def fake_req_obj(ctxt, db_req=None):
if db_req is None:
db_req = fake_db_req()
req_obj = objects.BuildRequest(ctxt)
for field in req_obj.fields:
value = db_req[field]
# create() can't be called if this is set
if field == 'id':
continue
if isinstance(req_obj.fields[field], fields.ObjectField):
value = value
if field == 'instance':
req_obj.instance = objects.Instance.obj_from_primitive(
jsonutils.loads(value))
elif field == 'block_device_mappings':
req_obj.block_device_mappings = (
objects.BlockDeviceMappingList.obj_from_primitive(
jsonutils.loads(value)))
elif field == 'tags':
req_obj.tags = objects.TagList.obj_from_primitive(
jsonutils.loads(value))
elif field == 'instance_metadata':
setattr(req_obj, field, jsonutils.loads(value))
else:
setattr(req_obj, field, value)
# This should never be a changed field
req_obj.obj_reset_changes(['id'])
return req_obj
def fake_req_obj(ctxt, db_req=None):
if db_req is None:
db_req = fake_db_req()
req_obj = objects.BuildRequest(ctxt)
for field in req_obj.fields:
value = db_req[field]
# create() can't be called if this is set
if field == 'id':
continue
if isinstance(req_obj.fields[field], fields.ObjectField):
value = value
if field == 'request_spec':
req_spec = objects.RequestSpec._from_db_object(context,
objects.RequestSpec(), value)
req_obj.request_spec = req_spec
elif field == 'info_cache':
setattr(req_obj, field,
objects.InstanceInfoCache.obj_from_primitive(
jsonutils.loads(value)))
elif field == 'security_groups':
setattr(req_obj, field,
objects.SecurityGroupList.obj_from_primitive(
jsonutils.loads(value)))
elif field == 'instance':
req_obj.instance = objects.Instance.obj_from_primitive(
jsonutils.loads(value))
elif field == 'instance_metadata':
setattr(req_obj, field, jsonutils.loads(value))
else:
setattr(req_obj, field, value)
# This should never be a changed field
req_obj.obj_reset_changes(['id'])
return req_obj
def test_reqspec_buildreq_instmapping_single_transaction(
self, mock_create):
# Simulate a DBError during an INSERT by raising an exception from the
# InstanceMapping.create method.
mock_create.side_effect = test.TestingException('oops')
ctxt = nova_context.RequestContext('fake-user', 'fake-project')
rs = objects.RequestSpec(context=ctxt, instance_uuid=uuids.inst)
# project_id and instance cannot be None
br = objects.BuildRequest(context=ctxt,
instance_uuid=uuids.inst,
project_id=ctxt.project_id,
instance=objects.Instance())
im = objects.InstanceMapping(context=ctxt, instance_uuid=uuids.inst)
self.assertRaises(test.TestingException,
compute_api.API._create_reqspec_buildreq_instmapping,
ctxt, rs, br, im)
# Since the instance mapping failed to INSERT, we should not have
# written a request spec record or a build request record.
self.assertRaises(exception.RequestSpecNotFound,
objects.RequestSpec.get_by_instance_uuid, ctxt,
uuids.inst)
self.assertRaises(exception.BuildRequestNotFound,
objects.BuildRequest.get_by_instance_uuid, ctxt,
uuids.inst)
def test_obj_make_compatible_pre_1_3(self):
obj = fake_build_request.fake_req_obj(self.context)
build_request_obj = objects.BuildRequest(self.context)
data = lambda x: x['nova_object.data']
obj_primitive = data(obj.obj_to_primitive())
self.assertIn('tags', obj_primitive)
build_request_obj.obj_make_compatible(obj_primitive, '1.2')
self.assertIn('instance_uuid', obj_primitive)
self.assertNotIn('tags', obj_primitive)
def test_from_db_object_set_deleted(self):
# Assert that if we persisted an instance not yet having the deleted
# field being set, we still return a value for that field.
fake_req = fake_build_request.fake_db_req()
with mock.patch.object(o_vo_base.VersionedObject,
'obj_set_defaults') as mock_obj_set_defaults:
build_request = objects.BuildRequest._from_db_object(
self.context, objects.BuildRequest(), fake_req)
mock_obj_set_defaults.assert_called_once_with('deleted')
self.assertFalse(build_request.instance.deleted)
def test_get_new_instance_show_changed_fields(self):
# Assert that we create a very dirty object from the cleaned one
# on build_request
fake_req = fake_build_request.fake_db_req()
fields = jsonutils.loads(fake_req['instance'])['nova_object.data']
build_request = objects.BuildRequest._from_db_object(
self.context, objects.BuildRequest(), fake_req)
self.assertEqual(0, len(build_request.instance.obj_what_changed()))
instance = build_request.get_new_instance(self.context)
for field in fields:
self.assertIn(field, instance.obj_what_changed())
self.assertEqual(getattr(build_request.instance, field),
getattr(instance, field))
def test_obj_make_compatible_pre_1_3(self):
obj = fake_build_request.fake_req_obj(self.context)
build_request_obj = objects.BuildRequest(self.context)
obj_primitive = obj.obj_to_primitive()
build_request_obj.obj_make_compatible(obj_primitive, '1.2')
self.assertNotIn('tags', obj_primitive)
def _test_schedule_provider_network(self, scheduler_hints,
mock_get_all, mock_by_host, mock_get_by_binary,
mock_get_all_states):
vif_dict = dict(vif_model='virtio')
fake_vif1 = fake_network_cache_model.new_vif(vif_dict)
fake_vif2 = fake_network_cache_model.new_vif(vif_dict)
fake_vif2['network']['id'] = 2
fake_vif3 = fake_network_cache_model.new_vif(vif_dict)
fake_vif3['network']['id'] = 3
fake_vif4 = fake_network_cache_model.new_vif(vif_dict)
fake_vif4['network']['id'] = 4
fake_nw_info = network_model.NetworkInfo([fake_vif1, fake_vif2,
fake_vif3, fake_vif4])
fake_info_cache = objects.InstanceInfoCache(network_info=fake_nw_info)
fake_inst = objects.Instance(info_cache=fake_info_cache)
fake_build_req = objects.BuildRequest(instance=fake_inst)
@staticmethod
def _fake_get_by_instance_uuid(context, instance_uuid):
return fake_build_req
@staticmethod
def _fake_get_by_uuid(context, instance_uuid):
return fake_inst
self.stub_out('nova.objects.BuildRequest.get_by_instance_uuid',
_fake_get_by_instance_uuid)
self.stub_out('nova.objects.Instance.get_by_uuid', _fake_get_by_uuid)
def _fake_net_get_dict(context, network_uuid):
if network_uuid == 1:
return {'provider:physical_network': 'physnet0'}
elif network_uuid == 2:
return {'provider:physical_network': 'physnet1'}
elif network_uuid == 3:
return {'provider:physical_network': 'physnet1'}
else:
return {}
from nova.network.neutronv2 import api as neutronapi
self.driver.network_api = neutronapi.API()
self.stubs.Set(self.driver.network_api, 'get_dict',
_fake_net_get_dict)
spec_obj = objects.RequestSpec(
num_instances=1,
flavor=objects.Flavor(memory_mb=512,
root_gb=512,
ephemeral_gb=0,
vcpus=1,
extra_specs={}),
project_id=1,
os_type='Linux',
instance_uuid='00000000-aaaa-bbbb-cccc-000000000000',
pci_requests=None,
numa_topology=None,
instance_group=None,
scheduler_hints=scheduler_hints,
# WRS extension
display_name = 'fake-vm',
name = 'instance-00000001',
image=objects.ImageMeta(properties=objects.ImageMetaProps()))
host_state = mock.Mock(spec=host_manager.HostState,
host=mock.sentinel.host, uuid=uuids.cn1, numa_topology=None)
all_host_states = [host_state]
mock_get_all_states.return_value = all_host_states
instance_uuids = [uuids.instance]
allocs = \
[{'allocations': [
{'resources': {'VCPU': 1, 'MEMORY_MB': 512, 'DISK_GB': 512},
'resource_provider': {'uuid': uuids.cn1}}
]
}]
alloc_reqs_by_rp_uuid = {
uuids.cn1: allocs,
}
with mock.patch.object(self.driver.host_manager,
'get_filtered_hosts') as mock_get_hosts:
mock_get_hosts.side_effect = fake_get_filtered_hosts
hosts = self.driver._schedule(self.context, spec_obj,
instance_uuids, alloc_reqs_by_rp_uuid,
mock.sentinel.provider_summaries)
self.assertEqual(len(hosts), 1)
return spec_obj
