infrahub-server 1.1.6__py3-none-any.whl → 1.2.0rc0__py3-none-any.whl

infrahub/services/__init__.py

@@ -1,50 +1,168 @@
-from typing import Awaitable, Callable, Optional
+from __future__ import annotations
 
-from infrahub_sdk import InfrahubClient
+from typing import TYPE_CHECKING, Awaitable, Callable, Optional
 
 from infrahub.components import ComponentType
-from infrahub.database import InfrahubDatabase
 from infrahub.exceptions import InitializationError
 from infrahub.log import get_logger
-from infrahub.message_bus import InfrahubMessage, InfrahubResponse
 from infrahub.message_bus.messages import ROUTING_KEY_MAP
-from infrahub.message_bus.types import MessageTTL
 
-from .adapters.cache import InfrahubCache
 from .adapters.event import InfrahubEventService
-from .adapters.http import InfrahubHTTP
 from .adapters.http.httpx import HttpxAdapter
-from .adapters.message_bus import InfrahubMessageBus
-from .adapters.workflow import InfrahubWorkflow
+from .adapters.workflow.local import WorkflowLocalExecution
+from .adapters.workflow.worker import WorkflowWorkerExecution
 from .component import InfrahubComponent
-from .protocols import InfrahubLogger
 from .scheduler import InfrahubScheduler
 
+if TYPE_CHECKING:
+    from infrahub_sdk import InfrahubClient
+
+    from infrahub.database import InfrahubDatabase
+    from infrahub.message_bus import InfrahubMessage
+    from infrahub.message_bus.types import MessageTTL
+
+    from .adapters.cache import InfrahubCache
+    from .adapters.http import InfrahubHTTP
+    from .adapters.message_bus import InfrahubMessageBus
+    from .adapters.workflow import InfrahubWorkflow
+    from .protocols import InfrahubLogger
+
 
 class InfrahubServices:
+    _cache: InfrahubCache | None
+    _client: InfrahubClient | None
+    _database: InfrahubDatabase | None
+    _message_bus: InfrahubMessageBus | None
+    _workflow: InfrahubWorkflow | None
+    _component: InfrahubComponent | None
+
+    log: InfrahubLogger
+    component_type: ComponentType
+    http: InfrahubHTTP
+    event: InfrahubEventService
+    scheduler: InfrahubScheduler
+
     def __init__(
         self,
-        cache: Optional[InfrahubCache] = None,
-        client: Optional[InfrahubClient] = None,
-        database: Optional[InfrahubDatabase] = None,
-        message_bus: Optional[InfrahubMessageBus] = None,
-        http: InfrahubHTTP | None = None,
-        workflow: Optional[InfrahubWorkflow] = None,
-        event: InfrahubEventService | None = None,
-        log: Optional[InfrahubLogger] = None,
-        component_type: Optional[ComponentType] = None,
-    ) -> None:
-        self.cache = cache or InfrahubCache()
+        log: InfrahubLogger,
+        component_type: ComponentType,
+        http: InfrahubHTTP,
+        event: InfrahubEventService,
+        scheduler: InfrahubScheduler,
+        cache: InfrahubCache | None = None,
+        client: InfrahubClient | None = None,
+        database: InfrahubDatabase | None = None,
+        message_bus: InfrahubMessageBus | None = None,
+        workflow: InfrahubWorkflow | None = None,
+    ):
+        """
+        This method should not be called directly, use `new` instead for a proper initialization.
+        """
+
+        self._cache = cache
         self._client = client
         self._database = database
