Merge "Add Bay.list_all method to allow admin context to query all tenants bay"

magnum/db/sqlalchemy/api.py

@@ -106,7 +106,13 @@ class Connection(api.Connection):
     def __init__(self):
         pass
 
-    def _add_tenant_filters(self, context, query):
+    def _add_tenant_filters(self, context, query, opts={}):
+
+        all_tenants = opts.get('get_all_tenants', False)
+
+        if context.is_admin and all_tenants:
+            return query
+
         if context.project_id:
             query = query.filter_by(project_id=context.project_id)
         else:
@@ -140,9 +146,9 @@ class Connection(api.Connection):
         return query
 
     def get_bay_list(self, context, filters=None, limit=None, marker=None,
-                     sort_key=None, sort_dir=None):
+                     sort_key=None, sort_dir=None, opts={}):
         query = model_query(models.Bay)
-        query = self._add_tenant_filters(context, query)
+        query = self._add_tenant_filters(context, query, opts=opts)
         query = self._add_bays_filters(query, filters)
         return _paginate_query(models.Bay, limit, marker,
                                sort_key, sort_dir, query)

magnum/objects/bay.py

@@ -147,6 +147,31 @@ class Bay(base.MagnumPersistentObject, base.MagnumObject,
                                          filters=filters)
         return Bay._from_db_object_list(db_bays, cls, context)
 
+    @base.remotable_classmethod
+    def list_all(cls, context, limit=None, marker=None,
+                 sort_key=None, sort_dir=None, filters=None):
+        """Return all tenants of Bay objects.
+
+        :param context: Security context, should be an admin context.
+        :param limit: maximum number of resources to return in a single result.
+        :param marker: pagination marker for large data sets.
+        :param sort_key: column to sort results by.
+        :param sort_dir: direction to sort. "asc" or "desc".
+        :param filters: filter dict, can includes 'baymodel_id', 'name',
+                        'node_count', 'stack_id', 'api_address',
+                        'node_addresses', 'project_id', 'user_id',
+                        'status'(should be a status list).
+        :returns: a list of :class:`Bay` object.
+
+        """
+        db_bays = cls.dbapi.get_bay_list(context, limit=limit,
+                                         marker=marker,
+                                         sort_key=sort_key,
+                                         sort_dir=sort_dir,
+                                         filters=filters,
+                                         opts={'get_all_tenants': True})
+        return Bay._from_db_object_list(db_bays, cls, context)
+
     @base.remotable
     def create(self, context=None):
         """Create a Bay record in the DB.

magnum/tests/unit/db/test_bay.py

@@ -17,6 +17,7 @@
 
 import six
 
+from magnum.common import context
 from magnum.common import exception
 from magnum.common import utils as magnum_utils
 from magnum.objects.bay import Status as bay_status
@@ -125,6 +126,19 @@ class DbBayTestCase(base.DbTestCase):
                                       filters=filters)
         self.assertEqual([bay1.id, bay3.id], [r.id for r in res])
 
+    def test_get_bay_list_by_admin_all_tenants(self):
+        uuids = []
+        for i in range(1, 6):
+            bay = utils.create_test_bay(
+                uuid=magnum_utils.generate_uuid(),
+                project_id=magnum_utils.generate_uuid(),
+                user_id=magnum_utils.generate_uuid())
+            uuids.append(six.text_type(bay['uuid']))
+        ctx = context.make_admin_context()
+        res = self.dbapi.get_bay_list(ctx, opts={'get_all_tenants': True})
+        res_uuids = [r.uuid for r in res]
+        self.assertEqual(sorted(uuids), sorted(res_uuids))
+
     def test_get_bay_list_baymodel_not_exist(self):
         utils.create_test_bay()
         self.assertEqual(1, len(self.dbapi.get_bay_list(self.context)))

magnum/tests/unit/objects/test_bay.py

@@ -70,6 +70,19 @@ class TestBayObject(base.DbTestCase):
             self.assertIsInstance(bays[0], objects.Bay)
             self.assertEqual(self.context, bays[0]._context)
 
+    def test_list_all(self):
+        with mock.patch.object(self.dbapi, 'get_bay_list',
+                               autospec=True) as mock_get_list:
+            mock_get_list.return_value = [self.fake_bay]
+            bays = objects.Bay.list_all(self.context)
+            mock_get_list.assert_called_once_with(
+                self.context, limit=None, opts={'get_all_tenants': True},
+                marker=None, filters=None, sort_dir=None, sort_key=None)
+            self.assertEqual(mock_get_list.call_count, 1)
+            self.assertThat(bays, HasLength(1))
+            self.assertIsInstance(bays[0], objects.Bay)
+            self.assertEqual(self.context, bays[0]._context)
+
     def test_list_with_filters(self):
         with mock.patch.object(self.dbapi, 'get_bay_list',
                                autospec=True) as mock_get_list: