Enable multi tenant for two k8s resource operation APIs

1) get_service_by_uuid
2) get_rc_by_uuid

Implements part of bp multi-tenant

Change-Id: Ib96e777bf73c7e29e1dc0834df273e11d14bd8c7

magnum/api/controllers/v1/replicationcontroller.py

@@ -236,8 +236,12 @@ class ReplicationControllersController(rest.RestController):
             raise exception.OperationNotPermitted
 
         rc.parse_manifest()
-        rc_obj = objects.ReplicationController(pecan.request.context,
-                              **rc.as_dict())
+        rc_dict = rc.as_dict()
+        ctxt = pecan.request.context
+        auth_token = ctxt.auth_token_info['token']
+        rc_dict['project_id'] = auth_token['project']['id']
+        rc_dict['user_id'] = auth_token['user']['id']
+        rc_obj = objects.ReplicationController(ctxt, **rc_dict)
         new_rc = pecan.request.rpcapi.rc_create(rc_obj)
         # Set the HTTP Location Header
         pecan.response.location = link.build_url('rcs', new_rc.uuid)

magnum/api/controllers/v1/service.py

@@ -248,8 +248,12 @@ class ServicesController(rest.RestController):
             raise exception.OperationNotPermitted
 
         service.parse_manifest()
-        service_obj = objects.Service(pecan.request.context,
-                                      **service.as_dict())
+        service_dict = service.as_dict()
+        ctxt = pecan.request.context
+        auth_token = ctxt.auth_token_info['token']
+        service_dict['project_id'] = auth_token['project']['id']
+        service_dict['user_id'] = auth_token['user']['id']
+        service_obj = objects.Service(ctxt, **service_dict)
         new_service = pecan.request.rpcapi.service_create(service_obj)
         # Set the HTTP Location Header
         pecan.response.location = link.build_url('services', new_service.uuid)

magnum/db/api.py

@@ -478,9 +478,10 @@ class Connection(object):
         """
 
     @abc.abstractmethod
-    def get_service_by_uuid(self, service_uuid):
+    def get_service_by_uuid(self, context, service_uuid):
         """Return a service.
 
+        :param context: The security context
         :param service_uuid: The uuid of a service.
         :returns: A service.
         """
@@ -565,9 +566,10 @@ class Connection(object):
         """
 
     @abc.abstractmethod
-    def get_rc_by_uuid(self, rc_uuid):
+    def get_rc_by_uuid(self, context, rc_uuid):
         """Return a ReplicationController.
 
+        :param context: The security context
         :param rc_uuid: The uuid of a ReplicationController.
         :returns: A ReplicationController.
         """

magnum/db/sqlalchemy/api.py

@@ -756,8 +756,10 @@ class Connection(api.Connection):
         except NoResultFound:
             raise exception.ServiceNotFound(service=service_id)
 
-    def get_service_by_uuid(self, service_uuid):
-        query = model_query(models.Service).filter_by(uuid=service_uuid)
+    def get_service_by_uuid(self, context, service_uuid):
+        query = model_query(models.Service)
+        query = self._add_tenant_filters(context, query)
+        query = query.filter_by(uuid=service_uuid)
         try:
             return query.one()
         except NoResultFound:
@@ -857,9 +859,10 @@ class Connection(api.Connection):
         except NoResultFound:
             raise exception.ReplicationControllerNotFound(rc=rc_id)
 
-    def get_rc_by_uuid(self, rc_uuid):
-        query = model_query(models.ReplicationController).filter_by(
-                                                             uuid=rc_uuid)
+    def get_rc_by_uuid(self, context, rc_uuid):
+        query = model_query(models.ReplicationController)
+        query = self._add_tenant_filters(context, query)
+        query = query.filter_by(uuid=rc_uuid)
         try:
             return query.one()
         except NoResultFound:

magnum/objects/replicationcontroller.py

@@ -96,7 +96,7 @@ class ReplicationController(base.MagnumObject):
         :param context: Security context
         :returns: a :class:`ReplicationController` object.
         """
-        db_rc = cls.dbapi.get_rc_by_uuid(uuid)
+        db_rc = cls.dbapi.get_rc_by_uuid(context, uuid)
         rc = ReplicationController._from_db_object(cls(context), db_rc)
         return rc
 

magnum/objects/service.py

@@ -94,7 +94,7 @@ class Service(base.MagnumObject):
         :param context: Security context
         :returns: a :class:`Service` object.
         """
