def test_root_image_metadata(self):
fake_image = {"properties": {"img_test_key": "img_test_value"}}
class FakeImageApi(object):
def show(*args, **kwargs):
return fake_image
block_device_mapping = block_device_obj.block_device_make_list(
None,
[
fake_block_device.FakeDbBlockDeviceDict(
{
"id": 1,
"boot_index": 0,
"source_type": "image",
"destination_type": "local",
"image_id": "fake-image",
"delete_on_termination": True,
}
)
],
)
image_meta = block_device_mapping.root_metadata(self.context, FakeImageApi(), None)
self.assertEqual(fake_image["properties"], image_meta)
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_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 _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 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_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 _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 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 test_is_volume_backed_instance_empty_bdm_by_uuid(self, mock_bdms):
ctxt = self.context
instance = create_instance(ctxt)
mock_bdms.return_value = block_device_obj.block_device_make_list(
ctxt, [])
self.assertFalse(
compute_utils.is_volume_backed_instance(ctxt, instance, None))
mock_bdms.assert_called_with(ctxt, instance.uuid)
def test_is_volume_backed_instance_empty_bdm_by_uuid(self, mock_bdms):
ctxt = self.context
instance = create_instance(ctxt)
mock_bdms.return_value = block_device_obj.block_device_make_list(
ctxt, [])
self.assertFalse(
compute_utils.is_volume_backed_instance(ctxt, instance, None))
mock_bdms.assert_called_with(ctxt, instance.uuid)
def test_is_volume_backed_instance_empty_bdm_with_image(self):
ctxt = self.context
instance = create_instance(ctxt, params={
'root_device_name': 'vda',
'image_ref': FAKE_IMAGE_REF
})
self.assertFalse(
compute_utils.is_volume_backed_instance(
ctxt, instance,
block_device_obj.block_device_make_list(ctxt, [])))
def test_is_volume_backed_instance_empty_bdm_with_image(self):
ctxt = self.context
instance = create_instance(ctxt, params={
'root_device_name': 'vda',
'image_ref': FAKE_IMAGE_REF
})
self.assertFalse(
compute_utils.is_volume_backed_instance(
ctxt, instance,
block_device_obj.block_device_make_list(ctxt, [])))
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))
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))
def test_is_volume_backed_instance_bdm_snapshot(self):
ctxt = self.context
instance = create_instance(ctxt, params={
'root_device_name': 'vda'
})
bdms = block_device_obj.block_device_make_list(ctxt,
[fake_block_device.FakeDbBlockDeviceDict(
{'source_type': 'volume',
'device_name': '/dev/vda',
'snapshot_id': 'de8836ac-d75e-11e2-8271-5254009297d6',
'instance_uuid': 'f8000000-0000-0000-0000-000000000000',
'destination_type': 'volume',
'boot_index': 0,
'volume_id': None})])
self.assertTrue(
compute_utils.is_volume_backed_instance(ctxt, instance, bdms))
def test_is_volume_backed_instance_bdm_snapshot(self):
ctxt = self.context
instance = create_instance(ctxt, params={'root_device_name': 'vda'})
bdms = block_device_obj.block_device_make_list(ctxt, [
fake_block_device.FakeDbBlockDeviceDict({
'source_type': 'volume',
'device_name': '/dev/vda',
'snapshot_id': 'de8836ac-d75e-11e2-8271-5254009297d6',
'instance_uuid': 'f8000000-0000-0000-0000-000000000000',
'destination_type': 'volume',
'boot_index': 0,
'volume_id': None
})
])
self.assertTrue(
compute_utils.is_volume_backed_instance(ctxt, instance, bdms))
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))
def test_root_image_metadata(self):
fake_image = {'properties': {'img_test_key': 'img_test_value'}}
class FakeImageApi(object):
def show(*args, **kwargs):
return fake_image
block_device_mapping = block_device_obj.block_device_make_list(None, [
fake_block_device.FakeDbBlockDeviceDict(
{'id': 1,
'boot_index': 0,
'source_type': 'image',
'destination_type': 'local',
'image_id': "fake-image",
'delete_on_termination': True})])
image_meta = block_device_mapping.root_metadata(
self.context, FakeImageApi(), None)
self.assertEqual(fake_image['properties'], image_meta)
def test_is_volume_backed_instance_bdm_snapshot(self):
ctxt = self.context
instance = create_instance(ctxt, params={"root_device_name": "vda"})
bdms = block_device_obj.block_device_make_list(
ctxt,
[
fake_block_device.FakeDbBlockDeviceDict(
{
"source_type": "volume",
"device_name": "/dev/vda",
"snapshot_id": "de8836ac-d75e-11e2-8271-5254009297d6",
"instance_uuid": "f8000000-0000-0000-0000-000000000000",
"destination_type": "volume",
"boot_index": 0,
"volume_id": None,
}
)
],
)
self.assertTrue(compute_utils.is_volume_backed_instance(ctxt, instance, bdms))
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 setUp(self):
super(DefaultDeviceNamesForInstanceTestCase, self).setUp()
self.context = context.RequestContext('fake', 'fake')
self.ephemerals = block_device_obj.block_device_make_list(
self.context,
[fake_block_device.FakeDbBlockDeviceDict(
{'id': 1,
'instance_uuid': uuids.block_device_instance,
'device_name': '/dev/vdb',
'source_type': 'blank',
'destination_type': 'local',
'delete_on_termination': True,
'guest_format': None,
'boot_index': -1})])
self.swap = block_device_obj.block_device_make_list(
self.context,
[fake_block_device.FakeDbBlockDeviceDict(
{'id': 2,
'instance_uuid': uuids.block_device_instance,
'device_name': '/dev/vdc',
'source_type': 'blank',
'destination_type': 'local',
'delete_on_termination': True,
'guest_format': 'swap',
'boot_index': -1})])
self.block_device_mapping = block_device_obj.block_device_make_list(
self.context,
[fake_block_device.FakeDbBlockDeviceDict(
{'id': 3,
'instance_uuid': uuids.block_device_instance,
'device_name': '/dev/vda',
'source_type': 'volume',
'destination_type': 'volume',
'volume_id': 'fake-volume-id-1',
'boot_index': 0}),
fake_block_device.FakeDbBlockDeviceDict(
{'id': 4,
'instance_uuid': uuids.block_device_instance,
'device_name': '/dev/vdd',
'source_type': 'snapshot',
'destination_type': 'volume',
'snapshot_id': 'fake-snapshot-id-1',
'boot_index': -1}),
fake_block_device.FakeDbBlockDeviceDict(
{'id': 5,
'instance_uuid': uuids.block_device_instance,
'device_name': '/dev/vde',
'source_type': 'blank',
'destination_type': 'volume',
'boot_index': -1})])
self.instance = {'uuid': uuids.instance,
'ephemeral_gb': 2}
self.is_libvirt = False
self.root_device_name = '/dev/vda'
self.update_called = False
self.patchers = []
self.patchers.append(
mock.patch.object(objects.BlockDeviceMapping, 'save'))
for patcher in self.patchers:
patcher.start()
def setUp(self):
super(DefaultDeviceNamesForInstanceTestCase, self).setUp()
self.context = context.RequestContext('fake', 'fake')
self.ephemerals = block_device_obj.block_device_make_list(
self.context,
[fake_block_device.FakeDbBlockDeviceDict(
{'id': 1, 'instance_uuid': 'fake-instance',
'device_name': '/dev/vdb',
'source_type': 'blank',
'destination_type': 'local',
'delete_on_termination': True,
'guest_format': None,
'boot_index': -1})])
self.swap = block_device_obj.block_device_make_list(
self.context,
[fake_block_device.FakeDbBlockDeviceDict(
{'id': 2, 'instance_uuid': 'fake-instance',
'device_name': '/dev/vdc',
'source_type': 'blank',
'destination_type': 'local',
'delete_on_termination': True,
'guest_format': 'swap',
'boot_index': -1})])
self.block_device_mapping = block_device_obj.block_device_make_list(
self.context,
[fake_block_device.FakeDbBlockDeviceDict(
{'id': 3, 'instance_uuid': 'fake-instance',
'device_name': '/dev/vda',
'source_type': 'volume',
'destination_type': 'volume',
'volume_id': 'fake-volume-id-1',
'boot_index': 0}),
fake_block_device.FakeDbBlockDeviceDict(
{'id': 4, 'instance_uuid': 'fake-instance',
'device_name': '/dev/vdd',
'source_type': 'snapshot',
'destination_type': 'volume',
'snapshot_id': 'fake-snapshot-id-1',
'boot_index': -1}),
fake_block_device.FakeDbBlockDeviceDict(
{'id': 5, 'instance_uuid': 'fake-instance',
'device_name': '/dev/vde',
'source_type': 'blank',
'destination_type': 'volume',
'boot_index': -1})])
self.flavor = {'swap': 4}
self.instance = {'uuid': 'fake_instance', 'ephemeral_gb': 2}
self.is_libvirt = False
self.root_device_name = '/dev/vda'
self.update_called = False
def fake_extract_flavor(instance):
return self.flavor
def fake_driver_matches(driver_string):
if driver_string == 'libvirt.LibvirtDriver':
return self.is_libvirt
return False
self.patchers = []
self.patchers.append(
mock.patch.object(objects.BlockDeviceMapping, 'save'))
self.patchers.append(
mock.patch.object(
flavors, 'extract_flavor',
new=mock.Mock(side_effect=fake_extract_flavor)))
self.patchers.append(
mock.patch.object(driver,
'compute_driver_matches',
new=mock.Mock(
side_effect=fake_driver_matches)))
for patcher in self.patchers:
patcher.start()
def setUp(self):
super(DefaultDeviceNamesForInstanceTestCase, self).setUp()
self.context = context.RequestContext('fake', 'fake')
self.ephemerals = block_device_obj.block_device_make_list(
self.context, [
fake_block_device.FakeDbBlockDeviceDict(
{
'id': 1,
'instance_uuid': 'fake-instance',
'device_name': '/dev/vdb',
'source_type': 'blank',
'destination_type': 'local',
'delete_on_termination': True,
'guest_format': None,
'boot_index': -1
})
])
self.swap = block_device_obj.block_device_make_list(
self.context, [
fake_block_device.FakeDbBlockDeviceDict(
{
'id': 2,
'instance_uuid': 'fake-instance',
'device_name': '/dev/vdc',
'source_type': 'blank',
'destination_type': 'local',
'delete_on_termination': True,
'guest_format': 'swap',
'boot_index': -1
})
])
self.block_device_mapping = block_device_obj.block_device_make_list(
self.context, [
fake_block_device.FakeDbBlockDeviceDict({
'id': 3,
'instance_uuid': 'fake-instance',
'device_name': '/dev/vda',
'source_type': 'volume',
'destination_type': 'volume',
'volume_id': 'fake-volume-id-1',
'boot_index': 0
}),
fake_block_device.FakeDbBlockDeviceDict({
'id': 4,
'instance_uuid': 'fake-instance',
'device_name': '/dev/vdd',
'source_type': 'snapshot',
'destination_type': 'volume',
'snapshot_id': 'fake-snapshot-id-1',
'boot_index': -1
}),
fake_block_device.FakeDbBlockDeviceDict({
'id': 5,
'instance_uuid': 'fake-instance',
'device_name': '/dev/vde',
'source_type': 'blank',
'destination_type': 'volume',
'boot_index': -1
})
])
self.flavor = {'swap': 4}
self.instance = {'uuid': 'fake_instance', 'ephemeral_gb': 2}
self.is_libvirt = False
self.root_device_name = '/dev/vda'
self.update_called = False
def fake_extract_flavor(instance):
return self.flavor
def fake_driver_matches(driver_string):
if driver_string == 'libvirt.LibvirtDriver':
return self.is_libvirt
return False
self.patchers = []
self.patchers.append(
mock.patch.object(objects.BlockDeviceMapping, 'save'))
self.patchers.append(
mock.patch.object(flavors,
'extract_flavor',
new=mock.Mock(side_effect=fake_extract_flavor)))
self.patchers.append(
mock.patch.object(driver,
'compute_driver_matches',
new=mock.Mock(side_effect=fake_driver_matches)))
for patcher in self.patchers:
patcher.start()
def setUp(self):
super(DefaultDeviceNamesForInstanceTestCase, self).setUp()
self.context = context.RequestContext("fake", "fake")
self.ephemerals = block_device_obj.block_device_make_list(
self.context,
[
fake_block_device.FakeDbBlockDeviceDict(
{
"id": 1,
"instance_uuid": "fake-instance",
"device_name": "/dev/vdb",
"source_type": "blank",
"destination_type": "local",
"delete_on_termination": True,
"guest_format": None,
"boot_index": -1,
}
)
],
)
self.swap = block_device_obj.block_device_make_list(
self.context,
[
fake_block_device.FakeDbBlockDeviceDict(
{
"id": 2,
"instance_uuid": "fake-instance",
"device_name": "/dev/vdc",
"source_type": "blank",
"destination_type": "local",
"delete_on_termination": True,
"guest_format": "swap",
"boot_index": -1,
}
)
],
)
self.block_device_mapping = block_device_obj.block_device_make_list(
self.context,
[
fake_block_device.FakeDbBlockDeviceDict(
{
"id": 3,
"instance_uuid": "fake-instance",
"device_name": "/dev/vda",
"source_type": "volume",
"destination_type": "volume",
"volume_id": "fake-volume-id-1",
"boot_index": 0,
}
),
fake_block_device.FakeDbBlockDeviceDict(
{
"id": 4,
"instance_uuid": "fake-instance",
"device_name": "/dev/vdd",
"source_type": "snapshot",
"destination_type": "volume",
"snapshot_id": "fake-snapshot-id-1",
"boot_index": -1,
}
),
fake_block_device.FakeDbBlockDeviceDict(
{
"id": 5,
"instance_uuid": "fake-instance",
"device_name": "/dev/vde",
"source_type": "blank",
"destination_type": "volume",
"boot_index": -1,
}
),
],
)
self.instance = {"uuid": "fake_instance", "ephemeral_gb": 2}
self.is_libvirt = False
self.root_device_name = "/dev/vda"
self.update_called = False
def fake_driver_matches(driver_string):
if driver_string == "libvirt.LibvirtDriver":
return self.is_libvirt
return False
self.patchers = []
self.patchers.append(mock.patch.object(objects.BlockDeviceMapping, "save"))
self.patchers.append(
mock.patch.object(driver, "compute_driver_matches", new=mock.Mock(side_effect=fake_driver_matches))
)
for patcher in self.patchers:
patcher.start()
def setUp(self):
super(DefaultDeviceNamesForInstanceTestCase, self).setUp()
self.context = context.RequestContext('fake', 'fake')
self.ephemerals = block_device_obj.block_device_make_list(
self.context,
[fake_block_device.FakeDbBlockDeviceDict(
{'id': 1,
'instance_uuid': uuids.block_device_instance,
'device_name': '/dev/vdb',
'source_type': 'blank',
'destination_type': 'local',
'delete_on_termination': True,
'guest_format': None,
'boot_index': -1})])
self.swap = block_device_obj.block_device_make_list(
self.context,
[fake_block_device.FakeDbBlockDeviceDict(
{'id': 2,
'instance_uuid': uuids.block_device_instance,
'device_name': '/dev/vdc',
'source_type': 'blank',
'destination_type': 'local',
'delete_on_termination': True,
'guest_format': 'swap',
'boot_index': -1})])
self.block_device_mapping = block_device_obj.block_device_make_list(
self.context,
[fake_block_device.FakeDbBlockDeviceDict(
{'id': 3,
'instance_uuid': uuids.block_device_instance,
'device_name': '/dev/vda',
'source_type': 'volume',
'destination_type': 'volume',
'volume_id': 'fake-volume-id-1',
'boot_index': 0}),
fake_block_device.FakeDbBlockDeviceDict(
{'id': 4,
'instance_uuid': uuids.block_device_instance,
'device_name': '/dev/vdd',
'source_type': 'snapshot',
'destination_type': 'volume',
'snapshot_id': 'fake-snapshot-id-1',
'boot_index': -1}),
fake_block_device.FakeDbBlockDeviceDict(
{'id': 5,
'instance_uuid': uuids.block_device_instance,
'device_name': '/dev/vde',
'source_type': 'blank',
'destination_type': 'volume',
'boot_index': -1})])
self.instance = {'uuid': uuids.instance,
'ephemeral_gb': 2}
self.is_libvirt = False
self.root_device_name = '/dev/vda'
self.update_called = False
self.patchers = []
self.patchers.append(
mock.patch.object(objects.BlockDeviceMapping, 'save'))
for patcher in self.patchers:
patcher.start()
