def test_legacy_mapping_from_object_list(self): bdm1 = block_device_obj.BlockDeviceMapping() bdm1 = block_device_obj.BlockDeviceMapping._from_db_object( None, bdm1, fake_block_device.FakeDbBlockDeviceDict(self.new_mapping[0])) bdm2 = block_device_obj.BlockDeviceMapping() bdm2 = block_device_obj.BlockDeviceMapping._from_db_object( None, bdm2, fake_block_device.FakeDbBlockDeviceDict(self.new_mapping[1])) bdmlist = block_device_obj.BlockDeviceMappingList() bdmlist.objects = [bdm1, bdm2] block_device.legacy_mapping(bdmlist)
def test_snapshot_from_object(self): for bdm in self.new_mapping[:-1]: obj = block_device_obj.BlockDeviceMapping() obj = block_device_obj.BlockDeviceMapping._from_db_object( None, obj, fake_block_device.FakeDbBlockDeviceDict( bdm)) self._test_snapshot_from_bdm(obj)
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_compute_api(self, method, rpc_method, expected_args=None, **kwargs): ctxt = context.RequestContext('fake_user', 'fake_project') rpcapi = kwargs.pop('rpcapi_class', compute_rpcapi.ComputeAPI)() self.assertIsNotNone(rpcapi.client) self.assertEqual(rpcapi.client.target.topic, CONF.compute_topic) orig_prepare = rpcapi.client.prepare base_version = rpcapi.client.target.version expected_version = kwargs.pop('version', base_version) expected_kwargs = kwargs.copy() if expected_args: expected_kwargs.update(expected_args) if 'host_param' in expected_kwargs: expected_kwargs['host'] = expected_kwargs.pop('host_param') else: expected_kwargs.pop('host', None) cast_and_call = ['confirm_resize', 'stop_instance'] if rpc_method == 'call' and method in cast_and_call: if method == 'confirm_resize': kwargs['cast'] = False else: kwargs['do_cast'] = False if 'host' in kwargs: host = kwargs['host'] elif 'instances' in kwargs: host = kwargs['instances'][0]['host'] else: host = kwargs['instance']['host'] with contextlib.nested( mock.patch.object(rpcapi.client, rpc_method), mock.patch.object(rpcapi.client, 'prepare'), mock.patch.object(rpcapi.client, 'can_send_version'), ) as ( rpc_mock, prepare_mock, csv_mock ): prepare_mock.return_value = rpcapi.client if '_return_value' in kwargs: rpc_mock.return_value = kwargs.pop('_return_value') del expected_kwargs['_return_value'] elif 'return_bdm_object' in kwargs: del kwargs['return_bdm_object'] rpc_mock.return_value = objects_block_dev.BlockDeviceMapping() elif rpc_method == 'call': rpc_mock.return_value = 'foo' else: rpc_mock.return_value = None csv_mock.side_effect = ( lambda v: orig_prepare(version=v).can_send_version()) retval = getattr(rpcapi, method)(ctxt, **kwargs) self.assertEqual(retval, rpc_mock.return_value) prepare_mock.assert_called_once_with(version=expected_version, server=host) rpc_mock.assert_called_once_with(ctxt, method, **expected_kwargs)
def test_create_fails_instance(self): values = {'source_type': 'volume', 'volume_id': 'fake-vol-id', 'destination_type': 'volume', 'instance_uuid': 'fake-instance', 'instance': instance_obj.Instance()} bdm = block_device_obj.BlockDeviceMapping(**values) self.assertRaises(exception.ObjectActionError, bdm.create, self.context)
def test_reserve_block_device_name(self): self.flags(long_rpc_timeout=1234) self._test_compute_api('reserve_block_device_name', 'call', instance=self.fake_instance_obj, device='device', volume_id='id', disk_bus='ide', device_type='cdrom', tag='foo', multiattach=True, version='5.0', timeout=1234, call_monitor_timeout=60, _return_value=objects_block_dev.BlockDeviceMapping())
def test_create(self): values = {'source_type': 'volume', 'volume_id': 'fake-vol-id', 'destination_type': 'volume', 'instance_uuid': 'fake-instance'} bdm = block_device_obj.BlockDeviceMapping(**values) with mock.patch.object(cells_rpcapi.CellsAPI, 'bdm_update_or_create_at_top'): bdm.create(self.context) for k, v in values.iteritems(): self.assertEqual(v, getattr(bdm, k))
def test_reserve_block_device_name(self): self._test_compute_api( 'reserve_block_device_name', 'call', instance=self.fake_instance_obj, device='device', volume_id='id', disk_bus='ide', device_type='cdrom', version='4.0', _return_value=objects_block_dev.BlockDeviceMapping())
def test_reserve_block_device_name(self): self._test_compute_api('reserve_block_device_name', 'call', instance=self.fake_instance_obj, device='device', volume_id='id', disk_bus='ide', device_type='cdrom', version='4.0', _return_value=objects_block_dev.BlockDeviceMapping()) self.flags(compute='kilo', group='upgrade_levels') self._test_compute_api('reserve_block_device_name', 'call', instance=self.fake_instance_obj, device='device', volume_id='id', disk_bus='ide', device_type='cdrom', version='3.35', return_bdm_object=True)
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 __init__(self, bdm): # TODO(ndipanov): Remove this check when we have all the rpc methods # use objects for block devices. if isinstance(bdm, block_device_obj.BlockDeviceMapping): self.__dict__['_bdm_obj'] = bdm else: self.__dict__['_bdm_obj'] = block_device_obj.BlockDeviceMapping() self._bdm_obj.update(block_device.BlockDeviceDict(bdm)) self._bdm_obj.obj_reset_changes() if self._bdm_obj.no_device: raise _NotTransformable() self.update(dict((field, None) for field in self._fields)) self._transform()
def _fake_bdm(volume_id, target_lun): connection_info = {'driver_volume_type': 'fibre_channel', 'data': {'volume_id': volume_id, 'target_lun': target_lun, 'initiator_target_map': {'21000024F5': ['50050768']}}} mapping_dict = {'source_type': 'volume', 'volume_id': volume_id, 'destination_type': 'volume', 'connection_info': jsonutils.dumps(connection_info), } bdm_dict = nova_block_device.BlockDeviceDict(mapping_dict) bdm_obj = bdmobj.BlockDeviceMapping(**bdm_dict) return nova_virt_bdm.DriverVolumeBlockDevice(bdm_obj)
def test_destroy_mocked(self): values = {'source_type': 'volume', 'volume_id': 'fake-vol-id', 'destination_type': 'volume', 'id': 1, 'instance_uuid': 'fake-instance', 'device_name': 'fake'} with contextlib.nested( mock.patch.object(db, 'block_device_mapping_destroy'), mock.patch.object(cells_rpcapi.CellsAPI, 'bdm_destroy_at_top') ) as (bdm_del, cells_destroy): bdm = block_device_obj.BlockDeviceMapping(**values) bdm.destroy(self.context) bdm_del.assert_called_once_with(self.context, values['id']) cells_destroy.assert_called_once_with( self.context, values['instance_uuid'], device_name=values['device_name'], volume_id=values['volume_id'])
def test_save(self): fake_bdm = self.fake_bdm() with contextlib.nested( mock.patch.object( db, 'block_device_mapping_update', return_value=fake_bdm), mock.patch.object( cells_rpcapi.CellsAPI, 'bdm_update_or_create_at_top') ) as (bdm_update_mock, cells_update_mock): bdm_object = block_device_obj.BlockDeviceMapping() bdm_object.id = 123 bdm_object.volume_id = 'fake_volume_id' bdm_object.save(self.context) bdm_update_mock.assert_called_once_with( self.context, 123, {'volume_id': 'fake_volume_id'}, legacy=False) cells_update_mock.assert_called_once_with(self.context, fake_bdm)
def test_create_mocked(self): values = {'source_type': 'volume', 'volume_id': 'fake-vol-id', 'destination_type': 'volume', 'instance_uuid': 'fake-instance'} fake_bdm = fake_block_device.FakeDbBlockDeviceDict(values) with contextlib.nested( mock.patch.object( db, 'block_device_mapping_create', return_value=fake_bdm), mock.patch.object(cells_rpcapi.CellsAPI, 'bdm_update_or_create_at_top') ) as (bdm_create_mock, cells_update_mock): bdm = block_device_obj.BlockDeviceMapping(**values) bdm.create(self.context) bdm_create_mock.assert_called_once_with( self.context, values, legacy=False) cells_update_mock.assert_called_once_with( self.context, fake_bdm, create=True)
def test_get_device_name(self): bdm_obj = block_device_obj.BlockDeviceMapping( 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 })) self.assertEqual('/dev/vda', blockinfo.get_device_name(bdm_obj)) driver_bdm = driver_block_device.DriverVolumeBlockDevice(bdm_obj) self.assertEqual('/dev/vda', blockinfo.get_device_name(driver_bdm)) bdm_obj.device_name = None self.assertEqual(None, blockinfo.get_device_name(bdm_obj)) driver_bdm = driver_block_device.DriverVolumeBlockDevice(bdm_obj) self.assertEqual(None, blockinfo.get_device_name(driver_bdm))
def _test_compute_api(self, method, rpc_method, assert_dict=False, **kwargs): ctxt = context.RequestContext('fake_user', 'fake_project') rpcapi = kwargs.pop('rpcapi_class', compute_rpcapi.ComputeAPI)() self.assertIsNotNone(rpcapi.client) self.assertEqual(rpcapi.client.target.topic, CONF.compute_topic) orig_prepare = rpcapi.client.prepare # TODO(danms): Remove this special case when we drop 3.x if CONF.upgrade_levels.compute == '3.40': base_version = '3.0' else: base_version = rpcapi.client.target.version expected_version = kwargs.pop('version', base_version) nova_network = kwargs.pop('nova_network', False) expected_kwargs = kwargs.copy() if ('requested_networks' in expected_kwargs and expected_version == '3.23'): expected_kwargs['requested_networks'] = [] for requested_network in kwargs['requested_networks']: if not nova_network: expected_kwargs['requested_networks'].append( (requested_network.network_id, str(requested_network.address), requested_network.port_id)) else: expected_kwargs['requested_networks'].append( (requested_network.network_id, str(requested_network.address))) if 'host_param' in expected_kwargs: expected_kwargs['host'] = expected_kwargs.pop('host_param') else: expected_kwargs.pop('host', None) if 'legacy_limits' in expected_kwargs: expected_kwargs['limits'] = expected_kwargs.pop('legacy_limits') kwargs.pop('legacy_limits', None) expected_kwargs.pop('destination', None) if 'mountpoint' in expected_kwargs and expected_version == '4.0': # TODO(danms): Remove me when we drop 3.x del expected_kwargs['mountpoint'] del expected_kwargs['volume_id'] if assert_dict: expected_kwargs['instance'] = jsonutils.to_primitive( expected_kwargs['instance']) cast_and_call = ['confirm_resize', 'stop_instance'] if rpc_method == 'call' and method in cast_and_call: if method == 'confirm_resize': kwargs['cast'] = False else: kwargs['do_cast'] = False if 'host' in kwargs: host = kwargs['host'] elif 'destination' in kwargs: host = kwargs['destination'] elif 'instances' in kwargs: host = kwargs['instances'][0]['host'] else: host = kwargs['instance']['host'] with contextlib.nested( mock.patch.object(rpcapi.client, rpc_method), mock.patch.object(rpcapi.client, 'prepare'), mock.patch.object(rpcapi.client, 'can_send_version'), ) as ( rpc_mock, prepare_mock, csv_mock ): prepare_mock.return_value = rpcapi.client if '_return_value' in kwargs: rpc_mock.return_value = kwargs.pop('_return_value') del expected_kwargs['_return_value'] elif 'return_bdm_object' in kwargs: del kwargs['return_bdm_object'] rpc_mock.return_value = objects_block_dev.BlockDeviceMapping() elif rpc_method == 'call': rpc_mock.return_value = 'foo' else: rpc_mock.return_value = None csv_mock.side_effect = ( lambda v: orig_prepare(version=v).can_send_version()) retval = getattr(rpcapi, method)(ctxt, **kwargs) self.assertEqual(retval, rpc_mock.return_value) prepare_mock.assert_called_once_with(version=expected_version, server=host) rpc_mock.assert_called_once_with(ctxt, method, **expected_kwargs)
def setUp(self): super(DefaultDeviceNamesTestCase, self).setUp() self.context = context.get_admin_context() self.instance = { 'uuid': '32dfcb37-5af1-552b-357c-be8c3aa38310', 'memory_kb': '1024000', 'basepath': '/some/path', 'bridge_name': 'br100', 'vcpus': 2, 'project_id': 'fake', 'bridge': 'br101', 'image_ref': '155d900f-4e14-4e4c-a73d-069cbf4541e6', 'root_gb': 10, 'ephemeral_gb': 20, 'instance_type_id': 2 } self.root_device_name = '/dev/vda' self.virt_type = 'kvm' self.flavor = {'swap': 4} self.patchers = [] self.patchers.append( mock.patch('nova.compute.flavors.extract_flavor', return_value=self.flavor)) self.patchers.append( mock.patch('nova.objects.block_device.BlockDeviceMapping.save')) for patcher in self.patchers: patcher.start() self.ephemerals = [ block_device_obj.BlockDeviceMapping( self.context, **fake_block_device.FakeDbBlockDeviceDict({ 'id': 1, 'instance_uuid': 'fake-instance', 'device_name': '/dev/vdb', 'source_type': 'blank', 'destination_type': 'local', 'device_type': 'disk', 'disk_bus': 'virtio', 'delete_on_termination': True, 'guest_format': None, 'volume_size': 1, 'boot_index': -1 })) ] self.swap = [ block_device_obj.BlockDeviceMapping( self.context, **fake_block_device.FakeDbBlockDeviceDict({ 'id': 2, 'instance_uuid': 'fake-instance', 'device_name': '/dev/vdc', 'source_type': 'blank', 'destination_type': 'local', 'device_type': 'disk', 'disk_bus': 'virtio', 'delete_on_termination': True, 'guest_format': 'swap', 'volume_size': 1, 'boot_index': -1 })) ] self.block_device_mapping = [ block_device_obj.BlockDeviceMapping( self.context, **fake_block_device.FakeDbBlockDeviceDict({ 'id': 3, 'instance_uuid': 'fake-instance', 'device_name': '/dev/vda', 'source_type': 'volume', 'destination_type': 'volume', 'device_type': 'disk', 'disk_bus': 'virtio', 'volume_id': 'fake-volume-id-1', 'boot_index': 0 })), block_device_obj.BlockDeviceMapping( self.context, **fake_block_device.FakeDbBlockDeviceDict({ 'id': 4, 'instance_uuid': 'fake-instance', 'device_name': '/dev/vdd', 'source_type': 'snapshot', 'device_type': 'disk', 'disk_bus': 'virtio', 'destination_type': 'volume', 'snapshot_id': 'fake-snapshot-id-1', 'boot_index': -1 })) ]
def test_save_instance_changed(self): bdm_object = block_device_obj.BlockDeviceMapping() bdm_object.instance = instance_obj.Instance() self.assertRaises(exception.ObjectActionError, bdm_object.save, self.context)