-        db_service = cls.dbapi.get_service_by_uuid(uuid)
+        db_service = cls.dbapi.get_service_by_uuid(context, uuid)
         service = Service._from_db_object(cls(context), db_service)
         return service
 

magnum/tests/api/controllers/v1/test_replicationcontroller.py

@@ -23,7 +23,7 @@ class TestRCController(db_base.DbTestCase):
         return rc
 
     def mock_rc_destroy(self, uuid):
-        rc = objects.ReplicationController.get_by_uuid({}, uuid)
+        rc = objects.ReplicationController.get_by_uuid(self.context, uuid)
         rc.destroy()
 
     def test_rc_api(self):

magnum/tests/db/test_replicationcontroller.py

@@ -44,7 +44,7 @@ class DbRCTestCase(base.DbTestCase):
         self.assertEqual(self.rc.uuid, rc.uuid)
 
     def test_get_rc_by_uuid(self):
-        rc = self.dbapi.get_rc_by_uuid(self.rc.uuid)
+        rc = self.dbapi.get_rc_by_uuid(self.context, self.rc.uuid)
         self.assertEqual(self.rc.id, rc.id)
         self.assertEqual(self.rc.uuid, rc.uuid)
 
@@ -53,6 +53,7 @@ class DbRCTestCase(base.DbTestCase):
                           self.dbapi.get_rc_by_id, 999)
         self.assertRaises(exception.ReplicationControllerNotFound,
                           self.dbapi.get_rc_by_uuid,
+                          self.context,
                           magnum_utils.generate_uuid())
 
     def test_get_rc_list_defaults(self):
@@ -142,10 +143,12 @@ class DbRCTestCase(base.DbTestCase):
                           self.dbapi.get_rc_by_id, self.rc.id)
 
     def test_destroy_rc_by_uuid(self):
-        self.assertIsNotNone(self.dbapi.get_rc_by_uuid(self.rc.uuid))
+        self.assertIsNotNone(self.dbapi.get_rc_by_uuid(self.context,
+                                                       self.rc.uuid))
         self.dbapi.destroy_rc(self.rc.uuid)
         self.assertRaises(exception.ReplicationControllerNotFound,
-                          self.dbapi.get_rc_by_uuid, self.rc.uuid)
+                          self.dbapi.get_rc_by_uuid,
+                          self.context, self.rc.uuid)
 
     def test_destroy_rc_that_does_not_exist(self):
         self.assertRaises(exception.ReplicationControllerNotFound,

magnum/tests/db/test_service.py

@@ -44,7 +44,7 @@ class DbServiceTestCase(base.DbTestCase):
         self.assertEqual(self.service.uuid, res.uuid)
 
     def test_get_service_by_uuid(self):
-        res = self.dbapi.get_service_by_uuid(self.service.uuid)
+        res = self.dbapi.get_service_by_uuid(self.context, self.service.uuid)
         self.assertEqual(self.service.id, res.id)
         self.assertEqual(self.service.uuid, res.uuid)
 
@@ -53,6 +53,7 @@ class DbServiceTestCase(base.DbTestCase):
                           self.dbapi.get_service_by_id, 999)
         self.assertRaises(exception.ServiceNotFound,
                           self.dbapi.get_service_by_uuid,
+                          self.context,
                           magnum_utils.generate_uuid())
 
     def test_get_serviceinfo_list_defaults(self):
@@ -178,10 +179,12 @@ class DbServiceTestCase(base.DbTestCase):
                           self.dbapi.get_service_by_id, self.service.id)
 
     def test_destroy_service_by_uuid(self):
-        self.assertIsNotNone(self.dbapi.get_service_by_uuid(self.service.uuid))
+        self.assertIsNotNone(self.dbapi.get_service_by_uuid(self.context,
+                                                            self.service.uuid))
         self.dbapi.destroy_service(self.service.uuid)
         self.assertRaises(exception.ServiceNotFound,
-                          self.dbapi.get_service_by_uuid, self.service.uuid)
+                          self.dbapi.get_service_by_uuid,
+                          self.context, self.service.uuid)
 
     def test_destroy_service_that_does_not_exist(self):
         self.assertRaises(exception.ServiceNotFound,
@@ -203,4 +206,4 @@ class DbServiceTestCase(base.DbTestCase):
     def test_update_service_uuid(self):
         self.assertRaises(exception.InvalidParameterValue,
                           self.dbapi.update_service, self.service.id,
-                          {'uuid': ''})
+                          {'uuid': ''})

