infrahub-server 1.3.5__py3-none-any.whl → 1.4.0b0__py3-none-any.whl

infrahub/server.py

@@ -23,8 +23,8 @@ from infrahub import __version__, config
 from infrahub.api import router as api
 from infrahub.api.exception_handlers import generic_api_exception_handler
 from infrahub.components import ComponentType
+from infrahub.constants.environment import INSTALLATION_TYPE
 from infrahub.core.initialization import initialization
-from infrahub.database import InfrahubDatabase, InfrahubDatabaseMode, get_db
 from infrahub.dependencies.registry import build_component_registry
 from infrahub.exceptions import Error, ValidationError
 from infrahub.graphql.api.endpoints import router as graphql_router
@@ -32,18 +32,24 @@ from infrahub.lock import initialize_lock
 from infrahub.log import clear_log_context, get_logger, set_log_data
 from infrahub.middleware import InfrahubCORSMiddleware
 from infrahub.services import InfrahubServices
-from infrahub.services.adapters.cache import InfrahubCache
-from infrahub.services.adapters.message_bus import InfrahubMessageBus
-from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
-from infrahub.services.adapters.workflow.worker import WorkflowWorkerExecution
 from infrahub.trace import add_span_exception, configure_trace, get_traceid
 from infrahub.worker import WORKER_IDENTITY
+from infrahub.workers.dependencies import (
+    get_cache,
+    get_component,
+    get_database,
+    get_installation_type,
+    get_message_bus,
+    get_workflow,
+    set_component_type,
+)
 
 CURRENT_DIRECTORY = Path(__file__).parent.resolve()
 
 
 async def app_initialization(application: FastAPI, enable_scheduler: bool = True) -> None:
     config.SETTINGS.initialize_and_exit()
+    _validate_feature_selection(configuration=config.SETTINGS.active_settings)
 
     # Initialize trace
     if config.SETTINGS.trace.enable:
@@ -55,27 +61,24 @@ async def app_initialization(application: FastAPI, enable_scheduler: bool = True
             exporter_protocol=config.SETTINGS.trace.exporter_protocol,
         )
 
+    component_type = ComponentType.API_SERVER
+    set_component_type(component_type=component_type)
+
     # Initialize database Driver and load local registry
-    database = application.state.db = InfrahubDatabase(mode=InfrahubDatabaseMode.DRIVER, driver=await get_db())
+    database = application.state.db = await get_database()
 
     build_component_registry()
 
-    workflow = config.OVERRIDE.workflow or (
-        WorkflowWorkerExecution()
-        if config.SETTINGS.workflow.driver == config.WorkflowDriver.WORKER
-        else WorkflowLocalExecution()
-    )
-    component_type = ComponentType.API_SERVER
-    message_bus = config.OVERRIDE.message_bus or await InfrahubMessageBus.new_from_driver(
-        component_type=component_type, driver=config.SETTINGS.broker.driver
-    )
-
-    cache = config.OVERRIDE.cache or (await InfrahubCache.new_from_driver(driver=config.SETTINGS.cache.driver))
+    workflow = get_workflow()
+    message_bus = await get_message_bus()
+    cache = await get_cache()
+    component = await get_component()
     service = await InfrahubServices.new(
         cache=cache,
         database=database,
         message_bus=message_bus,
         workflow=workflow,
+        component=component,
         component_type=component_type,
     )
     initialize_lock(service=service)
@@ -212,3 +215,12 @@ async def documentation() -> RedirectResponse:
 @app.get("/{rest_of_path:path}", include_in_schema=False)
 async def react_app(req: Request, rest_of_path: str) -> Response:  # noqa: ARG001
     return templates.TemplateResponse("index.html", {"request": req})
+
+
+def _validate_feature_selection(configuration: config.Settings) -> None:
+    if configuration.enterprise_features and not configuration.dev.allow_enterprise_configuration:
+        installation_type = get_installation_type()
+        if installation_type == INSTALLATION_TYPE:
+            raise ValidationError(
+                f"Enterprise features [{','.join(configuration.enterprise_features)}] are not supported when running Infrahub 'community'."
+            )

