infrahub-server 1.2.3__py3-none-any.whl → 1.2.5__py3-none-any.whl

infrahub/graphql/mutations/main.py

@@ -363,7 +363,7 @@ class InfrahubMutationMixin:
         branch: Branch,
         db: InfrahubDatabase,
         obj: Node,
-        run_constraint_checks: bool = True,
+        skip_uniqueness_check: bool = False,
     ) -> tuple[Node, Self]:
         """
         Wrapper around mutate_update to potentially activate locking and call it within a database transaction.
@@ -378,11 +378,11 @@ class InfrahubMutationMixin:
             if lock_names:
                 async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
                     obj = await cls.mutate_update_object(
-                        db=db, info=info, data=data, branch=branch, obj=obj, run_constraint_checks=run_constraint_checks
+                        db=db, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
                     )
             else:
                 obj = await cls.mutate_update_object(
-                    db=db, info=info, data=data, branch=branch, obj=obj, run_constraint_checks=run_constraint_checks
+                    db=db, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
                 )
             result = await cls.mutate_update_to_graphql(db=db, info=info, obj=obj)
             return obj, result
@@ -396,11 +396,11 @@ class InfrahubMutationMixin:
                         data=data,
                         branch=branch,
                         obj=obj,
-                        run_constraint_checks=run_constraint_checks,
+                        skip_uniqueness_check=skip_uniqueness_check,
                     )
             else:
                 obj = await cls.mutate_update_object(
-                    db=dbt, info=info, data=data, branch=branch, obj=obj, run_constraint_checks=run_constraint_checks
+                    db=dbt, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
                 )
             result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=obj)
             return obj, result
@@ -434,7 +434,7 @@ class InfrahubMutationMixin:
         data: InputObjectType,
         branch: Branch,
         obj: Node,
-        run_constraint_checks: bool = True,
+        skip_uniqueness_check: bool = False,
     ) -> Node:
         component_registry = get_component_registry()
         node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
@@ -442,8 +442,9 @@ class InfrahubMutationMixin:
         before_mutate_profile_ids = await cls._get_profile_ids(db=db, obj=obj)
         await obj.from_graphql(db=db, data=data)
         fields_to_validate = list(data)
-        if run_constraint_checks:
-            await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
+        await node_constraint_runner.check(
+            node=obj, field_filters=fields_to_validate, skip_uniqueness_check=skip_uniqueness_check
+        )
 
         fields = list(data.keys())
         for field_to_remove in ("id", "hfid"):
@@ -494,7 +495,6 @@ class InfrahubMutationMixin:
         db = database or graphql_context.db
         dict_data = dict(data)
         node = None
-        run_constraint_checks = True
 
         if "id" in dict_data:
             node = await NodeManager.get_one(
@@ -506,7 +506,6 @@ class InfrahubMutationMixin:
                 db=db,
                 branch=branch,
                 obj=node,
-                run_constraint_checks=run_constraint_checks,
             )
             return updated_obj, mutation, False
 
@@ -525,7 +524,6 @@ class InfrahubMutationMixin:
                 db=db,
                 branch=branch,
                 obj=node,
-                run_constraint_checks=run_constraint_checks,
             )
             return updated_obj, mutation, False
 
@@ -545,7 +543,7 @@ class InfrahubMutationMixin:
                 db=db,
                 branch=branch,
                 obj=node,
-                run_constraint_checks=run_constraint_checks,
+                skip_uniqueness_check=True,
             )
             return updated_obj, mutation, False
 

infrahub/message_bus/messages/__init__.py

@@ -1,8 +1,6 @@
 from infrahub.message_bus import InfrahubMessage, InfrahubResponse
 
 from .check_generator_run import CheckGeneratorRun
-from .event_branch_merge import EventBranchMerge
-from .event_worker_newprimaryapi import EventWorkerNewPrimaryAPI
 from .finalize_validator_execution import FinalizeValidatorExecution
 from .git_file_get import GitFileGet, GitFileGetResponse
 from .git_repository_connectivity import GitRepositoryConnectivity
@@ -16,8 +14,6 @@ from .send_echo_request import SendEchoRequest, SendEchoRequestResponse
 
 MESSAGE_MAP: dict[str, type[InfrahubMessage]] = {
     "check.generator.run": CheckGeneratorRun,
-    "event.branch.merge": EventBranchMerge,
-    "event.worker.new_primary_api": EventWorkerNewPrimaryAPI,
     "finalize.validator.execution": FinalizeValidatorExecution,
     "git.file.get": GitFileGet,
     "git.repository.connectivity": GitRepositoryConnectivity,

infrahub/message_bus/messages/request_proposedchange_pipeline.py

@@ -1,3 +1,5 @@
+import uuid
+
 from pydantic import Field
 
 from infrahub.context import InfrahubContext
@@ -16,3 +18,6 @@ class RequestProposedChangePipeline(InfrahubMessage):
         default=CheckType.ALL, description="Can be used to restrict the pipeline to a specific type of job"
     )
     context: InfrahubContext = Field(..., description="The context of the task")
+    pipeline_id: uuid.UUID = Field(
+        default_factory=uuid.uuid4, description="The unique ID of the execution of this pipeline"
+    )

infrahub/message_bus/operations/__init__.py

@@ -4,7 +4,6 @@ from prefect import Flow
 from infrahub.message_bus import RPCErrorResponse, messages
 from infrahub.message_bus.operations import (
     check,
-    event,
     finalize,
     git,
     refresh,
@@ -17,8 +16,6 @@ from infrahub.tasks.check import set_check_status
 
 COMMAND_MAP = {
     "check.generator.run": check.generator.run,
-    "event.branch.merge": event.branch.merge,
-    "event.worker.new_primary_api": event.worker.new_primary_api,
     "finalize.validator.execution": finalize.validator.execution,
     "git.file.get": git.file.get,
     "git.repository.connectivity": git.repository.connectivity,

infrahub/message_bus/operations/requests/proposed_change.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from enum import IntFlag
+from typing import TYPE_CHECKING
 
 from prefect import flow, task
 from prefect.logging import get_run_logger
@@ -20,6 +21,14 @@ from infrahub.message_bus.types import (
     ProposedChangeRepository,
     ProposedChangeSubscriber,
 )
+from infrahub.proposed_change.branch_diff import (
+    get_diff_summary_cache,
+    get_modified_kinds,
+    get_modified_node_ids,
+    has_data_changes,
+    has_node_changes,
+    set_diff_summary_cache,
+)
 from infrahub.proposed_change.models import (
     RequestArtifactDefinitionCheck,
     RequestProposedChangeDataIntegrity,
@@ -40,6 +49,9 @@ from infrahub.workflows.catalogue import (
 )
 from infrahub.workflows.utils import add_tags
 
+if TYPE_CHECKING:
+    from infrahub_sdk.diff import NodeDiff
+
 
 class DefinitionSelect(IntFlag):
     NONE = 0
@@ -101,8 +113,11 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
         await diff_coordinator.update_branch_diff(base_branch=destination_branch, diff_branch=source_branch)
 
     diff_summary = await service.client.get_diff_summary(branch=message.source_branch)
-    branch_diff = ProposedChangeBranchDiff(diff_summary=diff_summary, repositories=repositories)
-    await _populate_subscribers(branch_diff=branch_diff, service=service, branch=message.source_branch)
+    await set_diff_summary_cache(pipeline_id=message.pipeline_id, diff_summary=diff_summary, cache=service.cache)
+    branch_diff = ProposedChangeBranchDiff(repositories=repositories, pipeline_id=message.pipeline_id)
+    await _populate_subscribers(
+        branch_diff=branch_diff, diff_summary=diff_summary, service=service, branch=message.source_branch
+    )
 
     if message.check_type is CheckType.ARTIFACT:
         events.append(
@@ -132,8 +147,8 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
             parameters={"model": model_proposed_change_run_generator},
         )
 
-    if message.check_type in [CheckType.ALL, CheckType.DATA] and branch_diff.has_node_changes(
-        branch=message.source_branch
+    if message.check_type in [CheckType.ALL, CheckType.DATA] and has_node_changes(
+        diff_summary=diff_summary, branch=message.source_branch
     ):
         model_proposed_change_data_integrity = RequestProposedChangeDataIntegrity(
             proposed_change=message.proposed_change,
@@ -162,8 +177,8 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
             parameters={"model": model_proposed_change_repo_checks},
         )
 
-    if message.check_type in [CheckType.ALL, CheckType.SCHEMA] and branch_diff.has_data_changes(
-        branch=message.source_branch
+    if message.check_type in [CheckType.ALL, CheckType.SCHEMA] and has_data_changes(
+        diff_summary=diff_summary, branch=message.source_branch
     ):
         await service.workflow.submit_workflow(
             workflow=REQUEST_PROPOSED_CHANGE_SCHEMA_INTEGRITY,
@@ -215,6 +230,9 @@ async def refresh_artifacts(message: messages.RequestProposedChangeRefreshArtifa
         definitions=definition_information[InfrahubKind.ARTIFACTDEFINITION]["edges"]
     )
 
+    diff_summary = await get_diff_summary_cache(pipeline_id=message.branch_diff.pipeline_id, cache=service.cache)
+    modified_kinds = get_modified_kinds(diff_summary=diff_summary, branch=message.source_branch)
+
     for artifact_definition in artifact_definitions:
         # Request artifact definition checks if the source branch that is managed in combination
         # to the Git repository containing modifications which could indicate changes to the transforms
@@ -229,7 +247,7 @@ async def refresh_artifacts(message: messages.RequestProposedChangeRefreshArtifa
             condition=message.source_branch_sync_with_git and message.branch_diff.has_file_modifications,
         )
 
-        for changed_model in message.branch_diff.modified_kinds(branch=message.source_branch):
+        for changed_model in modified_kinds:
             condition = False
             if (changed_model in artifact_definition.query_models) or (
                 changed_model.startswith("Profile")
@@ -589,11 +607,13 @@ async def _gather_repository_repository_diffs(
             repo.files_changed = files_changed
 
 
-async def _populate_subscribers(branch_diff: ProposedChangeBranchDiff, service: InfrahubServices, branch: str) -> None:
+async def _populate_subscribers(
+    branch_diff: ProposedChangeBranchDiff, diff_summary: list[NodeDiff], service: InfrahubServices, branch: str
+) -> None:
     result = await service.client.execute_graphql(
         query=GATHER_GRAPHQL_QUERY_SUBSCRIBERS,
         branch_name=branch,
-        variables={"members": branch_diff.modified_nodes(branch=branch)},
+        variables={"members": get_modified_node_ids(diff_summary=diff_summary, branch=branch)},
     )
 
     for group in result[InfrahubKind.GRAPHQLQUERYGROUP]["edges"]:

infrahub/message_bus/types.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import re
+import uuid  # noqa: TC003
 from enum import Enum
 
-from infrahub_sdk.diff import NodeDiff  # noqa: TC002
 from pydantic import BaseModel, Field
 
 from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus
@@ -109,9 +109,9 @@ class ProposedChangeArtifactDefinition(BaseModel):
 
 
 class ProposedChangeBranchDiff(BaseModel):
-    diff_summary: list[NodeDiff] = Field(default_factory=list, description="The DiffSummary between two branches")
     repositories: list[ProposedChangeRepository] = Field(default_factory=list)
     subscribers: list[ProposedChangeSubscriber] = Field(default_factory=list)
+    pipeline_id: uuid.UUID = Field(..., description="The unique ID of the execution of this pipeline")
 
     def get_repository(self, repository_id: str) -> ProposedChangeRepository:
         for repository in self.repositories:
@@ -122,39 +122,7 @@ class ProposedChangeBranchDiff(BaseModel):
     def get_subscribers_ids(self, kind: str) -> list[str]:
         return [subscriber.subscriber_id for subscriber in self.subscribers if subscriber.kind == kind]
 
-    def has_node_changes(self, branch: str) -> bool:
-        """Indicates if there is at least one node object that has been modified in the branch"""
-        return bool(
-            [
-                entry
-                for entry in self.diff_summary
-                if entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"])
-            ]
-        )
-
-    def has_data_changes(self, branch: str) -> bool:
-        """Indicates if there are node or schema changes within the branch."""
-        return bool([entry for entry in self.diff_summary if entry["branch"] == branch])
-
     @property
     def has_file_modifications(self) -> bool:
         """Indicates modifications to any of the files in the Git repositories."""
         return any(repository.has_modifications for repository in self.repositories)
-
-    def modified_nodes(self, branch: str) -> list[str]:
-        """Return a list of non schema nodes that have been modified on the branch"""
-        return [
-            entry["id"]
-            for entry in self.diff_summary
-            if entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"])
-        ]
-
-    def modified_kinds(self, branch: str) -> list[str]:
-        """Return a list of non schema kinds that have been modified on the branch"""
-        return list(
-            {
-                entry["kind"]
-                for entry in self.diff_summary
-                if entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"])
-            }
-        )

infrahub/proposed_change/branch_diff.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import TYPE_CHECKING, cast
+
+from infrahub.exceptions import ResourceNotFoundError
+from infrahub.message_bus.types import KVTTL
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+    from infrahub_sdk.diff import NodeDiff
+
+    from infrahub.services.adapters.cache import InfrahubCache
+
+SCHEMA_CHANGE = re.compile(r"^Schema[A-Z]")
+
+
+def has_data_changes(diff_summary: list[NodeDiff], branch: str) -> bool:
+    """Indicates if there are node or schema changes within the branch."""
+    return any(entry["branch"] == branch for entry in diff_summary)
+
+
+def has_node_changes(diff_summary: list[NodeDiff], branch: str) -> bool:
+    """Indicates if there is at least one node object that has been modified in the branch"""
+    return any(entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"]) for entry in diff_summary)
+
+
+def get_modified_kinds(diff_summary: list[NodeDiff], branch: str) -> list[str]:
+    """Return a list of non schema kinds that have been modified on the branch"""
+    return list(
+        {
+            entry["kind"]
+            for entry in diff_summary
+            if entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"])
+        }
+    )
+
+
+def get_modified_node_ids(diff_summary: list[NodeDiff], branch: str) -> list[str]:
+    """Return a list of non schema nodes that have been modified on the branch"""
+    return [
+        entry["id"] for entry in diff_summary if entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"])
+    ]
+
+
+async def set_diff_summary_cache(pipeline_id: UUID, diff_summary: list[NodeDiff], cache: InfrahubCache) -> None:
+    serialized = json.dumps(diff_summary)
+    await cache.set(
+        key=f"proposed_change:pipeline:pipeline_id:{pipeline_id}:diff_summary",
+        value=serialized,
+        expires=KVTTL.TWO_HOURS,
+    )
+
+
+async def get_diff_summary_cache(pipeline_id: UUID, cache: InfrahubCache) -> list[NodeDiff]:
+    summary_payload = await cache.get(
+        key=f"proposed_change:pipeline:pipeline_id:{pipeline_id}:diff_summary",
+    )
+
+    if not summary_payload:
+        raise ResourceNotFoundError(message=f"Diff summary for pipeline {pipeline_id} was not found in the cache")
+
+    return cast(list["NodeDiff"], json.loads(summary_payload))

infrahub/proposed_change/tasks.py

@@ -61,7 +61,10 @@ from infrahub.workflows.catalogue import (
 )
 from infrahub.workflows.utils import add_tags
 
+from .branch_diff import get_diff_summary_cache, get_modified_kinds
+
 if TYPE_CHECKING:
+    from infrahub_sdk.diff import NodeDiff
     from infrahub_sdk.node import InfrahubNode
 
     from infrahub.core.models import SchemaUpdateConstraintInfo
@@ -253,6 +256,9 @@ async def run_generators(
         for generator in generators
     ]
 
+    diff_summary = await get_diff_summary_cache(pipeline_id=model.branch_diff.pipeline_id, cache=service.cache)
+    modified_kinds = get_modified_kinds(diff_summary=diff_summary, branch=model.source_branch)
+
     for generator_definition in generator_definitions:
         # Request generator definitions if the source branch that is managed in combination
         # to the Git repository containing modifications which could indicate changes to the transforms
@@ -267,7 +273,7 @@ async def run_generators(
             condition=model.source_branch_sync_with_git and model.branch_diff.has_file_modifications,
         )
 
-        for changed_model in model.branch_diff.modified_kinds(branch=model.source_branch):
+        for changed_model in modified_kinds:
             select = select.add_flag(
                 current=select,
                 flag=DefinitionSelect.MODIFIED_KINDS,
@@ -338,8 +344,9 @@ async def run_proposed_change_schema_integrity_check(
     schema_diff = dest_schema.diff(other=candidate_schema)
     validation_result = dest_schema.validate_update(other=candidate_schema, diff=schema_diff)
 
+    diff_summary = await get_diff_summary_cache(pipeline_id=model.branch_diff.pipeline_id, cache=service.cache)
     constraints_from_data_diff = await _get_proposed_change_schema_integrity_constraints(
-        model=model, schema=candidate_schema
+        schema=candidate_schema, diff_summary=diff_summary
     )
     constraints_from_schema_diff = validation_result.constraints
     constraints = set(constraints_from_data_diff + constraints_from_schema_diff)
@@ -390,10 +397,11 @@ async def run_proposed_change_schema_integrity_check(
 
 
 async def _get_proposed_change_schema_integrity_constraints(
-    model: RequestProposedChangeSchemaIntegrity, schema: SchemaBranch
+    schema: SchemaBranch, diff_summary: list[NodeDiff]
 ) -> list[SchemaUpdateConstraintInfo]:
     node_diff_field_summary_map: dict[str, NodeDiffFieldSummary] = {}
-    for node_diff in model.branch_diff.diff_summary:
+
+    for node_diff in diff_summary:
         node_kind = node_diff["kind"]
         if node_kind not in node_diff_field_summary_map:
             node_diff_field_summary_map[node_kind] = NodeDiffFieldSummary(kind=node_kind)

infrahub/server.py

@@ -33,10 +33,8 @@ 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.nats import NATSCache
-from infrahub.services.adapters.cache.redis import RedisCache
-from infrahub.services.adapters.message_bus.nats import NATSMessageBus
-from infrahub.services.adapters.message_bus.rabbitmq import RabbitMQMessageBus
+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
@@ -70,14 +68,11 @@ async def app_initialization(application: FastAPI, enable_scheduler: bool = True
         else WorkflowLocalExecution()
     )
     component_type = ComponentType.API_SERVER
-    message_bus = config.OVERRIDE.message_bus or (
-        await NATSMessageBus.new(component_type=component_type)
-        if config.SETTINGS.broker.driver == config.BrokerDriver.NATS
-        else await RabbitMQMessageBus.new(component_type=component_type)
-    )
-    cache = config.OVERRIDE.cache or (
-        await NATSCache.new() if config.SETTINGS.cache.driver == config.CacheDriver.NATS else RedisCache()
+    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))
     service = await InfrahubServices.new(
         cache=cache,
         database=database,

infrahub/services/adapters/cache/__init__.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import importlib
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from infrahub.config import CacheDriver
     from infrahub.message_bus.types import KVTTL
 
 
@@ -34,3 +36,18 @@ class InfrahubCache(ABC):
     async def set(self, key: str, value: str, expires: KVTTL | None = None, not_exists: bool = False) -> bool | None:
         """Set a value in the cache."""
         raise NotImplementedError()
+
+    @classmethod
+    async def new_from_driver(cls, driver: CacheDriver) -> InfrahubCache:
+        """Imports and initializes the correct class based on the supplied driver.
+
+        This is to ensure that we only import the Python modules that we actually
+        need to operate and not import all possible options.
+        """
+        module = importlib.import_module(driver.driver_module_path)
+        broker_driver: InfrahubCache = getattr(module, driver.driver_class_name)
+        return await broker_driver.new()
+
+    @classmethod
+    async def new(cls) -> InfrahubCache:
+        raise NotImplementedError()

infrahub/services/adapters/cache/redis.py

@@ -1,9 +1,15 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 import redis.asyncio as redis
 
 from infrahub import config
-from infrahub.message_bus.types import KVTTL
 from infrahub.services.adapters.cache import InfrahubCache
 
+if TYPE_CHECKING:
+    from infrahub.message_bus.types import KVTTL
+
 
 class RedisCache(InfrahubCache):
     def __init__(self) -> None:
@@ -44,3 +50,7 @@ class RedisCache(InfrahubCache):
 
     async def set(self, key: str, value: str, expires: KVTTL | None = None, not_exists: bool = False) -> bool | None:
         return await self.connection.set(name=key, value=value, ex=expires.value if expires else None, nx=not_exists)
+
+    @classmethod
+    async def new(cls) -> RedisCache:
+        return cls()

infrahub/services/adapters/message_bus/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import importlib
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, TypeVar
 
@@ -8,6 +9,8 @@ from infrahub.message_bus.messages import ROUTING_KEY_MAP
 ResponseClass = TypeVar("ResponseClass")
 
 if TYPE_CHECKING:
+    from infrahub.components import ComponentType
+    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
@@ -34,6 +37,23 @@ class InfrahubMessageBus(ABC):
     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"""
 
