ISSUE #390

Author: vladyslav-fenchak

packages/plugins/minos-discovery-kong/minos/plugins/kong/client.py

@@ -1,37 +1,52 @@
 from __future__ import (
     annotations,
 )
-from abc import ABC
+
+from abc import (
+    ABC,
+)
+from datetime import (
+    datetime,
+    timedelta,
+)
 from uuid import (
     UUID,
 )
 
 import httpx as httpx
-from datetime import datetime
-from datetime import timedelta
-
 import jwt
+from pytz import (
+    utc,
+)
+
 from minos.common import (
-    SetupMixin,
     Config,
+    SetupMixin,
 )
-from pytz import utc
 
 
-class KongClient: #(ABC, SetupMixin):
+class KongClient(ABC, SetupMixin):
     """Kong Client class."""
 
-    def __init__(self, route: str, **kwargs): #def __init__(self, host: str, port: str, token_expiration_minutes: int, **kwargs):
+    def __init__(self, host: str = None, port: str = None, token_expiration_sec: int = 60 * 5, **kwargs):
         super().__init__(**kwargs)
-        self.route = route #f"http://{host}:{port}"
-        #self.token_expiration_minutes = token_expiration_minutes
+        if host is None:
+            host = "localhost"
+        if port is None:
+            port = 8001
+
+        self.route = f"http://{host}:{port}"
+        self.token_expiration_sec = token_expiration_sec
+
+    @classmethod
+    def _from_config(cls, config: Config, **kwargs) -> KongClient:
+        discovery_config = config.get_discovery()
 
