| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| """ Tests for configuring Internal Load Balancing Rules. |
| """ |
| import logging |
| import math |
| import time |
| from nose.plugins.attrib import attr |
| |
| # Import Local Modules |
| from marvin.cloudstackTestCase import cloudstackTestCase |
| from marvin.codes import FAILED |
| from marvin.lib.base import ( |
| Account, |
| Configurations, |
| VPC, |
| VpcOffering, |
| ServiceOffering, |
| NetworkOffering, |
| Network, |
| PublicIPAddress, |
| NATRule, |
| ApplicationLoadBalancer, |
| VirtualMachine, |
| NetworkACLList |
| ) |
| from marvin.lib.common import ( |
| get_zone, |
| get_domain, |
| get_test_template, |
| list_network_offerings) |
| from marvin.sshClient import SshClient |
| |
| |
| class Services: |
| """Test VPC network services - Port Forwarding Rules Test Data Class. |
| """ |
| |
| def __init__(self): |
| self.services = { |
| "account": { |
| "email": "test@test.com", |
| "firstname": "Test", |
| "lastname": "User", |
| "username": "test", |
| # Random characters are appended for unique |
| # username |
| "password": "password", |
| }, |
| "host1": None, |
| "host2": None, |
| "compute_offering": { |
| "name": "Tiny Instance", |
| "displaytext": "Tiny Instance", |
| "cpunumber": 1, |
| "cpuspeed": 100, |
| "memory": 128, |
| }, |
| "network_offering": { |
| "name": 'VPC Network offering', |
| "displaytext": 'VPC Network', |
| "guestiptype": 'Isolated', |
| "supportedservices": 'Vpn,Dhcp,Dns,SourceNat,Lb,PortForwarding,UserData,StaticNat,NetworkACL', |
| "traffictype": 'GUEST', |
| "availability": 'Optional', |
| "useVpc": 'on', |
| "serviceProviderList": { |
| "Vpn": 'VpcVirtualRouter', |
| "Dhcp": 'VpcVirtualRouter', |
| "Dns": 'VpcVirtualRouter', |
| "SourceNat": 'VpcVirtualRouter', |
| "Lb": 'VpcVirtualRouter', |
| "PortForwarding": 'VpcVirtualRouter', |
| "UserData": 'VpcVirtualRouter', |
| "StaticNat": 'VpcVirtualRouter', |
| "NetworkACL": 'VpcVirtualRouter' |
| }, |
| }, |
| "network_offering_internal_lb": { |
| "name": 'VPC Network Internal Lb offering', |
| "displaytext": 'VPC Network internal lb', |
| "guestiptype": 'Isolated', |
| "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,UserData,StaticNat,NetworkACL,Lb', |
| "traffictype": 'GUEST', |
| "availability": 'Optional', |
| "useVpc": 'on', |
| "serviceCapabilityList": { |
| "Lb": { |
| "SupportedLbIsolation": 'dedicated', |
| "lbSchemes": 'internal' |
| } |
| }, |
| "serviceProviderList": { |
| "Dhcp": 'VpcVirtualRouter', |
| "Dns": 'VpcVirtualRouter', |
| "SourceNat": 'VpcVirtualRouter', |
| "PortForwarding": 'VpcVirtualRouter', |
| "UserData": 'VpcVirtualRouter', |
| "StaticNat": 'VpcVirtualRouter', |
| "NetworkACL": 'VpcVirtualRouter', |
| "Lb": 'InternalLbVm' |
| }, |
| "egress_policy": "true", |
| }, |
| "redundant_vpc_offering": { |
| "name": 'Redundant VPC off', |
| "displaytext": 'Redundant VPC off', |
| "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat', |
| "serviceProviderList": { |
| "Vpn": 'VpcVirtualRouter', |
| "Dhcp": 'VpcVirtualRouter', |
| "Dns": 'VpcVirtualRouter', |
| "SourceNat": 'VpcVirtualRouter', |
| "Lb": ["InternalLbVm", "VpcVirtualRouter"], |
| "PortForwarding": 'VpcVirtualRouter', |
| "UserData": 'VpcVirtualRouter', |
| "StaticNat": 'VpcVirtualRouter', |
| "NetworkACL": 'VpcVirtualRouter' |
| }, |
| "serviceCapabilityList": { |
| "SourceNat": { |
| "RedundantRouter": 'true' |
| }, |
| }, |
| }, |
| "vpc_offering": { |
| "name": "VPC off", |
| "displaytext": "VPC off", |
| "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat,NetworkACL", |
| "serviceProviderList": { |
| "Vpn": 'VpcVirtualRouter', |
| "Dhcp": 'VpcVirtualRouter', |
| "Dns": 'VpcVirtualRouter', |
| "SourceNat": 'VpcVirtualRouter', |
| "Lb": ["InternalLbVm", "VpcVirtualRouter"], |
| "PortForwarding": 'VpcVirtualRouter', |
| "UserData": 'VpcVirtualRouter', |
| "StaticNat": 'VpcVirtualRouter', |
| "NetworkACL": 'VpcVirtualRouter' |
| }, |
| }, |
| "vpc": { |
| "name": "TestVPC", |
| "displaytext": "TestVPC", |
| "cidr": '10.1.0.0/16' |
| }, |
| "network": { |
| "name": "Test Network", |
| "displaytext": "Test Network", |
| "netmask": '255.255.255.0' |
| }, |
| "lbrule": { |
| "name": "SSH", |
| "alg": "roundrobin", |
| # Algorithm used for load balancing |
| "privateport": 22, |
| "publicport": 2222, |
| "openfirewall": False, |
| "startport": 22, |
| "endport": 2222, |
| "protocol": "TCP", |
| "cidrlist": '0.0.0.0/0', |
| }, |
| "lbrule_http": { |
| "name": "HTTP", |
| "alg": "roundrobin", |
| # Algorithm used for load balancing |
| "privateport": 80, |
| "publicport": 80, |
| "openfirewall": False, |
| "startport": 80, |
| "endport": 80, |
| "protocol": "TCP", |
| "cidrlist": '0.0.0.0/0', |
| }, |
| "natrule": { |
| "protocol": "TCP", |
| "cidrlist": '0.0.0.0/0', |
| }, |
| "http_rule": { |
| "privateport": 80, |
| "publicport": 80, |
| "startport": 80, |
| "endport": 80, |
| "cidrlist": '0.0.0.0/0', |
| "protocol": "TCP" |
| }, |
| "virtual_machine": { |
| "displayname": "Test VM", |
| "username": "root", |
| "password": "password", |
| "ssh_port": 22, |
| "privateport": 22, |
| "publicport": 22, |
| "protocol": 'TCP', |
| } |
| } |
| |
| |
| class TestInternalLb(cloudstackTestCase): |
| """Test Internal LB |
| """ |
| |
| @classmethod |
| def setUpClass(cls): |
| |
| cls.logger = logging.getLogger('TestInternalLb') |
| cls.stream_handler = logging.StreamHandler() |
| cls.logger.setLevel(logging.DEBUG) |
| cls.logger.addHandler(cls.stream_handler) |
| |
| testClient = super(TestInternalLb, cls).getClsTestClient() |
| cls.apiclient = testClient.getApiClient() |
| cls.services = Services().services |
| |
| cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) |
| cls.domain = get_domain(cls.apiclient) |
| cls._cleanup = [] |
| |
| cls.logger.debug("Creating compute offering: %s" % cls.services["compute_offering"]["name"]) |
| cls.compute_offering = ServiceOffering.create( |
| cls.apiclient, |
| cls.services["compute_offering"] |
| ) |
| cls._cleanup.append(cls.compute_offering) |
| |
| cls.account = Account.create( |
| cls.apiclient, services=cls.services["account"]) |
| cls._cleanup.append(cls.account) |
| |
| cls.hypervisor = testClient.getHypervisorInfo() |
| |
| cls.template = get_test_template( |
| cls.apiclient, |
| cls.zone.id, |
| cls.hypervisor |
| ) |
| |
| if cls.template == FAILED: |
| assert False, "get_test_template() failed to return template" |
| |
| cls.logger.debug("Successfully created account: %s, id: \ |
| %s" % (cls.account.name, |
| cls.account.id)) |
| |
| return |
| |
| def setUp(self): |
| self.cleanup = [] |
| |
| def get_networkoffering_state(self, offering): |
| result = list_network_offerings(self.apiclient, id=offering.id) |
| if result: |
| offering = result[0] |
| return offering.state |
| else: |
| return None |
| |
| def create_and_enable_network_serviceoffering(self, services): |
| |
| try: |
| # Create offering |
| offering = NetworkOffering.create( |
| self.apiclient, services, conservemode=False) |
| |
| self.assertIsNotNone(offering, "Failed to create network offering") |
| self.logger.debug("Created network offering: %s" % offering.id) |
| |
| if offering: |
| # Enable offeringq |
| offering.update(self.apiclient, state="Enabled") |
| self.assertEqual(self.get_networkoffering_state( |
| offering), "Enabled", "Failed to enable network offering") |
| |
| self.logger.debug("Enabled network offering: %s" % offering.id) |
| |
| self.cleanup.insert(0, offering) |
| return offering |
| |
| except Exception as e: |
| self.fail("Failed to create and enable network offering due to %s" % e) |
| |
| def create_vpc(self, vpc_offering): |
| self.logger.debug("Creating VPC using offering ==> ID %s / Name %s" % (vpc_offering.id, vpc_offering.name)) |
| try: |
| vpc = VPC.create( |
| apiclient=self.apiclient, |
| services=self.services["vpc"], |
| networkDomain="vpc.internallb", |
| vpcofferingid=vpc_offering.id, |
| zoneid=self.zone.id, |
| account=self.account.name, |
| domainid=self.domain.id |
| ) |
| |
| self.assertIsNotNone(vpc, "VPC creation failed") |
| self.logger.debug("Created VPC %s" % vpc.id) |
| |
| self.cleanup.append(vpc) |
| return vpc |
| |
| except Exception as e: |
| self.fail("Failed to create VPC due to %s" % e) |
| |
| def create_network_tier(self, name, vpcid, gateway, network_offering): |
| self.services["network"]["name"] = name |
| self.services["network"]["displaytext"] = name |
| |
| default_acl = NetworkACLList.list(self.apiclient, name="default_allow")[0] |
| |
| try: |
| network = Network.create( |
| apiclient=self.apiclient, |
| services=self.services["network"], |
| accountid=self.account.name, |
| domainid=self.domain.id, |
| networkofferingid=network_offering.id, |
| zoneid=self.zone.id, |
| vpcid=vpcid, |
| gateway=gateway, |
| netmask=self.services["network"]["netmask"], |
| aclid=default_acl.id |
| ) |
| |
| self.assertIsNotNone(network, "Network failed to create") |
| self.logger.debug( |
| "Created network %s in VPC %s" % (network.id, vpcid)) |
| |
| self.cleanup.append(network) |
| return network |
| |
| except Exception as e: |
| raise Exception("Create network failed: %s" % e) |
| |
| def deployvm_in_network(self, vpc, networkid): |
| |
| try: |
| self.services["virtual_machine"]["networkids"] = networkid |
| vm = VirtualMachine.create(self.apiclient, services=self.services["virtual_machine"], |
| templateid=self.template.id, |
| zoneid=self.zone.id, |
| accountid=self.account.name, |
| domainid=self.domain.id, |
| serviceofferingid=self.compute_offering.id, |
| hypervisor=self.hypervisor |
| ) |
| self.assertIsNotNone( |
| vm, "Failed to deploy vm in network: %s" % networkid) |
| self.assertTrue(vm.state == 'Running', "VM is not running") |
| self.logger.debug("Deployed VM id: %s in VPC %s" % (vm.id, vpc.id)) |
| |
| self.cleanup.append(vm) |
| return vm |
| |
| except Exception as e: |
| raise Exception("Deployment failed of VM: %s" % e) |
| |
| def create_internal_loadbalancer(self, intport, sport, algorithm, networkid): |
| try: |
| # 5) Create an Internal Load Balancer |
| applb = ApplicationLoadBalancer.create(self.apiclient, services=self.services, |
| name="lbrule", |
| sourceport=sport, |
| instanceport=intport, |
| algorithm=algorithm, |
| scheme="Internal", |
| sourcenetworkid=networkid, |
| networkid=networkid |
| ) |
| self.assertIsNotNone(applb, "Failed to create loadbalancer") |
| self.cleanup.append(applb) |
| self.logger.debug("Created LB %s in VPC" % applb.id) |
| |
| return applb |
| |
| except Exception as e: |
| self.fail(e) |
| |
| def acquire_publicip(self, vpc, network): |
| self.logger.debug( |
| "Associating public IP for network: %s" % network.name) |
| public_ip = PublicIPAddress.create( |
| self.apiclient, |
| accountid=self.account.name, |
| zoneid=self.zone.id, |
| domainid=self.account.domainid, |
| networkid=network.id, |
| vpcid=vpc.id |
| ) |
| self.assertIsNotNone(public_ip, "Failed to acquire public IP") |
| self.cleanup.append(public_ip) |
| self.logger.debug("Associated %s with network %s" % ( |
| public_ip.ipaddress.ipaddress, |
| network.id |
| )) |
| return public_ip |
| |
| def create_natrule(self, vpc, vm, public_port, private_port, public_ip, network, services=None): |
| self.logger.debug("Creating NAT rule in network for vm with public IP") |
| if not services: |
| self.services["natrule"]["privateport"] = private_port |
| self.services["natrule"]["publicport"] = public_port |
| self.services["natrule"]["startport"] = public_port |
| self.services["natrule"]["endport"] = public_port |
| services = self.services["natrule"] |
| |
| nat_rule = NATRule.create( |
| apiclient=self.apiclient, |
| services=services, |
| ipaddressid=public_ip.ipaddress.id, |
| virtual_machine=vm, |
| networkid=network.id |
| ) |
| self.assertIsNotNone( |
| nat_rule, "Failed to create NAT Rule for %s" % public_ip.ipaddress.ipaddress) |
| self.cleanup.append(nat_rule) |
| self.logger.debug( |
| "Adding NetworkACL rules to make NAT rule accessible") |
| |
| vm.ssh_ip = nat_rule.ipaddress |
| vm.public_ip = nat_rule.ipaddress |
| vm.public_port = int(public_port) |
| return nat_rule |
| |
| def get_ssh_client(self, vm, retries): |
| """ Setup ssh client connection and return connection |
| vm requires attributes public_ip, public_port, username, password """ |
| |
| ssh_client = None |
| try: |
| ssh_client = SshClient( |
| vm.public_ip, |
| vm.public_port, |
| vm.username, |
| vm.password, |
| retries |
| ) |
| except Exception as e: |
| self.fail("Unable to create ssh connection: " % e) |
| |
| self.assertIsNotNone( |
| ssh_client, "Failed to setup ssh connection to vm=%s on public_ip=%s" % (vm.name, vm.public_ip)) |
| return ssh_client |
| |
| def setup_http_daemon(self, vm): |
| """ Creates a index.html in /tmp with private ip as content and |
| starts httpd daemon on all interfaces port 80 serving /tmp/ |
| (only tested on the busybox based tiny vm) |
| vm requires attributes public_ip, public_port, username, password |
| """ |
| commands = [ |
| # using ip address instead of hostname |
| "/sbin/ip addr show eth0 |grep 'inet '| cut -f6 -d' ' > /tmp/index.html", |
| "/usr/sbin/httpd -v -p 0.0.0.0:80 -h /tmp/" |
| ] |
| try: |
| ssh_client = self.get_ssh_client(vm, 8) |
| for cmd in commands: |
| ssh_client.execute(cmd) |
| except Exception as e: |
| self.fail("Failed to ssh into vm: %s due to %s" % (vm, e)) |
| |
| def run_ssh_test_accross_hosts(self, clienthost, lb_address, max_requests=30): |
| """ Uses clienthost to run wgets on hosts port 80 expects a unique output from url. |
| returns a list of outputs to evaluate. |
| """ |
| # Setup ssh connection |
| ssh_client = self.get_ssh_client(clienthost, 8) |
| self.logger.debug(ssh_client) |
| results = [] |
| |
| try: |
| for x in range(0, max_requests): |
| cmd_test_http = "curl --connect-timeout 3 -L http://" + \ |
| lb_address + "/ 2>/dev/null" |
| # self.debug( "SSH into VM public address: %s and port: %s" |
| # %(.public_ip, vm.public_port)) |
| results.append(ssh_client.execute(cmd_test_http)[0]) |
| self.logger.debug(results) |
| |
| except Exception as e: |
| self.fail("%s: SSH failed for VM with IP Address: %s" % |
| (e, clienthost.public_ip)) |
| |
| return results |
| |
| def get_std_deviation(self, data): |
| """ Calculates and outputs a mean, variance and standard deviation from an input list of values """ |
| num_val = len(data) |
| mean = sum(data) / num_val |
| sqrt = [math.pow(abs(x - mean), 2) for x in data] |
| variance = (sum(sqrt) / num_val - 1) |
| stddev = math.sqrt(variance) |
| return (mean, variance, stddev) |
| |
| def evaluate_http_responses(self, responses, algorithm): |
| """ Evaluates response values from http test and verifies algorithm used""" |
| if algorithm == 'roundrobin': |
| # get a list of unique values |
| unique_values = set(responses) |
| # count the occurence of each value in the responses |
| dataset = [responses.count(value) for value in unique_values] |
| |
| if len(set(dataset)) == 1: |
| # all values in dataset are equal, perfect result distribution |
| # woohoo! |
| self.logger.debug( |
| "HTTP responses are evenly distributed! SUCCESS!") |
| return True |
| else: |
| # calculate mean, var, stddev on dataset |
| mean, variance, stddev = self.get_std_deviation(dataset) |
| for value in dataset: |
| # determine how much value difference is there from the |
| # mean |
| difference = abs(value - mean) |
| # difference between response count of a host and the mean |
| # should be less than the standard deviation |
| self.assertLess( |
| difference, stddev, "Internal LB RoundRobin test Failed because http responsest are not evenly distributed") |
| self.logger.debug( |
| "Response distribution count: %d difference to mean: %d within standard deviation: %d" % (value, mean, stddev)) |
| return True |
| |
| @attr(tags=["smoke", "advanced"], required_hardware="true") |
| def test_01_internallb_roundrobin_1VPC_3VM_HTTP_port80(self): |
| """ |
| Test create, assign, remove of an Internal LB with roundrobin http traffic to 3 vm's in a Single VPC |
| """ |
| self.logger.debug("Starting test_01_internallb_roundrobin_1VPC_3VM_HTTP_port80") |
| |
| self.logger.debug("Creating a VPC offering..") |
| vpc_offering = VpcOffering.create( |
| self.apiclient, |
| self.services["vpc_offering"]) |
| self.cleanup.append(vpc_offering) |
| |
| self.logger.debug("Enabling the VPC offering created") |
| vpc_offering.update(self.apiclient, state='Enabled') |
| |
| self.execute_internallb_roundrobin_tests(vpc_offering) |
| |
| @attr(tags=["smoke", "advanced"], required_hardware="true") |
| def test_02_internallb_roundrobin_1RVPC_3VM_HTTP_port80(self): |
| """ |
| Test create, assign, remove of an Internal LB with roundrobin http traffic to 3 vm's in a Redundant VPC |
| """ |
| self.logger.debug("Starting test_02_internallb_roundrobin_1RVPC_3VM_HTTP_port80") |
| |
| self.logger.debug("Creating a Redundant VPC offering..") |
| redundant_vpc_offering = VpcOffering.create( |
| self.apiclient, |
| self.services["redundant_vpc_offering"]) |
| self.cleanup.append(redundant_vpc_offering) |
| |
| self.logger.debug("Enabling the Redundant VPC offering created") |
| redundant_vpc_offering.update(self.apiclient, state='Enabled') |
| |
| self.execute_internallb_roundrobin_tests(redundant_vpc_offering) |
| |
| def execute_internallb_roundrobin_tests(self, vpc_offering): |
| max_http_requests = 30 |
| algorithm = "roundrobin" |
| public_lb_port = 80 |
| private_http_port = 80 |
| public_ssh_start_port = 2000 |
| num_app_vms = 3 |
| |
| self.logger.debug("Starting test_01_internallb_roundrobin_1VPC_3VM_HTTP_port80") |
| # Create and enable network offerings |
| network_offering_guestnet = self.create_and_enable_network_serviceoffering( |
| self.services["network_offering"]) |
| network_offering_intlb = self.create_and_enable_network_serviceoffering( |
| self.services["network_offering_internal_lb"]) |
| |
| # Create VPC |
| vpc = self.create_vpc(vpc_offering) |
| |
| # Create network tiers |
| network_guestnet = self.create_network_tier( |
| "guestnet_test01", vpc.id, "10.1.1.1", network_offering_guestnet) |
| network_internal_lb = self.create_network_tier( |
| "intlb_test01", vpc.id, "10.1.2.1", network_offering_intlb) |
| |
| # Create 1 lb client vm in guestnet network tier |
| client_vm = self.deployvm_in_network(vpc, network_guestnet.id) |
| |
| # Create X app vm's in internal lb network tier |
| app_vms = [] |
| for x in range(0, num_app_vms): |
| vm = None |
| vm = self.deployvm_in_network(vpc, network_internal_lb.id) |
| app_vms.append(vm) |
| |
| # Acquire public ip to access guestnet app vms |
| guestnet_public_ip = self.acquire_publicip(vpc, network_guestnet) |
| intlb_public_ip = self.acquire_publicip(vpc, network_internal_lb) |
| |
| # Create nat rule to access client vm |
| self.create_natrule(vpc, client_vm, public_ssh_start_port, 22, guestnet_public_ip, network_guestnet) |
| |
| # Create nat rule to access app vms directly and start a http daemon on |
| # the vm |
| public_port = public_ssh_start_port + 1 |
| for vm in app_vms: |
| self.create_natrule(vpc, vm, public_port, 22, intlb_public_ip, network_internal_lb) |
| public_port += 1 |
| time.sleep(10) |
| # start http daemon on vm's |
| self.setup_http_daemon(vm) |
| |
| # Create a internal loadbalancer in the internal lb network tier |
| applb = self.create_internal_loadbalancer(private_http_port, public_lb_port, algorithm, network_internal_lb.id) |
| # wait for the loadbalancer to boot and be configured |
| time.sleep(10) |
| # Assign the 2 VMs to the Internal Load Balancer |
| self.logger.debug("Assigning virtual machines to LB: %s" % applb.id) |
| try: |
| applb.assign(self.apiclient, vms=app_vms) |
| except Exception as e: |
| self.fail( |
| "Failed to assign virtual machine(s) to loadbalancer: %s" % e) |
| |
| time.sleep(120) |
| # self.logger.debug(dir(applb)) |
| results = self.run_ssh_test_accross_hosts( |
| client_vm, applb.sourceipaddress, max_http_requests) |
| success = self.evaluate_http_responses(results, algorithm) |
| self.assertTrue(success, "Test failed on algorithm: %s" % algorithm) |
| |
| self.logger.debug( |
| "Removing virtual machines and networks for test_01_internallb_roundrobin_2VM_port80") |
| |
| # Remove the virtual machines from the Internal LoadBalancer |
| self.logger.debug("Remove virtual machines from LB: %s" % applb.id) |
| applb.remove(self.apiclient, vms=app_vms) |
| |
| def get_lb_stats_settings(self): |
| self.logger.debug("Retrieving haproxy stats settings") |
| settings = {} |
| try: |
| settings["stats_port"] = Configurations.list( |
| self.apiclient, name="network.loadbalancer.haproxy.stats.port")[0].value |
| settings["stats_uri"] = Configurations.list( |
| self.apiclient, name="network.loadbalancer.haproxy.stats.uri")[0].value |
| # Update global setting network.loadbalancer.haproxy.stats.auth to a known value |
| haproxy_auth = "admin:password" |
| Configurations.update(self.apiclient, "network.loadbalancer.haproxy.stats.auth", haproxy_auth) |
| self.logger.debug( |
| "Updated global setting stats network.loadbalancer.haproxy.stats.auth to %s" % (haproxy_auth)) |
| settings["username"], settings["password"] = haproxy_auth.split(":") |
| settings["visibility"] = Configurations.list( |
| self.apiclient, name="network.loadbalancer.haproxy.stats.visibility")[0].value |
| self.logger.debug(settings) |
| except Exception as e: |
| self.fail("Failed to retrieve stats settings " % e) |
| |
| return settings |
| |
| def verify_lb_stats(self, stats_ip, ssh_client, settings): |
| |
| word_to_verify = "uptime" |
| |
| url = "http://" + stats_ip + ":" + \ |
| settings["stats_port"] + settings["stats_uri"] |
| get_contents = "curl --connect-timeout 3 -L --user %s:%s %s" \ |
| % (settings["username"], settings["password"], url) |
| try: |
| self.logger.debug( |
| "Trying to connect to the haproxy stats url %s" % url) |
| result = ssh_client.execute(get_contents) |
| except Exception as e: |
| self.fail("Failed to verify admin stats url %s from: %s" % |
| (url, ssh_client)) |
| finally: |
| del ssh_client |
| |
| found = any(word_to_verify in word for word in result) |
| |
| if found: |
| return True |
| else: |
| return False |
| |
| @attr(tags=["smoke", "advanced"], required_hardware="true") |
| def test_03_vpc_internallb_haproxy_stats_on_all_interfaces(self): |
| """ Test to verify access to loadbalancer haproxy admin stats page |
| when global setting network.loadbalancer.haproxy.stats.visibility is set to 'all' |
| with credentials from global setting network.loadbalancer.haproxy.stats.auth |
| using the uri from global setting network.loadbalancer.haproxy.stats.uri. |
| |
| It uses a Single Router VPC |
| """ |
| self.logger.debug("Starting test_03_vpc_internallb_haproxy_stats_on_all_interfaces") |
| |
| self.logger.debug("Creating a VPC offering..") |
| vpc_offering = VpcOffering.create( |
| self.apiclient, |
| self.services["vpc_offering"]) |
| self.cleanup.append(vpc_offering) |
| |
| self.logger.debug("Enabling the VPC offering created") |
| vpc_offering.update(self.apiclient, state='Enabled') |
| |
| self.execute_internallb_haproxy_tests(vpc_offering) |
| |
| @attr(tags=["smoke", "advanced"], required_hardware="true") |
| def test_04_rvpc_internallb_haproxy_stats_on_all_interfaces(self): |
| """ Test to verify access to loadbalancer haproxy admin stats page |
| when global setting network.loadbalancer.haproxy.stats.visibility is set to 'all' |
| with credentials from global setting network.loadbalancer.haproxy.stats.auth |
| using the uri from global setting network.loadbalancer.haproxy.stats.uri. |
| |
| It uses a Redundant Routers VPC |
| """ |
| self.logger.debug("Starting test_04_rvpc_internallb_haproxy_stats_on_all_interfaces") |
| |
| self.logger.debug("Creating a Redundant VPC offering..") |
| redundant_vpc_offering = VpcOffering.create( |
| self.apiclient, |
| self.services["redundant_vpc_offering"]) |
| self.cleanup.append(redundant_vpc_offering) |
| |
| self.logger.debug("Enabling the Redundant VPC offering created") |
| redundant_vpc_offering.update(self.apiclient, state='Enabled') |
| |
| self.execute_internallb_haproxy_tests(redundant_vpc_offering) |
| |
| def execute_internallb_haproxy_tests(self, vpc_offering): |
| |
| settings = self.get_lb_stats_settings() |
| |
| dummy_port = 90 |
| network_gw = "10.1.2.1" |
| default_visibility = "global" |
| |
| # Update global setting if it is not set to our test default |
| if settings["visibility"] != default_visibility: |
| config_update = Configurations.update( |
| self.apiclient, "network.loadbalancer.haproxy.stats.visibility", default_visibility) |
| self.logger.debug( |
| "Updated global setting stats haproxy.stats.visibility to %s" % (default_visibility)) |
| settings = self.get_lb_stats_settings() |
| |
| # Create and enable network offering |
| network_offering_intlb = self.create_and_enable_network_serviceoffering( |
| self.services["network_offering_internal_lb"]) |
| |
| # Create VPC |
| vpc = self.create_vpc(vpc_offering) |
| |
| # Create network tier with internal lb service enabled |
| network_internal_lb = self.create_network_tier( |
| "intlb_test02", vpc.id, network_gw, network_offering_intlb) |
| |
| # Create 1 lb vm in internal lb network tier |
| vm = self.deployvm_in_network(vpc, network_internal_lb.id) |
| |
| # Acquire 1 public ip and attach to the internal lb network tier |
| public_ip = self.acquire_publicip(vpc, network_internal_lb) |
| |
| # Create an internal loadbalancer in the internal lb network tier |
| applb = self.create_internal_loadbalancer( |
| dummy_port, dummy_port, "leastconn", network_internal_lb.id) |
| |
| # Assign the 1 VM to the Internal Load Balancer |
| self.logger.debug("Assigning virtual machines to LB: %s" % applb.id) |
| try: |
| applb.assign(self.apiclient, vms=[vm]) |
| except Exception as e: |
| self.fail( |
| "Failed to assign virtual machine(s) to loadbalancer: %s" % e) |
| |
| # Create nat rule to access client vm |
| self.create_natrule( |
| vpc, vm, "22", "22", public_ip, network_internal_lb) |
| |
| # Verify access to and the contents of the admin stats page on the |
| # private address via a vm in the internal lb tier |
| stats = self.verify_lb_stats( |
| applb.sourceipaddress, self.get_ssh_client(vm, 5), settings) |
| self.assertTrue(stats, "Failed to verify LB HAProxy stats") |
| |
| @classmethod |
| def tearDownClass(cls): |
| super(TestInternalLb, cls).tearDownClass() |
| |
| def tearDown(self): |
| super(TestInternalLb, self).tearDown() |