-        self.message_bus = message_bus or InfrahubMessageBus()
-        self.workflow = workflow or InfrahubWorkflow()
-        self.event = event or InfrahubEventService()
-        self.log = log or get_logger()
-        self.component_type = component_type or ComponentType.NONE
-        self.http = http or HttpxAdapter()
-        self.scheduler = InfrahubScheduler()
-        self.component = InfrahubComponent()
+        self._message_bus = message_bus
+        self._workflow = workflow
+        self.log = log
+        self.component_type = component_type
+        self.http = http
+        self.event = event
+        self.scheduler = scheduler
+        self._component = None
+
+    @classmethod
+    async def new(
+        cls,
+        cache: InfrahubCache | None = None,
+        client: InfrahubClient | None = None,
+        database: InfrahubDatabase | None = None,
+        event: InfrahubEventService | None = None,
+        message_bus: InfrahubMessageBus | None = None,
+        workflow: InfrahubWorkflow | None = None,
+        log: InfrahubLogger | None = None,
+        component_type: ComponentType | None = None,
+        http: InfrahubHTTP | None = None,
+    ) -> InfrahubServices:
+        """
+        Instantiate InfrahubServices object, and finalize initializations of underlying services having a circular
+        dependency with InfrahubServices.
+        """
+
+        component_type = component_type or ComponentType.NONE
+
+        scheduler = InfrahubScheduler(component_type)
+        service = cls(
+            cache=cache,
+            client=client,
+            database=database,
+            message_bus=message_bus,
+            workflow=workflow,
+            log=log or get_logger(),
+            component_type=component_type,
+            scheduler=scheduler,
+            event=event or InfrahubEventService(message_bus),
+            http=http or HttpxAdapter(),
+        )
+
+        # This circular dependency could be removed if InfrahubScheduler only depends on what it needs.
+        scheduler.service = service
+
+        if message_bus is not None:
+            # Need circular dependency for injecting `service`  within `execute_message`. This might be removed
+            # using proper dependency injections.
+            message_bus.service = service
+
+            if cache is not None and database is not None:
+                component = await InfrahubComponent.new(
+                    cache=cache, component_type=component_type, db=database, message_bus=message_bus
+                )
+                # We need to post init `service._component` because InfrahubComponent.new relies on message_bus
+                # itself relying on service.
+                service._component = component
+
+        if workflow is not None:
+            if isinstance(workflow, WorkflowWorkerExecution):
+                assert service.component is not None
+                # Ideally `WorkflowWorkerExecution.initialize` would be directly part of WorkflowWorkerExecution
+                # constructor but this requires some redesign as it depends on InfrahubComponent which is instantiated
+                # after workflow instantiation.
+                await workflow.initialize(
+                    component_is_primary_server=await service.component.is_primary_gunicorn_worker()
+                )
+            elif isinstance(workflow, WorkflowLocalExecution):
+                # Circular dependency is only needed for injecting `service` within `execute_workflow` while testing.
+                workflow.service = service
+
+        return service
+
+    @property
+    def component(self) -> InfrahubComponent:
+        if not self._component:
+            raise InitializationError("Service is not initialized with a component")
+
+        return self._component
+
+    @property
+    def message_bus(self) -> InfrahubMessageBus:
+        if not self._message_bus:
+            raise InitializationError("Service is not initialized with a message bus")
+
+        return self._message_bus
+
+    @property
+    def workflow(self) -> InfrahubWorkflow:
+        if not self._workflow:
+            raise InitializationError("Service is not initialized with a workflow")
+
+        return self._workflow
+
+    @property
+    def cache(self) -> InfrahubCache:
+        if not self._cache:
+            raise InitializationError("Service is not initialized with a cache")
+
+        return self._cache
 
     @property
     def client(self) -> InfrahubClient:
@@ -53,9 +171,6 @@ class InfrahubServices:
 
         return self._client
 
-    def set_client(self, client: InfrahubClient | None) -> None:
-        self._client = client
-
     @property
     def database(self) -> InfrahubDatabase:
         if not self._database:
@@ -63,18 +178,7 @@ class InfrahubServices:
 
         return self._database
 
-    async def initialize(self) -> None:
-        """Initialize the Services"""
-        await self.message_bus.initialize(service=self)
-        await self.cache.initialize(service=self)
-        await self.http.initialize(service=self)
-        await self.component.initialize(service=self)
-        await self.scheduler.initialize(service=self)
-        await self.workflow.initialize(service=self)
-        await self.event.initialize(service=self)
-
     async def shutdown(self) -> None:
-        """Initialize the Services"""
         await self.scheduler.shutdown()
         await self.message_bus.shutdown()
 
@@ -84,24 +188,5 @@ class InfrahubServices:
             raise ValueError("Unable to determine routing key")
         await self.message_bus.publish(message, routing_key=routing_key, delay=delay, is_retry=is_retry)
 
