openstack
/
nova
Code Issues Proposed changes

Merge "Remove old flavor_get_all db api method"

This commit is contained in:
Zuul 2018-03-20 18:10:54 +00:00 committed by Gerrit Code Review
parent af5e3eb610 233cebc3ef
commit b35cb34faa
5 changed files with 0 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
nova/db/api.py
View File

@ -1519,14 +1519,6 @@ def flavor_create(context, values, projects=None):
"""Create a new instance type."""
return IMPL.flavor_create(context, values, projects=projects)
def flavor_get_all(context, inactive=False, filters=None, sort_key='flavorid',
sort_dir='asc', limit=None, marker=None):
"""Get all instance flavors."""
return IMPL.flavor_get_all(
context, inactive=inactive, filters=filters, sort_key=sort_key,
sort_dir=sort_dir, limit=limit, marker=marker)
####################

72
nova/db/sqlalchemy/api.py
View File

@ -4632,78 +4632,6 @@ def _dict_with_extra_specs(inst_type_query):
return inst_type_dict
def _flavor_get_query(context, read_deleted=None):
query = model_query(context, models.InstanceTypes,
read_deleted=read_deleted).\
options(joinedload('extra_specs'))
if not context.is_admin:
the_filter = [models.InstanceTypes.is_public == true()]
the_filter.extend([
models.InstanceTypes.projects.any(project_id=context.project_id)
])
query = query.filter(or_(*the_filter))
return query
@require_context
@pick_context_manager_reader
def flavor_get_all(context, inactive=False, filters=None,
sort_key='flavorid', sort_dir='asc', limit=None,
marker=None):
"""Returns all flavors.
"""
filters = filters or {}
# FIXME(sirp): now that we have the `disabled` field for flavors, we
# should probably remove the use of `deleted` to mark inactive. `deleted`
# should mean truly deleted, e.g. we can safely purge the record out of the
# database.
read_deleted = "yes" if inactive else "no"
query = _flavor_get_query(context, read_deleted=read_deleted)
if 'min_memory_mb' in filters:
query = query.filter(
models.InstanceTypes.memory_mb >= filters['min_memory_mb'])
if 'min_root_gb' in filters:
query = query.filter(
models.InstanceTypes.root_gb >= filters['min_root_gb'])
if 'disabled' in filters:
query = query.filter(
models.InstanceTypes.disabled == filters['disabled'])
if 'is_public' in filters and filters['is_public'] is not None:
the_filter = [models.InstanceTypes.is_public == filters['is_public']]
if filters['is_public'] and context.project_id is not None:
the_filter.extend([
models.InstanceTypes.projects.any(
project_id=context.project_id, deleted=0)
])
if len(the_filter) > 1:
query = query.filter(or_(*the_filter))
else:
query = query.filter(the_filter[0])
marker_row = None
if marker is not None:
marker_row = _flavor_get_query(context, read_deleted=read_deleted).\
filter_by(flavorid=marker).\
first()
if not marker_row:
raise exception.MarkerNotFound(marker=marker)
query = sqlalchemyutils.paginate_query(query, models.InstanceTypes, limit,
[sort_key, 'id'],
marker=marker_row,
sort_dir=sort_dir)
inst_types = query.all()
return [_dict_with_extra_specs(i) for i in inst_types]
####################

10
nova/tests/functional/db/test_flavor.py
View File

@ -152,16 +152,6 @@ class FlavorObjectTestCase(test.NoDBTestCase):
self.assertEqual(expect_len, len(flavors))
return flavors
def test_get_all(self):
expect_len = len(db_api.flavor_get_all(self.context))
self._test_get_all(expect_len)
def test_get_all_with_some_api_flavors(self):
expect_len = len(db_api.flavor_get_all(self.context))
flavor = objects.Flavor(context=self.context, **fake_api_flavor)
flavor.create()
self._test_get_all(expect_len + 1)
def test_get_all_with_all_api_flavors(self):
flavor = objects.Flavor(context=self.context, **fake_api_flavor)
flavor.create()

123
nova/tests/unit/db/test_db_api.py
View File

