def _shelve_then_unshelve_server(self, server):
compute.shelve_server(self.servers_client, server['id'],
force_shelve_offload=True)
self.servers_client.unshelve_server(server['id'])
waiters.wait_for_server_status(self.servers_client, server['id'],
'ACTIVE')
def test_shelve_unshelve_server(self):
if CONF.image_feature_enabled.api_v2:
glance_client = self.os_primary.image_client_v2
elif CONF.image_feature_enabled.api_v1:
glance_client = self.os_primary.image_client
else:
raise lib_exc.InvalidConfiguration(
'Either api_v1 or api_v2 must be True in '
'[image-feature-enabled].')
compute.shelve_server(self.client, self.server_id,
force_shelve_offload=True)
def _unshelve_server():
server_info = self.client.show_server(self.server_id)['server']
if 'SHELVED' in server_info['status']:
self.client.unshelve_server(self.server_id)
self.addCleanup(_unshelve_server)
server = self.client.show_server(self.server_id)['server']
image_name = server['name'] + '-shelved'
params = {'name': image_name}
if CONF.image_feature_enabled.api_v2:
images = glance_client.list_images(params)['images']
elif CONF.image_feature_enabled.api_v1:
images = glance_client.list_images(
detail=True, **params)['images']
self.assertEqual(1, len(images))
self.assertEqual(image_name, images[0]['name'])
self.client.unshelve_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
glance_client.wait_for_resource_deletion(images[0]['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 _create_and_attach(self, shelve_server=False):
# Start a server and wait for it to become ready
self.admin_pass = self.image_ssh_password
self.server = self.create_test_server(
validatable=True,
wait_until='ACTIVE',
adminPass=self.admin_pass)
# Record addresses so that we can ssh later
self.server['addresses'] = self.servers_client.list_addresses(
self.server['id'])['addresses']
# Create a volume and wait for it to become ready
self.volume = self.volumes_client.create_volume(
size=CONF.volume.volume_size, display_name='test')['volume']
self.addCleanup(self._delete_volume)
waiters.wait_for_volume_status(self.volumes_client,
self.volume['id'], 'available')
if shelve_server:
compute.shelve_server(self.servers_client, self.server['id'])
# Attach the volume to the server
self.attachment = self.servers_client.attach_volume(
self.server['id'],
volumeId=self.volume['id'],
device='/dev/%s' % self.device)['volumeAttachment']
waiters.wait_for_volume_status(self.volumes_client,
self.volume['id'], 'in-use')
self.addCleanup(self._detach, self.server['id'], self.volume['id'])
def test_shelve_shelved_server(self):
# shelve a shelved server.
compute.shelve_server(self.client, self.server_id)
def _unshelve_server():
server_info = self.client.show_server(self.server_id)['server']
if 'SHELVED' in server_info['status']:
self.client.unshelve_server(self.server_id)
self.addCleanup(_unshelve_server)
server = self.client.show_server(self.server_id)['server']
image_name = server['name'] + '-shelved'
if CONF.image_feature_enabled.api_v1:
kwargs = {'name': image_name}
else:
kwargs = {'params': {'name': image_name}}
images = self.images_client.list_images(**kwargs)['images']
self.assertEqual(1, len(images))
self.assertEqual(image_name, images[0]['name'])
self.assertRaises(lib_exc.Conflict,
self.client.shelve_server,
self.server_id)
self.client.unshelve_server(self.server_id)
def test_shelve_unshelve_server(self):
if CONF.image_feature_enabled.api_v2:
glance_client = self.os_primary.image_client_v2
elif CONF.image_feature_enabled.api_v1:
glance_client = self.os_primary.image_client
else:
raise lib_exc.InvalidConfiguration(
'Either api_v1 or api_v2 must be True in '
'[image-feature-enabled].')
compute.shelve_server(self.client,
self.server_id,
force_shelve_offload=True)
server = self.client.show_server(self.server_id)['server']
image_name = server['name'] + '-shelved'
params = {'name': image_name}
if CONF.image_feature_enabled.api_v2:
images = glance_client.list_images(params)['images']
elif CONF.image_feature_enabled.api_v1:
images = glance_client.list_images(detail=True, **params)['images']
self.assertEqual(1, len(images))
self.assertEqual(image_name, images[0]['name'])
self.client.unshelve_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
glance_client.wait_for_resource_deletion(images[0]['id'])
def test_shelve_paused_server(self):
server = self.create_test_server(wait_until='ACTIVE')
self.client.pause_server(server['id'])
waiters.wait_for_server_status(self.client, server['id'], 'PAUSED')
# Check if Shelve operation is successful on paused server.
compute.shelve_server(self.client, server['id'],
force_shelve_offload=True)
def test_shelve_shelved_server(self):
"""Shelving a shelved server should fail"""
compute.shelve_server(self.client, self.server_id)
def _unshelve_server():
server_info = self.client.show_server(self.server_id)['server']
if 'SHELVED' in server_info['status']:
self.client.unshelve_server(self.server_id)
self.addCleanup(_unshelve_server)
server = self.client.show_server(self.server_id)['server']
image_name = server['name'] + '-shelved'
if CONF.image_feature_enabled.api_v1:
kwargs = {'name': image_name}
else:
kwargs = {'params': {'name': image_name}}
images = self.images_client.list_images(**kwargs)['images']
self.assertEqual(1, len(images))
self.assertEqual(image_name, images[0]['name'])
self.assertRaises(lib_exc.Conflict, self.client.shelve_server,
self.server_id)
self.client.unshelve_server(self.server_id)
def _shelve_then_unshelve_server(self, server):
compute.shelve_server(self.servers_client, server['id'],
force_shelve_offload=True)
self.servers_client.unshelve_server(server['id'])
waiters.wait_for_server_status(self.servers_client, server['id'],
'ACTIVE')
def test_shelve_unshelve_server(self):
compute.shelve_server(self.client, self.server_id, force_shelve_offload=True)
server = self.client.show_server(self.server_id)["server"]
image_name = server["name"] + "-shelved"
params = {"name": image_name}
images = self.compute_images_client.list_images(**params)["images"]
self.assertEqual(1, len(images))
self.assertEqual(image_name, images[0]["name"])
self.client.unshelve_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id, "ACTIVE")
def test_shelve_unshelve_server(self):
compute.shelve_server(self.client, self.server_id,
force_shelve_offload=True)
server = self.client.show_server(self.server_id)['server']
image_name = server['name'] + '-shelved'
params = {'name': image_name}
images = self.compute_images_client.list_images(**params)['images']
self.assertEqual(1, len(images))
self.assertEqual(image_name, images[0]['name'])
self.client.unshelve_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
def test_shelve_unshelve_server(self):
compute.shelve_server(self.client, self.server_id,
force_shelve_offload=True)
server = self.client.show_server(self.server_id)['server']
image_name = server['name'] + '-shelved'
params = {'name': image_name}
images = self.compute_images_client.list_images(**params)['images']
self.assertEqual(1, len(images))
self.assertEqual(image_name, images[0]['name'])
self.client.unshelve_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
def test_shelve_shelved_server(self):
# shelve a shelved server.
compute.shelve_server(self.client, self.server_id)
server = self.client.show_server(self.server_id)['server']
image_name = server['name'] + '-shelved'
params = {'name': image_name}
images = self.compute_images_client.list_images(**params)['images']
self.assertEqual(1, len(images))
self.assertEqual(image_name, images[0]['name'])
self.assertRaises(lib_exc.Conflict, self.client.shelve_server,
self.server_id)
self.client.unshelve_server(self.server_id)
def test_shelve_shelved_server(self):
# shelve a shelved server.
compute.shelve_server(self.client, self.server_id)
server = self.client.show_server(self.server_id)['server']
image_name = server['name'] + '-shelved'
params = {'name': image_name}
images = self.compute_images_client.list_images(**params)['images']
self.assertEqual(1, len(images))
self.assertEqual(image_name, images[0]['name'])
self.assertRaises(lib_exc.Conflict,
self.client.shelve_server,
self.server_id)
self.client.unshelve_server(self.server_id)
def _create_and_attach(self, shelve_server=False):
# Start a server and wait for it to become ready
self.admin_pass = self.image_ssh_password
self.server = self.create_test_server(
validatable=True,
wait_until='ACTIVE',
adminPass=self.admin_pass)
# Record addresses so that we can ssh later
self.server['addresses'] = self.servers_client.list_addresses(
self.server['id'])['addresses']
# Create a volume and wait for it to become ready
self.volume = self.volumes_client.create_volume(
size=CONF.volume.volume_size, display_name='test')['volume']
self.addCleanup(self._delete_volume)
waiters.wait_for_volume_status(self.volumes_client,
self.volume['id'], 'available')
if shelve_server:
if CONF.validation.run_validation:
# NOTE(andreaf) If we are going to shelve a server, we should
# check first whether the server is ssh-able. Otherwise we
# won't be able to distinguish failures introduced by shelve
# from pre-existing ones. Also it's good to wait for cloud-init
# to be done and sshd server to be running before shelving to
# avoid breaking the VM
linux_client = remote_client.RemoteClient(
self.get_server_ip(self.server),
self.image_ssh_user,
self.admin_pass,
self.validation_resources['keypair']['private_key'])
linux_client.validate_authentication()
# If validation went ok, or it was skipped, shelve the server
compute.shelve_server(self.servers_client, self.server['id'])
# Attach the volume to the server
self.attachment = self.servers_client.attach_volume(
self.server['id'],
volumeId=self.volume['id'],
device='/dev/%s' % self.device)['volumeAttachment']
waiters.wait_for_volume_status(self.volumes_client,
self.volume['id'], 'in-use')
self.addCleanup(self._detach, self.server['id'], self.volume['id'])
def _create_and_attach(self, shelve_server=False):
# Start a server and wait for it to become ready
self.admin_pass = self.image_ssh_password
self.server = self.create_test_server(validatable=True,
wait_until='ACTIVE',
adminPass=self.admin_pass)
# Record addresses so that we can ssh later
self.server['addresses'] = self.servers_client.list_addresses(
self.server['id'])['addresses']
# Create a volume and wait for it to become ready
self.volume = self.volumes_client.create_volume(
size=CONF.volume.volume_size, display_name='test')['volume']
self.addCleanup(self._delete_volume)
waiters.wait_for_volume_status(self.volumes_client, self.volume['id'],
'available')
if shelve_server:
if CONF.validation.run_validation:
# NOTE(andreaf) If we are going to shelve a server, we should
# check first whether the server is ssh-able. Otherwise we
# won't be able to distinguish failures introduced by shelve
# from pre-existing ones. Also it's good to wait for cloud-init
# to be done and sshd server to be running before shelving to
# avoid breaking the VM
linux_client = remote_client.RemoteClient(
self.get_server_ip(self.server), self.image_ssh_user,
self.admin_pass,
self.validation_resources['keypair']['private_key'])
linux_client.validate_authentication()
# If validation went ok, or it was skipped, shelve the server
compute.shelve_server(self.servers_client, self.server['id'])
# Attach the volume to the server
self.attachment = self.servers_client.attach_volume(
self.server['id'],
volumeId=self.volume['id'],
device='/dev/%s' % self.device)['volumeAttachment']
waiters.wait_for_volume_status(self.volumes_client, self.volume['id'],
'in-use')
self.addCleanup(self._detach, self.server['id'], self.volume['id'])
def _shelve_server(self, server):
# NOTE(andreaf) If we are going to shelve a server, we should
# check first whether the server is ssh-able. Otherwise we
# won't be able to distinguish failures introduced by shelve
# from pre-existing ones. Also it's good to wait for cloud-init
# to be done and sshd server to be running before shelving to
# avoid breaking the VM
if CONF.validation.run_validation:
linux_client = remote_client.RemoteClient(
self.get_server_ip(server),
self.image_ssh_user,
self.image_ssh_password,
self.validation_resources['keypair']['private_key'],
server=server,
servers_client=self.servers_client)
linux_client.validate_authentication()
# If validation went ok, or it was skipped, shelve the server
compute.shelve_server(self.servers_client, server['id'])
def _shelve_server(self, server):
# NOTE(andreaf) If we are going to shelve a server, we should
# check first whether the server is ssh-able. Otherwise we
# won't be able to distinguish failures introduced by shelve
# from pre-existing ones. Also it's good to wait for cloud-init
# to be done and sshd server to be running before shelving to
# avoid breaking the VM
if CONF.validation.run_validation:
linux_client = remote_client.RemoteClient(
self.get_server_ip(server),
self.image_ssh_user,
self.image_ssh_password,
self.validation_resources['keypair']['private_key'],
server=server,
servers_client=self.servers_client)
linux_client.validate_authentication()
# If validation went ok, or it was skipped, shelve the server
compute.shelve_server(self.servers_client, server['id'])
def test_shelve_shelved_server(self):
# shelve a shelved server.
compute.shelve_server(self.client, self.server_id)
def _unshelve_server():
server_info = self.client.show_server(self.server_id)['server']
if 'SHELVED' in server_info['status']:
self.client.unshelve_server(self.server_id)
self.addOnException(_unshelve_server)
server = self.client.show_server(self.server_id)['server']
image_name = server['name'] + '-shelved'
params = {'name': image_name}
images = self.compute_images_client.list_images(**params)['images']
self.assertEqual(1, len(images))
self.assertEqual(image_name, images[0]['name'])
self.assertRaises(lib_exc.Conflict, self.client.shelve_server,
self.server_id)
self.client.unshelve_server(self.server_id)