magnum/tests/objects/test_replicationcontroller.py

@@ -44,7 +44,7 @@ class TestReplicationControllerObject(base.DbTestCase):
                                autospec=True) as mock_get_rc:
             mock_get_rc.return_value = self.fake_rc
             rc = objects.ReplicationController.get(self.context, uuid)
-            mock_get_rc.assert_called_once_with(uuid)
+            mock_get_rc.assert_called_once_with(self.context, uuid)
             self.assertEqual(self.context, rc._context)
 
     def test_get_bad_id_and_uuid(self):
@@ -81,7 +81,7 @@ class TestReplicationControllerObject(base.DbTestCase):
                 rc = objects.ReplicationController.get_by_uuid(self.context,
                                                                uuid)
                 rc.destroy()
-                mock_get_rc.assert_called_once_with(uuid)
+                mock_get_rc.assert_called_once_with(self.context, uuid)
                 mock_destroy_rc.assert_called_once_with(uuid)
                 self.assertEqual(self.context, rc._context)
 
@@ -97,7 +97,7 @@ class TestReplicationControllerObject(base.DbTestCase):
                 rc.replicas = 10
                 rc.save()
 
-                mock_get_rc.assert_called_once_with(uuid)
+                mock_get_rc.assert_called_once_with(self.context, uuid)
                 mock_update_rc.assert_called_once_with(
                         uuid, {'replicas': 10})
                 self.assertEqual(self.context, rc._context)
@@ -107,7 +107,8 @@ class TestReplicationControllerObject(base.DbTestCase):
         new_uuid = magnum_utils.generate_uuid()
         returns = [dict(self.fake_rc, uuid=uuid),
                    dict(self.fake_rc, 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_rc_by_uuid',
                                side_effect=returns,
                                autospec=True) as mock_get_rc:
@@ -116,4 +117,4 @@ class TestReplicationControllerObject(base.DbTestCase):
             rc.refresh()
             self.assertEqual(new_uuid, rc.uuid)
             self.assertEqual(expected, mock_get_rc.call_args_list)
-            self.assertEqual(self.context, rc._context)
+            self.assertEqual(self.context, rc._context)

magnum/tests/objects/test_service.py

@@ -44,7 +44,7 @@ class TestServiceObject(base.DbTestCase):
                                autospec=True) as mock_get_service:
             mock_get_service.return_value = self.fake_service
             service = objects.Service.get(self.context, uuid)
-            mock_get_service.assert_called_once_with(uuid)
+            mock_get_service.assert_called_once_with(self.context, uuid)
             self.assertEqual(self.context, service._context)
 
     def test_get_bad_id_and_uuid(self):
@@ -79,7 +79,7 @@ class TestServiceObject(base.DbTestCase):
                                    autospec=True) as mock_destroy_service:
                 service = objects.Service.get_by_uuid(self.context, uuid)
                 service.destroy()
-                mock_get_service.assert_called_once_with(uuid)
+                mock_get_service.assert_called_once_with(self.context, uuid)
                 mock_destroy_service.assert_called_once_with(uuid)
                 self.assertEqual(self.context, service._context)
 
@@ -94,7 +94,7 @@ class TestServiceObject(base.DbTestCase):
                 service.port = 4567
                 service.save()
 
-                mock_get_service.assert_called_once_with(uuid)
+                mock_get_service.assert_called_once_with(self.context, uuid)
                 mock_update_service.assert_called_once_with(
                         uuid, {'port': 4567})
                 self.assertEqual(self.context, service._context)
@@ -104,7 +104,8 @@ class TestServiceObject(base.DbTestCase):
         new_uuid = magnum_utils.generate_uuid()
         returns = [dict(self.fake_service, uuid=uuid),
                    dict(self.fake_service, 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_service_by_uuid',
                                side_effect=returns,
                                autospec=True) as mock_get_service:
@@ -113,4 +114,4 @@ class TestServiceObject(base.DbTestCase):
             service.refresh()
             self.assertEqual(new_uuid, service.uuid)
             self.assertEqual(expected, mock_get_service.call_args_list)
-            self.assertEqual(self.context, service._context)
+            self.assertEqual(self.context, service._context)