def test_with_fault(self):
fake_insts = [
fake_instance.fake_db_instance(uuid="fake-uuid", host="host"),
fake_instance.fake_db_instance(uuid="fake-inst2", host="host"),
]
fake_faults = test_instance_fault.fake_faults
self.mox.StubOutWithMock(db, "instance_get_all_by_host")
self.mox.StubOutWithMock(db, "instance_fault_get_by_instance_uuids")
db.instance_get_all_by_host(self.context, "host", columns_to_join=[], use_slave=False).AndReturn(fake_insts)
db.instance_fault_get_by_instance_uuids(self.context, [x["uuid"] for x in fake_insts]).AndReturn(fake_faults)
self.mox.ReplayAll()
instances = instance.InstanceList.get_by_host(self.context, "host", expected_attrs=["fault"], use_slave=False)
self.assertEqual(2, len(instances))
self.assertEqual(fake_faults["fake-uuid"][0], dict(instances[0].fault.iteritems()))
self.assertEqual(None, instances[1].fault)
def test_prep_resize_post_populates_retry(self):
self.manager.driver = fakes.FakeFilterScheduler()
image = 'image'
instance_uuid = 'fake-instance-id'
instance = fake_instance.fake_db_instance(uuid=instance_uuid)
instance_properties = {'project_id': 'fake', 'os_type': 'Linux'}
instance_type = "m1.tiny"
request_spec = {'instance_properties': instance_properties,
'instance_type': instance_type,
'instance_uuids': [instance_uuid]}
retry = {'hosts': [], 'num_attempts': 1}
filter_properties = {'retry': retry}
reservations = None
hosts = [dict(host='host', nodename='node', limits={})]
self._mox_schedule_method_helper('select_destinations')
self.manager.driver.select_destinations(
self.context, request_spec, filter_properties).AndReturn(hosts)
self.mox.StubOutWithMock(self.manager.compute_rpcapi, 'prep_resize')
self.manager.compute_rpcapi.prep_resize(self.context, image,
mox.IsA(objects.Instance),
instance_type, 'host', reservations, request_spec=request_spec,
filter_properties=filter_properties, node='node')
self.mox.ReplayAll()
self.manager.prep_resize(self.context, image, request_spec,
filter_properties, instance, instance_type, reservations)
self.assertEqual([['host', 'node']],
filter_properties['retry']['hosts'])
def instance_create(context, inst):
inst_type = flavors.get_flavor_by_flavor_id(3)
image_uuid = "76fa36fc-c930-4bf3-8c8a-ea2a2420deb6"
def_image_ref = "http://localhost/images/%s" % image_uuid
self.instance_cache_num += 1
instance = fake_instance.fake_db_instance(
**{
"id": self.instance_cache_num,
"display_name": inst["display_name"] or "test",
"uuid": FAKE_UUID,
"instance_type": dict(inst_type),
"access_ip_v4": "1.2.3.4",
"access_ip_v6": "fead::1234",
"image_ref": inst.get("image_ref", def_image_ref),
"user_id": "fake",
"project_id": "fake",
"reservation_id": inst["reservation_id"],
"created_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
"updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0),
"progress": 0,
"fixed_ips": [],
"task_state": "",
"vm_state": "",
"security_groups": inst["security_groups"],
}
)
self.instance_cache_by_id[instance["id"]] = instance
self.instance_cache_by_uuid[instance["uuid"]] = instance
return instance
def return_server(context, server_id, columns_to_join=None):
return fake_instance.fake_db_instance(
**{'id': int(server_id),
'power_state': 0x01,
'host': "localhost",
'uuid': FAKE_UUID1,
'name': 'asdf'})
def test_init_host(self):
our_host = self.compute.host
fake_context = 'fake-context'
inst = fake_instance.fake_db_instance(
vm_state=vm_states.ACTIVE,
info_cache={'instance_uuid': 'fake-uuid',
'network_info': None},
security_groups=None)
startup_instances = [inst, inst, inst]
def _do_mock_calls(defer_iptables_apply):
self.compute.driver.init_host(host=our_host)
context.get_admin_context().AndReturn(fake_context)
db.instance_get_all_by_host(
fake_context, our_host, columns_to_join=['info_cache'],
use_slave=False
).AndReturn(startup_instances)
if defer_iptables_apply:
self.compute.driver.filter_defer_apply_on()
self.compute._destroy_evacuated_instances(fake_context)
self.compute._init_instance(fake_context,
mox.IsA(instance_obj.Instance))
self.compute._init_instance(fake_context,
mox.IsA(instance_obj.Instance))
self.compute._init_instance(fake_context,
mox.IsA(instance_obj.Instance))
if defer_iptables_apply:
self.compute.driver.filter_defer_apply_off()
self.mox.StubOutWithMock(self.compute.driver, 'init_host')
self.mox.StubOutWithMock(self.compute.driver,
'filter_defer_apply_on')
self.mox.StubOutWithMock(self.compute.driver,
'filter_defer_apply_off')
self.mox.StubOutWithMock(db, 'instance_get_all_by_host')
self.mox.StubOutWithMock(context, 'get_admin_context')
self.mox.StubOutWithMock(self.compute,
'_destroy_evacuated_instances')
self.mox.StubOutWithMock(self.compute,
'_init_instance')
# Test with defer_iptables_apply
self.flags(defer_iptables_apply=True)
_do_mock_calls(True)
self.mox.ReplayAll()
self.compute.init_host()
self.mox.VerifyAll()
# Test without defer_iptables_apply
self.mox.ResetAll()
self.flags(defer_iptables_apply=False)
_do_mock_calls(False)
self.mox.ReplayAll()
self.compute.init_host()
# tearDown() uses context.get_admin_context(), so we have
# to do the verification here and unstub it.
self.mox.VerifyAll()
self.mox.UnsetStubs()
def instance_create(context, inst):
inst_type = flavors.get_flavor_by_flavor_id(3)
image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6'
def_image_ref = 'http://localhost/images/%s' % image_uuid
self.instance_cache_num += 1
instance = fake_instance.fake_db_instance(**{
'id': self.instance_cache_num,
'display_name': inst['display_name'] or 'test',
'uuid': FAKE_UUID,
'instance_type': dict(inst_type),
'access_ip_v4': '1.2.3.4',
'access_ip_v6': 'fead::1234',
'image_ref': inst.get('image_ref', def_image_ref),
'user_id': 'fake',
'project_id': 'fake',
'reservation_id': inst['reservation_id'],
"created_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
"updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0),
"config_drive": None,
"progress": 0,
"fixed_ips": [],
"task_state": "",
"vm_state": "",
"root_device_name": inst.get('root_device_name', 'vda'),
})
self.instance_cache_by_id[instance['id']] = instance
self.instance_cache_by_uuid[instance['uuid']] = instance
return instance
def test_check_can_live_migrate_source(self):
is_volume_backed = 'volume_backed'
bdms = 'bdms'
dest_check_data = dict(foo='bar')
db_instance = fake_instance.fake_db_instance()
instance = instance_obj.Instance._from_db_object(
self.context, instance_obj.Instance(), db_instance)
expected_dest_check_data = dict(dest_check_data,
is_volume_backed=is_volume_backed)
self.mox.StubOutWithMock(self.compute.conductor_api,
'block_device_mapping_get_all_by_instance')
self.mox.StubOutWithMock(self.compute.compute_api,
'is_volume_backed_instance')
self.mox.StubOutWithMock(self.compute.driver,
'check_can_live_migrate_source')
instance_p = obj_base.obj_to_primitive(instance)
self.compute.conductor_api.block_device_mapping_get_all_by_instance(
self.context, instance_p).AndReturn(bdms)
self.compute.compute_api.is_volume_backed_instance(
self.context, instance, bdms).AndReturn(is_volume_backed)
self.compute.driver.check_can_live_migrate_source(
self.context, instance, expected_dest_check_data)
self.mox.ReplayAll()
self.compute.check_can_live_migrate_source(
self.context, instance=instance,
dest_check_data=dest_check_data)
def setUp(self):
super(ComputeGetImageMetadataTestCase, self).setUp()
self.context = context.RequestContext("fake", "fake")
self.image = {"min_ram": 10, "min_disk": 1, "disk_format": "raw", "container_format": "bare", "properties": {}}
self.image_service = nova.tests.image.fake._FakeImageService()
self.stubs.Set(self.image_service, "show", self._fake_show)
self.ctx = context.RequestContext("fake", "fake")
sys_meta = {
"image_min_ram": 10,
"image_min_disk": 1,
"image_disk_format": "raw",
"image_container_format": "bare",
"instance_type_id": 0,
"instance_type_name": "m1.fake",
"instance_type_memory_mb": 10,
"instance_type_vcpus": 1,
"instance_type_root_gb": 1,
"instance_type_ephemeral_gb": 1,
"instance_type_flavorid": "0",
"instance_type_swap": 1,
"instance_type_rxtx_factor": 0.0,
"instance_type_vcpu_weight": None,
}
self.instance = fake_instance.fake_db_instance(memory_mb=0, root_gb=0, system_metadata=sys_meta)
def fake_instance_create(context, inst_, session=None):
inst = fake_instance.fake_db_instance(
**{
"id": 1,
"uuid": AUTO_INSTANCE_UUID,
"created_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
"updated_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
"progress": 0,
"name": "instance-1", # this is a property
"task_state": "",
"vm_state": "",
"auto_disk_config": inst_["auto_disk_config"],
"security_groups": inst_["security_groups"],
}
)
def fake_instance_get_for_create(context, id_, *args, **kwargs):
return (inst, inst)
self.stubs.Set(db, "instance_update_and_get_original", fake_instance_get_for_create)
def fake_instance_get_all_for_create(context, *args, **kwargs):
return [inst]
self.stubs.Set(db, "instance_get_all", fake_instance_get_all_for_create)
self.stubs.Set(db, "instance_get_all_by_filters", fake_instance_get_all_for_create)
def fake_instance_add_security_group(context, instance_id, security_group_id):
pass
self.stubs.Set(db, "instance_add_security_group", fake_instance_add_security_group)
return inst
def test_from_db_object_not_overwrite_info_cache(self):
info_cache = instance_info_cache.InstanceInfoCache()
inst = instance.Instance(context=self.context, info_cache=info_cache)
db_inst = fake_instance.fake_db_instance()
db_inst["info_cache"] = dict(test_instance_info_cache.fake_info_cache)
inst._from_db_object(self.context, inst, db_inst, expected_attrs=["info_cache"])
self.assertIs(info_cache, inst.info_cache)
def return_server_by_uuid(context, server_uuid, columns_to_join=None):
return fake_instance.fake_db_instance(
**{'id': 1,
'power_state': 0x01,
'host': "localhost",
'uuid': server_uuid,
'name': 'asdf'})
def return_server_by_uuid(context, server_uuid, columns_to_join=None):
return fake_instance.fake_db_instance(
**{'id': 1,
'uuid': '0cc3346e-9fef-4445-abe6-5d2b2690ec64',
'name': 'fake',
'locked': False,
'launched_at': timeutils.utcnow(),
'vm_state': vm_states.ACTIVE})
def test_get_by_security_group(self):
fake_secgroup = dict(test_security_group.fake_secgroup)
fake_secgroup["instances"] = [
fake_instance.fake_db_instance(id=1, system_metadata={"foo": "bar"}),
fake_instance.fake_db_instance(id=2),
]
with mock.patch.object(db, "security_group_get") as sgg:
sgg.return_value = fake_secgroup
secgroup = security_group.SecurityGroup()
secgroup.id = fake_secgroup["id"]
instances = instance.InstanceList.get_by_security_group(self.context, secgroup)
self.assertEqual(2, len(instances))
self.assertEqual([1, 2], [x.id for x in instances])
self.assertTrue(instances[0].obj_attr_is_set("system_metadata"))
self.assertEqual({"foo": "bar"}, instances[0].system_metadata)
def fake_compute_api_get(self, context, instance_uuid, want_objects=False):
instance = fake_instance.fake_db_instance(
id=1, uuid=instance_uuid, vm_state=vm_states.ACTIVE,
task_state=None, launched_at=timeutils.utcnow())
if want_objects:
instance = instance_obj.Instance._from_db_object(
context, instance_obj.Instance(), instance)
return instance
def _return_server_in_build_by_uuid(self, context, server_uuid,
columns_to_join=None):
return fake_instance.fake_db_instance(
**{'id': 1,
'uuid': '0cc3346e-9fef-4445-abe6-5d2b2690ec64',
'name': 'fake',
'locked': False,
'vm_state': vm_states.BUILDING})
def test_create_stubbed(self):
self.mox.StubOutWithMock(db, "instance_create")
vals = {"host": "foo-host", "memory_mb": 128, "system_metadata": {"foo": "bar"}}
fake_inst = fake_instance.fake_db_instance(**vals)
db.instance_create(self.context, vals).AndReturn(fake_inst)
self.mox.ReplayAll()
inst = instance.Instance(host="foo-host", memory_mb=128, system_metadata={"foo": "bar"})
inst.create(self.context)
def _fake_compute_api_get(self, context, instance_id, **kwargs):
instance = fake_instance.fake_db_instance(id=1, uuid=uuid,
task_state=None,
host='host1',
vm_state=vm_states.ACTIVE)
instance = instance_obj.Instance._from_db_object(context,
instance_obj.Instance(),
instance)
return instance
def setUp(self):
super(ComputeManagerBuildInstanceTestCase, self).setUp()
self.compute = importutils.import_object(CONF.compute_manager)
self.context = context.RequestContext('fake', 'fake')
self.instance = fake_instance.fake_db_instance(
vm_state=vm_states.ACTIVE)
self.admin_pass = '******'
self.injected_files = []
self.image = {}
def _stub_instance_get(self, uuid=None):
self.mox.StubOutWithMock(compute_api.API, "get")
if uuid is None:
uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_db_instance(id=1, uuid=uuid, vm_state=vm_states.ACTIVE, task_state=None)
instance = objects.Instance._from_db_object(self.context, objects.Instance(), instance)
self.compute_api.get(self.context, uuid, want_objects=True).AndReturn(instance)
return instance
def _stub_instance_get(self, uuid=None):
if uuid is None:
uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_db_instance(
id=1, uuid=uuid, vm_state=vm_states.ACTIVE, task_state=None, launched_at=timeutils.utcnow()
)
instance = objects.Instance._from_db_object(self.context, objects.Instance(), instance)
self.compute_api.get(self.context, uuid, want_objects=True).AndReturn(instance)
return instance
def test_init_host(self):
our_host = self.compute.host
fake_context = "fake-context"
inst = fake_instance.fake_db_instance(
vm_state=vm_states.ACTIVE,
info_cache={"instance_uuid": "fake-uuid", "network_info": None},
security_groups=None,
)
startup_instances = [inst, inst, inst]
def _do_mock_calls(defer_iptables_apply):
self.compute.driver.init_host(host=our_host)
context.get_admin_context().AndReturn(fake_context)
db.instance_get_all_by_host(fake_context, our_host, columns_to_join=["info_cache"]).AndReturn(
startup_instances
)
if defer_iptables_apply:
self.compute.driver.filter_defer_apply_on()
self.compute._destroy_evacuated_instances(fake_context)
self.compute._init_instance(fake_context, mox.IsA(instance_obj.Instance))
self.compute._init_instance(fake_context, mox.IsA(instance_obj.Instance))
self.compute._init_instance(fake_context, mox.IsA(instance_obj.Instance))
if defer_iptables_apply:
self.compute.driver.filter_defer_apply_off()
self.compute._report_driver_status(fake_context)
self.compute.publish_service_capabilities(fake_context)
self.mox.StubOutWithMock(self.compute.driver, "init_host")
self.mox.StubOutWithMock(self.compute.driver, "filter_defer_apply_on")
self.mox.StubOutWithMock(self.compute.driver, "filter_defer_apply_off")
self.mox.StubOutWithMock(db, "instance_get_all_by_host")
self.mox.StubOutWithMock(context, "get_admin_context")
self.mox.StubOutWithMock(self.compute, "_destroy_evacuated_instances")
self.mox.StubOutWithMock(self.compute, "_init_instance")
self.mox.StubOutWithMock(self.compute, "_report_driver_status")
self.mox.StubOutWithMock(self.compute, "publish_service_capabilities")
# Test with defer_iptables_apply
self.flags(defer_iptables_apply=True)
_do_mock_calls(True)
self.mox.ReplayAll()
self.compute.init_host()
self.mox.VerifyAll()
# Test without defer_iptables_apply
self.mox.ResetAll()
self.flags(defer_iptables_apply=False)
_do_mock_calls(False)
self.mox.ReplayAll()
self.compute.init_host()
# tearDown() uses context.get_admin_context(), so we have
# to do the verification here and unstub it.
self.mox.VerifyAll()
self.mox.UnsetStubs()
def test_destroy_stubbed(self):
self.mox.StubOutWithMock(db, "instance_destroy")
deleted_at = datetime.datetime(1955, 11, 6)
fake_inst = fake_instance.fake_db_instance(deleted_at=deleted_at, deleted=True)
db.instance_destroy(self.context, "fake-uuid", constraint=None).AndReturn(fake_inst)
self.mox.ReplayAll()
inst = instance.Instance(id=1, uuid="fake-uuid", host="foo")
inst.destroy(self.context)
self.assertEqual(timeutils.normalize_time(inst.deleted_at), timeutils.normalize_time(deleted_at))
self.assertTrue(inst.deleted)
def test_get_by_security_group(self):
fake_secgroup = dict(test_security_group.fake_secgroup)
fake_secgroup['instances'] = [
fake_instance.fake_db_instance(id=1,
system_metadata={'foo': 'bar'}),
fake_instance.fake_db_instance(id=2),
]
with mock.patch.object(db, 'security_group_get') as sgg:
sgg.return_value = fake_secgroup
secgroup = security_group.SecurityGroup()
secgroup.id = fake_secgroup['id']
instances = instance.InstanceList.get_by_security_group(
self.context, secgroup)
self.assertEqual(2, len(instances))
self.assertEqual([1, 2], [x.id for x in instances])
self.assertTrue(instances[0].obj_attr_is_set('system_metadata'))
self.assertEqual({'foo': 'bar'}, instances[0].system_metadata)
def _return_server_in_build_by_uuid(self, context, server_uuid, columns_to_join=None, use_slave=False):
return fake_instance.fake_db_instance(
**{
"id": 1,
"uuid": "0cc3346e-9fef-4445-abe6-5d2b2690ec64",
"name": "fake",
"locked": False,
"vm_state": vm_states.BUILDING,
}
)
def test_create_stubbed(self):
self.mox.StubOutWithMock(db, 'instance_create')
vals = {'host': 'foo-host',
'memory_mb': 128,
'system_metadata': {'foo': 'bar'}}
fake_inst = fake_instance.fake_db_instance(**vals)
db.instance_create(self.context, vals).AndReturn(fake_inst)
self.mox.ReplayAll()
inst = instance.Instance(host='foo-host', memory_mb=128,
system_metadata={'foo': 'bar'})
inst.create(self.context)
def return_server(context, server_id, columns_to_join=None):
return fake_instance.fake_db_instance(
**{
"id": server_id,
"uuid": "0cc3346e-9fef-4445-abe6-5d2b2690ec64",
"name": "fake",
"locked": False,
"launched_at": timeutils.utcnow(),
"vm_state": vm_states.ACTIVE,
}
)
def fake_get_all_by_filters(context, *args, **kwargs):
was['called'] = True
instances = []
for x in xrange(2):
instances.append(fake_instance.fake_db_instance(
image_ref='1',
uuid=x,
name=x,
vm_state='',
task_state=''))
return instances
def test_with_fault(self):
fake_insts = [
fake_instance.fake_db_instance(uuid='fake-uuid', host='host'),
fake_instance.fake_db_instance(uuid='fake-inst2', host='host'),
]
fake_faults = test_instance_fault.fake_faults
self.mox.StubOutWithMock(db, 'instance_get_all_by_host')
self.mox.StubOutWithMock(db, 'instance_fault_get_by_instance_uuids')
db.instance_get_all_by_host(self.context, 'host', columns_to_join=[]
).AndReturn(fake_insts)
db.instance_fault_get_by_instance_uuids(
self.context, [x['uuid'] for x in fake_insts]
).AndReturn(fake_faults)
self.mox.ReplayAll()
instances = instance.InstanceList.get_by_host(self.context, 'host',
expected_attrs=['fault'])
self.assertEqual(2, len(instances))
self.assertEqual(fake_faults['fake-uuid'][0],
dict(instances[0].fault.iteritems()))
self.assertEqual(None, instances[1].fault)
def test_get_by_volume_id_with_expected(self, get_by_vol_id):
get_by_vol_id.return_value = self.fake_bdm(
fake_instance.fake_db_instance())
vol_bdm = objects.BlockDeviceMapping.get_by_volume_id(
self.context, 'fake-volume-id', expected_attrs=['instance'])
for attr in block_device_obj.BLOCK_DEVICE_OPTIONAL_ATTRS:
self.assertTrue(vol_bdm.obj_attr_is_set(attr))
get_by_vol_id.assert_called_once_with(self.context, 'fake-volume-id',
['instance'])
self.assertRemotes()
def _stub_instance_get(self, uuid=None):
self.mox.StubOutWithMock(compute_api.API, 'get')
if uuid is None:
uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_db_instance(
id=1, uuid=uuid, vm_state=vm_states.ACTIVE, task_state=None)
instance = instance_obj.Instance._from_db_object(
self.context, instance_obj.Instance(), instance)
self.compute_api.get(self.context, uuid, want_objects=True,
expected_attrs=['pci_devices']).AndReturn(instance)
return instance
def _stub_instance_get(self, uuid=None):
if uuid is None:
uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_db_instance(
id=1,
uuid=uuid,
vm_state=vm_states.ACTIVE,
task_state=None,
launched_at=timeutils.utcnow())
instance = objects.Instance._from_db_object(self.context,
objects.Instance(),
instance)
self.compute_api.get(self.context, uuid,
want_objects=True).AndReturn(instance)
return instance
def test_with_fault(self):
fake_insts = [
fake_instance.fake_db_instance(uuid='fake-uuid', host='host'),
fake_instance.fake_db_instance(uuid='fake-inst2', host='host'),
]
fake_faults = test_instance_fault.fake_faults
self.mox.StubOutWithMock(db, 'instance_get_all_by_host')
self.mox.StubOutWithMock(db, 'instance_fault_get_by_instance_uuids')
db.instance_get_all_by_host(self.context,
'host',
columns_to_join=[],
use_slave=False).AndReturn(fake_insts)
db.instance_fault_get_by_instance_uuids(
self.context,
[x['uuid'] for x in fake_insts]).AndReturn(fake_faults)
self.mox.ReplayAll()
instances = instance.InstanceList.get_by_host(self.context,
'host',
expected_attrs=['fault'],
use_slave=False)
self.assertEqual(2, len(instances))
self.assertEqual(fake_faults['fake-uuid'][0],
dict(instances[0].fault.iteritems()))
self.assertIsNone(instances[1].fault)
def test_instance(self):
ctxt = context.get_admin_context()
fake_migration = fake_db_migration()
fake_inst = fake_instance.fake_db_instance()
self.mox.StubOutWithMock(db, 'instance_get_by_uuid')
db.instance_get_by_uuid(
ctxt,
fake_migration['instance_uuid'],
columns_to_join=['info_cache', 'security_groups'],
use_slave=False).AndReturn(fake_inst)
mig = migration.Migration._from_db_object(ctxt, migration.Migration(),
fake_migration)
mig._context = ctxt
self.mox.ReplayAll()
self.assertEqual(mig.instance.host, fake_inst['host'])
def test_get_by_address_with_extras(self, instance_get, network_get,
fixed_get):
db_fixed = dict(fake_fixed_ip,
network=test_network.fake_network,
instance=fake_instance.fake_db_instance())
fixed_get.return_value = db_fixed
fixedip = fixed_ip.FixedIP.get_by_address(
self.context, '1.2.3.4', expected_attrs=['network', 'instance'])
fixed_get.assert_called_once_with(
self.context, '1.2.3.4', columns_to_join=['network', 'instance'])
self._compare(fixedip, db_fixed)
self.assertEqual(db_fixed['network']['uuid'], fixedip.network.uuid)
self.assertEqual(db_fixed['instance']['uuid'], fixedip.instance.uuid)
self.assertFalse(network_get.called)
self.assertFalse(instance_get.called)
def setUp(self):
super(ComputeManagerBuildInstanceTestCase, self).setUp()
self.compute = importutils.import_object(CONF.compute_manager)
self.context = context.RequestContext('fake', 'fake')
self.instance = fake_instance.fake_db_instance(
vm_state=vm_states.ACTIVE)
self.admin_pass = '******'
self.injected_files = []
self.image = {}
self.node = 'fake-node'
self.limits = {}
# override tracker with a version that doesn't need the database:
fake_rt = fake_resource_tracker.FakeResourceTracker(
self.compute.host, self.compute.driver, self.node)
self.compute._resource_tracker_dict[self.node] = fake_rt
def test_create_stubbed(self):
self.mox.StubOutWithMock(db, 'instance_create')
vals = {
'host': 'foo-host',
'memory_mb': 128,
'system_metadata': {
'foo': 'bar'
}
}
fake_inst = fake_instance.fake_db_instance(**vals)
db.instance_create(self.context, vals).AndReturn(fake_inst)
self.mox.ReplayAll()
inst = instance.Instance(host='foo-host',
memory_mb=128,
system_metadata={'foo': 'bar'})
inst.create(self.context)
def test_ensure_ephemeral_resize_with_root_volume(self, mock_sizes,
mock_resize):
mock_sizes.return_value = [2000, 1000]
instance = fake_instance.fake_db_instance(root_gb=20, ephemeral_gb=20)
ephemerals = {"4": {"ref": 4}, "5": {"ref": 5}}
vdis = {'root': {'osvol': True, 'ref': 'vdi_ref'},
'ephemerals': ephemerals}
with mock.patch.object(vm_utils, 'generate_single_ephemeral',
autospec=True) as g:
self.vmops._resize_up_vdis(instance, vdis)
self.assertEqual([mock.call(self.vmops._session, instance, 4,
2000),
mock.call(self.vmops._session, instance, 5,
1000)],
mock_resize.call_args_list)
self.assertFalse(g.called)
def _stub_instance_get(self, uuid=None):
self.mox.StubOutWithMock(compute_api.API, 'get')
if uuid is None:
uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_db_instance(id=1,
uuid=uuid,
vm_state=vm_states.ACTIVE,
task_state=None)
instance = instance_obj.Instance._from_db_object(
self.context, instance_obj.Instance(), instance)
self.compute_api.get(self.context,
uuid,
want_objects=True,
expected_attrs=['pci_devices'
]).AndReturn(instance)
return instance
def setUp(self):
super(LiveMigrationTaskTestCase, self).setUp()
self.context = "context"
self.instance_host = "host"
self.instance_uuid = "uuid"
self.instance_image = "image_ref"
db_instance = fake_instance.fake_db_instance(
host=self.instance_host,
uuid=self.instance_uuid,
power_state=power_state.RUNNING,
memory_mb=512,
image_ref=self.instance_image)
self.instance = instance_obj.Instance._from_db_object(
self.context, instance_obj.Instance(), db_instance)
self.destination = "destination"
self.block_migration = "bm"
self.disk_over_commit = "doc"
self._generate_task()
def test_prep_resize_post_populates_retry(self):
self.manager.driver = fakes.FakeFilterScheduler()
image = 'image'
instance_uuid = 'fake-instance-id'
instance = fake_instance.fake_db_instance(uuid=instance_uuid)
instance_properties = {'project_id': 'fake', 'os_type': 'Linux'}
instance_type = "m1.tiny"
request_spec = {
'instance_properties': instance_properties,
'instance_type': instance_type,
'instance_uuids': [instance_uuid]
}
retry = {'hosts': [], 'num_attempts': 1}
filter_properties = {'retry': retry}
reservations = None
hosts = [dict(host='host', nodename='node', limits={})]
self._mox_schedule_method_helper('select_destinations')
self.manager.driver.select_destinations(
self.context, request_spec, filter_properties).AndReturn(hosts)
self.mox.StubOutWithMock(self.manager.compute_rpcapi, 'prep_resize')
self.manager.compute_rpcapi.prep_resize(
self.context,
image,
mox.IsA(objects.Instance),
instance_type,
'host',
reservations,
request_spec=request_spec,
filter_properties=filter_properties,
node='node')
self.mox.ReplayAll()
self.manager.prep_resize(self.context, image, request_spec,
filter_properties, instance, instance_type,
reservations)
self.assertEqual([['host', 'node']],
filter_properties['retry']['hosts'])
def test_create_with_special_things(self):
self.mox.StubOutWithMock(db, 'instance_create')
fake_inst = fake_instance.fake_db_instance()
db.instance_create(self.context,
{'host': 'foo-host',
'security_groups': ['foo', 'bar'],
'info_cache': {'network_info': '[]'},
}
).AndReturn(fake_inst)
self.mox.ReplayAll()
secgroups = security_group.SecurityGroupList()
secgroups.objects = []
for name in ('foo', 'bar'):
secgroup = security_group.SecurityGroup()
secgroup.name = name
secgroups.objects.append(secgroup)
info_cache = instance_info_cache.InstanceInfoCache()
info_cache.network_info = network_model.NetworkInfo()
inst = instance.Instance(host='foo-host', security_groups=secgroups,
info_cache=info_cache)
inst.create(self.context)
def test_sync_power_states_instance_not_found(self):
db_instance = fake_instance.fake_db_instance()
ctxt = context.get_admin_context()
instance_list = instance_obj._make_instance_list(
ctxt, instance_obj.InstanceList(), [db_instance], None)
instance = instance_list[0]
self.mox.StubOutWithMock(instance_obj.InstanceList, 'get_by_host')
self.mox.StubOutWithMock(self.compute.driver, 'get_num_instances')
self.mox.StubOutWithMock(vm_utils, 'lookup')
self.mox.StubOutWithMock(self.compute, '_sync_instance_power_state')
instance_obj.InstanceList.get_by_host(
ctxt, self.compute.host, use_slave=True).AndReturn(instance_list)
self.compute.driver.get_num_instances().AndReturn(1)
vm_utils.lookup(self.compute.driver._session, instance['name'],
False).AndReturn(None)
self.compute._sync_instance_power_state(ctxt, instance,
power_state.NOSTATE)
self.mox.ReplayAll()
self.compute._sync_power_states(ctxt)
def setUp(self):
super(ComputeGetImageMetadataTestCase, self).setUp()
self.context = context.RequestContext('fake', 'fake')
self.image = {
"min_ram": 10,
"min_disk": 1,
"disk_format": "raw",
"container_format": "bare",
"properties": {},
}
self.mock_image_api = mock.Mock()
self.mock_image_api.get.return_value = self.image
self.ctx = context.RequestContext('fake', 'fake')
sys_meta = {
'image_min_ram': 10,
'image_min_disk': 1,
'image_disk_format': 'raw',
'image_container_format': 'bare',
'instance_type_id': 0,
'instance_type_name': 'm1.fake',
'instance_type_memory_mb': 10,
'instance_type_vcpus': 1,
'instance_type_root_gb': 1,
'instance_type_ephemeral_gb': 1,
'instance_type_flavorid': '0',
'instance_type_swap': 1,
'instance_type_rxtx_factor': 0.0,
'instance_type_vcpu_weight': None,
}
self.instance = fake_instance.fake_db_instance(
memory_mb=0, root_gb=0,
system_metadata=sys_meta)
def setUp(self):
super(ComputeGetImageMetadataTestCase, self).setUp()
self.context = context.RequestContext('fake', 'fake')
self.image = {
"min_ram": 10,
"min_disk": 1,
"disk_format": "raw",
"container_format": "bare",
"properties": {},
}
self.image_service = nova.tests.image.fake._FakeImageService()
self.stubs.Set(self.image_service, 'show', self._fake_show)
self.ctx = context.RequestContext('fake', 'fake')
sys_meta = {
'image_min_ram': 10,
'image_min_disk': 1,
'image_disk_format': 'raw',
'image_container_format': 'bare',
'instance_type_id': 0,
'instance_type_name': 'm1.fake',
'instance_type_memory_mb': 10,
'instance_type_vcpus': 1,
'instance_type_root_gb': 1,
'instance_type_ephemeral_gb': 1,
'instance_type_flavorid': '0',
'instance_type_swap': 1,
'instance_type_rxtx_factor': 0.0,
'instance_type_vcpu_weight': None,
}
self.instance = fake_instance.fake_db_instance(
memory_mb=0, root_gb=0,
system_metadata=sys_meta)
def fake_instance_create(context, inst_, session=None):
inst = fake_instance.fake_db_instance(
**{
'id': 1,
'uuid': AUTO_INSTANCE_UUID,
'created_at': datetime.datetime(2010, 10, 10, 12, 0, 0),
'updated_at': datetime.datetime(2010, 10, 10, 12, 0, 0),
'progress': 0,
'name': 'instance-1', # this is a property
'task_state': '',
'vm_state': '',
'auto_disk_config': inst_['auto_disk_config'],
'security_groups': inst_['security_groups'],
})
def fake_instance_get_for_create(context, id_, *args, **kwargs):
return (inst, inst)
self.stubs.Set(db, 'instance_update_and_get_original',
fake_instance_get_for_create)
def fake_instance_get_all_for_create(context, *args, **kwargs):
return [inst]
self.stubs.Set(db, 'instance_get_all',
fake_instance_get_all_for_create)
self.stubs.Set(db, 'instance_get_all_by_filters',
fake_instance_get_all_for_create)
def fake_instance_add_security_group(context, instance_id,
security_group_id):
pass
self.stubs.Set(db, 'instance_add_security_group',
fake_instance_add_security_group)
return inst
def fake_instance_get_by_uuid(context, instance_id,
columns_to_join=None):
return fake_instance.fake_db_instance(
**{'name': 'fake', 'project_id': '%s_unequal' %
context.project_id})
def test_init_host(self):
our_host = self.compute.host
fake_context = 'fake-context'
inst = fake_instance.fake_db_instance(
vm_state=vm_states.ACTIVE,
info_cache={'instance_uuid': 'fake-uuid',
'network_info': None},
security_groups=None)
startup_instances = [inst, inst, inst]
def _do_mock_calls(defer_iptables_apply):
self.compute.driver.init_host(host=our_host)
context.get_admin_context().AndReturn(fake_context)
db.instance_get_all_by_host(
fake_context, our_host, columns_to_join=['info_cache']
).AndReturn(startup_instances)
if defer_iptables_apply:
self.compute.driver.filter_defer_apply_on()
self.compute._destroy_evacuated_instances(fake_context)
self.compute._init_instance(fake_context,
mox.IsA(instance_obj.Instance))
self.compute._init_instance(fake_context,
mox.IsA(instance_obj.Instance))
self.compute._init_instance(fake_context,
mox.IsA(instance_obj.Instance))
if defer_iptables_apply:
self.compute.driver.filter_defer_apply_off()
self.compute._report_driver_status(fake_context)
self.compute.publish_service_capabilities(fake_context)
self.mox.StubOutWithMock(self.compute.driver, 'init_host')
self.mox.StubOutWithMock(self.compute.driver,
'filter_defer_apply_on')
self.mox.StubOutWithMock(self.compute.driver,
'filter_defer_apply_off')
self.mox.StubOutWithMock(db, 'instance_get_all_by_host')
self.mox.StubOutWithMock(context, 'get_admin_context')
self.mox.StubOutWithMock(self.compute,
'_destroy_evacuated_instances')
self.mox.StubOutWithMock(self.compute,
'_init_instance')
self.mox.StubOutWithMock(self.compute,
'_report_driver_status')
self.mox.StubOutWithMock(self.compute,
'publish_service_capabilities')
# Test with defer_iptables_apply
self.flags(defer_iptables_apply=True)
_do_mock_calls(True)
self.mox.ReplayAll()
self.compute.init_host()
self.mox.VerifyAll()
# Test without defer_iptables_apply
self.mox.ResetAll()
self.flags(defer_iptables_apply=False)
_do_mock_calls(False)
self.mox.ReplayAll()
self.compute.init_host()
# tearDown() uses context.get_admin_context(), so we have
# to do the verification here and unstub it.
self.mox.VerifyAll()
self.mox.UnsetStubs()
def test_deallocate_fixed_ip(self):
instance = fake_instance.fake_db_instance()
self._test_network_api('deallocate_fixed_ip', rpc_method='call',
address='fake_addr', host='fake_host', instance=instance,
version='1.12')
USER_DATA_STRING = ("This is an encoded string")
ENCODE_USER_DATA_STRING = base64.b64encode(USER_DATA_STRING)
INSTANCE = fake_instance.fake_db_instance(
**{
'id': 1,
'uuid': 'b65cee2f-8c69-4aeb-be2f-f79742548fc2',
'name': 'fake',
'project_id': 'test',
'key_name': "mykey",
'key_data': "ssh-rsa AAAAB3Nzai....N3NtHw== someuser@somehost",
'host': 'test',
'launch_index': 1,
'instance_type': {
'name': 'm1.tiny'
},
'reservation_id': 'r-xxxxxxxx',
'user_data': ENCODE_USER_DATA_STRING,
'image_ref': 7,
'vcpus': 1,
'fixed_ips': [],
'root_device_name': '/dev/sda1',
'info_cache': test_instance_info_cache.fake_info_cache,
'hostname': 'test.novadomain',
'display_name': 'my_displayname',
'metadata': {},
'system_metadata': {},
})
def fake_inst_obj(context):
def fake_locked(context, instance_uuid, columns_to_join=None):
return fake_instance.fake_db_instance(name="foo",
uuid=FAKE_UUID,
locked=True)
def test_instance_dict_none_info_cache(self):
inst = fake_instance.fake_db_instance(info_cache=None)
self.assertIsNone(inst['info_cache'])
result = compute_utils.get_nw_info_for_instance(inst)
self.assertEqual(jsonutils.dumps([]), result.json())
def test_dont_resize_root_volumes_osvol_false(self, mock_resize):
instance = fake_instance.fake_db_instance(root_gb=20)
vdis = {'root': {'osvol': False, 'ref': 'vdi_ref'}}
self.vmops._resize_up_vdis(instance, vdis)
self.assertTrue(mock_resize.called)
def test_dont_resize_root_volumes_no_osvol(self, mock_resize):
instance = fake_instance.fake_db_instance(root_gb=20)
vdis = {'root': {}}
self.vmops._resize_up_vdis(instance, vdis)
self.assertFalse(mock_resize.called)
def setUp(self):
super(_TestQuotasObject, self).setUp()
self.context = context.RequestContext('fake_user1', 'fake_proj1')
self.instance = fake_instance.fake_db_instance(project_id='fake_proj2',
user_id='fake_user2')
def fake_instance_get_by_uuid(context,
instance_uuid,
columns_to_join=None,
use_slave=None):
return fake_instance.fake_db_instance(uuid=instance_uuid)