+    @classmethod
+    async def new(cls, component_type: ComponentType, settings: BrokerSettings | None = None) -> InfrahubMessageBus:
+        raise NotImplementedError()
+
+    @classmethod
+    async def new_from_driver(
+        cls, component_type: ComponentType, driver: BrokerDriver, settings: BrokerSettings | None = None
+    ) -> InfrahubMessageBus:
+        """Imports and initializes the correct class based on the supplied driver.
+
+        This is to ensure that we only import the Python modules that we actually
+        need to operate and not import all possible options.
+        """
+        module = importlib.import_module(driver.driver_module_path)
+        broker_driver: InfrahubMessageBus = getattr(module, driver.driver_class_name)
+        return await broker_driver.new(component_type=component_type, settings=settings)
+
     @abstractmethod
     async def publish(
         self, message: InfrahubMessage, routing_key: str, delay: MessageTTL | None = None, is_retry: bool = False

infrahub/services/adapters/workflow/worker.py

@@ -66,7 +66,7 @@ class WorkflowWorkerExecution(InfrahubWorkflow):
         if response.state.type == StateType.CRASHED:
             raise RuntimeError(response.state.message)
 
-        return await response.state.result(raise_on_failure=True, fetch=True)  # type: ignore[call-overload]
+        return await response.state.result(raise_on_failure=True)
 
     async def submit_workflow(
         self,

infrahub/services/component.py

@@ -10,7 +10,6 @@ from infrahub.core.constants import GLOBAL_BRANCH_NAME
 from infrahub.core.registry import registry
 from infrahub.core.timestamp import Timestamp
 from infrahub.log import get_logger
-from infrahub.message_bus import messages
 from infrahub.message_bus.types import KVTTL
 from infrahub.worker import WORKER_IDENTITY
 
@@ -116,7 +115,7 @@ class InfrahubComponent:
             key=PRIMARY_API_SERVER, value=WORKER_IDENTITY, expires=KVTTL.FIFTEEN, not_exists=True
         )
         if result:
-            await self.message_bus.send(message=messages.EventWorkerNewPrimaryAPI(worker_id=WORKER_IDENTITY))
+            log.info("api_worker promoted to primary", worker_id=WORKER_IDENTITY)
         else:
             log.debug("Primary node already set")
             primary_id = await self.cache.get(key=PRIMARY_API_SERVER)

infrahub/tasks/registry.py

@@ -22,7 +22,6 @@ async def refresh_branches(db: InfrahubDatabase) -> None:
 
     async with lock.registry.local_schema_lock():
         branches = await registry.branch_object.get_list(db=db)
-        active_branches = [branch.name for branch in branches]
         for new_branch in branches:
             if new_branch.name in registry.branch:
                 branch_registry: Branch = registry.branch[new_branch.name]
@@ -61,9 +60,6 @@ async def refresh_branches(db: InfrahubDatabase) -> None:
                     include_types=True,
                 )
 