infrahub/services/__init__.py

@@ -9,9 +9,7 @@ from infrahub.message_bus.messages import ROUTING_KEY_MAP
 
 from .adapters.event import InfrahubEventService
 from .adapters.http.httpx import HttpxAdapter
-from .adapters.workflow.local import WorkflowLocalExecution
 from .adapters.workflow.worker import WorkflowWorkerExecution
-from .component import InfrahubComponent
 from .scheduler import InfrahubScheduler
 
 if TYPE_CHECKING:
@@ -25,6 +23,7 @@ if TYPE_CHECKING:
     from .adapters.http import InfrahubHTTP
     from .adapters.message_bus import InfrahubMessageBus
     from .adapters.workflow import InfrahubWorkflow
+    from .component import InfrahubComponent
     from .protocols import InfrahubLogger
 
 
@@ -54,6 +53,7 @@ class InfrahubServices:
         database: InfrahubDatabase | None = None,
         message_bus: InfrahubMessageBus | None = None,
         workflow: InfrahubWorkflow | None = None,
+        component: InfrahubComponent | None = None,
     ):
         """
         This method should not be called directly, use `new` instead for a proper initialization.
@@ -64,12 +64,12 @@ class InfrahubServices:
         self._database = database
         self._message_bus = message_bus
         self._workflow = workflow
+        self._component = component
         self.log = log
         self.component_type = component_type
         self.http = http
         self.event = event
         self.scheduler = scheduler
-        self._component = None
 
     @classmethod
     async def new(
@@ -81,6 +81,7 @@ class InfrahubServices:
         message_bus: InfrahubMessageBus | None = None,
         workflow: InfrahubWorkflow | None = None,
         log: InfrahubLogger | None = None,
+        component: InfrahubComponent | None = None,
         component_type: ComponentType | None = None,
         http: InfrahubHTTP | None = None,
     ) -> InfrahubServices:
@@ -99,6 +100,7 @@ class InfrahubServices:
             message_bus=message_bus,
             workflow=workflow,
             log=log or get_logger(),
+            component=component,
             component_type=component_type,
             scheduler=scheduler,
             event=event or InfrahubEventService(message_bus),
@@ -108,31 +110,12 @@ class InfrahubServices:
         # 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
+        if workflow is not None and 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())
 
         return service
 
@@ -181,6 +164,8 @@ class InfrahubServices:
     async def shutdown(self) -> None:
         await self.scheduler.shutdown()
         await self.message_bus.shutdown()
+        if self._cache is not None:
+            await self._cache.close_connection()
 
     async def send(self, message: InfrahubMessage, delay: MessageTTL | None = None, is_retry: bool = False) -> None:
         routing_key = ROUTING_KEY_MAP.get(type(message))

infrahub/services/adapters/cache/__init__.py

@@ -51,3 +51,7 @@ class InfrahubCache(ABC):
     @classmethod
     async def new(cls) -> InfrahubCache:
         raise NotImplementedError()
+
+    @abstractmethod
+    async def close_connection(self) -> None:
+        raise NotImplementedError()

infrahub/services/adapters/cache/nats.py

@@ -149,3 +149,5 @@ class NATSCache(InfrahubCache):
                 return False
         await self._get_kv(key).put(key=key, value=value.encode())
         return True
+
+    async def close_connection(self) -> None: ...

infrahub/services/adapters/cache/redis.py

@@ -54,3 +54,6 @@ class RedisCache(InfrahubCache):
     @classmethod
     async def new(cls) -> RedisCache:
         return cls()
+
+    async def close_connection(self) -> None:
+        await self.connection.aclose()

infrahub/services/adapters/message_bus/__init__.py

@@ -13,7 +13,6 @@ if TYPE_CHECKING:
     from infrahub.config import BrokerDriver, BrokerSettings
     from infrahub.message_bus import InfrahubMessage, InfrahubResponse
     from infrahub.message_bus.types import MessageTTL
-    from infrahub.services import InfrahubServices
 
 
 class InfrahubMessageBus(ABC):
@@ -32,7 +31,6 @@ class InfrahubMessageBus(ABC):
     ]
     event_bindings: list[str] = ["refresh.registry.*"]
     broadcasted_event_bindings: list[str] = ["refresh.git.*"]
-    service: InfrahubServices
 
     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"""

