def test_delete_fast_if_host_not_set(self): inst = self._create_instance_obj() inst.host = '' updates = {'progress': 0, 'task_state': task_states.DELETING} self.mox.StubOutWithMock(inst, 'save') self.mox.StubOutWithMock(db, 'block_device_mapping_get_all_by_instance') self.mox.StubOutWithMock(db, 'constraint') self.mox.StubOutWithMock(db, 'instance_destroy') self.mox.StubOutWithMock(self.compute_api, '_create_reservations') db.block_device_mapping_get_all_by_instance(self.context, inst.uuid).AndReturn([]) inst.save() self.compute_api._create_reservations(self.context, inst, inst.instance_type_id, inst.project_id, inst.user_id ).AndReturn(None) db.constraint(host=mox.IgnoreArg()).AndReturn('constraint') db.instance_destroy(self.context, inst.uuid, 'constraint') self.mox.ReplayAll() self.compute_api.delete(self.context, inst) for k, v in updates.items(): self.assertEqual(inst[k], v)
def test_block_device_mapping_get_all_by_instance(self): fake_inst = {"uuid": "fake-uuid"} self.mox.StubOutWithMock(db, "block_device_mapping_get_all_by_instance") db.block_device_mapping_get_all_by_instance(self.context, fake_inst["uuid"]).AndReturn("fake-result") self.mox.ReplayAll() result = self.conductor.block_device_mapping_get_all_by_instance(self.context, fake_inst) self.assertEqual(result, "fake-result")
def test_delete_fast_if_host_not_set(self): inst = self._create_instance_obj() inst.host = '' db_inst = obj_base.obj_to_primitive(inst) updates = {'progress': 0, 'task_state': task_states.DELETING} new_inst = dict(db_inst, **updates) self.mox.StubOutWithMock(db, 'block_device_mapping_get_all_by_instance') self.mox.StubOutWithMock(db, 'instance_update_and_get_original') self.mox.StubOutWithMock(db, 'constraint') self.mox.StubOutWithMock(db, 'instance_destroy') self.mox.StubOutWithMock(self.compute_api, '_create_reservations') db.block_device_mapping_get_all_by_instance(self.context, inst.uuid).AndReturn([]) db.instance_update_and_get_original( self.context, inst.uuid, updates).AndReturn((db_inst, new_inst)) self.compute_api._create_reservations(self.context, db_inst, new_inst, inst.project_id, inst.user_id).AndReturn(None) db.constraint(host=mox.IgnoreArg()).AndReturn('constraint') db.instance_destroy(self.context, inst.uuid, 'constraint') if self.is_cells: self.mox.StubOutWithMock(self.compute_api, '_cast_to_cells') self.compute_api._cast_to_cells( self.context, db_inst, 'delete') self.mox.ReplayAll() self.compute_api.delete(self.context, db_inst)
def test_delete_fast_if_host_not_set(self): inst = self._create_instance_obj() inst.host = '' updates = {'progress': 0, 'task_state': task_states.DELETING} self.mox.StubOutWithMock(inst, 'save') self.mox.StubOutWithMock(db, 'block_device_mapping_get_all_by_instance') self.mox.StubOutWithMock(db, 'constraint') self.mox.StubOutWithMock(db, 'instance_destroy') self.mox.StubOutWithMock(self.compute_api, '_create_reservations') db.block_device_mapping_get_all_by_instance(self.context, inst.uuid).AndReturn([]) inst.save() self.compute_api._create_reservations(self.context, inst, inst.instance_type_id, inst.project_id, inst.user_id).AndReturn(None) db.constraint(host=mox.IgnoreArg()).AndReturn('constraint') db.instance_destroy(self.context, inst.uuid, constraint='constraint') self.mox.ReplayAll() self.compute_api.delete(self.context, inst) for k, v in updates.items(): self.assertEqual(inst[k], v)
def test_block_device_mapping_get_all_by_instance(self): fake_inst = {'uuid': 'fake-uuid'} self.mox.StubOutWithMock(db, 'block_device_mapping_get_all_by_instance') db.block_device_mapping_get_all_by_instance( self.context, fake_inst['uuid']).AndReturn('fake-result') self.mox.ReplayAll() result = self.conductor.block_device_mapping_get_all_by_instance( self.context, fake_inst) self.assertEqual(result, 'fake-result')
def test_block_device_mapping_get_all_by_instance(self): fake_inst = {'uuid': 'fake-uuid'} self.mox.StubOutWithMock(db, 'block_device_mapping_get_all_by_instance') db.block_device_mapping_get_all_by_instance( self.context, fake_inst['uuid']).AndReturn('fake-result') self.mox.ReplayAll() result = self.conductor.block_device_mapping_get_all_by_instance( self.context, fake_inst) self.assertEqual(result, 'fake-result')
def _assertSimilarBlockDeviceMapping(original, copy): original_bdms = db.block_device_mapping_get_all_by_instance(self.context, original["uuid"]) copy_bdms = db.block_device_mapping_get_all_by_instance(self.context, copy["uuid"]) original_bdms = [dict(i.iteritems()) for i in original_bdms] copy_bdms = [dict(i.iteritems()) for i in copy_bdms] # Remove fields that we do not care about for comparison for bdm in original_bdms + copy_bdms: del bdm["instance_uuid"] del bdm["created_at"] del bdm["deleted_at"] del bdm["id"] self.assertEquals(original_bdms, copy_bdms)
def _validate_device(self, device=None): bdms = db.block_device_mapping_get_all_by_instance( self.context, self.instance['uuid']) return compute_utils.get_device_name_for_instance(self.context, self.instance, bdms, device)
def test_create_instances_here(self): # Just grab the first instance type inst_type = objects.Flavor.get_by_id(self.ctxt, 1) image = {'properties': {}} instance_uuids = self.instance_uuids instance_props = { 'id': 'removed', 'security_groups': 'removed', 'info_cache': 'removed', 'name': 'instance-00000001', 'hostname': 'meow', 'display_name': 'moo', 'image_ref': uuidsentinel.fake_image_ref, 'user_id': self.ctxt.user_id, # Test these as lists 'metadata': { 'moo': 'cow' }, 'system_metadata': { 'meow': 'cat' }, 'flavor': inst_type, 'project_id': self.ctxt.project_id } call_info = {'uuids': []} block_device_mapping = objects.BlockDeviceMappingList(objects=[ objects.BlockDeviceMapping( context=self.ctxt, **fake_block_device.FakeDbBlockDeviceDict( block_device.create_image_bdm(uuidsentinel.fake_image_ref), anon=True)) ]) def _fake_instance_update_at_top(self, _ctxt, instance): call_info['uuids'].append(instance['uuid']) self.stub_out( 'nova.cells.messaging.MessageRunner.' 'instance_update_at_top', _fake_instance_update_at_top) self.scheduler._create_instances_here(self.ctxt, instance_uuids, instance_props, inst_type, image, ['default'], block_device_mapping) self.assertEqual(instance_uuids, call_info['uuids']) for count, instance_uuid in enumerate(instance_uuids): bdms = db.block_device_mapping_get_all_by_instance( self.ctxt, instance_uuid) self.assertIsNotNone(bdms) instance = db.instance_get_by_uuid(self.ctxt, instance_uuid) meta = utils.instance_meta(instance) self.assertEqual('cow', meta['moo']) sys_meta = utils.instance_sys_meta(instance) self.assertEqual('cat', sys_meta['meow']) self.assertEqual('meow', instance['hostname']) self.assertEqual('moo-%d' % (count + 1), instance['display_name']) self.assertEqual(uuidsentinel.fake_image_ref, instance['image_ref'])
def get_device_name_for_instance(context, instance, device): # NOTE(vish): this will generate a unique device name that is not # in use already. It is a reasonable guess at where # it will show up in a linux guest, but it may not # always be correct req_prefix = None req_letters = None if device: try: match = re.match("(^/dev/x{0,1}[a-z]d)([a-z]+)$", device) req_prefix, req_letters = match.groups() except (TypeError, AttributeError, ValueError): raise exception.InvalidDevicePath(path=device) bdms = db.block_device_mapping_get_all_by_instance(context, instance["uuid"]) mappings = block_device.instance_block_mapping(instance, bdms) try: match = re.match("(^/dev/x{0,1}[a-z]d)[a-z]+[0-9]*$", mappings["root"]) prefix = match.groups()[0] except (TypeError, AttributeError, ValueError): raise exception.InvalidDevicePath(path=mappings["root"]) if not req_prefix: req_prefix = prefix letters_list = [] for _name, device in mappings.iteritems(): letter = block_device.strip_prefix(device) # NOTE(vish): delete numbers in case we have something like # /dev/sda1 letter = re.sub("\d+", "", letter) letters_list.append(letter) used_letters = set(letters_list) if not req_letters: req_letters = _get_unused_letters(used_letters) if req_letters in used_letters: raise exception.DevicePathInUse(path=device) return req_prefix + req_letters
def block_device_mapping_get_all_by_instance(self, context, instance, legacy=True): bdms = db.block_device_mapping_get_all_by_instance(context, instance['uuid']) if legacy: bdms = block_device.legacy_mapping(bdms) return bdms
def block_device_mapping_get_all_by_instance(self, context, instance, legacy=True): bdms = db.block_device_mapping_get_all_by_instance(context, instance['uuid']) if legacy: bdms = block_device.legacy_mapping(bdms) return bdms
def _prepare_instance(self, context, instance): instance["name"] = instance["display_name"] instance["status"] = self._status_map.get( instance["vm_state"], instance["vm_state"]) image_id = instance["image_ref"] if image_id is None or len(image_id) == 0: image_id = instance["system_metadata"]["image_base_image_ref"] if image_id is None or len(image_id) == 0: image_id = instance["system_metadata"]["image_image_id"] image = image_api.API().get_item_by_id(context, image_id) if image is not None: instance["image"] = image['name'] instance["cached_nwinfo"] = \ compute_utils.get_nw_info_for_instance(instance) attached_disks = db.block_device_mapping_get_all_by_instance( nova_context.get_admin_context(), instance['uuid']) for disk in attached_disks: if disk["volume_id"] is not None: disk["volume"] = disk_api.API().get_item_by_id( context, disk["volume_id"]) instance["attached_disks"] = attached_disks return instance
def test_delete_soft_rollback(self): inst = self._create_instance_obj() self.mox.StubOutWithMock(db, 'block_device_mapping_get_all_by_instance') self.mox.StubOutWithMock(inst, 'save') delete_time = datetime.datetime(1955, 11, 5) timeutils.set_time_override(delete_time) db.block_device_mapping_get_all_by_instance( self.context, inst.uuid).AndReturn([]) inst.save().AndRaise(Exception) self.mox.ReplayAll() self.assertRaises(Exception, self.compute_api.soft_delete, self.context, inst)
def _tearDownBlockDeviceMapping(self, inst1, inst2, volumes): for vol in volumes: self.volume_api.delete(self.context, vol) for uuid in (inst1["uuid"], inst2["uuid"]): for bdm in db.block_device_mapping_get_all_by_instance(self.context, uuid): db.block_device_mapping_destroy(self.context, bdm["id"]) db.instance_destroy(self.context, inst2["uuid"]) db.instance_destroy(self.context, inst1["uuid"])
def test_delete_soft_rollback(self): inst = self._create_instance_obj() self.mox.StubOutWithMock(db, 'block_device_mapping_get_all_by_instance') self.mox.StubOutWithMock(inst, 'save') delete_time = datetime.datetime(1955, 11, 5) timeutils.set_time_override(delete_time) db.block_device_mapping_get_all_by_instance(self.context, inst.uuid).AndReturn([]) inst.save().AndRaise(Exception) self.mox.ReplayAll() self.assertRaises(Exception, self.compute_api.soft_delete, self.context, inst)
def _tearDownBlockDeviceMapping(self, inst1, inst2, volumes): for vol in volumes: self.volume_api.delete(self.context, vol['id']) for uuid in (inst1['uuid'], inst2['uuid']): for bdm in db.block_device_mapping_get_all_by_instance( self.context, uuid): db.block_device_mapping_destroy(self.context, bdm['id']) db.instance_destroy(self.context, inst2['uuid']) db.instance_destroy(self.context, inst1['uuid'])
def _tearDownBlockDeviceMapping(self, instances, volumes): for vols in volumes: for vol in vols: self.volume_api.delete(self.context, vol['id']) for instance in instances: for bdm in db.block_device_mapping_get_all_by_instance( self.context, instance['uuid']): db.block_device_mapping_destroy(self.context, bdm['id']) db.instance_destroy(self.context, instance['uuid'])
def _assertSimilarBlockDeviceMapping(original, copy): original_bdms = \ db.block_device_mapping_get_all_by_instance(self.context, original['uuid']) copy_bdms =\ db.block_device_mapping_get_all_by_instance(self.context, copy['uuid']) original_bdms = [dict(i.iteritems()) for i in original_bdms] copy_bdms = [dict(i.iteritems()) for i in copy_bdms] # Remove fields that we do not care about for comparison for bdm in original_bdms + copy_bdms: del bdm['instance_uuid'] del bdm['created_at'] del bdm['deleted_at'] del bdm['id'] self.assertEquals(original_bdms, copy_bdms)
def _tearDownBlockDeviceMapping(self, instances, volumes): for vols in volumes: for vol in vols: self.volume_api.delete(self.context, vol['id']) for instance in instances: for bdm in db.block_device_mapping_get_all_by_instance( self.context, instance['uuid']): db.block_device_mapping_destroy(self.context, bdm['id']) db.instance_destroy(self.context, instance['uuid'])
def test_create_instances_here(self): # Just grab the first instance type inst_type = objects.Flavor.get_by_id(self.ctxt, 1) image = {'properties': {}} instance_uuids = self.instance_uuids instance_props = {'id': 'removed', 'security_groups': 'removed', 'info_cache': 'removed', 'name': 'instance-00000001', 'hostname': 'meow', 'display_name': 'moo', 'image_ref': uuidsentinel.fake_image_ref, 'user_id': self.ctxt.user_id, # Test these as lists 'metadata': {'moo': 'cow'}, 'system_metadata': {'meow': 'cat'}, 'flavor': inst_type, 'project_id': self.ctxt.project_id} call_info = {'uuids': []} block_device_mapping = objects.BlockDeviceMappingList( objects=[ objects.BlockDeviceMapping(context=self.ctxt, **fake_block_device.FakeDbBlockDeviceDict( block_device.create_image_bdm( uuidsentinel.fake_image_ref), anon=True)) ]) def _fake_instance_update_at_top(self, _ctxt, instance): call_info['uuids'].append(instance['uuid']) self.stub_out('nova.cells.messaging.MessageRunner.' 'instance_update_at_top', _fake_instance_update_at_top) self.scheduler._create_instances_here(self.ctxt, instance_uuids, instance_props, inst_type, image, ['default'], block_device_mapping) self.assertEqual(instance_uuids, call_info['uuids']) for count, instance_uuid in enumerate(instance_uuids): bdms = db.block_device_mapping_get_all_by_instance(self.ctxt, instance_uuid) self.assertIsNotNone(bdms) instance = db.instance_get_by_uuid(self.ctxt, instance_uuid) meta = utils.instance_meta(instance) self.assertEqual('cow', meta['moo']) sys_meta = utils.instance_sys_meta(instance) self.assertEqual('cat', sys_meta['meow']) self.assertEqual('meow', instance['hostname']) self.assertEqual('moo-%d' % (count + 1), instance['display_name']) self.assertEqual(uuidsentinel.fake_image_ref, instance['image_ref'])
def get_device_name_for_instance(context, instance, device): """Validates (or generates) a device name for instance. If device is not set, it will generate a unique device appropriate for the instance. It uses the block device mapping table to find valid device names. If the device name is valid but applicable to a different backend (for example /dev/vdc is specified but the backend uses /dev/xvdc), the device name will be converted to the appropriate format. """ req_prefix = None req_letters = None if device: try: req_prefix, req_letters = block_device.match_device(device) except (TypeError, AttributeError, ValueError): raise exception.InvalidDevicePath(path=device) bdms = db.block_device_mapping_get_all_by_instance(context, instance['uuid']) mappings = block_device.instance_block_mapping(instance, bdms) try: prefix = block_device.match_device(mappings['root'])[0] except (TypeError, AttributeError, ValueError): raise exception.InvalidDevicePath(path=mappings['root']) # NOTE(vish): remove this when xenapi is setting default_root_device if (FLAGS.connection_type == 'xenapi' or FLAGS.compute_driver.endswith('xenapi.XenAPIDriver')): prefix = '/dev/xvd' if req_prefix != prefix: LOG.debug(_("Using %(prefix)s instead of %(req_prefix)s") % locals()) letters_list = [] for _name, device in mappings.iteritems(): letter = block_device.strip_prefix(device) # NOTE(vish): delete numbers in case we have something like # /dev/sda1 letter = re.sub("\d+", "", letter) letters_list.append(letter) used_letters = set(letters_list) # NOTE(vish): remove this when xenapi is properly setting # default_ephemeral_device and default_swap_device if (FLAGS.connection_type == 'xenapi' or FLAGS.compute_driver.endswith('xenapi.XenAPIDriver')): instance_type_id = instance['instance_type_id'] instance_type = instance_types.get_instance_type(instance_type_id) if instance_type['ephemeral_gb']: used_letters.update('b') if instance_type['swap']: used_letters.update('c') if not req_letters: req_letters = _get_unused_letters(used_letters) if req_letters in used_letters: raise exception.DevicePathInUse(path=device) return prefix + req_letters
def test_create_block_device_mapping(self): instance_type = {"swap": 1, "ephemeral_gb": 1} instance = self._create_fake_instance_obj() bdms = [ block_device.BlockDeviceDict( {"source_type": "image", "destination_type": "local", "image_id": "fake-image", "boot_index": 0} ) ] self.compute_api._create_block_device_mapping(instance_type, instance.uuid, bdms) bdms = db.block_device_mapping_get_all_by_instance(self.context, instance["uuid"]) self.assertEqual(0, len(bdms))
def test_create_instances_here(self): # Just grab the first instance type inst_type = objects.Flavor.get_by_id(self.ctxt, 1) image = {"properties": {}} instance_uuids = self.instance_uuids instance_props = { "id": "removed", "security_groups": "removed", "info_cache": "removed", "name": "instance-00000001", "hostname": "meow", "display_name": "moo", "image_ref": uuidsentinel.fake_image_ref, "user_id": self.ctxt.user_id, # Test these as lists "metadata": {"moo": "cow"}, "system_metadata": {"meow": "cat"}, "flavor": inst_type, "project_id": self.ctxt.project_id, } call_info = {"uuids": []} block_device_mapping = objects.BlockDeviceMappingList( objects=[ objects.BlockDeviceMapping( context=self.ctxt, **fake_block_device.FakeDbBlockDeviceDict( block_device.create_image_bdm(uuidsentinel.fake_image_ref), anon=True ) ) ] ) def _fake_instance_update_at_top(_ctxt, instance): call_info["uuids"].append(instance["uuid"]) self.stubs.Set(self.msg_runner, "instance_update_at_top", _fake_instance_update_at_top) self.scheduler._create_instances_here( self.ctxt, instance_uuids, instance_props, inst_type, image, ["default"], block_device_mapping ) self.assertEqual(instance_uuids, call_info["uuids"]) for count, instance_uuid in enumerate(instance_uuids): bdms = db.block_device_mapping_get_all_by_instance(self.ctxt, instance_uuid) self.assertIsNotNone(bdms) instance = db.instance_get_by_uuid(self.ctxt, instance_uuid) meta = utils.instance_meta(instance) self.assertEqual("cow", meta["moo"]) sys_meta = utils.instance_sys_meta(instance) self.assertEqual("cat", sys_meta["meow"]) self.assertEqual("meow", instance["hostname"]) self.assertEqual("moo-%d" % (count + 1), instance["display_name"]) self.assertEqual(uuidsentinel.fake_image_ref, instance["image_ref"])
def test_create_block_device_mapping(self): instance_type = {'swap': 1, 'ephemeral_gb': 1} instance = self._create_fake_instance_obj() bdms = [block_device.BlockDeviceDict({'source_type': 'image', 'destination_type': 'local', 'image_id': 'fake-image', 'boot_index': 0})] self.compute_api._create_block_device_mapping( instance_type, instance.uuid, bdms) bdms = db.block_device_mapping_get_all_by_instance( self.context, instance['uuid']) self.assertEqual(0, len(bdms))
def test_update_block_device_mapping(self): instance_type = {'swap': 1, 'ephemeral_gb': 1} instance = self._create_fake_instance_obj() bdms = [block_device.BlockDeviceDict({'source_type': 'image', 'destination_type': 'local', 'image_id': 'fake-image', 'boot_index': 0})] self.compute_api._update_block_device_mapping( instance_type, instance.uuid, bdms) bdms = db.block_device_mapping_get_all_by_instance( self.context, instance['uuid']) self.assertEqual(0, len(bdms))
def test_delete_soft_rollback(self): inst = self._create_instance_obj() db_inst = obj_base.obj_to_primitive(inst) self.mox.StubOutWithMock(db, 'block_device_mapping_get_all_by_instance') self.mox.StubOutWithMock(db, 'instance_update_and_get_original') delete_time = datetime.datetime(1955, 11, 5) timeutils.set_time_override(delete_time) db.block_device_mapping_get_all_by_instance( self.context, inst.uuid).AndReturn([]) db.instance_update_and_get_original( self.context, inst.uuid, {'progress': 0, 'deleted_at': delete_time, 'task_state': task_states.SOFT_DELETING, }).AndRaise(test.TestingException) self.mox.ReplayAll() self.assertRaises(test.TestingException, self.compute_api.soft_delete, self.context, db_inst)
def _format_instance_mapping(self, ctxt, instance_ref): root_device_name = instance_ref['root_device_name'] if root_device_name is None: return _DEFAULT_MAPPINGS mappings = {} mappings['ami'] = block_device.strip_dev(root_device_name) mappings['root'] = root_device_name default_ephemeral_device = \ instance_ref.get('default_ephemeral_device') if default_ephemeral_device: mappings['ephemeral0'] = default_ephemeral_device default_swap_device = instance_ref.get('default_swap_device') if default_swap_device: mappings['swap'] = default_swap_device ebs_devices = [] # 'ephemeralN', 'swap' and ebs for bdm in db.block_device_mapping_get_all_by_instance( ctxt, instance_ref['id']): if bdm['no_device']: continue # ebs volume case if (bdm['volume_id'] or bdm['snapshot_id']): ebs_devices.append(bdm['device_name']) continue virtual_name = bdm['virtual_name'] if not virtual_name: continue if block_device.is_swap_or_ephemeral(virtual_name): mappings[virtual_name] = bdm['device_name'] # NOTE(yamahata): I'm not sure how ebs device should be numbered. # Right now sort by device name for deterministic # result. if ebs_devices: nebs = 0 ebs_devices.sort() for ebs in ebs_devices: mappings['ebs%d' % nebs] = ebs nebs += 1 return mappings
def _format_instance_mapping(self, ctxt, instance_ref): root_device_name = instance_ref['root_device_name'] if root_device_name is None: return _DEFAULT_MAPPINGS mappings = {} mappings['ami'] = block_device.strip_dev(root_device_name) mappings['root'] = root_device_name default_ephemeral_device = \ instance_ref.get('default_ephemeral_device') if default_ephemeral_device: mappings['ephemeral0'] = default_ephemeral_device default_swap_device = instance_ref.get('default_swap_device') if default_swap_device: mappings['swap'] = default_swap_device ebs_devices = [] # 'ephemeralN', 'swap' and ebs for bdm in db.block_device_mapping_get_all_by_instance( ctxt, instance_ref['id']): if bdm['no_device']: continue # ebs volume case if (bdm['volume_id'] or bdm['snapshot_id']): ebs_devices.append(bdm['device_name']) continue virtual_name = bdm['virtual_name'] if not virtual_name: continue if block_device.is_swap_or_ephemeral(virtual_name): mappings[virtual_name] = bdm['device_name'] # NOTE(yamahata): I'm not sure how ebs device should be numbered. # Right now sort by device name for deterministic # result. if ebs_devices: nebs = 0 ebs_devices.sort() for ebs in ebs_devices: mappings['ebs%d' % nebs] = ebs nebs += 1 return mappings
def _format_instance_mapping(ctxt, instance): root_device_name = instance["root_device_name"] if root_device_name is None: return _DEFAULT_MAPPINGS mappings = {} mappings["ami"] = block_device.strip_dev(root_device_name) mappings["root"] = root_device_name default_ephemeral_device = instance.get("default_ephemeral_device") if default_ephemeral_device: mappings["ephemeral0"] = default_ephemeral_device default_swap_device = instance.get("default_swap_device") if default_swap_device: mappings["swap"] = default_swap_device ebs_devices = [] # 'ephemeralN', 'swap' and ebs for bdm in db.block_device_mapping_get_all_by_instance(ctxt, instance["uuid"]): if bdm["no_device"]: continue # ebs volume case if bdm["volume_id"] or bdm["snapshot_id"]: ebs_devices.append(bdm["device_name"]) continue virtual_name = bdm["virtual_name"] if not virtual_name: continue if block_device.is_swap_or_ephemeral(virtual_name): mappings[virtual_name] = bdm["device_name"] # NOTE(yamahata): I'm not sure how ebs device should be numbered. # Right now sort by device name for deterministic # result. if ebs_devices: nebs = 0 ebs_devices.sort() for ebs in ebs_devices: mappings["ebs%d" % nebs] = ebs nebs += 1 return mappings
def get_device_name_for_instance(context, instance, device): """Validates (or generates) a device name for instance. If device is not set, it will generate a unique device appropriate for the instance. It uses the block device mapping table to find valid device names. If the device name is valid but applicable to a different backend (for example /dev/vdc is specified but the backend uses /dev/xvdc), the device name will be converted to the appropriate format. """ req_prefix = None req_letters = None if device: try: req_prefix, req_letters = block_device.match_device(device) except (TypeError, AttributeError, ValueError): raise exception.InvalidDevicePath(path=device) bdms = db.block_device_mapping_get_all_by_instance(context, instance['uuid']) mappings = block_device.instance_block_mapping(instance, bdms) try: prefix = block_device.match_device(mappings['root'])[0] except (TypeError, AttributeError, ValueError): raise exception.InvalidDevicePath(path=mappings['root']) if req_prefix != prefix: LOG.debug(_("Using %(prefix)s instead of %(req_prefix)s") % locals()) letters_list = [] for _name, device in mappings.iteritems(): letter = block_device.strip_prefix(device) # NOTE(vish): delete numbers in case we have something like # /dev/sda1 letter = re.sub("\d+", "", letter) letters_list.append(letter) used_letters = set(letters_list) if not req_letters: req_letters = _get_unused_letters(used_letters) if req_letters in used_letters: raise exception.DevicePathInUse(path=device) return prefix + req_letters
def get_device_name_for_instance(context, instance, device): """Validates (or generates) a device name for instance. If device is not set, it will generate a unique device appropriate for the instance. It uses the block device mapping table to find valid device names. If the device name is valid but applicable to a different backend (for example /dev/vdc is specified but the backend uses /dev/xvdc), the device name will be converted to the appropriate format. """ req_prefix = None req_letters = None if device: try: req_prefix, req_letters = block_device.match_device(device) except (TypeError, AttributeError, ValueError): raise exception.InvalidDevicePath(path=device) bdms = db.block_device_mapping_get_all_by_instance(context, instance['uuid']) mappings = block_device.instance_block_mapping(instance, bdms) try: prefix = block_device.match_device(mappings['root'])[0] except (TypeError, AttributeError, ValueError): raise exception.InvalidDevicePath(path=mappings['root']) if req_prefix != prefix: LOG.debug(_("Using %(prefix)s instead of %(req_prefix)s") % locals()) letters_list = [] for _name, device in mappings.iteritems(): letter = block_device.strip_prefix(device) # NOTE(vish): delete numbers in case we have something like # /dev/sda1 letter = re.sub("\d+", "", letter) letters_list.append(letter) used_letters = set(letters_list) if not req_letters: req_letters = _get_unused_letters(used_letters) if req_letters in used_letters: raise exception.DevicePathInUse(path=device) return prefix + req_letters
def _db_block_device_mapping_get_all_by_instance( context, instance_uuid, use_slave=False): return db.block_device_mapping_get_all_by_instance( context, instance_uuid)
def _test_delete(self, delete_type, **attrs): inst = self._create_instance_obj() inst.update(attrs) inst._context = self.context delete_time = datetime.datetime(1955, 11, 5, 9, 30, tzinfo=iso8601.iso8601.Utc()) timeutils.set_time_override(delete_time) task_state = (delete_type == 'soft_delete' and task_states.SOFT_DELETING or task_states.DELETING) db_inst = obj_base.obj_to_primitive(inst) updates = {'progress': 0, 'task_state': task_state} if delete_type == 'soft_delete': updates['deleted_at'] = delete_time self.mox.StubOutWithMock(inst, 'save') self.mox.StubOutWithMock(db, 'block_device_mapping_get_all_by_instance') self.mox.StubOutWithMock(self.compute_api, '_create_reservations') self.mox.StubOutWithMock(self.context, 'elevated') self.mox.StubOutWithMock(db, 'service_get_by_compute_host') self.mox.StubOutWithMock(self.compute_api.servicegroup_api, 'service_is_up') self.mox.StubOutWithMock(db, 'migration_get_by_instance_and_status') self.mox.StubOutWithMock(self.compute_api, '_downsize_quota_delta') self.mox.StubOutWithMock(self.compute_api, '_reserve_quota_delta') self.mox.StubOutWithMock(self.compute_api, '_record_action_start') self.mox.StubOutWithMock(db, 'instance_update_and_get_original') self.mox.StubOutWithMock(db, 'instance_info_cache_delete') self.mox.StubOutWithMock(self.compute_api.network_api, 'deallocate_for_instance') self.mox.StubOutWithMock(db, 'instance_system_metadata_get') self.mox.StubOutWithMock(db, 'instance_destroy') self.mox.StubOutWithMock(compute_utils, 'notify_about_instance_usage') self.mox.StubOutWithMock(quota.QUOTAS, 'commit') db.block_device_mapping_get_all_by_instance( self.context, inst.uuid).AndReturn([]) inst.save() self.compute_api._create_reservations( self.context, inst, inst.instance_type_id, inst.project_id, inst.user_id).AndReturn('fake-resv') if inst.vm_state == vm_states.RESIZED: self._test_delete_resized_part(inst) self.context.elevated().MultipleTimes().AndReturn(self.context) db.service_get_by_compute_host(self.context, inst.host).AndReturn( 'fake-service') self.compute_api.servicegroup_api.service_is_up( 'fake-service').AndReturn(inst.host != 'down-host') if self.is_cells: rpcapi = self.compute_api.cells_rpcapi else: rpcapi = self.compute_api.compute_rpcapi self.mox.StubOutWithMock(rpcapi, 'terminate_instance') self.mox.StubOutWithMock(rpcapi, 'soft_delete_instance') if inst.host == 'down-host': db.instance_info_cache_delete(self.context, inst.uuid) compute_utils.notify_about_instance_usage(self.context, inst, '%s.start' % delete_type) self.compute_api.network_api.deallocate_for_instance( self.context, inst) db.instance_system_metadata_get(self.context, inst.uuid ).AndReturn('sys-meta') state = ('soft' in delete_type and vm_states.SOFT_DELETED or vm_states.DELETED) updates.update({'vm_state': state, 'task_state': None, 'terminated_at': delete_time}) inst.save() if self.is_cells: if delete_type == 'soft_delete': rpcapi.soft_delete_instance(self.context, inst, reservations=None) else: rpcapi.terminate_instance(self.context, inst, [], reservations=None) db.instance_destroy(self.context, inst.uuid) compute_utils.notify_about_instance_usage( self.context, inst, '%s.end' % delete_type, system_metadata='sys-meta') if inst.host == 'down-host': quota.QUOTAS.commit(self.context, 'fake-resv', project_id=inst.project_id, user_id=inst.user_id) elif delete_type == 'soft_delete': self.compute_api._record_action_start(self.context, inst, instance_actions.DELETE) rpcapi.soft_delete_instance(self.context, inst, reservations='fake-resv') elif delete_type in ['delete', 'force_delete']: self.compute_api._record_action_start(self.context, inst, instance_actions.DELETE) rpcapi.terminate_instance(self.context, inst, [], reservations='fake-resv') self.mox.ReplayAll() getattr(self.compute_api, delete_type)(self.context, inst) for k, v in updates.items(): self.assertEqual(inst[k], v)
def get_by_instance_uuid(cls, context, instance_uuid): db_bdms = db.block_device_mapping_get_all_by_instance( context, instance_uuid) return base.obj_make_list( context, cls(), BlockDeviceMapping, db_bdms or [])
def test_update_block_device_mapping(self): instance_id = self._create_instance() mappings = [{ 'virtual': 'ami', 'device': 'sda1' }, { 'virtual': 'root', 'device': '/dev/sda1' }, { 'virtual': 'swap', 'device': 'sdb1' }, { 'virtual': 'swap', 'device': 'sdb2' }, { 'virtual': 'swap', 'device': 'sdb3' }, { 'virtual': 'swap', 'device': 'sdb4' }, { 'virtual': 'ephemeral0', 'device': 'sdc1' }, { 'virtual': 'ephemeral1', 'device': 'sdc2' }, { 'virtual': 'ephemeral2', 'device': 'sdc3' }] block_device_mapping = [ # root { 'device_name': '/dev/sda1', 'snapshot_id': 0x12345678, 'delete_on_termination': False }, # overwrite swap { 'device_name': '/dev/sdb2', 'snapshot_id': 0x23456789, 'delete_on_termination': False }, { 'device_name': '/dev/sdb3', 'snapshot_id': 0x3456789A }, { 'device_name': '/dev/sdb4', 'no_device': True }, # overwrite ephemeral { 'device_name': '/dev/sdc2', 'snapshot_id': 0x456789AB, 'delete_on_termination': False }, { 'device_name': '/dev/sdc3', 'snapshot_id': 0x56789ABC }, { 'device_name': '/dev/sdc4', 'no_device': True }, # volume { 'device_name': '/dev/sdd1', 'snapshot_id': 0x87654321, 'delete_on_termination': False }, { 'device_name': '/dev/sdd2', 'snapshot_id': 0x98765432 }, { 'device_name': '/dev/sdd3', 'snapshot_id': 0xA9875463 }, { 'device_name': '/dev/sdd4', 'no_device': True } ] self.compute_api._update_image_block_device_mapping( self.context, instance_id, mappings) bdms = [ self._parse_db_block_device_mapping(bdm_ref) for bdm_ref in db.block_device_mapping_get_all_by_instance( self.context, instance_id) ] expected_result = [{ 'virtual_name': 'swap', 'device_name': '/dev/sdb1' }, { 'virtual_name': 'swap', 'device_name': '/dev/sdb2' }, { 'virtual_name': 'swap', 'device_name': '/dev/sdb3' }, { 'virtual_name': 'swap', 'device_name': '/dev/sdb4' }, { 'virtual_name': 'ephemeral0', 'device_name': '/dev/sdc1' }, { 'virtual_name': 'ephemeral1', 'device_name': '/dev/sdc2' }, { 'virtual_name': 'ephemeral2', 'device_name': '/dev/sdc3' }] bdms.sort() expected_result.sort() self.assertDictListMatch(bdms, expected_result) self.compute_api._update_block_device_mapping(self.context, instance_id, block_device_mapping) bdms = [ self._parse_db_block_device_mapping(bdm_ref) for bdm_ref in db.block_device_mapping_get_all_by_instance( self.context, instance_id) ] expected_result = [{ 'snapshot_id': 0x12345678, 'device_name': '/dev/sda1' }, { 'virtual_name': 'swap', 'device_name': '/dev/sdb1' }, { 'snapshot_id': 0x23456789, 'device_name': '/dev/sdb2' }, { 'snapshot_id': 0x3456789A, 'device_name': '/dev/sdb3' }, { 'no_device': True, 'device_name': '/dev/sdb4' }, { 'virtual_name': 'ephemeral0', 'device_name': '/dev/sdc1' }, { 'snapshot_id': 0x456789AB, 'device_name': '/dev/sdc2' }, { 'snapshot_id': 0x56789ABC, 'device_name': '/dev/sdc3' }, { 'no_device': True, 'device_name': '/dev/sdc4' }, { 'snapshot_id': 0x87654321, 'device_name': '/dev/sdd1' }, { 'snapshot_id': 0x98765432, 'device_name': '/dev/sdd2' }, { 'snapshot_id': 0xA9875463, 'device_name': '/dev/sdd3' }, { 'no_device': True, 'device_name': '/dev/sdd4' }] bdms.sort() expected_result.sort() self.assertDictListMatch(bdms, expected_result) for bdm in db.block_device_mapping_get_all_by_instance( self.context, instance_id): db.block_device_mapping_destroy(self.context, bdm['id']) self.compute.terminate_instance(self.context, instance_id)
def get_by_instance_uuid(cls, context, instance_uuid, use_slave=False): db_bdms = db.block_device_mapping_get_all_by_instance( context, instance_uuid, use_slave=use_slave) return base.obj_make_list( context, cls(), objects.BlockDeviceMapping, db_bdms or [])
def _format_instance_mapping(ctxt, instance): bdms = db.block_device_mapping_get_all_by_instance(ctxt, instance['uuid']) return block_device.instance_block_mapping(instance, bdms)
def get_by_instance_uuid(cls, context, instance_uuid): db_bdms = db.block_device_mapping_get_all_by_instance( context, instance_uuid) return base.obj_make_list( context, cls(), BlockDeviceMapping, db_bdms or [])
def test_update_block_device_mapping(self): instance_id = self._create_instance() mappings = [ {'virtual': 'ami', 'device': 'sda1'}, {'virtual': 'root', 'device': '/dev/sda1'}, {'virtual': 'swap', 'device': 'sdb1'}, {'virtual': 'swap', 'device': 'sdb2'}, {'virtual': 'swap', 'device': 'sdb3'}, {'virtual': 'swap', 'device': 'sdb4'}, {'virtual': 'ephemeral0', 'device': 'sdc1'}, {'virtual': 'ephemeral1', 'device': 'sdc2'}, {'virtual': 'ephemeral2', 'device': 'sdc3'}] block_device_mapping = [ # root {'device_name': '/dev/sda1', 'snapshot_id': 0x12345678, 'delete_on_termination': False}, # overwrite swap {'device_name': '/dev/sdb2', 'snapshot_id': 0x23456789, 'delete_on_termination': False}, {'device_name': '/dev/sdb3', 'snapshot_id': 0x3456789A}, {'device_name': '/dev/sdb4', 'no_device': True}, # overwrite ephemeral {'device_name': '/dev/sdc2', 'snapshot_id': 0x456789AB, 'delete_on_termination': False}, {'device_name': '/dev/sdc3', 'snapshot_id': 0x56789ABC}, {'device_name': '/dev/sdc4', 'no_device': True}, # volume {'device_name': '/dev/sdd1', 'snapshot_id': 0x87654321, 'delete_on_termination': False}, {'device_name': '/dev/sdd2', 'snapshot_id': 0x98765432}, {'device_name': '/dev/sdd3', 'snapshot_id': 0xA9875463}, {'device_name': '/dev/sdd4', 'no_device': True}] self.compute_api._update_image_block_device_mapping( self.context, instance_id, mappings) bdms = [self._parse_db_block_device_mapping(bdm_ref) for bdm_ref in db.block_device_mapping_get_all_by_instance( self.context, instance_id)] expected_result = [ {'virtual_name': 'swap', 'device_name': '/dev/sdb1'}, {'virtual_name': 'swap', 'device_name': '/dev/sdb2'}, {'virtual_name': 'swap', 'device_name': '/dev/sdb3'}, {'virtual_name': 'swap', 'device_name': '/dev/sdb4'}, {'virtual_name': 'ephemeral0', 'device_name': '/dev/sdc1'}, {'virtual_name': 'ephemeral1', 'device_name': '/dev/sdc2'}, {'virtual_name': 'ephemeral2', 'device_name': '/dev/sdc3'}] bdms.sort() expected_result.sort() self.assertDictListMatch(bdms, expected_result) self.compute_api._update_block_device_mapping( self.context, instance_id, block_device_mapping) bdms = [self._parse_db_block_device_mapping(bdm_ref) for bdm_ref in db.block_device_mapping_get_all_by_instance( self.context, instance_id)] expected_result = [ {'snapshot_id': 0x12345678, 'device_name': '/dev/sda1'}, {'virtual_name': 'swap', 'device_name': '/dev/sdb1'}, {'snapshot_id': 0x23456789, 'device_name': '/dev/sdb2'}, {'snapshot_id': 0x3456789A, 'device_name': '/dev/sdb3'}, {'no_device': True, 'device_name': '/dev/sdb4'}, {'virtual_name': 'ephemeral0', 'device_name': '/dev/sdc1'}, {'snapshot_id': 0x456789AB, 'device_name': '/dev/sdc2'}, {'snapshot_id': 0x56789ABC, 'device_name': '/dev/sdc3'}, {'no_device': True, 'device_name': '/dev/sdc4'}, {'snapshot_id': 0x87654321, 'device_name': '/dev/sdd1'}, {'snapshot_id': 0x98765432, 'device_name': '/dev/sdd2'}, {'snapshot_id': 0xA9875463, 'device_name': '/dev/sdd3'}, {'no_device': True, 'device_name': '/dev/sdd4'}] bdms.sort() expected_result.sort() self.assertDictListMatch(bdms, expected_result) for bdm in db.block_device_mapping_get_all_by_instance( self.context, instance_id): db.block_device_mapping_destroy(self.context, bdm['id']) self.compute.terminate_instance(self.context, instance_id)
def get_by_instance_uuid(cls, context, instance_uuid, use_slave=False): db_bdms = db.block_device_mapping_get_all_by_instance( context, instance_uuid, use_slave=use_slave) return base.obj_make_list(context, cls(), objects.BlockDeviceMapping, db_bdms or [])
def _format_instance_mapping(ctxt, instance): bdms = db.block_device_mapping_get_all_by_instance(ctxt, instance['uuid']) return block_device.instance_block_mapping(instance, bdms)
def _validate_device(self, device=None): bdms = db.block_device_mapping_get_all_by_instance( self.context, self.instance['uuid']) return compute_utils.get_device_name_for_instance( self.context, self.instance, bdms, device)
def _test_delete(self, delete_type, **attrs): inst = self._create_instance_obj() inst.update(attrs) inst._context = self.context delete_time = datetime.datetime(1955, 11, 5, 9, 30, tzinfo=iso8601.iso8601.Utc()) timeutils.set_time_override(delete_time) task_state = (delete_type == 'soft_delete' and task_states.SOFT_DELETING or task_states.DELETING) db_inst = obj_base.obj_to_primitive(inst) updates = {'progress': 0, 'task_state': task_state} if delete_type == 'soft_delete': updates['deleted_at'] = delete_time self.mox.StubOutWithMock(inst, 'save') self.mox.StubOutWithMock(db, 'block_device_mapping_get_all_by_instance') self.mox.StubOutWithMock(self.compute_api, '_create_reservations') self.mox.StubOutWithMock(self.context, 'elevated') self.mox.StubOutWithMock(db, 'service_get_by_compute_host') self.mox.StubOutWithMock(self.compute_api.servicegroup_api, 'service_is_up') self.mox.StubOutWithMock(db, 'migration_get_by_instance_and_status') self.mox.StubOutWithMock(self.compute_api, '_downsize_quota_delta') self.mox.StubOutWithMock(self.compute_api, '_reserve_quota_delta') self.mox.StubOutWithMock(self.compute_api, '_record_action_start') self.mox.StubOutWithMock(db, 'instance_update_and_get_original') self.mox.StubOutWithMock(inst.info_cache, 'delete') self.mox.StubOutWithMock(self.compute_api.network_api, 'deallocate_for_instance') self.mox.StubOutWithMock(db, 'instance_system_metadata_get') self.mox.StubOutWithMock(db, 'instance_destroy') self.mox.StubOutWithMock(compute_utils, 'notify_about_instance_usage') self.mox.StubOutWithMock(quota.QUOTAS, 'commit') db.block_device_mapping_get_all_by_instance(self.context, inst.uuid).AndReturn([]) inst.save() self.compute_api._create_reservations( self.context, inst, inst.instance_type_id, inst.project_id, inst.user_id).AndReturn('fake-resv') if inst.vm_state == vm_states.RESIZED: self._test_delete_resized_part(inst) self.context.elevated().MultipleTimes().AndReturn(self.context) db.service_get_by_compute_host(self.context, inst.host).AndReturn('fake-service') self.compute_api.servicegroup_api.service_is_up( 'fake-service').AndReturn(inst.host != 'down-host') if self.is_cells: rpcapi = self.compute_api.cells_rpcapi else: rpcapi = self.compute_api.compute_rpcapi self.mox.StubOutWithMock(rpcapi, 'terminate_instance') self.mox.StubOutWithMock(rpcapi, 'soft_delete_instance') if inst.host == 'down-host': inst.info_cache.delete() compute_utils.notify_about_instance_usage(self.context, inst, '%s.start' % delete_type) self.compute_api.network_api.deallocate_for_instance( self.context, inst) db.instance_system_metadata_get(self.context, inst.uuid).AndReturn('sys-meta') state = ('soft' in delete_type and vm_states.SOFT_DELETED or vm_states.DELETED) updates.update({ 'vm_state': state, 'task_state': None, 'terminated_at': delete_time }) inst.save() if self.is_cells: if delete_type == 'soft_delete': rpcapi.soft_delete_instance(self.context, inst, reservations=None) else: rpcapi.terminate_instance(self.context, inst, [], reservations=None) db.instance_destroy(self.context, inst.uuid, constraint=None) compute_utils.notify_about_instance_usage( self.context, inst, '%s.end' % delete_type, system_metadata='sys-meta') if inst.host == 'down-host': quota.QUOTAS.commit(self.context, 'fake-resv', project_id=inst.project_id, user_id=inst.user_id) elif delete_type == 'soft_delete': self.compute_api._record_action_start(self.context, inst, instance_actions.DELETE) rpcapi.soft_delete_instance(self.context, inst, reservations='fake-resv') elif delete_type in ['delete', 'force_delete']: self.compute_api._record_action_start(self.context, inst, instance_actions.DELETE) rpcapi.terminate_instance(self.context, inst, [], reservations='fake-resv') self.mox.ReplayAll() getattr(self.compute_api, delete_type)(self.context, inst) for k, v in updates.items(): self.assertEqual(inst[k], v)
def _test_delete(self, delete_type, **attrs): inst = self._create_instance_obj() inst.update(attrs) delete_time = datetime.datetime(1955, 11, 5, 9, 30) timeutils.set_time_override(delete_time) task_state = (delete_type == 'soft_delete' and task_states.SOFT_DELETING or task_states.DELETING) db_inst = obj_base.obj_to_primitive(inst) updates = {'progress': 0, 'task_state': task_state} if delete_type == 'soft_delete': updates['deleted_at'] = delete_time new_inst = dict(db_inst, **updates) self.mox.StubOutWithMock(db, 'block_device_mapping_get_all_by_instance') self.mox.StubOutWithMock(self.compute_api, '_create_reservations') self.mox.StubOutWithMock(self.context, 'elevated') self.mox.StubOutWithMock(db, 'service_get_by_compute_host') self.mox.StubOutWithMock(self.compute_api.servicegroup_api, 'service_is_up') self.mox.StubOutWithMock(db, 'migration_get_by_instance_and_status') self.mox.StubOutWithMock(self.compute_api, '_downsize_quota_delta') self.mox.StubOutWithMock(self.compute_api, '_reserve_quota_delta') self.mox.StubOutWithMock(self.compute_api, '_record_action_start') self.mox.StubOutWithMock(db, 'instance_update_and_get_original') self.mox.StubOutWithMock(db, 'instance_info_cache_delete') self.mox.StubOutWithMock(self.compute_api.network_api, 'deallocate_for_instance') self.mox.StubOutWithMock(db, 'instance_system_metadata_get') self.mox.StubOutWithMock(db, 'instance_destroy') self.mox.StubOutWithMock(compute_utils, 'notify_about_instance_usage') self.mox.StubOutWithMock(quota.QUOTAS, 'commit') self.mox.StubOutWithMock(self.compute_api.compute_rpcapi, 'terminate_instance') self.mox.StubOutWithMock(self.compute_api.compute_rpcapi, 'soft_delete_instance') db.block_device_mapping_get_all_by_instance( self.context, inst.uuid).AndReturn([]) db.instance_update_and_get_original( self.context, inst.uuid, updates).AndReturn((db_inst, new_inst)) self.compute_api._create_reservations( self.context, db_inst, new_inst, inst.project_id, inst.user_id ).AndReturn('fake-resv') if inst.vm_state == vm_states.RESIZED: self._test_delete_resized_part(db_inst) self.context.elevated().MultipleTimes().AndReturn(self.context) db.service_get_by_compute_host(self.context, inst.host).AndReturn( 'fake-service') self.compute_api.servicegroup_api.service_is_up( 'fake-service').AndReturn(inst.host != 'down-host') if inst.host == 'down-host' and ( not self.is_cells or not inst.cell_name): db.instance_info_cache_delete(self.context, inst.uuid) compute_utils.notify_about_instance_usage(self.context, db_inst, 'delete.start') self.compute_api.network_api.deallocate_for_instance( self.context, db_inst) db.instance_system_metadata_get(self.context, inst.uuid ).AndReturn('sys-meta') updates = {'vm_state': vm_states.DELETED, 'task_state': None, 'terminated_at': delete_time} del_inst = dict(new_inst, **updates) db.instance_update_and_get_original( self.context, inst.uuid, updates ).AndReturn((db_inst, del_inst)) db.instance_destroy(self.context, inst.uuid) compute_utils.notify_about_instance_usage( self.context, del_inst, 'delete.end', system_metadata='sys-meta') if inst.host == 'down-host': quota.QUOTAS.commit(self.context, 'fake-resv', project_id=inst.project_id, user_id=inst.user_id) elif delete_type == 'soft_delete': self.compute_api._record_action_start(self.context, db_inst, instance_actions.DELETE) self.compute_api.compute_rpcapi.soft_delete_instance( self.context, db_inst, reservations='fake-resv') elif delete_type in ['delete', 'force_delete']: self.compute_api._record_action_start(self.context, db_inst, instance_actions.DELETE) self.compute_api.compute_rpcapi.terminate_instance( self.context, db_inst, [], reservations='fake-resv') if self.is_cells: self.mox.StubOutWithMock(self.compute_api, '_cast_to_cells') self.compute_api._cast_to_cells( self.context, db_inst, delete_type) self.mox.ReplayAll() getattr(self.compute_api, delete_type)(self.context, db_inst)
def _db_block_device_mapping_get_all_by_instance(context, instance_uuid, use_slave=False): return db.block_device_mapping_get_all_by_instance( context, instance_uuid)