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)