infrahub/services/adapters/message_bus/local.py

@@ -36,8 +36,7 @@ class BusSimulator(InfrahubMessageBus):
         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)
+        await execute_message(routing_key=routing_key, message_body=message.body, message_bus=self)
 
     async def reply(self, message: InfrahubMessage, routing_key: str) -> None:  # noqa: ARG002
         correlation_id = message.meta.correlation_id or "default"

infrahub/services/adapters/message_bus/nats.py

@@ -12,7 +12,7 @@ from opentelemetry.instrumentation.utils import is_instrumentation_enabled
 
 from infrahub import config
 from infrahub.components import ComponentType
-from infrahub.log import clear_log_context, get_log_data
+from infrahub.log import clear_log_context, get_log_data, get_logger
 from infrahub.message_bus import InfrahubMessage, Meta, messages
 from infrahub.message_bus.operations import execute_message
 from infrahub.services.adapters.message_bus import InfrahubMessageBus
@@ -21,7 +21,6 @@ from infrahub.worker import WORKER_IDENTITY
 if TYPE_CHECKING:
     from infrahub.config import BrokerSettings
     from infrahub.message_bus.types import MessageTTL
-    from infrahub.services import InfrahubServices
 
 MessageFunction = Callable[[InfrahubMessage], Awaitable[None]]
 ResponseClass = TypeVar("ResponseClass")
@@ -38,7 +37,6 @@ class NATSMessageBus(InfrahubMessageBus):
     def __init__(self, component_type: ComponentType, settings: BrokerSettings | None = None) -> None:
         self.settings = settings or config.SETTINGS.broker
 
-        self.service: InfrahubServices
         self.connection: nats.NATS
         self.jetstream: nats.js.JetStreamContext
         self.callback_queue: nats.js.api.StreamInfo
@@ -102,9 +100,9 @@ class NATSMessageBus(InfrahubMessageBus):
 
                 clear_log_context()
                 if message.subject in messages.MESSAGE_MAP:
-                    await execute_message(routing_key=message.subject, message_body=message.data, service=self.service)
+                    await execute_message(routing_key=message.subject, message_body=message.data, message_bus=self)
                 else:
-                    self.service.log.error("Invalid message received", message=f"{message!r}")
+                    get_logger().error("Invalid message received", message=f"{message!r}")
         finally:
             if is_instrumentation_enabled() and message.headers:
                 context.detach(token)
@@ -121,12 +119,12 @@ class NATSMessageBus(InfrahubMessageBus):
                 clear_log_context()
                 if message.subject in messages.MESSAGE_MAP:
                     delay = await execute_message(
-                        routing_key=message.subject, message_body=message.data, service=self.service
+                        routing_key=message.subject, message_body=message.data, message_bus=self
                     )
                     if delay:
                         return await message.nak(delay / 1000)
                 else:
-                    self.service.log.error("Invalid message received", message=f"{message!r}")
+                    get_logger().error("Invalid message received", message=f"{message!r}")
 
                 return await message.ack()
         finally:
@@ -292,7 +290,7 @@ class NATSMessageBus(InfrahubMessageBus):
             request_id=request_id, correlation_id=correlation_id, reply_to=self.callback_queue.config.name
         )
 
-        await self.service.message_bus.send(message=message)
+        await self.send(message=message)
 
         response: nats.aio.msg.Msg = await future
         data = ujson.loads(response.data)

infrahub/services/adapters/message_bus/rabbitmq.py

@@ -12,7 +12,7 @@ from opentelemetry.semconv.trace import SpanAttributes
 
 from infrahub import config
 from infrahub.components import ComponentType
