def delete_router_interfaces(cmgr, router, and_attached_resources=False): if type(router) is not dict: router = cmgr.qsvc('router-show', router) ports = cmgr.qsvc('router-port-list', router['id']) for port in ports: if port['device_owner'].find(':router_interface') > 0: if 'fixed_ips' in port: for fixed_ips in port['fixed_ips']: if 'subnet_id' in fixed_ips: sv_port_list = cmgr.qsvc( "port-list", network_id=port['network_id'], device_owner="compute:None") for sv_port in sv_port_list: try: sv = cmgr.nova("server-show", sv_port['device_id']) cmgr.nova("server-delete", sv['id']) waiters.wait_for_server_termination( cmgr.manager.servers_client, sv['id']) except: pass cmgr.qsvc('router-interface-delete', router['id'], fixed_ips['subnet_id'])
def resource_cleanup(cls): # Delete the test instance cls.servers_client.delete_server(cls.server['id']) waiters.wait_for_server_termination(cls.servers_client, cls.server['id']) super(VolumesV2ActionsTest, cls).resource_cleanup()
def cleanup(self): """Cleanup the underlying instance. In order for the back-end to be useful again, call :meth:`setup_instance` method for preparing another underlying instance. """ LOG.info("Cleaning up...") if self._security_groups_rules: for rule in self._security_groups_rules: (self._manager.security_group_rules_client. delete_security_group_rule(rule)) if self._security_group: self._manager.servers_client.remove_security_group( server_id=self.internal_instance_id(), name=self._security_group['name']) if self._server: self._manager.servers_client.delete_server( self.internal_instance_id()) waiters.wait_for_server_termination( self._manager.servers_client, self.internal_instance_id()) if self._floating_ip: self._manager.floating_ips_client.delete_floating_ip( self._floating_ip['id']) if self._keypair: self._keypair.destroy() self._manager.cleanup_credentials()
def test_preserve_preexisting_port(self): """Tests that a pre-existing port provided on server boot is not deleted if the server is deleted. Nova should unbind the port from the instance on delete if the port was not created by Nova as part of the boot request. """ # Setup the network, create a port and boot the server from that port. self._setup_network_and_servers(boot_with_port=True) _, server = self.floating_ip_tuple self.assertEqual(1, len(self.ports), 'There should only be one port created for ' 'server %s.' % server['id']) port_id = self.ports[0]['port'] self.assertIsNotNone(port_id, 'Server should have been created from a ' 'pre-existing port.') # Assert the port is bound to the server. port_list = self._list_ports(device_id=server['id'], network_id=self.network['id']) self.assertEqual(1, len(port_list), 'There should only be one port created for ' 'server %s.' % server['id']) self.assertEqual(port_id, port_list[0]['id']) # Delete the server. self.servers_client.delete_server(server['id']) waiters.wait_for_server_termination(self.servers_client, server['id']) # Assert the port still exists on the network but is unbound from # the deleted server. port = self.ports_client.show_port(port_id)['port'] self.assertEqual(self.network['id'], port['network_id']) self.assertEqual('', port['device_id']) self.assertEqual('', port['device_owner'])
def test_delete_server_while_in_shutoff_state(self): # Delete a server while it's VM state is Shutoff server = self.create_test_server(wait_until='ACTIVE') self.client.stop_server(server['id']) waiters.wait_for_server_status(self.client, server['id'], 'SHUTOFF') self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id'])
def tearDown(self): if self.vip_fip: LOG.debug("tearDown lbass vip fip") self.disassociate_floatingip(self.vip_fip, and_delete=True) if self.loadbalancer: LOG.debug("tearDown lbass") lb_id = self.loadbalancer['id'] self.delete_loadbalancer_resources(lb_id) # make sure servers terminated before teardown network resources LOG.debug("tearDown lbaas servers") server_id_list = [] for servid in ['server1', 'server2']: server = getattr(self, servid, None) if server: if '_floating_ip' in server: fip = server['_floating_ip'] self.disassociate_floatingip(fip, and_delete=True) self.manager.servers_client.delete_server(server['id']) server_id_list.append(server['id']) for server_id in server_id_list: waiters.wait_for_server_termination( self.manager.servers_client, server_id) # delete lbaas network before handing back to framework LOG.debug("tearDown lbaas network") self.delete_wrapper(self.router.delete) self.delete_wrapper(self.subnet.delete) self.delete_wrapper(self.network.delete) super(TestLBaasRoundRobinOps, self).tearDown() LOG.debug("tearDown lbaas exiting...")
def test_delete_server_while_in_pause_state(self): # Delete a server while it's VM state is Pause server = self.create_test_server(wait_until='ACTIVE') self.client.pause_server(server['id']) waiters.wait_for_server_status(self.client, server['id'], 'PAUSED') self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id'])
def test_delete_server_while_in_suspended_state(self): # Delete a server while it's VM state is Suspended server = self.create_test_server(wait_until='ACTIVE') self.client.suspend_server(server['id']) waiters.wait_for_server_status(self.client, server['id'], 'SUSPENDED') self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id'])
def test_delete_server_while_in_shelved_state(self): # Delete a server while it's VM state is Shelved server = self.create_test_server(wait_until='ACTIVE') compute.shelve_server(self.client, server['id']) self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id'])
def delete_server(cls, server_id): """Deletes an existing server and waits for it to be gone.""" try: cls.servers_client.delete_server(server_id) waiters.wait_for_server_termination(cls.servers_client, server_id) except Exception: LOG.exception("Failed to delete server %s" % server_id)
def test_reboot_deleted_server(self): # Reboot a deleted server server = self.create_test_server() self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id']) self.assertRaises(lib_exc.NotFound, self.client.reboot_server, server['id'], type='SOFT')
def test_delete_server_while_in_verify_resize_state(self): # Delete a server while it's VM state is VERIFY_RESIZE server = self.create_test_server(wait_until='ACTIVE') self.client.resize_server(server['id'], self.flavor_ref_alt) waiters.wait_for_server_status(self.client, server['id'], 'VERIFY_RESIZE') self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id'])
def resource_setup(cls): super(ServersNegativeTestJSON, cls).resource_setup() server = cls.create_test_server(wait_until='ACTIVE') cls.server_id = server['id'] server = cls.create_test_server() cls.client.delete_server(server['id']) waiters.wait_for_server_termination(cls.client, server['id']) cls.deleted_server_id = server['id']
def test_rebuild_deleted_server(self): # Rebuild a deleted server server = self.create_test_server() self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id']) self.assertRaises(lib_exc.NotFound, self.client.rebuild_server, server['id'], self.image_ref_alt)
def test_delete_server_while_in_attached_volume(self): # Delete a server while a volume is attached to it server = self.create_test_server(wait_until='ACTIVE') volume = self.create_volume() self.attach_volume(server, volume) self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id']) waiters.wait_for_volume_resource_status(self.volumes_client, volume['id'], 'available')
def test_get_list_deleted_instance_actions(self): # List actions of the deleted server server = self.create_test_server(wait_until='ACTIVE') self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id']) body = (self.client.list_instance_actions(server['id']) ['instanceActions']) self.assertEqual(len(body), 2, str(body)) self.assertEqual(sorted([i['action'] for i in body]), ['create', 'delete'])
def resource_cleanup(cls): for server in cls.servers: cls.manager.servers_client.delete_server(server) waiters.wait_for_server_termination(cls.manager.servers_client, server) for keypair in cls.keypairs: cls.manager.keypairs_client.delete_keypair( keypair_name=keypair['name']) super(BaseTempestTestCase, cls).resource_cleanup()
def test_create_image_from_deleted_server(self): # An image should not be created if the server instance is removed server = self.create_test_server(wait_until="ACTIVE") # Delete server before trying to create server self.servers_client.delete_server(server["id"]) waiters.wait_for_server_termination(self.servers_client, server["id"]) # Create a new image after server is deleted name = data_utils.rand_name("image") meta = {"image_type": "test"} self.assertRaises(lib_exc.NotFound, self.create_image_from_server, server["id"], name=name, meta=meta)
def test_delete_server_while_in_error_state(self): # Delete a server while it's VM state is error server = self.create_test_server(wait_until='ACTIVE') self.admin_client.reset_state(server['id'], state='error') # Verify server's state server = self.non_admin_client.show_server(server['id'])['server'] self.assertEqual(server['status'], 'ERROR') self.non_admin_client.delete_server(server['id']) waiters.wait_for_server_termination(self.servers_client, server['id'], ignore_error=True)
def teardown_mtz_simple(cmgr, router, net_id_servers, sg): server_list = [] for net_id, server in net_id_servers.items(): server_id = server['server']['id'] cmgr.nova('server-delete', server_id) server_list.append(server_id) # wait for all servers go away for server_id in server_list: waiters.wait_for_server_termination(cmgr.manager.servers_client, server_id) NET.delete_this_router(cmgr.manager, router) cmgr.qsvc('security-group-delete', sg['id'])
def rebuild_server(cls, server_id, validatable=False, **kwargs): # Destroy an existing server and creates a new one if server_id: try: cls.servers_client.delete_server(server_id) waiters.wait_for_server_termination(cls.servers_client, server_id) except Exception: LOG.exception("Failed to delete server %s" % server_id) server = cls.create_test_server(validatable, wait_until="ACTIVE", **kwargs) cls.password = server["adminPass"] return server["id"]
def test_delete_server_while_in_attached_volume(self): # Delete a server while a volume is attached to it device = '/dev/%s' % CONF.compute.volume_device_name server = self.create_test_server(wait_until='ACTIVE') volume = self.create_volume() self.attach_volume(server, volume, device=device) self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id']) waiters.wait_for_volume_status(self.volumes_client, volume['id'], 'available')
def test_create_image_from_deleted_server(self): # An image should not be created if the server instance is removed server = self.create_test_server(wait_until='ACTIVE') # Delete server before trying to create image self.servers_client.delete_server(server['id']) waiters.wait_for_server_termination(self.servers_client, server['id']) # Create a new image after server is deleted meta = {'image_type': 'test'} self.assertRaises(lib_exc.NotFound, self.create_image_from_server, server['id'], metadata=meta)
def resource_setup(cls): super(ListServersNegativeTestJSON, cls).resource_setup() # The following servers are created for use # by the test methods in this class. These # servers are cleaned up automatically in the # tearDownClass method of the super-class. body = cls.create_test_server(wait_until='ACTIVE', min_count=3) # delete one of the created servers cls.deleted_id = body['server']['id'] cls.client.delete_server(cls.deleted_id) waiters.wait_for_server_termination(cls.client, cls.deleted_id)
def teardown_lb_servers(cmgr, env_cfg, **kwargs): E = env_cfg server_list = [x['id'] for x in (E['server1'], E['server2'])] for obj_id in server_list: cmgr.nova('server-delete-silent', obj_id) # make sure all servers are terminated. for obj_id in server_list: waiters.wait_for_server_termination(cmgr.manager.servers_client, obj_id) for obj in (E['fip1'], E['fip2']): cmgr.qsvc('floatingip-delete', obj['id']) NET.delete_this_router(cmgr, E['router']) cmgr.qsvc('net-delete', E['network']['id'])
def test_create_image_from_deleted_server(self): # An image should not be created if the server instance is removed server = self.create_test_server(wait_until='ACTIVE', availability_zone=CONF.compute.default_availability_zone) # Delete server before trying to create server self.servers_client.delete_server(server['id']) waiters.wait_for_server_termination(self.servers_client, server['id']) # Create a new image after server is deleted name = data_utils.rand_name('image') meta = {'image_type': 'test'} self.assertRaises(lib_exc.NotFound, self.create_image_from_server, server['id'], name=name, meta=meta)
def run(self): name = data_utils.rand_name("instance") self.logger.info("creating %s" % name) server = self.manager.servers_client.create_server( name, self.image, self.flavor)['server'] server_id = server['id'] waiters.wait_for_server_status(self.manager.servers_client, server_id, 'ACTIVE') self.logger.info("created %s" % server_id) self.logger.info("deleting %s" % name) self.manager.servers_client.delete_server(server_id) waiters.wait_for_server_termination(self.manager.servers_client, server_id) self.logger.info("deleted %s" % server_id)
def destroy_servers(servers): if not servers: return LOG.info("Destroying servers") for server in servers: client = client_for_user(server["owner"]) response = _get_server_by_name(client, server["name"]) if not response: LOG.info("Server '%s' does not exist" % server["name"]) continue # TODO(EmilienM): disassociate floating IP from server and release it. client.servers.delete_server(response["id"]) waiters.wait_for_server_termination(client.servers, response["id"], ignore_error=True)
def test_delete_server_while_in_shelved_state(self): # Delete a server while it's VM state is Shelved server = self.create_test_server(wait_until='ACTIVE') self.client.shelve_server(server['id']) offload_time = CONF.compute.shelved_offload_time if offload_time >= 0: waiters.wait_for_server_status(self.client, server['id'], 'SHELVED_OFFLOADED', extra_timeout=offload_time) else: waiters.wait_for_server_status(self.client, server['id'], 'SHELVED') self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id'])
def test_server_basic_ops(self): keypair = self.create_keypair() security_group = self._create_security_group() self.md = {'meta1': 'data1', 'meta2': 'data2', 'metaN': 'dataN'} self.instance = self.create_server( key_name=keypair['name'], security_groups=[{'name': security_group['name']}], config_drive=CONF.compute_feature_enabled.config_drive, metadata=self.md) self.verify_ssh(keypair) self.verify_metadata() self.verify_metadata_on_config_drive() self.verify_networkdata_on_config_drive() self.servers_client.delete_server(self.instance['id']) waiters.wait_for_server_termination( self.servers_client, self.instance['id'], ignore_error=False)
def _destroy_vm(self): self.logger.info("deleting %s" % self.server_id) self.manager.servers_client.delete_server(self.server_id) waiters.wait_for_server_termination(self.manager.servers_client, self.server_id) self.logger.info("deleted %s" % self.server_id)
def test_delete_server(self): server = self.create_test_server(wait_until='ACTIVE') self.rbac_utils.switch_role(self, toggle_rbac_role=True) self.servers_client.delete_server(server['id']) waiters.wait_for_server_termination(self.servers_client, server['id'])
def create_test_server(clients, validatable=False, validation_resources=None, tenant_network=None, wait_until=None, volume_backed=False, name=None, flavor=None, image_id=None, **kwargs): """Common wrapper utility returning a test server. This method is a common wrapper returning a test server that can be pingable or sshable. :param clients: Client manager which provides OpenStack Tempest clients. :param validatable: Whether the server will be pingable or sshable. :param validation_resources: Resources created for the connection to the server. Include a keypair, a security group and an IP. :param tenant_network: Tenant network to be used for creating a server. :param wait_until: Server status to wait for the server to reach after its creation. :param volume_backed: Whether the server is volume backed or not. If this is true, a volume will be created and create server will be requested with 'block_device_mapping_v2' populated with below values: .. code-block:: python bd_map_v2 = [{ 'uuid': volume['volume']['id'], 'source_type': 'volume', 'destination_type': 'volume', 'boot_index': 0, 'delete_on_termination': True}] kwargs['block_device_mapping_v2'] = bd_map_v2 If server needs to be booted from volume with other combination of bdm inputs than mentioned above, then pass the bdm inputs explicitly as kwargs and image_id as empty string (''). :param name: Name of the server to be provisioned. If not defined a random string ending with '-instance' will be generated. :param flavor: Flavor of the server to be provisioned. If not defined, CONF.compute.flavor_ref will be used instead. :param image_id: ID of the image to be used to provision the server. If not defined, CONF.compute.image_ref will be used instead. :returns: a tuple """ # TODO(jlanoux) add support of wait_until PINGABLE/SSHABLE if name is None: name = data_utils.rand_name(__name__ + "-instance") if flavor is None: flavor = CONF.compute.flavor_ref if image_id is None: image_id = CONF.compute.image_ref kwargs = fixed_network.set_networks_kwarg(tenant_network, kwargs) or {} multiple_create_request = (max(kwargs.get('min_count', 0), kwargs.get('max_count', 0)) > 1) if CONF.validation.run_validation and validatable: # As a first implementation, multiple pingable or sshable servers will # not be supported if multiple_create_request: msg = ("Multiple pingable or sshable servers not supported at " "this stage.") raise ValueError(msg) LOG.debug("Provisioning test server with validation resources %s", validation_resources) if 'security_groups' in kwargs: kwargs['security_groups'].append( {'name': validation_resources['security_group']['name']}) else: try: kwargs['security_groups'] = [{ 'name': validation_resources['security_group']['name'] }] except KeyError: LOG.debug("No security group provided.") if 'key_name' not in kwargs: try: kwargs['key_name'] = validation_resources['keypair']['name'] except KeyError: LOG.debug("No key provided.") if CONF.validation.connect_method == 'floating': if wait_until is None: wait_until = 'ACTIVE' if 'user_data' not in kwargs: # If nothing overrides the default user data script then run # a simple script on the host to print networking info. This is # to aid in debugging ssh failures. script = ''' #!/bin/sh echo "Printing {user} user authorized keys" cat ~{user}/.ssh/authorized_keys || true '''.format(user=CONF.validation.image_ssh_user) script_clean = textwrap.dedent(script).lstrip().encode('utf8') script_b64 = base64.b64encode(script_clean) kwargs['user_data'] = script_b64 if volume_backed: volume_name = data_utils.rand_name(__name__ + '-volume') volumes_client = clients.volumes_client_latest params = { 'name': volume_name, 'imageRef': image_id, 'size': CONF.volume.volume_size } if CONF.compute.compute_volume_common_az: params.setdefault('availability_zone', CONF.compute.compute_volume_common_az) volume = volumes_client.create_volume(**params) try: waiters.wait_for_volume_resource_status(volumes_client, volume['volume']['id'], 'available') except Exception: with excutils.save_and_reraise_exception(): try: volumes_client.delete_volume(volume['volume']['id']) volumes_client.wait_for_resource_deletion( volume['volume']['id']) except Exception as exc: LOG.exception("Deleting volume %s failed, exception %s", volume['volume']['id'], exc) bd_map_v2 = [{ 'uuid': volume['volume']['id'], 'source_type': 'volume', 'destination_type': 'volume', 'boot_index': 0, 'delete_on_termination': True }] kwargs['block_device_mapping_v2'] = bd_map_v2 # Since this is boot from volume an image does not need # to be specified. image_id = '' if CONF.compute.compute_volume_common_az: kwargs.setdefault('availability_zone', CONF.compute.compute_volume_common_az) body = clients.servers_client.create_server(name=name, imageRef=image_id, flavorRef=flavor, **kwargs) # handle the case of multiple servers if multiple_create_request: # Get servers created which name match with name param. body_servers = clients.servers_client.list_servers() servers = \ [s for s in body_servers['servers'] if s['name'].startswith(name)] else: body = rest_client.ResponseBody(body.response, body['server']) servers = [body] def _setup_validation_fip(): if CONF.service_available.neutron: ifaces = clients.interfaces_client.list_interfaces(server['id']) validation_port = None for iface in ifaces['interfaceAttachments']: if iface['net_id'] == tenant_network['id']: validation_port = iface['port_id'] break if not validation_port: # NOTE(artom) This will get caught by the catch-all clause in # the wait_until loop below raise ValueError('Unable to setup floating IP for validation: ' 'port not found on tenant network') clients.floating_ips_client.update_floatingip( validation_resources['floating_ip']['id'], port_id=validation_port) else: fip_client = clients.compute_floating_ips_client fip_client.associate_floating_ip_to_server( floating_ip=validation_resources['floating_ip']['ip'], server_id=servers[0]['id']) if wait_until: for server in servers: try: waiters.wait_for_server_status(clients.servers_client, server['id'], wait_until) # Multiple validatable servers are not supported for now. Their # creation will fail with the condition above. if CONF.validation.run_validation and validatable: if CONF.validation.connect_method == 'floating': _setup_validation_fip() except Exception: with excutils.save_and_reraise_exception(): for server in servers: try: clients.servers_client.delete_server(server['id']) except Exception: LOG.exception('Deleting server %s failed', server['id']) for server in servers: # NOTE(artom) If the servers were booted with volumes # and with delete_on_termination=False we need to wait # for the servers to go away before proceeding with # cleanup, otherwise we'll attempt to delete the # volumes while they're still attached to servers that # are in the process of being deleted. try: waiters.wait_for_server_termination( clients.servers_client, server['id']) except Exception: LOG.exception('Server %s failed to delete in time', server['id']) return body, servers
def wait_for_server_termination(cls, server_id): waiters.wait_for_server_termination(cls.servers_client, server_id)
def cleanup(): admin_manager = clients.AdminManager() body = admin_manager.servers_client.list_servers(all_tenants=True) LOG.info("Cleanup::remove %s servers" % len(body['servers'])) for s in body['servers']: try: admin_manager.servers_client.delete_server(s['id']) except Exception: pass for s in body['servers']: try: waiters.wait_for_server_termination(admin_manager.servers_client, s['id']) except Exception: pass keypairs = admin_manager.keypairs_client.list_keypairs()['keypairs'] LOG.info("Cleanup::remove %s keypairs" % len(keypairs)) for k in keypairs: try: admin_manager.keypairs_client.delete_keypair(k['name']) except Exception: pass secgrp_client = admin_manager.security_groups_client secgrp = (secgrp_client.list_security_groups( all_tenants=True)['security_groups']) secgrp_del = [grp for grp in secgrp if grp['name'] != 'default'] LOG.info("Cleanup::remove %s Security Group" % len(secgrp_del)) for g in secgrp_del: try: secgrp_client.delete_security_group(g['id']) except Exception: pass floating_ips = ( admin_manager.floating_ips_client.list_floating_ips()['floating_ips']) LOG.info("Cleanup::remove %s floating ips" % len(floating_ips)) for f in floating_ips: try: admin_manager.floating_ips_client.delete_floating_ip(f['id']) except Exception: pass users = admin_manager.identity_client.get_users() LOG.info("Cleanup::remove %s users" % len(users)) for user in users: if user['name'].startswith("stress_user"): admin_manager.identity_client.delete_user(user['id']) tenants = admin_manager.identity_client.list_tenants()['tenants'] LOG.info("Cleanup::remove %s tenants" % len(tenants)) for tenant in tenants: if tenant['name'].startswith("stress_tenant"): admin_manager.identity_client.delete_tenant(tenant['id']) # We have to delete snapshots first or # volume deletion may block _, snaps = admin_manager.snapshots_client.list_snapshots( params={"all_tenants": True})['snapshots'] LOG.info("Cleanup::remove %s snapshots" % len(snaps)) for v in snaps: try: admin_manager.snapshots_client.\ wait_for_snapshot_status(v['id'], 'available') admin_manager.snapshots_client.delete_snapshot(v['id']) except Exception: pass for v in snaps: try: admin_manager.snapshots_client.wait_for_resource_deletion(v['id']) except Exception: pass vols = admin_manager.volumes_client.list_volumes( params={"all_tenants": True}) LOG.info("Cleanup::remove %s volumes" % len(vols)) for v in vols: try: admin_manager.volumes_client.\ wait_for_volume_status(v['id'], 'available') admin_manager.volumes_client.delete_volume(v['id']) except Exception: pass for v in vols: try: admin_manager.volumes_client.wait_for_resource_deletion(v['id']) except Exception: pass
def test_admin_delete_servers_of_others(self): # Administrator can delete servers of others server = self.create_test_server(wait_until='ACTIVE') self.admin_client.delete_server(server['id']) waiters.wait_for_server_termination(self.servers_client, server['id'])
def cleanup_server(): self.client.delete_server(server_multi_nics['id']) waiters.wait_for_server_termination(self.client, server_multi_nics['id'])
def test_delete_active_server(self): # Delete a server while it's VM state is Active server = self.create_test_server(wait_until='ACTIVE') self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id'])
def test_delete_server(self): server = self.create_test_server(wait_until='ACTIVE') with self.rbac_utils.override_role(self): self.servers_client.delete_server(server['id']) waiters.wait_for_server_termination(self.servers_client, server['id'])
def test_delete_server_while_in_building_state(self): # Delete a server while it's VM state is Building server = self.create_test_server(wait_until='BUILD') self.client.delete_server(server['id']) waiters.wait_for_server_termination(self.client, server['id'])
def _delete_server(self, server): self.servers_client.delete_server(server['id']) waiters.wait_for_server_termination(self.servers_client, server['id'])