-    async def reply(self, message: InfrahubResponse, initiator: InfrahubMessage) -> None:
-        if initiator.meta:
-            message.meta.correlation_id = initiator.meta.correlation_id
-            routing_key = initiator.meta.reply_to or ""
-            await self.message_bus.reply(message, routing_key=routing_key)
-
-
-class ServiceManager:
-    def __init__(self) -> None:
-        self.service = InfrahubServices()
-        self.send = self.service.send
-
-    def prepare(self, service: InfrahubServices) -> None:
-        self.service = service
-        self.send = self.service.send
-
 
 ServiceFunction = Callable[[InfrahubServices], Awaitable[None]]
-
-
-services = ServiceManager()

infrahub/services/adapters/cache/__init__.py

@@ -1,34 +1,36 @@
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
     from infrahub.message_bus.types import KVTTL
-    from infrahub.services import InfrahubServices
 
 
-class InfrahubCache:
+class InfrahubCache(ABC):
     """Base class for caching services"""
 
-    async def initialize(self, service: InfrahubServices) -> None:
-        """Initialize the cache"""
-
+    @abstractmethod
     async def delete(self, key: str) -> None:
         """Delete a key from the cache."""
         raise NotImplementedError()
 
+    @abstractmethod
     async def get(self, key: str) -> Optional[str]:
         """Retrieve a value from the cache."""
         raise NotImplementedError()
 
+    @abstractmethod
     async def get_values(self, keys: list[str]) -> list[Optional[str]]:
         """Return a list the values for requested keys."""
         raise NotImplementedError()
 
+    @abstractmethod
     async def list_keys(self, filter_pattern: str) -> list[str]:
         """Return a list of active keys that match the provided filter."""
         raise NotImplementedError()
 
+    @abstractmethod
     async def set(
         self, key: str, value: str, expires: Optional[KVTTL] = None, not_exists: bool = False
     ) -> Optional[bool]:

infrahub/services/adapters/cache/nats.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import ssl
-from typing import TYPE_CHECKING, Optional
+from typing import Optional
 
 import nats
 
@@ -9,26 +9,38 @@ from infrahub import config
 from infrahub.message_bus.types import KVTTL
 from infrahub.services.adapters.cache import InfrahubCache
 
-if TYPE_CHECKING:
-    from infrahub.services import InfrahubServices
+# Inherit from BaseModel to avoid implementing a `__init__` otherwise `cls(...)` fails.
 
 
 class NATSCache(InfrahubCache):
-    def __init__(self) -> None:
-        self.connection: nats.NATS
-        self.jetstream: nats.js.JetStreamContext
-        self.kv: dict[int, nats.js.kv.KeyValue]
-
+    connection: nats.NATS
+    jetstream: nats.js.JetStreamContext
+    kv: dict[int, nats.js.kv.KeyValue]
+    kv_buckets: dict[str, KVTTL]
+
+    def __init__(
+        self,
+        connection: nats.NATS,
+        jetstream: nats.js.JetStreamContext,
+        kv: dict[int, nats.js.kv.KeyValue],
+        kv_buckets: dict[str, KVTTL],
+    ):
+        self.connection = connection
+        self.jetstream = jetstream
+        self.kv = kv
+        self.kv_buckets = kv_buckets
+
+    @classmethod
+    async def new(cls) -> NATSCache:
         # FIXME: remove once NATS supports TTL for keys (2.11)
-        self.kv_buckets = {
-            self._tokenize_key_name("validator_execution_id:"): KVTTL.TWO_HOURS,
-            self._tokenize_key_name("workers:primary:"): KVTTL.FIFTEEN,
-            self._tokenize_key_name("workers:schema_hash:branch:"): KVTTL.TWO_HOURS,
-            self._tokenize_key_name("workers:active:"): KVTTL.FIFTEEN,
-            self._tokenize_key_name("workers:worker:"): KVTTL.TWO_HOURS,
+        kv_buckets = {
+            NATSCache._tokenize_key_name("validator_execution_id:"): KVTTL.TWO_HOURS,
+            NATSCache._tokenize_key_name("workers:primary:"): KVTTL.FIFTEEN,
+            NATSCache._tokenize_key_name("workers:schema_hash:branch:"): KVTTL.TWO_HOURS,
+            NATSCache._tokenize_key_name("workers:active:"): KVTTL.FIFTEEN,
+            NATSCache._tokenize_key_name("workers:worker:"): KVTTL.TWO_HOURS,
         }
 
-    async def initialize(self, service: InfrahubServices) -> None:
         tls_context = None
         if config.SETTINGS.cache.tls_enabled:
             tls_context = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH)
