def test_load_balancer_show_stats(self): """Tests load balancer show statistics API. * Create a load balancer. * Validates that other accounts cannot see the stats for the * load balancer. * Show load balancer statistics. * Validate the show reflects the expected values. """ lb_name = data_utils.rand_name("lb_member_lb1-show_stats") lb = self.mem_lb_client.create_loadbalancer( name=lb_name, provider=CONF.load_balancer.provider, vip_network_id=self.lb_member_vip_net[const.ID]) self.addClassResourceCleanup(self.mem_lb_client.cleanup_loadbalancer, lb[const.ID]) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) # Test that a user, without the load balancer member role, cannot # use this command if CONF.load_balancer.RBAC_test_type == const.ADVANCED: self.assertRaises( exceptions.Forbidden, self.os_primary.loadbalancer_client.get_loadbalancer_stats, lb[const.ID]) # Test that a different user, with the load balancer role, cannot see # the load balancer stats if not CONF.load_balancer.RBAC_test_type == const.NONE: member2_client = self.os_roles_lb_member2.loadbalancer_client self.assertRaises(exceptions.Forbidden, member2_client.get_loadbalancer_stats, lb[const.ID]) stats = self.mem_lb_client.get_loadbalancer_stats(lb[const.ID]) self.assertEqual(5, len(stats)) self.assertEqual(0, stats[const.ACTIVE_CONNECTIONS]) self.assertEqual(0, stats[const.BYTES_IN]) self.assertEqual(0, stats[const.BYTES_OUT]) self.assertEqual(0, stats[const.REQUEST_ERRORS]) self.assertEqual(0, stats[const.TOTAL_CONNECTIONS]) # Attempt to clean up so that one full test run doesn't start 10+ # amps before the cleanup phase fires try: self.mem_lb_client.delete_loadbalancer(lb[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) except Exception: pass
def test_pool_delete(self): """Tests pool create and delete APIs. * Creates a pool. * Validates that other accounts cannot delete the pool * Deletes the pool. * Validates the pool is in the DELETED state. """ pool_name = data_utils.rand_name("lb_member_pool1-delete") pool_sp_cookie_name = 'my_cookie' pool_kwargs = { const.NAME: pool_name, const.PROTOCOL: self.protocol, const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN, const.LOADBALANCER_ID: self.lb_id, } if self.lb_feature_enabled.session_persistence_enabled: pool_kwargs[const.SESSION_PERSISTENCE] = { const.TYPE: const.SESSION_PERSISTENCE_APP_COOKIE, const.COOKIE_NAME: pool_sp_cookie_name, } pool = self.mem_pool_client.create_pool(**pool_kwargs) self.addClassResourceCleanup(self.mem_pool_client.cleanup_pool, pool[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) # Test that a user without the load balancer role cannot # delete this pool if CONF.load_balancer.RBAC_test_type == const.ADVANCED: self.assertRaises(exceptions.Forbidden, self.os_primary.pool_client.delete_pool, pool[const.ID]) # Test that a different user, with the load balancer member role # cannot delete this pool if not CONF.load_balancer.RBAC_test_type == const.NONE: member2_client = self.os_roles_lb_member2.pool_client self.assertRaises(exceptions.Forbidden, member2_client.delete_pool, pool[const.ID]) self.mem_pool_client.delete_pool(pool[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_pool_client.show_pool, pool[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout)
def test_listener_delete(self): """Tests listener create and delete APIs. * Creates a listener. * Validates that other accounts cannot delete the listener * Deletes the listener. * Validates the listener is in the DELETED state. """ listener_name = data_utils.rand_name("lb_member_listener1-delete") listener_kwargs = { const.NAME: listener_name, const.PROTOCOL: self.protocol, const.PROTOCOL_PORT: 83, const.LOADBALANCER_ID: self.lb_id, } listener = self.mem_listener_client.create_listener(**listener_kwargs) self.addClassResourceCleanup(self.mem_listener_client.cleanup_listener, listener[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) # Test that a user without the load balancer role cannot # delete this listener if CONF.load_balancer.RBAC_test_type == const.ADVANCED: self.assertRaises(exceptions.Forbidden, self.os_primary.listener_client.delete_listener, listener[const.ID]) # Test that a different user, with the load balancer member role # cannot delete this listener if not CONF.load_balancer.RBAC_test_type == const.NONE: member2_client = self.os_roles_lb_member2.listener_client self.assertRaises(exceptions.Forbidden, member2_client.delete_listener, listener[const.ID]) self.mem_listener_client.delete_listener(listener[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_listener_client.show_listener, listener[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout)
def test_load_balancer_failover(self): """Tests load balancer failover API. * Create a load balancer. * Validates that other accounts cannot failover the load balancer * Wait for the load balancer to go ACTIVE. * Failover the load balancer. * Wait for the load balancer to go ACTIVE. """ lb_name = data_utils.rand_name("lb_member_lb1-failover") lb = self.mem_lb_client.create_loadbalancer( name=lb_name, vip_network_id=self.lb_member_vip_net[const.ID]) self.addClassResourceCleanup(self.mem_lb_client.cleanup_loadbalancer, lb[const.ID]) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) # Test RBAC not authorized for non-admin role if not CONF.load_balancer.RBAC_test_type == const.NONE: self.assertRaises(exceptions.Forbidden, self.mem_lb_client.failover_loadbalancer, lb[const.ID]) # Assert we didn't go into PENDING_* lb = self.mem_lb_client.show_loadbalancer(lb[const.ID]) self.assertEqual(const.ACTIVE, lb[const.PROVISIONING_STATUS]) self.os_roles_lb_admin.loadbalancer_client.failover_loadbalancer( lb[const.ID]) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) # TODO(johnsom) Assert the amphora ID has changed when amp client # is available. # Attempt to clean up so that one full test run doesn't start 10+ # amps before the cleanup phase fires try: self.mem_lb_client.delete_loadbalancer(lb[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) except Exception: pass
def test_l7policy_delete(self): """Tests l7policy create and delete APIs. * Creates a l7policy. * Validates that other accounts cannot delete the l7policy * Deletes the l7policy. * Validates the l7policy is in the DELETED state. """ l7policy_name = data_utils.rand_name("lb_member_l7policy1-delete") l7policy_kwargs = { const.LISTENER_ID: self.listener_id, const.NAME: l7policy_name, const.ACTION: const.REJECT, } l7policy = self.mem_l7policy_client.create_l7policy(**l7policy_kwargs) self.addClassResourceCleanup(self.mem_l7policy_client.cleanup_l7policy, l7policy[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) # Test that a user without the load balancer role cannot # delete this l7policy if CONF.load_balancer.RBAC_test_type == const.ADVANCED: self.assertRaises(exceptions.Forbidden, self.os_primary.l7policy_client.delete_l7policy, l7policy[const.ID]) # Test that a different user, with the load balancer member role # cannot delete this l7policy if not CONF.load_balancer.RBAC_test_type == const.NONE: member2_client = self.os_roles_lb_member2.l7policy_client self.assertRaises(exceptions.Forbidden, member2_client.delete_l7policy, l7policy[const.ID]) self.mem_l7policy_client.delete_l7policy(l7policy[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_l7policy_client.show_l7policy, l7policy[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout)
def test_load_balancer_delete_cascade(self): """Tests load balancer create and cascade delete APIs. * Creates a load balancer. * Validates that other accounts cannot delete the load balancer * Deletes the load balancer with the cascade parameter. * Validates the load balancer is in the DELETED state. """ lb_name = data_utils.rand_name("lb_member_lb1-cascade_delete") lb = self.mem_lb_client.create_loadbalancer( name=lb_name, provider=CONF.load_balancer.provider, vip_network_id=self.lb_member_vip_net[const.ID]) self.addClassResourceCleanup(self.mem_lb_client.cleanup_loadbalancer, lb[const.ID]) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) # TODO(johnsom) Add other objects when we have clients for them # Test that a user without the load balancer role cannot # delete this load balancer if CONF.load_balancer.RBAC_test_type == const.ADVANCED: self.assertRaises( exceptions.Forbidden, self.os_primary.loadbalancer_client.delete_loadbalancer, lb[const.ID], cascade=True) # Test that a different user, with the load balancer member role # cannot delete this load balancer if not CONF.load_balancer.RBAC_test_type == const.NONE: member2_client = self.os_roles_lb_member2.loadbalancer_client self.assertRaises(exceptions.Forbidden, member2_client.delete_loadbalancer, lb[const.ID], cascade=True) self.mem_lb_client.delete_loadbalancer(lb[const.ID], cascade=True) waiters.wait_for_deleted_status_or_not_found( self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout)
def test_l7rule_CRUD(self): """Tests l7rule create, read, update, delete * Create a fully populated l7rule. * Show l7rule details. * Update the l7rule. * Delete the l7rule. """ # L7Rule create l7rule_kwargs = { const.ADMIN_STATE_UP: False, const.L7POLICY_ID: self.l7policy_id, const.TYPE: const.HEADER, const.VALUE: 'myvalue-create', const.COMPARE_TYPE: const.EQUAL_TO, const.KEY: 'mykey-create', const.INVERT: False, } l7rule = self.mem_l7rule_client.create_l7rule(**l7rule_kwargs) self.addCleanup(self.mem_l7rule_client.cleanup_l7rule, l7rule[const.ID], l7policy_id=self.l7policy_id, lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) l7rule = waiters.wait_for_status(self.mem_l7rule_client.show_l7rule, l7rule[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, l7policy_id=self.l7policy_id) parser.parse(l7rule[const.CREATED_AT]) parser.parse(l7rule[const.UPDATED_AT]) UUID(l7rule[const.ID]) # Operating status will be OFFLINE while admin_state_up = False self.assertEqual(const.OFFLINE, l7rule[const.OPERATING_STATUS]) equal_items = [ const.ADMIN_STATE_UP, const.TYPE, const.VALUE, const.COMPARE_TYPE, const.KEY, const.INVERT ] for item in equal_items: self.assertEqual(l7rule_kwargs[item], l7rule[item]) # L7Rule update l7rule_update_kwargs = { const.L7POLICY_ID: self.l7policy_id, const.ADMIN_STATE_UP: True, const.TYPE: const.COOKIE, const.VALUE: 'myvalue-UPDATED', const.COMPARE_TYPE: const.CONTAINS, const.KEY: 'mykey-UPDATED', const.INVERT: True, } l7rule = self.mem_l7rule_client.update_l7rule(l7rule[const.ID], **l7rule_update_kwargs) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) l7rule = waiters.wait_for_status(self.mem_l7rule_client.show_l7rule, l7rule[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, l7policy_id=self.l7policy_id) # Operating status for a l7rule will be ONLINE if it is enabled: self.assertEqual(const.ONLINE, l7rule[const.OPERATING_STATUS]) # Test changed items (which is all of them, for l7rules) equal_items = [ const.ADMIN_STATE_UP, const.TYPE, const.VALUE, const.COMPARE_TYPE, const.KEY, const.INVERT ] for item in equal_items: self.assertEqual(l7rule_update_kwargs[item], l7rule[item]) # L7Rule delete waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) self.mem_l7rule_client.delete_l7rule(l7rule[const.ID], l7policy_id=self.l7policy_id) waiters.wait_for_deleted_status_or_not_found( self.mem_l7rule_client.show_l7rule, l7rule[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout, l7policy_id=self.l7policy_id)
def _test_healthmonitor_traffic(self, protocol, protocol_port): """Tests traffic is correctly routed based on healthmonitor status * Create three members: * One should be working, and ONLINE with a healthmonitor (passing) * One should be working, and ERROR with a healthmonitor (failing) * One should be disabled, and OFFLINE with a healthmonitor * Verify members are in their correct respective operating statuses. * Verify that traffic is balanced evenly between the working members. * Create a fully populated healthmonitor. * Verify members are in their correct respective operating statuses. * Verify that traffic is balanced *unevenly*. * Delete the healthmonitor. * Verify members are in their correct respective operating statuses. * Verify that traffic is balanced evenly between the working members. """ member1_name = data_utils.rand_name("lb_member_member1-hm-traffic") member1_kwargs = { const.POOL_ID: self.pool_ids[protocol], const.NAME: member1_name, const.ADMIN_STATE_UP: True, const.ADDRESS: self.webserver1_ip, const.PROTOCOL_PORT: 80, } if self.lb_member_1_subnet: member1_kwargs[const.SUBNET_ID] = self.lb_member_1_subnet[const.ID] member1 = self.mem_member_client.create_member(**member1_kwargs) member1_id = member1[const.ID] self.addCleanup(self.mem_member_client.cleanup_member, member1_id, pool_id=self.pool_ids[protocol], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) # Set up Member 2 for Webserver 2 member2_name = data_utils.rand_name("lb_member_member2-hm-traffic") member2_kwargs = { const.POOL_ID: self.pool_ids[protocol], const.NAME: member2_name, const.ADMIN_STATE_UP: True, const.ADDRESS: self.webserver2_ip, const.PROTOCOL_PORT: 80, const.MONITOR_PORT: 9999, # We want this to go offline with a HM } if self.lb_member_2_subnet: member2_kwargs[const.SUBNET_ID] = self.lb_member_2_subnet[const.ID] member2 = self.mem_member_client.create_member(**member2_kwargs) member2_id = member2[const.ID] self.addCleanup(self.mem_member_client.cleanup_member, member2_id, pool_id=self.pool_ids[protocol], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) # Set up Member 3 as a non-existent disabled node member3_name = data_utils.rand_name("lb_member_member3-hm-traffic") member3_kwargs = { const.POOL_ID: self.pool_ids[protocol], const.NAME: member3_name, const.ADMIN_STATE_UP: False, const.ADDRESS: '192.0.2.1', const.PROTOCOL_PORT: 80, } member3 = self.mem_member_client.create_member(**member3_kwargs) member3_id = member3[const.ID] self.addCleanup(self.mem_member_client.cleanup_member, member3_id, pool_id=self.pool_ids[protocol], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) # Wait for members to adjust to the correct OPERATING_STATUS waiters.wait_for_status(self.mem_member_client.show_member, member1_id, const.OPERATING_STATUS, const.NO_MONITOR, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, pool_id=self.pool_ids[protocol]) waiters.wait_for_status(self.mem_member_client.show_member, member2_id, const.OPERATING_STATUS, const.NO_MONITOR, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, pool_id=self.pool_ids[protocol]) waiters.wait_for_status(self.mem_member_client.show_member, member3_id, const.OPERATING_STATUS, const.OFFLINE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, pool_id=self.pool_ids[protocol]) # Send some traffic and verify it is balanced self.check_members_balanced(self.lb_vip_address, protocol_port=protocol_port, protocol=protocol, traffic_member_count=2) # Create the healthmonitor hm_name = data_utils.rand_name("lb_member_hm1-hm-traffic") if protocol != const.HTTP: if protocol == const.UDP: hm_type = const.HEALTH_MONITOR_UDP_CONNECT elif protocol == const.TCP: hm_type = const.HEALTH_MONITOR_TCP hm_kwargs = { const.POOL_ID: self.pool_ids[protocol], const.NAME: hm_name, const.TYPE: hm_type, const.DELAY: 3, const.TIMEOUT: 2, const.MAX_RETRIES: 2, const.MAX_RETRIES_DOWN: 2, const.ADMIN_STATE_UP: True, } else: hm_kwargs = { const.POOL_ID: self.pool_ids[protocol], const.NAME: hm_name, const.TYPE: const.HEALTH_MONITOR_HTTP, const.DELAY: 2, const.TIMEOUT: 2, const.MAX_RETRIES: 2, const.MAX_RETRIES_DOWN: 2, const.HTTP_METHOD: const.GET, const.URL_PATH: '/', const.EXPECTED_CODES: '200', const.ADMIN_STATE_UP: True, } hm = self.mem_healthmonitor_client.create_healthmonitor(**hm_kwargs) self.addCleanup(self.mem_healthmonitor_client.cleanup_healthmonitor, hm[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) hm = waiters.wait_for_status( self.mem_healthmonitor_client.show_healthmonitor, hm[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) # Wait for members to adjust to the correct OPERATING_STATUS waiters.wait_for_status(self.mem_member_client.show_member, member1_id, const.OPERATING_STATUS, const.ONLINE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, error_ok=True, pool_id=self.pool_ids[protocol]) waiters.wait_for_status(self.mem_member_client.show_member, member2_id, const.OPERATING_STATUS, const.ERROR, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, pool_id=self.pool_ids[protocol]) waiters.wait_for_status(self.mem_member_client.show_member, member3_id, const.OPERATING_STATUS, const.OFFLINE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, pool_id=self.pool_ids[protocol]) # Send some traffic and verify it is *unbalanced*, as expected self.check_members_balanced(self.lb_vip_address, protocol_port=protocol_port, protocol=protocol, traffic_member_count=1) # Delete the healthmonitor self.mem_healthmonitor_client.delete_healthmonitor(hm[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_healthmonitor_client.show_healthmonitor, hm[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) # Wait for members to adjust to the correct OPERATING_STATUS waiters.wait_for_status(self.mem_member_client.show_member, member1_id, const.OPERATING_STATUS, const.NO_MONITOR, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, pool_id=self.pool_ids[protocol]) waiters.wait_for_status(self.mem_member_client.show_member, member2_id, const.OPERATING_STATUS, const.NO_MONITOR, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, pool_id=self.pool_ids[protocol]) waiters.wait_for_status(self.mem_member_client.show_member, member3_id, const.OPERATING_STATUS, const.OFFLINE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, pool_id=self.pool_ids[protocol]) # Send some traffic and verify it is balanced again self.check_members_balanced(self.lb_vip_address, protocol_port=protocol_port, protocol=protocol)
def _cleanup_obj(self, obj_id, lb_client=None, lb_id=None, parent_id=None): """Clean up an object (for use in tempest addClassResourceCleanup). We always need to wait for the parent LB to be in a mutable state before deleting the child object, and the cleanups will not guarantee this if we just pass the delete function to tempest cleanup. For example, if we add multiple listeners on the same LB to cleanup, tempest will delete the first one and then immediately try to delete the second one, which will fail because the LB will be immutable. We also need to wait to return until the parent LB is back in a mutable state so future tests don't break right at the start. This function: * Waits until the parent LB is ACTIVE * Deletes the object * Waits until the parent LB is ACTIVE :param obj_id: The object ID to clean up. :param lb_client: (Optional) The loadbalancer client, if this isn't the loadbalancer client already. :param lb_id: (Optional) The ID of the parent loadbalancer, if the main obj_id is for a sub-object and not a loadbalancer. :return: """ if parent_id: uri = self.uri.format(parent=parent_id) else: uri = self.uri if lb_client and lb_id: wait_id = lb_id wait_client = lb_client wait_func = lb_client.show_loadbalancer else: wait_id = obj_id wait_client = self wait_func = self._show_object LOG.info("Starting cleanup for %s %s...", self.root_tag, obj_id) try: request_uri = '{0}/{1}'.format(uri, obj_id) response, body = self.get(request_uri) resp_obj = jsonutils.loads(body.decode('utf-8'))[self.root_tag] if (response.status == 404 or resp_obj['provisioning_status'] == const.DELETED): raise exceptions.NotFound() except exceptions.NotFound: # Already gone, cleanup complete LOG.info("%s %s is already gone. Cleanup considered complete.", self.root_tag, obj_id) return LOG.info("Waiting for %s %s to be ACTIVE...", wait_client.root_tag, wait_id) try: waiters.wait_for_status(wait_func, wait_id, const.PROVISIONING_STATUS, const.ACTIVE, self.build_interval, self.timeout) except exceptions.UnexpectedResponseCode: # Status is ERROR, go ahead with deletion LOG.debug("Found %s %s in ERROR status, proceeding with cleanup.", wait_client.root_tag, wait_id) except exceptions.TimeoutException: # Timed out, nothing to be done, let errors happen LOG.error("Timeout exceeded waiting to clean up %s %s.", self.root_tag, obj_id) except exceptions.NotFound: # Already gone, cleanup complete LOG.info("%s %s is already gone. Cleanup considered complete.", wait_client.root_tag.capitalize(), wait_id) return except Exception as e: # Log that something weird happens, then let the chips fall LOG.error( "Cleanup encountered an unknown exception while waiting " "for %s %s: %s", wait_client.root_tag, wait_id, e) uri = '{0}/{1}'.format(uri, obj_id) LOG.info("Cleaning up %s %s...", self.root_tag, obj_id) return_status = test_utils.call_and_ignore_notfound_exc( self.delete, uri) if lb_id and lb_client: LOG.info("Waiting for %s %s to be ACTIVE...", wait_client.root_tag, wait_id) waiters.wait_for_status(wait_func, wait_id, const.PROVISIONING_STATUS, const.ACTIVE, self.build_interval, self.timeout) else: LOG.info("Waiting for %s %s to be DELETED...", wait_client.root_tag, wait_id) waiters.wait_for_deleted_status_or_not_found( wait_func, wait_id, const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) LOG.info("Cleanup complete for %s %s...", self.root_tag, obj_id) return return_status
def test_load_balancer_show_status(self): """Tests load balancer show status tree API. * Create a load balancer. * Validates that other accounts cannot see the status for the * load balancer. * Show load balancer status tree. * Validate the show reflects the expected values. """ lb_name = data_utils.rand_name("lb_member_lb1-status") lb = self.mem_lb_client.create_loadbalancer( name=lb_name, vip_network_id=self.lb_member_vip_net[const.ID]) self.addClassResourceCleanup(self.mem_lb_client.cleanup_loadbalancer, lb[const.ID]) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) if not CONF.load_balancer.test_with_noop: lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.OPERATING_STATUS, const.ONLINE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) # Test that a user, without the load balancer member role, cannot # use this method if CONF.load_balancer.RBAC_test_type == const.ADVANCED: self.assertRaises( exceptions.Forbidden, self.os_primary.loadbalancer_client.get_loadbalancer_status, lb[const.ID]) # Test that a different user, with load balancer role, cannot see # the load balancer status if not CONF.load_balancer.RBAC_test_type == const.NONE: member2_client = self.os_roles_lb_member2.loadbalancer_client self.assertRaises(exceptions.Forbidden, member2_client.get_loadbalancer_status, lb[const.ID]) status = self.mem_lb_client.get_loadbalancer_status(lb[const.ID]) self.assertEqual(1, len(status)) lb_status = status[const.LOADBALANCER] self.assertEqual(5, len(lb_status)) self.assertEqual(lb[const.ID], lb_status[const.ID]) self.assertEqual([], lb_status[const.LISTENERS]) self.assertEqual(lb_name, lb_status[const.NAME]) # Operating status is a measured status, so no-op will not go online if CONF.load_balancer.test_with_noop: self.assertEqual(const.OFFLINE, lb_status[const.OPERATING_STATUS]) else: self.assertEqual(const.ONLINE, lb_status[const.OPERATING_STATUS]) self.assertEqual(const.ACTIVE, lb_status[const.PROVISIONING_STATUS]) # Attempt to clean up so that one full test run doesn't start 10+ # amps before the cleanup phase fires try: self.mem_lb_client.delete_loadbalancer(lb[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) except Exception: pass
def _test_load_balancer_create(self, ip_version): """Tests load balancer create and basic show APIs. * Tests that users without the load balancer member role cannot create load balancers. * Create a fully populated load balancer. * Show load balancer details. * Validate the show reflects the requested values. """ lb_name = data_utils.rand_name("lb_member_lb1-create-" "ipv{}".format(ip_version)) lb_description = data_utils.arbitrary_string(size=255) lb_kwargs = { const.ADMIN_STATE_UP: True, const.DESCRIPTION: lb_description, const.PROVIDER: CONF.load_balancer.provider, # TODO(johnsom) Fix test to use a real flavor # flavor=lb_flavor, # TODO(johnsom) Add QoS # vip_qos_policy_id=lb_qos_policy_id) const.NAME: lb_name } self._setup_lb_network_kwargs(lb_kwargs, ip_version, use_fixed_ip=True) # Test that a user without the load balancer role cannot # create a load balancer if CONF.load_balancer.RBAC_test_type == const.ADVANCED: self.assertRaises( exceptions.Forbidden, self.os_primary.loadbalancer_client.create_loadbalancer, **lb_kwargs) lb = self.mem_lb_client.create_loadbalancer(**lb_kwargs) self.addClassResourceCleanup(self.mem_lb_client.cleanup_loadbalancer, lb[const.ID]) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) if not CONF.load_balancer.test_with_noop: lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.OPERATING_STATUS, const.ONLINE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) self.assertTrue(lb[const.ADMIN_STATE_UP]) parser.parse(lb[const.CREATED_AT]) parser.parse(lb[const.UPDATED_AT]) self.assertEqual(lb_description, lb[const.DESCRIPTION]) UUID(lb[const.ID]) self.assertEqual(lb_name, lb[const.NAME]) # Operating status is a measured status, so no-op will not go online if CONF.load_balancer.test_with_noop: self.assertEqual(const.OFFLINE, lb[const.OPERATING_STATUS]) else: self.assertEqual(const.ONLINE, lb[const.OPERATING_STATUS]) if ip_version == 4: self.assertEqual(self.lb_member_vip_net[const.ID], lb[const.VIP_NETWORK_ID]) else: self.assertEqual(self.lb_member_vip_ipv6_net[const.ID], lb[const.VIP_NETWORK_ID]) self.assertEqual(self.os_roles_lb_member.credentials.project_id, lb[const.PROJECT_ID]) self.assertEqual(CONF.load_balancer.provider, lb[const.PROVIDER]) self.assertIsNotNone(lb[const.VIP_PORT_ID]) if lb_kwargs[const.VIP_SUBNET_ID]: self.assertEqual(lb_kwargs[const.VIP_ADDRESS], lb[const.VIP_ADDRESS]) self.assertEqual(lb_kwargs[const.VIP_SUBNET_ID], lb[const.VIP_SUBNET_ID]) # Attempt to clean up so that one full test run doesn't start 10+ # amps before the cleanup phase fires try: self.mem_lb_client.delete_loadbalancer(lb[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) except Exception: pass
def test_load_balancer_update(self): """Tests load balancer update and show APIs. * Create a fully populated load balancer. * Show load balancer details. * Validate the show reflects the initial values. * Validates that other accounts cannot update the load balancer. * Update the load balancer details. * Show load balancer details. * Validate the show reflects the updated values. """ lb_name = data_utils.rand_name("lb_member_lb1-update") lb_description = data_utils.arbitrary_string(size=255) lb_kwargs = { const.ADMIN_STATE_UP: False, const.DESCRIPTION: lb_description, const.PROVIDER: CONF.load_balancer.provider, # TODO(johnsom) Fix test to use a real flavor # flavor=lb_flavor, # TODO(johnsom) Add QoS # vip_qos_policy_id=lb_qos_policy_id) const.NAME: lb_name } self._setup_lb_network_kwargs(lb_kwargs, 4, use_fixed_ip=True) lb = self.mem_lb_client.create_loadbalancer(**lb_kwargs) self.addClassResourceCleanup(self.mem_lb_client.cleanup_loadbalancer, lb[const.ID]) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) self.assertFalse(lb[const.ADMIN_STATE_UP]) parser.parse(lb[const.CREATED_AT]) parser.parse(lb[const.UPDATED_AT]) self.assertEqual(lb_description, lb[const.DESCRIPTION]) UUID(lb[const.ID]) self.assertEqual(lb_name, lb[const.NAME]) self.assertEqual(const.OFFLINE, lb[const.OPERATING_STATUS]) self.assertEqual(self.os_roles_lb_member.credentials.project_id, lb[const.PROJECT_ID]) self.assertEqual(CONF.load_balancer.provider, lb[const.PROVIDER]) self.assertEqual(self.lb_member_vip_net[const.ID], lb[const.VIP_NETWORK_ID]) self.assertIsNotNone(lb[const.VIP_PORT_ID]) if lb_kwargs[const.VIP_SUBNET_ID]: self.assertEqual(lb_kwargs[const.VIP_ADDRESS], lb[const.VIP_ADDRESS]) self.assertEqual(lb_kwargs[const.VIP_SUBNET_ID], lb[const.VIP_SUBNET_ID]) new_name = data_utils.rand_name("lb_member_lb1-update") new_description = data_utils.arbitrary_string(size=255, base_text='new') # Test that a user, without the load balancer member role, cannot # use this command if CONF.load_balancer.RBAC_test_type == const.ADVANCED: self.assertRaises( exceptions.Forbidden, self.os_primary.loadbalancer_client.update_loadbalancer, lb[const.ID], admin_state_up=True) # Assert we didn't go into PENDING_* lb_check = self.mem_lb_client.show_loadbalancer(lb[const.ID]) self.assertEqual(const.ACTIVE, lb_check[const.PROVISIONING_STATUS]) self.assertFalse(lb_check[const.ADMIN_STATE_UP]) # Test that a user, without the load balancer member role, cannot # update this load balancer if not CONF.load_balancer.RBAC_test_type == const.NONE: member2_client = self.os_roles_lb_member2.loadbalancer_client self.assertRaises(exceptions.Forbidden, member2_client.update_loadbalancer, lb[const.ID], admin_state_up=True) # Assert we didn't go into PENDING_* lb_check = self.mem_lb_client.show_loadbalancer(lb[const.ID]) self.assertEqual(const.ACTIVE, lb_check[const.PROVISIONING_STATUS]) self.assertFalse(lb_check[const.ADMIN_STATE_UP]) lb = self.mem_lb_client.update_loadbalancer( lb[const.ID], admin_state_up=True, description=new_description, # TODO(johnsom) Add QoS # vip_qos_policy_id=lb_qos_policy_id) name=new_name) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) self.assertTrue(lb[const.ADMIN_STATE_UP]) self.assertEqual(new_description, lb[const.DESCRIPTION]) self.assertEqual(new_name, lb[const.NAME]) # TODO(johnsom) Add QoS # Attempt to clean up so that one full test run doesn't start 10+ # amps before the cleanup phase fires try: self.mem_lb_client.delete_loadbalancer(lb[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) except Exception: pass
def test_member_CRUD(self): """Tests member create, read, update, delete * Create a fully populated member. * Show member details. * Update the member. * Delete the member. """ # Member create member_name = data_utils.rand_name("lb_member_member1-CRUD") member_kwargs = { const.NAME: member_name, const.ADMIN_STATE_UP: True, const.POOL_ID: self.pool_id, const.ADDRESS: '192.0.2.1', const.PROTOCOL_PORT: 80, const.WEIGHT: 50, const.MONITOR_ADDRESS: '192.0.2.2', const.MONITOR_PORT: 8080, } if self.mem_member_client.is_version_supported(self.api_version, '2.1'): member_kwargs.update({ const.BACKUP: False, }) if self.lb_member_vip_subnet: member_kwargs[const.SUBNET_ID] = self.lb_member_vip_subnet[ const.ID] hm_enabled = CONF.loadbalancer_feature_enabled.health_monitor_enabled if not hm_enabled: del member_kwargs[const.MONITOR_ADDRESS] del member_kwargs[const.MONITOR_PORT] member = self.mem_member_client.create_member(**member_kwargs) self.addCleanup(self.mem_member_client.cleanup_member, member[const.ID], pool_id=self.pool_id, lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) member = waiters.wait_for_status(self.mem_member_client.show_member, member[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, pool_id=self.pool_id) parser.parse(member[const.CREATED_AT]) parser.parse(member[const.UPDATED_AT]) UUID(member[const.ID]) # Members may be in a transitional state initially # like DOWN or MAINT, give it some time to stablize on # NO_MONITOR. This is LIVE status. member = waiters.wait_for_status(self.mem_member_client.show_member, member[const.ID], const.OPERATING_STATUS, const.NO_MONITOR, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout, pool_id=self.pool_id) equal_items = [ const.NAME, const.ADMIN_STATE_UP, const.ADDRESS, const.PROTOCOL_PORT, const.WEIGHT ] if hm_enabled: equal_items += [const.MONITOR_ADDRESS, const.MONITOR_PORT] if self.mem_member_client.is_version_supported(self.api_version, '2.1'): equal_items.append(const.BACKUP) if const.SUBNET_ID in member_kwargs: equal_items.append(const.SUBNET_ID) else: self.assertIsNone(member.get(const.SUBNET_ID)) for item in equal_items: self.assertEqual(member_kwargs[item], member[item]) # Member update new_name = data_utils.rand_name("lb_member_member1-update") member_update_kwargs = { const.POOL_ID: member_kwargs[const.POOL_ID], const.NAME: new_name, const.ADMIN_STATE_UP: not member[const.ADMIN_STATE_UP], const.WEIGHT: member[const.WEIGHT] + 1, } if self.mem_member_client.is_version_supported(self.api_version, '2.1'): member_update_kwargs.update({ const.BACKUP: not member[const.BACKUP], }) if hm_enabled: member_update_kwargs[const.MONITOR_ADDRESS] = '192.0.2.3' member_update_kwargs[ const.MONITOR_PORT] = member[const.MONITOR_PORT] + 1 member = self.mem_member_client.update_member(member[const.ID], **member_update_kwargs) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) member = waiters.wait_for_status(self.mem_member_client.show_member, member[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout, pool_id=self.pool_id) # Test changed items equal_items = [const.NAME, const.ADMIN_STATE_UP, const.WEIGHT] if hm_enabled: equal_items += [const.MONITOR_ADDRESS, const.MONITOR_PORT] if self.mem_member_client.is_version_supported(self.api_version, '2.1'): equal_items.append(const.BACKUP) for item in equal_items: self.assertEqual(member_update_kwargs[item], member[item]) # Test unchanged items equal_items = [const.ADDRESS, const.PROTOCOL_PORT] if const.SUBNET_ID in member_kwargs: equal_items.append(const.SUBNET_ID) else: self.assertIsNone(member.get(const.SUBNET_ID)) for item in equal_items: self.assertEqual(member_kwargs[item], member[item]) # Member delete waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) self.mem_member_client.delete_member(member[const.ID], pool_id=self.pool_id) waiters.wait_for_deleted_status_or_not_found( self.mem_member_client.show_member, member[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout, pool_id=self.pool_id)
def test_l7policy_CRUD(self): """Tests l7policy create, read, update, delete * Create a fully populated l7policy. * Show l7policy details. * Update the l7policy. * Delete the l7policy. """ # L7Policy create l7policy_name = data_utils.rand_name("lb_member_l7policy1-CRUD") l7policy_description = data_utils.arbitrary_string(size=255) l7policy_kwargs = { const.LISTENER_ID: self.listener_id, const.NAME: l7policy_name, const.DESCRIPTION: l7policy_description, const.ADMIN_STATE_UP: False, const.POSITION: 1, const.ACTION: const.REDIRECT_TO_POOL, const.REDIRECT_POOL_ID: self.pool_id, } l7policy = self.mem_l7policy_client.create_l7policy(**l7policy_kwargs) self.addCleanup(self.mem_l7policy_client.cleanup_l7policy, l7policy[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) l7policy = waiters.wait_for_status( self.mem_l7policy_client.show_l7policy, l7policy[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) self.assertEqual(l7policy_name, l7policy[const.NAME]) self.assertEqual(l7policy_description, l7policy[const.DESCRIPTION]) self.assertFalse(l7policy[const.ADMIN_STATE_UP]) parser.parse(l7policy[const.CREATED_AT]) parser.parse(l7policy[const.UPDATED_AT]) UUID(l7policy[const.ID]) # Operating status will be OFFLINE while admin_state_up = False self.assertEqual(const.OFFLINE, l7policy[const.OPERATING_STATUS]) self.assertEqual(self.listener_id, l7policy[const.LISTENER_ID]) self.assertEqual(1, l7policy[const.POSITION]) self.assertEqual(const.REDIRECT_TO_POOL, l7policy[const.ACTION]) self.assertEqual(self.pool_id, l7policy[const.REDIRECT_POOL_ID]) self.assertIsNone(l7policy.pop(const.REDIRECT_URL, None)) # L7Policy update new_name = data_utils.rand_name("lb_member_l7policy1-update") new_description = data_utils.arbitrary_string(size=255, base_text='new') redirect_url = 'http://localhost' l7policy_update_kwargs = { const.NAME: new_name, const.DESCRIPTION: new_description, const.ADMIN_STATE_UP: True, const.POSITION: 2, const.ACTION: const.REDIRECT_TO_URL, const.REDIRECT_URL: redirect_url, } l7policy = self.mem_l7policy_client.update_l7policy( l7policy[const.ID], **l7policy_update_kwargs) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) l7policy = waiters.wait_for_status( self.mem_l7policy_client.show_l7policy, l7policy[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) self.assertEqual(new_name, l7policy[const.NAME]) self.assertEqual(new_description, l7policy[const.DESCRIPTION]) self.assertTrue(l7policy[const.ADMIN_STATE_UP]) # Operating status for a l7policy will be ONLINE if it is enabled: self.assertEqual(const.ONLINE, l7policy[const.OPERATING_STATUS]) self.assertEqual(self.listener_id, l7policy[const.LISTENER_ID]) # Position will have recalculated to 1 self.assertEqual(1, l7policy[const.POSITION]) self.assertEqual(const.REDIRECT_TO_URL, l7policy[const.ACTION]) self.assertEqual(redirect_url, l7policy[const.REDIRECT_URL]) self.assertIsNone(l7policy.pop(const.REDIRECT_POOL_ID, None)) # L7Policy delete waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) self.mem_l7policy_client.delete_l7policy(l7policy[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_l7policy_client.show_l7policy, l7policy[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout)
def test_listener_CRUD(self): """Tests listener create, read, update, delete * Create a fully populated listener. * Show listener details. * Update the listener. * Delete the listener. """ # Listener create listener_name = data_utils.rand_name("lb_member_listener1-CRUD") listener_description = data_utils.arbitrary_string(size=255) listener_kwargs = { const.NAME: listener_name, const.DESCRIPTION: listener_description, const.ADMIN_STATE_UP: False, const.PROTOCOL: self.protocol, const.PROTOCOL_PORT: 80, const.LOADBALANCER_ID: self.lb_id, const.CONNECTION_LIMIT: 200, const.INSERT_HEADERS: { const.X_FORWARDED_FOR: "true", const.X_FORWARDED_PORT: "true" }, const.DEFAULT_POOL_ID: self.pool1_id, # TODO(rm_work): need to finish the rest of this stuff # const.DEFAULT_TLS_CONTAINER_REF: '', # const.SNI_CONTAINER_REFS: [], } if self.mem_listener_client.is_version_supported( self.api_version, '2.1'): listener_kwargs.update({ const.TIMEOUT_CLIENT_DATA: 1000, const.TIMEOUT_MEMBER_CONNECT: 1000, const.TIMEOUT_MEMBER_DATA: 1000, const.TIMEOUT_TCP_INSPECT: 50, }) listener = self.mem_listener_client.create_listener(**listener_kwargs) self.addCleanup(self.mem_listener_client.cleanup_listener, listener[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) listener = waiters.wait_for_status( self.mem_listener_client.show_listener, listener[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) self.assertEqual(listener_name, listener[const.NAME]) self.assertEqual(listener_description, listener[const.DESCRIPTION]) self.assertFalse(listener[const.ADMIN_STATE_UP]) parser.parse(listener[const.CREATED_AT]) parser.parse(listener[const.UPDATED_AT]) UUID(listener[const.ID]) # Operating status will be OFFLINE while admin_state_up = False self.assertEqual(const.OFFLINE, listener[const.OPERATING_STATUS]) self.assertEqual(self.protocol, listener[const.PROTOCOL]) self.assertEqual(80, listener[const.PROTOCOL_PORT]) self.assertEqual(200, listener[const.CONNECTION_LIMIT]) insert_headers = listener[const.INSERT_HEADERS] self.assertTrue( strutils.bool_from_string(insert_headers[const.X_FORWARDED_FOR])) self.assertTrue( strutils.bool_from_string(insert_headers[const.X_FORWARDED_PORT])) self.assertEqual(self.pool1_id, listener[const.DEFAULT_POOL_ID]) if self.mem_listener_client.is_version_supported( self.api_version, '2.1'): self.assertEqual(1000, listener[const.TIMEOUT_CLIENT_DATA]) self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_CONNECT]) self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_DATA]) self.assertEqual(50, listener[const.TIMEOUT_TCP_INSPECT]) # Listener update new_name = data_utils.rand_name("lb_member_listener1-update") new_description = data_utils.arbitrary_string(size=255, base_text='new') listener_update_kwargs = { const.NAME: new_name, const.DESCRIPTION: new_description, const.ADMIN_STATE_UP: True, const.CONNECTION_LIMIT: 400, const.INSERT_HEADERS: { const.X_FORWARDED_FOR: "false", const.X_FORWARDED_PORT: "false" }, const.DEFAULT_POOL_ID: self.pool2_id, # TODO(rm_work): need to finish the rest of this stuff # const.DEFAULT_TLS_CONTAINER_REF: '', # const.SNI_CONTAINER_REFS: [], } if self.mem_listener_client.is_version_supported( self.api_version, '2.1'): listener_update_kwargs.update({ const.TIMEOUT_CLIENT_DATA: 2000, const.TIMEOUT_MEMBER_CONNECT: 2000, const.TIMEOUT_MEMBER_DATA: 2000, const.TIMEOUT_TCP_INSPECT: 100, }) listener = self.mem_listener_client.update_listener( listener[const.ID], **listener_update_kwargs) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) listener = waiters.wait_for_status( self.mem_listener_client.show_listener, listener[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) if not CONF.load_balancer.test_with_noop: listener = waiters.wait_for_status( self.mem_listener_client.show_listener, listener[const.ID], const.OPERATING_STATUS, const.ONLINE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) self.assertEqual(new_name, listener[const.NAME]) self.assertEqual(new_description, listener[const.DESCRIPTION]) self.assertTrue(listener[const.ADMIN_STATE_UP]) # Operating status is a measured status, so no-op will not go online if CONF.load_balancer.test_with_noop: self.assertEqual(const.OFFLINE, listener[const.OPERATING_STATUS]) else: self.assertEqual(const.ONLINE, listener[const.OPERATING_STATUS]) self.assertEqual(self.protocol, listener[const.PROTOCOL]) self.assertEqual(80, listener[const.PROTOCOL_PORT]) self.assertEqual(400, listener[const.CONNECTION_LIMIT]) insert_headers = listener[const.INSERT_HEADERS] self.assertFalse( strutils.bool_from_string(insert_headers[const.X_FORWARDED_FOR])) self.assertFalse( strutils.bool_from_string(insert_headers[const.X_FORWARDED_PORT])) self.assertEqual(self.pool2_id, listener[const.DEFAULT_POOL_ID]) if self.mem_listener_client.is_version_supported( self.api_version, '2.1'): self.assertEqual(2000, listener[const.TIMEOUT_CLIENT_DATA]) self.assertEqual(2000, listener[const.TIMEOUT_MEMBER_CONNECT]) self.assertEqual(2000, listener[const.TIMEOUT_MEMBER_DATA]) self.assertEqual(100, listener[const.TIMEOUT_TCP_INSPECT]) # Listener delete waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) self.mem_listener_client.delete_listener(listener[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_listener_client.show_listener, listener[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout)
def test_healthmonitor_CRUD(self): """Tests healthmonitor create, read, update, delete, and member status * Create a fully populated healthmonitor. * Show healthmonitor details. * Update the healthmonitor. * Delete the healthmonitor. """ # Healthmonitor create hm_name = data_utils.rand_name("lb_member_hm1-CRUD") hm_kwargs = { const.POOL_ID: self.pool_id, const.NAME: hm_name, const.TYPE: const.HEALTH_MONITOR_HTTP, const.DELAY: 2, const.TIMEOUT: 2, const.MAX_RETRIES: 2, const.MAX_RETRIES_DOWN: 2, const.HTTP_METHOD: const.GET, const.URL_PATH: '/', const.EXPECTED_CODES: '200', const.ADMIN_STATE_UP: True, } hm = self.mem_healthmonitor_client.create_healthmonitor(**hm_kwargs) self.addCleanup(self.mem_healthmonitor_client.cleanup_healthmonitor, hm[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) hm = waiters.wait_for_status( self.mem_healthmonitor_client.show_healthmonitor, hm[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) parser.parse(hm[const.CREATED_AT]) parser.parse(hm[const.UPDATED_AT]) UUID(hm[const.ID]) self.assertEqual(const.ONLINE, hm[const.OPERATING_STATUS]) equal_items = [ const.NAME, const.TYPE, const.DELAY, const.TIMEOUT, const.MAX_RETRIES, const.MAX_RETRIES_DOWN, const.HTTP_METHOD, const.URL_PATH, const.EXPECTED_CODES, const.ADMIN_STATE_UP ] for item in equal_items: self.assertEqual(hm_kwargs[item], hm[item]) # Healthmonitor update new_name = data_utils.rand_name("lb_member_hm1-update") hm_update_kwargs = { const.NAME: new_name, const.DELAY: hm_kwargs[const.DELAY] + 1, const.TIMEOUT: hm_kwargs[const.TIMEOUT] + 1, const.MAX_RETRIES: hm_kwargs[const.MAX_RETRIES] + 1, const.MAX_RETRIES_DOWN: hm_kwargs[const.MAX_RETRIES_DOWN] + 1, const.HTTP_METHOD: const.POST, const.URL_PATH: '/test', const.EXPECTED_CODES: '201,202', const.ADMIN_STATE_UP: not hm_kwargs[const.ADMIN_STATE_UP], } hm = self.mem_healthmonitor_client.update_healthmonitor( hm[const.ID], **hm_update_kwargs) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) hm = waiters.wait_for_status( self.mem_healthmonitor_client.show_healthmonitor, hm[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) # Test changed items equal_items = [ const.NAME, const.DELAY, const.TIMEOUT, const.MAX_RETRIES, const.MAX_RETRIES_DOWN, const.HTTP_METHOD, const.URL_PATH, const.EXPECTED_CODES, const.ADMIN_STATE_UP ] for item in equal_items: self.assertEqual(hm_update_kwargs[item], hm[item]) # Test unchanged items equal_items = [const.TYPE] for item in equal_items: self.assertEqual(hm_kwargs[item], hm[item]) # Healthmonitor delete self.mem_healthmonitor_client.delete_healthmonitor(hm[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_healthmonitor_client.show_healthmonitor, hm[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout)
def test_l7rule_delete(self): """Tests l7rule create and delete APIs. * Creates a l7rule. * Validates that other accounts cannot delete the l7rule * Deletes the l7rule. * Validates the l7rule is in the DELETED state. """ l7rule_kwargs = { const.L7POLICY_ID: self.l7policy_id, const.TYPE: const.HEADER, const.VALUE: 'myvalue-delete', const.COMPARE_TYPE: const.EQUAL_TO, const.KEY: 'mykey-delete', } l7rule = self.mem_l7rule_client.create_l7rule(**l7rule_kwargs) self.addClassResourceCleanup(self.mem_l7rule_client.cleanup_l7rule, l7rule[const.ID], l7policy_id=self.l7policy_id, lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) # Test that a user without the load balancer role cannot # delete this l7rule if CONF.load_balancer.RBAC_test_type == const.ADVANCED: self.assertRaises(exceptions.Forbidden, self.os_primary.l7rule_client.delete_l7rule, l7rule[const.ID], l7policy_id=self.l7policy_id) # Test that a different user, with the load balancer member role # cannot delete this l7rule if not CONF.load_balancer.RBAC_test_type == const.NONE: member2_client = self.os_roles_lb_member2.l7rule_client self.assertRaises(exceptions.Forbidden, member2_client.delete_l7rule, l7rule[const.ID], l7policy_id=self.l7policy_id) self.mem_l7rule_client.delete_l7rule(l7rule[const.ID], l7policy_id=self.l7policy_id) waiters.wait_for_deleted_status_or_not_found( self.mem_l7rule_client.show_l7rule, l7rule[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout, l7policy_id=self.l7policy_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout)
def test_healthmonitor_delete(self): """Tests healthmonitor create and delete APIs. * Create a clean pool to use for the healthmonitor. * Creates a healthmonitor. * Validates that other accounts cannot delete the healthmonitor * Deletes the healthmonitor. * Validates the healthmonitor is in the DELETED state. """ pool_name = data_utils.rand_name("lb_member_pool1_hm-delete") pool_kwargs = { const.NAME: pool_name, const.PROTOCOL: const.HTTP, const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN, const.LOADBALANCER_ID: self.lb_id, } pool = self.mem_pool_client.create_pool(**pool_kwargs) self.addCleanup( self.mem_pool_client.cleanup_pool, pool[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) hm_name = data_utils.rand_name("lb_member_hm1-delete") hm_kwargs = { const.POOL_ID: pool[const.ID], const.NAME: hm_name, const.TYPE: const.HEALTH_MONITOR_TCP, const.DELAY: 2, const.TIMEOUT: 3, const.MAX_RETRIES: 4, } hm = self.mem_healthmonitor_client.create_healthmonitor(**hm_kwargs) self.addCleanup( self.mem_healthmonitor_client.cleanup_healthmonitor, hm[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status( self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) # Test that a user without the loadbalancer role cannot # delete this healthmonitor if CONF.load_balancer.RBAC_test_type == const.ADVANCED: self.assertRaises( exceptions.Forbidden, self.os_primary.healthmonitor_client.delete_healthmonitor, hm[const.ID]) # Test that a different user, with the loadbalancer member role # cannot delete this healthmonitor if not CONF.load_balancer.RBAC_test_type == const.NONE: member2_client = self.os_roles_lb_member2.healthmonitor_client self.assertRaises(exceptions.Forbidden, member2_client.delete_healthmonitor, hm[const.ID]) self.mem_healthmonitor_client.delete_healthmonitor(hm[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_healthmonitor_client.show_healthmonitor, hm[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) waiters.wait_for_status( self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout)
def test_load_balancer_failover(self): """Tests load balancer failover API. * Create a load balancer. * Validates that other accounts cannot failover the load balancer * Wait for the load balancer to go ACTIVE. * Failover the load balancer. * Wait for the load balancer to go ACTIVE. """ lb_name = data_utils.rand_name("lb_member_lb1-failover") lb = self.mem_lb_client.create_loadbalancer( name=lb_name, provider=CONF.load_balancer.provider, vip_network_id=self.lb_member_vip_net[const.ID]) self.addClassResourceCleanup(self.mem_lb_client.cleanup_loadbalancer, lb[const.ID]) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) # Test RBAC not authorized for non-admin role if not CONF.load_balancer.RBAC_test_type == const.NONE: self.assertRaises(exceptions.Forbidden, self.mem_lb_client.failover_loadbalancer, lb[const.ID]) # Assert we didn't go into PENDING_* lb = self.mem_lb_client.show_loadbalancer(lb[const.ID]) self.assertEqual(const.ACTIVE, lb[const.PROVISIONING_STATUS]) if CONF.load_balancer.provider in ['amphora', 'octavia']: before_amphorae = self.lb_admin_amphora_client.list_amphorae( query_params='{loadbalancer_id}={lb_id}'.format( loadbalancer_id=const.LOADBALANCER_ID, lb_id=lb[const.ID])) self.os_roles_lb_admin.loadbalancer_client.failover_loadbalancer( lb[const.ID]) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) if CONF.load_balancer.provider in ['amphora', 'octavia']: after_amphorae = self.lb_admin_amphora_client.list_amphorae( query_params='{loadbalancer_id}={lb_id}'.format( loadbalancer_id=const.LOADBALANCER_ID, lb_id=lb[const.ID])) # Make sure all of the amphora on the load balancer have # failed over for amphora in before_amphorae: for new_amp in after_amphorae: self.assertNotEqual(amphora[const.ID], new_amp[const.ID]) # Attempt to clean up so that one full test run doesn't start 10+ # amps before the cleanup phase fires try: self.mem_lb_client.delete_loadbalancer(lb[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) except Exception: pass
def _test_pool_CRUD(self, has_listener): """Tests pool create, read, update, delete * Create a fully populated pool. * Show pool details. * Update the pool. * Delete the pool. """ # Pool create pool_name = data_utils.rand_name("lb_member_pool1-CRUD") pool_description = data_utils.arbitrary_string(size=255) pool_sp_cookie_name = 'my_cookie' pool_kwargs = { const.NAME: pool_name, const.DESCRIPTION: pool_description, const.ADMIN_STATE_UP: False, const.PROTOCOL: self.protocol, const.LB_ALGORITHM: self.lb_algorithm, } if self.lb_feature_enabled.session_persistence_enabled: pool_kwargs[const.SESSION_PERSISTENCE] = { const.TYPE: const.SESSION_PERSISTENCE_APP_COOKIE, const.COOKIE_NAME: pool_sp_cookie_name, } if has_listener: pool_kwargs[const.LISTENER_ID] = self.listener_id else: pool_kwargs[const.LOADBALANCER_ID] = self.lb_id pool = self.mem_pool_client.create_pool(**pool_kwargs) self.addCleanup( self.mem_pool_client.cleanup_pool, pool[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id) waiters.wait_for_status( self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) pool = waiters.wait_for_status( self.mem_pool_client.show_pool, pool[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) self.assertEqual(pool_name, pool[const.NAME]) self.assertEqual(pool_description, pool[const.DESCRIPTION]) self.assertFalse(pool[const.ADMIN_STATE_UP]) parser.parse(pool[const.CREATED_AT]) parser.parse(pool[const.UPDATED_AT]) UUID(pool[const.ID]) self.assertEqual(const.OFFLINE, pool[const.OPERATING_STATUS]) self.assertEqual(self.protocol, pool[const.PROTOCOL]) self.assertEqual(1, len(pool[const.LOADBALANCERS])) self.assertEqual(self.lb_id, pool[const.LOADBALANCERS][0][const.ID]) if has_listener: self.assertEqual(1, len(pool[const.LISTENERS])) self.assertEqual(self.listener_id, pool[const.LISTENERS][0][const.ID]) else: self.assertEmpty(pool[const.LISTENERS]) self.assertEqual(self.lb_algorithm, pool[const.LB_ALGORITHM]) if self.lb_feature_enabled.session_persistence_enabled: self.assertIsNotNone(pool.get(const.SESSION_PERSISTENCE)) self.assertEqual(const.SESSION_PERSISTENCE_APP_COOKIE, pool[const.SESSION_PERSISTENCE][const.TYPE]) self.assertEqual(pool_sp_cookie_name, pool[const.SESSION_PERSISTENCE][ const.COOKIE_NAME]) # Pool update new_name = data_utils.rand_name("lb_member_pool1-update") new_description = data_utils.arbitrary_string(size=255, base_text='new') pool_update_kwargs = { const.NAME: new_name, const.DESCRIPTION: new_description, const.ADMIN_STATE_UP: True, } if self.lb_feature_enabled.pool_algorithms_enabled: pool_update_kwargs[const.LB_ALGORITHM] = ( const.LB_ALGORITHM_LEAST_CONNECTIONS) if self.protocol == const.HTTP and ( self.lb_feature_enabled.session_persistence_enabled): pool_update_kwargs[const.SESSION_PERSISTENCE] = { const.TYPE: const.SESSION_PERSISTENCE_HTTP_COOKIE} pool = self.mem_pool_client.update_pool( pool[const.ID], **pool_update_kwargs) waiters.wait_for_status( self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) pool = waiters.wait_for_status( self.mem_pool_client.show_pool, pool[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.build_interval, CONF.load_balancer.build_timeout) self.assertEqual(new_name, pool[const.NAME]) self.assertEqual(new_description, pool[const.DESCRIPTION]) self.assertTrue(pool[const.ADMIN_STATE_UP]) if self.lb_feature_enabled.pool_algorithms_enabled: self.assertEqual(const.LB_ALGORITHM_LEAST_CONNECTIONS, pool[const.LB_ALGORITHM]) if self.lb_feature_enabled.session_persistence_enabled: self.assertIsNotNone(pool.get(const.SESSION_PERSISTENCE)) self.assertEqual(const.SESSION_PERSISTENCE_HTTP_COOKIE, pool[const.SESSION_PERSISTENCE][const.TYPE]) self.assertIsNone( pool[const.SESSION_PERSISTENCE].get(const.COOKIE_NAME)) # Pool delete waiters.wait_for_status( self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) self.mem_pool_client.delete_pool(pool[const.ID]) waiters.wait_for_deleted_status_or_not_found( self.mem_pool_client.show_pool, pool[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout) waiters.wait_for_status( self.mem_lb_client.show_loadbalancer, self.lb_id, const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout)
def _test_load_balancer_CRUD(self, ip_version): """Tests load balancer create, read, update, delete * Create a fully populated load balancer. * Show load balancer details. * Update the load balancer. * Delete the load balancer. """ lb_name = data_utils.rand_name("lb_member_lb1-CRUD") lb_description = data_utils.arbitrary_string(size=255) lb_kwargs = { const.ADMIN_STATE_UP: False, const.DESCRIPTION: lb_description, const.PROVIDER: CONF.load_balancer.provider, const.NAME: lb_name } self._setup_lb_network_kwargs(lb_kwargs, ip_version) lb = self.mem_lb_client.create_loadbalancer(**lb_kwargs) self.addCleanup(self.mem_lb_client.cleanup_loadbalancer, lb[const.ID]) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) self.assertFalse(lb[const.ADMIN_STATE_UP]) parser.parse(lb[const.CREATED_AT]) parser.parse(lb[const.UPDATED_AT]) self.assertEqual(lb_description, lb[const.DESCRIPTION]) UUID(lb[const.ID]) self.assertEqual(lb_name, lb[const.NAME]) self.assertEqual(const.OFFLINE, lb[const.OPERATING_STATUS]) self.assertEqual(self.os_roles_lb_member.credentials.project_id, lb[const.PROJECT_ID]) self.assertEqual(CONF.load_balancer.provider, lb[const.PROVIDER]) if ip_version == 4: self.assertEqual(self.lb_member_vip_net[const.ID], lb[const.VIP_NETWORK_ID]) else: self.assertEqual(self.lb_member_vip_ipv6_net[const.ID], lb[const.VIP_NETWORK_ID]) self.assertIsNotNone(lb[const.VIP_PORT_ID]) if lb_kwargs[const.VIP_SUBNET_ID]: self.assertEqual(lb_kwargs[const.VIP_SUBNET_ID], lb[const.VIP_SUBNET_ID]) # Load balancer update new_name = data_utils.rand_name("lb_member_lb1-update") new_description = data_utils.arbitrary_string(size=255, base_text='new') lb = self.mem_lb_client.update_loadbalancer( lb[const.ID], admin_state_up=True, description=new_description, name=new_name) lb = waiters.wait_for_status(self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, const.ACTIVE, CONF.load_balancer.lb_build_interval, CONF.load_balancer.lb_build_timeout) self.assertTrue(lb[const.ADMIN_STATE_UP]) self.assertEqual(new_description, lb[const.DESCRIPTION]) self.assertEqual(new_name, lb[const.NAME]) # Load balancer delete self.mem_lb_client.delete_loadbalancer(lb[const.ID], cascade=True) waiters.wait_for_deleted_status_or_not_found( self.mem_lb_client.show_loadbalancer, lb[const.ID], const.PROVISIONING_STATUS, CONF.load_balancer.check_interval, CONF.load_balancer.check_timeout)