def get_test_instance(context=None, flavor=None, obj=False): if not context: context = get_test_admin_context() if not flavor: flavor = get_test_flavor(context) metadata = {} flavors.save_flavor_info(metadata, flavor, '') test_instance = {'memory_kb': '2048000', 'basepath': '/some/path', 'bridge_name': 'br100', 'vcpus': 4, 'root_gb': 40, 'project_id': 'fake', 'bridge': 'br101', 'image_ref': 'cedef40a-ed67-4d10-800e-17455edce175', 'instance_type_id': '5', 'system_metadata': metadata, 'extra_specs': {}} if obj: instance = instance_obj.Instance(context, **test_instance) instance.create() else: instance = nova.db.instance_create(context, test_instance) return instance
def get_test_instance(context=None, instance_type=None): if not context: context = get_test_admin_context() if not instance_type: instance_type = get_test_instance_type(context) metadata = {} flavors.save_flavor_info(metadata, instance_type, "") test_instance = { "memory_kb": "2048000", "basepath": "/some/path", "bridge_name": "br100", "vcpus": 4, "root_gb": 40, "project_id": "fake", "bridge": "br101", "image_ref": "cedef40a-ed67-4d10-800e-17455edce175", "instance_type_id": "5", "system_metadata": metadata, "extra_specs": {}, } instance_ref = nova.db.instance_create(context, test_instance) return instance_ref
def get_test_instance(context=None, flavor=None, obj=False): if not context: context = get_test_admin_context() if not flavor: flavor = get_test_flavor(context) test_instance = { "memory_kb": "2048000", "basepath": "/some/path", "bridge_name": "br100", "vcpus": 4, "root_gb": 40, "bridge": "br101", "image_ref": "cedef40a-ed67-4d10-800e-17455edce175", "instance_type_id": flavor["id"], "system_metadata": {}, "extra_specs": {}, "user_id": context.user_id, "project_id": context.project_id, } if obj: instance = objects.Instance(context, **test_instance) instance.flavor = objects.Flavor.get_by_id(context, flavor["id"]) instance.create() else: flavors.save_flavor_info(test_instance["system_metadata"], flavor, "") instance = nova.db.instance_create(context, test_instance) return instance
def test_delete_flavor_info(self): instance_type = flavors.get_default_flavor() metadata = {} flavors.save_flavor_info(metadata, instance_type) flavors.save_flavor_info(metadata, instance_type, '_') flavors.delete_flavor_info(metadata, '', '_') self.assertEqual(metadata, {})
def get_test_instance(context=None, flavor=None, obj=False): if not context: context = get_test_admin_context() if not flavor: flavor = get_test_flavor(context) test_instance = {'memory_kb': '2048000', 'basepath': '/some/path', 'bridge_name': 'br100', 'vcpus': 4, 'root_gb': 40, 'bridge': 'br101', 'image_ref': 'cedef40a-ed67-4d10-800e-17455edce175', 'instance_type_id': flavor['id'], 'system_metadata': {}, 'extra_specs': {}, 'user_id': context.user_id, 'project_id': context.project_id, } if obj: instance = objects.Instance(context, **test_instance) instance.flavor = objects.Flavor.get_by_id(context, flavor['id']) instance.create() else: flavors.save_flavor_info(test_instance['system_metadata'], flavor, '') instance = nova.db.instance_create(context, test_instance) return instance
def build_request_spec(image, instances, instance_type=None): """Build a request_spec for the scheduler. The request_spec assumes that all instances to be scheduled are the same type. :param image: optional primitive image meta dict :param instances: list of instances; objects will be converted to primitives :param instance_type: optional flavor; objects will be converted to primitives :return: dict with the following keys:: 'image': the image dict passed in or {} 'instance_properties': primitive version of the first instance passed 'instance_type': primitive version of the instance_type or None 'num_instances': the number of instances passed in """ instance = instances[0] if instance_type is None: if isinstance(instance, obj_instance.Instance): instance_type = instance.get_flavor() else: instance_type = flavors.extract_flavor(instance) if isinstance(instance, obj_instance.Instance): instance = obj_base.obj_to_primitive(instance) # obj_to_primitive doesn't copy this enough, so be sure # to detach our metadata blob because we modify it below. instance['system_metadata'] = dict(instance.get('system_metadata', {})) if isinstance(instance_type, objects.Flavor): instance_type = obj_base.obj_to_primitive(instance_type) # NOTE(danms): Replicate this old behavior because the # scheduler RPC interface technically expects it to be # there. Remove this when we bump the scheduler RPC API to # v5.0 try: flavors.save_flavor_info(instance.get('system_metadata', {}), instance_type) except KeyError: # If the flavor isn't complete (which is legit with a # flavor object, just don't put it in the request spec pass request_spec = { 'image': image or {}, 'instance_properties': instance, 'instance_type': instance_type, 'num_instances': len(instances)} # NOTE(mriedem): obj_to_primitive above does not serialize everything # in an object, like datetime fields, so we need to still call to_primitive # to recursively serialize the items in the request_spec dict. return jsonutils.to_primitive(request_spec)
def _test_extract_flavor(self, prefix): instance_type = flavors.get_default_flavor() metadata = {} flavors.save_flavor_info(metadata, instance_type, prefix) instance = {"system_metadata": self._dict_to_metadata(metadata)} _instance_type = flavors.extract_flavor(instance, prefix) props = flavors.system_metadata_flavor_props.keys() for key in instance_type.keys(): if key not in props: del instance_type[key] self.assertEqual(instance_type, _instance_type)
def test_add_fixed_ip_to_instance_refresh_cache(self): sys_meta = flavors.save_flavor_info({}, test_flavor.fake_flavor) instance = fake_instance.fake_instance_obj( self.context, expected_attrs=["system_metadata"], system_metadata=sys_meta ) network_id = "fake-network-id" self._test_refresh_cache("add_fixed_ip_to_instance", self.context, instance, network_id)
def _stub_migrate_instance_calls(self, method, multi_host, info): fake_flavor = flavors.get_default_flavor() fake_flavor['rxtx_factor'] = 1.21 sys_meta = flavors.save_flavor_info({}, fake_flavor) fake_instance = objects.Instance( uuid=uuid.uuid4().hex, project_id='fake_project_id', instance_type_id=fake_flavor['id'], system_metadata=sys_meta) fake_migration = {'source_compute': 'fake_compute_source', 'dest_compute': 'fake_compute_dest'} def fake_mig_inst_method(*args, **kwargs): info['kwargs'] = kwargs def fake_get_multi_addresses(*args, **kwargs): return multi_host, ['fake_float1', 'fake_float2'] self.stubs.Set(network_rpcapi.NetworkAPI, method, fake_mig_inst_method) self.stubs.Set(self.network_api, '_get_multi_addresses', fake_get_multi_addresses) expected = {'instance_uuid': fake_instance.uuid, 'source_compute': 'fake_compute_source', 'dest_compute': 'fake_compute_dest', 'rxtx_factor': 1.21, 'project_id': 'fake_project_id', 'floating_addresses': None} if multi_host: expected['floating_addresses'] = ['fake_float1', 'fake_float2'] return fake_instance, fake_migration, expected
def _create_instances_here(self, ctxt, instance_uuids, instance_properties, instance_type, image, security_groups, block_device_mapping): instance_values = copy.copy(instance_properties) # The parent may pass these metadata values as lists, and the # create call expects it to be a dict. instance_values['metadata'] = utils.instance_meta(instance_values) sys_metadata = utils.instance_sys_meta(instance_values) # Make sure the flavor info is set. It may not have been passed # down. sys_metadata = flavors.save_flavor_info(sys_metadata, instance_type) instance_values['system_metadata'] = sys_metadata # Pop out things that will get set properly when re-creating the # instance record. instance_values.pop('id') instance_values.pop('name') instance_values.pop('info_cache') instance_values.pop('security_groups') num_instances = len(instance_uuids) for i, instance_uuid in enumerate(instance_uuids): instance = instance_obj.Instance() instance.update(instance_values) instance.uuid = instance_uuid instance = self.compute_api.create_db_entry_for_new_instance( ctxt, instance_type, image, instance, security_groups, block_device_mapping, num_instances, i) instance = obj_base.obj_to_primitive(instance) self.msg_runner.instance_update_at_top(ctxt, instance)
def test_allocate_for_instance_handles_macs_passed(self): # If a macs argument is supplied to the 'nova-network' API, it is just # ignored. This test checks that the call down to the rpcapi layer # doesn't pass macs down: nova-network doesn't support hypervisor # mac address limits (today anyhow). macs = set(["ab:cd:ef:01:23:34"]) self.mox.StubOutWithMock(self.network_api.network_rpcapi, "allocate_for_instance") kwargs = dict( zip( [ "host", "instance_id", "project_id", "requested_networks", "rxtx_factor", "vpn", "macs", "dhcp_options", ], itertools.repeat(mox.IgnoreArg()), ) ) self.network_api.network_rpcapi.allocate_for_instance(mox.IgnoreArg(), **kwargs).AndReturn([]) self.mox.ReplayAll() flavor = flavors.get_default_flavor() flavor["rxtx_factor"] = 0 sys_meta = flavors.save_flavor_info({}, flavor) instance = dict( id="id", uuid="uuid", project_id="project_id", host="host", system_metadata=utils.dict_to_metadata(sys_meta) ) self.network_api.allocate_for_instance(self.context, instance, "vpn", "requested_networks", macs=macs)
def test_remove_fixed_ip_from_instance_refresh_cache(self): sys_meta = flavors.save_flavor_info({}, test_flavor.fake_flavor) instance = fake_instance.fake_instance_obj( self.context, expected_attrs=["system_metadata"], system_metadata=sys_meta ) address = "fake-address" self._test_refresh_cache("remove_fixed_ip_from_instance", self.context, instance, address)
def compat_instance(instance): """Create a dict-like instance structure from an objects.Instance. This is basically the same as nova.objects.base.obj_to_primitive(), except that it includes some instance-specific details, like stashing flavor information in system_metadata. If you have a function (or RPC client) that needs to see the instance as a dict that has flavor information in system_metadata, use this to appease it (while you fix said thing). :param instance: a nova.objects.Instance instance :returns: a dict-based instance structure """ if not isinstance(instance, objects.Instance): return instance db_instance = copy.deepcopy(base.obj_to_primitive(instance)) flavor_attrs = [("", "flavor"), ("old_", "old_flavor"), ("new_", "new_flavor")] for prefix, attr in flavor_attrs: flavor = instance.obj_attr_is_set(attr) and getattr(instance, attr) or None if flavor: # NOTE(danms): If flavor is unset or None, don't # copy it into the primitive's system_metadata db_instance["system_metadata"] = flavors.save_flavor_info( db_instance.get("system_metadata", {}), flavor, prefix ) if attr in db_instance: del db_instance[attr] return db_instance
def _test_extract_flavor(self, prefix): instance_type = objects.Flavor.get_by_name(self.context, 'm1.small') instance_type_p = obj_base.obj_to_primitive(instance_type) metadata = {} flavors.save_flavor_info(metadata, instance_type, prefix) instance = {'system_metadata': self._dict_to_metadata(metadata)} _instance_type = flavors.extract_flavor(instance, prefix) _instance_type_p = obj_base.obj_to_primitive(_instance_type) props = flavors.system_metadata_flavor_props.keys() for key in list(instance_type_p.keys()): if key not in props: del instance_type_p[key] self.assertEqual(instance_type_p, _instance_type_p)
def _test_extract_flavor(self, prefix): instance_type = flavors.get_default_flavor() instance_type_p = obj_base.obj_to_primitive(instance_type) metadata = {} flavors.save_flavor_info(metadata, instance_type, prefix) instance = {'system_metadata': self._dict_to_metadata(metadata)} _instance_type = flavors.extract_flavor(instance, prefix) _instance_type_p = obj_base.obj_to_primitive(_instance_type) props = flavors.system_metadata_flavor_props.keys() for key in instance_type_p.keys(): if key not in props: del instance_type_p[key] self.assertEqual(instance_type_p, _instance_type_p)
def _create_instances_here(self, ctxt, instance_uuids, instance_properties, instance_type, image, security_groups, block_device_mapping): instance_values = copy.copy(instance_properties) # The parent may pass these metadata values as lists, and the # create call expects it to be a dict. instance_values['metadata'] = utils.instance_meta(instance_values) sys_metadata = utils.instance_sys_meta(instance_values) # Make sure the flavor info is set. It may not have been passed # down. sys_metadata = flavors.save_flavor_info(sys_metadata, instance_type) instance_values['system_metadata'] = sys_metadata instance_values.pop('name') num_instances = len(instance_uuids) for i, instance_uuid in enumerate(instance_uuids): instance_values['uuid'] = instance_uuid instance = self.compute_api.create_db_entry_for_new_instance( ctxt, instance_type, image, instance_values, security_groups, block_device_mapping, num_instances, i) self.msg_runner.instance_update_at_top(ctxt, instance)
def setUp(self): super(SimpleTenantUsageControllerTest, self).setUp() self.controller = simple_tenant_usage.SimpleTenantUsageController() class FakeComputeAPI: def get_instance_type(self, context, flavor_type): if flavor_type == 1: return flavors.get_default_flavor() else: raise exception.InstanceTypeNotFound(flavor_type) self.compute_api = FakeComputeAPI() self.context = None now = timeutils.utcnow() self.baseinst = dict(display_name='foo', launched_at=now - datetime.timedelta(1), terminated_at=now, instance_type_id=1, vm_state='deleted', deleted=0) basetype = flavors.get_default_flavor() sys_meta = utils.dict_to_metadata( flavors.save_flavor_info({}, basetype)) self.baseinst['system_metadata'] = sys_meta self.basetype = flavors.extract_flavor(self.baseinst)
def test_allocate_for_instance_refresh_cache(self): sys_meta = flavors.save_flavor_info({}, test_flavor.fake_flavor) instance = fake_instance.fake_instance_obj( self.context, expected_attrs=["system_metadata"], system_metadata=sys_meta ) vpn = "fake-vpn" requested_networks = "fake-networks" self._test_refresh_cache("allocate_for_instance", self.context, instance, vpn, requested_networks)
def test_save_flavor_info(self): instance_type = objects.Flavor.get_by_name(self.context, 'm1.small') example = {} example_prefix = {} for key in flavors.system_metadata_flavor_props.keys(): example['instance_type_%s' % key] = instance_type[key] example_prefix['fooinstance_type_%s' % key] = instance_type[key] metadata = {} flavors.save_flavor_info(metadata, instance_type) self.assertEqual(example, metadata) metadata = {} flavors.save_flavor_info(metadata, instance_type, 'foo') self.assertEqual(example_prefix, metadata)
def test_save_flavor_info(self): instance_type = flavors.get_default_flavor() example = {} example_prefix = {} for key in flavors.system_metadata_flavor_props.keys(): example['instance_type_%s' % key] = instance_type[key] example_prefix['fooinstance_type_%s' % key] = instance_type[key] metadata = {} flavors.save_flavor_info(metadata, instance_type) self.assertEqual(example, metadata) metadata = {} flavors.save_flavor_info(metadata, instance_type, 'foo') self.assertEqual(example_prefix, metadata)
def _setUpBlockDeviceMapping(self): image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175' sys_meta = flavors.save_flavor_info( {}, flavors.get_flavor(1)) inst1 = db.instance_create(self.context, {'image_ref': image_uuid, 'instance_type_id': 1, 'root_device_name': '/dev/sdb1', 'system_metadata': sys_meta}) inst2 = db.instance_create(self.context, {'image_ref': image_uuid, 'instance_type_id': 1, 'root_device_name': '/dev/sdc1', 'system_metadata': sys_meta}) instance_uuid = inst1['uuid'] mappings0 = [ {'instance_uuid': instance_uuid, 'device_name': '/dev/sdb1', 'snapshot_id': '1', 'volume_id': '2'}, {'instance_uuid': instance_uuid, 'device_name': '/dev/sdb2', 'volume_id': '3', 'volume_size': 1}, {'instance_uuid': instance_uuid, 'device_name': '/dev/sdb3', 'delete_on_termination': True, 'snapshot_id': '4', 'volume_id': '5'}, {'instance_uuid': instance_uuid, 'device_name': '/dev/sdb4', 'delete_on_termination': False, 'snapshot_id': '6', 'volume_id': '7'}, {'instance_uuid': instance_uuid, 'device_name': '/dev/sdb5', 'snapshot_id': '8', 'volume_id': '9', 'volume_size': 0}, {'instance_uuid': instance_uuid, 'device_name': '/dev/sdb6', 'snapshot_id': '10', 'volume_id': '11', 'volume_size': 1}, {'instance_uuid': instance_uuid, 'device_name': '/dev/sdb7', 'no_device': True}, {'instance_uuid': instance_uuid, 'device_name': '/dev/sdb8', 'virtual_name': 'swap'}, {'instance_uuid': instance_uuid, 'device_name': '/dev/sdb9', 'virtual_name': 'ephemeral3'}] volumes = self._block_device_mapping_create(instance_uuid, mappings0) return (inst1, inst2, volumes)
def test_allocate_for_instance_refresh_cache(self): sys_meta = flavors.save_flavor_info({}, test_flavor.fake_flavor) instance = fake_instance.fake_instance_obj( self.context, expected_attrs=['system_metadata'], system_metadata=sys_meta) vpn = 'fake-vpn' requested_networks = 'fake-networks' self._test_refresh_cache('allocate_for_instance', self.context, instance, vpn, requested_networks)
def test_set_default_ephemeral_device(self): instance = objects.Instance(context=self.context) instance.system_metadata = flavors.save_flavor_info( {}, flavors.get_default_flavor()) instance.system_metadata['instance_type_ephemeral_gb'] = 1 with mock.patch.object(instance, 'save') as mock_save: self.driver._set_default_ephemeral_device(instance) mock_save.assert_called_once_with() self.assertEqual('/dev/sda1', instance.default_ephemeral_device)
def test_translate_pvc_instance(self): pvc_instance = self.pvcinstance.pvc_instance ctx = self.ctx self.moxer.StubOutWithMock(self.PowerVCCloudManager._staging_cache, "get_staging_user_and_project") self.PowerVCCloudManager._staging_cache.\ get_staging_user_and_project(True)\ .AndReturn(('', '')) self.moxer.StubOutWithMock(self.PowerVCCloudManager, "_get_image_from_instance") self.PowerVCCloudManager._get_image_from_instance(ctx, pvc_instance, None)\ .AndReturn(self.osimage.os_image) self.moxer.StubOutWithMock(self.PowerVCCloudManager, "_get_flavor_from_instance") self.PowerVCCloudManager._get_flavor_from_instance(ctx, pvc_instance, None)\ .AndReturn(self.osflavor.os_flavor) self.moxer.StubOutWithMock(flavors, "save_flavor_info") flavors.save_flavor_info(dict(), self.osflavor.os_flavor)\ .AndReturn("system_metadata") self.moxer.ReplayAll() ins, image, flavor = self.PowerVCCloudManager.\ _translate_pvc_instance(ctx, pvc_instance) self.moxer.UnsetStubs() self.moxer.VerifyAll() print "====ins=======================================================" print ins print "===self.osinstance.os_instance================================" print self.osinstance.os_instance print "==============================================================" self.assertEqual(ins, self.osinstance.os_instance)
def create_instance(context, instance=None, driver=None): """Create a test instance""" if instance == None: instance = {} system_metadata = instance.get('system_metadata', {}) instance_type = flavors.get_flavor_by_name('m1.tiny') system_metadata.update(flavors.save_flavor_info(dict(), instance_type)) instance.setdefault('user_id', context.user_id) instance.setdefault('project_id', context.project_id) instance.setdefault('instance_type_id', instance_type['id']) instance.setdefault('system_metadata', system_metadata) instance.setdefault('image_id', 1) instance.setdefault('image_ref', 1) instance.setdefault('reservation_id', 'r-fakeres') instance.setdefault('launch_time', '10') instance.setdefault('mac_address', "ca:ca:ca:01") instance.setdefault('ami_launch_index', 0) instance.setdefault('vm_state', vm_states.ACTIVE) instance.setdefault('root_gb', 10) instance.setdefault('ephemeral_gb', 10) instance.setdefault('memory_mb', 512) instance.setdefault('vcpus', 1) instance.setdefault('info_cache', {'network_info': json.dumps({})}) # We should record in the quotas information about this instance. reservations = quota.QUOTAS.reserve(context, instances=1, ram=instance['memory_mb'], cores=instance['vcpus']) context.elevated() instance_ref = db.instance_create(context, instance) db.block_device_mapping_create(context, { 'source_type': 'image', 'destination_type': 'local', 'device_type': 'disk', 'image_id': 1, 'boot_index': 0, 'instance_uuid': instance_ref['uuid'] }, legacy=False) if driver: # Add this instance to the driver driver.instances[instance_ref.name] = FakeInstance( instance_ref.name, instance_ref.get('power_state', power_state.RUNNING)) quota.QUOTAS.commit(context, reservations) return instance_ref['uuid']
def _test_get_flavor(self, namespace): prefix = '%s_' % namespace if namespace is not None else '' db_inst = db.instance_create(self.context, { 'user_id': self.context.user_id, 'project_id': self.context.project_id, 'system_metadata': flavors.save_flavor_info( {}, flavors.get_default_flavor(), prefix)}) db_flavor = flavors.extract_flavor(db_inst, prefix) inst = instance.Instance.get_by_uuid(self.context, db_inst['uuid']) flavor = inst.get_flavor(namespace) self.assertEqual(db_flavor['flavorid'], flavor.flavorid)
def obj_make_compatible(self, primitive, target_version): super(Instance, self).obj_make_compatible(primitive, target_version) target_version = utils.convert_version_to_tuple(target_version) unicode_attributes = [ "user_id", "project_id", "image_ref", "kernel_id", "ramdisk_id", "hostname", "key_name", "key_data", "host", "node", "user_data", "availability_zone", "display_name", "display_description", "launched_on", "locked_by", "os_type", "architecture", "vm_mode", "root_device_name", "default_ephemeral_device", "default_swap_device", "config_drive", "cell_name", ] if target_version < (1, 7): # NOTE(danms): Before 1.7, we couldn't handle unicode in # string fields, so squash it here for field in [x for x in unicode_attributes if x in primitive and primitive[x] is not None]: primitive[field] = primitive[field].encode("ascii", "replace") if target_version < (1, 18): if "system_metadata" in primitive: for ftype in ("", "old_", "new_"): attrname = "%sflavor" % ftype primitive.pop(attrname, None) if self[attrname] is not None: flavors.save_flavor_info(primitive["system_metadata"], getattr(self, attrname), ftype)
def test_delete_flavor(self): namespace = 'foo' prefix = '%s_' % namespace db_inst = db.instance_create(self.context, { 'user_id': self.context.user_id, 'project_id': self.context.project_id, 'system_metadata': flavors.save_flavor_info( {}, flavors.get_default_flavor(), prefix)}) inst = instance.Instance.get_by_uuid(self.context, db_inst['uuid']) inst.delete_flavor(namespace) db_inst = db.instance_get(self.context, db_inst['id']) self.assertEqual({}, utils.instance_sys_meta(db_inst))
def build_request_spec(ctxt, image, instances, instance_type=None): """Build a request_spec for the scheduler. The request_spec assumes that all instances to be scheduled are the same type. """ instance = instances[0] if instance_type is None: if isinstance(instance, obj_instance.Instance): instance_type = instance.get_flavor() else: instance_type = flavors.extract_flavor(instance) if isinstance(instance, obj_instance.Instance): instance = obj_base.obj_to_primitive(instance) # obj_to_primitive doesn't copy this enough, so be sure # to detach our metadata blob because we modify it below. instance['system_metadata'] = dict(instance.get('system_metadata', {})) if isinstance(instance_type, objects.Flavor): instance_type = obj_base.obj_to_primitive(instance_type) # NOTE(danms): Replicate this old behavior because the # scheduler RPC interface technically expects it to be # there. Remove this when we bump the scheduler RPC API to # v5.0 try: flavors.save_flavor_info(instance.get('system_metadata', {}), instance_type) except KeyError: # If the flavor isn't complete (which is legit with a # flavor object, just don't put it in the request spec pass request_spec = { 'image': image or {}, 'instance_properties': instance, 'instance_type': instance_type, 'num_instances': len(instances) } return jsonutils.to_primitive(request_spec)
def create_instance(context, instance=None, driver=None): """Create a test instance""" if instance == None: instance = {} system_metadata = instance.get('system_metadata', {}) instance_type = flavors.get_flavor_by_name('m1.tiny') system_metadata.update(flavors.save_flavor_info(dict(), instance_type)) instance.setdefault('user_id', context.user_id) instance.setdefault('project_id', context.project_id) instance.setdefault('instance_type_id', instance_type['id']) instance.setdefault('system_metadata', system_metadata) instance.setdefault('image_id', 1) instance.setdefault('image_ref', 1) instance.setdefault('reservation_id', 'r-fakeres') instance.setdefault('launch_time', '10') instance.setdefault('mac_address', "ca:ca:ca:01") instance.setdefault('ami_launch_index', 0) instance.setdefault('vm_state', vm_states.ACTIVE) instance.setdefault('root_gb', 10) instance.setdefault('ephemeral_gb', 10) instance.setdefault('memory_mb', 512) instance.setdefault('vcpus', 1) instance.setdefault('info_cache', {'network_info':json.dumps({})}) # We should record in the quotas information about this instance. reservations = quota.QUOTAS.reserve(context, instances=1, ram=instance['memory_mb'], cores=instance['vcpus']) context.elevated() instance_ref = db.instance_create(context, instance) db.block_device_mapping_create(context, {'source_type': 'image', 'destination_type': 'local', 'device_type': 'disk', 'image_id': 1, 'boot_index': 0, 'instance_uuid': instance_ref['uuid']}, legacy=False) if driver: # Add this instance to the driver driver.instances[instance_ref.name] = FakeInstance(instance_ref.name, instance_ref.get('power_state', power_state.RUNNING)) quota.QUOTAS.commit(context, reservations) return instance_ref['uuid']
def create_instance(testcase): fake.stub_out_image_service(testcase.stubs) ctxt = context.get_admin_context() instance_type = db.flavor_get(ctxt, 1) sys_meta = flavors.save_flavor_info({}, instance_type) return db.instance_create(ctxt, {'user_id': 'fake', 'project_id': 'fake', 'instance_type_id': 1, 'memory_mb': 1024, 'vcpus': 2, 'image_ref': '155d900f-4e14-4e4c-a73d-069cbf4541e6', 'system_metadata': sys_meta})
def create_instance(testcase): fake.stub_out_image_service(testcase.stubs) ctxt = context.get_admin_context() instance_type = db.instance_type_get(ctxt, 1) sys_meta = flavors.save_flavor_info({}, instance_type) return db.instance_create(ctxt, {'user_id': 'fake', 'project_id': 'fake', 'instance_type_id': 1, 'memory_mb': 1024, 'vcpus': 2, 'image_ref': '155d900f-4e14-4e4c-a73d-069cbf4541e6', 'system_metadata': sys_meta})
def build_request_spec(ctxt, image, instances, instance_type=None): """Build a request_spec for the scheduler. The request_spec assumes that all instances to be scheduled are the same type. """ instance = instances[0] if instance_type is None: if isinstance(instance, obj_instance.Instance): instance_type = instance.get_flavor() else: instance_type = flavors.extract_flavor(instance) if isinstance(instance, obj_instance.Instance): instance = obj_base.obj_to_primitive(instance) # obj_to_primitive doesn't copy this enough, so be sure # to detach our metadata blob because we modify it below. instance['system_metadata'] = dict(instance.get('system_metadata', {})) if isinstance(instance_type, objects.Flavor): instance_type = obj_base.obj_to_primitive(instance_type) # NOTE(danms): Replicate this old behavior because the # scheduler RPC interface technically expects it to be # there. Remove this when we bump the scheduler RPC API to # v5.0 try: flavors.save_flavor_info(instance.get('system_metadata', {}), instance_type) except KeyError: # If the flavor isn't complete (which is legit with a # flavor object, just don't put it in the request spec pass request_spec = { 'image': image or {}, 'instance_properties': instance, 'instance_type': instance_type, 'num_instances': len(instances)} return jsonutils.to_primitive(request_spec)
def get_fake_db_instance(start, end, instance_id, tenant_id): sys_meta = utils.dict_to_metadata( flavors.save_flavor_info({}, FAKE_INST_TYPE)) return {'id': instance_id, 'uuid': '00000000-0000-0000-0000-00000000000000%02d' % instance_id, 'image_ref': '1', 'project_id': tenant_id, 'user_id': 'fakeuser', 'display_name': 'name', 'state_description': 'state', 'instance_type_id': 1, 'launched_at': start, 'terminated_at': end, 'system_metadata': sys_meta}
def get_test_instance(context=None, instance_type=None): if not context: context = get_test_admin_context() if not instance_type: instance_type = get_test_instance_type(context) metadata = {} flavors.save_flavor_info(metadata, instance_type, '') test_instance = {'memory_kb': '2048000', 'basepath': '/some/path', 'bridge_name': 'br100', 'vcpus': 4, 'root_gb': 40, 'project_id': 'fake', 'bridge': 'br101', 'image_ref': 'cedef40a-ed67-4d10-800e-17455edce175', 'instance_type_id': '5', 'system_metadata': metadata, 'extra_specs': {}} instance_ref = nova.db.instance_create(context, test_instance) return instance_ref
def _create_instance(self, params={}): """Create a test instance.""" flavor = flavors.get_flavor_by_name('m1.tiny') sys_meta = flavors.save_flavor_info({}, flavor) inst = {} inst['image_ref'] = 1 inst['reservation_id'] = 'r-fakeres' inst['user_id'] = self.user_id inst['project_id'] = self.project_id inst['instance_type_id'] = flavor['id'] inst['system_metadata'] = sys_meta inst['ami_launch_index'] = 0 inst['root_gb'] = 0 inst['ephemeral_gb'] = 0 inst.update(params) return db.instance_create(self.context, inst)['id']
def _create_instances_here(self, ctxt, instance_uuids, instance_properties, instance_type, image, security_groups, block_device_mapping): instance_values = copy.copy(instance_properties) sys_metadata = flavors.save_flavor_info(dict(), instance_type) instance_values['system_metadata'] = sys_metadata instance_values.pop('name') num_instances = len(instance_uuids) for i, instance_uuid in enumerate(instance_uuids): instance_values['uuid'] = instance_uuid instance = self.compute_api.create_db_entry_for_new_instance( ctxt, instance_type, image, instance_values, security_groups, block_device_mapping, num_instances, i) self.msg_runner.instance_update_at_top(ctxt, instance)
def test_upgrade_flavor_already_migrated(self): flavor = flavors.get_default_flavor() sysmeta = flavors.save_flavor_info({}, flavor) sysmeta['foo'] = 'bar' inst = objects.Instance(context=self.context, uuid=uuid.uuid4(), user_id=self.context.user_id, project_id=self.context.project_id, system_metadata=sysmeta) inst.create() # Trigger the migration by lazy-loading flavor inst.flavor inst.save() self.assertNotIn('instance_type_id', inst.system_metadata) sysmeta = db_api.instance_system_metadata_get(self.context, inst.uuid) self.assertEqual({'foo': 'bar'}, sysmeta) self.migration.upgrade(self.engine)
def test_flavor_numa_extras_are_saved(self): instance_type = objects.Flavor.get_by_name(self.context, 'm1.small') instance_type['extra_specs'] = { 'hw:numa_mem.0': '123', 'hw:numa_cpus.0': '456', 'hw:numa_mem.1': '789', 'hw:numa_cpus.1': 'ABC', 'foo': 'bar', } sysmeta = flavors.save_flavor_info({}, instance_type) _instance_type = flavors.extract_flavor({'system_metadata': sysmeta}) expected_extra_specs = { 'hw:numa_mem.0': '123', 'hw:numa_cpus.0': '456', 'hw:numa_mem.1': '789', 'hw:numa_cpus.1': 'ABC', } self.assertEqual(expected_extra_specs, _instance_type['extra_specs'])
def _create_instances_here(self, ctxt, instance_uuids, instance_properties, instance_type, image, security_groups, block_device_mapping): instance_values = copy.copy(instance_properties) # The parent may pass these metadata values as lists, and the # create call expects it to be a dict. instance_values['metadata'] = utils.instance_meta(instance_values) sys_metadata = utils.instance_sys_meta(instance_values) # Make sure the flavor info is set. It may not have been passed # down. sys_metadata = flavors.save_flavor_info(sys_metadata, instance_type) instance_values['system_metadata'] = sys_metadata # Pop out things that will get set properly when re-creating the # instance record. instance_values.pop('id') instance_values.pop('name') instance_values.pop('info_cache') instance_values.pop('security_groups') # FIXME(danms): The instance was brutally serialized before being # sent over RPC to us. Thus, the pci_requests value wasn't really # sent in a useful form. Since it was getting ignored for cells # before it was part of the Instance, skip it now until cells RPC # is sending proper instance objects. instance_values.pop('pci_requests', None) instances = [] num_instances = len(instance_uuids) for i, instance_uuid in enumerate(instance_uuids): instance = objects.Instance(context=ctxt) instance.update(instance_values) instance.uuid = instance_uuid instance = self.compute_api.create_db_entry_for_new_instance( ctxt, instance_type, image, instance, security_groups, block_device_mapping, num_instances, i) instances.append(instance) instance_p = obj_base.obj_to_primitive(instance) self.msg_runner.instance_update_at_top(ctxt, instance_p) return instances
def _wrapped_create(self, params=None): instance_type = flavors.get_flavor_by_name('m1.tiny') sys_meta = flavors.save_flavor_info({}, instance_type) inst = {} inst['image_ref'] = 1 inst['user_id'] = self.user_id inst['project_id'] = self.project_id inst['instance_type_id'] = instance_type['id'] inst['root_gb'] = 0 inst['ephemeral_gb'] = 0 inst['access_ip_v4'] = '1.2.3.4' inst['access_ip_v6'] = 'feed:5eed' inst['display_name'] = 'test_instance' inst['hostname'] = 'test_instance_hostname' inst['node'] = 'test_instance_node' inst['system_metadata'] = sys_meta if params: inst.update(params) return db.instance_create(self.context, inst)
def test_flavor_numa_extras_are_saved(self): instance_type = flavors.get_default_flavor() instance_type['extra_specs'] = { 'hw:numa_mem.0': '123', 'hw:numa_cpus.0': '456', 'hw:numa_mem.1': '789', 'hw:numa_cpus.1': 'ABC', 'foo': 'bar', } sysmeta = flavors.save_flavor_info({}, instance_type) _instance_type = flavors.extract_flavor({'system_metadata': sysmeta}) expected_extra_specs = { 'hw:numa_mem.0': '123', 'hw:numa_cpus.0': '456', 'hw:numa_mem.1': '789', 'hw:numa_cpus.1': 'ABC', } self.assertEqual(expected_extra_specs, _instance_type['extra_specs']) flavors.delete_flavor_info(sysmeta, '') self.assertEqual({}, sysmeta)
def get_fake_db_instance(start, end, instance_id, tenant_id, vm_state=vm_states.ACTIVE): sys_meta = utils.dict_to_metadata( flavors.save_flavor_info({}, FAKE_INST_TYPE)) # NOTE(mriedem): We use fakes.stub_instance since it sets the fields # needed on the db instance for converting it to an object, but we still # need to override system_metadata to use our fake flavor. inst = fakes.stub_instance( id=instance_id, uuid='00000000-0000-0000-0000-00000000000000%02d' % instance_id, image_ref='1', project_id=tenant_id, user_id='fakeuser', display_name='name', flavor_id=FAKE_INST_TYPE['id'], launched_at=start, terminated_at=end, vm_state=vm_state) inst['system_metadata'] = sys_meta return inst
def _wrapped_create(self, params=None): instance_type = flavors.get_flavor_by_name('m1.tiny') sys_meta = flavors.save_flavor_info({}, instance_type) inst = objects.Instance(image_ref=1, user_id=self.user_id, project_id=self.project_id, instance_type_id=instance_type['id'], root_gb=0, ephemeral_gb=0, access_ip_v4='1.2.3.4', access_ip_v6='feed::5eed', display_name='test_instance', hostname='test_instance_hostname', node='test_instance_node', system_metadata=sys_meta) inst._context = self.context if params: inst.update(params) inst.create() return inst
def _stub_migrate_instance_calls(self, method, multi_host, info): fake_flavor = flavors.get_default_flavor() fake_flavor['rxtx_factor'] = 1.21 sys_meta = utils.dict_to_metadata( flavors.save_flavor_info({}, fake_flavor)) fake_instance = { 'uuid': 'fake_uuid', 'instance_type_id': fake_flavor['id'], 'project_id': 'fake_project_id', 'system_metadata': sys_meta } fake_migration = { 'source_compute': 'fake_compute_source', 'dest_compute': 'fake_compute_dest' } def fake_mig_inst_method(*args, **kwargs): info['kwargs'] = kwargs def fake_is_multi_host(*args, **kwargs): return multi_host def fake_get_floaters(*args, **kwargs): return ['fake_float1', 'fake_float2'] self.stubs.Set(network_rpcapi.NetworkAPI, method, fake_mig_inst_method) self.stubs.Set(self.network_api, '_is_multi_host', fake_is_multi_host) self.stubs.Set(self.network_api, '_get_floating_ip_addresses', fake_get_floaters) expected = { 'instance_uuid': 'fake_uuid', 'source_compute': 'fake_compute_source', 'dest_compute': 'fake_compute_dest', 'rxtx_factor': 1.21, 'project_id': 'fake_project_id', 'floating_addresses': None } if multi_host: expected['floating_addresses'] = ['fake_float1', 'fake_float2'] return fake_instance, fake_migration, expected
def _prep_instance(self, instance_ref, **kwargs): type_id = 5 # m1.small flavor = db.flavor_get(self.context, type_id) sys_meta = flavors.save_flavor_info({}, flavor) instance_ref.update( uuid='1e4fa700-a506-11e3-a1fc-7071bc7738b5', power_state=power_state.SHUTDOWN, user_id=self.user_id, project_id=self.project_id, instance_type_id=str(type_id), system_metadata=sys_meta, extra_specs={}, ) for key, val in kwargs.items(): instance_ref[key] = val instance = instance_obj.Instance(self.context, **instance_ref) instance.create() return instance
def test_upgrade_flavor_deleted_sysmeta(self): flavor = flavors.get_default_flavor() sysmeta = flavors.save_flavor_info({}, flavor) sysmeta['foo'] = 'bar' inst = objects.Instance(context=self.context, uuid=uuid.uuid4(), user_id=self.context.user_id, project_id=self.context.project_id, system_metadata=sysmeta) inst.create() sysmeta = db_api.instance_system_metadata_get(self.context, inst.uuid) sysmeta = {k: v for k, v in sysmeta.items() if not k.startswith('instance_type_')} db_api.instance_system_metadata_update(self.context, inst.uuid, sysmeta, True) inst.refresh() self.assertEqual({'foo': 'bar'}, inst.system_metadata) self.migration.upgrade(self.engine)
def setUp(self): super(LibvirtBlockInfoTest, self).setUp() self.user_id = 'fake' self.project_id = 'fake' self.context = context.get_admin_context() instance_type = db.flavor_get(self.context, 2) sys_meta = flavors.save_flavor_info({}, instance_type) nova.tests.image.fake.stub_out_image_service(self.stubs) self.test_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, # m1.tiny 'system_metadata': sys_meta}
def test_allocate_for_instance_handles_macs_passed(self): # If a macs argument is supplied to the 'nova-network' API, it is just # ignored. This test checks that the call down to the rpcapi layer # doesn't pass macs down: nova-network doesn't support hypervisor # mac address limits (today anyhow). macs = set(['ab:cd:ef:01:23:34']) self.mox.StubOutWithMock( self.network_api.network_rpcapi, "allocate_for_instance") kwargs = dict(zip(['host', 'instance_id', 'project_id', 'requested_networks', 'rxtx_factor', 'vpn', 'macs', 'dhcp_options'], itertools.repeat(mox.IgnoreArg()))) self.network_api.network_rpcapi.allocate_for_instance( mox.IgnoreArg(), **kwargs).AndReturn([]) self.mox.ReplayAll() flavor = flavors.get_default_flavor() flavor['rxtx_factor'] = 0 sys_meta = flavors.save_flavor_info({}, flavor) instance = dict(id='id', uuid='uuid', project_id='project_id', host='host', system_metadata=utils.dict_to_metadata(sys_meta)) self.network_api.allocate_for_instance( self.context, instance, 'vpn', 'requested_networks', macs=macs)
def setUp(self): super(GraniteDriverTestCase, self).setUp() self.flags(instances_path=self.useFixture(fixtures.TempDir()).path) self.lxc_connection = lxc_connection.LXCDriver(None) instance_type = db.flavor_get(context.get_admin_context(), 5) sys_meta = flavors.save_flavor_info({}, instance_type) 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': '5', # m1.small 'extra_specs': {}, 'system_metadata': sys_meta }
def _create_instances_here(self, ctxt, instance_uuids, instance_properties, instance_type, image, security_groups, block_device_mapping): instance_values = copy.copy(instance_properties) # The parent may pass these metadata values as lists, and the # create call expects it to be a dict. instance_values['metadata'] = utils.instance_meta(instance_values) sys_metadata = utils.instance_sys_meta(instance_values) # Make sure the flavor info is set. It may not have been passed # down. sys_metadata = flavors.save_flavor_info(sys_metadata, instance_type) instance_values['system_metadata'] = sys_metadata # Pop out things that will get set properly when re-creating the # instance record. instance_values.pop('id') instance_values.pop('name') instance_values.pop('info_cache') instance_values.pop('security_groups') instances = [] num_instances = len(instance_uuids) for i, instance_uuid in enumerate(instance_uuids): instance = objects.Instance() instance.update(instance_values) instance.uuid = instance_uuid instance = self.compute_api.create_db_entry_for_new_instance( ctxt, instance_type, image, instance, security_groups, block_device_mapping, num_instances, i) instances.append(instance) instance_p = obj_base.obj_to_primitive(instance) self.msg_runner.instance_update_at_top(ctxt, instance_p) return instances
def _setUpBlockDeviceMapping(self): image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175' sys_meta = flavors.save_flavor_info({}, flavors.get_flavor(1)) inst1 = db.instance_create( self.context, { 'image_ref': image_uuid, 'instance_type_id': 1, 'root_device_name': '/dev/sdb1', 'system_metadata': sys_meta }) inst2 = db.instance_create( self.context, { 'image_ref': image_uuid, 'instance_type_id': 1, 'root_device_name': '/dev/sdc1', 'system_metadata': sys_meta }) instance_uuid = inst1['uuid'] mappings0 = [{ 'instance_uuid': instance_uuid, 'device_name': '/dev/sdb1', 'snapshot_id': '1', 'volume_id': '2' }, { 'instance_uuid': instance_uuid, 'device_name': '/dev/sdb2', 'volume_id': '3', 'volume_size': 1 }, { 'instance_uuid': instance_uuid, 'device_name': '/dev/sdb3', 'delete_on_termination': True, 'snapshot_id': '4', 'volume_id': '5' }, { 'instance_uuid': instance_uuid, 'device_name': '/dev/sdb4', 'delete_on_termination': False, 'snapshot_id': '6', 'volume_id': '7' }, { 'instance_uuid': instance_uuid, 'device_name': '/dev/sdb5', 'snapshot_id': '8', 'volume_id': '9', 'volume_size': 0 }, { 'instance_uuid': instance_uuid, 'device_name': '/dev/sdb6', 'snapshot_id': '10', 'volume_id': '11', 'volume_size': 1 }, { 'instance_uuid': instance_uuid, 'device_name': '/dev/sdb7', 'no_device': True }, { 'instance_uuid': instance_uuid, 'device_name': '/dev/sdb8', 'virtual_name': 'swap' }, { 'instance_uuid': instance_uuid, 'device_name': '/dev/sdb9', 'virtual_name': 'ephemeral3' }] volumes = self._block_device_mapping_create(instance_uuid, mappings0) return (inst1, inst2, volumes)
def stub_instance(id=1, user_id=None, project_id=None, host=None, node=None, vm_state=None, task_state=None, reservation_id="", uuid=FAKE_UUID, image_ref="10", flavor_id="1", name=None, key_name='', access_ipv4=None, access_ipv6=None, progress=0, auto_disk_config=False, display_name=None, display_description=None, include_fake_metadata=True, config_drive=None, power_state=None, nw_cache=None, metadata=None, security_groups=None, root_device_name=None, limit=None, marker=None, launched_at=timeutils.utcnow(), terminated_at=timeutils.utcnow(), availability_zone='', locked_by=None, cleaned=False, memory_mb=0, vcpus=0, root_gb=0, ephemeral_gb=0, instance_type=None, launch_index=0, kernel_id="", ramdisk_id="", user_data=None, system_metadata=None, services=None): if user_id is None: user_id = 'fake_user' if project_id is None: project_id = 'fake_project' if metadata: metadata = [{'key': k, 'value': v} for k, v in metadata.items()] elif include_fake_metadata: metadata = [models.InstanceMetadata(key='seq', value=str(id))] else: metadata = [] inst_type = flavors.get_flavor_by_flavor_id(int(flavor_id)) sys_meta = flavors.save_flavor_info({}, inst_type) sys_meta.update(system_metadata or {}) if host is not None: host = str(host) if key_name: key_data = 'FAKE' else: key_data = '' if security_groups is None: security_groups = [{ "id": 1, "name": "test", "description": "Foo:", "project_id": "project", "user_id": "user", "created_at": None, "updated_at": None, "deleted_at": None, "deleted": False }] # ReservationID isn't sent back, hack it in there. server_name = name or "server%s" % id if reservation_id != "": server_name = "reservation_%s" % (reservation_id, ) info_cache = create_info_cache(nw_cache) if instance_type is None: instance_type = flavors.get_default_flavor() flavorinfo = jsonutils.dumps({ 'cur': instance_type.obj_to_primitive(), 'old': None, 'new': None, }) instance = { "id": int(id), "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0), "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0), "deleted_at": datetime.datetime(2010, 12, 12, 10, 0, 0), "deleted": None, "user_id": user_id, "project_id": project_id, "image_ref": image_ref, "kernel_id": kernel_id, "ramdisk_id": ramdisk_id, "launch_index": launch_index, "key_name": key_name, "key_data": key_data, "config_drive": config_drive, "vm_state": vm_state or vm_states.ACTIVE, "task_state": task_state, "power_state": power_state, "memory_mb": memory_mb, "vcpus": vcpus, "min_vcpus": vcpus, "max_vcpus": vcpus, "root_gb": root_gb, "ephemeral_gb": ephemeral_gb, "ephemeral_key_uuid": None, "hostname": display_name or server_name, "host": host, "node": node, "instance_type_id": 1, "instance_type": inst_type, "user_data": user_data, "reservation_id": reservation_id, "mac_address": "", "launched_at": launched_at, "terminated_at": terminated_at, "availability_zone": availability_zone, "display_name": display_name or server_name, "display_description": display_description, "locked": locked_by is not None, "locked_by": locked_by, "metadata": metadata, "access_ip_v4": access_ipv4, "access_ip_v6": access_ipv6, "uuid": uuid, "progress": progress, "auto_disk_config": auto_disk_config, "name": "instance-%s" % id, "shutdown_terminate": True, "disable_terminate": False, "security_groups": security_groups, "root_device_name": root_device_name, "system_metadata": utils.dict_to_metadata(sys_meta), "pci_devices": [], "vm_mode": "", "default_swap_device": "", "default_ephemeral_device": "", "launched_on": "", "cell_name": "", "architecture": "", "os_type": "", "extra": { "numa_topology": None, "pci_requests": None, "flavor": flavorinfo, }, "cleaned": cleaned, "services": services } instance.update(info_cache) instance['info_cache']['instance_uuid'] = instance['uuid'] return instance
def get_default_sys_meta(): return flavors.save_flavor_info({}, flavors.get_default_flavor())
def get_default_sys_meta(): return utils.dict_to_metadata( flavors.save_flavor_info({}, flavors.get_default_flavor()))
def set_flavor(self, flavor, namespace=None): prefix = ('%s_' % namespace) if namespace is not None else '' self.system_metadata = flavors.save_flavor_info( self.system_metadata, flavor, prefix) self.save()