@@ -38,25 +50,27 @@ class NATSCache(InfrahubCache):
                 tls_context.check_hostname = False
                 tls_context.verify_mode = ssl.CERT_NONE
 
-        self.connection = await nats.connect(
+        connection = await nats.connect(
             f"nats://{config.SETTINGS.cache.address}:{config.SETTINGS.cache.service_port}",
             user=config.SETTINGS.cache.username,
             password=config.SETTINGS.cache.password,
             tls=tls_context,
         )
-
-        self.jetstream = self.connection.jetstream()
+        jetstream = connection.jetstream()
 
         kv_config = nats.js.api.KeyValueConfig(bucket=f"kv_{config.SETTINGS.cache.database}")
-        self.kv = {0: await self.jetstream.create_key_value(config=kv_config)}
+        kv = {0: await jetstream.create_key_value(config=kv_config)}
 
         # FIXME: remove once NATS supports TTL for keys (2.11)
         for ttl in KVTTL.variations():
             kv_config.bucket = f"kv_{config.SETTINGS.cache.database}_ttl_{ttl.name.lower()}"
             kv_config.ttl = ttl.value
-            self.kv[ttl.value] = await self.jetstream.create_key_value(config=kv_config)
+            kv[ttl.value] = await jetstream.create_key_value(config=kv_config)
+
+        return cls(kv_buckets=kv_buckets, kv=kv, connection=connection, jetstream=jetstream)
 
-    def _tokenize_key_name(self, key: str) -> str:
+    @staticmethod
+    def _tokenize_key_name(key: str) -> str:
         return key.replace(":", ".")
 
     # FIXME: remove once NATS supports TTL for keys (2.11)
@@ -121,7 +135,11 @@ class NATSCache(InfrahubCache):
         return [key.replace(".", ":") for key in keys]
 
     async def set(
-        self, key: str, value: str, expires: Optional[KVTTL] = None, not_exists: bool = False
+        self,
+        key: str,
+        value: str,
+        expires: Optional[KVTTL] = None,  # noqa: ARG002
+        not_exists: bool = False,
     ) -> Optional[bool]:
         key = self._tokenize_key_name(key)
         if not_exists:

infrahub/services/adapters/cache/redis.py

@@ -4,7 +4,6 @@ import redis.asyncio as redis
 
 from infrahub import config
 from infrahub.message_bus.types import KVTTL
-from infrahub.services import InfrahubServices
 from infrahub.services.adapters.cache import InfrahubCache
 
 
@@ -20,9 +19,6 @@ class RedisCache(InfrahubCache):
             ssl_ca_certs=config.SETTINGS.cache.tls_ca_file,
         )
 
-    async def initialize(self, service: InfrahubServices) -> None:
-        pass
-
     async def delete(self, key: str) -> None:
         await self.connection.delete(key)
 

infrahub/services/adapters/event/__init__.py

@@ -5,29 +5,18 @@ from typing import TYPE_CHECKING
 
 from prefect.events import emit_event
 
-from infrahub.exceptions import InitializationError
-
 if TYPE_CHECKING:
     from infrahub.events import InfrahubEvent
-    from infrahub.services import InfrahubServices
+    from infrahub.services import InfrahubMessageBus
 
 
 class InfrahubEventService:
     """Base class for infrahub event service"""
 
-    def __init__(self) -> None:
-        self._service: InfrahubServices | None = None
-
-    @property
-    def service(self) -> InfrahubServices:
-        if not self._service:
-            raise InitializationError("Event is not initialized with a service")
-
-        return self._service
-
-    async def initialize(self, service: InfrahubServices) -> None:
-        """Initialize the event service"""
-        self._service = service
+    def __init__(self, message_bus: InfrahubMessageBus | None = None) -> None:
+        # Ideally message_bus should not be optional, we let it like this for existing tests that
+        #  pass without a bus as corresponding tested events do not send bus messages.
+        self.message_bus = message_bus
 
     async def send(self, event: InfrahubEvent) -> None:
         tasks = [self._send_bus(event=event), self._send_prefect(event=event)]