-from infrahub.log import clear_log_context, get_log_data
+from infrahub.log import clear_log_context, get_log_data, get_logger
 from infrahub.message_bus import InfrahubMessage, Meta, messages
 from infrahub.message_bus.operations import execute_message
 from infrahub.message_bus.types import MessageTTL
@@ -30,7 +30,6 @@ if TYPE_CHECKING:
     from opentelemetry.instrumentation.aio_pika.span_builder import SpanBuilder
 
     from infrahub.config import BrokerSettings
-    from infrahub.services import InfrahubServices
 
 MessageFunction = Callable[[InfrahubMessage], Awaitable[None]]
 ResponseClass = TypeVar("ResponseClass")
@@ -72,7 +71,6 @@ class RabbitMQMessageBus(InfrahubMessageBus):
         self.channel: AbstractChannel
         self.exchange: AbstractExchange
         self.delayed_exchange: AbstractExchange
-        self.service: InfrahubServices  # Needed because we inject `service` while sending messages.
         self.connection: AbstractRobustConnection
         self.callback_queue: AbstractQueue
         self.events_queue: AbstractQueue
@@ -130,23 +128,23 @@ class RabbitMQMessageBus(InfrahubMessageBus):
 
         clear_log_context()
         if message.routing_key in messages.MESSAGE_MAP:
-            await execute_message(routing_key=message.routing_key, message_body=message.body, service=self.service)
+            await execute_message(routing_key=message.routing_key, message_body=message.body, message_bus=self)
         else:
-            self.service.log.error("Invalid message received", message=f"{message!r}")
+            get_logger().error("Invalid message received", message=f"{message!r}")
 
     async def on_message(self, message: AbstractIncomingMessage) -> None:
         async with message.process():
             clear_log_context()
             if message.routing_key in messages.MESSAGE_MAP:
-                await execute_message(routing_key=message.routing_key, message_body=message.body, service=self.service)
+                await execute_message(routing_key=message.routing_key, message_body=message.body, message_bus=self)
             else:
-                self.service.log.error("Invalid message received", message=f"{message!r}")
+                get_logger().error("Invalid message received", message=f"{message!r}")
 
     async def on_reconnect(
         self,
         weak: bool = False,  # noqa: ARG002
     ) -> None:
-        self.service.log.info("Reconnected to RabbitMQ, reinitializing connection")
+        get_logger().info("Reconnected to RabbitMQ, reinitializing connection")
         await self._initialize_connection()
 
     async def _initialize_api_server(self) -> None:
@@ -246,7 +244,7 @@ class RabbitMQMessageBus(InfrahubMessageBus):
         request_id = log_data.get("request_id", "")
         message.meta = Meta(request_id=request_id, correlation_id=correlation_id, reply_to=self.callback_queue.name)
 
-        await self.service.message_bus.send(message=message)
+        await self.send(message=message)
 
         response: AbstractIncomingMessage = await future
         data = ujson.loads(response.body)

infrahub/services/adapters/workflow/__init__.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Any, Callable, ParamSpec, TypeVar, overload
 if TYPE_CHECKING:
     from infrahub.context import InfrahubContext
     from infrahub.workflows.models import WorkflowDefinition, WorkflowInfo
+
 Return = TypeVar("Return")
 Params = ParamSpec("Params")
 

infrahub/services/adapters/workflow/local.py

@@ -5,19 +5,16 @@ from typing import Any
 
 from typing_extensions import TYPE_CHECKING
 
-from infrahub.workers.utils import inject_context_parameter, inject_service_parameter
+from infrahub.workers.utils import inject_context_parameter
 from infrahub.workflows.models import WorkflowDefinition, WorkflowInfo
 
 from . import InfrahubWorkflow, Return
 
 if TYPE_CHECKING:
     from infrahub.context import InfrahubContext
-    from infrahub.services import InfrahubServices
 
 
 class WorkflowLocalExecution(InfrahubWorkflow):
-    service: InfrahubServices | None = None  # needed for local injections
-
     async def execute_workflow(
         self,
         workflow: WorkflowDefinition,
@@ -26,12 +23,8 @@ class WorkflowLocalExecution(InfrahubWorkflow):
         parameters: dict[str, Any] | None = None,
         tags: list[str] | None = None,  # noqa: ARG002
     ) -> Any:
