Remove wait_for_server_status from servers_client

wait_for_server_status of compute client just calls the one of waiters
module and the method is a wrapper.
So the method seems redundant and it doesn't fit as service clients.

This patch removes wait_for_server_status from compute client and
replaces it with waiters' one.

Partially implements blueprint consistent-service-method-names

Change-Id: Ie821ea4ba0924b71caba80132e1c383fb5bb125d
This commit is contained in:
Ken'ichi Ohmichi 2015-07-13 02:18:25 +00:00
parent e083f64669
commit 0eb153c636
39 changed files with 262 additions and 176 deletions

View File

@ -17,6 +17,7 @@
import testtools
from tempest.api.compute import base
from tempest.common import waiters
from tempest import config
from tempest import test
@ -103,10 +104,11 @@ class LiveBlockMigrationTestJSON(base.BaseV2ComputeAdminTest):
if state == 'PAUSED':
self.admin_servers_client.pause_server(server_id)
self.admin_servers_client.wait_for_server_status(server_id, state)
waiters.wait_for_server_status(self.admin_servers_client,
server_id, state)
self._migrate_server_to(server_id, target_host)
self.servers_client.wait_for_server_status(server_id, state)
waiters.wait_for_server_status(self.servers_client, server_id, state)
self.assertEqual(target_host, self._get_host_for_server(server_id))
@test.idempotent_id('1dce86b8-eb04-4c03-a9d8-9c1dc3ee0c7b')
@ -156,5 +158,6 @@ class LiveBlockMigrationTestJSON(base.BaseV2ComputeAdminTest):
self.volumes_client.wait_for_volume_status(volume['id'], 'in-use')
self._migrate_server_to(server_id, target_host)
self.servers_client.wait_for_server_status(server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client,
server_id, 'ACTIVE')
self.assertEqual(target_host, self._get_host_for_server(server_id))

View File

@ -15,6 +15,7 @@
import testtools
from tempest.api.compute import base
from tempest.common import waiters
from tempest import config
from tempest import test
@ -42,9 +43,11 @@ class MigrationsAdminTest(base.BaseV2ComputeAdminTest):
server_id = server['id']
self.servers_client.resize(server_id, self.flavor_ref_alt)
self.servers_client.wait_for_server_status(server_id, 'VERIFY_RESIZE')
waiters.wait_for_server_status(self.servers_client,
server_id, 'VERIFY_RESIZE')
self.servers_client.confirm_resize(server_id)
self.servers_client.wait_for_server_status(server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client,
server_id, 'ACTIVE')
body = self.client.list_migrations()

View File

