Enable multi tenant for get_xx_by_uuid

The updated API include the following:
1) get_bay_by_uuid
2) get_baymodel_by_uuid
3) get_node_by_uuid
4) get_container_by_uuid

Implements part of bp multi-tenant

Change-Id: I6cff457e585b4dd11f485eb63e477b8de0e96bea

magnum/db/api.py

@@ -163,9 +163,10 @@ class Connection(object):
         """
 
     @abc.abstractmethod
-    def get_baymodel_by_uuid(self, baymodel_uuid):
+    def get_baymodel_by_uuid(self, ctxt, baymodel_uuid):
         """Return a baymodel.
 
+        :param ctxt: The security context
         :param baymodel_uuid: The uuid of a baymodel.
         :returns: A baymodel.
         """
@@ -236,9 +237,10 @@ class Connection(object):
         """
 
     @abc.abstractmethod
-    def get_container_by_uuid(self, container_uuid):
+    def get_container_by_uuid(self, ctxt, container_uuid):
         """Return a container.
 
+        :param ctxt: The security context
         :param container_uuid: The uuid of a container.
         :returns: A container.
         """
@@ -307,9 +309,10 @@ class Connection(object):
         """
 
     @abc.abstractmethod
-    def get_node_by_uuid(self, node_uuid):
+    def get_node_by_uuid(self, ctxt, node_uuid):
         """Return a node.
 
+        :param ctxt: The security context
         :param node_uuid: The uuid of a node.
         :returns: A node.
         """

magnum/db/sqlalchemy/api.py

@@ -107,6 +107,14 @@ class Connection(api.Connection):
     def __init__(self):
         pass
 
+    def _add_tenant_filters(self, ctxt, query):
+        if ctxt.project_id:
+            query = query.filter_by(project_id=ctxt.project_id)
+        else:
+            query = query.filter_by(user_id=ctxt.user_id)
+
+        return query
+
     def _add_bays_filters(self, query, filters):
         if filters is None:
             filters = []
@@ -172,11 +180,9 @@ class Connection(api.Connection):
             raise exception.BayNotFound(bay=bay_id)
 
     def get_bay_by_uuid(self, ctxt, bay_uuid):
-        auth_token = ctxt.auth_token_info['token']
-        project_id = auth_token['project']['id']
-        user_id = auth_token['user']['id']
-        query = model_query(models.Bay).filter_by(uuid=bay_uuid,
-                            project_id=project_id, user_id=user_id)
+        query = model_query(models.Bay)
+        query = self._add_tenant_filters(ctxt, query)
+        query = query.filter_by(uuid=bay_uuid)
         try:
             return query.one()
         except NoResultFound:
@@ -307,8 +313,10 @@ class Connection(api.Connection):
         except NoResultFound:
             raise exception.BayModelNotFound(baymodel=baymodel_id)
 
-    def get_baymodel_by_uuid(self, baymodel_uuid):
-        query = model_query(models.BayModel).filter_by(uuid=baymodel_uuid)
+    def get_baymodel_by_uuid(self, ctxt, baymodel_uuid):
+        query = model_query(models.BayModel)
+        query = self._add_tenant_filters(ctxt, query)
+        query = query.filter_by(uuid=baymodel_uuid)
         try:
             return query.one()
         except NoResultFound:
@@ -414,8 +422,10 @@ class Connection(api.Connection):
         except NoResultFound:
             raise exception.ContainerNotFound(container=container_id)
 
-    def get_container_by_uuid(self, container_uuid):
-        query = model_query(models.Container).filter_by(uuid=container_uuid)
+    def get_container_by_uuid(self, ctxt, container_uuid):
+        query = model_query(models.Container)
+        query = self._add_tenant_filters(ctxt, query)
+        query = query.filter_by(uuid=container_uuid)
         try:
             return query.one()
         except NoResultFound:
@@ -519,8 +529,10 @@ class Connection(api.Connection):
         except NoResultFound:
             raise exception.NodeNotFound(node=node_id)
 
-    def get_node_by_uuid(self, node_uuid):
-        query = model_query(models.Node).filter_by(uuid=node_uuid)
+    def get_node_by_uuid(self, ctxt, node_uuid):
+        query = model_query(models.Node)
+        query = self._add_tenant_filters(ctxt, query)
+        query = query.filter_by(uuid=node_uuid)
         try:
             return query.one()
         except NoResultFound:

magnum/objects/baymodel.py

@@ -88,7 +88,7 @@ class BayModel(base.MagnumObject):
         :param context: Security context
         :returns: a :class:`BayModel` object.
         """
