def test_rebuild_failures(self, mock_save, mock_get, mock_driver_fields,
mock_fg_bid, mock_set_pstate):
node_uuid = uuidutils.generate_uuid()
instance_uuid = uuidutils.generate_uuid()
node = ironic_utils.get_test_node(uuid=node_uuid,
instance_uuid=instance_uuid,
instance_type_id=5)
mock_get.return_value = node
image_meta = ironic_utils.get_test_image_meta()
flavor_id = 5
flavor = {'id': flavor_id, 'name': 'baremetal'}
mock_fg_bid.return_value = flavor
instance = fake_instance.fake_instance_obj(self.ctx,
uuid=instance_uuid,
node=node_uuid,
instance_type_id=flavor_id)
exceptions = [
exception.NovaException(),
ironic_exception.BadRequest(),
ironic_exception.InternalServerError(),
]
for e in exceptions:
mock_set_pstate.side_effect = e
self.assertRaises(exception.InstanceDeployFailure,
self.driver.rebuild,
context=self.ctx, instance=instance, image_meta=image_meta,
injected_files=None, admin_password=None, bdms=None,
detach_block_devices=None, attach_block_devices=None)
def test__node_resources_unavailable(self):
node_dicts = [
# a node in maintenance /w no instance and power OFF
{"uuid": uuidutils.generate_uuid(), "maintenance": True, "power_state": ironic_states.POWER_OFF},
# a node in maintenance /w no instance and ERROR power state
{"uuid": uuidutils.generate_uuid(), "maintenance": True, "power_state": ironic_states.ERROR},
# a node not in maintenance /w no instance and bad power state
{"uuid": uuidutils.generate_uuid(), "power_state": ironic_states.NOSTATE},
]
for n in node_dicts:
node = ironic_utils.get_test_node(**n)
self.assertTrue(self.driver._node_resources_unavailable(node))
avail_node = ironic_utils.get_test_node(power_state=ironic_states.POWER_OFF)
self.assertFalse(self.driver._node_resources_unavailable(avail_node))
def test_create_vm_invalid_guestid(self, mock_log_warn):
"""Ensure we warn when create_vm() fails after we passed an
unrecognised guestId
"""
found = [False]
def fake_log_warn(msg, values):
if not isinstance(values, dict):
return
if values.get('ostype') == 'invalid_os_type':
found[0] = True
mock_log_warn.side_effect = fake_log_warn
instance_values = {'id': 7, 'name': 'fake-name',
'uuid': uuidutils.generate_uuid(),
'vcpus': 2, 'memory_mb': 2048}
instance = fake_instance.fake_instance_obj(
context.RequestContext('fake', 'fake', is_admin=False),
**instance_values)
session = driver.VMwareAPISession()
config_spec = vm_util.get_vm_create_spec(
session.vim.client.factory,
instance, instance.name, 'fake-datastore', [],
vm_util.ExtraSpecs(),
os_type='invalid_os_type')
self.assertRaises(vexc.VMwareDriverException,
vm_util.create_vm, session, instance, 'folder',
config_spec, 'res-pool')
self.assertTrue(found[0])
def test__node_resource(self):
node_uuid = uuidutils.generate_uuid()
instance_uuid = uuidutils.generate_uuid()
props = _get_properties()
stats = _get_stats()
node = ironic_utils.get_test_node(uuid=node_uuid, instance_uuid=instance_uuid, properties=props)
result = self.driver._node_resource(node)
self.assertEqual(props["cpus"], result["vcpus"])
self.assertEqual(props["cpus"], result["vcpus_used"])
self.assertEqual(props["memory_mb"], result["memory_mb"])
self.assertEqual(props["memory_mb"], result["memory_mb_used"])
self.assertEqual(props["local_gb"], result["local_gb"])
self.assertEqual(props["local_gb"], result["local_gb_used"])
self.assertEqual(node_uuid, result["hypervisor_hostname"])
self.assertEqual(stats, jsonutils.loads(result["stats"]))
def setUp(self):
super(CreateBackupTests, self).setUp()
self.stubs.Set(compute_api.API, 'get', fake_compute_api_get)
self.backup_stubs = fakes.stub_out_compute_api_backup(self.stubs)
self.app = compute.APIRouter(init_only=('servers',))
self.uuid = uuidutils.generate_uuid()
def setUp(self):
super(_ImageTestCase, self).setUp()
self.INSTANCES_PATH = tempfile.mkdtemp(suffix='instances')
self.flags(disable_process_locking=True,
instances_path=self.INSTANCES_PATH)
self.INSTANCE = {'name': 'instance',
'uuid': uuidutils.generate_uuid()}
self.DISK_INFO_PATH = os.path.join(self.INSTANCES_PATH,
self.INSTANCE['uuid'], 'disk.info')
self.NAME = 'fake.vm'
self.TEMPLATE = 'template'
self.OLD_STYLE_INSTANCE_PATH = \
fake_libvirt_utils.get_instance_path(self.INSTANCE, forceold=True)
self.PATH = os.path.join(
fake_libvirt_utils.get_instance_path(self.INSTANCE), self.NAME)
# TODO(mikal): rename template_dir to base_dir and template_path
# to cached_image_path. This will be less confusing.
self.TEMPLATE_DIR = os.path.join(CONF.instances_path, '_base')
self.TEMPLATE_PATH = os.path.join(self.TEMPLATE_DIR, 'template')
self.useFixture(fixtures.MonkeyPatch(
'nova.virt.libvirt.imagebackend.libvirt_utils',
fake_libvirt_utils))
def fake_chown(path, owner_uid=None):
return None
self.stubs.Set(utils, 'chown', fake_chown)
def test_get_vm_create_spec_with_limit(self):
instance_uuid = uuidutils.generate_uuid()
fake_instance = {'id': 7, 'name': 'fake!',
'uuid': instance_uuid,
'vcpus': 2, 'memory_mb': 2048}
result = vm_util.get_vm_create_spec(fake.FakeFactory(),
fake_instance, instance_uuid,
'fake-datastore', [],
allocations={'cpu_limit': 7})
expected = """{
'files': {'vmPathName': '[fake-datastore]',
'obj_name': 'ns0:VirtualMachineFileInfo'},
'instanceUuid': '%(instance_uuid)s',
'name': '%(instance_uuid)s', 'deviceChange': [],
'extraConfig': [{'value': '%(instance_uuid)s',
'key': 'nvp.vm-uuid',
'obj_name': 'ns0:OptionValue'}],
'memoryMB': 2048,
'managedBy': {'extensionKey': 'org.openstack.compute',
'type': 'instance',
'obj_name': 'ns0:ManagedByInfo'},
'obj_name': 'ns0:VirtualMachineConfigSpec',
'guestId': 'otherGuest',
'tools': {'beforeGuestStandby': True,
'beforeGuestReboot': True,
'beforeGuestShutdown': True,
'afterResume': True,
'afterPowerOn': True,
'obj_name': 'ns0:ToolsConfigInfo'},
'cpuAllocation': {'limit': 7,
'obj_name': 'ns0:ResourceAllocationInfo'},
'numCPUs': 2}""" % {'instance_uuid': instance_uuid}
expected = re.sub(r'\s+', '', expected)
result = re.sub(r'\s+', '', repr(result))
self.assertEqual(expected, result)
def test_get_instances_on_driver(self):
fake_context = context.get_admin_context()
driver_instances = []
for x in xrange(10):
instance = dict(uuid=uuidutils.generate_uuid())
driver_instances.append(instance)
self.mox.StubOutWithMock(self.compute.driver,
'list_instance_uuids')
self.mox.StubOutWithMock(self.compute.conductor_api,
'instance_get_all_by_filters')
self.compute.driver.list_instance_uuids().AndReturn(
[inst['uuid'] for inst in driver_instances])
self.compute.conductor_api.instance_get_all_by_filters(
fake_context,
{'uuid': [inst['uuid'] for
inst in driver_instances]},
columns_to_join=[]).AndReturn(
driver_instances)
self.mox.ReplayAll()
result = self.compute._get_instances_on_driver(fake_context,
columns_to_join=[])
self.assertEqual(driver_instances, result)
def test_get_instances_on_driver_fallback(self):
# Test getting instances when driver doesn't support
# 'list_instance_uuids'
self.compute.host = 'host'
filters = {'host': self.compute.host}
fake_context = context.get_admin_context()
all_instances = []
driver_instances = []
for x in xrange(10):
instance = dict(name=uuidutils.generate_uuid())
if x % 2:
driver_instances.append(instance)
all_instances.append(instance)
self.mox.StubOutWithMock(self.compute.driver,
'list_instance_uuids')
self.mox.StubOutWithMock(self.compute.driver,
'list_instances')
self.mox.StubOutWithMock(self.compute.conductor_api,
'instance_get_all_by_filters')
self.compute.driver.list_instance_uuids().AndRaise(
NotImplementedError())
self.compute.driver.list_instances().AndReturn(
[inst['name'] for inst in driver_instances])
self.compute.conductor_api.instance_get_all_by_filters(
fake_context, filters,
columns_to_join=None).AndReturn(all_instances)
self.mox.ReplayAll()
result = self.compute._get_instances_on_driver(fake_context, filters)
self.assertEqual(driver_instances, result)
def test_get_info_http_not_found(self, mock_gbiu):
mock_gbiu.side_effect = ironic_exception.NotFound()
expected = {"state": nova_states.NOSTATE, "max_mem": 0, "mem": 0, "num_cpu": 0, "cpu_time": 0}
instance = fake_instance.fake_instance_obj(self.ctx, uuid=uuidutils.generate_uuid())
result = self.driver.get_info(instance)
self.assertEqual(expected, result)
def test_macs_for_instance_http_not_found(self, mock_get):
mock_get.side_effect = ironic_exception.NotFound()
instance = fake_instance.fake_instance_obj(
self.ctx, node=uuidutils.generate_uuid())
result = self.driver.macs_for_instance(instance)
self.assertEqual([], result)
def test_get_vm_create_spec(self):
instance_uuid = uuidutils.generate_uuid()
fake_instance = {"id": 7, "name": "fake!", "uuid": instance_uuid, "vcpus": 2, "memory_mb": 2048}
result = vm_util.get_vm_create_spec(fake.FakeFactory(), fake_instance, instance_uuid, "fake-datastore", [])
expected = """{
'files': {'vmPathName': '[fake-datastore]',
'obj_name': 'ns0:VirtualMachineFileInfo'},
'instanceUuid': '%(instance_uuid)s',
'name': '%(instance_uuid)s', 'deviceChange': [],
'extraConfig': [{'value': '%(instance_uuid)s',
'key': 'nvp.vm-uuid',
'obj_name': 'ns0:OptionValue'}],
'memoryMB': 2048,
'obj_name': 'ns0:VirtualMachineConfigSpec',
'guestId': 'otherGuest',
'tools': {'beforeGuestStandby': True,
'beforeGuestReboot': True,
'beforeGuestShutdown': True,
'afterResume': True,
'afterPowerOn': True,
'obj_name': 'ns0:ToolsConfigInfo'},
'numCPUs': 2}""" % {
"instance_uuid": instance_uuid
}
expected = re.sub(r"\s+", "", expected)
result = re.sub(r"\s+", "", repr(result))
self.assertEqual(expected, result)
def test_node_is_available(self, mock_get):
no_guid = None
any_guid = uuidutils.generate_uuid()
in_maintenance = True
is_available = True
not_in_maintenance = False
not_available = False
power_off = ironic_states.POWER_OFF
not_power_off = ironic_states.POWER_ON
testing_set = {(no_guid, not_in_maintenance, power_off):is_available,
(no_guid, not_in_maintenance, not_power_off):not_available,
(no_guid, in_maintenance, power_off):not_available,
(no_guid, in_maintenance, not_power_off):not_available,
(any_guid, not_in_maintenance, power_off):not_available,
(any_guid, not_in_maintenance, not_power_off):not_available,
(any_guid, in_maintenance, power_off):not_available,
(any_guid, in_maintenance, not_power_off):not_available}
for key in testing_set.keys():
node = ironic_utils.get_test_node(instance_uuid=key[0],
maintenance=key[1],
power_state=key[2])
mock_get.return_value = node
expected = testing_set[key]
observed = self.driver.node_is_available("dummy_nodename")
self.assertEqual(expected, observed)
def _init_cells_scheduler(self):
fakes.init(self)
self.msg_runner = fakes.get_message_runner('api-cell')
self.scheduler = self.msg_runner.scheduler
self.state_manager = self.msg_runner.state_manager
self.my_cell_state = self.state_manager.get_my_state()
self.ctxt = context.RequestContext('fake', 'fake')
instance_uuids = []
for x in xrange(3):
instance_uuids.append(uuidutils.generate_uuid())
self.instance_uuids = instance_uuids
self.instances = [{'uuid': uuid} for uuid in instance_uuids]
self.request_spec = {
'instance_uuids': instance_uuids,
'instance_properties': 'fake_properties',
'instance_type': 'fake_type',
'image': 'fake_image',
'security_group': 'fake_sec_groups',
'block_device_mapping': 'fake_bdm'}
self.build_inst_kwargs = {
'instances': self.instances,
'image': 'fake_image',
'filter_properties': {'instance_type': 'fake_type'},
'security_groups': 'fake_sec_groups',
'block_device_mapping': 'fake_bdm'}
def test_spawn_setting_instance_uuid_fail(self):
instance = fake_instance.fake_instance_obj(self.ctx,
node=uuidutils.generate_uuid())
with mock.patch.object(FAKE_CLIENT.node, 'update') as mock_update:
mock_update.side_effect = ironic_exception.HTTPBadRequest()
self.assertRaises(exception.NovaException, self.driver.spawn,
self.ctx, instance, None, [], None)
def _init_cells_scheduler(self):
fakes.init(self)
self.msg_runner = fakes.get_message_runner("api-cell")
self.scheduler = self.msg_runner.scheduler
self.state_manager = self.msg_runner.state_manager
self.my_cell_state = self.state_manager.get_my_state()
self.ctxt = context.RequestContext("fake", "fake")
instance_uuids = []
for x in xrange(3):
instance_uuids.append(uuidutils.generate_uuid())
self.instance_uuids = instance_uuids
self.instances = [objects.Instance(uuid=uuid, id=id) for id, uuid in enumerate(instance_uuids)]
self.request_spec = {
"num_instances": len(instance_uuids),
"instance_properties": self.instances[0],
"instance_type": "fake_type",
"image": "fake_image",
}
self.build_inst_kwargs = {
"instances": self.instances,
"image": "fake_image",
"filter_properties": {"instance_type": "fake_type"},
"security_groups": "fake_sec_groups",
"block_device_mapping": "fake_bdm",
}
def _login(self):
"""Logs in and sets the session object in the db."""
self._session = uuidutils.generate_uuid()
session = DataObject()
session.key = self._session
_db_content['session'][self._session] = session
return session
def __init__(self, msg_runner, ctxt, method_name, method_kwargs,
direction, need_response=False, fanout=False, uuid=None,
routing_path=None, hop_count=0, max_hop_count=None,
**kwargs):
self.ctxt = ctxt
self.resp_queue = None
self.msg_runner = msg_runner
self.state_manager = msg_runner.state_manager
# Copy these.
self.base_attrs_to_json = self.base_attrs_to_json[:]
# Normally this would just be CONF.cells.name, but going through
# the msg_runner allows us to stub it more easily.
self.our_path_part = self.msg_runner.our_name
self.uuid = uuid
if self.uuid is None:
self.uuid = uuidutils.generate_uuid()
self.method_name = method_name
self.method_kwargs = method_kwargs
self.direction = direction
self.need_response = need_response
self.fanout = fanout
self.routing_path = routing_path
self.hop_count = hop_count
if max_hop_count is None:
max_hop_count = CONF.cells.max_hop_count
self.max_hop_count = max_hop_count
self.is_broadcast = False
self._append_hop()
# Each sub-class should set this when the message is inited
self.next_hops = []
self.resp_queue = None
def test_macs_for_instance_http_not_found(self):
with mock.patch.object(FAKE_CLIENT.node, 'get') as mock_get:
mock_get.side_effect = ironic_exception.NotFound()
instance = fake_instance.fake_instance_obj(
self.ctx, node=uuidutils.generate_uuid())
result = self.driver.macs_for_instance(instance)
self.assertEqual([], result)
def setUp(self):
super(ResetStateTestsV21, self).setUp()
self.uuid = uuidutils.generate_uuid()
self.admin_api = self.admin_act.AdminActionsController()
self.compute_api = self.admin_api.compute_api
self.request = self._get_request()
self.context = self.request.environ['nova.context']
def setUp(self):
super(AdminActionsTest, self).setUp()
self.stubs.Set(compute_api.API, 'get', fake_compute_api_get)
self.UUID = uuidutils.generate_uuid()
self.app = fakes.wsgi_app_v3(init_only=('servers',
'os-admin-actions'))
for _method in self._methods:
self.stubs.Set(compute_api.API, _method, fake_compute_api)
def _test_rebuild(
self,
mock_save,
mock_get,
mock_driver_fields,
mock_fg_bid,
mock_set_pstate,
mock_looping,
mock_wait_active,
preserve=False,
):
node_uuid = uuidutils.generate_uuid()
instance_uuid = uuidutils.generate_uuid()
node = ironic_utils.get_test_node(uuid=node_uuid, instance_uuid=instance_uuid, instance_type_id=5)
mock_get.return_value = node
image_meta = ironic_utils.get_test_image_meta()
flavor_id = 5
flavor = {"id": flavor_id, "name": "baremetal"}
mock_fg_bid.return_value = flavor
instance = fake_instance.fake_instance_obj(
self.ctx, uuid=instance_uuid, node=node_uuid, instance_type_id=flavor_id
)
fake_looping_call = FakeLoopingCall()
mock_looping.return_value = fake_looping_call
self.driver.rebuild(
context=self.ctx,
instance=instance,
image_meta=image_meta,
injected_files=None,
admin_password=None,
bdms=None,
detach_block_devices=None,
attach_block_devices=None,
preserve_ephemeral=preserve,
)
mock_save.assert_called_once_with(expected_task_state=[task_states.REBUILDING])
mock_driver_fields.assert_called_once_with(node, instance, image_meta, flavor, preserve)
mock_set_pstate.assert_called_once_with(node_uuid, ironic_states.REBUILD)
mock_looping.assert_called_once_with(mock_wait_active, FAKE_CLIENT_WRAPPER, instance)
fake_looping_call.start.assert_called_once_with(interval=CONF.ironic.api_retry_interval)
fake_looping_call.wait.assert_called_once()
def test_validate_instance_and_node_failed(self, mock_gbiui):
icli = cw.IronicClientWrapper()
mock_gbiui.side_effect = ironic_exception.NotFound()
instance_uuid = uuidutils.generate_uuid(),
instance = fake_instance.fake_instance_obj(self.ctx,
uuid=instance_uuid)
self.assertRaises(exception.InstanceNotFound,
ironic_driver.validate_instance_and_node,
icli, instance)
def test_get_available_nodes(self, mock_list):
node_dicts = [
# a node in maintenance /w no instance and power OFF
{"uuid": uuidutils.generate_uuid(), "maintenance": True, "power_state": ironic_states.POWER_OFF},
# a node /w instance and power ON
{
"uuid": uuidutils.generate_uuid(),
"instance_uuid": uuidutils.generate_uuid(),
"power_state": ironic_states.POWER_ON,
},
# a node not in maintenance /w no instance and bad power state
{"uuid": uuidutils.generate_uuid(), "power_state": ironic_states.ERROR},
]
nodes = [ironic_utils.get_test_node(**n) for n in node_dicts]
mock_list.return_value = nodes
available_nodes = self.driver.get_available_nodes()
expected_uuids = [n["uuid"] for n in node_dicts]
self.assertEqual(sorted(expected_uuids), sorted(available_nodes))
def setUp(self):
super(ResetStateTestsV21, self).setUp()
self.uuid = uuidutils.generate_uuid()
self.admin_api = self.admin_act.AdminActionsController()
self.compute_api = self.admin_api.compute_api
url = "%s/%s/action" % (self.fake_url, self.uuid)
self.request = self._get_request(url)
self.context = self.request.environ["nova.context"]
def _stub_instance_get(self, uuid=None):
if uuid is None:
uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_db_instance(
id=1, uuid=uuid, vm_state=vm_states.ACTIVE, task_state=None, launched_at=timeutils.utcnow()
)
instance = objects.Instance._from_db_object(self.context, objects.Instance(), instance)
self.compute_api.get(self.context, uuid, want_objects=True).AndReturn(instance)
return instance
def _stub_instance_get(self, uuid=None):
if uuid is None:
uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_instance_obj(self.context,
id=1, uuid=uuid, vm_state=vm_states.ACTIVE,
task_state=None, launched_at=timeutils.utcnow())
self.compute_api.get(self.context, uuid, expected_attrs=None,
want_objects=True).AndReturn(instance)
return instance
def _stub_instance_get_failure(self, exc_info, uuid=None, objects=True):
if uuid is None:
uuid = uuidutils.generate_uuid()
if objects:
self.compute_api.get(self.context, uuid,
want_objects=True).AndRaise(exc_info)
else:
self.compute_api.get(self.context, uuid).AndRaise(exc_info)
return uuid
def _stub_instance_get(self, uuid=None):
self.mox.StubOutWithMock(compute_api.API, "get")
if uuid is None:
uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_db_instance(id=1, uuid=uuid, vm_state=vm_states.ACTIVE, task_state=None)
instance = objects.Instance._from_db_object(self.context, objects.Instance(), instance)
self.compute_api.get(self.context, uuid, want_objects=True).AndReturn(instance)
return instance
def create(self, req, body):
context = req.environ['nova.context']
server_dict = body['app']
name = server_dict['name']
self._validate_server_name(name)
name = name.strip()
if server_dict.get('uuid') != None:
uuid = server_dict['uuid']
app = dict();
app['uuid'] = uuid;
app['display_name'] = name;
self.compute_api.failover_app (context, app=app)
appR = self._view_builder.create(req, app);
robj = wsgi.ResponseObject(appR);
return robj;
else:
uuid = '';
network_bandwidth = server_dict.get('network_bandwidth');
memory_mb = server_dict.get('memory_mb');
disk_gb = server_dict.get('disk_gb');
ports = server_dict.get('ports');
for port in ports:
LOG.info(_(port));
if network_bandwidth == None:
LOG.info(_("None bandwidth"));
if memory_mb == None:
LOG.info(_("None memory"));
if disk_gb == None:
LOG.info(_("None disk"));
app = dict();
app['network_bandwidth'] = network_bandwidth;
app['memory_mb'] = memory_mb;
app['disk_gb'] = disk_gb;
app['uuid'] = uuidutils.generate_uuid();
app['display_name'] = name;
app['ports'] = ports;
self.compute_api.create_app (context, app=app,
network_bandwidth=network_bandwidth,
memory_mb=memory_mb,
disk_gb=disk_gb);
appR = self._view_builder.create(req, app);
robj = wsgi.ResponseObject(appR);
return robj;
def generate_request_id():
return 'req-%s' % uuidutils.generate_uuid()
def test_swap_volume_volume_api_usage(self):
# This test ensures that volume_id arguments are passed to volume_api
# and that volumes return to previous states in case of error.
def fake_vol_api_begin_detaching(context, volume_id):
self.assertTrue(uuidutils.is_uuid_like(volume_id))
volumes[volume_id]['status'] = 'detaching'
def fake_vol_api_roll_detaching(context, volume_id):
self.assertTrue(uuidutils.is_uuid_like(volume_id))
if volumes[volume_id]['status'] == 'detaching':
volumes[volume_id]['status'] = 'in-use'
def fake_vol_api_reserve(context, volume_id):
self.assertTrue(uuidutils.is_uuid_like(volume_id))
self.assertTrue(volumes[volume_id]['status'], 'available')
volumes[volume_id]['status'] = 'attaching'
def fake_vol_api_unreserve(context, volume_id):
self.assertTrue(uuidutils.is_uuid_like(volume_id))
if volumes[volume_id]['status'] == 'attaching':
volumes[volume_id]['status'] = 'available'
def fake_swap_volume_exc(context, instance, old_volume_id,
new_volume_id):
raise AttributeError # Random exception
# Should fail if VM state is not valid
instance = {'vm_state': vm_states.BUILDING,
'launched_at': timeutils.utcnow(),
'locked': False,
'availability_zone': 'fake_az',
'uuid': 'fake'}
volumes = {}
old_volume_id = uuidutils.generate_uuid()
volumes[old_volume_id] = {'id': old_volume_id,
'display_name': 'old_volume',
'attach_status': 'attached',
'instance_uuid': 'fake',
'size': 5,
'status': 'in-use'}
new_volume_id = uuidutils.generate_uuid()
volumes[new_volume_id] = {'id': new_volume_id,
'display_name': 'new_volume',
'attach_status': 'detached',
'instance_uuid': None,
'size': 5,
'status': 'available'}
self.assertRaises(exception.InstanceInvalidState,
self.compute_api.swap_volume, self.context, instance,
volumes[old_volume_id], volumes[new_volume_id])
instance['vm_state'] = vm_states.ACTIVE
# Should fail if old volume is not attached
volumes[old_volume_id]['attach_status'] = 'detached'
self.assertRaises(exception.InvalidVolume,
self.compute_api.swap_volume, self.context, instance,
volumes[old_volume_id], volumes[new_volume_id])
self.assertEquals(volumes[old_volume_id]['status'], 'in-use')
self.assertEquals(volumes[new_volume_id]['status'], 'available')
volumes[old_volume_id]['attach_status'] = 'attached'
# Should fail if old volume's instance_uuid is not that of the instance
volumes[old_volume_id]['instance_uuid'] = 'fake2'
self.assertRaises(exception.VolumeUnattached,
self.compute_api.swap_volume, self.context, instance,
volumes[old_volume_id], volumes[new_volume_id])
self.assertEquals(volumes[old_volume_id]['status'], 'in-use')
self.assertEquals(volumes[new_volume_id]['status'], 'available')
volumes[old_volume_id]['instance_uuid'] = 'fake'
# Should fail if new volume is attached
volumes[new_volume_id]['attach_status'] = 'attached'
self.assertRaises(exception.InvalidVolume,
self.compute_api.swap_volume, self.context, instance,
volumes[old_volume_id], volumes[new_volume_id])
self.assertEquals(volumes[old_volume_id]['status'], 'in-use')
self.assertEquals(volumes[new_volume_id]['status'], 'available')
volumes[new_volume_id]['attach_status'] = 'detached'
# Should fail if new volume is smaller than the old volume
volumes[new_volume_id]['size'] = 4
self.assertRaises(exception.InvalidVolume,
self.compute_api.swap_volume, self.context, instance,
volumes[old_volume_id], volumes[new_volume_id])
self.assertEquals(volumes[old_volume_id]['status'], 'in-use')
self.assertEquals(volumes[new_volume_id]['status'], 'available')
volumes[new_volume_id]['size'] = 5
# Fail call to swap_volume
self.stubs.Set(self.compute_api.volume_api, 'begin_detaching',
fake_vol_api_begin_detaching)
self.stubs.Set(self.compute_api.volume_api, 'roll_detaching',
fake_vol_api_roll_detaching)
self.stubs.Set(self.compute_api.volume_api, 'reserve_volume',
fake_vol_api_reserve)
self.stubs.Set(self.compute_api.volume_api, 'unreserve_volume',
fake_vol_api_unreserve)
self.stubs.Set(self.compute_api.compute_rpcapi, 'swap_volume',
fake_swap_volume_exc)
self.assertRaises(AttributeError,
self.compute_api.swap_volume, self.context, instance,
volumes[old_volume_id], volumes[new_volume_id])
self.assertEquals(volumes[old_volume_id]['status'], 'in-use')
self.assertEquals(volumes[new_volume_id]['status'], 'available')
# Should succeed
self.stubs.Set(self.compute_api.compute_rpcapi, 'swap_volume',
lambda c, instance, old_volume_id, new_volume_id: True)
self.compute_api.swap_volume(self.context, instance,
volumes[old_volume_id],
volumes[new_volume_id])
def test_swap_volume_volume_api_usage(self):
# This test ensures that volume_id arguments are passed to volume_api
# and that volume states are OK
volumes = {}
old_volume_id = uuidutils.generate_uuid()
volumes[old_volume_id] = {
'id': old_volume_id,
'display_name': 'old_volume',
'status': 'detaching'
}
new_volume_id = uuidutils.generate_uuid()
volumes[new_volume_id] = {
'id': new_volume_id,
'display_name': 'new_volume',
'status': 'attaching'
}
def fake_vol_api_func(context, volume, *args):
self.assertTrue(uuidutils.is_uuid_like(volume))
return {}
def fake_vol_get(context, volume_id):
self.assertTrue(uuidutils.is_uuid_like(volume_id))
return volumes[volume_id]
def fake_vol_attach(context, volume_id, instance_uuid, connector):
self.assertTrue(uuidutils.is_uuid_like(volume_id))
self.assertIn(volumes[volume_id]['status'],
['available', 'attaching'])
volumes[volume_id]['status'] = 'in-use'
def fake_vol_unreserve(context, volume_id):
self.assertTrue(uuidutils.is_uuid_like(volume_id))
if volumes[volume_id]['status'] == 'attaching':
volumes[volume_id]['status'] = 'available'
def fake_vol_detach(context, volume_id):
self.assertTrue(uuidutils.is_uuid_like(volume_id))
volumes[volume_id]['status'] = 'available'
def fake_vol_migrate_volume_completion(context,
old_volume_id,
new_volume_id,
error=False):
self.assertTrue(uuidutils.is_uuid_like(old_volume_id))
self.assertTrue(uuidutils.is_uuid_like(old_volume_id))
return {'save_volume_id': new_volume_id}
def fake_func_exc(*args, **kwargs):
raise AttributeError # Random exception
self.stubs.Set(self.compute.volume_api, 'get', fake_vol_get)
self.stubs.Set(self.compute.volume_api, 'initialize_connection',
fake_vol_api_func)
self.stubs.Set(self.compute.volume_api, 'attach', fake_vol_attach)
self.stubs.Set(self.compute.volume_api, 'unreserve_volume',
fake_vol_unreserve)
self.stubs.Set(self.compute.volume_api, 'terminate_connection',
fake_vol_api_func)
self.stubs.Set(self.compute.volume_api, 'detach', fake_vol_detach)
self.stubs.Set(
self.compute, '_get_instance_volume_bdm', lambda x, y, z: {
'device_name': '/dev/vdb',
'connection_info': '{"foo": "bar"}'
})
self.stubs.Set(self.compute.driver, 'get_volume_connector',
lambda x: {})
self.stubs.Set(self.compute.driver, 'swap_volume',
lambda w, x, y, z: None)
self.stubs.Set(self.compute.volume_api, 'migrate_volume_completion',
fake_vol_migrate_volume_completion)
self.stubs.Set(self.compute.conductor_api,
'block_device_mapping_update_or_create',
lambda x, y: None)
self.stubs.Set(self.compute.conductor_api, 'instance_fault_create',
lambda x, y: None)
# Good path
self.compute.swap_volume(self.context, old_volume_id, new_volume_id,
{'uuid': 'fake'})
self.assertEqual(volumes[old_volume_id]['status'], 'available')
self.assertEqual(volumes[new_volume_id]['status'], 'in-use')
# Error paths
volumes[old_volume_id]['status'] = 'detaching'
volumes[new_volume_id]['status'] = 'attaching'
self.stubs.Set(self.compute.driver, 'swap_volume', fake_func_exc)
self.assertRaises(AttributeError, self.compute.swap_volume,
self.context, old_volume_id, new_volume_id,
{'uuid': 'fake'})
self.assertEqual(volumes[old_volume_id]['status'], 'detaching')
self.assertEqual(volumes[new_volume_id]['status'], 'attaching')
volumes[old_volume_id]['status'] = 'detaching'
volumes[new_volume_id]['status'] = 'attaching'
self.stubs.Set(self.compute.volume_api, 'initialize_connection',
fake_func_exc)
self.assertRaises(AttributeError, self.compute.swap_volume,
self.context, old_volume_id, new_volume_id,
{'uuid': 'fake'})
self.assertEqual(volumes[old_volume_id]['status'], 'detaching')
self.assertEqual(volumes[new_volume_id]['status'], 'available')
def _stub_instance_get_failure(self, exc_info, uuid=None):
if uuid is None:
uuid = uuidutils.generate_uuid()
self.compute_api.get(self.context, uuid, expected_attrs=None,
want_objects=True).AndRaise(exc_info)
return uuid
def _make_url(self, uuid=None):
if uuid is None:
uuid = uuidutils.generate_uuid()
return '/servers/%s/action' % uuid
def _generate_key_id(self):
key_id = uuidutils.generate_uuid()
while key_id in self.keys:
key_id = uuidutils.generate_uuid()
return key_id
def test_migrate_live_unable_to_migrate_to_self(self):
uuid = uuidutils.generate_uuid()
self._test_migrate_live_failed_with_exception(
exception.UnableToMigrateToSelf(instance_id=uuid,
host='host'),
uuid=uuid)
