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)
