def stub_bdm_get_all_by_instance(context, instance_uuid, use_slave=False):
return [fake_block_device.FakeDbBlockDeviceDict(
{'id': 1, 'source_type': 'volume', 'destination_type': 'volume',
'volume_id': 'volume_id1', 'instance_uuid': instance_uuid}),
fake_block_device.FakeDbBlockDeviceDict(
{'id': 2, 'source_type': 'volume', 'destination_type': 'volume',
'volume_id': 'volume_id2', 'instance_uuid': instance_uuid})]
def fake_bdms_get_all_by_instance_uuids(*args, **kwargs):
return [
fake_block_device.FakeDbBlockDeviceDict({
'id': 1,
'volume_id': 'some_volume_1',
'instance_uuid': UUID1,
'source_type': 'volume',
'destination_type': 'volume',
'delete_on_termination': True,
}),
fake_block_device.FakeDbBlockDeviceDict({
'id': 2,
'volume_id': 'some_volume_2',
'instance_uuid': UUID2,
'source_type': 'volume',
'destination_type': 'volume',
'delete_on_termination': False,
}),
fake_block_device.FakeDbBlockDeviceDict({
'id': 3,
'volume_id': 'some_volume_3',
'instance_uuid': UUID2,
'source_type': 'volume',
'destination_type': 'volume',
'delete_on_termination': False,
}),
]
def test_is_volume_backed_instance_bdm_local_no_image(self):
# if the root device is local the instance is not volume backed, even
# if no image_ref is set.
ctxt = self.context
instance = create_instance(ctxt,
params={
'root_device_name': 'vda',
'image_ref': ''
})
bdms = block_device_obj.block_device_make_list(ctxt, [
fake_block_device.FakeDbBlockDeviceDict({
'source_type': 'volume',
'device_name': '/dev/vda',
'volume_id': uuids.volume_id,
'destination_type': 'local',
'instance_uuid': 'f8000000-0000-0000-0000-000000000000',
'boot_index': 0,
'snapshot_id': None
}),
fake_block_device.FakeDbBlockDeviceDict({
'source_type': 'volume',
'device_name': '/dev/vdb',
'instance_uuid': 'f8000000-0000-0000-0000-000000000000',
'boot_index': 1,
'destination_type': 'volume',
'volume_id': 'c2ec2156-d75e-11e2-985b-5254009297d6',
'snapshot_id': None
})
])
self.assertFalse(
compute_utils.is_volume_backed_instance(ctxt, instance, bdms))
def fake_bdms_get_all_by_instance(context, instance_uuid, use_slave=False):
return [
fake_block_device.FakeDbBlockDeviceDict({
'id': 1,
'instance_uuid': instance_uuid,
'device_name': '/dev/fake0',
'delete_on_termination': 'False',
'source_type': 'volume',
'destination_type': 'volume',
'snapshot_id': None,
'volume_id': FAKE_UUID_A,
'volume_size': 1
}),
fake_block_device.FakeDbBlockDeviceDict({
'id': 2,
'instance_uuid': instance_uuid,
'device_name': '/dev/fake1',
'delete_on_termination': 'False',
'source_type': 'volume',
'destination_type': 'volume',
'snapshot_id': None,
'volume_id': FAKE_UUID_B,
'volume_size': 1
})
]
def fake_bdms_get_all_by_instance(context,
instance_uuid,
use_slave=False):
bdms = [
fake_block_device.FakeDbBlockDeviceDict({
'id':
1,
'volume_id':
self.OLD_VOLUME_ID,
'instance_uuid':
server_id,
'source_type':
'volume',
'destination_type':
'volume',
'device_name':
'/dev/sdd'
}),
fake_block_device.FakeDbBlockDeviceDict({
'id':
2,
'volume_id':
'a26887c6-c47b-4654-abb5-dfadf7d3f804',
'instance_uuid':
server_id,
'source_type':
'volume',
'destination_type':
'volume',
'device_name':
'/dev/sdc'
})
]
return bdms
def fake_bdm_get(ctxt, uuid, use_slave=False):
return [
fake_block_device.FakeDbBlockDeviceDict({
'volume_id':
87654321,
'snapshot_id':
None,
'no_device':
None,
'source_type':
'volume',
'destination_type':
'volume',
'delete_on_termination':
True,
'device_name':
'/dev/sdh'
}),
fake_block_device.FakeDbBlockDeviceDict({
'volume_id':
None,
'snapshot_id':
None,
'no_device':
None,
'source_type':
'blank',
'destination_type':
'local',
'guest_format':
'swap',
'delete_on_termination':
None,
'device_name':
'/dev/sdc'
}),
fake_block_device.FakeDbBlockDeviceDict({
'volume_id':
None,
'snapshot_id':
None,
'no_device':
None,
'source_type':
'blank',
'destination_type':
'local',
'guest_format':
None,
'delete_on_termination':
None,
'device_name':
'/dev/sdb'
})
]
def test_legacy_mapping_from_object_list(self):
bdm1 = objects.BlockDeviceMapping()
bdm1 = objects.BlockDeviceMapping._from_db_object(
None, bdm1,
fake_block_device.FakeDbBlockDeviceDict(self.new_mapping[0]))
bdm2 = objects.BlockDeviceMapping()
bdm2 = objects.BlockDeviceMapping._from_db_object(
None, bdm2,
fake_block_device.FakeDbBlockDeviceDict(self.new_mapping[1]))
bdmlist = objects.BlockDeviceMappingList()
bdmlist.objects = [bdm1, bdm2]
block_device.legacy_mapping(bdmlist)
def fake_bdms_get_all_by_instance(*args, **kwargs):
return [
fake_block_device.FakeDbBlockDeviceDict({
'volume_id': UUID1,
'source_type': 'volume',
'destination_type': 'volume',
'id': 1
}),
fake_block_device.FakeDbBlockDeviceDict({
'volume_id': UUID2,
'source_type': 'volume',
'destination_type': 'volume',
'id': 2
})
]
def _get_fake_bdms(self, ctxt):
return block_device_obj.block_device_make_list(self.ctxt,
[fake_block_device.FakeDbBlockDeviceDict(
{'device_name': '/dev/vda',
'source_type': 'volume',
'destination_type': 'volume',
'volume_id': '5d721593-f033-4f6d-ab6f-b5b067e61bc4'})])
def setUp(self):
super(ComputeRpcAPITestCase, self).setUp()
self.context = context.get_admin_context()
self.fake_flavor_obj = fake_flavor.fake_flavor_obj(self.context)
self.fake_flavor = jsonutils.to_primitive(self.fake_flavor_obj)
instance_attr = {
'host': 'fake_host',
'instance_type_id': self.fake_flavor_obj['id'],
'instance_type': self.fake_flavor_obj
}
self.fake_instance_obj = fake_instance.fake_instance_obj(
self.context, **instance_attr)
self.fake_instance = jsonutils.to_primitive(self.fake_instance_obj)
self.fake_volume_bdm = objects_block_dev.BlockDeviceMapping(
**fake_block_device.FakeDbBlockDeviceDict(
{
'source_type': 'volume',
'destination_type': 'volume',
'instance_uuid': self.fake_instance_obj.uuid,
'volume_id': 'fake-volume-id'
}))
# FIXME(melwitt): Temporary while things have no mappings
self.patcher1 = mock.patch('nova.objects.InstanceMapping.'
'get_by_instance_uuid')
self.patcher2 = mock.patch('nova.objects.HostMapping.get_by_host')
mock_inst_mapping = self.patcher1.start()
mock_host_mapping = self.patcher2.start()
mock_inst_mapping.side_effect = exception.InstanceMappingNotFound(
uuid=self.fake_instance_obj.uuid)
mock_host_mapping.side_effect = exception.HostMappingNotFound(
name=self.fake_instance_obj.host)
def _test_create_mocked(self, update_or_create=False):
values = {'source_type': 'volume', 'volume_id': 'fake-vol-id',
'destination_type': 'volume',
'instance_uuid': uuids.instance,
'attachment_id': None}
fake_bdm = fake_block_device.FakeDbBlockDeviceDict(values)
with test.nested(
mock.patch.object(
db, 'block_device_mapping_create', return_value=fake_bdm),
mock.patch.object(
db, 'block_device_mapping_update_or_create',
return_value=fake_bdm),
) as (bdm_create_mock, bdm_update_or_create_mock):
bdm = objects.BlockDeviceMapping(context=self.context, **values)
if update_or_create:
method = bdm.update_or_create
else:
method = bdm.create
method()
if update_or_create:
bdm_update_or_create_mock.assert_called_once_with(
self.context, values, legacy=False)
else:
bdm_create_mock.assert_called_once_with(
self.context, values, legacy=False)
def fake_bdm(self, instance=None):
instance = instance or {}
fake_bdm = fake_block_device.FakeDbBlockDeviceDict({
'id':
123,
'uuid':
uuids.bdm,
'instance_uuid':
instance.get('uuid') or uuids.instance,
'attachment_id':
None,
'device_name':
'/dev/sda2',
'source_type':
'snapshot',
'destination_type':
'volume',
'connection_info':
"{'fake': 'connection_info'}",
'snapshot_id':
'fake-snapshot-id-1',
'boot_index':
-1
})
if instance:
fake_bdm['instance'] = instance
return fake_bdm
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 test_root_volume_metadata(self):
fake_volume = {
'volume_image_metadata': {
'vol_test_key': 'vol_test_value'
}
}
class FakeVolumeApi(object):
def get(*args, **kwargs):
return fake_volume
block_device_mapping = block_device_obj.block_device_make_list(
None, [
fake_block_device.FakeDbBlockDeviceDict(
{
'id': 1,
'boot_index': 0,
'source_type': 'volume',
'destination_type': 'volume',
'volume_id': 'fake_volume_id',
'delete_on_termination': False
})
])
volume_meta = block_device_mapping.root_metadata(
self.context, None, FakeVolumeApi())
self.assertEqual(fake_volume['volume_image_metadata'], volume_meta)
def test_snapshot_from_object(self):
for bdm in self.new_mapping[:-1]:
obj = objects.BlockDeviceMapping()
obj = objects.BlockDeviceMapping._from_db_object(
None, obj, fake_block_device.FakeDbBlockDeviceDict(
bdm))
self._test_snapshot_from_bdm(obj)
def _test_create_mocked(self,
cell_type=None,
update_or_create=False,
device_name=None):
if cell_type:
self.flags(enable=True, cell_type=cell_type, group='cells')
else:
self.flags(enable=False, group='cells')
values = {
'source_type': 'volume',
'volume_id': 'fake-vol-id',
'destination_type': 'volume',
'instance_uuid': uuids.instance,
'attachment_id': None
}
if device_name:
values['device_name'] = device_name
fake_bdm = fake_block_device.FakeDbBlockDeviceDict(values)
with test.nested(
mock.patch.object(db,
'block_device_mapping_create',
return_value=fake_bdm),
mock.patch.object(db,
'block_device_mapping_update_or_create',
return_value=fake_bdm),
mock.patch.object(cells_rpcapi.CellsAPI,
'bdm_update_or_create_at_top')) as (
bdm_create_mock,
bdm_update_or_create_mock,
cells_update_mock):
bdm = objects.BlockDeviceMapping(context=self.context, **values)
if update_or_create:
method = bdm.update_or_create
else:
method = bdm.create
if cell_type == 'api':
self.assertRaises(exception.ObjectActionError, method)
else:
method()
if update_or_create:
bdm_update_or_create_mock.assert_called_once_with(
self.context, values, legacy=False)
else:
bdm_create_mock.assert_called_once_with(self.context,
values,
legacy=False)
if cell_type == 'compute' and 'device_name' in values:
self.assertEqual(1, cells_update_mock.call_count)
self.assertGreater(len(cells_update_mock.call_args[0]), 1)
self.assertEqual(self.context,
cells_update_mock.call_args[0][0])
self.assertIsInstance(cells_update_mock.call_args[0][1],
block_device_obj.BlockDeviceMapping)
self.assertEqual({'create': update_or_create or None},
cells_update_mock.call_args[1])
else:
self.assertFalse(cells_update_mock.called)
def test_image_mapping(self):
removed_fields = ['id', 'instance_uuid', 'connection_info',
'created_at', 'updated_at', 'deleted_at', 'deleted']
for bdm in self.new_mapping:
mapping_bdm = fake_block_device.FakeDbBlockDeviceDict(
bdm).get_image_mapping()
for fld in removed_fields:
self.assertNotIn(fld, mapping_bdm)
def fake_bdm_get_by_volume_and_instance(
self, ctxt, volume_id, instance_uuid, expected_attrs=None):
return objects.BlockDeviceMapping._from_db_object(
ctxt, objects.BlockDeviceMapping(),
fake_block_device.FakeDbBlockDeviceDict(
{'id': 1, 'volume_id': self.OLD_VOLUME_ID,
'instance_uuid': instance_uuid, 'source_type': 'volume',
'destination_type': 'volume', 'device_name': '/dev/sdd'})
)
def test_attach_detach_different_power_states(self, _):
instance_ref, network_info = self._get_running_instance()
connection_info = {
"driver_volume_type": "fake",
"serial": "fake_serial",
"data": {}
}
self.connection.power_off(instance_ref)
self.connection.attach_volume(None, connection_info, instance_ref,
'/dev/sda')
bdm = {
'root_device_name':
None,
'swap':
None,
'ephemerals': [],
'block_device_mapping':
driver_block_device.convert_volumes([
objects.BlockDeviceMapping(
self.ctxt,
**fake_block_device.FakeDbBlockDeviceDict({
'id':
1,
'instance_uuid':
instance_ref['uuid'],
'device_name':
'/dev/sda',
'source_type':
'volume',
'destination_type':
'volume',
'delete_on_termination':
False,
'snapshot_id':
None,
'volume_id':
'abcdedf',
'volume_size':
None,
'no_device':
None
})),
])
}
bdm['block_device_mapping'][0]['connection_info'] = ({
'driver_volume_type':
'fake',
'data': {}
})
with mock.patch.object(driver_block_device.DriverVolumeBlockDevice,
'save'):
self.connection.power_on(self.ctxt, instance_ref, network_info,
bdm)
self.connection.detach_volume(mock.sentinel.context,
connection_info, instance_ref,
'/dev/sda')
def fake_db_req(**updates):
ctxt = context.RequestContext('fake-user', 'fake-project')
instance_uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_instance_obj(ctxt,
objects.Instance,
uuid=instance_uuid)
# This will always be set this way for an instance at build time
instance.host = None
block_devices = objects.BlockDeviceMappingList(objects=[
fake_block_device.fake_bdm_object(
context,
fake_block_device.FakeDbBlockDeviceDict(
source_type='blank',
destination_type='local',
guest_format='foo',
device_type='disk',
disk_bus='',
boot_index=1,
device_name='xvda',
delete_on_termination=False,
snapshot_id=None,
volume_id=None,
volume_size=0,
image_id='bar',
no_device=False,
connection_info=None,
tag='',
instance_uuid=uuids.instance))
])
tags = objects.TagList(
objects=[objects.Tag(tag='tag1', resource_id=instance_uuid)])
db_build_request = {
'id': 1,
'project_id': 'fake-project',
'instance_uuid': instance_uuid,
'instance': jsonutils.dumps(instance.obj_to_primitive()),
'block_device_mappings':
jsonutils.dumps(block_devices.obj_to_primitive()),
'tags': jsonutils.dumps(tags.obj_to_primitive()),
'created_at': datetime.datetime(2016, 1, 16),
'updated_at': datetime.datetime(2016, 1, 16),
}
for name, field in objects.BuildRequest.fields.items():
if name in db_build_request:
continue
if field.nullable:
db_build_request[name] = None
elif field.default != fields.UnspecifiedDefault:
db_build_request[name] = field.default
else:
raise Exception('fake_db_req needs help with %s' % name)
if updates:
db_build_request.update(updates)
return db_build_request
def _fake_bdm(device):
return fake_block_device.FakeDbBlockDeviceDict({
'source_type': 'volume',
'destination_type': 'volume',
'device_name': device,
'no_device': None,
'volume_id': 'fake',
'snapshot_id': None,
'guest_format': None
})
def test_create_instances_here(self):
# Just grab the first instance type
inst_type = flavors.get_flavor(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': '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.BlockDeviceMapping(
context=self.ctxt,
**fake_block_device.FakeDbBlockDeviceDict(
block_device.create_image_bdm('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):
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('fake_image_ref', instance['image_ref'])
def fake_bdm(self, bdm_id):
fake_bdm = fake_block_device.FakeDbBlockDeviceDict({
'id': bdm_id, 'instance_uuid': 'fake-instance',
'device_name': '/dev/sda2',
'source_type': 'snapshot',
'destination_type': 'volume',
'connection_info': "{'fake': 'connection_info'}",
'snapshot_id': 'fake-snapshot-id-1',
'boot_index': -1,
})
return fake_bdm
def fake_bdm_get_by_volume_and_instance(
self, ctxt, volume_id, instance_uuid, expected_attrs=None):
tag = self._get_tags_per_volume().get(self.OLD_VOLUME_ID)
return objects.BlockDeviceMapping._from_db_object(
ctxt, objects.BlockDeviceMapping(),
fake_block_device.FakeDbBlockDeviceDict(
{'id': 1, 'volume_id': self.OLD_VOLUME_ID,
'instance_uuid': instance_uuid, 'source_type': 'volume',
'destination_type': 'volume', 'device_name': '/dev/sdd',
'tag': tag, 'delete_on_termination': False})
)
def fake_block_device_mapping_get_all_by_instance(context, inst_id,
use_slave=False):
return [fake_block_device.FakeDbBlockDeviceDict(
{'volume_id': _fake_id('a'),
'source_type': 'snapshot',
'destination_type': 'volume',
'volume_size': 1,
'device_name': 'vda',
'snapshot_id': 1,
'boot_index': 0,
'delete_on_termination': False,
'no_device': None})]
def setUp(self):
super(ComputeRpcAPITestCase, self).setUp()
self.context = context.get_admin_context()
instance_attr = {'host': 'fake_host',
'instance_type_id': 1}
self.fake_instance_obj = fake_instance.fake_instance_obj(self.context,
**instance_attr)
self.fake_volume_bdm = objects_block_dev.BlockDeviceMapping(
**fake_block_device.FakeDbBlockDeviceDict(
{'source_type': 'volume', 'destination_type': 'volume',
'instance_uuid': self.fake_instance_obj.uuid,
'volume_id': 'fake-volume-id'}))
def setUp(self):
super(ComputeRpcAPITestCase, self).setUp()
self.context = context.get_admin_context()
instance_attr = {'host': 'fake_host',
'instance_type_id': 1}
self.fake_instance_obj = fake_instance.fake_instance_obj(self.context,
**instance_attr)
self.fake_instance = jsonutils.to_primitive(self.fake_instance_obj)
self.fake_volume_bdm = jsonutils.to_primitive(
fake_block_device.FakeDbBlockDeviceDict(
{'source_type': 'volume', 'destination_type': 'volume',
'instance_uuid': self.fake_instance['uuid'],
'volume_id': 'fake-volume-id'}))
def fake_bdm_list_get_by_instance_uuid(cls, context, instance_uuid):
db_list = [fake_block_device.FakeDbBlockDeviceDict(
{'id': 1,
'instance_uuid': instance_uuid,
'device_name': '/dev/fake0',
'delete_on_termination': 'False',
'source_type': 'volume',
'destination_type': 'volume',
'snapshot_id': None,
'volume_id': FAKE_UUID_A,
'volume_size': 1}),
fake_block_device.FakeDbBlockDeviceDict(
{'id': 2,
'instance_uuid': instance_uuid,
'device_name': '/dev/fake1',
'delete_on_termination': 'False',
'source_type': 'volume',
'destination_type': 'volume',
'snapshot_id': None,
'volume_id': FAKE_UUID_B,
'volume_size': 1})]
item_cls = objects.BlockDeviceMapping
return base.obj_make_list(context, cls(), item_cls, db_list)
def stub_bdm_get_all_by_instance_uuids(context, instance_uuids,
use_slave=False):
i = 1
result = []
for instance_uuid in instance_uuids:
for x in range(2): # add two BDMs per instance
result.append(fake_block_device.FakeDbBlockDeviceDict({
'id': i,
'source_type': 'volume',
'destination_type': 'volume',
'volume_id': 'volume_id%d' % (i),
'instance_uuid': instance_uuid,
}))
i += 1
return result
def test_is_volume_backed_instance_bdm_volume_with_image(self):
ctxt = self.context
instance = create_instance(ctxt, params={
'root_device_name': 'vda',
'image_ref': FAKE_IMAGE_REF
})
bdms = block_device_obj.block_device_make_list(ctxt,
[fake_block_device.FakeDbBlockDeviceDict(
{'source_type': 'volume',
'device_name': '/dev/vda',
'volume_id': uuids.volume_id,
'boot_index': 0,
'destination_type': 'volume'})])
self.assertTrue(
compute_utils.is_volume_backed_instance(ctxt, instance, bdms))