-        if self.service is None:
-            raise ValueError("WorkflowLocalExecution.service is not initialized")
-
         flow_func = workflow.load_function()
         parameters = dict(parameters) if parameters is not None else {}  # avoid mutating input parameters
-        inject_service_parameter(func=flow_func, parameters=parameters, service=self.service)
         inject_context_parameter(func=flow_func, parameters=parameters, context=context)
 
         parameters = flow_func.validate_parameters(parameters=parameters)

infrahub/services/component.py

@@ -15,7 +15,8 @@ from infrahub.worker import WORKER_IDENTITY
 
 if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
-    from infrahub.services import InfrahubCache, InfrahubMessageBus
+    from infrahub.services import InfrahubCache
+    from infrahub.services.adapters.message_bus import InfrahubMessageBus
 
 PRIMARY_API_SERVER = "workers:primary:api_server"
 WORKER_MATCH = re.compile(r":worker:([^:]+)")

infrahub/task_manager/event.py

@@ -172,6 +172,46 @@ class PrefectEventData(PrefectEventModel):
 
         return {"members": members, "ancestors": ancestors}
 
+    def _return_proposed_change_event(self) -> dict[str, Any]:
+        data = {}
+        for resource in self.related:
+            if resource.role != "infrahub.related.node":
+                continue
+            match self.event:
+                case "infrahub.proposed_change.merged":
+                    data.update(
+                        {
+                            "merged_by_account_id": resource.get("infrahub.node.id"),
+                            "merged_by_account_name": resource.get("infrahub.merged_by.account.name"),
+                        }
+                    )
+                case "infrahub.proposed_change.review_requested":
+                    data.update(
+                        {
+                            "requested_by_account_id": resource.get("infrahub.node.id"),
+                            "requested_by_account_name": resource.get("infrahub.requested_by.account.name"),
+                        }
+                    )
+                case (
+                    "infrahub.proposed_change.approved"
+                    | "infrahub.proposed_change.rejected"
+                    | "infrahub.proposed_change.approval_revoked"
+                    | "infrahub.proposed_change.rejection_revoked"
+                ):
+                    data.update(
+                        {
+                            "reviewer_account_id": resource.get("infrahub.node.id"),
+                            "reviewer_account_name": resource.get("infrahub.reviewer.account.name"),
+                        }
+                    )
+        return data
+
+    def _return_proposed_change_reviewer_decision(self) -> dict[str, Any]:
+        return {"reviewer_decision": self.resource.get("infrahub.proposed_change.reviewer_decision")}
+
+    def _return_proposed_change_reviewer_former_decision(self) -> dict[str, Any]:
+        return {"reviewer_former_decision": self.resource.get("infrahub.proposed_change.reviewer_former_decision")}
+
     def _return_event_specifics(self) -> dict[str, Any]:
         """Return event specific data based on the type of event being processed"""
 
@@ -192,6 +232,18 @@ class PrefectEventData(PrefectEventModel):
                 event_specifics = self._return_branch_rebased()
             case "infrahub.group.member_added" | "infrahub.group.member_removed":
                 event_specifics = self._return_group_event()
+            case "infrahub.proposed_change.approved" | "infrahub.proposed_change.rejected":
+                event_specifics = {
+                    **self._return_proposed_change_event(),
+                    **self._return_proposed_change_reviewer_decision(),
+                }
+            case "infrahub.proposed_change.approval_revoked" | "infrahub.proposed_change.rejection_revoked":
+                event_specifics = {
+                    **self._return_proposed_change_event(),
+                    **self._return_proposed_change_reviewer_former_decision(),
+                }
+            case "infrahub.proposed_change.review_requested" | "infrahub.proposed_change.merged":
+                event_specifics = self._return_proposed_change_event()
 
         return event_specifics
 

infrahub/task_manager/models.py

@@ -14,10 +14,12 @@ from prefect.events.filters import (
     EventRelatedFilter,
     EventResourceFilter,
 )