@ -4080,129 +4080,6 @@ class InstanceTypeTestCase(BaseInstanceTypeTestCase):
ignored_keys)
self._assertEqualObjects(extra_specs, flavor['extra_specs'])
def test_flavor_get_all(self):
flavors = [
{'root_gb': 600, 'memory_mb': 100, 'disabled': True,
'is_public': True, 'name': 'a1', 'flavorid': 'f1'},
{'root_gb': 500, 'memory_mb': 200, 'disabled': True,
'is_public': True, 'name': 'a2', 'flavorid': 'f2'},
{'root_gb': 400, 'memory_mb': 300, 'disabled': False,
'is_public': True, 'name': 'a3', 'flavorid': 'f3'},
{'root_gb': 300, 'memory_mb': 400, 'disabled': False,
'is_public': False, 'name': 'a4', 'flavorid': 'f4'},
{'root_gb': 200, 'memory_mb': 500, 'disabled': True,
'is_public': False, 'name': 'a5', 'flavorid': 'f5'},
{'root_gb': 100, 'memory_mb': 600, 'disabled': True,
'is_public': False, 'name': 'a6', 'flavorid': 'f6'}
]
flavors = [self._create_flavor(it) for it in flavors]
lambda_filters = {
'min_memory_mb': lambda it, v: it['memory_mb'] >= v,
'min_root_gb': lambda it, v: it['root_gb'] >= v,
'disabled': lambda it, v: it['disabled'] == v,
'is_public': lambda it, v: (v is None or it['is_public'] == v)
}
mem_filts = [{'min_memory_mb': x} for x in [100, 350, 550, 650]]
root_filts = [{'min_root_gb': x} for x in [100, 350, 550, 650]]
disabled_filts = [{'disabled': x} for x in [True, False]]
is_public_filts = [{'is_public': x} for x in [True, False, None]]
def assert_multi_filter_flavor_get(filters=None):
if filters is None:
filters = {}
expected_it = flavors
for name, value in filters.items():
filt = lambda it: lambda_filters[name](it, value)
expected_it = list(filter(filt, expected_it))
real_it = db.flavor_get_all(self.ctxt, filters=filters)
self._assertEqualListsOfObjects(expected_it, real_it)
# no filter
assert_multi_filter_flavor_get()
# test only with one filter
for filt in mem_filts:
assert_multi_filter_flavor_get(filt)
for filt in root_filts:
assert_multi_filter_flavor_get(filt)
for filt in disabled_filts:
assert_multi_filter_flavor_get(filt)
for filt in is_public_filts:
assert_multi_filter_flavor_get(filt)
# test all filters together
for mem in mem_filts:
for root in root_filts:
for disabled in disabled_filts:
for is_public in is_public_filts:
filts = {}
for f in (mem, root, disabled, is_public):
filts.update(f)
assert_multi_filter_flavor_get(filts)
def test_flavor_get_all_limit_sort(self):
def assert_sorted_by_key_dir(sort_key, asc=True):
sort_dir = 'asc' if asc else 'desc'
results = db.flavor_get_all(self.ctxt, sort_key='name',
sort_dir=sort_dir)
# Manually sort the results as we would expect them
expected_results = sorted(results,
key=lambda item: item['name'],
reverse=(not asc))
self.assertEqual(expected_results, results)
def assert_sorted_by_key_both_dir(sort_key):
assert_sorted_by_key_dir(sort_key, True)
assert_sorted_by_key_dir(sort_key, False)
for attr in ['memory_mb', 'root_gb', 'deleted_at', 'name', 'deleted',
'created_at', 'ephemeral_gb', 'updated_at', 'disabled',
'vcpus', 'swap', 'rxtx_factor', 'is_public', 'flavorid',
'vcpu_weight', 'id']:
assert_sorted_by_key_both_dir(attr)
def test_flavor_get_all_limit(self):
flavors = [
{'root_gb': 1, 'memory_mb': 100, 'disabled': True,
'is_public': False, 'name': 'flavor1', 'flavorid': 'flavor1'},
{'root_gb': 100, 'memory_mb': 200, 'disabled': True,
'is_public': False, 'name': 'flavor2', 'flavorid': 'flavor2'},
{'root_gb': 100, 'memory_mb': 300, 'disabled': True,
'is_public': False, 'name': 'flavor3', 'flavorid': 'flavor3'},
]
flavors = [self._create_flavor(it) for it in flavors]
limited_flavors = db.flavor_get_all(self.ctxt, limit=2)
self.assertEqual(2, len(limited_flavors))
def test_flavor_get_all_list_marker(self):
flavors = [
{'root_gb': 1, 'memory_mb': 100, 'disabled': True,
'is_public': False, 'name': 'flavor1', 'flavorid': 'flavor1'},
{'root_gb': 100, 'memory_mb': 200, 'disabled': True,
'is_public': False, 'name': 'flavor2', 'flavorid': 'flavor2'},
{'root_gb': 100, 'memory_mb': 300, 'disabled': True,
'is_public': False, 'name': 'flavor3', 'flavorid': 'flavor3'},
]
flavors = [self._create_flavor(it) for it in flavors]
all_flavors = db.flavor_get_all(self.ctxt)
# Set the 3rd result as the marker
marker_flavorid = all_flavors[2]['flavorid']
marked_flavors = db.flavor_get_all(self.ctxt, marker=marker_flavorid)
# We expect everything /after/ the 3rd result
expected_results = all_flavors[3:]
self.assertEqual(expected_results, marked_flavors)
def test_flavor_get_all_marker_not_found(self):
self.assertRaises(exception.MarkerNotFound,
db.flavor_get_all, self.ctxt, marker='invalid')
@mock.patch('time.sleep', new=lambda x: None)
class FixedIPTestCase(BaseInstanceTypeTestCase):

2
nova/tests/unit/test_flavors.py
View File

@ -274,8 +274,6 @@ class CreateInstanceTypeTest(test.TestCase):
self.assertEqual(1.1, flavor.rxtx_factor)
def test_rxtx_factor_must_be_within_sql_float_range(self):
_context = context.get_admin_context()
db.flavor_get_all(_context)
# We do * 10 since this is an approximation and we need to make sure
# the difference is noticeble.
over_rxtx_factor = db.SQL_SP_FLOAT_MAX * 10