-        db_baymodel = cls.dbapi.get_baymodel_by_uuid(uuid)
+        db_baymodel = cls.dbapi.get_baymodel_by_uuid(context, uuid)
         baymodel = BayModel._from_db_object(cls(context), db_baymodel)
         return baymodel
 

magnum/objects/container.py

@@ -83,7 +83,7 @@ class Container(base.MagnumObject):
         :param context: Security context
         :returns: a :class:`Container` object.
         """
-        db_container = cls.dbapi.get_container_by_uuid(uuid)
+        db_container = cls.dbapi.get_container_by_uuid(context, uuid)
         container = Container._from_db_object(cls(context), db_container)
         return container
 

magnum/objects/node.py

@@ -83,7 +83,7 @@ class Node(base.MagnumObject):
         :param context: Security context
         :returns: a :class:`Node` object.
         """
-        db_node = cls.dbapi.get_node_by_uuid(uuid)
+        db_node = cls.dbapi.get_node_by_uuid(context, uuid)
         node = Node._from_db_object(cls(context), db_node)
         return node
 

magnum/tests/base.py

@@ -62,12 +62,18 @@ class TestCase(base.BaseTestCase):
             }
         }
         self.context = magnum_context.RequestContext(
-                            auth_token_info=token_info)
+                            auth_token_info=token_info,
+                            project_id='fake_project',
+                            user_id='fake_user')
 
         def make_context(*args, **kwargs):
             # If context hasn't been constructed with token_info
             if not kwargs.get('auth_token_info'):
                 kwargs['auth_token_info'] = copy.deepcopy(token_info)
+            if not kwargs.get('project_id'):
+                kwargs['project_id'] = 'fake_project'
+            if not kwargs.get('user_id'):
+                kwargs['user_id'] = 'fake_user'
 
             ctxt = magnum_context.RequestContext(*args, **kwargs)
             return magnum_context.RequestContext.from_dict(ctxt.to_dict())

magnum/tests/db/test_baymodel.py

@@ -100,7 +100,7 @@ class DbBaymodelTestCase(base.DbTestCase):
 
     def test_get_baymodel_by_uuid(self):
         bm = self._create_test_baymodel()
-        baymodel = self.dbapi.get_baymodel_by_uuid(bm['uuid'])
+        baymodel = self.dbapi.get_baymodel_by_uuid(self.context, bm['uuid'])
         self.assertEqual(bm['id'], baymodel.id)
 
     def test_get_baymodel_that_does_not_exist(self):
@@ -131,10 +131,11 @@ class DbBaymodelTestCase(base.DbTestCase):
     def test_destroy_baymodel_by_uuid(self):
         uuid = magnum_utils.generate_uuid()
         self._create_test_baymodel(uuid=uuid)
-        self.assertIsNotNone(self.dbapi.get_baymodel_by_uuid(uuid))
+        self.assertIsNotNone(self.dbapi.get_baymodel_by_uuid(self.context,
+                                                             uuid))
         self.dbapi.destroy_baymodel(uuid)
         self.assertRaises(exception.BayModelNotFound,
-                          self.dbapi.get_baymodel_by_uuid, uuid)
+                          self.dbapi.get_baymodel_by_uuid, self.context, uuid)
 
     def test_destroy_baymodel_that_does_not_exist(self):
         self.assertRaises(exception.BayModelNotFound,

magnum/tests/db/test_container.py

@@ -41,7 +41,8 @@ class DbContainerTestCase(base.DbTestCase):
 
     def test_get_container_by_uuid(self):
         container = utils.create_test_container()
-        res = self.dbapi.get_container_by_uuid(container.uuid)
+        res = self.dbapi.get_container_by_uuid(self.context,
+                                               container.uuid)
         self.assertEqual(container.id, res.id)
         self.assertEqual(container.uuid, res.uuid)
 
@@ -50,6 +51,7 @@ class DbContainerTestCase(base.DbTestCase):
                           self.dbapi.get_container_by_id, 99)
         self.assertRaises(exception.ContainerNotFound,
                           self.dbapi.get_container_by_uuid,
+                          self.context,
                           magnum_utils.generate_uuid())
 
     def test_get_containerinfo_list_defaults(self):
