| # Copyright 2014 Mirantis.inc |
| # All Rights Reserved. |
| # |
| # Licensed 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. |
| |
| import time |
| import urllib |
| |
| from tempest.api.network import common as net_common |
| from tempest import config |
| from tempest import exceptions |
| from tempest.scenario import manager |
| from tempest import test |
| |
| config = config.CONF |
| |
| |
| class TestLoadBalancerBasic(manager.NetworkScenarioTest): |
| |
| """ |
| This test checks basic load balancing. |
| |
| The following is the scenario outline: |
| 1. Create an instance |
| 2. SSH to the instance and start two servers |
| 3. Create a load balancer with two members and with ROUND_ROBIN algorithm |
| associate the VIP with a floating ip |
| 4. Send 10 requests to the floating ip and check that they are shared |
| between the two servers and that both of them get equal portions |
| of the requests |
| """ |
| |
| @classmethod |
| def check_preconditions(cls): |
| super(TestLoadBalancerBasic, cls).check_preconditions() |
| cfg = config.network |
| if not test.is_extension_enabled('lbaas', 'network'): |
| msg = 'LBaaS Extension is not enabled' |
| cls.enabled = False |
| raise cls.skipException(msg) |
| if not (cfg.tenant_networks_reachable or cfg.public_network_id): |
| msg = ('Either tenant_networks_reachable must be "true", or ' |
| 'public_network_id must be defined.') |
| cls.enabled = False |
| raise cls.skipException(msg) |
| |
| @classmethod |
| def setUpClass(cls): |
| super(TestLoadBalancerBasic, cls).setUpClass() |
| cls.check_preconditions() |
| cls.servers_keypairs = {} |
| cls.members = [] |
| cls.floating_ips = {} |
| cls.server_ips = {} |
| cls.port1 = 80 |
| cls.port2 = 88 |
| |
| def setUp(self): |
| super(TestLoadBalancerBasic, self).setUp() |
| self.server_ips = {} |
| self._create_security_group() |
| |
| def cleanup_wrapper(self, resource): |
| self.cleanup_resource(resource, self.__class__.__name__) |
| |
| def _create_security_group(self): |
| self.security_group = self._create_security_group_neutron( |
| tenant_id=self.tenant_id) |
| self._create_security_group_rules_for_port(self.port1) |
| self._create_security_group_rules_for_port(self.port2) |
| self.addCleanup(self.cleanup_wrapper, self.security_group) |
| |
| def _create_security_group_rules_for_port(self, port): |
| rule = { |
| 'direction': 'ingress', |
| 'protocol': 'tcp', |
| 'port_range_min': port, |
| 'port_range_max': port, |
| } |
| self._create_security_group_rule( |
| client=self.network_client, |
| secgroup=self.security_group, |
| tenant_id=self.tenant_id, |
| **rule) |
| |
| def _create_server(self, name): |
| keypair = self.create_keypair(name='keypair-%s' % name) |
| self.addCleanup(self.cleanup_wrapper, keypair) |
| security_groups = [self.security_group.name] |
| net = self._list_networks(tenant_id=self.tenant_id)[0] |
| create_kwargs = { |
| 'nics': [ |
| {'net-id': net['id']}, |
| ], |
| 'key_name': keypair.name, |
| 'security_groups': security_groups, |
| } |
| server = self.create_server(name=name, |
| create_kwargs=create_kwargs) |
| self.addCleanup(self.cleanup_wrapper, server) |
| self.servers_keypairs[server.id] = keypair |
| if (config.network.public_network_id and not |
| config.network.tenant_networks_reachable): |
| public_network_id = config.network.public_network_id |
| floating_ip = self._create_floating_ip( |
| server, public_network_id) |
| self.addCleanup(self.cleanup_wrapper, floating_ip) |
| self.floating_ips[floating_ip] = server |
| self.server_ips[server.id] = floating_ip.floating_ip_address |
| else: |
| self.server_ips[server.id] = server.networks[net.name][0] |
| self.assertTrue(self.servers_keypairs) |
| return server |
| |
| def _create_servers(self): |
| for count in range(2): |
| self._create_server(name=("server%s" % (count + 1))) |
| self.assertEqual(len(self.servers_keypairs), 2) |
| |
| def _start_servers(self): |
| """ |
| Start two backends |
| |
| 1. SSH to the instance |
| 2. Start two http backends listening on ports 80 and 88 respectively |
| In case there are two instances, each backend is created on a separate |
| instance. |
| |
| The backends are the inetd services. To start them we need to edit |
| /etc/inetd.conf in the following way: |
| www stream tcp nowait root /bin/sh sh /home/cirros/script_name |
| |
| Where /home/cirros/script_name is a path to a script which |
| echoes the responses: |
| echo -e 'HTTP/1.0 200 OK\r\n\r\nserver_name |
| |
| If we want the server to listen on port 88, then we use |
| "kerberos" instead of "www". |
| """ |
| |
| for server_id, ip in self.server_ips.iteritems(): |
| private_key = self.servers_keypairs[server_id].private_key |
| server_name = self.compute_client.servers.get(server_id).name |
| ssh_client = self.get_remote_client( |
| server_or_ip=ip, |
| private_key=private_key) |
| ssh_client.validate_authentication() |
| # Create service for inetd |
| create_script = """sudo sh -c "echo -e \\"echo -e 'HTTP/1.0 """ \ |
| """200 OK\\\\\\r\\\\\\n\\\\\\r\\\\\\n""" \ |
| """%(server)s'\\" >>/home/cirros/%(script)s\"""" |
| |
| cmd = create_script % { |
| 'server': server_name, |
| 'script': 'script1'} |
| ssh_client.exec_command(cmd) |
| # Configure inetd |
| configure_inetd = """sudo sh -c "echo -e \\"%(service)s """ \ |
| """stream tcp nowait root /bin/sh sh """ \ |
| """/home/cirros/%(script)s\\" >> """ \ |
| """/etc/inetd.conf\"""" |
| # "www" stands for port 80 |
| cmd = configure_inetd % {'service': 'www', |
| 'script': 'script1'} |
| ssh_client.exec_command(cmd) |
| |
| if len(self.server_ips) == 1: |
| cmd = create_script % {'server': 'server2', |
| 'script': 'script2'} |
| ssh_client.exec_command(cmd) |
| # "kerberos" stands for port 88 |
| cmd = configure_inetd % {'service': 'kerberos', |
| 'script': 'script2'} |
| ssh_client.exec_command(cmd) |
| |
| # Get PIDs of inetd |
| pids = ssh_client.get_pids('inetd') |
| if pids != ['']: |
| # If there are any inetd processes, reload them |
| kill_cmd = "sudo kill -HUP %s" % ' '.join(pids) |
| ssh_client.exec_command(kill_cmd) |
| else: |
| # In other case start inetd |
| start_inetd = "sudo /usr/sbin/inetd /etc/inetd.conf" |
| ssh_client.exec_command(start_inetd) |
| |
| def _check_connection(self, check_ip, port=80): |
| def try_connect(ip, port): |
| try: |
| resp = urllib.urlopen("http://{0}:{1}/".format(ip, port)) |
| if resp.getcode() == 200: |
| return True |
| return False |
| except IOError: |
| return False |
| timeout = config.compute.ping_timeout |
| start = time.time() |
| while not try_connect(check_ip, port): |
| if (time.time() - start) > timeout: |
| message = "Timed out trying to connect to %s" % check_ip |
| raise exceptions.TimeoutException(message) |
| |
| def _create_pool(self): |
| """Create a pool with ROUND_ROBIN algorithm.""" |
| # get tenant subnet and verify there's only one |
| subnet = self._list_subnets(tenant_id=self.tenant_id)[0] |
| self.subnet = net_common.DeletableSubnet(client=self.network_client, |
| **subnet) |
| self.pool = super(TestLoadBalancerBasic, self)._create_pool( |
| lb_method='ROUND_ROBIN', |
| protocol='HTTP', |
| subnet_id=self.subnet.id) |
| self.addCleanup(self.cleanup_wrapper, self.pool) |
| self.assertTrue(self.pool) |
| |
| def _create_members(self): |
| """ |
| Create two members. |
| |
| In case there is only one server, create both members with the same ip |
| but with different ports to listen on. |
| """ |
| |
| for server_id, ip in self.server_ips.iteritems(): |
| if len(self.server_ips) == 1: |
| member1 = self._create_member(address=ip, |
| protocol_port=self.port1, |
| pool_id=self.pool.id) |
| self.addCleanup(self.cleanup_wrapper, member1) |
| member2 = self._create_member(address=ip, |
| protocol_port=self.port2, |
| pool_id=self.pool.id) |
| self.addCleanup(self.cleanup_wrapper, member2) |
| self.members.extend([member1, member2]) |
| else: |
| member = self._create_member(address=ip, |
| protocol_port=self.port1, |
| pool_id=self.pool.id) |
| self.addCleanup(self.cleanup_wrapper, member) |
| self.members.append(member) |
| self.assertTrue(self.members) |
| |
| def _assign_floating_ip_to_vip(self, vip): |
| public_network_id = config.network.public_network_id |
| port_id = vip.port_id |
| floating_ip = self._create_floating_ip(vip, public_network_id, |
| port_id=port_id) |
| self.addCleanup(self.cleanup_wrapper, floating_ip) |
| self.floating_ips.setdefault(vip.id, []) |
| self.floating_ips[vip.id].append(floating_ip) |
| |
| def _create_load_balancer(self): |
| self._create_pool() |
| self._create_members() |
| self.vip = self._create_vip(protocol='HTTP', |
| protocol_port=80, |
| subnet_id=self.subnet.id, |
| pool_id=self.pool.id) |
| self.addCleanup(self.cleanup_wrapper, self.vip) |
| self.status_timeout(NeutronRetriever(self.network_client, |
| self.network_client.vip_path, |
| net_common.DeletableVip), |
| self.vip.id, |
| expected_status='ACTIVE') |
| if (config.network.public_network_id and not |
| config.network.tenant_networks_reachable): |
| self._assign_floating_ip_to_vip(self.vip) |
| self.vip_ip = self.floating_ips[ |
| self.vip.id][0]['floating_ip_address'] |
| else: |
| self.vip_ip = self.vip.address |
| |
| def _check_load_balancing(self): |
| """ |
| 1. Send 100 requests on the floating ip associated with the VIP |
| 2. Check that the requests are shared between |
| the two servers and that both of them get equal portions |
| of the requests |
| """ |
| |
| self._check_connection(self.vip_ip) |
| resp = self._send_requests(self.vip_ip) |
| self.assertEqual(set(["server1\n", "server2\n"]), set(resp)) |
| self.assertEqual(50, resp.count("server1\n")) |
| self.assertEqual(50, resp.count("server2\n")) |
| |
| def _send_requests(self, vip_ip): |
| resp = [] |
| for count in range(100): |
| resp.append( |
| urllib.urlopen( |
| "http://{0}/".format(vip_ip)).read()) |
| return resp |
| |
| @test.attr(type='smoke') |
| @test.services('compute', 'network') |
| def test_load_balancer_basic(self): |
| self._create_server('server1') |
| self._start_servers() |
| self._create_load_balancer() |
| self._check_load_balancing() |
| |
| |
| class NeutronRetriever(object): |
| """ |
| Helper class to make possible handling neutron objects returned by GET |
| requests as attribute dicts. |
| |
| Whet get() method is called, the returned dictionary is wrapped into |
| a corresponding DeletableResource class which provides attribute access |
| to dictionary values. |
| |
| Usage: |
| This retriever is used to allow using status_timeout from |
| tempest.manager with Neutron objects. |
| """ |
| |
| def __init__(self, network_client, path, resource): |
| self.network_client = network_client |
| self.path = path |
| self.resource = resource |
| |
| def get(self, thing_id): |
| obj = self.network_client.get(self.path % thing_id) |
| return self.resource(client=self.network_client, **obj.values()[0]) |