clariteia / api_gateway_common Goto Github PK

METH_GET = "GET"
METH_DELETE = "DELETE"
METH_PATCH = "PATCH"
METH_POST = "POST"
METH_PUT = "PUT"


class ClientHttpBase:
    def __init__(self, **kwargs):
        pass

    async def get(self, url, params: dict = None, **kwargs: Any):
        return await self._triger_request(METH_GET, url, params, **kwargs)

    async def post(self, url, params: dict = None, data: Any = None, **kwargs: Any):
        return await self._triger_request(METH_POST, url, params, data, **kwargs)

    async def put(self, url, params: dict = None, data: Any = None, **kwargs: Any):
        return await self._triger_request(METH_PUT, url, params, data, **kwargs)

    async def patch(self, url, params: dict = None, data: Any = None, **kwargs: Any):
        return await self._triger_request(METH_PATCH, url, params, data, **kwargs)

    async def delete(self, url, params: dict = None, data: Any = None, **kwargs: Any):
        return await self._triger_request(METH_DELETE, url, params, data, **kwargs)

    async def _triger_request(self, method, url, params, data: Any = None, **kwargs: Any):
        async with aiohttp.ClientSession() as session:
            async with session.request(method=method, url=url, params=params, data=data, **kwargs) as resp:
                return resp

def import_module(module: str) -> t.Type:
    """Import the given module from a package"""
    try:
        if "." in module:
            parts = module.split(".")
            name = ".".join(parts[:-1])

        module_ref = importlib.import_module(name)
        kallable = getattr(module_ref, parts[-1])
        if not six.callable(kallable):
            raise TypeError("The module is not callable")
        return kallable
    except ImportError as e:
        raise MinosImportException("Error importing Package")


def classname(cls: t.Type) -> str:
    """Compute the given class full name.

    :param cls: Target class.
    :return: An string object.
    """
    return f"{cls.__module__}.{cls.__qualname__}"

class RestRoutesLoader:
    """
    Rest Interface Handler

    Rest Interface for aiohttp web handling.

    """

    __slots__ = "_config", "_app"

    def __init__(self, config: MinosConfig, app: web.Application = web.Application()):
        self._config = config
        self._app = app
        self.load_routes()

    def load_routes(self):
        """Load routes from config file."""
        for item in self._config.discovery.endpoints:
            callable_f = self.class_resolver(item.controller, item.action)
            self._app.router.add_route(item.method, item.route, callable_f)

    @staticmethod
    def class_resolver(controller: str, action: str):
        """Load controller class and action method.
        :param controller: Controller string. Example: "tests.service.CommandTestService.CommandService"
        :param action: Config instance. Example: "get_order"
        :return: A class method callable instance.
        """
        object_class = import_module(controller)
        instance_class = object_class()
        class_method = getattr(instance_class, action)

        return class_method

    def get_app(self):
        """Return rest application instance.
        :return: A `web.Application` instance.
        """
        return self._app

class RESTService(AIOHTTPService):
    """
    Rest Interface

    Expose REST Interface handler using aiomisc AIOHTTPService.

    """

    def __init__(self, address: str, port: int, endpoints: dict, app: web.Application = web.Application(), **kwds: t.Any):
        address = address
        port = port
        super().__init__(address=address, port=port, **kwds)
        self._endpoints = endpoints
        self.rest_interface = RestRoutesLoader(endpoints=endpoints, app=app)

    async def create_application(self):
        return self.rest_interface.get_app()  # pragma: no cover

class TestRestService(RESTService):
    def __init__(self, address: str, port: int, endpoints: dict, **kwds: t.Any):
        super().__init__(address=address, port=port, endpoints=endpoints, **kwds)

config = MinosConfig(self.CONFIG_FILE_PATH)
        rest_interface = TestRestService(address=config.rest.connection.host, port=config.rest.connection.port, endpoints=config.rest.endpoints)

class RestRoutesLoader:
    ...
    def resolve_callable(self, controller: str, action: str):
        """Load controller class and action method.
        :param controller: Controller string. Example: "tests.service.CommandTestService.CommandService"
        :param action: Config instance. Example: "get_order"
        :return: A class method callable instance.
        """
        object_class = import_module(controller)
        instance_class = object_class()
        class_method = getattr(instance_class, action)
        partial = functools.partial(class_method, config=self._config)

        return partial

   ...

class ClientHttp(ClientHttpBase):
 ...
   async def _trigger_request(self, method: str, url: str, params, data: Any = None, **kwargs: Any):
        """Trigger the request.
        :param method: HTTP method.
        :param url: Url to call.
        :param params: Params to send on URL.
        :param data: Data to send in body.
        :param kwargs: Additional named arguments.
        :return: A `_RequestContextManager` instance.
        """
        async with aiohttp.ClientSession() as session:
            async with session.request(method=method, url=url, params=params, data=data, **kwargs) as resp:
                return resp
  ....

class ClientHttp(ClientHttpBase):
    """HTTP Client aiohttp."""

    async def __aenter__(self):
        self.session = aiohttp.ClientSession()
        return self.session

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self.session.close()

    async def _trigger_request(self, method: str, url: str, params, data: Any = None, **kwargs: Any):
        """Trigger the request.
        :param method: HTTP method.
        :param url: Url to call.
        :param params: Params to send on URL.
        :param data: Data to send in body.
        :param kwargs: Additional named arguments.
        :return: A `_RequestContextManager` instance.
        """
        async with self.session.request(method=method, url=url, params=params, data=data, **kwargs) as response:
            return response

        async with ClientHttp() as client:
            request = await client.get(url="http://httpbin.org/get")
            self.assertEqual(request.status, 200)