@@ -137,7 +139,8 @@ class DbContainerTestCase(base.DbTestCase):
         container = utils.create_test_container()
         self.dbapi.destroy_container(container.uuid)
         self.assertRaises(exception.ContainerNotFound,
-                          self.dbapi.get_container_by_uuid, container.uuid)
+                          self.dbapi.get_container_by_uuid,
+                          self.context, container.uuid)
 
     def test_destroy_container_that_does_not_exist(self):
         self.assertRaises(exception.ContainerNotFound,

magnum/tests/db/test_node.py

@@ -50,7 +50,7 @@ class DbNodeTestCase(base.DbTestCase):
 
     def test_get_node_by_uuid(self):
         node = utils.create_test_node()
-        res = self.dbapi.get_node_by_uuid(node.uuid)
+        res = self.dbapi.get_node_by_uuid(self.context, node.uuid)
         self.assertEqual(node.id, res.id)
         self.assertEqual(node.uuid, res.uuid)
 
@@ -59,6 +59,7 @@ class DbNodeTestCase(base.DbTestCase):
                           self.dbapi.get_node_by_id, 99)
         self.assertRaises(exception.NodeNotFound,
                           self.dbapi.get_node_by_uuid,
+                          self.context,
                           magnum_utils.generate_uuid())
 
     def test_get_nodeinfo_list_defaults(self):
@@ -151,7 +152,8 @@ class DbNodeTestCase(base.DbTestCase):
         node = utils.create_test_node()
         self.dbapi.destroy_node(node.uuid)
         self.assertRaises(exception.NodeNotFound,
-                          self.dbapi.get_node_by_uuid, node.uuid)
+                          self.dbapi.get_node_by_uuid,
+                          self.context, node.uuid)
 
     def test_destroy_node_that_does_not_exist(self):
         self.assertRaises(exception.NodeNotFound,

magnum/tests/objects/test_baymodel.py

@@ -44,7 +44,7 @@ class TestBayModelObject(base.DbTestCase):
                                autospec=True) as mock_get_baymodel:
             mock_get_baymodel.return_value = self.fake_baymodel
             baymodel = objects.BayModel.get(self.context, uuid)
-            mock_get_baymodel.assert_called_once_with(uuid)
+            mock_get_baymodel.assert_called_once_with(self.context, uuid)
             self.assertEqual(self.context, baymodel._context)
 
     def test_get_bad_id_and_uuid(self):
@@ -79,7 +79,7 @@ class TestBayModelObject(base.DbTestCase):
                                    autospec=True) as mock_destroy_baymodel:
                 bm = objects.BayModel.get_by_uuid(self.context, uuid)
                 bm.destroy()
-                mock_get_baymodel.assert_called_once_with(uuid)
+                mock_get_baymodel.assert_called_once_with(self.context, uuid)
                 mock_destroy_baymodel.assert_called_once_with(uuid)
                 self.assertEqual(self.context, bm._context)
 
@@ -94,7 +94,7 @@ class TestBayModelObject(base.DbTestCase):
                 bm.image_id = 'test-image'
                 bm.save()
 
-                mock_get_baymodel.assert_called_once_with(uuid)
+                mock_get_baymodel.assert_called_once_with(self.context, uuid)
                 mock_update_baymodel.assert_called_once_with(
                         uuid, {'image_id': 'test-image'})
                 self.assertEqual(self.context, bm._context)
@@ -104,7 +104,8 @@ class TestBayModelObject(base.DbTestCase):
         new_uuid = magnum_utils.generate_uuid()
         returns = [dict(self.fake_baymodel, uuid=uuid),
                    dict(self.fake_baymodel, uuid=new_uuid)]
-        expected = [mock.call(uuid), mock.call(uuid)]
+        expected = [mock.call(self.context, uuid),
+                    mock.call(self.context, uuid)]
         with mock.patch.object(self.dbapi, 'get_baymodel_by_uuid',
                                side_effect=returns,
                                autospec=True) as mock_get_baymodel:
@@ -113,4 +114,4 @@ class TestBayModelObject(base.DbTestCase):
             bm.refresh()
             self.assertEqual(new_uuid, bm.uuid)
             self.assertEqual(expected, mock_get_baymodel.call_args_list)
-            self.assertEqual(self.context, bm._context)
+            self.assertEqual(self.context, bm._context)

magnum/tests/objects/test_container.py