-        for branch_name in list(registry.branch.keys()):
-            if branch_name not in active_branches:
-                del registry.branch[branch_name]
-                log.info(
-                    f"Removed branch {branch_name!r} from the registry", branch=branch_name, worker=WORKER_IDENTITY
-                )
+        purged_branches = await registry.purge_inactive_branches(db=db, active_branches=branches)
+        for branch_name in purged_branches:
+            log.info(f"Removed branch {branch_name!r} from the registry", branch=branch_name, worker=WORKER_IDENTITY)

infrahub/workers/infrahub_async.py

@@ -24,11 +24,7 @@ from infrahub.git import initialize_repositories_directory
 from infrahub.lock import initialize_lock
 from infrahub.services import InfrahubServices
 from infrahub.services.adapters.cache import InfrahubCache
-from infrahub.services.adapters.cache.nats import NATSCache
-from infrahub.services.adapters.cache.redis import RedisCache
 from infrahub.services.adapters.message_bus import InfrahubMessageBus
-from infrahub.services.adapters.message_bus.nats import NATSMessageBus
-from infrahub.services.adapters.message_bus.rabbitmq import RabbitMQMessageBus
 from infrahub.services.adapters.workflow import InfrahubWorkflow
 from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 from infrahub.services.adapters.workflow.worker import WorkflowWorkerExecution
