feat(controller): add get manager user status

duanhongyi · duanhongyi · commit aa744181a870 · 2021-10-31T00:15:51.000+08:00
diff --git a/rootfs/api/authentication.py b/rootfs/api/authentication.py
@@ -8,6 +8,7 @@
     get_authorization_header
 from rest_framework import exceptions
 
+from api import manager
 from api.oauth import OAuthManager
 
 logger = logging.getLogger(__name__)
@@ -35,7 +36,7 @@ def authenticate(self, request):
             return AnonymousUser(), None
 
 
-class DryccOIDCAuthentication(TokenAuthentication):
+class DryccAuthentication(TokenAuthentication):
     def authenticate(self, request):
         if 'Drycc' in request.META.get('HTTP_USER_AGENT', ''):
             auth = get_authorization_header(request).split()
@@ -57,14 +58,18 @@ def authenticate(self, request):
                 raise exceptions.AuthenticationFailed(msg)
             return cache.get_or_set(
                 token, lambda: self._get_user(token), settings.OAUTH_CACHE_USER_TIME), None  # noqa
-        return super(DryccOIDCAuthentication, self).authenticate(request)  # noqa
+        return super(DryccAuthentication, self).authenticate(request)  # noqa
 
     @staticmethod
     def _get_user(key):
         try:
             user_info = OAuthManager().get_user_by_token(key)
             if not user_info.get('email'):
                 user_info['email'] = OAuthManager().get_email_by_token(key)
+            if settings.WORKFLOW_MANAGER_URL and settings.WORKFLOW_MANAGER_TOKEN:
+                status = manager.User().get_status(user_info.username)
+                if not status["is_active"]:
+                    raise exceptions.AuthenticationFailed(_(status["message"]))
         except Exception as e:
             logger.info(e)
             raise exceptions.AuthenticationFailed(_('Verify token fail.'))
diff --git a/rootfs/api/manager.py b/rootfs/api/manager.py
@@ -0,0 +1,136 @@
+import requests
+from typing import List, Dict
+from requests_toolbelt import user_agent
+from django.conf import settings
+from api import __version__ as drycc_version
+
+
+class ManagerAPI(object):
+
+    def __init__(self):
+        self.headers = {
+                'Content-Type': 'application/json',
+                'Authorization': 'token %s' % settings.WORKFLOW_MANAGER_TOKEN,
+                'User-Agent': user_agent('Drycc Controller ', drycc_version)
+        }
+
+    def requests(self, method, url, **kwargs):
+        headers = kwargs.get("headers", {})
+        headers.update(self.headers)
+        kwargs["headers"] = headers
+        requests.request(method, url, **kwargs)
+
+    def get(self, url, params=None, **kwargs):
+        return self.request('get', url, params=params, **kwargs)
+
+    def options(self, url, **kwargs):
+        return self.request('options', url, **kwargs)
+
+    def head(self, url, **kwargs):
+        kwargs.setdefault('allow_redirects', False)
+        return self.request('head', url, **kwargs)
+
+    def post(self, url, data=None, json=None, **kwargs):
+        return self.request('post', url, data=data, json=json, **kwargs)
+
+    def put(self, url, data=None, **kwargs):
+        return self.request('put', url, data=data, **kwargs)
+
+    def patch(self, url, data=None, **kwargs):
+        return self.request('patch', url, data=data, **kwargs)
+
+    def delete(self, url, **kwargs):
+        return self.request('delete', url, **kwargs)
+
+
+class User(ManagerAPI):
+
+    def get_status(self, username):
+        """
+        {
+            "is_active": false,
+            "message": "The user is in arrears"
+        }
+        """
+        url = f"{settings.WORKFLOW_MANAGER_URL}/users/{username}/status/"
+        return self.get(url=url).json()
+
+
+class Measurement(ManagerAPI):
+
+    def post_config(self, config: List[Dict[str, str]]):
+        """
+        [
+            {
+                "app_id":  "test",
+                "owner_id": "test",
+                "container_type": web,
+                "cpu": "1",
+                "memory": "2G",
+                "timestamp": 1609231998.9103732
+            }
+        ]
+        """
+        url = "%s/measurements/config/" % settings.WORKFLOW_MANAGER_URL
+        return self.post(url=url, json=config)
+
+    def post_volumes(self, volumes: List[Dict[str, str]]):
+        """
+        [
+            {
+                "name": "disk",
+                "app_id": "test",
+                "owner_id": "test",
+                "size": "100G",
+                "timestamp": "1609231998.9103732"
+            }
+        ]
+        """
+        url = "%s/measurements/volumes/" % settings.WORKFLOW_MANAGER_URL,
+        return self.post(url=url, json=volumes)
+
+    def post_networks(self, networks: List[Dict[str, str]]):
+        """
+        [
+            {
+                "app_id": "test",
+                "owner_id": "test",
+                "pod_name": "django2test-web-xxxxxx",
+                "rx_bytes": "10000",
+                "tx_bytes": "200000",
+                "timestamp": "1609231998.9103732"
+            }
+        ]
+        """
+        url = "%s/measurements/networks/" % settings.WORKFLOW_MANAGER_URL
+        return self.post(url=url, json=networks)
+
+    def post_instances(self, instances: List[Dict[str, str]]):
+        """
+        [
+            {
+                "app_id": "test",
+                "owner_id":  "test",
+                "container_type": "web",
+                "container_count": 1,
+                "timestamp": "1609231998.9103732"
+            }
+        ]
+        """
+        url = "%s/measurements/instances/" % settings.WORKFLOW_MANAGER_URL
+        return self.post(url=url, json=instances)
+
+    def post_resources(self, resources: List[Dict[str, str]]):
+        """
+        [
+            {
+                "name": "test1",
+                "app_id": "redis",
+                "owener_id": "test",
+                "plan": "redis:small",
+                "timestamp": "1609231998.9103732"
+            }
+        ]
+        """
+        url = "%s/measurements/resources/" % settings.WORKFLOW_MANAGER_URL
+        return self.post(url=url, json=resources)
diff --git a/rootfs/api/models/app.py b/rootfs/api/models/app.py
@@ -59,10 +59,6 @@ def validate_reserved_names(value):
         raise ValidationError('{} is a reserved name.'.format(value))
 
 
