def test_count_members_by_user(self): instance1 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance1.user_id = 'user1' instance1.save() instance2 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance2.user_id = 'user2' instance2.save() instance3 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance3.user_id = 'user2' instance3.save() instance_ids = [instance1.uuid, instance2.uuid, instance3.uuid] values = self._get_default_values() group = self._create_instance_group(self.context, values) instance_group.InstanceGroup.add_members(self.context, group.uuid, instance_ids) group = instance_group.InstanceGroup.get_by_uuid(self.context, group.uuid) count_user1 = group.count_members_by_user(self.context, 'user1') count_user2 = group.count_members_by_user(self.context, 'user2') count_user3 = group.count_members_by_user(self.context, 'user3') self.assertEqual(1, count_user1) self.assertEqual(2, count_user2) self.assertEqual(0, count_user3)
def test_count_members_by_user(self): instance1 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance1.user_id = 'user1' instance1.save() instance2 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance2.user_id = 'user2' instance2.save() instance3 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance3.user_id = 'user2' instance3.save() instance_ids = [instance1.uuid, instance2.uuid, instance3.uuid] values = self._get_default_values() group = self._create_instance_group(self.context, values) instance_group.InstanceGroup.add_members(self.context, group.uuid, instance_ids) group = instance_group.InstanceGroup.get_by_uuid(self.context, group.uuid) count_user1 = group.count_members_by_user('user1') count_user2 = group.count_members_by_user('user2') count_user3 = group.count_members_by_user('user3') self.assertEqual(1, count_user1) self.assertEqual(2, count_user2) self.assertEqual(0, count_user3)
def test_get_hosts(self): instance1 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance1.host = 'hostA' instance1.save() instance2 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance2.host = 'hostB' instance2.save() instance3 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance3.host = 'hostB' instance3.save() instance_ids = [instance1.uuid, instance2.uuid, instance3.uuid] values = self._get_default_values() group = self._create_instance_group(self.context, values) instance_group.InstanceGroup.add_members(self.context, group.uuid, instance_ids) group = instance_group.InstanceGroup.get_by_uuid(self.context, group.uuid) hosts = group.get_hosts(self.context) self.assertEqual(2, len(hosts)) self.assertIn('hostA', hosts) self.assertIn('hostB', hosts) hosts = group.get_hosts(self.context, exclude=[instance1.uuid]) self.assertEqual(1, len(hosts)) self.assertIn('hostB', hosts)
def test_get_hosts(self): instance1 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance1.host = 'hostA' instance1.save() instance2 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance2.host = 'hostB' instance2.save() instance3 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance3.host = 'hostB' instance3.save() instance_ids = [instance1.uuid, instance2.uuid, instance3.uuid] values = self._get_default_values() group = self._create_instance_group(self.context, values) instance_group.InstanceGroup.add_members(self.context, group.uuid, instance_ids) group = instance_group.InstanceGroup.get_by_uuid(self.context, group.uuid) hosts = group.get_hosts() self.assertEqual(2, len(hosts)) self.assertIn('hostA', hosts) self.assertIn('hostB', hosts) hosts = group.get_hosts(exclude=[instance1.uuid]) self.assertEqual(1, len(hosts)) self.assertIn('hostB', hosts)
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"], "instance_type": flavors.get_default_flavor(), } ) 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_get_flavor_from_deleted_with_id(self): # Deleted instances may not have type info in system_metadata, # so verify that they get their type from a lookup of their # instance_type_id inst_without_sys_meta = dict(self.baseinst, system_metadata=[], deleted=1) flavor = self.controller._get_flavor(self.context, self.compute_api, inst_without_sys_meta, {}) self.assertEqual(flavor, flavors.get_default_flavor())
def fake_inst_obj(context): inst = objects.Instance( context=context, id=1, user_id="fake_user", uuid="b65cee2f-8c69-4aeb-be2f-f79742548fc2", project_id="test", key_name="key", key_data="ssh-rsa AAAAB3Nzai....N3NtHw== someuser@somehost", host="test", launch_index=1, reservation_id="r-xxxxxxxx", user_data=ENCODE_USER_DATA_STRING, image_ref=7, vcpus=1, fixed_ips=[], root_device_name="/dev/sda1", hostname="test.novadomain", display_name="my_displayname", metadata={}, default_ephemeral_device=None, default_swap_device=None, system_metadata={}, ) nwinfo = network_model.NetworkInfo([]) inst.info_cache = objects.InstanceInfoCache(context=context, instance_uuid=inst.uuid, network_info=nwinfo) with mock.patch.object(inst, "save"): inst.set_flavor(flavors.get_default_flavor()) return inst
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 instance = objects.Instance( id=1, uuid='uuid', project_id='project_id', host='host', system_metadata={}, flavor=flavor) self.network_api.allocate_for_instance( self.context, instance, 'vpn', 'requested_networks', macs=macs)
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 _stub_migrate_instance_calls(self, method, multi_host, info): fake_flavor = flavors.get_default_flavor() fake_flavor['rxtx_factor'] = 1.21 fake_instance = objects.Instance( uuid=uuid.uuid4().hex, project_id='fake_project_id', instance_type_id=fake_flavor['id'], flavor=fake_flavor, system_metadata={}) 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 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 fake_inst_obj(context): inst = objects.Instance( context=context, id=1, user_id='fake_user', uuid='b65cee2f-8c69-4aeb-be2f-f79742548fc2', project_id='test', key_name="key", key_data="ssh-rsa AAAAB3Nzai....N3NtHw== someuser@somehost", host='test', launch_index=1, reservation_id='r-xxxxxxxx', user_data=ENCODE_USER_DATA_STRING, image_ref=7, kernel_id=None, ramdisk_id=None, vcpus=1, fixed_ips=[], root_device_name='/dev/sda1', hostname='test.novadomain', display_name='my_displayname', metadata={}, default_ephemeral_device=None, default_swap_device=None, system_metadata={}, availability_zone=None) nwinfo = network_model.NetworkInfo([]) inst.info_cache = objects.InstanceInfoCache(context=context, instance_uuid=inst.uuid, network_info=nwinfo) with mock.patch.object(inst, 'save'): inst.set_flavor(flavors.get_default_flavor()) return inst
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"]) with mock.patch.object(self.network_api.network_rpcapi, "allocate_for_instance") as mock_alloc: kwargs = dict( zip( [ "host", "instance_id", "project_id", "requested_networks", "rxtx_factor", "vpn", "macs", "dhcp_options", ], itertools.repeat(mock.ANY), ) ) mock_alloc.return_value = [] flavor = flavors.get_default_flavor() flavor["rxtx_factor"] = 0 instance = objects.Instance( id=1, uuid=uuids.instance, project_id="project_id", host="host", system_metadata={}, flavor=flavor ) self.network_api.allocate_for_instance(self.context, instance, "vpn", requested_networks=None, macs=macs) mock_alloc.assert_called_once_with(self.context, **kwargs)
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=1, uuid='uuid', project_id='project_id', host='host', system_metadata=utils.dict_to_metadata(sys_meta)) instance = fake_instance.fake_instance_obj( self.context, expected_attrs=['system_metadata'], **instance) self.network_api.allocate_for_instance(self.context, instance, 'vpn', 'requested_networks', macs=macs)
def _stub_migrate_instance_calls(self, method, multi_host, info): fake_flavor = flavors.get_default_flavor() fake_flavor["rxtx_factor"] = 1.21 fake_instance = objects.Instance( uuid=uuid.uuid4().hex, project_id="fake_project_id", instance_type_id=fake_flavor["id"], flavor=fake_flavor, system_metadata={}, ) 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.stub_out("nova.network.rpcapi.NetworkAPI." + method, fake_mig_inst_method) self.stub_out("nova.network.api.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 _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 fake_inst_obj(context): inst = objects.Instance( context=context, id=1, user_id='fake_user', uuid='b65cee2f-8c69-4aeb-be2f-f79742548fc2', project_id='test', key_name="key", key_data="ssh-rsa AAAAB3Nzai....N3NtHw== someuser@somehost", host='test', launch_index=1, reservation_id='r-xxxxxxxx', user_data=ENCODE_USER_DATA_STRING, image_ref=7, kernel_id=None, ramdisk_id=None, vcpus=1, fixed_ips=[], root_device_name='/dev/sda1', hostname='test.novadomain', display_name='my_displayname', metadata={}, default_ephemeral_device=None, default_swap_device=None, system_metadata={}) nwinfo = network_model.NetworkInfo([]) inst.info_cache = objects.InstanceInfoCache(context=context, instance_uuid=inst.uuid, network_info=nwinfo) with mock.patch.object(inst, 'save'): inst.set_flavor(flavors.get_default_flavor()) return inst
def _stub_migrate_instance_calls(self, method, multi_host, info): fake_flavor = flavors.get_default_flavor() fake_flavor['rxtx_factor'] = 1.21 fake_instance = objects.Instance( uuid=uuidutils.generate_uuid(dashed=False), project_id='fake_project_id', instance_type_id=fake_flavor['id'], flavor=fake_flavor, system_metadata={}) 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.stub_out('nova.network.rpcapi.NetworkAPI.' + method, fake_mig_inst_method) self.stub_out('nova.network.api.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 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 = datetime.datetime.now() 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_flavor_get_by_None_name_returns_default(self): # Ensure get by name returns default flavor with no name. default = flavors.get_default_flavor() actual = flavors.get_flavor_by_name(None) self.assertIsInstance(default, objects.Flavor) self.assertIsInstance(actual, objects.Flavor) self.assertEqual(default.flavorid, actual.flavorid)
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_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']) with mock.patch.object(self.network_api.network_rpcapi, "allocate_for_instance") as mock_alloc: kwargs = dict( zip([ 'host', 'instance_id', 'project_id', 'requested_networks', 'rxtx_factor', 'vpn', 'macs', 'dhcp_options' ], itertools.repeat(mock.ANY))) mock_alloc.return_value = [] flavor = flavors.get_default_flavor() flavor['rxtx_factor'] = 0 instance = objects.Instance(id=1, uuid=uuids.instance, project_id='project_id', host='host', system_metadata={}, flavor=flavor) self.network_api.allocate_for_instance(self.context, instance, 'vpn', 'requested_networks', macs=macs) mock_alloc.assert_called_once_with(self.context, **kwargs)
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_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_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 test_get_hosts_with_some_none(self): instance1 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance1.host = None instance1.save() instance2 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance2.host = "hostB" instance2.save() instance_ids = [instance1.uuid, instance2.uuid] values = self._get_default_values() group = self._create_instance_group(self.context, values) instance_group.InstanceGroup.add_members(self.context, group.uuid, instance_ids) group = instance_group.InstanceGroup.get_by_uuid(self.context, group.uuid) hosts = group.get_hosts(self.context) self.assertEqual(1, len(hosts)) self.assertIn("hostB", hosts)
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 _get_instance_xml(self, driver, vif, image_meta=None): default_inst_type = flavors.get_default_flavor() extra_specs = default_inst_type["extra_specs"].items() quota_bandwidth = self.bandwidth.items() default_inst_type["extra_specs"] = dict(extra_specs + quota_bandwidth) conf = self._get_conf() nic = driver.get_config(self.instance, vif, image_meta, default_inst_type) conf.add_device(nic) return conf.to_xml()
def _get_instance_xml(self, driver, vif, image_meta=None): default_inst_type = flavors.get_default_flavor() extra_specs = default_inst_type['extra_specs'].items() quota_bandwidth = self.bandwidth.items() default_inst_type['extra_specs'] = dict(extra_specs + quota_bandwidth) conf = self._get_conf() nic = driver.get_config(self.instance, vif, image_meta, default_inst_type) conf.add_device(nic) return conf.to_xml()
def _test_set_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} ) inst = instance.Instance.get_by_uuid(self.context, db_inst["uuid"]) db_flavor = flavors.get_default_flavor() inst.set_flavor(db_flavor, namespace) db_inst = db.instance_get(self.context, db_inst["id"]) self.assertEqual(db_flavor["flavorid"], flavors.extract_flavor(db_inst, prefix)["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 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_set_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, }) inst = instance.Instance.get_by_uuid(self.context, db_inst['uuid']) db_flavor = flavors.get_default_flavor() inst.set_flavor(db_flavor, namespace) db_inst = db.instance_get(self.context, db_inst['id']) self.assertEqual( db_flavor['flavorid'], flavors.extract_flavor( db_inst, prefix)['flavorid'])
def _test_set_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, }) inst = instance.Instance.get_by_uuid(self.context, db_inst['uuid']) db_flavor = flavors.get_default_flavor() inst.set_flavor(db_flavor, namespace) db_inst = db.instance_get(self.context, db_inst['id']) self.assertEqual(db_flavor['flavorid'], flavors.extract_flavor(db_inst, prefix)['flavorid'])
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_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_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_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_create_instance_over_quota_during_recheck( self, check_deltas_mock): self.stub_out('nova.tests.unit.image.fake._FakeImageService.show', self.fake_show) # Simulate a race where the first check passes and the recheck fails. fake_quotas = {'instances': 5, 'cores': 10, 'ram': 4096} fake_headroom = {'instances': 5, 'cores': 10, 'ram': 4096} fake_usages = {'instances': 5, 'cores': 10, 'ram': 4096} exc = exception.OverQuota(overs=['instances'], quotas=fake_quotas, headroom=fake_headroom, usages=fake_usages) check_deltas_mock.side_effect = [None, exc] inst_type = flavors.get_default_flavor() # Try to create 3 instances. self.assertRaises(exception.QuotaError, self.compute_api.create, self.context, inst_type, self.fake_image['id'], min_count=3) project_id = self.context.project_id self.assertEqual(2, check_deltas_mock.call_count) call1 = mock.call(self.context, {'instances': 3, 'cores': inst_type.vcpus * 3, 'ram': inst_type.memory_mb * 3}, project_id, user_id=None, check_project_id=project_id, check_user_id=None) call2 = mock.call(self.context, {'instances': 0, 'cores': 0, 'ram': 0}, project_id, user_id=None, check_project_id=project_id, check_user_id=None) check_deltas_mock.assert_has_calls([call1, call2]) # Verify we removed the artifacts that were added after the first # quota check passed. instances = objects.InstanceList.get_all(self.context) self.assertEqual(0, len(instances)) build_requests = objects.BuildRequestList.get_all(self.context) self.assertEqual(0, len(build_requests)) @db_api.api_context_manager.reader def request_spec_get_all(context): return context.session.query(api_models.RequestSpec).all() request_specs = request_spec_get_all(self.context) self.assertEqual(0, len(request_specs)) instance_mappings = objects.InstanceMappingList.get_by_project_id( self.context, project_id) self.assertEqual(0, len(instance_mappings))
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'], 'instance_type': flavors.get_default_flavor(), }) return inst
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 list(instance_type_p.keys()): if key not in props: del instance_type_p[key] self.assertEqual(instance_type_p, _instance_type_p)
def _get_instance_xml(self, driver, net, mapping, image_meta=None): conf = vconfig.LibvirtConfigGuest() conf.virt_type = "qemu" conf.name = "fake-name" conf.uuid = "fake-uuid" conf.memory = 100 * 1024 conf.vcpus = 4 default_inst_type = flavors.get_default_flavor() extra_specs = default_inst_type['extra_specs'].items() quota_bandwith = self.bandwidth.items() default_inst_type['extra_specs'] = dict(extra_specs + quota_bandwith) nic = driver.get_config(self.instance, net, mapping, image_meta, default_inst_type) conf.add_device(nic) return conf.to_xml()
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_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 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'])
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 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 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'], 'instance_type': flavors.get_default_flavor(), }) def fake_instance_get_for_create(context, id_, *args, **kwargs): return (inst, inst) self.stub_out('nova.db.instance_update_and_get_original', fake_instance_get_for_create) def fake_instance_get_all_for_create(context, *args, **kwargs): return [inst] self.stub_out('nova.db.instance_get_all', fake_instance_get_all_for_create) self.stub_out('nova.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.stub_out('nova.db.instance_add_security_group', fake_instance_add_security_group) return inst
def test_create_instance_no_quota_recheck(self, check_deltas_mock): self.stub_out('nova.tests.unit.image.fake._FakeImageService.show', self.fake_show) # Disable recheck_quota. self.flags(recheck_quota=False, group='quota') inst_type = flavors.get_default_flavor() (refs, resv_id) = self.compute_api.create(self.context, inst_type, self.fake_image['id']) self.assertEqual(1, len(refs)) project_id = self.context.project_id # check_deltas should have been called only once. check_deltas_mock.assert_called_once_with(self.context, { 'instances': 1, 'cores': inst_type.vcpus, 'ram': inst_type.memory_mb }, project_id, user_id=None, check_project_id=project_id, check_user_id=None)
def get_instance_type(self, context, flavor_type): if flavor_type == 1: return flavors.get_default_flavor() else: raise exception.InstanceTypeNotFound(flavor_type)
def get_default_sys_meta(): return flavors.save_flavor_info({}, flavors.get_default_flavor())