Skeleton ready

shared/application/rabbitmq_kernel.py

@@ -0,0 +1,139 @@
+from os import getenv
+from logging import Logger
+from punq import Container
+from pyee import EventEmitter
+from pyee.asyncio import AsyncIOEventEmitter
+from aioredlock import Aioredlock
+from redis.asyncio import Redis as AsyncRedis
+
+from kernel.application.manager.stop_event import StopEvent as StopEventManager
+from kernel.application.stop_event import StopEvent
+from kernel.application.view.application import Application
+from kernel.application.view.configuration import Configuration
+from kernel.application.view.rabbitmq import RabbitMQ
+from kernel.application.view.redis import Redis as RedisConfig
+
+from kernel.application.kernel import Kernel
+from shared.application.service.environment_loader import EnvironmentLoader
+from shared.application.manager.listener_arguments_parser import ListenerArgumentsParser
+from shared.application.factory.logger import Logger as LoggerFactory
+from shared.application.view.listener_arguments import ListenerArguments
+from kernel.rabbitmq.client import Client
+from kernel.rabbitmq.view.authentication_params import AuthenticationParams
+from kernel.rabbitmq.view.connection_params import ConnectionParams
+
+
+class RabbitMQKernel(Kernel):
+    __container: Container
+
+    def __init__(self) -> None:
+        self.__load_env()
+        self.__init_container()
+        self.__register_config()
+        self.__register_arguments()
+        self.__register_stop_event()
+        self.__register_logger()
+        self.__register_rabbitmq_client()
+        self.__register_redis()
+        self.__register_lock_provider()
+        self.__register_event_emitter()
+
+    def get_container(self) -> Container:
+        return self.__container
+
+    def __load_env(self) -> None:
+        env_loader = EnvironmentLoader(override=False)
+        env_loader.load()
+
+    def __init_container(self) -> None:
+        self.__container = Container()
+
+    def __register_config(self) -> None:
+        application = Application(
+            name=getenv("APP_NAME", ""),
+            env=getenv("APP_ENV", ""),
+        )
+
+        rabbitmq = RabbitMQ(
+            host=getenv("RABBITMQ_HOST", "localhost"),
+            port=int(getenv("RABBITMQ_PORT", "5672")),
+            user=getenv("RABBITMQ_USER", "guest"),
+            password=getenv("RABBITMQ_PASS", "guest"),
+            vhost=getenv("RABBITMQ_VHOST", "/")
+        )
+
+        redis = RedisConfig(
+            host=getenv("REDIS_HOST", "localhost"),
+            port=int(getenv("REDIS_PORT", "6379")),
+            db=int(getenv("REDIS_DB", "0"))
+        )
+
+        config = Configuration(application, rabbitmq, redis)
+
+        self.__container.register(Configuration, instance=config)
+
+    def __register_arguments(self) -> None:
+        argument_parser = ListenerArgumentsParser()
+        arguments_parsed = argument_parser.parse_args()
+
+        arguments = ListenerArguments(
+            queue=arguments_parsed.queue,
+            exchange=arguments_parsed.exchange,
+            routing_key=arguments_parsed.routing_key
+        )
+
+        self.__container.register(ListenerArguments, instance=arguments)
+
+    def __register_stop_event(self) -> None:
+        stop_event = StopEvent()
+
+        stop_event_manager = StopEventManager(stop_event)
+        stop_event_manager.setup_stop_signals()
+
+        self.__container.register(StopEvent, instance=stop_event)
+
+    def __register_logger(self) -> None:
+        logger_factory = LoggerFactory()
+        logger = logger_factory.create_stdout(name="rbmq.listener")
+
+        self.__container.register(Logger, instance=logger)
+
+    def __register_rabbitmq_client(self) -> None:
+        config = self.__container.resolve(Configuration).rabbitmq()
+
+        rabbitmq_client = Client(
+            AuthenticationParams(config.user, config.password),
+            ConnectionParams(config.host, config.port, config.vhost),
+            self.__container.resolve(Logger)
+        )
+
+        self.__container.register(Client, instance=rabbitmq_client)
+
+    def __register_redis(self) -> None:
+        config = self.__container.resolve(Configuration).redis()
+
+        client = AsyncRedis(
+            host=config.host,
+            port=config.port,
+            db=config.db,
+            decode_responses=True
+        )
+
+        self.__container.register(AsyncRedis, instance=client)
+
+    def __register_lock_provider(self) -> None:
+        config = self.__container.resolve(Configuration).redis()
+
+        aioredlock = Aioredlock([
+            {
+                "host": config.host,
+                "port": config.port,
+                "db": config.db
+            }
+        ])
+
+        self.__container.register(Aioredlock, instance=aioredlock)
+
+    def __register_event_emitter(self) -> None:
+        event_emitter = AsyncIOEventEmitter()
+        self.__container.register(EventEmitter, instance=event_emitter)