-    # @classmethod
-    # def _from_config(cls, config: Config, **kwargs) -> KongClient:
-    #     discovery_config = config.get_discovery()
-    #
-    #     token_expiration = discovery_config.get("token-exp-minutes")
-    #     return cls(token_expiration=token_expiration, **kwargs)
+        token_expiration_sec = discovery_config.get("token-exp-minutes")
+        host = discovery_config.get("host")
+        port = discovery_config.get("port")
+
+        return cls(host=host, port=port, token_expiration_sec=token_expiration_sec, **kwargs)
 
     @staticmethod
     async def register_service(
@@ -152,21 +167,24 @@ async def activate_basic_auth_plugin_on_route(self, route_id: str):
             return resp
 
     async def activate_jwt_plugin_on_route(self, route_id: str):
-        payload = {"name": "jwt",
-                   "config": {"secret_is_base64": False, "run_on_preflight": True, "claims_to_verify": ["exp", "nbf"]}}
+        payload = {
+            "name": "jwt",
+            "config": {"secret_is_base64": False, "run_on_preflight": True, "claims_to_verify": ["exp", "nbf"]},
+        }
 
         async with httpx.AsyncClient() as client:
             resp = await client.post(f"{self.route}/routes/{route_id}/plugins", json=payload)
             return resp
 
-    async def get_jwt_token(self, key: str, secret: str, algorithm: str = 'HS256', exp: datetime = None, nbf: datetime = None) -> str:
+    async def get_jwt_token(
+        self, key: str, secret: str, algorithm: str = "HS256", exp: datetime = None, nbf: datetime = None
+    ) -> str:
         payload = {"iss": key, "exp": exp, "nbf": nbf}
 
         current = datetime.now(tz=utc)
 
         if not exp:
-            #payload["exp"] = current + timedelta(minutes=self.token_expiration_minutes)
-            payload["exp"] = current + timedelta(minutes=120)
+            payload["exp"] = current + timedelta(seconds=self.token_expiration_sec)
 
         if not nbf:
             payload["nbf"] = current

packages/plugins/minos-discovery-kong/minos/plugins/kong/discovery.py

@@ -41,6 +41,7 @@ def __init__(
         host: Optional[str] = None,
         port: Optional[int] = None,
         circuit_breaker_exceptions: Iterable[type] = tuple(),
+        client: KongClient = None,
         **kwargs,
     ):
         if host is None:
@@ -50,7 +51,11 @@ def __init__(
         super().__init__(
             host, port, circuit_breaker_exceptions=(httpx.HTTPStatusError, *circuit_breaker_exceptions), **kwargs
         )
-        self.kong = KongClient(self.route)
+
+        if client is None:
+            client = KongClient()
+
+        self.client = client
 
         self.auth_type = None
         if "auth_type" in kwargs:
@@ -66,8 +71,9 @@ def _from_config(cls, config: Config, **kwargs) -> KongDiscoveryClient:
                 auth_type = config.get_by_key("discovery.auth-type")
             except Exception:
                 auth_type = None
+        client = KongClient.from_config(config)
 
-        return super()._from_config(config, auth_type=auth_type, **kwargs)
+        return super()._from_config(config, auth_type=auth_type, client=client, **kwargs)
 
     async def subscribe(
         self, host: str, port: int, name: str, endpoints: list[dict[str, str]], *args, **kwargs
@@ -83,13 +89,13 @@ async def subscribe(
         :return: This method does not return anything.
         """
 
-        fnsr = partial(self.kong.register_service, self.route, name, host, port)
+        fnsr = partial(self.client.register_service, self.route, name, host, port)
         response_service = await self.with_circuit_breaker(fnsr)  # register a service
         if response_service.status_code == 409:  # service already exist
             # if service already exist, delete and add again
-            fn_delete = partial(self.kong.delete_service, self.route, name)
+            fn_delete = partial(self.client.delete_service, self.route, name)
             await self.with_circuit_breaker(fn_delete)  # delete the service
-            fnsr = partial(self.kong.register_service, self.route, name, host, port)
+            fnsr = partial(self.client.register_service, self.route, name, host, port)
             response_service = await self.with_circuit_breaker(fnsr)  # send the servie subscription again
 
         content_service = response_service.json()  # get the servie information like the id
@@ -98,7 +104,7 @@ async def subscribe(
             endpointClass = Endpoint(endpoint["url"])
 
             fn = partial(
-                self.kong.create_route,
+                self.client.create_route,
                 self.route,
                 ["http"],
                 [endpoint["method"]],
@@ -111,15 +117,15 @@ async def subscribe(
 
             if "authenticated" in endpoint and self.auth_type:
                 if self.auth_type == "basic-auth":
-                    fn = partial(self.kong.activate_basic_auth_plugin_on_route, route_id=resp["id"])
+                    fn = partial(self.client.activate_basic_auth_plugin_on_route, route_id=resp["id"])
                     await self.with_circuit_breaker(fn)
                 elif self.auth_type == "jwt":
-                    fn = partial(self.kong.activate_jwt_plugin_on_route, route_id=resp["id"])
+                    fn = partial(self.client.activate_jwt_plugin_on_route, route_id=resp["id"])
                     await self.with_circuit_breaker(fn)
 
             if "authorized_groups" in endpoint:
                 fn = partial(
-                    self.kong.activate_acl_plugin_on_route, route_id=resp["id"], allow=endpoint["authorized_groups"]
+                    self.client.activate_acl_plugin_on_route, route_id=resp["id"], allow=endpoint["authorized_groups"]
                 )
                 await self.with_circuit_breaker(fn)
 
@@ -133,6 +139,6 @@ async def unsubscribe(self, name: str, *args, **kwargs) -> httpx.Response:
         :param kwargs: Additional named arguments.
         :return: This method does not return anything.
         """
-        fn = partial(self.kong.delete_service, self.route, name)
+        fn = partial(self.client.delete_service, self.route, name)
         response = await self.with_circuit_breaker(fn)
         return response

packages/plugins/minos-discovery-kong/tests/test_kong/test_client.py

@@ -1,23 +1,29 @@
 import os
 import unittest
+from datetime import (
+    datetime,
+    timedelta,
+)
 from uuid import (
     uuid4,
 )
 
 import httpx
+from pytz import (
+    utc,
+)
 
+from minos.common import (
+    Config,
+)
 from minos.plugins.kong import (
     KongClient,
     KongDiscoveryClient,
 )
 from tests.utils import (
+    CONFIG_FILE_PATH,
     TEST_HOST,
 )
-from datetime import datetime
-from datetime import timedelta
-
-import jwt
-from pytz import utc
 
 PROTOCOL = "http"
 
@@ -28,7 +34,7 @@ class TestKongDiscoveryClient(unittest.IsolatedAsyncioTestCase):
 
     def setUp(self) -> None:
         self.client = KongDiscoveryClient(self.KONG_HOST, self.KONG_PORT, circuit_breaker_time=0.1)
-        self.kong = KongClient(self.client.route)
+        self.kong = KongClient()
 
     @staticmethod
     def generate_underscore_uuid():
@@ -195,7 +201,7 @@ async def test_jwt_token_generation(self):
         self.assertTrue(201 == response.status_code)
         resp = response.json()
 
-        token = await self.kong.get_jwt_token(key=resp['key'], secret=resp['secret'])
+        token = await self.kong.get_jwt_token(key=resp["key"], secret=resp["secret"])
 
         self.assertGreater(len(token), 50)
 
@@ -213,11 +219,36 @@ async def test_jwt_token_generation_with_expiration(self):
         resp = response.json()
 
         current = datetime.now(tz=utc)
-        token = await self.kong.get_jwt_token(key=resp['key'], secret=resp['secret'],
-                                              exp=current + timedelta(minutes=10), nbf=current + timedelta(minutes=9))
+        token = await self.kong.get_jwt_token(
+            key=resp["key"],
+            secret=resp["secret"],
+            exp=current + timedelta(minutes=10),
+            nbf=current + timedelta(minutes=9),
+        )
 
         self.assertGreater(len(token), 50)
 
 
+class TestKongClientFromConfig(unittest.IsolatedAsyncioTestCase):
+    KONG_HOST = os.getenv("KONG_HOST", "localhost")
+    KONG_PORT = os.getenv("KONG_PORT", 8001)
+
+    def setUp(self) -> None:
+        config = Config(CONFIG_FILE_PATH)
+        self.kong = KongClient.from_config(config=config)
+
+    @staticmethod
+    def generate_underscore_uuid():
+        name = str(uuid4())
+        return name.replace("-", "_")
+
+    async def test_create_consumer(self):
+        user_uuid = uuid4()
+        user_name = self.generate_underscore_uuid()
+        response = await self.kong.create_consumer(username=user_name, user=user_uuid, tags=[])
+
+        self.assertTrue(201 == response.status_code)
+
+
 if __name__ == "__main__":
     unittest.main()