Enable multi tenant for get_xxx_list

The updated API include the following:
1) get_node_list
2) get_baymodel_list
3) get_bay_list
4) get_container_list

Implements part of bp multi-tenant

Change-Id: Iabc81288cf58d0a7da4f4fec90a1be561d41d9f3

magnum/db/api.py

@@ -43,13 +43,14 @@ class Connection(object):
         """Constructor."""
 
     @abc.abstractmethod
-    def get_bay_list(self, columns=None, filters=None, limit=None,
+    def get_bay_list(self, ctxt, columns=None, filters=None, limit=None,
                      marker=None, sort_key=None, sort_dir=None):
         """Get specific columns for matching bays.
 
         Return a list of the specified columns for all bays that match the
         specified filters.
 
+        :param ctxt: The security context
         :param columns: List of column names to return.
                         Defaults to 'id' column when columns == None.
         :param filters: Filters to apply. Defaults to None.
@@ -115,13 +116,14 @@ class Connection(object):
         """
 
     @abc.abstractmethod
-    def get_baymodel_list(self, columns=None, filters=None, limit=None,
+    def get_baymodel_list(self, ctxt, columns=None, filters=None, limit=None,
                      marker=None, sort_key=None, sort_dir=None):
         """Get specific columns for matching baymodels.
 
         Return a list of the specified columns for all baymodels that match the
         specified filters.
 
+        :param ctxt: The security context
         :param columns: List of column names to return.
                         Defaults to 'id' column when columns == None.
         :param filters: Filters to apply. Defaults to None.
@@ -188,13 +190,14 @@ class Connection(object):
         """
 
     @abc.abstractmethod
-    def get_container_list(self, columns=None, filters=None, limit=None,
+    def get_container_list(self, ctxt, columns=None, filters=None, limit=None,
                      marker=None, sort_key=None, sort_dir=None):
         """Get specific columns for matching containers.
 
         Return a list of the specified columns for all containers that match
         the specified filters.
 
+        :param ctxt: The security context
         :param columns: List of column names to return.
                         Defaults to 'id' column when columns == None.
         :param filters: Filters to apply. Defaults to None.
@@ -262,13 +265,14 @@ class Connection(object):
         """
 
     @abc.abstractmethod
-    def get_node_list(self, columns=None, filters=None, limit=None,
+    def get_node_list(self, ctxt, columns=None, filters=None, limit=None,
                      marker=None, sort_key=None, sort_dir=None):
         """Get specific columns for matching nodes.
 
         Return a list of the specified columns for all nodes that match the
         specified filters.
 
+        :param ctxt: The security context
         :param columns: List of column names to return.
                         Defaults to 'id' column when columns == None.
         :param filters: Filters to apply. Defaults to None.

magnum/db/sqlalchemy/api.py

@@ -152,9 +152,10 @@ class Connection(api.Connection):
         return _paginate_query(models.Bay, limit, marker,
                                sort_key, sort_dir, query)
 
-    def get_bay_list(self, filters=None, limit=None, marker=None,
+    def get_bay_list(self, ctxt, filters=None, limit=None, marker=None,
                       sort_key=None, sort_dir=None):
         query = model_query(models.Bay)
+        query = self._add_tenant_filters(ctxt, query)
         query = self._add_bays_filters(query, filters)
         return _paginate_query(models.Bay, limit, marker,
                                sort_key, sort_dir, query)
@@ -286,9 +287,10 @@ class Connection(api.Connection):
         return _paginate_query(models.BayModel, limit, marker,
                                sort_key, sort_dir, query)
 
-    def get_baymodel_list(self, filters=None, limit=None, marker=None,
+    def get_baymodel_list(self, ctxt, filters=None, limit=None, marker=None,
                       sort_key=None, sort_dir=None):
         query = model_query(models.BayModel)
+        query = self._add_tenant_filters(ctxt, query)
         query = self._add_baymodels_filters(query, filters)
         return _paginate_query(models.BayModel, limit, marker,
                                sort_key, sort_dir, query)
@@ -395,9 +397,10 @@ class Connection(api.Connection):
         return _paginate_query(models.Container, limit, marker,
                                sort_key, sort_dir, query)
 
-    def get_container_list(self, filters=None, limit=None, marker=None,
+    def get_container_list(self, ctxt, filters=None, limit=None, marker=None,
                       sort_key=None, sort_dir=None):
         query = model_query(models.Container)
+        query = self._add_tenant_filters(ctxt, query)
         query = self._add_containers_filters(query, filters)
         return _paginate_query(models.Container, limit, marker,
                                sort_key, sort_dir, query)
@@ -498,9 +501,10 @@ class Connection(api.Connection):
         return _paginate_query(models.Node, limit, marker,
                                sort_key, sort_dir, query)
 
-    def get_node_list(self, filters=None, limit=None, marker=None,
+    def get_node_list(self, ctxt, filters=None, limit=None, marker=None,
                       sort_key=None, sort_dir=None):
         query = model_query(models.Node)
+        query = self._add_tenant_filters(ctxt, query)
         query = self._add_nodes_filters(query, filters)
         return _paginate_query(models.Node, limit, marker,
                                sort_key, sort_dir, query)

magnum/objects/bay.py

@@ -103,7 +103,7 @@ class Bay(base.MagnumObject):
         :returns: a list of :class:`Bay` object.
 
         """
-        db_bays = cls.dbapi.get_bay_list(limit=limit,
+        db_bays = cls.dbapi.get_bay_list(context, limit=limit,
                                          marker=marker,
                                          sort_key=sort_key,
                                          sort_dir=sort_dir)

magnum/objects/baymodel.py

@@ -105,7 +105,7 @@ class BayModel(base.MagnumObject):
         :returns: a list of :class:`BayModel` object.
 
         """
-        db_baymodels = cls.dbapi.get_baymodel_list(limit=limit,
+        db_baymodels = cls.dbapi.get_baymodel_list(context, limit=limit,
                                          marker=marker,
                                          sort_key=sort_key,
                                          sort_dir=sort_dir)

magnum/objects/container.py

@@ -100,7 +100,7 @@ class Container(base.MagnumObject):
         :returns: a list of :class:`Container` object.
 
         """
-        db_containers = cls.dbapi.get_container_list(limit=limit,
+        db_containers = cls.dbapi.get_container_list(context, limit=limit,
                                          marker=marker,
                                          sort_key=sort_key,
                                          sort_dir=sort_dir)

magnum/objects/node.py

@@ -100,7 +100,7 @@ class Node(base.MagnumObject):
         :returns: a list of :class:`Node` object.
 
         """
-        db_nodes = cls.dbapi.get_node_list(limit=limit,
+        db_nodes = cls.dbapi.get_node_list(context, limit=limit,
                                          marker=marker,
                                          sort_key=sort_key,
                                          sort_dir=sort_dir)

magnum/tests/db/test_bay.py

@@ -131,7 +131,7 @@ class DbBayTestCase(base.DbTestCase):
         for i in range(1, 6):
             bay = utils.create_test_bay(uuid=magnum_utils.generate_uuid())
             uuids.append(six.text_type(bay['uuid']))
-        res = self.dbapi.get_bay_list()
+        res = self.dbapi.get_bay_list(self.context)
         res_uuids = [r.uuid for r in res]
         self.assertEqual(uuids.sort(), res_uuids.sort())
 
@@ -149,28 +149,34 @@ class DbBayTestCase(base.DbTestCase):
             baymodel_id=bm2['uuid'],
             node_count=1)
 
-        res = self.dbapi.get_bay_list(filters={'baymodel_id': bm1['uuid']})
+        res = self.dbapi.get_bay_list(self.context,
+                                      filters={'baymodel_id': bm1['uuid']})
         self.assertEqual([bay1.id], [r.id for r in res])
 
-        res = self.dbapi.get_bay_list(filters={'baymodel_id': bm2['uuid']})
+        res = self.dbapi.get_bay_list(self.context,
+                                      filters={'baymodel_id': bm2['uuid']})
         self.assertEqual([bay2.id], [r.id for r in res])
 
-        res = self.dbapi.get_bay_list(filters={'name': 'bay-one'})
+        res = self.dbapi.get_bay_list(self.context,
+                                      filters={'name': 'bay-one'})
         self.assertEqual([bay1.id], [r.id for r in res])
 
-        res = self.dbapi.get_bay_list(filters={'name': 'bad-bay'})
+        res = self.dbapi.get_bay_list(self.context,
+                                      filters={'name': 'bad-bay'})
         self.assertEqual([], [r.id for r in res])
 
-        res = self.dbapi.get_bay_list(filters={'node_count': 3})
+        res = self.dbapi.get_bay_list(self.context,
+                                      filters={'node_count': 3})
         self.assertEqual([bay1.id], [r.id for r in res])
 
-        res = self.dbapi.get_bay_list(filters={'node_count': 1})
+        res = self.dbapi.get_bay_list(self.context,
+                                      filters={'node_count': 1})
         self.assertEqual([bay2.id], [r.id for r in res])
 
     def test_get_bay_list_baymodel_not_exist(self):
         utils.create_test_bay()
-        self.assertEqual(1, len(self.dbapi.get_bay_list()))
-        res = self.dbapi.get_bay_list({
+        self.assertEqual(1, len(self.dbapi.get_bay_list(self.context)))
+        res = self.dbapi.get_bay_list(self.context, {
             'baymodel_id': magnum_utils.generate_uuid()})
         self.assertEqual(0, len(res))
 

magnum/tests/db/test_baymodel.py

@@ -37,38 +37,32 @@ class DbBaymodelTestCase(base.DbTestCase):
                                          uuid=magnum_utils.generate_uuid())
             self.dbapi.create_baymodel(bm)
             uuids.append(six.text_type(bm['uuid']))
-        res = self.dbapi.get_baymodel_list()
+        res = self.dbapi.get_baymodel_list(self.context)
         res_uuids = [r.uuid for r in res]
         self.assertEqual(sorted(uuids), sorted(res_uuids))
 
     def test_get_baymodel_list_with_filters(self):
         bm1 = self._create_test_baymodel(id=1, name='bm-one',
             uuid=magnum_utils.generate_uuid(),
-            image_id='image1', project_id='fake-project1',
-            user_id='fake-user1')
+            image_id='image1')
         bm2 = self._create_test_baymodel(id=2, name='bm-two',
             uuid=magnum_utils.generate_uuid(),
-            image_id='image2', project_id='fake-project2',
-            user_id='fake-user2')
+            image_id='image2')
 
-        res = self.dbapi.get_baymodel_list(filters={'name': 'bm-one'})
+        res = self.dbapi.get_baymodel_list(self.context,
+                                           filters={'name': 'bm-one'})
         self.assertEqual([bm1['id']], [r.id for r in res])
 
-        res = self.dbapi.get_baymodel_list(filters={'name': 'bad-name'})
+        res = self.dbapi.get_baymodel_list(self.context,
+                                           filters={'name': 'bad-name'})
         self.assertEqual([], [r.id for r in res])
 
-        res = self.dbapi.get_baymodel_list(filters={'image_id': 'image1'})
+        res = self.dbapi.get_baymodel_list(self.context,
+                                           filters={'image_id': 'image1'})
         self.assertEqual([bm1['id']], [r.id for r in res])
 
-        res = self.dbapi.get_baymodel_list(filters={
-                   'prject_id': 'fake-project1', 'user_id': 'fake-user1'})
-        self.assertEqual([bm1['id']], [r.id for r in res])
-
-        res = self.dbapi.get_baymodel_list(filters={'image_id': 'image2'})
-        self.assertEqual([bm2['id']], [r.id for r in res])
-
-        res = self.dbapi.get_baymodel_list(filters={
-                   'prject_id': 'fake-project2', 'user_id': 'fake-user2'})
+        res = self.dbapi.get_baymodel_list(self.context,
+                                           filters={'image_id': 'image2'})
         self.assertEqual([bm2['id']], [r.id for r in res])
 
     def test_get_baymodelinfo_list_defaults(self):

magnum/tests/db/test_container.py

@@ -110,7 +110,7 @@ class DbContainerTestCase(base.DbTestCase):
             container = utils.create_test_container(
                 uuid=magnum_utils.generate_uuid())
             uuids.append(six.text_type(container['uuid']))
-        res = self.dbapi.get_container_list()
+        res = self.dbapi.get_container_list(self.context)
         res_uuids = [r.uuid for r in res]
         self.assertEqual(sorted(uuids), sorted(res_uuids))
 
@@ -120,13 +120,16 @@ class DbContainerTestCase(base.DbTestCase):
         container2 = utils.create_test_container(name='container-two',
             uuid=magnum_utils.generate_uuid())
 
-        res = self.dbapi.get_container_list(filters={'name': 'container-one'})
+        res = self.dbapi.get_container_list(self.context,
+                                            filters={'name': 'container-one'})
         self.assertEqual([container1.id], [r.id for r in res])
 
-        res = self.dbapi.get_container_list(filters={'name': 'container-two'})
+        res = self.dbapi.get_container_list(self.context,
+                                            filters={'name': 'container-two'})
         self.assertEqual([container2.id], [r.id for r in res])
 
-        res = self.dbapi.get_container_list(filters={'name': 'bad-container'})
+        res = self.dbapi.get_container_list(self.context,
+                                            filters={'name': 'bad-container'})
         self.assertEqual([], [r.id for r in res])
 
     def test_destroy_container(self):

magnum/tests/db/test_node.py

@@ -119,7 +119,7 @@ class DbNodeTestCase(base.DbTestCase):
         for i in range(1, 6):
             node = utils.create_test_node(uuid=magnum_utils.generate_uuid())
             uuids.append(six.text_type(node['uuid']))
-        res = self.dbapi.get_node_list()
+        res = self.dbapi.get_node_list(self.context)
         res_uuids = [r.uuid for r in res]
         self.assertEqual(sorted(uuids), sorted(res_uuids))
 
@@ -130,16 +130,19 @@ class DbNodeTestCase(base.DbTestCase):
         node2 = utils.create_test_node(type='bare',
             uuid=magnum_utils.generate_uuid())
 
-        res = self.dbapi.get_node_list(filters={'type': 'virt'})
+        res = self.dbapi.get_node_list(self.context, filters={'type': 'virt'})
         self.assertEqual([node1.id], [r.id for r in res])
 
-        res = self.dbapi.get_node_list(filters={'type': 'bad-type'})
+        res = self.dbapi.get_node_list(self.context,
+                                       filters={'type': 'bad-type'})
         self.assertEqual([], [r.id for r in res])
 
-        res = self.dbapi.get_node_list(filters={'associated': True})
+        res = self.dbapi.get_node_list(self.context,
+                                       filters={'associated': True})
         self.assertEqual([node1.id], [r.id for r in res])
 
-        res = self.dbapi.get_node_list(filters={'associated': False})
+        res = self.dbapi.get_node_list(self.context,
+                                       filters={'associated': False})
         self.assertEqual([node2.id], [r.id for r in res])
 
     def test_destroy_node(self):