-class Pod(dict):
-    pass
-
-
 class App(UuidAuditedModel):
     """
     Application used to service requests on behalf of end-users
@@ -945,7 +941,7 @@ def list_pods(self, *args, **kwargs):
                 if self._scheduler.pod.deleted(p):
                     continue
 
-                item = Pod()
+                item = {}
                 item['name'] = p['metadata']['name']
                 item['state'] = state
                 item['release'] = labels['version']
diff --git a/rootfs/api/settings/production.py b/rootfs/api/settings/production.py
@@ -158,7 +158,7 @@
         'rest_framework.permissions.IsAuthenticated',
     ),
     'DEFAULT_AUTHENTICATION_CLASSES': (
-        'api.authentication.DryccOIDCAuthentication',
+        'api.authentication.DryccAuthentication',
     ),
     'DEFAULT_RENDERER_CLASSES': (
         'rest_framework.renderers.JSONRenderer',
diff --git a/rootfs/api/tasks.py b/rootfs/api/tasks.py
@@ -1,18 +1,15 @@
 # Create your tasks here
 import time
 import uuid
-import json
 import logging
-import requests
 from datetime import timedelta
 from typing import List, Dict
 from django.core import signals
-from django.conf import settings
 from django.utils.timezone import now
 from celery import shared_task
-from requests_toolbelt import user_agent
+
+from api import manager
 from api.models.resource import Resource
-from api import __version__ as drycc_version
 logger = logging.getLogger(__name__)
 
 
@@ -41,30 +38,11 @@ def retrieve_resource(resource):
 
 @shared_task
 def measure_config(config: List[Dict[str, str]]):
-    """
-    [
-        {
-            "app_id":  "test",
-            "owner_id": "test",
-            "container_type": web,
-            "cpu": "1",
-            "memory": "2G",
-            "timestamp": 1609231998.9103732
-        }
-    ]
-    """
     task_id = uuid.uuid4().hex
     signals.request_started.send(sender=task_id)
     try:
-        requests.post(
-            url="%s/measurements/config/" % settings.WORKFLOW_MANAGER_URL,
-            headers={
-                'Content-Type': 'application/json',
-                'Authorization': 'token %s' % settings.WORKFLOW_MANAGER_TOKEN,
-                'User-Agent': user_agent('Drycc Controller ', drycc_version)
-            },
-            data=json.dumps(config)
-        )
+        measurement = manager.Measurement()
+        measurement.post_config(config)
     except Exception as e:
         logger.exception("write influxdb point fail: {}".format(e))
     finally:
@@ -73,29 +51,11 @@ def measure_config(config: List[Dict[str, str]]):
 
 @shared_task
 def measure_volumes(volumes: List[Dict[str, str]]):
-    """
-    [
-        {
-            "name": "disk",
-            "app_id": "test",
-            "owner_id": "test",
-            "size": "100G",
-            "timestamp": "1609231998.9103732"
-        }
-    ]
-    """
     task_id = uuid.uuid4().hex
     signals.request_started.send(sender=task_id)
     try:
-        requests.post(
-            url="%s/measurements/volumes/" % settings.WORKFLOW_MANAGER_URL,
-            headers={
-                'Content-Type': 'application/json',
-                'Authorization': 'token %s' % settings.WORKFLOW_MANAGER_TOKEN,
-                'User-Agent': user_agent('Drycc Controller ', drycc_version)
-            },
-            data=json.dumps(volumes)
-        )
+        measurement = manager.Measurement()
+        measurement.post_volumes(volumes)
     except Exception as e:
         logger.exception("write influxdb point fail: {}".format(e))
     finally:
@@ -104,30 +64,11 @@ def measure_volumes(volumes: List[Dict[str, str]]):
 
 @shared_task
 def measure_networks(networks: List[Dict[str, str]]):
-    """
-    [
-        {
-            "app_id": "test",
-            "owner_id": "test",
-            "pod_name": "django2test-web-xxxxxx",
-            "rx_bytes": "10000",
-            "tx_bytes": "200000",
-            "timestamp": "1609231998.9103732"
-        }
-    ]
-    """
     task_id = uuid.uuid4().hex
     signals.request_started.send(sender=task_id)
     try:
-        requests.post(
-            url="%s/measurements/networks/" % settings.WORKFLOW_MANAGER_URL,
-            headers={
-                'Content-Type': 'application/json',
-                'Authorization': 'token %s' % settings.WORKFLOW_MANAGER_TOKEN,
-                'User-Agent': user_agent('Drycc Controller ', drycc_version)
-            },
-            data=json.dumps(networks)
-        )
+        measurement = manager.Measurement()
+        measurement.post_networks(networks)
     except Exception as e:
         logger.exception("write influxdb point fail: {}".format(e))
     finally:
@@ -136,29 +77,11 @@ def measure_networks(networks: List[Dict[str, str]]):
 
 @shared_task
 def measure_instances(instances: List[Dict[str, str]]):
-    """
-    [
-        {
-            "app_id": "test",
-            "owner_id":  "test",
-            "container_type": "web",
-            "container_count": 1,
-            "timestamp": "1609231998.9103732"
-        }
-    ]
-    """
     task_id = uuid.uuid4().hex
     signals.request_started.send(sender=task_id)
     try:
-        requests.post(
-            url="%s/measurements/instances/" % settings.WORKFLOW_MANAGER_URL,
-            headers={
-                'Content-Type': 'application/json',
-                'Authorization': 'token %s' % settings.WORKFLOW_MANAGER_TOKEN,
-                'User-Agent': user_agent('Drycc Controller ', drycc_version)
-            },
-            data=json.dumps(instances)
-        )
+        measurement = manager.Measurement()
+        measurement.post_instances(instances)
     except Exception as e:
         logger.exception("write influxdb point fail: {}".format(e))
     finally:
@@ -167,29 +90,11 @@ def measure_instances(instances: List[Dict[str, str]]):
 
 @shared_task
 def measure_resources(resources: List[Dict[str, str]]):
-    """
-    [
-        {
-            "name": "test1",
-            "app_id": "redis",
-            "owener_id": "test",
-            "plan": "redis:small",
-            "timestamp": "1609231998.9103732"
-        }
-    ]
-    """
     task_id = uuid.uuid4().hex
     signals.request_started.send(sender=task_id)
     try:
-        requests.post(
-            url="%s/measurements/resources/" % settings.WORKFLOW_MANAGER_URL,
-            headers={
-                'Content-Type': 'application/json',
-                'Authorization': 'token %s' % settings.WORKFLOW_MANAGER_TOKEN,
-                'User-Agent': user_agent('Drycc Controller ', drycc_version)
-            },
-            data=json.dumps(resources)
-        )
+        measurement = manager.Measurement()
+        measurement.post_resources(resources)
     except Exception as e:
         logger.exception("write influxdb point fail: {}".format(e))
     finally:
