buz 2.13.1rc8__py3-none-any.whl → 2.14.0__py3-none-any.whl

buz/event/async_event_bus.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from typing import Collection
+
+from buz.event import Event
+from buz.kafka.infrastructure.interfaces.async_connection_manager import AsyncConnectionManager
+
+
+class AsyncEventBus(AsyncConnectionManager, ABC):
+    @abstractmethod
+    async def publish(self, event: Event) -> None:
+        pass
+
+    @abstractmethod
+    async def bulk_publish(self, events: Collection[Event]) -> None:
+        pass

buz/event/event_bus.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Collection
+from typing import Iterable
 
 from buz.event import Event
 
@@ -10,5 +10,5 @@ class EventBus(ABC):
         pass
 
     @abstractmethod
-    def bulk_publish(self, events: Collection[Event]) -> None:
+    def bulk_publish(self, events: Iterable[Event]) -> None:
         pass

buz/event/infrastructure/buz_kafka/async_buz_kafka_event_bus.py

@@ -0,0 +1,107 @@
+from logging import Logger
+from typing import Collection, Optional
+
+from buz.event import Event
+from buz.event.async_event_bus import AsyncEventBus
+from buz.event.exceptions.event_not_published_exception import EventNotPublishedException
+from buz.event.infrastructure.buz_kafka.exceptions.kafka_event_bus_config_not_valid_exception import (
+    KafkaEventBusConfigNotValidException,
+)
+from buz.event.infrastructure.buz_kafka.publish_strategy.publish_strategy import KafkaPublishStrategy
+from buz.event.middleware.async_publish_middleware import AsyncPublishMiddleware
+from buz.event.middleware.async_publish_middleware_chain_resolver import AsyncPublishMiddlewareChainResolver
+from buz.kafka.domain.exceptions.topic_already_created_exception import KafkaTopicsAlreadyCreatedException
+from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
+from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
+from buz.kafka.domain.services.async_kafka_producer import AsyncKafkaProducer
+from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+
+
+class AsyncBuzKafkaEventBus(AsyncEventBus):
+    def __init__(
+        self,
+        *,
+        publish_strategy: KafkaPublishStrategy,
+        producer: AsyncKafkaProducer,
+        logger: Logger,
+        kafka_admin_client: Optional[KafkaAdminClient] = None,
+        publish_middlewares: Optional[list[AsyncPublishMiddleware]] = None,
+        auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
+    ):
+        self.__publish_middleware_chain_resolver = AsyncPublishMiddlewareChainResolver(publish_middlewares or [])
+        self.__publish_strategy = publish_strategy
+        self.__producer = producer
+        self.__topics_checked: dict[str, bool] = {}
+        self.__kafka_admin_client = kafka_admin_client
+        self.__auto_create_topic_configuration = auto_create_topic_configuration
+        self.__logger = logger
+        self.__check_kafka_admin_client_is_needed()
+
+    def __check_kafka_admin_client_is_needed(self) -> None:
+        if self.__kafka_admin_client is None and self.__auto_create_topic_configuration is not None:
+            raise KafkaEventBusConfigNotValidException(
+                "A KafkaAdminClient is needed to create topics when 'auto_create_topic_configuration' is set."
+            )
+
+    async def publish(self, event: Event) -> None:
+        await self.__publish_middleware_chain_resolver.resolve(event, self.__perform_publish)
+
+    async def __perform_publish(self, event: Event) -> None:
+        try:
+            topic = self.__publish_strategy.get_topic(event)
+
+            if self.__auto_create_topic_configuration is not None and self.__is_topic_created(topic) is False:
+                try:
+                    self.__logger.info(f"Creating missing topic: {topic}..")
+                    self.__get_kafka_admin_client().create_topics(
+                        topics=[
+                            CreateKafkaTopic(
+                                name=topic,
+                                partitions=self.__auto_create_topic_configuration.partitions,
+                                replication_factor=self.__auto_create_topic_configuration.replication_factor,
+                                configs=self.__auto_create_topic_configuration.configs,
+                            )
+                        ]
+                    )
+                    self.__logger.info(f"Created missing topic: {topic}")
+                    self.__topics_checked[topic] = True
+                except KafkaTopicsAlreadyCreatedException:
+                    pass
+
+            headers = self.__get_event_headers(event)
+            await self.__producer.produce(
+                message=event,
+                headers=headers,
+                topic=topic,
+            )
+        except Exception as exc:
+            raise EventNotPublishedException(event) from exc
+
+    def __get_kafka_admin_client(self) -> KafkaAdminClient:
+        if self.__kafka_admin_client is None:
+            raise KafkaEventBusConfigNotValidException("KafkaAdminClient is not set.")
+        return self.__kafka_admin_client
+
+    def __is_topic_created(self, topic: str) -> bool:
+        is_topic_created = self.__topics_checked.get(topic, None)
+
+        if is_topic_created is not None:
+            return is_topic_created
+
+        is_topic_created = self.__get_kafka_admin_client().is_topic_created(topic)
+        self.__topics_checked[topic] = is_topic_created
+
+        return is_topic_created
+
+    async def bulk_publish(self, events: Collection[Event]) -> None:
+        for event in events:
+            await self.publish(event)
+
+    def __get_event_headers(self, event: Event) -> dict:
+        return {"id": event.id}
+
+    async def connect(self) -> None:
+        await self.__producer.connect()
+
+    async def disconnect(self) -> None:
+        await self.__producer.disconnect()

buz/event/infrastructure/buz_kafka/base_buz_aiokafka_async_consumer.py

@@ -17,11 +17,9 @@ from buz.event.infrastructure.buz_kafka.consume_strategy.consume_strategy import
 from buz.event.infrastructure.buz_kafka.kafka_event_subscriber_executor import KafkaEventSubscriberExecutor
 from buz.event.infrastructure.models.consuming_task import ConsumingTask
 from buz.event.meta_subscriber import MetaSubscriber
-from buz.kafka import (
-    KafkaConnectionConfig,
-    ConsumerInitialOffsetPosition,
-)
 from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
+from buz.kafka.domain.models.consumer_initial_offset_position import ConsumerInitialOffsetPosition
+from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
 from buz.kafka.domain.models.kafka_poll_record import KafkaPollRecord
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
 from buz.kafka.infrastructure.aiokafka.aiokafka_consumer import AIOKafkaConsumer
@@ -107,12 +105,9 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
 
         if self.__exceptions_are_thrown(worker_errors):
             consume_events_exception, polling_task_exception = worker_errors
-            if consume_events_exception:
-                self._logger.exception(consume_events_exception)
-            if polling_task_exception:
-                self._logger.exception(polling_task_exception)
-
-            raise WorkerExecutionException("The worker was closed by an unexpected exception")
+            raise WorkerExecutionException(
+                "The worker was closed by an unexpected exception"
+            ) from consume_events_exception or polling_task_exception
 
     async def __run_worker(self) -> tuple[Optional[Exception], Optional[Exception]]:
         consume_events_task = create_task(self.__consume_events_task())

buz/event/infrastructure/buz_kafka/buz_aiokafka_async_consumer.py

@@ -15,11 +15,10 @@ from buz.event.meta_subscriber import MetaSubscriber
 from buz.event.middleware.async_consume_middleware import AsyncConsumeMiddleware
 from buz.event.strategies.retry.consume_retrier import ConsumeRetrier
 from buz.event.strategies.retry.reject_callback import RejectCallback
-from buz.kafka import (
-    KafkaConnectionConfig,
-    ConsumerInitialOffsetPosition,
-)
+
 from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
+from buz.kafka.domain.models.consumer_initial_offset_position import ConsumerInitialOffsetPosition
+from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
 from buz.kafka.infrastructure.deserializers.bytes_to_message_deserializer import BytesToMessageDeserializer
 from buz.kafka.infrastructure.deserializers.implementations.json_bytes_to_message_deserializer import (

buz/event/infrastructure/buz_kafka/buz_aiokafka_multi_threaded_consumer.py

@@ -15,11 +15,9 @@ from buz.event.meta_subscriber import MetaSubscriber
 from buz.event.middleware.consume_middleware import ConsumeMiddleware
 from buz.event.strategies.retry.consume_retrier import ConsumeRetrier
 from buz.event.strategies.retry.reject_callback import RejectCallback
-from buz.kafka import (
-    KafkaConnectionConfig,
-    ConsumerInitialOffsetPosition,
-)
 from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
+from buz.kafka.domain.models.consumer_initial_offset_position import ConsumerInitialOffsetPosition
+from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
 from buz.kafka.infrastructure.deserializers.bytes_to_message_deserializer import BytesToMessageDeserializer
 from buz.kafka.infrastructure.deserializers.implementations.json_bytes_to_message_deserializer import (

buz/event/infrastructure/buz_kafka/buz_kafka_event_bus.py

@@ -1,5 +1,5 @@
 from logging import Logger
-from typing import Collection, Optional
+from typing import Optional, Iterable
 
 from buz.event import Event, EventBus
 from buz.event.exceptions.event_not_published_exception import EventNotPublishedException
@@ -11,13 +11,11 @@ from buz.event.middleware import (
     PublishMiddleware,
 )
 from buz.event.middleware.publish_middleware_chain_resolver import PublishMiddlewareChainResolver
-from buz.kafka import (
-    KafkaPythonProducer,
-)
 from buz.kafka.domain.exceptions.topic_already_created_exception import KafkaTopicsAlreadyCreatedException
 from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
 from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+from buz.kafka.domain.services.kafka_producer import KafkaProducer
 
 
 class BuzKafkaEventBus(EventBus):
@@ -25,7 +23,7 @@ class BuzKafkaEventBus(EventBus):
         self,
         *,
         publish_strategy: KafkaPublishStrategy,
-        producer: KafkaPythonProducer,
+        producer: KafkaProducer,
         logger: Logger,
         kafka_admin_client: Optional[KafkaAdminClient] = None,
         publish_middlewares: Optional[list[PublishMiddleware]] = None,
@@ -96,7 +94,7 @@ class BuzKafkaEventBus(EventBus):
 
         return is_topic_created
 
-    def bulk_publish(self, events: Collection[Event]) -> None:
+    def bulk_publish(self, events: Iterable[Event]) -> None:
         for event in events:
             self.publish(event)
 

buz/event/infrastructure/buz_kafka/kafka_event_sync_subscriber_executor.py

@@ -67,11 +67,6 @@ class KafkaEventSyncSubscriberExecutor(KafkaEventSubscriberExecutor):
             self.__logger.error(
                 f'The message "{str(kafka_poll_record.value)}" is not valid, it will be consumed but not processed'
             )
-        except Exception as exception:
-            if self.__on_fail_strategy == KafkaOnFailStrategy.CONSUME_ON_FAIL:
-                self.__logger.error(f"Error consuming event: {exception}")
-                return
-            raise exception
 
     def __execution_callback(self, subscriber: Subscriber, message: KafkaConsumerRecord[Event]) -> None:
         self.__consume_middleware_chain_resolver.resolve(
@@ -86,13 +81,13 @@ class KafkaEventSyncSubscriberExecutor(KafkaEventSubscriberExecutor):
                 return
             except Exception as exception:
                 self.__logger.warning(f"Event {event.id} could not be consumed by the subscriber {subscriber.fqn}")
-                self.__logger.error(exception, exc_info=True)
-
                 if self.__should_retry(event, subscriber) is True:
                     self.__register_retry(event, subscriber)
                     time.sleep(self.__seconds_between_retires)
                     continue
 
+                self.__logger.exception(exception)
+
                 if self.__reject_callback:
                     self.__reject_callback.on_reject(event=event, subscribers=[subscriber], exception=exception)
 

buz/event/infrastructure/kombu/kombu_consumer.py

@@ -135,6 +135,7 @@ class KombuConsumer(ConsumerMixin, Consumer):
             message.requeue()
             return
 
+        self.__logger.exception(exception)
         self.__reject_message(message, event, subscribers, exception)
 
     def __reject_message(

buz/event/infrastructure/kombu/kombu_event_bus.py

@@ -1,21 +1,20 @@
 from dataclasses import asdict
-from typing import Collection, Optional
+from typing import Optional, Iterable
 
 from kombu import Connection, Exchange, Producer
 from kombu.entity import PERSISTENT_DELIVERY_MODE
 
 from buz.event import Event, EventBus
-from buz.event.infrastructure.kombu.publish_strategy import PublishStrategy
+from buz.event.exceptions.event_not_published_exception import EventNotPublishedException
 from buz.event.infrastructure.kombu.allowed_kombu_serializer import AllowedKombuSerializer
+from buz.event.infrastructure.kombu.publish_strategy import PublishStrategy
+from buz.event.infrastructure.kombu.retry_strategy.publish_retry_policy import PublishRetryPolicy
+from buz.event.infrastructure.kombu.retry_strategy.simple_publish_retry_policy import SimplePublishRetryPolicy
 from buz.event.middleware import (
     PublishMiddleware,
     PublishMiddlewareChainResolver,
 )
 
-from buz.event.exceptions.event_not_published_exception import EventNotPublishedException
-from buz.event.infrastructure.kombu.retry_strategy.publish_retry_policy import PublishRetryPolicy
-from buz.event.infrastructure.kombu.retry_strategy.simple_publish_retry_policy import SimplePublishRetryPolicy
-
 
 class KombuEventBus(EventBus):
     def __init__(
@@ -96,6 +95,6 @@ class KombuEventBus(EventBus):
     def __get_headers(self, event: Event) -> dict:
         return {"fqn": event.fqn()}
 
-    def bulk_publish(self, events: Collection[Event]) -> None:
+    def bulk_publish(self, events: Iterable[Event]) -> None:
         for event in events:
             self.publish(event)

buz/event/middleware/async_publish_middleware.py

@@ -0,0 +1,13 @@
+from abc import abstractmethod
+from typing import Awaitable, Callable
+
+from buz.event import Event
+from buz.middleware import Middleware
+
+AsyncPublishCallable = Callable[[Event], Awaitable[None]]
+
+
+class AsyncPublishMiddleware(Middleware):
+    @abstractmethod
+    async def on_publish(self, event: Event, publish: AsyncPublishCallable) -> None:
+        pass

buz/event/middleware/async_publish_middleware_chain_resolver.py

@@ -0,0 +1,22 @@
+from buz.event import Event
+from buz.event.middleware.async_publish_middleware import AsyncPublishCallable, AsyncPublishMiddleware
+from buz.middleware import MiddlewareChainBuilder
+
+
+class AsyncPublishMiddlewareChainResolver:
+    def __init__(self, middlewares: list[AsyncPublishMiddleware]):
+        self.__middlewares = middlewares
+        self.__middleware_chain_builder: MiddlewareChainBuilder[
+            AsyncPublishCallable, AsyncPublishMiddleware
+        ] = MiddlewareChainBuilder(middlewares)
+
+    async def resolve(self, event: Event, publish: AsyncPublishCallable) -> None:
+        chain_callable: AsyncPublishCallable = self.__middleware_chain_builder.get_chain_callable(
+            publish, self.__get_middleware_callable
+        )
+        await chain_callable(event)
+
+    def __get_middleware_callable(
+        self, middleware: AsyncPublishMiddleware, publish_callable: AsyncPublishCallable
+    ) -> AsyncPublishCallable:
+        return lambda event: middleware.on_publish(event, publish_callable)

buz/event/sync/sync_event_bus.py

@@ -1,4 +1,4 @@
-from typing import Collection, Optional
+from typing import Optional, Iterable
 
 from buz.event import Event, EventBus, Subscriber
 from buz.event.middleware import (
@@ -32,6 +32,6 @@ class SyncEventBus(EventBus):
     def __perform_consume(self, event: Event, subscriber: Subscriber) -> None:
         subscriber.consume(event)
 
-    def bulk_publish(self, events: Collection[Event]) -> None:
+    def bulk_publish(self, events: Iterable[Event]) -> None:
         for event in events:
             self.publish(event)

buz/event/transactional_outbox/outbox_repository.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Sequence
+from typing import Sequence, Iterable
 
 from buz.event.transactional_outbox import OutboxRecord
 from buz.event.transactional_outbox import OutboxCriteria
@@ -10,6 +10,10 @@ class OutboxRepository(ABC):
     def save(self, outbox_record: OutboxRecord) -> None:
         pass
 
+    @abstractmethod
+    def bulk_create(self, outbox_records: Iterable[OutboxRecord]) -> None:
+        pass
+
     @abstractmethod
     def find(self, criteria: OutboxCriteria) -> Sequence[OutboxRecord]:
         pass

buz/event/transactional_outbox/transactional_outbox_event_bus.py

@@ -1,6 +1,7 @@
-from typing import Collection, Optional
+from typing import Optional, Iterable
 
 from buz.event import Event, EventBus
+from buz.event.transactional_outbox import OutboxRecord
 from buz.event.transactional_outbox.event_to_outbox_record_translator import EventToOutboxRecordTranslator
 from buz.event.transactional_outbox.outbox_record_validation.outbox_record_validator import OutboxRecordValidator
 from buz.event.transactional_outbox.outbox_repository import OutboxRepository
@@ -18,16 +19,16 @@ class TransactionalOutboxEventBus(EventBus):
         self.__outbox_record_validator = outbox_record_validator
 
     def publish(self, event: Event) -> None:
-        """
-        Raises:
-            OutboxRecordValidationException: If any validation inside outbox_record_validator fails.
-        """
+        outbox_record = self.__translate_and_validate(event)
+        self.__outbox_repository.save(outbox_record)
+
+    def bulk_publish(self, events: Iterable[Event]) -> None:
+        outbox_records = map(self.__translate_and_validate, events)
+        self.__outbox_repository.bulk_create(outbox_records)
+
+    # Raises OutboxRecordValidationException: If any validation inside outbox_record_validator fails
+    def __translate_and_validate(self, event: Event) -> OutboxRecord:
         outbox_record = self.__event_to_outbox_record_translator.translate(event)
         if self.__outbox_record_validator is not None:
             self.__outbox_record_validator.validate(record=outbox_record)
-
-        self.__outbox_repository.save(outbox_record)
-
-    def bulk_publish(self, events: Collection[Event]) -> None:
-        for event in events:
-            self.publish(event)
+        return outbox_record

buz/kafka/__init__.py

@@ -1,18 +1,32 @@
+from buz.kafka.domain.exceptions.not_all_partition_assigned_exception import NotAllPartitionAssignedException
+from buz.kafka.domain.exceptions.not_valid_kafka_message_exception import NotValidKafkaMessageException
 from buz.kafka.domain.exceptions.topic_already_created_exception import KafkaTopicsAlreadyCreatedException
+from buz.kafka.domain.exceptions.topic_not_found_exception import TopicNotFoundException
+from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
 from buz.kafka.domain.models.consumer_initial_offset_position import ConsumerInitialOffsetPosition
 from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
+from buz.kafka.domain.models.kafka_connection_credentials import KafkaConnectionCredentials
+from buz.kafka.domain.models.kafka_connection_plain_text_credentials import KafkaConnectionPlainTextCredentials
+from buz.kafka.domain.models.kafka_connection_sasl_credentials import KafkaConnectionSaslCredentials
 from buz.kafka.domain.models.kafka_consumer_record import KafkaConsumerRecord
+from buz.kafka.domain.models.kafka_supported_sasl_mechanisms import KafkaSupportedSaslMechanisms
 from buz.kafka.domain.models.kafka_supported_security_protocols import KafkaSupportedSecurityProtocols
 from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
 from buz.kafka.domain.services.kafka_admin_test_client import KafkaAdminTestClient
 from buz.kafka.domain.services.kafka_producer import KafkaProducer
-from buz.kafka.infrastructure.kafka_python.factories.kafka_python_producer_factory import KafkaPythonProducerFactory
+from buz.kafka.infrastructure.aiokafka.aiokafka_producer import AIOKafkaProducer
 from buz.kafka.infrastructure.kafka_python.kafka_python_admin_client import KafkaPythonAdminClient
 from buz.kafka.infrastructure.kafka_python.kafka_python_admin_test_client import KafkaPythonAdminTestClient
 from buz.kafka.infrastructure.kafka_python.kafka_python_producer import KafkaPythonProducer
 from buz.kafka.infrastructure.serializers.byte_serializer import ByteSerializer
 from buz.kafka.infrastructure.serializers.implementations.json_byte_serializer import JSONByteSerializer
+from buz.kafka.domain.models.kafka_supported_compression_type import KafkaSupportedCompressionType
+from buz.event.infrastructure.buz_kafka.exceptions.kafka_event_bus_config_not_valid_exception import (
+    KafkaEventBusConfigNotValidException,
+)
+from buz.event.infrastructure.buz_kafka.async_buz_kafka_event_bus import AsyncBuzKafkaEventBus
+from buz.event.infrastructure.buz_kafka.buz_kafka_event_bus import BuzKafkaEventBus
 
 
 __all__ = [
@@ -22,7 +36,6 @@ __all__ = [
     "KafkaAdminTestClient",
     "KafkaPythonAdminClient",
     "KafkaPythonAdminTestClient",
-    "KafkaPythonProducerFactory",
     "KafkaTopicsAlreadyCreatedException",
     "KafkaConsumerRecord",
     "CreateKafkaTopic",
@@ -31,4 +44,17 @@ __all__ = [
     "ByteSerializer",
     "JSONByteSerializer",
     "ConsumerInitialOffsetPosition",
+    "KafkaSupportedCompressionType",
+    "KafkaEventBusConfigNotValidException",
+    "AsyncBuzKafkaEventBus",
+    "BuzKafkaEventBus",
+    "AutoCreateTopicConfiguration",
+    "NotAllPartitionAssignedException",
+    "NotValidKafkaMessageException",
+    "TopicNotFoundException",
+    "KafkaConnectionCredentials",
+    "KafkaConnectionPlainTextCredentials",
+    "KafkaConnectionSaslCredentials",
+    "KafkaSupportedSaslMechanisms",
+    "AIOKafkaProducer",
 ]

buz/kafka/domain/exceptions/not_all_partition_assigned_exception.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+
+class NotAllPartitionAssignedException(Exception):
+    def __init__(self, topic_name: str) -> None:
+        super().__init__(
+            f'Not all the partition were assigned for the topic "{topic_name}", please disconnect the rest of subscribers'
+        )

buz/kafka/domain/exceptions/topic_not_found_exception.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+
+class TopicNotFoundException(Exception):
+    def __init__(self, topic_name: str) -> None:
+        super().__init__(f'The topic "{topic_name}", has not been found')

buz/kafka/domain/models/kafka_supported_compression_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class KafkaSupportedCompressionType(Enum):
+    GZIP = "gzip"
+    SNAPPY = "snappy"
+    LZ4 = "lz4"
+    ZSTD = "zstd"

buz/kafka/domain/services/async_kafka_producer.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from abc import abstractmethod, ABC
+from typing import Generic, Optional, TypeVar
+
+from buz.kafka.infrastructure.interfaces.async_connection_manager import AsyncConnectionManager
+
+T = TypeVar("T")
+
+
+class AsyncKafkaProducer(AsyncConnectionManager, ABC, Generic[T]):
+    @abstractmethod
+    async def produce(
+        self,
+        *,
+        topic: str,
+        message: T,
+        partition_key: Optional[str] = None,
+        headers: Optional[dict[str, str]] = None,
+    ) -> None:
+        pass

buz/kafka/domain/services/kafka_admin_client.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
 from abc import abstractmethod, ABC
+from datetime import datetime
 from typing import Sequence
 
 from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
+from buz.kafka.infrastructure.interfaces.connection_manager import ConnectionManager
 
 DEFAULT_NUMBER_OF_MESSAGES_TO_POLLING = 999
 
 
-class KafkaAdminClient(ABC):
+class KafkaAdminClient(ConnectionManager, ABC):
     @abstractmethod
     def create_topics(
         self,
@@ -37,3 +39,16 @@ class KafkaAdminClient(ABC):
         self,
     ) -> set[str]:
         pass
+
+    # This function moves the following offset from the provided date
+    # if there are no messages with a date greater than the provided offset
+    # the offset will be moved to the end
+    @abstractmethod
+    def move_offsets_to_datetime(
+        self,
+        *,
+        consumer_group: str,
+        topic: str,
+        target_datetime: datetime,
+    ) -> None:
+        pass

buz/kafka/domain/services/kafka_producer.py

@@ -3,10 +3,12 @@ from __future__ import annotations
 from abc import abstractmethod, ABC
 from typing import Generic, Optional, TypeVar
 
+from buz.kafka.infrastructure.interfaces.connection_manager import ConnectionManager
+
 T = TypeVar("T")
 
 
-class KafkaProducer(ABC, Generic[T]):
+class KafkaProducer(ConnectionManager, ABC, Generic[T]):
     @abstractmethod
     def produce(
         self,

buz/kafka/infrastructure/aiokafka/aiokafka_consumer.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from logging import Logger
-from ssl import SSLContext
 from typing import Awaitable, Callable, Optional, Sequence, cast
 
 from aiokafka import AIOKafkaConsumer as AIOKafkaNativeConsumer, TopicPartition, OffsetAndMetadata
@@ -69,21 +68,25 @@ class AIOKafkaConsumer:
             )
 
     def __generate_consumer(self) -> AIOKafkaNativeConsumer:
-        sasl_mechanism: Optional[str] = None
-        ssl_context: Optional[SSLContext] = None
-
         if self.__auto_create_topic_configuration is not None:
             self.__ensure_topics_are_created(self.__auto_create_topic_configuration)
 
-        if self.__connection_config.credentials.sasl_mechanism is not None:
-            sasl_mechanism = self.__connection_config.credentials.sasl_mechanism.value
+        sasl_mechanism = (
+            self.__connection_config.credentials.sasl_mechanism.value
+            if self.__connection_config.credentials.sasl_mechanism
+            else "PLAIN"
+        )
+
+        ssl_context = (
+            create_ssl_context()
+            if self.__connection_config.credentials.security_protocol == KafkaSupportedSecurityProtocols.SASL_SSL
+            else None
+        )
 
-        if self.__connection_config.credentials.security_protocol == KafkaSupportedSecurityProtocols.SASL_SSL:
-            ssl_context = create_ssl_context()
         consumer = AIOKafkaNativeConsumer(
             None,
             ssl_context=ssl_context,
-            bootstrap_servers=self.__connection_config.bootstrap_servers,
+            bootstrap_servers=",".join(self.__connection_config.bootstrap_servers),
             security_protocol=self.__connection_config.credentials.security_protocol.value,
             sasl_mechanism=sasl_mechanism,
             sasl_plain_username=self.__connection_config.credentials.user,