@@ -35,12 +24,15 @@ class InfrahubEventService:
 
     async def _send_bus(self, event: InfrahubEvent) -> None:
         for message in event.get_messages():
-            await self.service.send(message=message)
+            if self.message_bus is None:
+                raise ValueError("InfrahubEventService.message_bus is None.")
+            await self.message_bus.send(message=message)
 
     async def _send_prefect(self, event: InfrahubEvent) -> None:
         emit_event(
+            id=event.meta.id,
             event=event.get_name(),
             resource=event.get_resource(),
             related=event.get_related(),
-            payload=event.get_payload(),
+            payload=event.get_event_payload(),
         )

infrahub/services/adapters/http/__init__.py

@@ -5,13 +5,8 @@ from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     import httpx
 
-    from infrahub.services import InfrahubServices
-
 
 class InfrahubHTTP:
-    async def initialize(self, service: InfrahubServices) -> None:
-        """Initialize the HTTP adapter"""
-
     async def get(
         self,
         url: str,

infrahub/services/adapters/http/httpx.py

@@ -2,30 +2,37 @@ from __future__ import annotations
 
 import ssl
 from functools import cached_property
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import httpx
 
 from infrahub import config
 from infrahub.exceptions import HTTPServerError, HTTPServerSSLError, HTTPServerTimeoutError
+from infrahub.log import get_logger
 from infrahub.services.adapters.http import InfrahubHTTP
 
-if TYPE_CHECKING:
-    from infrahub.services import InfrahubServices
+log = get_logger()
 
 
 class HttpxAdapter(InfrahubHTTP):
-    settings: config.HTTPSettings
-    service: InfrahubServices
+    """The HttpxAdapter is a generic interface for InfrahubHTTP
 
-    async def initialize(self, service: InfrahubServices) -> None:
-        """Initialize the HTTP adapter"""
-        self.service = service
-        self.settings = config.SETTINGS.http
+    The class provides a way to send HTTP requests from Infrahub for example
+    when sending webhooks, telemetry data or when communicating with SSO
+    providers. The main purpose is to have a single location to manage
+    configuration and error handling with regards to HTTP traffic and
+    allow users to define configurations such as timeout, TLS options
+    and eventually proxy settings in one location."""
 
-        # Cache the context during init, this is to avoid issue when a CA bundle might be accessible
-        # when Infrahub initializes but then removed before the first external HTTP call is made.
-        _ = self.tls_context
+    _settings: config.HTTPSettings | None = None
+
+    @property
+    def settings(self) -> config.HTTPSettings:
+        if self._settings:
+            return self._settings
+
+        self._settings = config.SETTINGS.http
+        return self._settings
 
     @cached_property
     def tls_context(self) -> ssl.SSLContext:
@@ -62,16 +69,16 @@ class HttpxAdapter(InfrahubHTTP):
                     **params,
                 )
             except ssl.SSLCertVerificationError as exc:
-                self.service.log.info(f"TLS verification failed for connection to {url}")
+                log.info(f"TLS verification failed for connection to {url}")
                 raise HTTPServerSSLError(message=f"Unable to validate TLS certificate for connection to {url}") from exc
             except httpx.ReadTimeout as exc:
-                self.service.log.info(f"Connection timed out when trying to reach {url}")
+                log.info(f"Connection timed out when trying to reach {url}")
                 raise HTTPServerTimeoutError(
                     message=f"Connection to {url} timed out after {self.settings.timeout}"
                 ) from exc
             except httpx.RequestError as exc:
                 # Catch all error from httpx
-                self.service.log.warning(f"Unhandled HTTP error for {url} ({exc})")
+                log.warning(f"Unhandled HTTP error for {url} ({exc})")
                 raise HTTPServerError(message=f"Unknown http error when connecting to {url}") from exc
 
         return response

infrahub/services/adapters/message_bus/__init__.py

@@ -1,16 +1,19 @@
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Optional, TypeVar
 
+from infrahub.message_bus.messages import ROUTING_KEY_MAP
+
 ResponseClass = TypeVar("ResponseClass")
 
 if TYPE_CHECKING:
-    from infrahub.message_bus import InfrahubMessage
+    from infrahub.message_bus import InfrahubMessage, InfrahubResponse
     from infrahub.message_bus.types import MessageTTL
     from infrahub.services import InfrahubServices
 
 
