openstack/nova
Code Issues Proposed changes

Merge "Remove remaining legacy DB API instance_group* methods"

Browse Source
This commit is contained in:
Zuul
2018-07-04 17:36:41 +00:00
committed by Gerrit Code Review
parent a976a6e2b1 683fbe3c84
commit e019be3724
5 changed files with 2 additions and 486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
nova/db/api.py
View File

@@ -905,43 +905,6 @@ def instance_remove_security_group(context, instance_id, security_group_id):
####################
def instance_group_create(context, values, policies=None, members=None):
"""Create a new group.
Each group will receive a unique uuid. This will be used for access to the
group.
"""
return IMPL.instance_group_create(context, values, policies, members)
def instance_group_get(context, group_uuid):
"""Get a specific group by id."""
return IMPL.instance_group_get(context, group_uuid)
def instance_group_get_by_instance(context, instance_uuid):
"""Get the group an instance is a member of."""
return IMPL.instance_group_get_by_instance(context, instance_uuid)
def instance_group_update(context, group_uuid, values):
"""Update the attributes of an group."""
return IMPL.instance_group_update(context, group_uuid, values)
def instance_group_get_all(context):
"""Get all groups."""
return IMPL.instance_group_get_all(context)
def instance_group_get_all_by_project_id(context, project_id):
"""Get all groups for a specific project_id."""
return IMPL.instance_group_get_all_by_project_id(context, project_id)
###################
def instance_info_cache_get(context, instance_uuid):
"""Gets an instance info cache from the table.

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

@@ -5670,208 +5670,6 @@ def service_uuids_online_data_migration(context, max_count):
####################
def _instance_group_get_query(context, model_class, id_field=None, id=None,
read_deleted=None):
columns_to_join = {models.InstanceGroup: ['_policies', '_members']}
query = model_query(context, model_class, read_deleted=read_deleted,
project_only=True)
for c in columns_to_join.get(model_class, []):
query = query.options(joinedload(c))
if id and id_field:
query = query.filter(id_field == id)
return query
@pick_context_manager_writer
def instance_group_create(context, values, policies=None, members=None):
"""Create a new group."""
uuid = values.get('uuid', None)
if uuid is None:
uuid = uuidutils.generate_uuid()
values['uuid'] = uuid
try:
group = models.InstanceGroup()
group.update(values)
group.save(context.session)
except db_exc.DBDuplicateEntry:
raise exception.InstanceGroupIdExists(group_uuid=uuid)
# We don't want '_policies' and '_members' attributes to be lazy loaded
# later. We know there is nothing here since we just created this
# instance group.
if policies:
_instance_group_policies_add(context, group.id, policies)
else:
group._policies = []
if members:
_instance_group_members_add(context, group.id, members)
else:
group._members = []
return instance_group_get(context, uuid)
@pick_context_manager_reader
def instance_group_get(context, group_uuid):
"""Get a specific group by uuid."""
group = _instance_group_get_query(context,
models.InstanceGroup,
models.InstanceGroup.uuid,
group_uuid).\
first()
if not group:
raise exception.InstanceGroupNotFound(group_uuid=group_uuid)
return group
@pick_context_manager_reader
def instance_group_get_by_instance(context, instance_uuid):
group_member = model_query(context, models.InstanceGroupMember).\
filter_by(instance_id=instance_uuid).\
first()
if not group_member:
raise exception.InstanceGroupNotFound(group_uuid='')
group = _instance_group_get_query(context, models.InstanceGroup,
models.InstanceGroup.id,
group_member.group_id).first()
if not group:
raise exception.InstanceGroupNotFound(
group_uuid=group_member.group_id)
return group
@pick_context_manager_writer
def instance_group_update(context, group_uuid, values):
"""Update the attributes of a group.
If values contains a metadata key, it updates the aggregate metadata
too. Similarly for the policies and members.
"""
group = model_query(context, models.InstanceGroup).\
filter_by(uuid=group_uuid).\
first()
if not group:
raise exception.InstanceGroupNotFound(group_uuid=group_uuid)
policies = values.get('policies')
if policies is not None:
_instance_group_policies_add(context,
group.id,
values.pop('policies'),
set_delete=True)
members = values.get('members')
if members is not None:
_instance_group_members_add(context,
group.id,
values.pop('members'),
set_delete=True)
group.update(values)
if policies:
values['policies'] = policies
if members:
values['members'] = members
@pick_context_manager_reader
def instance_group_get_all(context):
"""Get all groups."""
return _instance_group_get_query(context, models.InstanceGroup).all()
@pick_context_manager_reader
def instance_group_get_all_by_project_id(context, project_id):
"""Get all groups."""
return _instance_group_get_query(context, models.InstanceGroup).\
filter_by(project_id=project_id).\
all()
def _instance_group_count_by_project_and_user(context, project_id, user_id):
return model_query(context, models.InstanceGroup, read_deleted="no").\
filter_by(project_id=project_id).\
filter_by(user_id=user_id).\
count()
def _instance_group_model_get_query(context, model_class, group_id,
read_deleted='no'):
return model_query(context,
model_class,
read_deleted=read_deleted).\
filter_by(group_id=group_id)
def _instance_group_id(context, group_uuid):
"""Returns the group database ID for the group UUID."""
result = model_query(context,
models.InstanceGroup,
(models.InstanceGroup.id,)).\
filter_by(uuid=group_uuid).\
first()
if not result:
raise exception.InstanceGroupNotFound(group_uuid=group_uuid)
return result.id
def _instance_group_members_add(context, id, members, set_delete=False):
all_members = set(members)
query = _instance_group_model_get_query(context,
models.InstanceGroupMember, id)
if set_delete:
query.filter(~models.InstanceGroupMember.instance_id.in_(
all_members)).\
soft_delete(synchronize_session=False)
query = query.filter(
models.InstanceGroupMember.instance_id.in_(all_members))
already_existing = set()
for member_ref in query.all():
already_existing.add(member_ref.instance_id)
for instance_id in members:
if instance_id in already_existing:
continue
member_ref = models.InstanceGroupMember()
member_ref.update({'instance_id': instance_id,
'group_id': id})
context.session.add(member_ref)
return members
def _instance_group_policies_add(context, id, policies, set_delete=False):
allpols = set(policies)
query = _instance_group_model_get_query(context,
models.InstanceGroupPolicy, id)
if set_delete:
query.filter(~models.InstanceGroupPolicy.policy.in_(allpols)).\
soft_delete(synchronize_session=False)
query = query.filter(models.InstanceGroupPolicy.policy.in_(allpols))
already_existing = set()
for policy_ref in query.all():
already_existing.add(policy_ref.policy)
for policy in policies:
if policy in already_existing:
continue
policy_ref = models.InstanceGroupPolicy()
policy_ref.update({'policy': policy,
'group_id': id})
context.session.add(policy_ref)
return policies
####################
@pick_context_manager_reader
def pci_device_get_by_addr(context, node_id, dev_addr):
pci_dev_ref = model_query(context, models.PciDevice).\

61
nova/tests/functional/db/test_instance_group_model.py
View File

@@ -1,61 +0,0 @@
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from nova.db.sqlalchemy import api_models
from nova.db.sqlalchemy import models
from nova import test
# TODO(mriedem): Drop this test when the "main" DB instance group API
# methods are all removed.
class InstanceGroupTablesCompareTestCase(test.NoDBTestCase):
def _get_column_list(self, model):
column_list = [m.key for m in model.__table__.columns]
return column_list
def _check_column_list(self,
columns_new,
columns_old,
added=None,
removed=None):
for c in added or []:
columns_new.remove(c)
for c in removed or []:
columns_old.remove(c)
intersect = set(columns_new).intersection(set(columns_old))
if intersect != set(columns_new) or intersect != set(columns_old):
return False
return True
def _compare_models(self, m_a, m_b,
added=None, removed=None):
added = added or []
removed = removed or ['deleted_at', 'deleted']
c_a = self._get_column_list(m_a)
c_b = self._get_column_list(m_b)
self.assertTrue(self._check_column_list(c_a, c_b,
added=added,
removed=removed))
def test_tables_instance_groups(self):
self._compare_models(api_models.InstanceGroup(),
models.InstanceGroup())
def test_tables_instance_group_policy(self):
self._compare_models(api_models.InstanceGroupPolicy(),
models.InstanceGroupPolicy())
def test_tables_instance_group_member(self):
self._compare_models(api_models.InstanceGroupMember(),
models.InstanceGroupMember(),
added=['instance_uuid'],
removed=['deleted_at', 'deleted', 'instance_id'])

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

@@ -8509,191 +8509,6 @@ class ArchiveTestCase(test.TestCase, ModelsObjectComparatorMixin):
)
class InstanceGroupDBApiTestCase(test.TestCase, ModelsObjectComparatorMixin):
def setUp(self):
super(InstanceGroupDBApiTestCase, self).setUp()
self.user_id = 'fake_user'
self.project_id = 'fake_project'
self.new_user_id = 'new_user_id'
self.new_project_id = 'new_project_id'
self.context = context.RequestContext(self.user_id, self.project_id)
self.new_context = context.RequestContext(self.new_user_id,
self.new_project_id)
def _get_default_values(self):
return {'name': 'fake_name',
'user_id': self.user_id,
'project_id': self.project_id}
def _get_new_default_values(self):
return {'name': 'fake_new_name',
'user_id': self.new_user_id,
'project_id': self.new_project_id}
def _create_instance_group(self, context, values, policies=None,
members=None):
return db.instance_group_create(context, values, policies=policies,
members=members)
def test_instance_group_create_no_key(self):
values = self._get_default_values()
result = self._create_instance_group(self.context, values)
ignored_keys = ['id', 'uuid', 'deleted', 'deleted_at', 'updated_at',
'created_at']
self._assertEqualObjects(result, values, ignored_keys)
self.assertTrue(uuidutils.is_uuid_like(result['uuid']))
def test_instance_group_create_with_key(self):
values = self._get_default_values()
values['uuid'] = 'fake_id'
result = self._create_instance_group(self.context, values)
ignored_keys = ['id', 'deleted', 'deleted_at', 'updated_at',
'created_at']
self._assertEqualObjects(result, values, ignored_keys)
def test_instance_group_create_with_same_key(self):
values = self._get_default_values()
values['uuid'] = 'fake_id'
self._create_instance_group(self.context, values)
self.assertRaises(exception.InstanceGroupIdExists,
self._create_instance_group, self.context, values)
def test_instance_group_get(self):
values = self._get_default_values()
result1 = self._create_instance_group(self.context, values)
result2 = db.instance_group_get(self.context, result1['uuid'])
self._assertEqualObjects(result1, result2)
def test_instance_group_update_simple(self):
values = self._get_default_values()
result1 = self._create_instance_group(self.context, values)
values = {'name': 'new_name'}
db.instance_group_update(self.context, result1['uuid'],
values)
result2 = db.instance_group_get(self.context, result1['uuid'])
self.assertEqual(result1['uuid'], result2['uuid'])
ignored_keys = ['id', 'uuid', 'deleted', 'deleted_at', 'updated_at',
'created_at', 'project_id', 'user_id']
self._assertEqualObjects(result2, values, ignored_keys)
def test_instance_group_get_nonexistent(self):
self.assertRaises(exception.InstanceGroupNotFound,
db.instance_group_get,
self.context,
'nonexistent')
def test_instance_group_get_all(self):
groups = db.instance_group_get_all(self.context)
self.assertEqual(0, len(groups))
value = self._get_default_values()
result1 = self._create_instance_group(self.context, value)
groups = db.instance_group_get_all(self.context)
self.assertEqual(1, len(groups))
value = self._get_default_values()
result2 = self._create_instance_group(self.context, value)
groups = db.instance_group_get_all(self.context)
results = [result1, result2]
self._assertEqualListsOfObjects(results, groups)
def test_instance_group_get_all_by_project_id(self):
groups = db.instance_group_get_all_by_project_id(self.context,
'invalid_project_id')
self.assertEqual(0, len(groups))
values = self._get_default_values()
result1 = self._create_instance_group(self.context, values)
groups = db.instance_group_get_all_by_project_id(self.context,
self.project_id)
self.assertEqual(1, len(groups))
values = self._get_new_default_values()
result2 = self._create_instance_group(self.new_context, values)
groups = db.instance_group_get_all(self.context)
groups.extend(db.instance_group_get_all(self.new_context))
results = [result1, result2]
self._assertEqualListsOfObjects(results, groups)
projects = [{'context': self.context, 'name': self.project_id,
'value': [result1]},
{'context': self.new_context, 'name': self.new_project_id,
'value': [result2]}]
for project in projects:
groups = db.instance_group_get_all_by_project_id(
project['context'], project['name'])
self._assertEqualListsOfObjects(project['value'], groups)
def test_instance_group_update(self):
values = self._get_default_values()
result = self._create_instance_group(self.context, values)
ignored_keys = ['id', 'uuid', 'deleted', 'deleted_at', 'updated_at',
'created_at']
self._assertEqualObjects(result, values, ignored_keys)
self.assertTrue(uuidutils.is_uuid_like(result['uuid']))
id = result['uuid']
values = self._get_default_values()
values['name'] = 'new_fake_name'
db.instance_group_update(self.context, id, values)
result = db.instance_group_get(self.context, id)
self.assertEqual(result['name'], 'new_fake_name')
# update update members
values = self._get_default_values()
members = ['instance_id1', 'instance_id2']
values['members'] = members
db.instance_group_update(self.context, id, values)
result = db.instance_group_get(self.context, id)
self._assertEqualListsOfPrimitivesAsSets(result['members'], members)
# update update policies
values = self._get_default_values()
policies = ['policy1', 'policy2']
values['policies'] = policies
db.instance_group_update(self.context, id, values)
result = db.instance_group_get(self.context, id)
self._assertEqualListsOfPrimitivesAsSets(result['policies'], policies)
# test invalid ID
self.assertRaises(exception.InstanceGroupNotFound,
db.instance_group_update, self.context,
'invalid_id', values)
def test_instance_group_get_by_other_project_user(self):
values = self._get_default_values()
result = self._create_instance_group(self.context, values)
self.assertRaises(exception.InstanceGroupNotFound,
db.instance_group_get,
self.new_context, result['uuid'])
def test_instance_group_get_by_admin(self):
values = self._get_default_values()
result = self._create_instance_group(self.context, values)
group = db.instance_group_get(context.get_admin_context(),
result['uuid'])
self.assertEqual(result['uuid'], group.uuid)
self.assertEqual(values['user_id'], group.user_id)
self.assertEqual(values['project_id'], group.project_id)
class InstanceGroupMembersDBApiTestCase(InstanceGroupDBApiTestCase):
def test_instance_group_members_on_create(self):
values = self._get_default_values()
values['uuid'] = 'fake_id'
members = ['instance_id1', 'instance_id2']
result = self._create_instance_group(self.context, values,
members=members)
ignored_keys = ['id', 'deleted', 'deleted_at', 'updated_at',
'created_at']
self._assertEqualObjects(result, values, ignored_keys)
self._assertEqualListsOfPrimitivesAsSets(result['members'], members)
class InstanceGroupPoliciesDBApiTestCase(InstanceGroupDBApiTestCase):
def test_instance_group_policies_on_create(self):
values = self._get_default_values()
values['uuid'] = 'fake_id'
policies = ['policy1', 'policy2']
result = self._create_instance_group(self.context, values,
policies=policies)
ignored_keys = ['id', 'deleted', 'deleted_at', 'updated_at',
'created_at']
self._assertEqualObjects(result, values, ignored_keys)
self._assertEqualListsOfPrimitivesAsSets(result['policies'], policies)
class PciDeviceDBApiTestCase(test.TestCase, ModelsObjectComparatorMixin):
def setUp(self):
super(PciDeviceDBApiTestCase, self).setUp()

3
nova/tests/unit/db/test_sqlalchemy_migration.py
View File

@@ -341,7 +341,8 @@ class TestOcataCheck(test.TestCase):
self.migration.upgrade(self.engine)
def test_upgrade_dirty_instance_groups(self):
db_api.instance_group_create(self.context, self.ig_values)
igs = db_utils.get_table(self.engine, 'instance_groups')
igs.insert().execute(self.ig_values)
self.assertRaises(exception.ValidationError,
self.migration.upgrade, self.engine)