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'])