-class InfrahubMessageBus:
+class InfrahubMessageBus(ABC):
     DELIVER_TIMEOUT: int = 30 * 60  # 30 minutes
     worker_bindings: list[str] = [
         "check.*.*",
@@ -26,20 +29,34 @@ class InfrahubMessageBus:
     ]
     event_bindings: list[str] = ["refresh.registry.*"]
     broadcasted_event_bindings: list[str] = ["refresh.git.*"]
+    service: InfrahubServices
 
-    async def initialize(self, service: InfrahubServices) -> None:
-        """Initialize the Message bus"""
-
-    async def shutdown(self) -> None:
+    async def shutdown(self) -> None:  # noqa: B027 We want a default empty behavior, so it's ok to have an empty non-abstract method.
         """Shutdown the Message bus"""
 
+    @abstractmethod
     async def publish(
         self, message: InfrahubMessage, routing_key: str, delay: Optional[MessageTTL] = None, is_retry: bool = False
     ) -> None:
         raise NotImplementedError()
 
+    @abstractmethod
     async def reply(self, message: InfrahubMessage, routing_key: str) -> None:
         raise NotImplementedError()
 
+    @abstractmethod
     async def rpc(self, message: InfrahubMessage, response_class: type[ResponseClass]) -> ResponseClass:
         raise NotImplementedError()
+
+    async def send(self, message: InfrahubMessage, delay: Optional[MessageTTL] = None, is_retry: bool = False) -> None:
+        routing_key = ROUTING_KEY_MAP.get(type(message))
+        if not routing_key:
+            raise ValueError("Unable to determine routing key")
+        await self.publish(message, routing_key=routing_key, delay=delay, is_retry=is_retry)
+
+    # TODO rename it
+    async def reply_if_initiator_meta(self, message: InfrahubResponse, initiator: InfrahubMessage) -> None:
+        if initiator.meta:
+            message.meta.correlation_id = initiator.meta.correlation_id
+            routing_key = initiator.meta.reply_to or ""
+            await self.reply(message, routing_key=routing_key)

infrahub/services/adapters/message_bus/local.py

@@ -10,34 +10,36 @@ from infrahub.dependencies.registry import build_component_registry
 from infrahub.message_bus import InfrahubMessage, Meta
 from infrahub.message_bus.messages import ROUTING_KEY_MAP
 from infrahub.message_bus.operations import execute_message
-from infrahub.services import InfrahubServices
 from infrahub.services.adapters.message_bus import InfrahubMessageBus
 
 if TYPE_CHECKING:
-    from infrahub.database import InfrahubDatabase
     from infrahub.message_bus.types import MessageTTL
 
 ResponseClass = TypeVar("ResponseClass")
 
 
 class BusSimulator(InfrahubMessageBus):
-    def __init__(self, database: Optional[InfrahubDatabase] = None) -> None:
+    def __init__(self) -> None:
         self.messages: list[InfrahubMessage] = []
         self.messages_per_routing_key: dict[str, list[InfrahubMessage]] = {}
-        self.service: InfrahubServices = InfrahubServices(database=database, message_bus=self)
         self.replies: dict[str, list[InfrahubMessage]] = defaultdict(list)
         build_component_registry()
 
     async def publish(
-        self, message: InfrahubMessage, routing_key: str, delay: Optional[MessageTTL] = None, is_retry: bool = False
+        self,
+        message: InfrahubMessage,
+        routing_key: str,
+        delay: Optional[MessageTTL] = None,  # noqa: ARG002
+        is_retry: bool = False,  # noqa: ARG002
     ) -> None:
         self.messages.append(message)
         if routing_key not in self.messages_per_routing_key:
             self.messages_per_routing_key[routing_key] = []
         self.messages_per_routing_key[routing_key].append(message)
+        assert self.service is not None
         await execute_message(routing_key=routing_key, message_body=message.body, service=self.service)
 
-    async def reply(self, message: InfrahubMessage, routing_key: str) -> None:
+    async def reply(self, message: InfrahubMessage, routing_key: str) -> None:  # noqa: ARG002
         correlation_id = message.meta.correlation_id or "default"
         self.replies[correlation_id].append(message)