+from prefect.events.filters import EventOrder as PrefectEventOrder
 from prefect.events.schemas.events import ResourceSpecification
 from pydantic import BaseModel, Field
 
 from infrahub.core.timestamp import Timestamp
+from infrahub.events.constants import EventSortOrder
 
 from .constants import LOG_LEVEL_MAPPING
 
@@ -176,6 +178,7 @@ class InfrahubEventFilter(EventFilter):
     @classmethod
     def from_filters(
         cls,
+        order: EventSortOrder,
         ids: list[str] | None = None,
         account__ids: list[str] | None = None,
         related_node__ids: list[str] | None = None,
@@ -201,6 +204,12 @@ class InfrahubEventFilter(EventFilter):
         else:
             filters = cls()
 
+        match order:
+            case EventSortOrder.ASC:
+                filters.order = PrefectEventOrder.ASC
+            case EventSortOrder.DESC:
+                filters.order = PrefectEventOrder.DESC
+
         filters.add_event_filter(level=level, has_children=has_children)
         filters.add_event_id_filter(ids=ids)
         filters.add_event_type_filter(event_type=event_type, event_type_filter=event_type_filter)

infrahub/tasks/artifact.py

@@ -6,20 +6,19 @@ from infrahub import lock
 from infrahub.artifacts.models import CheckArtifactCreate
 from infrahub.core.constants import InfrahubKind
 from infrahub.git.models import RequestArtifactGenerate
-from infrahub.services import InfrahubServices
+from infrahub.workers.dependencies import get_client
 
 
 @task(name="define-artifact", task_run_name="Define Artifact", cache_policy=NONE)  # type: ignore[arg-type]
-async def define_artifact(
-    model: CheckArtifactCreate | RequestArtifactGenerate, service: InfrahubServices
-) -> tuple[InfrahubNode, bool]:
+async def define_artifact(model: CheckArtifactCreate | RequestArtifactGenerate) -> tuple[InfrahubNode, bool]:
     """Return an artifact together with a flag to indicate if the artifact is created now or already existed."""
+    client = get_client()
     created = False
     if model.artifact_id:
-        artifact = await service.client.get(kind=InfrahubKind.ARTIFACT, id=model.artifact_id, branch=model.branch_name)
+        artifact = await client.get(kind=InfrahubKind.ARTIFACT, id=model.artifact_id, branch=model.branch_name)
     else:
         async with lock.registry.get(f"{model.target_id}-{model.artifact_definition}", namespace="artifact"):
-            artifacts = await service.client.filters(
+            artifacts = await client.filters(
                 kind=InfrahubKind.ARTIFACT,
                 branch=model.branch_name,
                 definition__ids=[model.artifact_definition],
@@ -28,7 +27,7 @@ async def define_artifact(
             if artifacts:
                 artifact = artifacts[0]
             else:
-                artifact = await service.client.create(
+                artifact = await client.create(
                     kind=InfrahubKind.ARTIFACT,
                     branch=model.branch_name,
                     data={

infrahub/tasks/check.py

@@ -1,17 +1,14 @@
 from infrahub.log import get_logger
 from infrahub.message_bus import InfrahubMessage
 from infrahub.message_bus.types import KVTTL
-from infrahub.services import InfrahubServices
+from infrahub.workers.dependencies import get_cache
 
 log = get_logger()
 
 
-async def set_check_status(message: InfrahubMessage, conclusion: str, service: InfrahubServices) -> None:
+async def set_check_status(message: InfrahubMessage, conclusion: str) -> None:
     if message.meta.validator_execution_id and message.meta.check_execution_id:
         key = f"validator_execution_id:{message.meta.validator_execution_id}:check_execution_id:{message.meta.check_execution_id}"
-        await service.cache.set(
-            key=key,
-            value=conclusion,
-            expires=KVTTL.TWO_HOURS,
-        )
+        cache = await get_cache()
+        await cache.set(key=key, value=conclusion, expires=KVTTL.TWO_HOURS)
         log.debug("setting check status in cache", key=key, conclusion=conclusion)