@ -17,6 +17,7 @@ from tempest_lib import decorators
from tempest.api.compute import base
from tempest.common import fixed_network
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import test
@ -113,7 +114,8 @@ class ServersAdminTestJSON(base.BaseV2ComputeAdminTest):
test_server = self.client.create_server(name, image_id, flavor,
**network_kwargs)
self.addCleanup(self.client.delete_server, test_server['id'])
self.client.wait_for_server_status(test_server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.client,
test_server['id'], 'ACTIVE')
server = self.client.show_server(test_server['id'])
self.assertEqual(server['status'], 'ACTIVE')
hostname = server[self._host_key]
@ -163,7 +165,7 @@ class ServersAdminTestJSON(base.BaseV2ComputeAdminTest):
self.client.reset_state(self.s1_id, state='error')
rebuilt_server = self.non_admin_client.rebuild(
self.s1_id, self.image_ref_alt)
self.addCleanup(self.non_admin_client.wait_for_server_status,
self.addCleanup(waiters.wait_for_server_status, self.non_admin_client,
self.s1_id, 'ACTIVE')
self.addCleanup(self.non_admin_client.rebuild, self.s1_id,
self.image_ref)
@ -173,9 +175,9 @@ class ServersAdminTestJSON(base.BaseV2ComputeAdminTest):
rebuilt_image_id = rebuilt_server['image']['id']
self.assertEqual(self.image_ref_alt, rebuilt_image_id)
self.assertEqual(self.flavor_ref, rebuilt_server['flavor']['id'])
self.non_admin_client.wait_for_server_status(rebuilt_server['id'],
'ACTIVE',
raise_on_error=False)
waiters.wait_for_server_status(self.non_admin_client,
rebuilt_server['id'], 'ACTIVE',
raise_on_error=False)
# Verify the server properties after rebuilding
server = self.non_admin_client.show_server(rebuilt_server['id'])
rebuilt_image_id = server['image']['id']

View File

@ -20,6 +20,7 @@ import testtools
from tempest.api.compute import base
from tempest.common import tempest_fixtures as fixtures
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest import test
@ -151,7 +152,8 @@ class ServersAdminNegativeTestJSON(base.BaseV2ComputeAdminTest):
server_id = server['id']
# suspend the server.
self.client.suspend_server(server_id)
self.client.wait_for_server_status(server_id, 'SUSPENDED')
waiters.wait_for_server_status(self.client,
server_id, 'SUSPENDED')
# migrate an suspended server should fail
self.assertRaises(lib_exc.Conflict,
self.client.migrate_server,

View File

@ -144,8 +144,8 @@ class BaseComputeTest(tempest.test.BaseTestCase):
"""
if getattr(cls, 'server_id', None) is not None:
try:
cls.servers_client.wait_for_server_status(cls.server_id,
'ACTIVE')
waiters.wait_for_server_status(cls.servers_client,
cls.server_id, 'ACTIVE')
except Exception as exc:
LOG.exception(exc)
cls.servers_client.delete_server(cls.server_id)
@ -289,8 +289,8 @@ class BaseComputeTest(tempest.test.BaseTestCase):
if kwargs['wait_until'] == 'ACTIVE':
if kwargs.get('wait_for_server', True):
cls.servers_client.wait_for_server_status(server_id,
'ACTIVE')
waiters.wait_for_server_status(cls.servers_client,
server_id, 'ACTIVE')
return image
@classmethod

View File

@ -17,6 +17,7 @@ from tempest_lib import exceptions as lib_exc
from tempest.api.compute.floating_ips import base
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import test
@ -113,7 +114,8 @@ class FloatingIPsTestJSON(base.BaseFloatingIPsTest):
# Create server so as to use for Multiple association
new_name = data_utils.rand_name('floating_server')
body = self.create_test_server(name=new_name)
self.servers_client.wait_for_server_status(body['id'], 'ACTIVE')
waiters.wait_for_server_status(self.servers_client,
body['id'], 'ACTIVE')
self.new_server_id = body['id']
self.addCleanup(self.servers_client.delete_server, self.new_server_id)

View File

@ -16,6 +16,7 @@ from tempest_lib import exceptions as lib_exc
from tempest.api.compute import base
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest import test
@ -74,8 +75,8 @@ class ImagesNegativeTestJSON(base.BaseV2ComputeTest):
def test_create_image_from_stopped_server(self):
server = self.create_test_server(wait_until='ACTIVE')
self.servers_client.stop(server['id'])
self.servers_client.wait_for_server_status(server['id'],
'SHUTOFF')
waiters.wait_for_server_status(self.servers_client,
server['id'], 'SHUTOFF')
self.addCleanup(self.servers_client.delete_server, server['id'])
snapshot_name = data_utils.rand_name('test-snap')
image = self.create_image_from_server(server['id'],

View File

@ -38,8 +38,8 @@ class ImagesOneServerTestJSON(base.BaseV2ComputeTest):
super(ImagesOneServerTestJSON, self).setUp()
# Check if the server is in a clean state after test
try:
self.servers_client.wait_for_server_status(self.server_id,
'ACTIVE')
waiters.wait_for_server_status(self.servers_client,
self.server_id, 'ACTIVE')
except Exception:
LOG.exception('server %s timed out to become ACTIVE. rebuilding'
% self.server_id)

View File

@ -19,6 +19,7 @@ from tempest_lib import exceptions as lib_exc
from tempest.api.compute import base
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest import test
@ -43,8 +44,8 @@ class ImagesOneServerNegativeTestJSON(base.BaseV2ComputeTest):
super(ImagesOneServerNegativeTestJSON, self).setUp()
# Check if the server is in a clean state after test
try:
self.servers_client.wait_for_server_status(self.server_id,
'ACTIVE')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'ACTIVE')
except Exception:
LOG.exception('server %s timed out to become ACTIVE. rebuilding'
% self.server_id)

View File

@ -81,8 +81,8 @@ class ListImageFiltersTestJSON(base.BaseV2ComputeTest):
cls.server1 = cls.create_test_server()
cls.server2 = cls.create_test_server(wait_until='ACTIVE')
# NOTE(sdague) this is faster than doing the sync wait_util on both
cls.servers_client.wait_for_server_status(cls.server1['id'],
'ACTIVE')
waiters.wait_for_server_status(cls.servers_client,
cls.server1['id'], 'ACTIVE')
# Create images to be used in the filter tests
cls.snapshot1 = cls.create_image_from_server(

View File

@ -17,6 +17,7 @@ from tempest_lib import exceptions as lib_exc
from tempest.api.compute.security_groups import base
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import test
@ -97,7 +98,8 @@ class SecurityGroupsTestJSON(base.BaseSecurityGroupsTest):
server_name = data_utils.rand_name('server')
server = self.create_test_server(name=server_name)
server_id = server['id']
self.servers_client.wait_for_server_status(server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, server_id,
'ACTIVE')
self.servers_client.add_security_group(server_id, sg['name'])
# Check that we are not able to delete the security
@ -108,7 +110,8 @@ class SecurityGroupsTestJSON(base.BaseSecurityGroupsTest):
# Reboot and add the other security group
self.servers_client.reboot(server_id, 'HARD')
self.servers_client.wait_for_server_status(server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, server_id,
'ACTIVE')
self.servers_client.add_security_group(server_id, sg2['name'])
# Check that we are not able to delete the other security

View File

@ -52,7 +52,7 @@ class DeleteServersTestJSON(base.BaseV2ComputeTest):
# Delete a server while it's VM state is Shutoff
server = self.create_test_server(wait_until='ACTIVE')
self.client.stop(server['id'])
self.client.wait_for_server_status(server['id'], 'SHUTOFF')
waiters.wait_for_server_status(self.client, server['id'], 'SHUTOFF')
self.client.delete_server(server['id'])
self.client.wait_for_server_termination(server['id'])
@ -63,7 +63,7 @@ class DeleteServersTestJSON(base.BaseV2ComputeTest):
# Delete a server while it's VM state is Pause
server = self.create_test_server(wait_until='ACTIVE')
self.client.pause_server(server['id'])
self.client.wait_for_server_status(server['id'], 'PAUSED')
waiters.wait_for_server_status(self.client, server['id'], 'PAUSED')
self.client.delete_server(server['id'])
self.client.wait_for_server_termination(server['id'])
@ -74,7 +74,7 @@ class DeleteServersTestJSON(base.BaseV2ComputeTest):
# Delete a server while it's VM state is Suspended
server = self.create_test_server(wait_until='ACTIVE')
self.client.suspend_server(server['id'])
self.client.wait_for_server_status(server['id'], 'SUSPENDED')
waiters.wait_for_server_status(self.client, server['id'], 'SUSPENDED')
self.client.delete_server(server['id'])
self.client.wait_for_server_termination(server['id'])
@ -88,12 +88,12 @@ class DeleteServersTestJSON(base.BaseV2ComputeTest):
offload_time = CONF.compute.shelved_offload_time
if offload_time >= 0:
self.client.wait_for_server_status(server['id'],
'SHELVED_OFFLOADED',
extra_timeout=offload_time)
waiters.wait_for_server_status(self.client, server['id'],
'SHELVED_OFFLOADED',
extra_timeout=offload_time)
else:
self.client.wait_for_server_status(server['id'],
'SHELVED')
waiters.wait_for_server_status(self.client, server['id'],
'SHELVED')
self.client.delete_server(server['id'])
self.client.wait_for_server_termination(server['id'])
@ -104,7 +104,8 @@ class DeleteServersTestJSON(base.BaseV2ComputeTest):
# Delete a server while it's VM state is VERIFY_RESIZE
server = self.create_test_server(wait_until='ACTIVE')
self.client.resize(server['id'], self.flavor_ref_alt)
self.client.wait_for_server_status(server['id'], 'VERIFY_RESIZE')
waiters.wait_for_server_status(self.client, server['id'],
'VERIFY_RESIZE')
self.client.delete_server(server['id'])
self.client.wait_for_server_termination(server['id'])

View File

@ -16,6 +16,7 @@
import testtools
from tempest.api.compute import base
from tempest.common import waiters
from tempest import config
from tempest import test
@ -47,7 +48,7 @@ class ServerDiskConfigTestJSON(base.BaseV2ComputeTest):
if disk_config != server['OS-DCF:diskConfig']:
server = self.client.update_server(self.server_id,
disk_config=disk_config)
self.client.wait_for_server_status(server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.client, server['id'], 'ACTIVE')
server = self.client.show_server(server['id'])
self.assertEqual(disk_config, server['OS-DCF:diskConfig'])
@ -61,7 +62,7 @@ class ServerDiskConfigTestJSON(base.BaseV2ComputeTest):
disk_config='MANUAL')
# Wait for the server to become active
self.client.wait_for_server_status(server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.client, server['id'], 'ACTIVE')
# Verify the specified attributes are set correctly
server = self.client.show_server(server['id'])
@ -77,7 +78,7 @@ class ServerDiskConfigTestJSON(base.BaseV2ComputeTest):
disk_config='AUTO')
# Wait for the server to become active
self.client.wait_for_server_status(server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.client, server['id'], 'ACTIVE')
# Verify the specified attributes are set correctly
server = self.client.show_server(server['id'])
@ -101,9 +102,10 @@ class ServerDiskConfigTestJSON(base.BaseV2ComputeTest):
# Resize with auto option
flavor_id = self._get_alternative_flavor()
self.client.resize(self.server_id, flavor_id, disk_config='AUTO')
self.client.wait_for_server_status(self.server_id, 'VERIFY_RESIZE')
waiters.wait_for_server_status(self.client, self.server_id,
'VERIFY_RESIZE')
self.client.confirm_resize(self.server_id)
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
server = self.client.show_server(self.server_id)
self.assertEqual('AUTO', server['OS-DCF:diskConfig'])
@ -118,9 +120,10 @@ class ServerDiskConfigTestJSON(base.BaseV2ComputeTest):
# Resize with manual option
flavor_id = self._get_alternative_flavor()
self.client.resize(self.server_id, flavor_id, disk_config='MANUAL')
self.client.wait_for_server_status(self.server_id, 'VERIFY_RESIZE')
waiters.wait_for_server_status(self.client, self.server_id,
'VERIFY_RESIZE')
self.client.confirm_resize(self.server_id)
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
server = self.client.show_server(self.server_id)
self.assertEqual('MANUAL', server['OS-DCF:diskConfig'])
@ -133,7 +136,7 @@ class ServerDiskConfigTestJSON(base.BaseV2ComputeTest):
# Update the disk_config attribute to manual
server = self.client.update_server(self.server_id,
disk_config='MANUAL')
self.client.wait_for_server_status(server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.client, server['id'], 'ACTIVE')
# Verify the disk_config attribute is set correctly
server = self.client.show_server(server['id'])

View File

@ -14,6 +14,7 @@
# under the License.
from tempest.api.compute import base
from tempest.common import waiters
from tempest import test
@ -35,7 +36,7 @@ class InstanceActionsTestJSON(base.BaseV2ComputeTest):
def test_list_instance_actions(self):
# List actions of the provided server
self.client.reboot(self.server_id, 'HARD')
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
body = self.client.list_instance_actions(self.server_id)
self.assertTrue(len(body) == 2, str(body))

View File

@ -19,6 +19,7 @@ from tempest.api.compute import base
from tempest.api import utils
from tempest.common import fixed_network
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest import test
@ -137,12 +138,12 @@ class ListServerFiltersTestJSON(base.BaseV2ComputeTest):
# Filter the list of servers by server shutoff status
params = {'status': 'shutoff'}
self.client.stop(self.s1['id'])
self.client.wait_for_server_status(self.s1['id'],
'SHUTOFF')
waiters.wait_for_server_status(self.client, self.s1['id'],
'SHUTOFF')
body = self.client.list_servers(**params)
self.client.start(self.s1['id'])
self.client.wait_for_server_status(self.s1['id'],
'ACTIVE')
waiters.wait_for_server_status(self.client, self.s1['id'],
'ACTIVE')
servers = body['servers']
self.assertIn(self.s1['id'], map(lambda x: x['id'], servers))

View File

@ -24,6 +24,7 @@ import testtools
from tempest.api.compute import base
from tempest.common.utils import data_utils
from tempest.common.utils.linux import remote_client
from tempest.common import waiters
from tempest import config
from tempest import test
@ -41,7 +42,8 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
super(ServerActionsTestJSON, self).setUp()
# Check if the server is in a clean state after test
try:
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client,
self.server_id, 'ACTIVE')
except lib_exc.NotFound:
# The server was deleted by previous test, create a new one
server = self.create_test_server(wait_until='ACTIVE')
@ -72,7 +74,7 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
# The server's password should be set to the provided password
new_password = 'Newpass1234'
self.client.change_password(self.server_id, new_password)
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
if self.run_ssh:
# Verify that the user can authenticate with the new password
@ -90,7 +92,7 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
boot_time = linux_client.get_boot_time()
self.client.reboot(self.server_id, reboot_type)
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
if self.run_ssh:
# Log in and verify the boot time has changed
@ -114,7 +116,7 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
def _rebuild_server_and_check(self, image_ref):
rebuilt_server = self.client.rebuild(self.server_id, image_ref)
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
msg = ('Server was not rebuilt to the original image. '
'The original image: {0}. The current image: {1}'
.format(image_ref, rebuilt_server['image']['id']))
@ -148,7 +150,8 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
self.assertEqual(self.flavor_ref, rebuilt_server['flavor']['id'])
# Verify the server properties after the rebuild completes
self.client.wait_for_server_status(rebuilt_server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.client,
rebuilt_server['id'], 'ACTIVE')
server = self.client.show_server(rebuilt_server['id'])
rebuilt_image_id = server['image']['id']
self.assertTrue(self.image_ref_alt.endswith(rebuilt_image_id))
@ -169,7 +172,7 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
new_image = (self.image_ref_alt
if old_image == self.image_ref else self.image_ref)
self.client.stop(self.server_id)
self.client.wait_for_server_status(self.server_id, 'SHUTOFF')
waiters.wait_for_server_status(self.client, self.server_id, 'SHUTOFF')
rebuilt_server = self.client.rebuild(self.server_id, new_image)
# If the server was rebuilt on a different image, restore it to the
# original image once the test ends
@ -183,7 +186,8 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
self.assertEqual(self.flavor_ref, rebuilt_server['flavor']['id'])
# Verify the server properties after the rebuild completes
self.client.wait_for_server_status(rebuilt_server['id'], 'SHUTOFF')
waiters.wait_for_server_status(self.client,
rebuilt_server['id'], 'SHUTOFF')
server = self.client.show_server(rebuilt_server['id'])
rebuilt_image_id = server['image']['id']
self.assertEqual(new_image, rebuilt_image_id)
@ -196,15 +200,17 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
if stop:
self.servers_client.stop(self.server_id)
self.servers_client.wait_for_server_status(self.server_id,
'SHUTOFF')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'SHUTOFF')
self.client.resize(self.server_id, self.flavor_ref_alt)
self.client.wait_for_server_status(self.server_id, 'VERIFY_RESIZE')
waiters.wait_for_server_status(self.client, self.server_id,
'VERIFY_RESIZE')
self.client.confirm_resize(self.server_id)
expected_status = 'SHUTOFF' if stop else 'ACTIVE'
self.client.wait_for_server_status(self.server_id, expected_status)
waiters.wait_for_server_status(self.client, self.server_id,
expected_status)
server = self.client.show_server(self.server_id)
self.assertEqual(self.flavor_ref_alt, server['flavor']['id'])
@ -237,10 +243,11 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
# values after a resize is reverted
self.client.resize(self.server_id, self.flavor_ref_alt)
self.client.wait_for_server_status(self.server_id, 'VERIFY_RESIZE')
waiters.wait_for_server_status(self.client, self.server_id,
'VERIFY_RESIZE')
self.client.revert_resize(self.server_id)
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
server = self.client.show_server(self.server_id)
self.assertEqual(self.flavor_ref, server['flavor']['id'])
@ -276,7 +283,8 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
self.os.image_client.wait_for_image_status(image1_id, 'active')
backup2 = data_utils.rand_name('backup-2')
self.servers_client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'ACTIVE')
resp = self.servers_client.create_backup(self.server_id,
'daily',
2,
@ -304,7 +312,8 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
# create the third one, due to the rotation is 2,
# the first one will be deleted
backup3 = data_utils.rand_name('backup-3')
self.servers_client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'ACTIVE')
resp = self.servers_client.create_backup(self.server_id,
'daily',
2,
@ -312,7 +321,8 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
image3_id = data_utils.parse_image_id(resp['location'])
self.addCleanup(self.os.image_client.delete_image, image3_id)
# the first back up should be deleted
self.servers_client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'ACTIVE')
self.os.image_client.wait_for_resource_deletion(image1_id)
oldest_backup_exist = False
image_list = self.os.image_client.list_images(
@ -349,8 +359,8 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
# "console-log" API.
# The detail is https://bugs.launchpad.net/nova/+bug/1251920
self.servers_client.reboot(self.server_id, 'HARD')
self.servers_client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'ACTIVE')
self.wait_for(self._get_output)
@test.idempotent_id('89104062-69d8-4b19-a71b-f47b7af093d7')
@ -386,8 +396,8 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
temp_server_id = server['id']
self.servers_client.stop(temp_server_id)
self.servers_client.wait_for_server_status(temp_server_id, 'SHUTOFF')
waiters.wait_for_server_status(self.servers_client, temp_server_id,
'SHUTOFF')
self.wait_for(self._get_output)
@test.idempotent_id('bd61a9fd-062f-4670-972b-2d6c3e3b9e73')
@ -395,18 +405,19 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
'Pause is not available.')
def test_pause_unpause_server(self):
self.client.pause_server(self.server_id)
self.client.wait_for_server_status(self.server_id, 'PAUSED')
waiters.wait_for_server_status(self.client, self.server_id, 'PAUSED')
self.client.unpause_server(self.server_id)
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
@test.idempotent_id('0d8ee21e-b749-462d-83da-b85b41c86c7f')
@testtools.skipUnless(CONF.compute_feature_enabled.suspend,
'Suspend is not available.')
def test_suspend_resume_server(self):
self.client.suspend_server(self.server_id)
self.client.wait_for_server_status(self.server_id, 'SUSPENDED')
waiters.wait_for_server_status(self.client, self.server_id,
'SUSPENDED')
self.client.resume_server(self.server_id)
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
@test.idempotent_id('77eba8e0-036e-4635-944b-f7a8f3b78dc9')
@testtools.skipUnless(CONF.compute_feature_enabled.shelve,
@ -416,16 +427,16 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
offload_time = CONF.compute.shelved_offload_time
if offload_time >= 0:
self.client.wait_for_server_status(self.server_id,
'SHELVED_OFFLOADED',
extra_timeout=offload_time)
waiters.wait_for_server_status(self.client, self.server_id,
'SHELVED_OFFLOADED',
extra_timeout=offload_time)
else:
self.client.wait_for_server_status(self.server_id,
'SHELVED')
waiters.wait_for_server_status(self.client, self.server_id,
'SHELVED')
self.client.shelve_offload_server(self.server_id)
self.client.wait_for_server_status(self.server_id,
'SHELVED_OFFLOADED')
waiters.wait_for_server_status(self.client, self.server_id,
'SHELVED_OFFLOADED')
server = self.client.show_server(self.server_id)
image_name = server['name'] + '-shelved'
@ -435,14 +446,16 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
self.assertEqual(image_name, images[0]['name'])
self.client.unshelve_server(self.server_id)
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
@test.idempotent_id('af8eafd4-38a7-4a4b-bdbc-75145a580560')
def test_stop_start_server(self):
self.servers_client.stop(self.server_id)
self.servers_client.wait_for_server_status(self.server_id, 'SHUTOFF')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'SHUTOFF')
self.servers_client.start(self.server_id)
self.servers_client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'ACTIVE')
@test.idempotent_id('80a8094c-211e-440a-ab88-9e59d556c7ee')
def test_lock_unlock_server(self):
@ -455,9 +468,11 @@ class ServerActionsTestJSON(base.BaseV2ComputeTest):
self.servers_client.stop, self.server_id)
self.servers_client.unlock_server(self.server_id)
self.servers_client.stop(self.server_id)
self.servers_client.wait_for_server_status(self.server_id, 'SHUTOFF')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'SHUTOFF')
self.servers_client.start(self.server_id)
self.servers_client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'ACTIVE')
def _validate_url(self, url):
valid_scheme = ['http', 'https']

View File

@ -15,6 +15,7 @@
from tempest.api.compute import base
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest import test
@ -56,7 +57,8 @@ class ServerRescueTestJSON(base.BaseV2ComputeTest):
server = cls.create_test_server(wait_until='BUILD')
cls.server_id = server['id']
cls.password = server['adminPass']
cls.servers_client.wait_for_server_status(cls.server_id, 'ACTIVE')
waiters.wait_for_server_status(cls.servers_client, cls.server_id,
'ACTIVE')
def setUp(self):
super(ServerRescueTestJSON, self).setUp()
@ -74,22 +76,26 @@ class ServerRescueTestJSON(base.BaseV2ComputeTest):
def _unrescue(self, server_id):
self.servers_client.unrescue_server(server_id)
self.servers_client.wait_for_server_status(server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, server_id,
'ACTIVE')
@test.idempotent_id('fd032140-714c-42e4-a8fd-adcd8df06be6')
def test_rescue_unrescue_instance(self):
self.servers_client.rescue_server(
self.server_id, adminPass=self.password)
self.servers_client.wait_for_server_status(self.server_id, 'RESCUE')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'RESCUE')
self.servers_client.unrescue_server(self.server_id)
self.servers_client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'ACTIVE')
@test.idempotent_id('4842e0cf-e87d-4d9d-b61f-f4791da3cacc')
def test_rescued_vm_associate_dissociate_floating_ip(self):
# Rescue the server
self.servers_client.rescue_server(
self.server_id, adminPass=self.password)
self.servers_client.wait_for_server_status(self.server_id, 'RESCUE')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'RESCUE')
self.addCleanup(self._unrescue, self.server_id)
# Association of floating IP to a rescued vm
@ -106,7 +112,8 @@ class ServerRescueTestJSON(base.BaseV2ComputeTest):
# Rescue the server
self.servers_client.rescue_server(
self.server_id, adminPass=self.password)
self.servers_client.wait_for_server_status(self.server_id, 'RESCUE')
waiters.wait_for_server_status(self.servers_client, self.server_id,
'RESCUE')
self.addCleanup(self._unrescue, self.server_id)
# Add Security group

View File

@ -54,8 +54,10 @@ class ServerRescueNegativeTestJSON(base.BaseV2ComputeTest):
cls.servers_client.rescue_server(
cls.rescue_id, adminPass=rescue_password)
cls.servers_client.wait_for_server_status(cls.rescue_id, 'RESCUE')
cls.servers_client.wait_for_server_status(cls.server_id, 'ACTIVE')
waiters.wait_for_server_status(cls.servers_client,
cls.rescue_id, 'RESCUE')
waiters.wait_for_server_status(cls.servers_client,
cls.server_id, 'ACTIVE')
def _create_volume(self):
volume = self.volumes_extensions_client.create_volume(
@ -73,11 +75,13 @@ class ServerRescueNegativeTestJSON(base.BaseV2ComputeTest):
def _unrescue(self, server_id):
self.servers_client.unrescue_server(server_id)
self.servers_client.wait_for_server_status(server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client,
server_id, 'ACTIVE')
def _unpause(self, server_id):
self.servers_client.unpause_server(server_id)
self.servers_client.wait_for_server_status(server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client,
server_id, 'ACTIVE')
@test.idempotent_id('cc3a883f-43c0-4fb6-a9bb-5579d64984ed')
@testtools.skipUnless(CONF.compute_feature_enabled.pause,
@ -87,7 +91,8 @@ class ServerRescueNegativeTestJSON(base.BaseV2ComputeTest):
# Rescue a paused server
self.servers_client.pause_server(self.server_id)
self.addCleanup(self._unpause, self.server_id)
self.servers_client.wait_for_server_status(self.server_id, 'PAUSED')
waiters.wait_for_server_status(self.servers_client,
self.server_id, 'PAUSED')
self.assertRaises(lib_exc.Conflict,
self.servers_client.rescue_server,
self.server_id)
@ -124,7 +129,8 @@ class ServerRescueNegativeTestJSON(base.BaseV2ComputeTest):
# Rescue the server
self.servers_client.rescue_server(self.server_id,
adminPass=self.password)
self.servers_client.wait_for_server_status(self.server_id, 'RESCUE')
waiters.wait_for_server_status(self.servers_client,
self.server_id, 'RESCUE')
self.addCleanup(self._unrescue, self.server_id)
# Attach the volume to the server
@ -150,7 +156,8 @@ class ServerRescueNegativeTestJSON(base.BaseV2ComputeTest):
# Rescue the server
self.servers_client.rescue_server(self.server_id,
adminPass=self.password)
self.servers_client.wait_for_server_status(self.server_id, 'RESCUE')
waiters.wait_for_server_status(self.servers_client,
self.server_id, 'RESCUE')
# addCleanup is a LIFO queue
self.addCleanup(self._detach, self.server_id, volume['id'])
self.addCleanup(self._unrescue, self.server_id)

View File

@ -15,6 +15,7 @@
from tempest.api.compute import base
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import test
@ -66,7 +67,7 @@ class ServersTestJSON(base.BaseV2ComputeTest):
self.addCleanup(self.keypairs_client.delete_keypair, key_name)
self.keypairs_client.list_keypairs()
server = self.create_test_server(key_name=key_name)
self.client.wait_for_server_status(server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.client, server['id'], 'ACTIVE')
server = self.client.show_server(server['id'])
self.assertEqual(key_name, server['key_name'])
@ -76,7 +77,7 @@ class ServersTestJSON(base.BaseV2ComputeTest):
# Update the server with a new name
self.client.update_server(server_id,
name=new_name)
self.client.wait_for_server_status(server_id, status)
waiters.wait_for_server_status(self.client, server_id, status)
# Verify the name of the server has changed
server = self.client.show_server(server_id)
@ -95,7 +96,7 @@ class ServersTestJSON(base.BaseV2ComputeTest):
# The server name should be changed to the the provided value
server = self.create_test_server(wait_until='ACTIVE')
self.client.stop(server['id'])
self.client.wait_for_server_status(server['id'], 'SHUTOFF')
waiters.wait_for_server_status(self.client, server['id'], 'SHUTOFF')
updated_server = self._update_server_name(server['id'], 'SHUTOFF')
self.assertNotIn('progress', updated_server)
@ -108,7 +109,7 @@ class ServersTestJSON(base.BaseV2ComputeTest):
self.client.update_server(server['id'],
accessIPv4='1.1.1.1',
accessIPv6='::babe:202:202')
self.client.wait_for_server_status(server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.client, server['id'], 'ACTIVE')
# Verify the access addresses have been updated
server = self.client.show_server(server['id'])
@ -119,6 +120,6 @@ class ServersTestJSON(base.BaseV2ComputeTest):
def test_create_server_with_ipv6_addr_only(self):
# Create a server without an IPv4 address(only IPv6 address).
server = self.create_test_server(accessIPv6='2001:2001::3')
self.client.wait_for_server_status(server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.client, server['id'], 'ACTIVE')
server = self.client.show_server(server['id'])
self.assertEqual('2001:2001::3', server['accessIPv6'])

View File

@ -20,6 +20,7 @@ import testtools
from tempest.api.compute import base
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest import test
@ -33,7 +34,8 @@ class ServersNegativeTestJSON(base.BaseV2ComputeTest):
def setUp(self):
super(ServersNegativeTestJSON, self).setUp()
try:
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
waiters.wait_for_server_status(self.client, self.server_id,
'ACTIVE')
except Exception:
self.__class__.server_id = self.rebuild_server(self.server_id)
@ -157,7 +159,7 @@ class ServersNegativeTestJSON(base.BaseV2ComputeTest):
def test_pause_paused_server(self):
# Pause a paused server.
self.client.pause_server(self.server_id)
self.client.wait_for_server_status(self.server_id, 'PAUSED')
waiters.wait_for_server_status(self.client, self.server_id, 'PAUSED')
self.assertRaises(lib_exc.Conflict,
self.client.pause_server,
self.server_id)
@ -384,7 +386,8 @@ class ServersNegativeTestJSON(base.BaseV2ComputeTest):
def test_suspend_server_invalid_state(self):
# suspend a suspended server.
self.client.suspend_server(self.server_id)
self.client.wait_for_server_status(self.server_id, 'SUSPENDED')
waiters.wait_for_server_status(self.client, self.server_id,
'SUSPENDED')
self.assertRaises(lib_exc.Conflict,
self.client.suspend_server,
self.server_id)
@ -465,12 +468,14 @@ class ServersNegativeTestJSON(base.BaseV2ComputeTest):
offload_time = CONF.compute.shelved_offload_time
if offload_time >= 0:
self.client.wait_for_server_status(self.server_id,
'SHELVED_OFFLOADED',
extra_timeout=offload_time)
waiters.wait_for_server_status(self.client,
self.server_id,
'SHELVED_OFFLOADED',
extra_timeout=offload_time)
else:
self.client.wait_for_server_status(self.server_id,
'SHELVED')
waiters.wait_for_server_status(self.client,
self.server_id,
'SHELVED')
server = self.client.show_server(self.server_id)
image_name = server['name'] + '-shelved'

View File

@ -17,6 +17,7 @@ from tempest_lib import exceptions as lib_exc
from tempest.api.compute import base
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest import test
@ -55,4 +56,5 @@ class LiveBlockMigrationNegativeTestJSON(base.BaseV2ComputeAdminTest):
self.assertRaises(lib_exc.BadRequest, self._migrate_server_to,
server_id, target_host)
self.servers_client.wait_for_server_status(server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, server_id,
'ACTIVE')

View File

@ -17,6 +17,7 @@ import testtools
from tempest.api.compute import base
from tempest.common.utils.linux import remote_client
from tempest.common import waiters
from tempest import config
from tempest import test
@ -93,11 +94,12 @@ class AttachVolumeTestJSON(base.BaseV2ComputeTest):
self._create_and_attach()
self.servers_client.stop(self.server['id'])
self.servers_client.wait_for_server_status(self.server['id'],
'SHUTOFF')
waiters.wait_for_server_status(self.servers_client, self.server['id'],
'SHUTOFF')
self.servers_client.start(self.server['id'])
self.servers_client.wait_for_server_status(self.server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, self.server['id'],
'ACTIVE')
linux_client = remote_client.RemoteClient(self.server,
self.image_ssh_user,
@ -108,11 +110,12 @@ class AttachVolumeTestJSON(base.BaseV2ComputeTest):
self._detach(self.server['id'], self.volume['id'])
self.attachment = None
self.servers_client.stop(self.server['id'])
self.servers_client.wait_for_server_status(self.server['id'],
'SHUTOFF')
waiters.wait_for_server_status(self.servers_client, self.server['id'],
'SHUTOFF')
self.servers_client.start(self.server['id'])
self.servers_client.wait_for_server_status(self.server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, self.server['id'],
'ACTIVE')
linux_client = remote_client.RemoteClient(self.server,
self.image_ssh_user,

View File

@ -15,6 +15,7 @@
from tempest.api.volume import base
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest import test
import testtools
@ -37,7 +38,8 @@ class VolumesV2ActionsTest(base.BaseVolumeTest):
# Create a test shared instance
srv_name = data_utils.rand_name(cls.__name__ + '-Instance')
cls.server = cls.create_server(srv_name)
cls.servers_client.wait_for_server_status(cls.server['id'], 'ACTIVE')
waiters.wait_for_server_status(cls.servers_client, cls.server['id'],
'ACTIVE')
# Create a test shared volume for attach/detach tests
cls.volume = cls.create_volume()

View File

@ -19,6 +19,7 @@ from tempest_lib import exceptions as lib_exc
from tempest.api.volume import base
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import test
@ -181,7 +182,8 @@ class VolumesV2NegativeTest(base.BaseVolumeTest):
srv_name = data_utils.rand_name('Instance')
server = self.create_server(srv_name)
self.addCleanup(self.servers_client.delete_server, server['id'])
self.servers_client.wait_for_server_status(server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, server['id'],
'ACTIVE')
self.assertRaises(lib_exc.NotFound,
self.client.attach_volume,
str(uuid.uuid4()),

View File

@ -14,6 +14,7 @@ from oslo_log import log as logging
from tempest.api.volume import base
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest import test
@ -70,7 +71,8 @@ class VolumesV2SnapshotTestJSON(base.BaseVolumeTest):
server_name = data_utils.rand_name('instance')
server = self.create_server(server_name)
self.addCleanup(self.servers_client.delete_server, server['id'])
self.servers_client.wait_for_server_status(server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, server['id'],
'ACTIVE')
mountpoint = '/dev/%s' % CONF.compute.volume_device_name
self.servers_client.attach_volume(
server['id'], self.volume_origin['id'], mountpoint)

View File

@ -18,6 +18,7 @@ from oslo_utils import excutils
from tempest_lib.common.utils import data_utils
from tempest.common import fixed_network
from tempest.common import waiters
from tempest import config
CONF = config.CONF
@ -98,8 +99,8 @@ def create_test_server(clients, validatable, validation_resources=None,
if 'wait_until' in kwargs:
for server in servers:
try:
clients.servers_client.wait_for_server_status(
server['id'], kwargs['wait_until'])
waiters.wait_for_server_status(
clients.servers_client, server['id'], kwargs['wait_until'])
# Multiple validatable servers are not supported for now. Their
# creation will fail with the condition above (l.58).

View File

@ -25,6 +25,7 @@ from tempest_lib import exceptions as lib_exc
from tempest.common import fixed_network
from tempest.common.utils import data_utils
from tempest.common.utils.linux import remote_client
from tempest.common import waiters
from tempest import config
from tempest import exceptions
from tempest.services.network import resources as net_resources
@ -177,8 +178,9 @@ class ScenarioTest(tempest.test.BaseTestCase):
cleanup_callable=self.delete_wrapper,
cleanup_args=[self.servers_client.delete_server, server['id']])
if wait_on_boot:
self.servers_client.wait_for_server_status(server_id=server['id'],
status='ACTIVE')
waiters.wait_for_server_status(self.servers_client,
server_id=server['id'],
status='ACTIVE')
# The instance retrieved on creation is missing network
# details, necessitating retrieval after it becomes active to
# ensure correct details.
@ -443,7 +445,8 @@ class ScenarioTest(tempest.test.BaseTestCase):
preserve_ephemeral=preserve_ephemeral,
**rebuild_kwargs)
if wait:
self.servers_client.wait_for_server_status(server_id, 'ACTIVE')
waiters.wait_for_server_status(self.servers_client,
server_id, 'ACTIVE')
def ping_ip_address(self, ip_address, should_succeed=True,
ping_timeout=None):
@ -1226,8 +1229,8 @@ class BaremetalScenarioTest(ScenarioTest):
BaremetalProvisionStates.ACTIVE,
timeout=CONF.baremetal.active_timeout)
self.servers_client.wait_for_server_status(self.instance['id'],
'ACTIVE')
waiters.wait_for_server_status(self.servers_client,
self.instance['id'], 'ACTIVE')
self.node = self.get_node(instance_id=self.instance['id'])
self.instance = self.servers_client.show_server(self.instance['id'])

View File

@ -15,6 +15,7 @@
from oslo_log import log as logging
from tempest.common import waiters
from tempest import config
from tempest.scenario import manager
from tempest import test
@ -52,11 +53,13 @@ class BaremetalBasicOps(manager.BaremetalScenarioTest):
self.assertEqual(self.node['uuid'], node['uuid'])
self.node = node
self.servers_client.wait_for_server_status(
waiters.wait_for_server_status(
self.servers_client,
server_id=self.instance['id'],
status='REBUILD',
ready_wait=False)
self.servers_client.wait_for_server_status(
waiters.wait_for_server_status(
self.servers_client,
server_id=self.instance['id'],
status='ACTIVE')

View File

@ -18,6 +18,7 @@ from tempest_lib import exceptions as lib_exc
from tempest.common import fixed_network
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest.scenario import manager
from tempest import test
@ -76,7 +77,8 @@ class TestLargeOpsScenario(manager.ScenarioTest):
for server in self.servers:
# Make sure nova list keeps working throughout the build process
self.servers_client.list_servers()
self.servers_client.wait_for_server_status(server['id'], status)
waiters.wait_for_server_status(self.servers_client,
server['id'], status)
def nova_boot(self):
name = data_utils.rand_name('scenario-server')

View File

@ -16,6 +16,7 @@
from oslo_log import log as logging
from tempest.common import custom_matchers
from tempest.common import waiters
from tempest import config
from tempest import exceptions
from tempest.scenario import manager
@ -43,7 +44,8 @@ class TestMinimumBasicScenario(manager.ScenarioTest):
server_id = self.server['id']
# Raise on error defaults to True, which is consistent with the
# original function from scenario tests here
self.servers_client.wait_for_server_status(server_id, status)
waiters.wait_for_server_status(self.servers_client,
server_id, status)
def nova_keypair_add(self):
self.keypair = self.create_keypair()

View File

@ -17,6 +17,7 @@ from oslo_log import log as logging
import testtools
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest.scenario import manager
from tempest import test
@ -90,7 +91,8 @@ class TestNetworkAdvancedServerOps(manager.NetworkScenarioTest):
servers=[self.server])
def _wait_server_status_and_check_network_connectivity(self):
self.servers_client.wait_for_server_status(self.server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.servers_client,
self.server['id'], 'ACTIVE')
self._check_network_connectivity()
@test.idempotent_id('61f1aa9a-1573-410e-9054-afa557cab021')
@ -99,8 +101,8 @@ class TestNetworkAdvancedServerOps(manager.NetworkScenarioTest):
def test_server_connectivity_stop_start(self):
self._setup_network_and_servers()
self.servers_client.stop(self.server['id'])
self.servers_client.wait_for_server_status(self.server['id'],
'SHUTOFF')
waiters.wait_for_server_status(self.servers_client,
self.server['id'], 'SHUTOFF')
self._check_network_connectivity(should_connect=False)
self.servers_client.start(self.server['id'])
self._wait_server_status_and_check_network_connectivity()
@ -128,7 +130,8 @@ class TestNetworkAdvancedServerOps(manager.NetworkScenarioTest):
def test_server_connectivity_pause_unpause(self):
self._setup_network_and_servers()
self.servers_client.pause_server(self.server['id'])
self.servers_client.wait_for_server_status(self.server['id'], 'PAUSED')
waiters.wait_for_server_status(self.servers_client,
self.server['id'], 'PAUSED')
self._check_network_connectivity(should_connect=False)
self.servers_client.unpause_server(self.server['id'])
self._wait_server_status_and_check_network_connectivity()
@ -140,8 +143,8 @@ class TestNetworkAdvancedServerOps(manager.NetworkScenarioTest):
def test_server_connectivity_suspend_resume(self):
self._setup_network_and_servers()
self.servers_client.suspend_server(self.server['id'])
self.servers_client.wait_for_server_status(self.server['id'],
'SUSPENDED')
waiters.wait_for_server_status(self.servers_client, self.server['id'],
'SUSPENDED')
self._check_network_connectivity(should_connect=False)
self.servers_client.resume_server(self.server['id'])
self._wait_server_status_and_check_network_connectivity()
@ -157,7 +160,7 @@ class TestNetworkAdvancedServerOps(manager.NetworkScenarioTest):
raise self.skipException(msg)
self._setup_network_and_servers()
self.servers_client.resize(self.server['id'], flavor_ref=resize_flavor)
self.servers_client.wait_for_server_status(self.server['id'],
'VERIFY_RESIZE')
waiters.wait_for_server_status(self.servers_client, self.server['id'],
'VERIFY_RESIZE')
self.servers_client.confirm_resize(self.server['id'])
self._wait_server_status_and_check_network_connectivity()

View File

@ -16,6 +16,7 @@
from oslo_log import log as logging
import testtools
from tempest.common import waiters
from tempest import config
from tempest.scenario import manager
from tempest import test
@ -58,14 +59,14 @@ class TestServerAdvancedOps(manager.ScenarioTest):
LOG.debug("Resizing instance %s from flavor %s to flavor %s",
instance['id'], instance['flavor']['id'], resize_flavor)
self.servers_client.resize(instance_id, resize_flavor)
self.servers_client.wait_for_server_status(instance_id,
'VERIFY_RESIZE')
waiters.wait_for_server_status(self.servers_client, instance_id,
'VERIFY_RESIZE')
LOG.debug("Confirming resize of instance %s", instance_id)
self.servers_client.confirm_resize(instance_id)
self.servers_client.wait_for_server_status(instance_id,
'ACTIVE')
waiters.wait_for_server_status(self.servers_client, instance_id,
'ACTIVE')
@test.idempotent_id('949da7d5-72c8-4808-8802-e3d70df98e2c')
@testtools.skipUnless(CONF.compute_feature_enabled.suspend,
@ -78,23 +79,23 @@ class TestServerAdvancedOps(manager.ScenarioTest):
LOG.debug("Suspending instance %s. Current status: %s",
instance_id, instance['status'])
self.servers_client.suspend_server(instance_id)
self.servers_client.wait_for_server_status(instance_id,
'SUSPENDED')
waiters.wait_for_server_status(self.servers_client, instance_id,
'SUSPENDED')
fetched_instance = self.servers_client.show_server(instance_id)
LOG.debug("Resuming instance %s. Current status: %s",
instance_id, fetched_instance['status'])
self.servers_client.resume_server(instance_id)
self.servers_client.wait_for_server_status(instance_id,
'ACTIVE')
waiters.wait_for_server_status(self.servers_client, instance_id,
'ACTIVE')
fetched_instance = self.servers_client.show_server(instance_id)
LOG.debug("Suspending instance %s. Current status: %s",
instance_id, fetched_instance['status'])
self.servers_client.suspend_server(instance_id)
self.servers_client.wait_for_server_status(instance_id,
'SUSPENDED')
waiters.wait_for_server_status(self.servers_client, instance_id,
'SUSPENDED')
fetched_instance = self.servers_client.show_server(instance_id)
LOG.debug("Resuming instance %s. Current status: %s",
instance_id, fetched_instance['status'])
self.servers_client.resume_server(instance_id)
self.servers_client.wait_for_server_status(instance_id,
'ACTIVE')
waiters.wait_for_server_status(self.servers_client, instance_id,
'ACTIVE')

View File

@ -16,6 +16,7 @@
from oslo_log import log
import testtools
from tempest.common import waiters
from tempest import config
from tempest.scenario import manager
from tempest import test
@ -50,15 +51,18 @@ class TestShelveInstance(manager.ScenarioTest):
self.servers_client.shelve_server(server['id'])
offload_time = CONF.compute.shelved_offload_time
if offload_time >= 0:
self.servers_client.wait_for_server_status(
server['id'], 'SHELVED_OFFLOADED', extra_timeout=offload_time)
waiters.wait_for_server_status(self.servers_client, server['id'],
'SHELVED_OFFLOADED',
extra_timeout=offload_time)
else:
self.servers_client.wait_for_server_status(server['id'], 'SHELVED')
waiters.wait_for_server_status(self.servers_client,
server['id'], 'SHELVED')
self.servers_client.shelve_offload_server(server['id'])
self.servers_client.wait_for_server_status(server['id'],
'SHELVED_OFFLOADED')
waiters.wait_for_server_status(self.servers_client, server['id'],
'SHELVED_OFFLOADED')
self.servers_client.unshelve_server(server['id'])
self.servers_client.wait_for_server_status(server['id'], 'ACTIVE')
waiters.wait_for_server_status(self.servers_client, server['id'],
'ACTIVE')
@test.idempotent_id('1164e700-0af0-4a4c-8792-35909a88743c')
@testtools.skipUnless(CONF.compute_feature_enabled.shelve,

View File

@ -13,6 +13,7 @@
from oslo_log import log
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
from tempest.scenario import manager
from tempest import test
@ -85,7 +86,8 @@ class TestVolumeBootPattern(manager.ScenarioTest):
for i in instances:
self.servers_client.stop(i['id'])
for i in instances:
self.servers_client.wait_for_server_status(i['id'], 'SHUTOFF')
waiters.wait_for_server_status(self.servers_client,
i['id'], 'SHUTOFF')
def _detach_volumes(self, volumes):
# NOTE(gfidente): two loops so we do not wait for the status twice

View File

@ -22,7 +22,6 @@ from tempest_lib import exceptions as lib_exc
from tempest.api_schema.response.compute.v2_1 import servers as schema
from tempest.common import service_client
from tempest.common import waiters
from tempest import exceptions
@ -166,14 +165,6 @@ class ServersClient(service_client.ServiceClient):
self.validate_response(_schema, resp, body)
return service_client.ResponseBody(resp, body)
def wait_for_server_status(self, server_id, status, extra_timeout=0,
raise_on_error=True, ready_wait=True):
"""Waits for a server to reach a given status."""
return waiters.wait_for_server_status(self, server_id, status,
extra_timeout=extra_timeout,
raise_on_error=raise_on_error,
ready_wait=ready_wait)
def wait_for_server_termination(self, server_id, ignore_error=False):
"""Waits for server to reach termination."""
start_time = int(time.time())

View File

@ -13,6 +13,7 @@
# limitations under the License.
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
import tempest.stress.stressaction as stressaction
@ -31,8 +32,8 @@ class ServerCreateDestroyTest(stressaction.StressAction):
server = self.manager.servers_client.create_server(
name, self.image, self.flavor)
server_id = server['id']
self.manager.servers_client.wait_for_server_status(server_id,
'ACTIVE')
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)

View File

@ -14,6 +14,7 @@ import socket
import subprocess
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
import tempest.stress.stressaction as stressaction
import tempest.test
@ -79,8 +80,8 @@ class FloatingStress(stressaction.StressAction):
**vm_args)
self.server_id = server['id']
if self.wait_after_vm_create:
self.manager.servers_client.wait_for_server_status(self.server_id,
'ACTIVE')
waiters.wait_for_server_status(self.manager.servers_client,
self.server_id, 'ACTIVE')
def _destroy_vm(self):
self.logger.info("deleting %s" % self.server_id)
@ -172,8 +173,8 @@ class FloatingStress(stressaction.StressAction):
self._create_vm()
if self.reboot:
self.manager.servers_client.reboot(self.server_id, 'HARD')
self.manager.servers_client.wait_for_server_status(self.server_id,
'ACTIVE')
waiters.wait_for_server_status(self.manager.servers_client,
self.server_id, 'ACTIVE')
self.run_core()

View File

@ -12,6 +12,7 @@
# limitations under the License.
from tempest.common.utils import data_utils
from tempest.common import waiters
from tempest import config
import tempest.stress.stressaction as stressaction
@ -40,7 +41,8 @@ class VolumeAttachDeleteTest(stressaction.StressAction):
server = self.manager.servers_client.create_server(
vm_name, self.image, self.flavor)
server_id = server['id']
self.manager.servers_client.wait_for_server_status(server_id, 'ACTIVE')
waiters.wait_for_server_status(self.manager.servers_client, server_id,
'ACTIVE')
self.logger.info("created vm %s" % server_id)
# Step 3: attach volume to vm

View File

@ -14,6 +14,7 @@ import re
from tempest.common.utils import data_utils
from tempest.common.utils.linux import remote_client
from tempest.common import waiters
from tempest import config
import tempest.stress.stressaction as stressaction
import tempest.test
@ -41,8 +42,8 @@ class VolumeVerifyStress(stressaction.StressAction):
self.flavor,
**vm_args)
self.server_id = server['id']
self.manager.servers_client.wait_for_server_status(self.server_id,
'ACTIVE')
waiters.wait_for_server_status(self.manager.servers_client,
self.server_id, 'ACTIVE')
def _destroy_vm(self):
self.logger.info("deleting server: %s" % self.server_id)