def test_execute_dummy_action_plan(self): _, audit_template = self.create_audit_template() _, audit = self.create_audit(audit_template['uuid']) self.assertTrue(test.call_until_true( func=functools.partial(self.has_audit_succeeded, audit['uuid']), duration=30, sleep_for=.5 )) _, action_plans = self.client.list_action_plans( audit_uuid=audit['uuid']) action_plan = action_plans['action_plans'][0] _, action_plan = self.client.show_action_plan(action_plan['uuid']) # Execute the action by changing its state to PENDING _, updated_ap = self.client.update_action_plan( action_plan['uuid'], patch=[{'path': '/state', 'op': 'replace', 'value': 'PENDING'}] ) self.assertTrue(test.call_until_true( func=functools.partial( self.has_action_plan_finished, action_plan['uuid']), duration=30, sleep_for=.5 )) _, finished_ap = self.client.show_action_plan(action_plan['uuid']) self.assertIn(updated_ap['state'], ('PENDING', 'ONGOING')) self.assertEqual('SUCCEEDED', finished_ap['state'])
def check_flip_status(self, floating_ip, status): """Verifies floatingip reaches the given status :param dict floating_ip: floating IP dict to check status :param status: target status :raises: AssertionError if status doesn't match """ # TODO(ptoohill): Find a way to utilze the proper client method floatingip_id = floating_ip['id'] def refresh(): result = (self.floating_ips_client_admin. show_floatingip(floatingip_id)['floatingip']) return status == result['status'] test.call_until_true(refresh, 100, 1) floating_ip = self.floating_ips_client_admin.show_floatingip( floatingip_id)['floatingip'] self.assertEqual(status, floating_ip['status'], message="FloatingIP: {fp} is at status: {cst}. " "failed to reach status: {st}" .format(fp=floating_ip, cst=floating_ip['status'], st=status)) LOG.info("FloatingIP: {fp} is at status: {st}" .format(fp=floating_ip, st=status))
def _hotplug_server(self): old_floating_ip, server = self.floating_ip_tuple ip_address = old_floating_ip.floating_ip_address private_key = self.servers[server].private_key ssh_client = self.get_remote_client(ip_address, private_key=private_key) old_nic_list = self._get_server_nics(ssh_client) # get a port from a list of one item port_list = self._list_ports(device_id=server.id) self.assertEqual(1, len(port_list)) old_port = port_list[0] self.compute_client.servers.interface_attach(server=server, net_id=self.new_net.id, port_id=None, fixed_ip=None) # move server to the head of the cleanup list self.addCleanup(self.cleanup_wrapper, server) def check_ports(): port_list = [port for port in self._list_ports(device_id=server.id) if port != old_port] return len(port_list) == 1 test.call_until_true(check_ports, 60, 1) new_port_list = [p for p in self._list_ports(device_id=server.id) if p != old_port] self.assertEqual(1, len(new_port_list)) new_port = new_port_list[0] new_port = net_common.DeletablePort(client=self.network_client, **new_port) new_nic_list = self._get_server_nics(ssh_client) diff_list = [n for n in new_nic_list if n not in old_nic_list] self.assertEqual(1, len(diff_list)) num, new_nic = diff_list[0] ssh_client.assign_static_ip(nic=new_nic, addr=new_port.fixed_ips[0]["ip_address"]) ssh_client.turn_nic_on(nic=new_nic)
def assertScale(from_servers, to_servers): call_until_true(lambda: server_count() == to_servers, timeout, interval) self.assertEqual(to_servers, self.server_count, 'Failed scaling from %d to %d servers. ' 'Current server count: %s' % ( from_servers, to_servers, self.server_count))
def _prepare_and_test(self, address6_mode, n_subnets6=1, dualnet=False): net_list = self.prepare_network(address6_mode=address6_mode, n_subnets6=n_subnets6, dualnet=dualnet) sshv4_1, ips_from_api_1, sid1 = self.prepare_server(networks=net_list) sshv4_2, ips_from_api_2, sid2 = self.prepare_server(networks=net_list) def guest_has_address(ssh, addr): return addr in ssh.get_ip_list() # Turn on 2nd NIC for Cirros when dualnet if dualnet: self.turn_nic6_on(sshv4_1, sid1) self.turn_nic6_on(sshv4_2, sid2) # get addresses assigned to vNIC as reported by 'ip address' utility ips_from_ip_1 = sshv4_1.get_ip_list() ips_from_ip_2 = sshv4_2.get_ip_list() self.assertIn(ips_from_api_1['4'], ips_from_ip_1) self.assertIn(ips_from_api_2['4'], ips_from_ip_2) for i in range(n_subnets6): # v6 should be configured since the image supports it # It can take time for ipv6 automatic address to get assigned srv1_v6_addr_assigned = functools.partial( guest_has_address, sshv4_1, ips_from_api_1['6'][i]) srv2_v6_addr_assigned = functools.partial( guest_has_address, sshv4_2, ips_from_api_2['6'][i]) self.assertTrue(test.call_until_true(srv1_v6_addr_assigned, CONF.compute.ping_timeout, 1)) self.assertTrue(test.call_until_true(srv2_v6_addr_assigned, CONF.compute.ping_timeout, 1)) self._check_connectivity(sshv4_1, ips_from_api_2['4']) self._check_connectivity(sshv4_2, ips_from_api_1['4']) # Some VM (like cirros) may not have ping6 utility result = sshv4_1.exec_command('whereis ping6') is_ping6 = False if result == 'ping6:\n' else True if is_ping6: for i in range(n_subnets6): self._check_connectivity(sshv4_1, ips_from_api_2['6'][i]) self._check_connectivity(sshv4_1, self.subnets_v6[i].gateway_ip) self._check_connectivity(sshv4_2, ips_from_api_1['6'][i]) self._check_connectivity(sshv4_2, self.subnets_v6[i].gateway_ip) else: LOG.warning('Ping6 is not available, skipping')
def call_until_valid(self, func, duration, *args, **kwargs): # Call until get valid response for "duration" # because tenant usage doesn't become available immediately # after create VM. def is_valid(): try: self.resp = func(*args, **kwargs) return True except e.InvalidHTTPResponseBody: return False test.call_until_true(is_valid, duration, 1) return self.resp
def _hotplug_server(self): old_floating_ip, server = self.floating_ip_tuple ip_address = old_floating_ip.floating_ip_address private_key = self._get_server_key(server) ssh_client = self.get_remote_client(ip_address, private_key=private_key) old_nic_list = self._get_server_nics(ssh_client) # get a port from a list of one item port_list = self._list_ports(device_id=server['id']) self.assertEqual(1, len(port_list)) old_port = port_list[0] interface = self.interface_client.create_interface( server_id=server['id'], net_id=self.new_net.id)['interfaceAttachment'] self.addCleanup(self.network_client.wait_for_resource_deletion, 'port', interface['port_id'], client=self.ports_client) self.addCleanup(self.delete_wrapper, self.interface_client.delete_interface, server['id'], interface['port_id']) def check_ports(): self.new_port_list = [port for port in self._list_ports(device_id=server['id']) if port['id'] != old_port['id']] return len(self.new_port_list) == 1 if not test.call_until_true(check_ports, CONF.network.build_timeout, CONF.network.build_interval): raise exceptions.TimeoutException( "No new port attached to the server in time (%s sec)! " "Old port: %s. Number of new ports: %d" % ( CONF.network.build_timeout, old_port, len(self.new_port_list))) new_port = net_resources.DeletablePort(ports_client=self.ports_client, **self.new_port_list[0]) def check_new_nic(): new_nic_list = self._get_server_nics(ssh_client) self.diff_list = [n for n in new_nic_list if n not in old_nic_list] return len(self.diff_list) == 1 if not test.call_until_true(check_new_nic, CONF.network.build_timeout, CONF.network.build_interval): raise exceptions.TimeoutException("Interface not visible on the " "guest after %s sec" % CONF.network.build_timeout) num, new_nic = self.diff_list[0] ssh_client.assign_static_ip(nic=new_nic, addr=new_port.fixed_ips[0]['ip_address']) ssh_client.turn_nic_on(nic=new_nic)
def test_datasource_db_sync_remove(self): # Verify that a replica removes a datasource when a datasource # disappears from the database. CLIENT2_PORT = 4001 client1 = self.admin_manager.congress_client fake_id = self.create_fake(client1) need_to_delete_fake = True try: self.start_replica(CLIENT2_PORT) # Verify that primary server has fake datasource if not test.call_until_true( func=lambda: self.datasource_exists(client1, fake_id), duration=60, sleep_for=1): raise exceptions.TimeoutException( "primary should have fake, but does not") # Create session for second server. client2 = self.create_client(CLIENT2_PORT) # Verify that second server has fake datasource if not test.call_until_true( func=lambda: self.datasource_exists(client2, fake_id), duration=60, sleep_for=1): raise exceptions.TimeoutException( "replica should have fake, but does not") # Remove fake from primary server instance. LOG.debug("removing fake datasource %s", str(fake_id)) client1.delete_datasource(fake_id) need_to_delete_fake = False # Confirm that fake is gone from primary server instance. if not test.call_until_true( func=lambda: self.datasource_missing(client1, fake_id), duration=60, sleep_for=1): self.stop_replica(CLIENT2_PORT) raise exceptions.TimeoutException( "primary instance still has fake") LOG.debug("removed fake datasource from primary instance") # Confirm that second service instance removes fake. if not test.call_until_true( func=lambda: self.datasource_missing(client2, fake_id), duration=60, sleep_for=1): raise exceptions.TimeoutException( "replica should remove fake, but still has it") finally: self.stop_replica(CLIENT2_PORT) if need_to_delete_fake: self.admin_manager.congress_client.delete_datasource(fake_id)
def test_execute_dummy_action_plan(self): """Execute an action plan based on the 'dummy' strategy - create an audit template with the 'dummy' strategy - run the audit to create an action plan - get the action plan - run the action plan - get results and make sure it succeeded """ _, goal = self.client.show_goal("dummy") _, audit_template = self.create_audit_template(goal['uuid']) _, audit = self.create_audit(audit_template['uuid']) self.assertTrue(test.call_until_true( func=functools.partial(self.has_audit_succeeded, audit['uuid']), duration=30, sleep_for=.5 )) _, action_plans = self.client.list_action_plans( audit_uuid=audit['uuid']) action_plan = action_plans['action_plans'][0] _, action_plan = self.client.show_action_plan(action_plan['uuid']) # Execute the action by changing its state to PENDING _, updated_ap = self.client.update_action_plan( action_plan['uuid'], patch=[{'path': '/state', 'op': 'replace', 'value': 'PENDING'}] ) self.assertTrue(test.call_until_true( func=functools.partial( self.has_action_plan_finished, action_plan['uuid']), duration=30, sleep_for=.5 )) _, finished_ap = self.client.show_action_plan(action_plan['uuid']) _, action_list = self.client.list_actions( action_plan_uuid=finished_ap["uuid"]) action_counter = collections.Counter( act['action_type'] for act in action_list['actions']) self.assertIn(updated_ap['state'], ('PENDING', 'ONGOING')) self.assertEqual('SUCCEEDED', finished_ap['state']) # A dummy strategy generates 2 "nop" actions and 1 "sleep" action self.assertEqual(3, len(action_list['actions'])) self.assertEqual(2, action_counter.get("nop")) self.assertEqual(1, action_counter.get("sleep"))
def _hotplug_server(self): old_floating_ip, server = self.floating_ip_tuple ip_address = old_floating_ip.floating_ip_address private_key = self.servers[server].private_key ssh_client = self.get_remote_client(ip_address, private_key=private_key) old_nic_list = self._get_server_nics(ssh_client) # get a port from a list of one item port_list = self._list_ports(device_id=server.id) self.assertEqual(1, len(port_list)) old_port = port_list[0] self.compute_client.servers.interface_attach(server=server, net_id=self.new_net.id, port_id=None, fixed_ip=None) # move server to the head of the cleanup list self.addCleanup(self.delete_timeout, self.compute_client.servers, server.id) self.addCleanup(self.delete_wrapper, server) def check_ports(): self.new_port_list = [port for port in self._list_ports(device_id=server.id) if port != old_port] return len(self.new_port_list) == 1 if not test.call_until_true(check_ports, CONF.network.build_timeout, CONF.network.build_interval): raise exceptions.TimeoutException("No new port attached to the " "server in time (%s sec) !" % CONF.network.build_timeout) new_port = net_common.DeletablePort(client=self.network_client, **self.new_port_list[0]) def check_new_nic(): new_nic_list = self._get_server_nics(ssh_client) self.diff_list = [n for n in new_nic_list if n not in old_nic_list] return len(self.diff_list) == 1 if not test.call_until_true(check_new_nic, CONF.network.build_timeout, CONF.network.build_interval): raise exceptions.TimeoutException("Interface not visible on the " "guest after %s sec" % CONF.network.build_timeout) num, new_nic = self.diff_list[0] ssh_client.assign_static_ip(nic=new_nic, addr=new_port.fixed_ips[0]['ip_address']) ssh_client.turn_nic_on(nic=new_nic)
def _prepare_and_test(self, address6_mode, n_subnets6=1, dualnet=False): net_list = self.prepare_network(address6_mode=address6_mode, n_subnets6=n_subnets6, dualnet=dualnet) sshv4_1, ips_from_api_1, sid1 = self.prepare_server(networks=net_list) sshv4_2, ips_from_api_2, sid2 = self.prepare_server(networks=net_list) def guest_has_address(ssh, addr): return addr in ssh.get_ip_list() # Turn on 2nd NIC for Cirros when dualnet if dualnet: self.turn_nic6_on(sshv4_1, sid1) self.turn_nic6_on(sshv4_2, sid2) # get addresses assigned to vNIC as reported by 'ip address' utility ips_from_ip_1 = sshv4_1.get_ip_list() ips_from_ip_2 = sshv4_2.get_ip_list() self.assertIn(ips_from_api_1['4'], ips_from_ip_1) self.assertIn(ips_from_api_2['4'], ips_from_ip_2) for i in range(n_subnets6): # v6 should be configured since the image supports it # It can take time for ipv6 automatic address to get assigned srv1_v6_addr_assigned = functools.partial( guest_has_address, sshv4_1, ips_from_api_1['6'][i]) srv2_v6_addr_assigned = functools.partial( guest_has_address, sshv4_2, ips_from_api_2['6'][i]) self.assertTrue(test.call_until_true(srv1_v6_addr_assigned, CONF.validation.ping_timeout, 1)) self.assertTrue(test.call_until_true(srv2_v6_addr_assigned, CONF.validation.ping_timeout, 1)) self._check_connectivity(sshv4_1, ips_from_api_2['4']) self._check_connectivity(sshv4_2, ips_from_api_1['4']) for i in range(n_subnets6): self._check_connectivity(sshv4_1, ips_from_api_2['6'][i]) self._check_connectivity(sshv4_1, self.subnets_v6[i].gateway_ip) self._check_connectivity(sshv4_2, ips_from_api_1['6'][i]) self._check_connectivity(sshv4_2, self.subnets_v6[i].gateway_ip)
def test_keystone_roles_table(self): role_schema = ( self.admin_manager.congress_client.show_datasource_table_schema( self.datasource_id, 'roles')['columns']) role_id_col = next(i for i, c in enumerate(role_schema) if c['name'] == 'id') def _check_data_table_keystone_roles(): # Fetch data from keystone each time, because this test may start # before keystone has all the users. roles = self.roles_client.list_roles()['roles'] roles_map = {} for role in roles: roles_map[role['id']] = role results = ( self.admin_manager.congress_client.list_datasource_rows( self.datasource_id, 'roles')) for row in results['results']: try: role_row = roles_map[row['data'][role_id_col]] except KeyError: return False for index in range(len(role_schema)): if (str(row['data'][index]) != str(role_row[role_schema[index]['name']])): return False return True if not test.call_until_true(func=_check_data_table_keystone_roles, duration=100, sleep_for=4): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_glancev2_tags_table(self): def _check_data_table_glance_images(): # Fetch data from glance each time, because this test may start # before glance has all the users. images = self.glancev2.list_images()['images'] image_tag_map = {} for image in images: image_tag_map[image['id']] = image['tags'] results = ( self.admin_manager.congress_client.list_datasource_rows( self.datasource_id, 'tags')) for row in results['results']: image_id, tag = row['data'][0], row['data'][1] glance_image_tags = image_tag_map.get(image_id) if not glance_image_tags: # congress had image that glance doesn't know about. return False if tag not in glance_image_tags: # congress had a tag that wasn't on the image. return False return True if not test.call_until_true(func=_check_data_table_glance_images, duration=100, sleep_for=5): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_ceilometer_meters_table(self): meter_schema = ( self.admin_manager.congress_client.show_datasource_table_schema( self.datasource_id, 'meters')['columns']) meter_id_col = next(i for i, c in enumerate(meter_schema) if c['name'] == 'meter_id') def _check_data_table_ceilometer_meters(): # Fetch data from ceilometer each time, because this test may start # before ceilometer has all the users. meters = self.telemetry_client.list_meters() meter_map = {} for meter in meters: meter_map[meter['meter_id']] = meter results = ( self.admin_manager.congress_client.list_datasource_rows( self.datasource_id, 'meters')) for row in results['results']: try: meter_row = meter_map[row['data'][meter_id_col]] except KeyError: return False for index in range(len(meter_schema)): if (str(row['data'][index]) != str(meter_row[meter_schema[index]['name']])): return False return True if not test.call_until_true(func=_check_data_table_ceilometer_meters, duration=100, sleep_for=5): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_neutronv2_networks_table(self): def _check_data(): networks = self.neutron_client.list_networks() network_map = {} for network in networks['networks']: network_map[network['id']] = network client = self.admin_manager.congress_client client.request_refresh(self.datasource_id) time.sleep(1) network_schema = (client.show_datasource_table_schema( self.datasource_id, 'networks')['columns']) results = (client.list_datasource_rows( self.datasource_id, 'networks')) for row in results['results']: network_row = network_map[row['data'][0]] for index in range(len(network_schema)): if (str(row['data'][index]) != str(network_row[network_schema[index]['name']])): return False return True if not test.call_until_true(func=_check_data, duration=200, sleep_for=10): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def wait_for_table_active(cls, table_name, timeout=120, interval=3): def check(): resp = cls.client.describe_table(table_name) if "Table" in resp and "TableStatus" in resp["Table"]: return resp["Table"]["TableStatus"] == "ACTIVE" return test.call_until_true(check, timeout, interval)
def test_nova_datasource_driver_flavors(self): _, flavors = self.flavors_client.list_flavors_with_detail() flavor_id_map = {} for flavor in flavors: flavor_id_map[flavor['id']] = flavor def _check_data_table_nova_flavors(): results = \ self.admin_manager.congress_policy_client.list_datasource_rows( 'nova', 'flavors') keys = ['id', 'name', 'vcpus', 'ram', 'disk', 'OS-FLV-EXT-DATA:ephemeral', 'rxtx_factor'] for row in results['results']: match = True flavor_row = flavor_id_map[row['data'][0]] for index in range(len(keys)): if row['data'][index] != flavor_row[keys[index]]: match = False break if match: return True return False if not test.call_until_true(func=_check_data_table_nova_flavors, duration=20, sleep_for=4): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_trust_subscription(self): sub_queue = data_utils.rand_name('Queues-Test') self.addCleanup(self.client.delete_queue, sub_queue) subscriber = 'trust+{0}/{1}/queues/{2}/messages'.format( self.client.base_url, self.client.uri_prefix, sub_queue) post_body = json.dumps( {'messages': [{'body': '$zaqar_message$', 'ttl': 60}]}) post_headers = {'X-Project-ID': self.client.tenant_id, 'Client-ID': str(uuid.uuid4())} sub_body = {'ttl': 1200, 'subscriber': subscriber, 'options': {'post_data': post_body, 'post_headers': post_headers}} self.create_subscription(queue_name=self.queue_name, rbody=sub_body) message_body = self.generate_message_body() self.post_messages(queue_name=self.queue_name, rbody=message_body) if not test.call_until_true( lambda: self.list_messages(sub_queue)[1]['messages'], 10, 1): self.fail("Couldn't get messages") _, body = self.list_messages(sub_queue) expected = message_body['messages'][0] expected['queue_name'] = self.queue_name expected['Message_Type'] = 'Notification' for message in body['messages']: # There are two message in the queue. One is the confirm message, # the other one is the notification. if message['body']['Message_Type'] == 'Notification': self.assertEqual(expected, message['body'])
def test_policy_basic_op(self): self._setup_network_and_servers() body = {"rule": "port_security_group(id, security_group_name) " ":-neutronv2:ports(id, tenant_id, name, network_id," "mac_address, admin_state_up, status, device_id, " "device_owner)," "neutronv2:security_group_port_bindings(id, " "security_group_id), neutronv2:security_groups(" "security_group_id, tenant_id1, security_group_name," "description)"} results = self.admin_manager.congress_client.create_policy_rule( 'classification', body) rule_id = results['id'] self.addCleanup( self.admin_manager.congress_client.delete_policy_rule, 'classification', rule_id) # Find the ports of on this server ports = self._list_ports(device_id=self.servers[0]['id']) def check_data(): results = self.admin_manager.congress_client.list_policy_rows( 'classification', 'port_security_group') for row in results['results']: if (row['data'][0] == ports[0]['id'] and row['data'][1] == self.servers[0]['security_groups'][0]['name']): return True else: return False if not test.call_until_true(func=check_data, duration=100, sleep_for=5): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_cinder_volumes_table(self): volume_schema = self.admin_manager.congress_client.show_datasource_table_schema(self.datasource_id, "volumes")[ "columns" ] volume_id_col = next(i for i, c in enumerate(volume_schema) if c["name"] == "id") def _check_data_table_cinder_volumes(): # Fetch data from cinder each time, because this test may start # before cinder has all the users. volumes = self.cinder.list_volumes() volumes_map = {} for volume in volumes: volumes_map[volume["id"]] = volume results = self.admin_manager.congress_client.list_datasource_rows(self.datasource_id, "volumes") for row in results["results"]: try: volume_row = volumes_map[row["data"][volume_id_col]] except KeyError: return False for index in range(len(volume_schema)): if str(row["data"][index]) != str(volume_row[volume_schema[index]["name"]]): return False return True if not test.call_until_true(func=_check_data_table_cinder_volumes, duration=100, sleep_for=5): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_nova_datasource_driver_servers(self): self._setup_network_and_servers() def _check_data_table_nova_servers(): results = \ self.admin_manager.congress_policy_client.list_datasource_rows( 'nova', 'servers') keys = ['id', 'name', 'hostId', 'status', 'tenant_id', 'user_id', 'image', 'flavor'] for row in results['results']: match = True for index in range(len(keys)): if keys[index] in ['image', 'flavor']: val = self.servers[0][keys[index]]['id'] else: val = self.servers[0][keys[index]] if row['data'][index] != val: match = False break if match: return True return False if not test.call_until_true(func=_check_data_table_nova_servers, duration=20, sleep_for=4): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_neutronv2_security_group_rules_table(self): sgrs_schema = ( self.admin_manager.congress_client.show_datasource_table_schema( self.datasource_id, 'security_group_rules')['columns']) def _check_data(): client = self.neutron_client security_groups_neutron = client.list_security_groups() sgrs_map = {} # security_group_rules for sg in security_groups_neutron['security_groups']: for sgr in sg['security_group_rules']: sgrs_map[sgr['id']] = sgr client = self.admin_manager.congress_client client.request_refresh(self.datasource_id) time.sleep(1) security_group_rules = ( client.list_datasource_rows( self.datasource_id, 'security_group_rules')) # Validate security_group_rules table for row in security_group_rules['results']: sg_rule_row = sgrs_map[row['data'][1]] for index in range(len(sgrs_schema)): if (str(row['data'][index]) != str(sg_rule_row[sgrs_schema[index]['name']])): return False return True if not test.call_until_true(func=_check_data, duration=200, sleep_for=10): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_nova_datasource_driver_flavors(self): def _check_data_table_nova_flavors(): # Fetch data from nova each time, because this test may start # before nova has all the users. flavors = self.flavors_client.list_flavors(detail=True) flavor_id_map = {} for flavor in flavors: flavor_id_map[flavor['id']] = flavor results = ( self.admin_manager.congress_client.list_datasource_rows( self.datasource_id, 'flavors')) # TODO(alexsyip): Not sure what the following OS-FLV-EXT-DATA: # prefix is for. keys = ['id', 'name', 'vcpus', 'ram', 'disk', 'OS-FLV-EXT-DATA:ephemeral', 'rxtx_factor'] for row in results['results']: match = True try: flavor_row = flavor_id_map[row['data'][0]] except KeyError: return False for index in range(len(keys)): if row['data'][index] != flavor_row[keys[index]]: match = False break if match: return True return False if not test.call_until_true(func=_check_data_table_nova_flavors, duration=100, sleep_for=5): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_neutronv2_security_group_rules_table(self): sgrs_schema = self.admin_manager.congress_client.show_datasource_table_schema( self.datasource_id, "security_group_rules" )["columns"] @helper.retry_on_exception def _check_data(): client = self.security_groups_client security_groups_neutron = client.list_security_groups() sgrs_map = {} # security_group_rules for sg in security_groups_neutron["security_groups"]: for sgr in sg["security_group_rules"]: sgrs_map[sgr["id"]] = sgr client = self.admin_manager.congress_client client.request_refresh(self.datasource_id) time.sleep(1) security_group_rules = client.list_datasource_rows(self.datasource_id, "security_group_rules") # Validate security_group_rules table for row in security_group_rules["results"]: sg_rule_row = sgrs_map[row["data"][1]] for index in range(len(sgrs_schema)): if str(row["data"][index]) != str(sg_rule_row[sgrs_schema[index]["name"]]): return False return True if not test.call_until_true(func=_check_data, duration=200, sleep_for=10): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_execute_basic_action_plan(self): """Execute an action plan based on the BASIC strategy - create an audit template with the basic strategy - run the audit to create an action plan - get the action plan - run the action plan - get results and make sure it succeeded """ self.addCleanup(self.rollback_compute_nodes_status) self._create_one_instance_per_host() _, goal = self.client.show_goal(self.BASIC_GOAL) _, audit_template = self.create_audit_template(goal['uuid']) _, audit = self.create_audit(audit_template['uuid']) self.assertTrue(test.call_until_true( func=functools.partial(self.has_audit_succeeded, audit['uuid']), duration=600, sleep_for=2 )) _, action_plans = self.client.list_action_plans( audit_uuid=audit['uuid']) action_plan = action_plans['action_plans'][0] _, action_plan = self.client.show_action_plan(action_plan['uuid']) # Execute the action by changing its state to PENDING _, updated_ap = self.client.update_action_plan( action_plan['uuid'], patch=[{'path': '/state', 'op': 'replace', 'value': 'PENDING'}] ) self.assertTrue(test.call_until_true( func=functools.partial( self.has_action_plan_finished, action_plan['uuid']), duration=600, sleep_for=2 )) _, finished_ap = self.client.show_action_plan(action_plan['uuid']) _, action_list = self.client.list_actions( action_plan_uuid=finished_ap["uuid"]) self.assertIn(updated_ap['state'], ('PENDING', 'ONGOING')) self.assertEqual('SUCCEEDED', finished_ap['state']) for action in action_list['actions']: self.assertEqual('SUCCEEDED', action.get('state'))
def _prepare_and_test(self, address6_mode, n_subnets6=1): self.prepare_network(address6_mode=address6_mode, n_subnets6=n_subnets6) sshv4_1, ips_from_api_1 = self.prepare_server() sshv4_2, ips_from_api_2 = self.prepare_server() def guest_has_address(ssh, addr): return addr in ssh.get_ip_list() # get addresses assigned to vNIC as reported by 'ip address' utility ips_from_ip_1 = sshv4_1.get_ip_list() ips_from_ip_2 = sshv4_2.get_ip_list() self.assertIn(ips_from_api_1['4'], ips_from_ip_1) self.assertIn(ips_from_api_2['4'], ips_from_ip_2) for i in range(n_subnets6): # v6 should be configured since the image supports it # It can take time for ipv6 automatic address to get assigned srv1_v6_addr_assigned = functools.partial( guest_has_address, sshv4_1, ips_from_api_1['6'][i]) srv2_v6_addr_assigned = functools.partial( guest_has_address, sshv4_2, ips_from_api_2['6'][i]) self.assertTrue(test.call_until_true(srv1_v6_addr_assigned, CONF.compute.ping_timeout, 1)) self.assertTrue(test.call_until_true(srv2_v6_addr_assigned, CONF.compute.ping_timeout, 1)) result = sshv4_1.ping_host(ips_from_api_2['4']) self.assertIn('0% packet loss', result) result = sshv4_2.ping_host(ips_from_api_1['4']) self.assertIn('0% packet loss', result) # Some VM (like cirros) may not have ping6 utility result = sshv4_1.exec_command('whereis ping6') is_ping6 = False if result == 'ping6:\n' else True if is_ping6: for i in range(n_subnets6): result = sshv4_1.ping_host(ips_from_api_2['6'][i]) self.assertIn('0% packet loss', result) result = sshv4_2.ping_host(ips_from_api_1['6'][i]) self.assertIn('0% packet loss', result) else: LOG.warning('Ping6 is not available, skipping')
def _wait_for_active(self, fw_id): def _wait(): _, firewall = self.client.show_firewall(fw_id) firewall = firewall["firewall"] return firewall["status"] == "ACTIVE" if not test.call_until_true(_wait, CONF.network.build_timeout, CONF.network.build_interval): m = "Timed out waiting for firewall %s to become ACTIVE." % fw_id raise exceptions.TimeoutException(m)
def _run_and_wait(self, key, data, content_type='application/json', headers=None): def wait(): return self.logs_search_client.count_search_messages(key) > 0 self.assertEqual(0, self.logs_search_client.count_search_messages(key), 'Find log message in elasticsearch: {0}'.format(key)) headers = base._get_headers(headers, content_type) data = base._get_data(data, content_type) response, _ = self.logs_client.send_single_log(data, headers) self.assertEqual(204, response.status) test.call_until_true(wait, _RETRY_COUNT, _RETRY_WAIT) response = self.logs_search_client.search_messages(key) self.assertEqual(1, len(response)) return response
def _wait_until_ready(self, fw_id): target_states = ("ACTIVE", "CREATED") def _wait(): _, firewall = self.client.show_firewall(fw_id) firewall = firewall["firewall"] return firewall["status"] in target_states if not test.call_until_true(_wait, CONF.network.build_timeout, CONF.network.build_interval): m = "Timed out waiting for firewall %s to reach %s state(s)" % (fw_id, target_states) raise exceptions.TimeoutException(m)
def _wait_for_active(self, fw_id): def _wait(): resp, firewall = self.client.show_firewall(fw_id) self.assertEqual('200', resp['status']) firewall = firewall['firewall'] return firewall['status'] == 'ACTIVE' if not test.call_until_true(_wait, CONF.network.build_timeout, CONF.network.build_interval): m = 'Timed out waiting for firewall %s to become ACTIVE.' % fw_id raise exceptions.TimeoutException(m)
def _wait_until_ready(self, fw_id): target_states = ('ACTIVE', 'CREATED') def _wait(): firewall = self.client.show_firewall(fw_id) firewall = firewall['firewall'] return firewall['status'] in target_states if not test.call_until_true(_wait, CONF.network.build_timeout, CONF.network.build_interval): m = ("Timed out waiting for firewall %s to reach %s state(s)" % (fw_id, target_states)) raise exceptions.TimeoutException(m)
def _wait_for_volume_available_on_the_system(self, ip_address, private_key): ssh = self.get_remote_client(ip_address, private_key=private_key) def _func(): part = ssh.get_partitions() LOG.debug("Partitions:%s" % part) return CONF.compute.volume_device_name in part if not test.call_until_true(_func, CONF.compute.build_timeout, CONF.compute.build_interval): raise exceptions.TimeoutException
def resource_cleanup(cls): """Ensure that all created objects get destroyed.""" try: action_plans_to_be_deleted = set() # Phase 1: Make sure all objects are in an idle state for audit_uuid in cls.created_audits: test.call_until_true( func=functools.partial( cls.is_audit_idle, audit_uuid), duration=30, sleep_for=.5 ) for audit_uuid in cls.created_action_plans_audit_uuids: _, action_plans = cls.client.list_action_plans( audit_uuid=audit_uuid) action_plans_to_be_deleted.update( ap['uuid'] for ap in action_plans['action_plans']) for action_plan in action_plans['action_plans']: test.call_until_true( func=functools.partial( cls.is_action_plan_idle, action_plan['uuid']), duration=30, sleep_for=.5 ) # Phase 2: Delete them all for action_plan_uuid in action_plans_to_be_deleted: cls.delete_action_plan(action_plan_uuid) for audit_uuid in cls.created_audits.copy(): cls.delete_audit(audit_uuid) for audit_template_uuid in cls.created_audit_templates.copy(): cls.delete_audit_template(audit_template_uuid) finally: super(BaseInfraOptimTest, cls).resource_cleanup()
def _ping_ip_address(self, ip_address): cmd = ['ping', '-c1', '-w1', ip_address] def ping(): proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) proc.wait() if proc.returncode == 0: return True # TODO(mnewby) Allow configuration of execution and sleep duration. return test.call_until_true(ping, 20, 1)
def resource_setup(cls): super(TestShowListActionPlan, cls).resource_setup() _, cls.goal = cls.client.show_goal("DUMMY") _, cls.audit_template = cls.create_audit_template(cls.goal['uuid']) _, cls.audit = cls.create_audit(cls.audit_template['uuid']) assert test.call_until_true(func=functools.partial( cls.has_audit_succeeded, cls.audit['uuid']), duration=30, sleep_for=.5) _, action_plans = cls.client.list_action_plans( audit_uuid=cls.audit['uuid']) cls.action_plan = action_plans['action_plans'][0]
def test_neutronv2_routers_tables(self): router_schema = ( self.admin_manager.congress_client.show_datasource_table_schema( self.datasource_id, 'routers')['columns']) ext_gw_info_schema = ( self.admin_manager.congress_client.show_datasource_table_schema( self.datasource_id, 'external_gateway_infos')['columns']) @helper.retry_on_exception def _check_data(): routers_from_neutron = self.routers_client.list_routers() router_map = {} for router in routers_from_neutron['routers']: router_map[router['id']] = router client = self.admin_manager.congress_client client.request_refresh(self.datasource_id) time.sleep(1) routers = (client.list_datasource_rows(self.datasource_id, 'routers')) ext_gw_info = (client.list_datasource_rows( self.datasource_id, 'external_gateway_infos')) # Validate routers table for row in routers['results']: router_row = router_map[row['data'][0]] for index in range(len(router_schema)): if (str(row['data'][index]) != str( router_row[router_schema[index]['name']])): return False # validate external_gateway_infos for row in ext_gw_info['results']: router_ext_gw_info = ( router_map[row['data'][0]]['external_gateway_info']) # populate router_id router_ext_gw_info['router_id'] = row['data'][0] for index in range(len(ext_gw_info_schema)): val = router_ext_gw_info[ext_gw_info_schema[index]['name']] if (str(row['data'][index]) != str(val)): return False return True if not test.call_until_true( func=_check_data, duration=200, sleep_for=10): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_cinder_volumes_table(self): volume_schema = ( self.admin_manager.congress_client.show_datasource_table_schema( self.datasource_id, 'volumes')['columns']) volume_id_col = next(i for i, c in enumerate(volume_schema) if c['name'] == 'id') def _check_data_table_cinder_volumes(): # Fetch data from cinder each time, because this test may start # before cinder has all the users. volumes = self.cinder.list_volumes()['volumes'] LOG.debug('cinder volume list: %s', volumes) volumes_map = {} for volume in volumes: volumes_map[volume['id']] = volume results = (self.admin_manager.congress_client.list_datasource_rows( self.datasource_id, 'volumes')) LOG.debug('congress cinder volumes table: %s', results) # check that congress and cinder return the same volume IDs rows_volume_id_set = set() for row in results['results']: rows_volume_id_set.add(row['data'][volume_id_col]) if rows_volume_id_set != frozenset(volumes_map.keys()): LOG.debug('volumes IDs mismatch') return False # FIXME(ekcs): the following code is broken because 'user_id' # and 'description' fields do not appear in results provided by # [tempest].os.volumes_client.list_volumes(). # Detailed checking disabled for now. Re-enable when fixed. # It appears the code was written for v1 volumes client but never # worked. The problem was not evident because the list of volumes # was empty. # Additional adaptation is needed for v2 volumes client. # for row in results['results']: # try: # volume_row = volumes_map[row['data'][volume_id_col]] # except KeyError: # return False # for index in range(len(volume_schema)): # if (str(row['data'][index]) != # str(volume_row[volume_schema[index]['name']])): # return False return True if not test.call_until_true(func=_check_data_table_cinder_volumes, duration=100, sleep_for=5): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def wait_ipsec_site_connection(self, site_id, status=None): def _wait(): conn = self.show_ipsec_site_connection(site_id) return conn['status'] == status try: if not test.call_until_true(_wait, CONF.network.build_timeout, CONF.network.build_interval): m = ("Timed out waiting for ipsec site connection %s " "to reach %s state" % (site_id, status)) raise exc.TimeoutException(m) return self.show_ipsec_site_connection(site_id) except exc.NotFound as ex: if status: raise ex
def wait_for_table_active(self, table_name, timeout=120, interval=1, alt=False): def check(): client = self.client if not alt else self.alt_client headers, body = client.describe_table(table_name) if "table" in body and "table_status" in body["table"]: status = body["table"]["table_status"] if status == TABLE_STATUS_CREATE_FAILED: self.fail('Table creation failure.') return body["table"]["table_status"] == TABLE_STATUS_ACTIVE return test.call_until_true(check, timeout, interval)
def test_execute_dummy_action_plan(self): _, goal = self.client.show_goal("DUMMY") _, audit_template = self.create_audit_template(goal['uuid']) _, audit = self.create_audit(audit_template['uuid']) self.assertTrue( test.call_until_true(func=functools.partial( self.has_audit_succeeded, audit['uuid']), duration=30, sleep_for=.5)) _, action_plans = self.client.list_action_plans( audit_uuid=audit['uuid']) action_plan = action_plans['action_plans'][0] _, action_plan = self.client.show_action_plan(action_plan['uuid']) # Execute the action by changing its state to PENDING _, updated_ap = self.client.update_action_plan(action_plan['uuid'], patch=[{ 'path': '/state', 'op': 'replace', 'value': 'PENDING' }]) self.assertTrue( test.call_until_true(func=functools.partial( self.has_action_plan_finished, action_plan['uuid']), duration=30, sleep_for=.5)) _, finished_ap = self.client.show_action_plan(action_plan['uuid']) self.assertIn(updated_ap['state'], ('PENDING', 'ONGOING')) self.assertEqual('SUCCEEDED', finished_ap['state'])
def create_and_add_security_group_to_server(self, server): secgroup = self._create_security_group() self.servers_client.add_security_group(server['id'], secgroup['name']) self.addCleanup(self.servers_client.remove_security_group, server['id'], secgroup['name']) def wait_for_secgroup_add(): body = (self.servers_client.show_server(server['id'])['server']) return {'name': secgroup['name']} in body['security_groups'] if not test.call_until_true(wait_for_secgroup_add, CONF.compute.build_timeout, CONF.compute.build_interval): msg = ('Timed out waiting for adding security group %s to server ' '%s' % (secgroup['id'], server['id'])) raise exceptions.TimeoutException(msg)
def call_until_valid(self, func, duration, *args, **kwargs): # Call until get valid response for "duration" # because tenant usage doesn't become available immediately # after create VM. def is_valid(): try: self.resp = func(*args, **kwargs) return True except e.InvalidHTTPResponseBody: return False self.assertEqual( test.call_until_true(is_valid, duration, 1), True, "%s not return valid response in %s secs" % (func.__name__, duration)) return self.resp
def wait_for_table_deleted(self, table_name, timeout=120, interval=1, alt=False): def check(): client = self.client if not alt else self.alt_client try: headers, body = client.describe_table(table_name) if "table" in body and "table_status" in body["table"]: status = body["table"]["table_status"] if status == TABLE_STATUS_DELETE_FAILED: self.fail('Table deletion failure.') except exceptions.NotFound: return True return test.call_until_true(check, timeout, interval)
def wait_for_node(self, node_name): def check_node(): try: self.node_show(node_name) except lib_exc.NotFound: return False return True if not test.call_until_true( check_node, duration=CONF.baremetal_introspection.discovery_timeout, sleep_for=20): msg = ("Timed out waiting for node %s " % node_name) raise lib_exc.TimeoutException(msg) inspected_node = self.node_show(self.node_info['name']) self.wait_for_introspection_finished(inspected_node['uuid'])
def test_create_action_plan(self): _, audit_template = self.create_audit_template() _, audit = self.create_audit(audit_template['uuid']) self.assertTrue(test.call_until_true( func=functools.partial(self.has_audit_succeeded, audit['uuid']), duration=30, sleep_for=.5 )) _, action_plans = self.client.list_action_plans( audit_uuid=audit['uuid']) action_plan = action_plans['action_plans'][0] _, action_plan = self.client.show_action_plan(action_plan['uuid']) self.assertEqual(audit['uuid'], action_plan['audit_uuid']) self.assertEqual('RECOMMENDED', action_plan['state'])
def test_all_loaded_datasources_are_initialized(self): datasources = self.admin_manager.congress_client.list_datasources() def _check_all_datasources_are_initialized(): for datasource in datasources['results']: results = ( self.admin_manager.congress_client.list_datasource_status( datasource['id'])) if results['initialized'] != 'True': return False return True if not test.call_until_true( func=_check_all_datasources_are_initialized, duration=20, sleep_for=4): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def create_action_plan(cls, audit_template_uuid, **audit_kwargs): """Wrapper utility for creating a test action plan :param audit_template_uuid: Audit template UUID to use :param audit_kwargs: Dict of audit properties to set :return: The action plan as dict """ _, audit = cls.create_audit(audit_template_uuid, **audit_kwargs) audit_uuid = audit['uuid'] assert test.call_until_true(func=functools.partial( cls.has_audit_succeeded, audit_uuid), duration=30, sleep_for=.5) _, action_plans = cls.client.list_action_plans(audit_uuid=audit_uuid) return action_plans['action_plans'][0]
def test_all_datasources_have_tables(self): datasources = self.admin_manager.congress_client.list_datasources() def check_data(): for datasource in datasources['results']: results = ( self.admin_manager.congress_client.list_datasource_tables( datasource['id'])) # NOTE(arosen): if there are no results here we return false as # there is something wrong with a driver as it doesn't expose # any tables. if not results['results']: return False return True if not test.call_until_true(func=check_data, duration=20, sleep_for=4): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def _test_remote_connectivity(self, source, dest, should_succeed=True): """ check ping server via source ssh connection :param source: RemoteClient: an ssh connection from which to ping :param dest: and IP to ping against :param should_succeed: boolean should ping succeed or not :returns: boolean -- should_succeed == ping :returns: ping is false if ping failed """ def ping_remote(): try: source.ping_host(dest) except exceptions.SSHExecCommandFailed as ex: LOG.debug(ex) return not should_succeed return should_succeed return call_until_true(ping_remote, CONF.compute.ping_timeout, 1)
def test_glancev2_images_table(self): image_schema = ( self.admin_manager.congress_client.show_datasource_table_schema( 'glancev2', 'images')['columns']) image_id_col = next(i for i, c in enumerate(image_schema) if c['name'] == 'id') def _check_data_table_glancev2_images(): # Fetch data from glance each time, because this test may start # before glance has all the users. images = self.glancev2.image_list() image_map = {} for image in images: image_map[image['id']] = image results = (self.admin_manager.congress_client.list_datasource_rows( 'glancev2', 'images')) for row in results['results']: try: image_row = image_map[row['data'][image_id_col]] except KeyError: return False for index in range(len(image_schema)): # glancev2 doesn't return kernel_id/ramdisk_id if # it isn't present... if ((image_schema[index]['name'] == 'kernel_id' and 'kernel_id' not in row['data']) or (image_schema[index]['name'] == 'ramdisk_id' and 'ramdisk_id' not in row['data'])): continue # FIXME(arosen): congress-server should retain the type # but doesn't today. if (str(row['data'][index]) != str( image_row[image_schema[index]['name']])): return False return True if not test.call_until_true(func=_check_data_table_glancev2_images, duration=20, sleep_for=4): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_delete_action_plan(self): _, audit_template = self.create_audit_template() _, audit = self.create_audit(audit_template['uuid']) self.assertTrue(test.call_until_true( func=functools.partial(self.has_audit_succeeded, audit['uuid']), duration=30, sleep_for=.5 )) _, action_plans = self.client.list_action_plans( audit_uuid=audit['uuid']) action_plan = action_plans['action_plans'][0] _, action_plan = self.client.show_action_plan(action_plan['uuid']) self.client.delete_action_plan(action_plan['uuid']) self.assertRaises(lib_exc.NotFound, self.client.show_action_plan, action_plan['uuid'])
def test_nova_datasource_driver_servers(self): self._setup_network_and_servers() server_schema = ( self.admin_manager.congress_client.show_datasource_table_schema( self.datasource_id, 'servers')['columns']) # Convert some of the column names. def convert_col(col): if col == 'host_id': return 'hostId' elif col == 'image_id': return 'image' elif col == 'flavor_id': return 'flavor' else: return col keys = [convert_col(c['name']) for c in server_schema] def _check_data_table_nova_servers(): results = ( self.admin_manager.congress_client.list_datasource_rows( self.datasource_id, 'servers')) for row in results['results']: match = True for index in range(len(keys)): if keys[index] in ['image', 'flavor']: val = self.servers[0][keys[index]]['id'] else: val = self.servers[0][keys[index]] if row['data'][index] != val: match = False break if match: return True return False if not test.call_until_true(func=_check_data_table_nova_servers, duration=20, sleep_for=4): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def verify_metadata(self): if self.run_ssh and CONF.compute_feature_enabled.metadata_service: # Verify metadata service md_url = 'http://169.254.169.254/latest/meta-data/public-ipv4' def exec_cmd_and_verify_output(): cmd = 'curl ' + md_url result = self.ssh_client.exec_command(cmd) if result: msg = ('Failed while verifying metadata on server. Result ' 'of command "%s" is NOT "%s".' % (cmd, self.fip)) self.assertEqual(self.fip, result, msg) return 'Verification is successful!' if not test.call_until_true(exec_cmd_and_verify_output, CONF.compute.build_timeout, CONF.compute.build_interval): raise exceptions.TimeoutException('Timed out while waiting to ' 'verify metadata on server. ' '%s is empty.' % md_url)
def wait_for_compute_node_setup(cls): def _are_compute_nodes_setup(): try: hypervisors_client = cls.mgr.hypervisor_client hypervisors = hypervisors_client.list_hypervisors( detail=True)['hypervisors'] available_hypervisors = set(hyp['hypervisor_hostname'] for hyp in hypervisors) available_services = set( service['host'] for service in cls.get_compute_nodes_setup()) return (available_hypervisors == available_services and len(hypervisors) >= 2) except Exception: return False assert test.call_until_true(func=_are_compute_nodes_setup, duration=600, sleep_for=2)
def test_delete_action_plan(self): _, goal = self.client.show_goal("dummy") _, audit_template = self.create_audit_template(goal['uuid']) _, audit = self.create_audit(audit_template['uuid']) self.assertTrue(test.call_until_true( func=functools.partial(self.has_audit_finished, audit['uuid']), duration=30, sleep_for=.5 )) _, action_plans = self.client.list_action_plans( audit_uuid=audit['uuid']) action_plan = action_plans['action_plans'][0] _, action_plan = self.client.show_action_plan(action_plan['uuid']) self.client.delete_action_plan(action_plan['uuid']) self.assertRaises(exceptions.NotFound, self.client.show_action_plan, action_plan['uuid'])
def _confirm_notifications(self, container_name, obj_name): """ Loop seeking for appropriate notifications about the containers and objects sent to swift. """ def _check_samples(): """ Return True only if we have notifications about some containers and some objects and the notifications are about the expected containers and objects. Otherwise returning False will case _check_samples to be called again. """ results = self.telemetry_client.list_samples( 'storage.api.request') LOG.debug('got samples %s', results) # Extract container info from samples. containers, objects = [], [] for sample in results: meta = sample['resource_metadata'] if meta.get('container') and meta['container'] != 'None': containers.append(meta['container']) elif (meta.get('target.metadata:container') and meta['target.metadata:container'] != 'None'): containers.append(meta['target.metadata:container']) if meta.get('object') and meta['object'] != 'None': objects.append(meta['object']) elif (meta.get('target.metadata:object') and meta['target.metadata:object'] != 'None'): objects.append(meta['target.metadata:object']) return (container_name in containers and obj_name in objects) self.assertTrue(test.call_until_true(_check_samples, NOTIFICATIONS_WAIT, NOTIFICATIONS_SLEEP), 'Correct notifications were not received after ' '%s seconds.' % NOTIFICATIONS_WAIT)
def _check_remote_connectivity(self, source, dest, should_succeed=True): """check ping server via source ssh connection :param source: RemoteClient: an ssh connection from which to ping :param dest: and IP to ping against :param should_succeed: boolean should ping succeed or not :returns: boolean -- should_succeed == ping :returns: ping is false if ping failed """ def ping_remote(): try: self.ping_host(source, dest) except lib_exc.SSHExecCommandFailed: LOG.warning(_LW('Failed to ping IP: %(dest)s ' 'via a ssh connection from: %(source)s.'), {'dest': dest, 'source': source}) return not should_succeed return should_succeed return test.call_until_true(ping_remote, CONF.validation.ping_timeout, 1)
def test_keystone_users_table(self): user_schema = ( self.admin_manager.congress_client.show_datasource_table_schema( self.datasource_id, 'users')['columns']) user_id_col = next(i for i, c in enumerate(user_schema) if c['name'] == 'id') def _check_data_table_keystone_users(): # Fetch data from keystone each time, because this test may start # before keystone has all the users. users = self.users_client.list_users()['users'] user_map = {} for user in users: user_map[user['id']] = user results = (self.admin_manager.congress_client.list_datasource_rows( self.datasource_id, 'users')) for row in results['results']: try: user_row = user_map[row['data'][user_id_col]] except KeyError: return False for index in range(len(user_schema)): if ((user_schema[index]['name'] == 'tenantId' and 'tenantId' not in user_row) or (user_schema[index]['name'] == 'email' and 'email' not in user_row)): # Keystone does not return the tenantId or email column # if not present. pass elif (str(row['data'][index]) != str( user_row[user_schema[index]['name']])): return False return True if not test.call_until_true(func=_check_data_table_keystone_users, duration=100, sleep_for=4): raise exceptions.TimeoutException("Data did not converge in time " "or failure in server")
def test_trust_subscription(self): sub_queue = data_utils.rand_name('Queues-Test') self.addCleanup(self.client.delete_queue, sub_queue) subscriber = 'trust+{0}/{1}/queues/{2}/messages'.format( self.client.base_url, self.client.uri_prefix, sub_queue) post_body = json.dumps( {'messages': [{ 'body': '$zaqar_message$', 'ttl': 60 }]}) post_headers = { 'X-Project-ID': self.client.tenant_id, 'Client-ID': str(uuid.uuid4()) } sub_body = { 'ttl': 1200, 'subscriber': subscriber, 'options': { 'post_data': post_body, 'post_headers': post_headers } } self.create_subscription(queue_name=self.queue_name, rbody=sub_body) message_body = self.generate_message_body() self.post_messages(queue_name=self.queue_name, rbody=message_body) if not test.call_until_true( lambda: self.list_messages(sub_queue)[1]['messages'], 10, 1): self.fail("Couldn't get messages") _, body = self.list_messages(sub_queue) expected = message_body['messages'][0] expected['queue_name'] = self.queue_name expected['Message_Type'] = 'Notification' for message in body['messages']: # There are two message in the queue. One is the confirm message, # the other one is the notification. if message['body']['Message_Type'] == 'Notification': self.assertEqual(expected, message['body'])
def test_net_ip_availability_after_port_delete(self): net_name = data_utils.rand_name('network-') network = self.create_network(network_name=net_name) self.addCleanup(self.client.delete_network, network['id']) subnet, prefix = self._create_subnet(network, self.ip_version) self.addCleanup(self.client.delete_subnet, subnet['id']) port = self.client.create_port(network_id=network['id']) self.addCleanup(self._cleanUp_port, port['port']['id']) net_availability = self.admin_client.list_network_ip_availabilities() used_ip = self._get_used_ips(network, net_availability) self.client.delete_port(port['port']['id']) def get_net_availability(): availabilities = self.admin_client.list_network_ip_availabilities() used_ip_after_port_delete = self._get_used_ips( network, availabilities) return used_ip - 1 == used_ip_after_port_delete self.assertTrue( test.call_until_true(get_net_availability, DELETE_TIMEOUT, DELETE_SLEEP), msg="IP address did not become available after port delete")