openstack
/
nova
Code Issues Proposed changes

Use db.flavor_ instead of db.instance_type_ 

We are removing instance_type as a synonym for a flavor. This fixes that
for the db.ap.

Partially implements bp flavor-instance-type-dedup

Change-Id: Id41b3b86a7af476622c70415080f4982c267a646
This commit is contained in:
Joe Gordon 2013-07-09 16:05:16 +01:00
parent 6b99c6c132
commit 952a26a851
28 changed files with 163 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
nova/api/openstack/compute/contrib/flavorextraspecs.py
View File

@ -47,7 +47,7 @@ class FlavorExtraSpecsController(object):
"""The flavor extra specs API controller for the OpenStack API."""
def _get_extra_specs(self, context, flavor_id):
extra_specs = db.instance_type_extra_specs_get(context, flavor_id)
extra_specs = db.flavor_extra_specs_get(context, flavor_id)
return dict(extra_specs=extra_specs)
def _check_body(self, body):
@ -69,7 +69,7 @@ class FlavorExtraSpecsController(object):
self._check_body(body)
specs = body.get('extra_specs')
try:
db.instance_type_extra_specs_update_or_create(context,
db.flavor_extra_specs_update_or_create(context,
flavor_id,
specs)
except exception.MetadataLimitExceeded as error:
@ -88,7 +88,7 @@ class FlavorExtraSpecsController(object):
expl = _('Request body contains too many items')
raise exc.HTTPBadRequest(explanation=expl)
try:
db.instance_type_extra_specs_update_or_create(context,
db.flavor_extra_specs_update_or_create(context,
flavor_id,
body)
except exception.MetadataLimitExceeded as error:
@ -101,7 +101,7 @@ class FlavorExtraSpecsController(object):
context = req.environ['nova.context']
authorize(context, action='show')
try:
extra_spec = db.instance_type_extra_specs_get_item(context,
extra_spec = db.flavor_extra_specs_get_item(context,
flavor_id, id)
return extra_spec
except exception.InstanceTypeExtraSpecsNotFound:
@ -111,7 +111,7 @@ class FlavorExtraSpecsController(object):
"""Deletes an existing extra spec."""
context = req.environ['nova.context']
authorize(context, action='delete')
db.instance_type_extra_specs_delete(context, flavor_id, id)
db.flavor_extra_specs_delete(context, flavor_id, id)
class Flavorextraspecs(extensions.ExtensionDescriptor):

2
nova/cells/state.py
View File

@ -293,7 +293,7 @@ class CellStateManager(base.Base):
ram_mb_free_units[str(memory_mb)] += ram_free_units
disk_mb_free_units[str(disk_mb)] += disk_free_units
instance_types = self.db.instance_type_get_all(ctxt)
instance_types = self.db.flavor_get_all(ctxt)
for compute_values in compute_hosts.values():
total_ram_mb_free += compute_values['free_ram_mb']

4
nova/cmd/manage.py
View File

@ -964,7 +964,7 @@ class InstanceTypeCommands(object):
ctxt = context.get_admin_context()
ext_spec = {key: value}
db.instance_type_extra_specs_update_or_create(
db.flavor_extra_specs_update_or_create(
ctxt,
inst_type["flavorid"],
ext_spec)
@ -985,7 +985,7 @@ class InstanceTypeCommands(object):
return(2)
ctxt = context.get_admin_context()
db.instance_type_extra_specs_delete(
db.flavor_extra_specs_delete(
ctxt,
inst_type["flavorid"],
key)

18
nova/compute/flavors.py
View File

@ -132,7 +132,7 @@ def create(name, memory, vcpus, root_gb, ephemeral_gb=0, flavorid=None,
raise exception.InvalidInput(reason=_("is_public must be a boolean"))
try:
return db.instance_type_create(context.get_admin_context(), kwargs)
return db.flavor_create(context.get_admin_context(), kwargs)
except db_exc.DBError as e:
LOG.exception(_('DB error: %s') % e)
raise exception.InstanceTypeCreateFailed()
@ -142,7 +142,7 @@ def destroy(name):
"""Marks flavor as deleted."""
try:
assert name is not None
db.instance_type_destroy(context.get_admin_context(), name)
db.flavor_destroy(context.get_admin_context(), name)
except (AssertionError, exception.NotFound):
LOG.exception(_('Instance type %s not found for deletion') % name)
raise exception.InstanceTypeNotFoundByName(instance_type_name=name)
@ -156,7 +156,7 @@ def get_all_flavors(ctxt=None, inactive=False, filters=None):
if ctxt is None:
ctxt = context.get_admin_context()
inst_types = db.instance_type_get_all(
inst_types = db.flavor_get_all(
ctxt, inactive=inactive, filters=filters)
inst_type_dict = {}
@ -182,7 +182,7 @@ def get_flavor(instance_type_id, ctxt=None, inactive=False):
if inactive:
ctxt = ctxt.elevated(read_deleted="yes")
return db.instance_type_get(ctxt, instance_type_id)
return db.flavor_get(ctxt, instance_type_id)
def get_flavor_by_name(name, ctxt=None):
@ -193,7 +193,7 @@ def get_flavor_by_name(name, ctxt=None):
if ctxt is None:
ctxt = context.get_admin_context()
return db.instance_type_get_by_name(ctxt, name)
return db.flavor_get_by_name(ctxt, name)
# TODO(termie): flavor-specific code should probably be in the API that uses
@ -206,7 +206,7 @@ def get_flavor_by_flavor_id(flavorid, ctxt=None, read_deleted="yes"):
if ctxt is None:
ctxt = context.get_admin_context(read_deleted=read_deleted)
return db.instance_type_get_by_flavor_id(ctxt, flavorid, read_deleted)
return db.flavor_get_by_flavor_id(ctxt, flavorid, read_deleted)
def get_flavor_access_by_flavor_id(flavorid, ctxt=None):
@ -214,7 +214,7 @@ def get_flavor_access_by_flavor_id(flavorid, ctxt=None):
if ctxt is None:
ctxt = context.get_admin_context()
return db.instance_type_access_get_by_flavor_id(ctxt, flavorid)
return db.flavor_access_get_by_flavor_id(ctxt, flavorid)
def add_flavor_access(flavorid, projectid, ctxt=None):
@ -222,7 +222,7 @@ def add_flavor_access(flavorid, projectid, ctxt=None):
if ctxt is None:
ctxt = context.get_admin_context()
return db.instance_type_access_add(ctxt, flavorid, projectid)
return db.flavor_access_add(ctxt, flavorid, projectid)
def remove_flavor_access(flavorid, projectid, ctxt=None):
@ -230,7 +230,7 @@ def remove_flavor_access(flavorid, projectid, ctxt=None):
if ctxt is None:
ctxt = context.get_admin_context()
return db.instance_type_access_remove(ctxt, flavorid, projectid)
return db.flavor_access_remove(ctxt, flavorid, projectid)
def extract_flavor(instance, prefix=''):

2
nova/conductor/manager.py
View File

@ -361,7 +361,7 @@ class ConductorManager(manager.Manager):
values)
def instance_type_get(self, context, instance_type_id):
result = self.db.instance_type_get(context, instance_type_id)
result = self.db.flavor_get(context, instance_type_id)
return jsonutils.to_primitive(result)
def instance_fault_create(self, context, values):

2
nova/scheduler/utils.py
View File

@ -37,7 +37,7 @@ def build_request_spec(ctxt, image, instances):
instance_type = flavors.extract_flavor(instance)
# NOTE(comstud): This is a bit ugly, but will get cleaned up when
# we're passing an InstanceType internal object.
extra_specs = db.instance_type_extra_specs_get(ctxt,
extra_specs = db.flavor_extra_specs_get(ctxt,
instance_type['flavorid'])
instance_type['extra_specs'] = extra_specs
request_spec = {

28
nova/tests/api/openstack/compute/contrib/test_flavors_extra_specs.py
View File

@ -62,7 +62,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
self.controller = flavorextraspecs.FlavorExtraSpecsController()
def test_index(self):
self.stubs.Set(nova.db, 'instance_type_extra_specs_get',
self.stubs.Set(nova.db, 'flavor_extra_specs_get',
return_flavor_extra_specs)
req = fakes.HTTPRequest.blank('/v2/fake/flavors/1/os-extra_specs')
@ -71,7 +71,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
self.assertEqual('value1', res_dict['extra_specs']['key1'])
def test_index_no_data(self):
self.stubs.Set(nova.db, 'instance_type_extra_specs_get',
self.stubs.Set(nova.db, 'flavor_extra_specs_get',
return_empty_flavor_extra_specs)
req = fakes.HTTPRequest.blank('/v2/fake/flavors/1/os-extra_specs')
@ -80,7 +80,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
self.assertEqual(0, len(res_dict['extra_specs']))
def test_show(self):
self.stubs.Set(nova.db, 'instance_type_extra_specs_get_item',
self.stubs.Set(nova.db, 'flavor_extra_specs_get_item',
return_flavor_extra_specs_item)
req = fakes.HTTPRequest.blank('/v2/fake/flavors/1/os-extra_specs' +
@ -90,7 +90,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
self.assertEqual('value5', res_dict['key5'])
def test_show_spec_not_found(self):
self.stubs.Set(nova.db, 'instance_type_extra_specs_get',
self.stubs.Set(nova.db, 'flavor_extra_specs_get',
return_empty_flavor_extra_specs)
req = fakes.HTTPRequest.blank('/v2/fake/flavors/1/os-extra_specs' +
@ -99,7 +99,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
req, 1, 'key6')
def test_delete(self):
self.stubs.Set(nova.db, 'instance_type_extra_specs_delete',
self.stubs.Set(nova.db, 'flavor_extra_specs_delete',
delete_flavor_extra_specs)
req = fakes.HTTPRequest.blank('/v2/fake/flavors/1/os-extra_specs' +
@ -107,7 +107,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
self.controller.delete(req, 1, 'key5')
def test_delete_no_admin(self):
self.stubs.Set(nova.db, 'instance_type_extra_specs_delete',
self.stubs.Set(nova.db, 'flavor_extra_specs_delete',
delete_flavor_extra_specs)
req = fakes.HTTPRequest.blank('/v2/fake/flavors/1/os-extra_specs' +
@ -117,7 +117,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
def test_create(self):
self.stubs.Set(nova.db,
'instance_type_extra_specs_update_or_create',
'flavor_extra_specs_update_or_create',
return_create_flavor_extra_specs)
body = {"extra_specs": {"key1": "value1"}}
@ -129,7 +129,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
def test_create_no_admin(self):
self.stubs.Set(nova.db,
'instance_type_extra_specs_update_or_create',
'flavor_extra_specs_update_or_create',
return_create_flavor_extra_specs)
body = {"extra_specs": {"key1": "value1"}}
@ -139,7 +139,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
def test_create_empty_body(self):
self.stubs.Set(nova.db,
'instance_type_extra_specs_update_or_create',
'flavor_extra_specs_update_or_create',
return_create_flavor_extra_specs)
req = fakes.HTTPRequest.blank('/v2/fake/flavors/1/os-extra_specs',
@ -149,7 +149,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
def test_update_item(self):
self.stubs.Set(nova.db,
'instance_type_extra_specs_update_or_create',
'flavor_extra_specs_update_or_create',
return_create_flavor_extra_specs)
body = {"key1": "value1"}
@ -161,7 +161,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
def test_update_item_no_admin(self):
self.stubs.Set(nova.db,
'instance_type_extra_specs_update_or_create',
'flavor_extra_specs_update_or_create',
return_create_flavor_extra_specs)
body = {"key1": "value1"}
@ -172,7 +172,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
def test_update_item_empty_body(self):
self.stubs.Set(nova.db,
'instance_type_extra_specs_update_or_create',
'flavor_extra_specs_update_or_create',
return_create_flavor_extra_specs)
req = fakes.HTTPRequest.blank('/v2/fake/flavors/1/os-extra_specs' +
@ -182,7 +182,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
def test_update_item_too_many_keys(self):
self.stubs.Set(nova.db,
'instance_type_extra_specs_update_or_create',
'flavor_extra_specs_update_or_create',
return_create_flavor_extra_specs)
body = {"key1": "value1", "key2": "value2"}
@ -193,7 +193,7 @@ class FlavorsExtraSpecsTest(test.TestCase):
def test_update_item_body_uri_mismatch(self):
self.stubs.Set(nova.db,
'instance_type_extra_specs_update_or_create',
'flavor_extra_specs_update_or_create',
return_create_flavor_extra_specs)
body = {"key1": "value1"}

8
nova/tests/api/openstack/compute/plugins/v3/test_flavors.py
View File

@ -589,16 +589,16 @@ class DisabledFlavorsWithRealDBTest(test.TestCase):
self.admin_context = context.get_admin_context()
self.disabled_type = self._create_disabled_instance_type()
self.inst_types = db.instance_type_get_all(self.admin_context)
self.inst_types = db.flavor_get_all(self.admin_context)
def tearDown(self):
db.instance_type_destroy(self.admin_context,
db.flavor_destroy(self.admin_context,
self.disabled_type['name'])
super(DisabledFlavorsWithRealDBTest, self).tearDown()
def _create_disabled_instance_type(self):
inst_types = db.instance_type_get_all(self.admin_context)
inst_types = db.flavor_get_all(self.admin_context)
inst_type = inst_types[0]
@ -608,7 +608,7 @@ class DisabledFlavorsWithRealDBTest(test.TestCase):
[int(flavor['flavorid']) for flavor in inst_types]) + 1)
inst_type['disabled'] = True
disabled_type = db.instance_type_create(self.admin_context,
disabled_type = db.flavor_create(self.admin_context,
inst_type)
return disabled_type

8
nova/tests/api/openstack/compute/test_flavors.py
View File

@ -689,17 +689,17 @@ class DisabledFlavorsWithRealDBTest(test.TestCase):
self.admin_context = context.get_admin_context()
self.disabled_type = self._create_disabled_instance_type()
self.inst_types = db.instance_type_get_all(
self.inst_types = db.flavor_get_all(
self.admin_context)
def tearDown(self):
db.instance_type_destroy(
db.flavor_destroy(
self.admin_context, self.disabled_type['name'])
super(DisabledFlavorsWithRealDBTest, self).tearDown()
def _create_disabled_instance_type(self):
inst_types = db.instance_type_get_all(self.admin_context)
inst_types = db.flavor_get_all(self.admin_context)
inst_type = inst_types[0]
@ -709,7 +709,7 @@ class DisabledFlavorsWithRealDBTest(test.TestCase):
[int(flavor['flavorid']) for flavor in inst_types]) + 1)
inst_type['disabled'] = True
disabled_type = db.instance_type_create(
disabled_type = db.flavor_create(
self.admin_context, inst_type)
return disabled_type

2
nova/tests/cells/test_cells_scheduler.py
View File

@ -92,7 +92,7 @@ class CellsSchedulerTestCase(test.TestCase):
def test_create_instances_here(self):
# Just grab the first instance type
inst_type = db.instance_type_get(self.ctxt, 1)
inst_type = db.flavor_get(self.ctxt, 1)
image = {'properties': {}}
instance_uuids = self.instance_uuids
instance_props = {'name': 'instance-00000001',

2
nova/tests/cells/test_cells_state_manager.py
View File

@ -63,7 +63,7 @@ class TestCellsStateManager(test.TestCase):
super(TestCellsStateManager, self).setUp()
self.stubs.Set(db, 'compute_node_get_all', _fake_compute_node_get_all)
self.stubs.Set(db, 'instance_type_get_all', _fake_instance_type_all)
self.stubs.Set(db, 'flavor_get_all', _fake_instance_type_all)
def test_capacity_no_reserve(self):
# utilize entire cell

18
nova/tests/compute/test_compute.py
View File

@ -311,7 +311,7 @@ class BaseTestCase(test.TestCase):
inst['swap'] = 2048
inst['rxtx_factor'] = 1
inst.update(params)
return db.instance_type_create(context, inst)['id']
return db.flavor_create(context, inst)['id']
def _create_group(self):
values = {'name': 'testgroup',
@ -3415,14 +3415,14 @@ class ComputeTestCase(BaseTestCase):
# Confirm the instance size before the resize starts
inst_ref = db.instance_get_by_uuid(self.context, instance_uuid)
instance_type_ref = db.instance_type_get(self.context,
instance_type_ref = db.flavor_get(self.context,
inst_ref['instance_type_id'])
self.assertEqual(instance_type_ref['flavorid'], '1')
new_inst_ref = db.instance_update(self.context, instance_uuid,
{'vm_state': old_vm_state})
new_instance_type_ref = db.instance_type_get_by_flavor_id(
new_instance_type_ref = db.flavor_get_by_flavor_id(
self.context, 3)
new_instance_type_p = jsonutils.to_primitive(new_instance_type_ref)
self.compute.prep_resize(self.context,
@ -3451,7 +3451,7 @@ class ComputeTestCase(BaseTestCase):
# Prove that the instance size is now the new size
rpcinst = get_primitive_instance_by_uuid(self.context, instance_uuid)
instance_type_ref = db.instance_type_get(self.context,
instance_type_ref = db.flavor_get(self.context,
rpcinst['instance_type_id'])
self.assertEqual(instance_type_ref['flavorid'], '3')
@ -3484,7 +3484,7 @@ class ComputeTestCase(BaseTestCase):
instance = get_primitive_instance_by_uuid(self.context, instance_uuid)
self.assertEqual(instance['task_state'], None)
instance_type_ref = db.instance_type_get(self.context,
instance_type_ref = db.flavor_get(self.context,
instance['instance_type_id'])
self.assertEqual(instance_type_ref['flavorid'], '3')
self.assertEqual('fake-mini', migration_ref['source_compute'])
@ -3537,7 +3537,7 @@ class ComputeTestCase(BaseTestCase):
# Confirm the instance size before the resize starts
inst_ref = db.instance_get_by_uuid(self.context, instance_uuid)
instance_type_ref = db.instance_type_get(self.context,
instance_type_ref = db.flavor_get(self.context,
inst_ref['instance_type_id'])
self.assertEqual(instance_type_ref['flavorid'], '1')
@ -3546,7 +3546,7 @@ class ComputeTestCase(BaseTestCase):
{'host': 'foo',
'vm_state': old_vm_state})
new_instance_type_ref = db.instance_type_get_by_flavor_id(
new_instance_type_ref = db.flavor_get_by_flavor_id(
self.context, 3)
new_instance_type_p = jsonutils.to_primitive(new_instance_type_ref)
self.compute.prep_resize(self.context,
@ -3575,7 +3575,7 @@ class ComputeTestCase(BaseTestCase):
# Prove that the instance size is now the new size
rpcinst = get_primitive_instance_by_uuid(self.context, instance_uuid)
instance_type_ref = db.instance_type_get(self.context,
instance_type_ref = db.flavor_get(self.context,
rpcinst['instance_type_id'])
self.assertEqual(instance_type_ref['flavorid'], '3')
@ -3612,7 +3612,7 @@ class ComputeTestCase(BaseTestCase):
instance = get_primitive_instance_by_uuid(self.context, instance_uuid)
self.assertEqual(instance['task_state'], None)
instance_type_ref = db.instance_type_get(self.context,
instance_type_ref = db.flavor_get(self.context,
instance['instance_type_id'])
self.assertEqual(instance_type_ref['flavorid'], '1')
self.assertEqual(instance['host'], migration_ref['source_compute'])

2
nova/tests/compute/test_resource_tracker.py
View File

@ -112,7 +112,7 @@ class BaseTestCase(test.TestCase):
'instance_update_and_get_original',
self._fake_instance_update_and_get_original)
self.stubs.Set(self.conductor.db,
'instance_type_get', self._fake_flavor_get)
'flavor_get', self._fake_flavor_get)
self.host = 'fakehost'

8
nova/tests/conductor/test_conductor.py
View File

@ -357,8 +357,8 @@ class _BaseTestCase(object):
fake_values)
def test_flavor_get(self):
self.mox.StubOutWithMock(db, 'instance_type_get')
db.instance_type_get(self.context, 'fake-id').AndReturn('fake-type')
self.mox.StubOutWithMock(db, 'flavor_get')
db.flavor_get(self.context, 'fake-id').AndReturn('fake-type')
self.mox.ReplayAll()
result = self.conductor.instance_type_get(self.context, 'fake-id')
self.assertEqual(result, 'fake-type')
@ -1243,11 +1243,11 @@ class _BaseTaskTestCase(object):
{'system_metadata': system_metadata})
expected_instance_type['extra_specs'] = 'fake-specs'
self.mox.StubOutWithMock(db, 'instance_type_extra_specs_get')
self.mox.StubOutWithMock(db, 'flavor_extra_specs_get')
self.mox.StubOutWithMock(self.conductor_manager.scheduler_rpcapi,
'run_instance')
db.instance_type_extra_specs_get(
db.flavor_extra_specs_get(
self.context,
instance_type['flavorid']).AndReturn('fake-specs')
self.conductor_manager.scheduler_rpcapi.run_instance(self.context,

16
nova/tests/db/fakes.py
View File

@ -228,7 +228,7 @@ def stub_out_db_network_api(stubs):
continue
fixed_ip_fields['virtual_interface'] = FakeModel(vif[0])
def fake_instance_type_get(context, id):
def fake_flavor_get(context, id):
if flavor_fields['id'] == id:
return FakeModel(flavor_fields)
@ -314,7 +314,7 @@ def stub_out_db_network_api(stubs):
fake_fixed_ip_get_by_instance,
fake_fixed_ip_get_by_address,
fake_fixed_ip_update,
fake_instance_type_get,
fake_flavor_get,
fake_virtual_interface_create,
fake_virtual_interface_delete_by_instance,
fake_virtual_interface_get_by_instance,
@ -418,13 +418,13 @@ def stub_out_db_instance_api(stubs, injected=True):
'address_v6': 'fe80::a00:3',
'network_id': 'fake_flat'}
def fake_instance_type_get_all(context, inactive=0, filters=None):
def fake_flavor_get_all(context, inactive=0, filters=None):
return INSTANCE_TYPES.values()
def fake_instance_type_get_by_name(context, name):
def fake_flavor_get_by_name(context, name):
return INSTANCE_TYPES[name]
def fake_instance_type_get(context, id):
def fake_flavor_get(context, id):
for name, inst_type in INSTANCE_TYPES.iteritems():
if str(inst_type['id']) == str(id):
return inst_type
@ -433,8 +433,8 @@ def stub_out_db_instance_api(stubs, injected=True):
def fake_fixed_ip_get_by_instance(context, instance_id):
return [FakeModel(fixed_ip_fields)]
funcs = [fake_instance_type_get_all,
fake_instance_type_get_by_name,
fake_instance_type_get,
funcs = [fake_flavor_get_all,
fake_flavor_get_by_name,
fake_flavor_get,
fake_fixed_ip_get_by_instance]
stub_out(stubs, funcs)

104
nova/tests/db/test_db_api.py
View File

@ -2023,7 +2023,7 @@ class BaseInstanceTypeTestCase(test.TestCase, ModelsObjectComparatorMixin):
def _create_inst_type(self, values):
v = self._get_base_values()
v.update(values)
return db.instance_type_create(self.ctxt, v)
return db.flavor_create(self.ctxt, v)
class InstanceActionTestCase(test.TestCase, ModelsObjectComparatorMixin):
@ -2352,7 +2352,7 @@ class InstanceFaultTestCase(test.TestCase, ModelsObjectComparatorMixin):
class InstanceTypeTestCase(BaseInstanceTypeTestCase):
def test_instance_type_create(self):
def test_flavor_create(self):
inst_type = self._create_inst_type({})
ignored_keys = ['id', 'deleted', 'deleted_at', 'updated_at',
'created_at', 'extra_specs']
@ -2369,34 +2369,34 @@ class InstanceTypeTestCase(BaseInstanceTypeTestCase):
inst_type2 = self._create_inst_type({'name': 'name2', 'flavorid': 'a2',
'extra_specs': specs2})
db.instance_type_destroy(self.ctxt, 'name1')
db.flavor_destroy(self.ctxt, 'name1')
self.assertRaises(exception.InstanceTypeNotFound,
db.instance_type_get, self.ctxt, inst_type1['id'])
real_specs1 = db.instance_type_extra_specs_get(self.ctxt,
db.flavor_get, self.ctxt, inst_type1['id'])
real_specs1 = db.flavor_extra_specs_get(self.ctxt,
inst_type1['flavorid'])
self._assertEqualObjects(real_specs1, {})
r_inst_type2 = db.instance_type_get(self.ctxt, inst_type2['id'])
r_inst_type2 = db.flavor_get(self.ctxt, inst_type2['id'])
self._assertEqualObjects(inst_type2, r_inst_type2, 'extra_specs')
def test_instance_type_destroy_not_found(self):
self.assertRaises(exception.InstanceTypeNotFound,
db.instance_type_destroy, self.ctxt, 'nonexists')
db.flavor_destroy, self.ctxt, 'nonexists')
def test_instance_type_create_duplicate_name(self):
def test_flavor_create_duplicate_name(self):
self._create_inst_type({})
self.assertRaises(exception.InstanceTypeExists,
self._create_inst_type,
{'flavorid': 'some_random_flavor'})
def test_instance_type_create_duplicate_flavorid(self):
def test_flavor_create_duplicate_flavorid(self):
self._create_inst_type({})
self.assertRaises(exception.InstanceTypeIdExists,
self._create_inst_type,
{'name': 'some_random_name'})
def test_instance_type_create_with_extra_specs(self):
def test_flavor_create_with_extra_specs(self):
extra_specs = dict(a='abc', b='def', c='ghi')
inst_type = self._create_inst_type({'extra_specs': extra_specs})
ignored_keys = ['id', 'deleted', 'deleted_at', 'updated_at',
@ -2408,8 +2408,8 @@ class InstanceTypeTestCase(BaseInstanceTypeTestCase):
def test_instance_type_get_all(self):
# NOTE(boris-42): Remove base instance types
for it in db.instance_type_get_all(self.ctxt):
db.instance_type_destroy(self.ctxt, it['name'])
for it in db.flavor_get_all(self.ctxt):
db.flavor_destroy(self.ctxt, it['name'])
instance_types = [
{'root_gb': 600, 'memory_mb': 100, 'disabled': True,
@ -2448,7 +2448,7 @@ class InstanceTypeTestCase(BaseInstanceTypeTestCase):
filt = lambda it: lambda_filters[name](it, value)
expected_it = filter(filt, expected_it)
real_it = db.instance_type_get_all(self.ctxt, filters=filters)
real_it = db.flavor_get_all(self.ctxt, filters=filters)
self._assertEqualListsOfObjects(expected_it, real_it)
#no filter
@ -2481,7 +2481,7 @@ class InstanceTypeTestCase(BaseInstanceTypeTestCase):
inst_types = [self._create_inst_type(t) for t in inst_types]
for inst_type in inst_types:
inst_type_by_id = db.instance_type_get(self.ctxt, inst_type['id'])
inst_type_by_id = db.flavor_get(self.ctxt, inst_type['id'])
self._assertEqualObjects(inst_type, inst_type_by_id)
def test_instance_type_get_non_public(self):
@ -2489,17 +2489,17 @@ class InstanceTypeTestCase(BaseInstanceTypeTestCase):
'is_public': False})
# Admin can see it
inst_type_by_id = db.instance_type_get(self.ctxt, inst_type['id'])
inst_type_by_id = db.flavor_get(self.ctxt, inst_type['id'])
self._assertEqualObjects(inst_type, inst_type_by_id)
# Regular user can not
self.assertRaises(exception.InstanceTypeNotFound, db.instance_type_get,
self.assertRaises(exception.InstanceTypeNotFound, db.flavor_get,
self.user_ctxt, inst_type['id'])
# Regular user can see it after being granted access
db.instance_type_access_add(self.ctxt, inst_type['flavorid'],
db.flavor_access_add(self.ctxt, inst_type['flavorid'],
self.user_ctxt.project_id)
inst_type_by_id = db.instance_type_get(self.user_ctxt, inst_type['id'])
inst_type_by_id = db.flavor_get(self.user_ctxt, inst_type['id'])
self._assertEqualObjects(inst_type, inst_type_by_id)
def test_instance_type_get_by_name(self):
@ -2509,33 +2509,33 @@ class InstanceTypeTestCase(BaseInstanceTypeTestCase):
inst_types = [self._create_inst_type(t) for t in inst_types]
for inst_type in inst_types:
inst_type_by_name = db.instance_type_get_by_name(self.ctxt,
inst_type_by_name = db.flavor_get_by_name(self.ctxt,
inst_type['name'])
self._assertEqualObjects(inst_type, inst_type_by_name)
def test_instance_type_get_by_name_not_found(self):
self._create_inst_type({})
self.assertRaises(exception.InstanceTypeNotFoundByName,
db.instance_type_get_by_name, self.ctxt, 'nonexists')
db.flavor_get_by_name, self.ctxt, 'nonexists')
def test_instance_type_get_by_name_non_public(self):
inst_type = self._create_inst_type({'name': 'abc', 'flavorid': '123',
'is_public': False})
# Admin can see it
inst_type_by_name = db.instance_type_get_by_name(self.ctxt,
inst_type_by_name = db.flavor_get_by_name(self.ctxt,
inst_type['name'])
self._assertEqualObjects(inst_type, inst_type_by_name)
# Regular user can not
self.assertRaises(exception.InstanceTypeNotFoundByName,
db.instance_type_get_by_name, self.user_ctxt,
db.flavor_get_by_name, self.user_ctxt,
inst_type['name'])
# Regular user can see it after being granted access
db.instance_type_access_add(self.ctxt, inst_type['flavorid'],
db.flavor_access_add(self.ctxt, inst_type['flavorid'],
self.user_ctxt.project_id)
inst_type_by_name = db.instance_type_get_by_name(self.user_ctxt,
inst_type_by_name = db.flavor_get_by_name(self.user_ctxt,
inst_type['name'])
self._assertEqualObjects(inst_type, inst_type_by_name)
@ -2547,13 +2547,13 @@ class InstanceTypeTestCase(BaseInstanceTypeTestCase):
for inst_type in inst_types:
params = (self.ctxt, inst_type['flavorid'])
inst_type_by_flavorid = db.instance_type_get_by_flavor_id(*params)
inst_type_by_flavorid = db.flavor_get_by_flavor_id(*params)
self._assertEqualObjects(inst_type, inst_type_by_flavorid)
def test_instance_type_get_by_flavor_not_found(self):
self._create_inst_type({})
self.assertRaises(exception.FlavorNotFound,
db.instance_type_get_by_flavor_id,
db.flavor_get_by_flavor_id,
self.ctxt, 'nonexists')
def test_instance_type_get_by_flavor_id_non_public(self):
@ -2561,28 +2561,28 @@ class InstanceTypeTestCase(BaseInstanceTypeTestCase):
'is_public': False})
# Admin can see it
inst_type_by_fid = db.instance_type_get_by_flavor_id(self.ctxt,
inst_type_by_fid = db.flavor_get_by_flavor_id(self.ctxt,
inst_type['flavorid'])
self._assertEqualObjects(inst_type, inst_type_by_fid)
# Regular user can not
self.assertRaises(exception.FlavorNotFound,
db.instance_type_get_by_flavor_id, self.user_ctxt,
db.flavor_get_by_flavor_id, self.user_ctxt,
inst_type['flavorid'])
# Regular user can see it after being granted access
db.instance_type_access_add(self.ctxt, inst_type['flavorid'],
db.flavor_access_add(self.ctxt, inst_type['flavorid'],
self.user_ctxt.project_id)
inst_type_by_fid = db.instance_type_get_by_flavor_id(self.user_ctxt,
inst_type_by_fid = db.flavor_get_by_flavor_id(self.user_ctxt,
inst_type['flavorid'])
self._assertEqualObjects(inst_type, inst_type_by_fid)
def test_instance_type_get_by_flavor_id_deleted(self):
inst_type = self._create_inst_type({'name': 'abc', 'flavorid': '123'})
db.instance_type_destroy(self.ctxt, 'abc')
db.flavor_destroy(self.ctxt, 'abc')
inst_type_by_fid = db.instance_type_get_by_flavor_id(self.ctxt,
inst_type_by_fid = db.flavor_get_by_flavor_id(self.ctxt,
inst_type['flavorid'], read_deleted='yes')
self.assertEqual(inst_type['id'], inst_type_by_fid['id'])
@ -2596,13 +2596,13 @@ class InstanceTypeExtraSpecsTestCase(BaseInstanceTypeTestCase):
{'name': 'n2', 'flavorid': 'f2',
'extra_specs': dict(d='d', e='e', f='f')})
# NOTE(boris-42): We have already tested instance_type_create method
# NOTE(boris-42): We have already tested flavor_create method
# with extra_specs in InstanceTypeTestCase.
self.inst_types = [self._create_inst_type(v) for v in values]
def test_instance_type_extra_specs_get(self):
for it in self.inst_types:
real_specs = db.instance_type_extra_specs_get(self.ctxt,
real_specs = db.flavor_extra_specs_get(self.ctxt,
it['flavorid'])
self._assertEqualObjects(it['extra_specs'], real_specs)
@ -2612,7 +2612,7 @@ class InstanceTypeExtraSpecsTestCase(BaseInstanceTypeTestCase):
for flavor, specs in expected.iteritems():
for key, val in specs.iteritems():
spec = db.instance_type_extra_specs_get_item(self.ctxt, flavor,
spec = db.flavor_extra_specs_get_item(self.ctxt, flavor,
key)
self.assertEqual(spec[key], val)
@ -2621,8 +2621,8 @@ class InstanceTypeExtraSpecsTestCase(BaseInstanceTypeTestCase):
specs = it['extra_specs']
key = specs.keys()[0]
del specs[key]
db.instance_type_extra_specs_delete(self.ctxt, it['flavorid'], key)
real_specs = db.instance_type_extra_specs_get(self.ctxt,
db.flavor_extra_specs_delete(self.ctxt, it['flavorid'], key)
real_specs = db.flavor_extra_specs_get(self.ctxt,
it['flavorid'])
self._assertEqualObjects(it['extra_specs'], real_specs)
@ -2631,21 +2631,21 @@ class InstanceTypeExtraSpecsTestCase(BaseInstanceTypeTestCase):
current_specs = it['extra_specs']
current_specs.update(dict(b='b1', c='c1', d='d1', e='e1'))
params = (self.ctxt, it['flavorid'], current_specs)
db.instance_type_extra_specs_update_or_create(*params)
real_specs = db.instance_type_extra_specs_get(self.ctxt,
db.flavor_extra_specs_update_or_create(*params)
real_specs = db.flavor_extra_specs_get(self.ctxt,
it['flavorid'])
self._assertEqualObjects(current_specs, real_specs)
def test_instance_type_extra_specs_update_or_create_flavor_not_found(self):
self.assertRaises(exception.FlavorNotFound,
db.instance_type_extra_specs_update_or_create,
db.flavor_extra_specs_update_or_create,
self.ctxt, 'nonexists', {})
class InstanceTypeAccessTestCase(BaseInstanceTypeTestCase):
def _create_inst_type_access(self, instance_type_id, project_id):
return db.instance_type_access_add(self.ctxt, instance_type_id,
return db.flavor_access_add(self.ctxt, instance_type_id,
project_id)
def test_instance_type_access_get_by_flavor_id(self):
@ -2660,12 +2660,12 @@ class InstanceTypeAccessTestCase(BaseInstanceTypeTestCase):
for it, access_it in zip((it1, it2), (access_it1, access_it2)):
params = (self.ctxt, it['flavorid'])
real_access_it = db.instance_type_access_get_by_flavor_id(*params)
real_access_it = db.flavor_access_get_by_flavor_id(*params)
self._assertEqualListsOfObjects(access_it, real_access_it)
def test_instance_type_access_get_by_flavor_id_flavor_not_found(self):
self.assertRaises(exception.FlavorNotFound,
db.instance_type_get_by_flavor_id,
db.flavor_get_by_flavor_id,
self.ctxt, 'nonexists')
def test_instance_type_access_add(self):
@ -2704,17 +2704,17 @@ class InstanceTypeAccessTestCase(BaseInstanceTypeTestCase):
access_it2 = [self._create_inst_type_access(it2['flavorid'], 'pr1')]
db.instance_type_access_remove(self.ctxt, it1['flavorid'],
db.flavor_access_remove(self.ctxt, it1['flavorid'],
access_it1[1]['project_id'])
for it, access_it in zip((it1, it2), (access_it1[:1], access_it2)):
params = (self.ctxt, it['flavorid'])
real_access_it = db.instance_type_access_get_by_flavor_id(*params)
real_access_it = db.flavor_access_get_by_flavor_id(*params)
self._assertEqualListsOfObjects(access_it, real_access_it)
def test_instance_type_access_remove_flavor_not_found(self):
self.assertRaises(exception.FlavorNotFound,
db.instance_type_access_remove,
db.flavor_access_remove,
self.ctxt, 'nonexists', 'does_not_matter')
def test_instance_type_access_remove_access_not_found(self):
@ -2722,7 +2722,7 @@ class InstanceTypeAccessTestCase(BaseInstanceTypeTestCase):
params = (inst_type['flavorid'], 'p1')
self._create_inst_type_access(*params)
self.assertRaises(exception.FlavorAccessNotFound,
db.instance_type_access_remove,
db.flavor_access_remove,
self.ctxt, inst_type['flavorid'], 'p2')
def test_instance_type_access_removed_after_instance_type_destroy(self):
@ -2736,14 +2736,14 @@ class InstanceTypeAccessTestCase(BaseInstanceTypeTestCase):
for v in values:
self._create_inst_type_access(*v)
db.instance_type_destroy(self.ctxt, inst_type1['name'])
db.flavor_destroy(self.ctxt, inst_type1['name'])
p = (self.ctxt, inst_type1['flavorid'])
self.assertEqual(0, len(db.instance_type_access_get_by_flavor_id(*p)))
self.assertEqual(0, len(db.flavor_access_get_by_flavor_id(*p)))
p = (self.ctxt, inst_type2['flavorid'])
self.assertEqual(1, len(db.instance_type_access_get_by_flavor_id(*p)))
db.instance_type_destroy(self.ctxt, inst_type2['name'])
self.assertEqual(0, len(db.instance_type_access_get_by_flavor_id(*p)))
self.assertEqual(1, len(db.flavor_access_get_by_flavor_id(*p)))
db.flavor_destroy(self.ctxt, inst_type2['name'])
self.assertEqual(0, len(db.flavor_access_get_by_flavor_id(*p)))
class FixedIPTestCase(BaseInstanceTypeTestCase):

2
nova/tests/test_flavors.py
View File

@ -262,7 +262,7 @@ class InstanceTypeFilteringTest(test.TestCase):
self.context = context.get_admin_context()
def assertFilterResults(self, filters, expected):
inst_types = db.instance_type_get_all(
inst_types = db.flavor_get_all(
self.context, filters=filters)
inst_names = [i['name'] for i in inst_types]
self.assertEqual(inst_names, expected)

34
nova/tests/test_instance_types_extra_specs.py
View File

@ -39,14 +39,14 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
xpus=2,
xpu_model="Tesla 2050")
values['extra_specs'] = specs
ref = db.instance_type_create(self.context,
ref = db.flavor_create(self.context,
values)
self.instance_type_id = ref["id"]
self.flavorid = ref["flavorid"]
def tearDown(self):
# Remove the instance type from the database
db.instance_type_destroy(self.context, "cg1.4xlarge")
db.flavor_destroy(self.context, "cg1.4xlarge")
super(InstanceTypeExtraSpecsTestCase, self).tearDown()
def test_instance_type_specs_get(self):
@ -55,7 +55,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
xpu_arch="fermi",
xpus="2",
xpu_model="Tesla 2050")
actual_specs = db.instance_type_extra_specs_get(
actual_specs = db.flavor_extra_specs_get(
self.context,
self.flavorid)
self.assertEquals(expected_specs, actual_specs)
@ -65,10 +65,10 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
cpu_model="Nehalem",
xpu_arch="fermi",
xpus="2")
db.instance_type_extra_specs_delete(self.context,
db.flavor_extra_specs_delete(self.context,
self.flavorid,
"xpu_model")
actual_specs = db.instance_type_extra_specs_get(
actual_specs = db.flavor_extra_specs_get(
self.context,
self.flavorid)
self.assertEquals(expected_specs, actual_specs)
@ -79,11 +79,11 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
xpu_arch="fermi",
xpus="2",
xpu_model="Tesla 2050")
db.instance_type_extra_specs_update_or_create(
db.flavor_extra_specs_update_or_create(
self.context,
self.flavorid,
dict(cpu_model="Sandy Bridge"))
actual_specs = db.instance_type_extra_specs_get(
actual_specs = db.flavor_extra_specs_get(
self.context,
self.flavorid)
self.assertEquals(expected_specs, actual_specs)
@ -92,7 +92,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
extra_specs = dict(cpu_arch="x86_64")
nonexisting_flavorid = "some_flavor_that_doesnt_exists"
self.assertRaises(exception.FlavorNotFound,
db.instance_type_extra_specs_update_or_create,
db.flavor_extra_specs_update_or_create,
self.context, nonexisting_flavorid, extra_specs)
def test_instance_type_extra_specs_create(self):
@ -103,18 +103,18 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
xpu_model="Tesla 2050",
net_arch="ethernet",
net_mbps="10000")
db.instance_type_extra_specs_update_or_create(
db.flavor_extra_specs_update_or_create(
self.context,
self.flavorid,
dict(net_arch="ethernet",
net_mbps=10000))
actual_specs = db.instance_type_extra_specs_get(
actual_specs = db.flavor_extra_specs_get(
self.context,
self.flavorid)
self.assertEquals(expected_specs, actual_specs)
def test_instance_type_get_with_extra_specs(self):
instance_type = db.instance_type_get(
instance_type = db.flavor_get(
self.context,
self.instance_type_id)
self.assertEquals(instance_type['extra_specs'],
@ -123,13 +123,13 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
xpu_arch="fermi",
xpus="2",
xpu_model="Tesla 2050"))
instance_type = db.instance_type_get(
instance_type = db.flavor_get(
self.context,
5)
self.assertEquals(instance_type['extra_specs'], {})
def test_instance_type_get_by_name_with_extra_specs(self):
instance_type = db.instance_type_get_by_name(
instance_type = db.flavor_get_by_name(
self.context,
"cg1.4xlarge")
self.assertEquals(instance_type['extra_specs'],
@ -139,13 +139,13 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
xpus="2",
xpu_model="Tesla 2050"))
instance_type = db.instance_type_get_by_name(
instance_type = db.flavor_get_by_name(
self.context,
"m1.small")
self.assertEquals(instance_type['extra_specs'], {})
def test_instance_type_get_by_flavor_id_with_extra_specs(self):
instance_type = db.instance_type_get_by_flavor_id(
instance_type = db.flavor_get_by_flavor_id(
self.context,
105)
self.assertEquals(instance_type['extra_specs'],
@ -155,7 +155,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
xpus="2",
xpu_model="Tesla 2050"))
instance_type = db.instance_type_get_by_flavor_id(
instance_type = db.flavor_get_by_flavor_id(
self.context,
2)
self.assertEquals(instance_type['extra_specs'], {})
@ -167,7 +167,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
xpus='2',
xpu_model="Tesla 2050")
types = db.instance_type_get_all(self.context)
types = db.flavor_get_all(self.context)
name2specs = {}
for instance_type in types:

14
nova/tests/test_nova_manage.py
View File

@ -290,7 +290,7 @@ class InstanceTypeCommandsTestCase(test.TestCase):
root_gb=16,
ephemeral_gb=32,
flavorid=105)
ref = db.instance_type_create(context.get_admin_context(),
ref = db.flavor_create(context.get_admin_context(),
values)
self.instance_type_name = ref["name"]
self.instance_type_id = ref["id"]
@ -299,13 +299,13 @@ class InstanceTypeCommandsTestCase(test.TestCase):
self.unset_key = manage.InstanceTypeCommands().unset_key
def tearDown(self):
db.instance_type_destroy(context.get_admin_context(),
db.flavor_destroy(context.get_admin_context(),
"test.small")
super(InstanceTypeCommandsTestCase, self).tearDown()
def _test_extra_specs_empty(self):
empty_specs = {}
actual_specs = db.instance_type_extra_specs_get(
actual_specs = db.flavor_extra_specs_get(
context.get_admin_context(),
self.instance_type_id)
self.assertEquals(empty_specs, actual_specs)
@ -316,7 +316,7 @@ class InstanceTypeCommandsTestCase(test.TestCase):
self._test_extra_specs_empty()
self.set_key(self.instance_type_name, "k1", "v1")
actual_specs = db.instance_type_extra_specs_get(
actual_specs = db.flavor_extra_specs_get(
context.get_admin_context(),
self.instance_type_flavorid)
self.assertEquals(expected_specs, actual_specs)
@ -331,13 +331,13 @@ class InstanceTypeCommandsTestCase(test.TestCase):
self._test_extra_specs_empty()
self.set_key(self.instance_type_name, "k1", "v1")
actual_specs = db.instance_type_extra_specs_get(
actual_specs = db.flavor_extra_specs_get(
context.get_admin_context(),
self.instance_type_flavorid)
self.assertEquals(expected_specs, actual_specs)
self.set_key(self.instance_type_name, "k1", "v2")
actual_specs = db.instance_type_extra_specs_get(
actual_specs = db.flavor_extra_specs_get(
context.get_admin_context(),
self.instance_type_flavorid)
self.assertEquals(updated_specs, actual_specs)
@ -352,7 +352,7 @@ class InstanceTypeCommandsTestCase(test.TestCase):
self.set_key(self.instance_type_name, "k1", "v1")
self.set_key(self.instance_type_name, "k3", "v3")
actual_specs = db.instance_type_extra_specs_get(
actual_specs = db.flavor_extra_specs_get(
context.get_admin_context(),
self.instance_type_flavorid)
self.assertEquals(two_items_extra_specs, actual_specs)

4
nova/tests/utils.py
View File

@ -58,10 +58,10 @@ def get_test_instance_type(context=None):
'ephemeral_gb': 80,
'swap': 1024}
try:
instance_type_ref = nova.db.instance_type_create(context,
instance_type_ref = nova.db.flavor_create(context,
test_instance_type)
except (exception.InstanceTypeExists, exception.InstanceTypeIdExists):
instance_type_ref = nova.db.instance_type_get_by_name(context,
instance_type_ref = nova.db.flavor_get_by_name(context,
'kinda.big')
return instance_type_ref

4
nova/tests/virt/hyperv/db_fakes.py
View File

@ -162,7 +162,7 @@ def stub_out_db_instance_api(stubs):
return {}
stubs.Set(db, 'instance_create', fake_instance_create)
stubs.Set(db, 'instance_type_get_all', fake_instance_type_get_all)
stubs.Set(db, 'instance_type_get_by_name', fake_instance_type_get_by_name)
stubs.Set(db, 'flavor_get_all', fake_instance_type_get_all)
stubs.Set(db, 'flavor_get_by_name', fake_instance_type_get_by_name)
stubs.Set(db, 'block_device_mapping_get_all_by_instance',
fake_block_device_mapping_get_all_by_instance)

2
nova/tests/virt/hyperv/test_hypervapi.py
View File

@ -1088,7 +1088,7 @@ class HyperVAPITestCase(test.TestCase):
else:
flavor = 'm1.small'
instance_type = db.instance_type_get_by_name(self._context, flavor)
instance_type = db.flavor_get_by_name(self._context, flavor)
if not size_exception:
fake_root_vhd_path = 'C:\\FakePath\\root.vhd'

6
nova/tests/virt/libvirt/test_libvirt.py
View File

@ -331,7 +331,7 @@ class LibvirtConnTestCase(test.TestCase):
self.stubs.Set(libvirt_driver.LibvirtDriver, '_connect',
lambda *a, **k: self.conn)
instance_type = db.instance_type_get(self.context, 5)
instance_type = db.flavor_get(self.context, 5)
sys_meta = flavors.save_flavor_info({}, instance_type)
nova.tests.image.fake.stub_out_image_service(self.stubs)
@ -2802,7 +2802,7 @@ class LibvirtConnTestCase(test.TestCase):
instance_ref = self.test_instance
instance_ref['image_ref'] = 123456 # we send an int to test sha1 call
instance_type = db.instance_type_get(self.context,
instance_type = db.flavor_get(self.context,
instance_ref['instance_type_id'])
sys_meta = flavors.save_flavor_info({}, instance_type)
instance_ref['system_metadata'] = sys_meta
@ -4726,7 +4726,7 @@ class NWFilterTestCase(test.TestCase):
inst['swap'] = '2048'
inst['rxtx_factor'] = 1
inst.update(params)
return db.instance_type_create(context, inst)['id']
return db.flavor_create(context, inst)['id']
def test_creates_base_rule_first(self):
# These come pre-defined by libvirt

2
nova/tests/virt/libvirt/test_libvirt_blockinfo.py
View File

@ -33,7 +33,7 @@ class LibvirtBlockInfoTest(test.TestCase):
self.user_id = 'fake'
self.project_id = 'fake'
self.context = context.get_admin_context()
instance_type = db.instance_type_get(self.context, 2)
instance_type = db.flavor_get(self.context, 2)
sys_meta = flavors.save_flavor_info({}, instance_type)
nova.tests.image.fake.stub_out_image_service(self.stubs)
self.test_instance = {

2
nova/tests/virt/powervm/test_powervm.py
View File

@ -180,7 +180,7 @@ def fake_get_powervm_operator():
def create_instance(testcase):
fake.stub_out_image_service(testcase.stubs)
ctxt = context.get_admin_context()
instance_type = db.instance_type_get(ctxt, 1)
instance_type = db.flavor_get(ctxt, 1)
sys_meta = flavors.save_flavor_info({}, instance_type)
return db.instance_create(ctxt,
{'user_id': 'fake',

8
nova/tests/virt/vmwareapi/db_fakes.py
View File

@ -79,12 +79,12 @@ def stub_out_db_instance_api(stubs):
}
return FakeModel(base_options)
def fake_instance_type_get_all(context, inactive=0, filters=None):
def fake_flavor_get_all(context, inactive=0, filters=None):
return INSTANCE_TYPES.values()
def fake_instance_type_get_by_name(context, name):
def fake_flavor_get_by_name(context, name):
return INSTANCE_TYPES[name]
stubs.Set(db, 'instance_create', fake_instance_create)
stubs.Set(db, 'instance_type_get_all', fake_instance_type_get_all)
stubs.Set(db, 'instance_type_get_by_name', fake_instance_type_get_by_name)
stubs.Set(db, 'flavor_get_all', fake_flavor_get_all)
stubs.Set(db, 'flavor_get_by_name', fake_flavor_get_by_name)

2
nova/tests/virt/vmwareapi/test_vmwareapi.py
View File

@ -154,7 +154,7 @@ class VMwareAPIVMTestCase(test.TestCase):
def _create_vm(self):
"""Create and spawn the VM."""
self._create_instance_in_the_db()
self.type_data = db.instance_type_get_by_name(None, 'm1.large')
self.type_data = db.flavor_get_by_name(None, 'm1.large')
self.conn.spawn(self.context, self.instance, self.image,
injected_files=[], admin_password=None,
network_info=self.network_info,

12
nova/tests/virt/xenapi/test_xenapi.py
View File

@ -182,7 +182,7 @@ def stub_vm_utils_with_vdi_attached_here(function, should_return=True):
def create_instance_with_system_metadata(context, instance_values):
instance_type = db.instance_type_get(context,
instance_type = db.flavor_get(context,
instance_values['instance_type_id'])
sys_meta = flavors.save_flavor_info({},
instance_type)
@ -586,7 +586,7 @@ class XenAPIVMTestCase(stubs.XenAPITestBase):
def check_vm_record(self, conn, check_injection=False):
# Check that m1.large above turned into the right thing.
instance_type = db.instance_type_get_by_name(conn, 'm1.large')
instance_type = db.flavor_get_by_name(conn, 'm1.large')
mem_kib = long(instance_type['memory_mb']) << 10
mem_bytes = str(mem_kib << 10)
vcpus = instance_type['vcpus']
@ -1511,7 +1511,7 @@ class XenAPIMigrateInstance(stubs.XenAPITestBase):
def test_migrate_disk_and_power_off(self):
instance = db.instance_create(self.context, self.instance_values)
xenapi_fake.create_vm(instance['name'], 'Running')
instance_type = db.instance_type_get_by_name(self.context, 'm1.large')
instance_type = db.flavor_get_by_name(self.context, 'm1.large')
conn = xenapi_conn.XenAPIDriver(fake.FakeVirtAPI(), False)
conn.migrate_disk_and_power_off(self.context, instance,
'127.0.0.1', instance_type, None)
@ -1519,7 +1519,7 @@ class XenAPIMigrateInstance(stubs.XenAPITestBase):
def test_migrate_disk_and_power_off_passes_exceptions(self):
instance = db.instance_create(self.context, self.instance_values)
xenapi_fake.create_vm(instance['name'], 'Running')
instance_type = db.instance_type_get_by_name(self.context, 'm1.large')
instance_type = db.flavor_get_by_name(self.context, 'm1.large')
def fake_raise(*args, **kwargs):
raise exception.MigrationError(reason='test failure')
@ -1661,7 +1661,7 @@ class XenAPIMigrateInstance(stubs.XenAPITestBase):
instance_values['root_gb'] = 40
instance = db.instance_create(self.context, instance_values)
xenapi_fake.create_vm(instance['name'], 'Running')
instance_type = db.instance_type_get_by_name(self.context, 'm1.small')
instance_type = db.flavor_get_by_name(self.context, 'm1.small')
conn = xenapi_conn.XenAPIDriver(fake.FakeVirtAPI(), False)
def fake_get_partitions(partition):
@ -1680,7 +1680,7 @@ class XenAPIMigrateInstance(stubs.XenAPITestBase):
instance_values['root_gb'] = 40
instance = db.instance_create(self.context, instance_values)
xenapi_fake.create_vm(instance['name'], 'Running')
instance_type = db.instance_type_get_by_name(self.context, 'm1.small')
instance_type = db.flavor_get_by_name(self.context, 'm1.small')
conn = xenapi_conn.XenAPIDriver(fake.FakeVirtAPI(), False)
def fake_get_partitions(partition):