@@ -198,15 +194,13 @@ class InfrahubWorkerAsync(BaseWorker):
 
     async def _init_message_bus(self, component_type: ComponentType) -> InfrahubMessageBus:
         return config.OVERRIDE.message_bus or (
-            await NATSMessageBus.new(component_type=component_type)
-            if config.SETTINGS.broker.driver == config.BrokerDriver.NATS
-            else await RabbitMQMessageBus.new(component_type=component_type)
+            await InfrahubMessageBus.new_from_driver(
+                component_type=component_type, driver=config.SETTINGS.broker.driver
+            )
         )
 
     async def _init_cache(self) -> InfrahubCache:
-        return config.OVERRIDE.cache or (
-            await NATSCache.new() if config.SETTINGS.cache.driver == config.CacheDriver.NATS else RedisCache()
-        )
+        return config.OVERRIDE.cache or (await InfrahubCache.new_from_driver(driver=config.SETTINGS.cache.driver))
 
     async def _init_services(self, client: InfrahubClient) -> None:
         component_type = ComponentType.GIT_AGENT

infrahub/workflows/catalogue.py

@@ -190,6 +190,15 @@ BRANCH_MERGE = WorkflowDefinition(
     tags=[WorkflowTag.DATABASE_CHANGE],
 )
 
+BRANCH_MERGE_POST_PROCESS = WorkflowDefinition(
+    name="branch-merge-post-process",
+    type=WorkflowType.CORE,
+    module="infrahub.core.branch.tasks",
+    function="post_process_branch_merge",
+    tags=[WorkflowTag.DATABASE_CHANGE],
+)
+
+
 BRANCH_MERGE_MUTATION = WorkflowDefinition(
     name="merge-branch-mutation",
     type=WorkflowType.CORE,
@@ -431,6 +440,7 @@ workflows = [
     BRANCH_DELETE,
     BRANCH_MERGE,
     BRANCH_MERGE_MUTATION,
+    BRANCH_MERGE_POST_PROCESS,
     BRANCH_REBASE,
     BRANCH_VALIDATE,
     COMPUTED_ATTRIBUTE_PROCESS_JINJA2,