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))