@@ -44,7 +44,7 @@ class TestContainerObject(base.DbTestCase):
                                autospec=True) as mock_get_container:
             mock_get_container.return_value = self.fake_container
             container = objects.Container.get(self.context, uuid)
-            mock_get_container.assert_called_once_with(uuid)
+            mock_get_container.assert_called_once_with(self.context, uuid)
             self.assertEqual(self.context, container._context)
 
     def test_get_bad_id_and_uuid(self):
@@ -79,7 +79,7 @@ class TestContainerObject(base.DbTestCase):
                                    autospec=True) as mock_destroy_container:
                 container = objects.Container.get_by_uuid(self.context, uuid)
                 container.destroy()
-                mock_get_container.assert_called_once_with(uuid)
+                mock_get_container.assert_called_once_with(self.context, uuid)
                 mock_destroy_container.assert_called_once_with(uuid)
                 self.assertEqual(self.context, container._context)
 
@@ -94,7 +94,7 @@ class TestContainerObject(base.DbTestCase):
                 container.image_id = 'container.img'
                 container.save()
 
-                mock_get_container.assert_called_once_with(uuid)
+                mock_get_container.assert_called_once_with(self.context, uuid)
                 mock_update_container.assert_called_once_with(
                         uuid, {'image_id': 'container.img'})
                 self.assertEqual(self.context, container._context)
@@ -104,7 +104,8 @@ class TestContainerObject(base.DbTestCase):
         new_uuid = magnum_utils.generate_uuid()
         returns = [dict(self.fake_container, uuid=uuid),
                    dict(self.fake_container, uuid=new_uuid)]
-        expected = [mock.call(uuid), mock.call(uuid)]
+        expected = [mock.call(self.context, uuid),
+                    mock.call(self.context, uuid)]
         with mock.patch.object(self.dbapi, 'get_container_by_uuid',
                                side_effect=returns,
                                autospec=True) as mock_get_container:
@@ -113,4 +114,4 @@ class TestContainerObject(base.DbTestCase):
             container.refresh()
             self.assertEqual(new_uuid, container.uuid)
             self.assertEqual(expected, mock_get_container.call_args_list)
-            self.assertEqual(self.context, container._context)
+            self.assertEqual(self.context, container._context)

magnum/tests/objects/test_node.py

@@ -44,7 +44,7 @@ class TestNodeObject(base.DbTestCase):
                                autospec=True) as mock_get_node:
             mock_get_node.return_value = self.fake_node
             node = objects.Node.get(self.context, uuid)
-            mock_get_node.assert_called_once_with(uuid)
+            mock_get_node.assert_called_once_with(self.context, uuid)
             self.assertEqual(self.context, node._context)
 
     def test_get_bad_id_and_uuid(self):
@@ -79,7 +79,7 @@ class TestNodeObject(base.DbTestCase):
                                    autospec=True) as mock_destroy_node:
                 node = objects.Node.get_by_uuid(self.context, uuid)
                 node.destroy()
-                mock_get_node.assert_called_once_with(uuid)
+                mock_get_node.assert_called_once_with(self.context, uuid)
                 mock_destroy_node.assert_called_once_with(uuid)
                 self.assertEqual(self.context, node._context)
 
@@ -94,7 +94,7 @@ class TestNodeObject(base.DbTestCase):
                 node.type = 'bare'
                 node.save()
 
-                mock_get_node.assert_called_once_with(uuid)
+                mock_get_node.assert_called_once_with(self.context, uuid)
                 mock_update_node.assert_called_once_with(
                         uuid, {'type': 'bare'})
                 self.assertEqual(self.context, node._context)
@@ -104,7 +104,8 @@ class TestNodeObject(base.DbTestCase):
         new_uuid = magnum_utils.generate_uuid()
         returns = [dict(self.fake_node, uuid=uuid),
                    dict(self.fake_node, uuid=new_uuid)]
-        expected = [mock.call(uuid), mock.call(uuid)]
+        expected = [mock.call(self.context, uuid),
+                    mock.call(self.context, uuid)]
         with mock.patch.object(self.dbapi, 'get_node_by_uuid',
                                side_effect=returns,
                                autospec=True) as mock_get_node:
@@ -113,4 +114,4 @@ class TestNodeObject(base.DbTestCase):
             node.refresh()
             self.assertEqual(new_uuid, node.uuid)
             self.assertEqual(expected, mock_get_node.call_args_list)
-            self.assertEqual(self.context, node._context)
+            self.assertEqual(self.context, node._context)