init comment-service

services/comment-service/comment_service/events/base_consumer.py

@@ -0,0 +1,80 @@
+import logging
+from typing import Type
+
+from google.protobuf import message
+from aiokafka import AIOKafkaConsumer
+from aiokafka.structs import ConsumerRecord
+
+from comment_service.models.config import Config
+from comment_service.models.service import CommentDBRepository
+
+
+class EventConsumer:
+    """An abstract consumer base class.
+    
+    Attributes:
+        CONSUMER_TOPIC: The topic to consume events from.
+        CONSUMER_EVENT_TYPE (Type[message.Message]): The protobuf class type of the event msgs (used for deserialisation).
+        _db_repo (Type[CommentDBRepository]): The repository interface for modifying data.
+        _consumer (aiokafka.AIOKafkaConsumer): The underlying Kafka instance.
+        
+    """
+    CONSUMER_TOPIC: str
+    CONSUMER_EVENT_TYPE: Type[message.Message]
+
+    def __init__(self, config: Config, db_repo: Type[CommentDBRepository]) -> None:
+        """Initialise the event consumer.
+        
+        Args:
+            config (Config): The app configuration instance (to access brokers list).
+            db_repo (Type[CommentDBRepository]): The repository interface for updating data.
+
+        """
+        self._db_repo = db_repo
+        self._consumer = AIOKafkaConsumer(
+            self.CONSUMER_TOPIC,
+            bootstrap_servers=config.kafka_brokers,
+            group_id="comment-service"
+        )
+
+    async def start(self) -> None:
+        """Begin consuming messages."""
+        await self._consumer.start()
+        try:
+            async for msg in self._consumer:
+                await self._process_msg(msg)
+        except Exception as e:
+            logging.error(f"error whilst consuming messages (on topic '{self.CONSUMER_TOPIC}'): {e}")
+        finally:
+            await self._consumer.stop()
+
+    async def _process_msg(self, msg: ConsumerRecord) -> None:
+        """Process a recieved message.
+        
+        The messages are deserialise from bytes into their protobuf form,
+        then passed to the `_process_event` method to handle the logic.
+        
+        Args:
+            msg (kafka.Message): The event to process.
+        
+        """
+        try:    
+            event = self.CONSUMER_EVENT_TYPE()
+            event.ParseFromString(msg.value)
+            assert event.type != ""
+            await self._process_event(event)
+        except AssertionError:
+            logging.error("invalid event recieved")
+            return
+        except Exception as e:
+            logging.error("error whilst processing recieved event:", e)
+            return
+
+    async def _process_event(self, event: Type[message.Message]) -> None:
+        """Process a recieved event.
+
+        Args:
+            event (Type[message.Message]): The event serialised to protobuf form.
+        
+        """
+        raise NotImplementedError("required consumer method (_process_event) not implemented")