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