infrahub-server 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

infrahub/core/schema/basenode_schema.py

@@ -11,7 +11,7 @@ from infrahub_sdk.utils import compare_lists, intersection
 from pydantic import field_validator
 
 from infrahub.core.constants import RelationshipCardinality, RelationshipKind
-from infrahub.core.models import HashableModelDiff
+from infrahub.core.models import HashableModel, HashableModelDiff
 
 from .attribute_schema import AttributeSchema
 from .generated.base_node_schema import GeneratedBaseNodeSchema
@@ -27,6 +27,16 @@ if TYPE_CHECKING:
 NODE_METADATA_ATTRIBUTES = ["_source", "_owner"]
 INHERITED = "INHERITED"
 
+OPTIONAL_TEXT_FIELDS = [
+    "default_filter",
+    "description",
+    "label",
+    "menu_placement",
+    "documentation",
+    "parent",
+    "children",
+]
+
 
 class BaseNodeSchema(GeneratedBaseNodeSchema):
     _exclude_from_hash: list[str] = ["attributes", "relationships"]
@@ -480,6 +490,16 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
             return UniquenessConstraintType.SUBSET_OF_HFID
         return UniquenessConstraintType.STANDARD
 
+    def update(self, other: HashableModel) -> Self:
+        super().update(other=other)
+
+        # Allow to specify empty string to remove existing fields values
+        for field_name in OPTIONAL_TEXT_FIELDS:
+            if getattr(other, field_name, None) == "":  # noqa: PLC1901
+                setattr(self, field_name, None)
+
+        return self
+
 
 @dataclass
 class SchemaUniquenessConstraintPath:

infrahub/core/schema/definitions/internal.py

@@ -18,6 +18,7 @@ from infrahub.core.constants import (
     DEFAULT_NAME_MIN_LENGTH,
     DEFAULT_REL_IDENTIFIER_LENGTH,
     NAME_REGEX,
+    NAME_REGEX_OR_EMPTY,
     NAMESPACE_REGEX,
     NODE_KIND_REGEX,
     NODE_NAME_REGEX,
@@ -269,7 +270,7 @@ base_node_schema = SchemaNode(
         SchemaAttribute(
             name="default_filter",
             kind="Text",
-            regex=str(NAME_REGEX),
+            regex=str(NAME_REGEX_OR_EMPTY),
             description="Default filter used to search for a node in addition to its ID. (deprecated: please use human_friendly_id instead)",
             optional=True,
             extra={"update": UpdateSupport.ALLOWED},

infrahub/core/schema/generated/base_node_schema.py

@@ -50,7 +50,7 @@ class GeneratedBaseNodeSchema(HashableModel):
     default_filter: str | None = Field(
         default=None,
         description="Default filter used to search for a node in addition to its ID. (deprecated: please use human_friendly_id instead)",
-        pattern=r"^[a-z0-9\_]+$",
+        pattern=r"^[a-z0-9\_]*$",
         json_schema_extra={"update": "allowed"},
     )
     human_friendly_id: list[str] | None = Field(

infrahub/core/schema/manager.py

@@ -744,3 +744,24 @@ class SchemaManager(NodeManager):
         """Convert a schema_node object loaded from the database into GenericSchema object."""
         node_data = await cls._prepare_node_data(schema_node=schema_node, db=db)
         return GenericSchema(**node_data)
+
+    def purge_inactive_branches(self, active_branches: list[str]) -> list[str]:
+        """Return non active branches that were purged."""
+
+        hashes_to_keep: set[str] = set()
+        for active_branch in active_branches:
+            if branch := self._branches.get(active_branch):
+                nodes = branch.get_all(include_internal=True, duplicate=False)
+                hashes_to_keep.update([node.get_hash() for node in nodes.values()])
+
+        removed_branches: list[str] = []
+        for branch_name in list(self._branches.keys()):
+            if branch_name not in active_branches:
+                del self._branches[branch_name]
+                removed_branches.append(branch_name)
+
+        for hash_key in list(self._cache.keys()):
+            if hash_key not in hashes_to_keep:
+                del self._cache[hash_key]
+
+        return removed_branches

infrahub/core/schema/schema_branch.py

@@ -6,6 +6,8 @@ from collections import defaultdict
 from itertools import chain, combinations
 from typing import Any
 
+from infrahub_sdk.template import Jinja2Template
+from infrahub_sdk.template.exceptions import JinjaTemplateError, JinjaTemplateOperationViolationError
 from infrahub_sdk.topological_sort import DependencyCycleExistsError, topological_sort
 from infrahub_sdk.utils import compare_lists, deep_merge_dict, duplicates, intersection
 from typing_extensions import Self
@@ -51,7 +53,6 @@ from infrahub.core.schema.definitions.core import core_profile_schema_definition
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
 from infrahub.exceptions import SchemaNotFoundError, ValidationError
 from infrahub.log import get_logger
-from infrahub.support.macro import MacroDefinition
 from infrahub.types import ATTRIBUTE_TYPES
 from infrahub.utils import format_label
 from infrahub.visuals import select_color
@@ -1037,14 +1038,22 @@ class SchemaBranch:
                 | SchemaElementPathType.REL_ONE_MANDATORY_ATTR_WITH_PROP
                 | SchemaElementPathType.REL_ONE_ATTR_WITH_PROP
             )
+
+            jinja_template = Jinja2Template(template=attribute.computed_attribute.jinja2_template)
             try:
-                macro = MacroDefinition(macro=attribute.computed_attribute.jinja2_template)
-            except ValueError as exc:
+                variables = jinja_template.get_variables()
+                jinja_template.validate(restricted=config.SETTINGS.security.restrict_untrusted_jinja2_filters)
+            except JinjaTemplateOperationViolationError as exc:
+                raise ValueError(
+                    f"{node.kind}: Attribute {attribute.name!r} is assigned by a jinja2 template, but has an invalid template: {exc.message}"
+                ) from exc
+
+            except JinjaTemplateError as exc:
                 raise ValueError(
-                    f"{node.kind}: Attribute {attribute.name!r} is assigned by a jinja2 template, but has an invalid template"
+                    f"{node.kind}: Attribute {attribute.name!r} is assigned by a jinja2 template, but has an invalid template: : {exc.message}"
                 ) from exc
 
-            for variable in macro.variables:
+            for variable in variables:
                 try:
                     schema_path = self.validate_schema_path(
                         node_schema=node, path=variable, allowed_path_types=allowed_path_types
@@ -1946,10 +1955,9 @@ class SchemaBranch:
                 )
             )
 
-            if relationship.kind == RelationshipKind.PARENT:
-                template_schema.human_friendly_id = [
-                    f"{relationship.name}__template_name__value"
-                ] + template_schema.human_friendly_id
+            parent_hfid = f"{relationship.name}__template_name__value"
+            if relationship.kind == RelationshipKind.PARENT and parent_hfid not in template_schema.human_friendly_id:
+                template_schema.human_friendly_id = [parent_hfid] + template_schema.human_friendly_id
                 template_schema.uniqueness_constraints[0].append(relationship.name)
 
     def generate_object_template_from_node(

infrahub/database/__init__.py

@@ -205,6 +205,16 @@ class InfrahubDatabase:
     def add_schema(self, schema: SchemaBranch, name: str | None = None) -> None:
         self._schemas[name or schema.name] = schema
 
+    def purge_inactive_schemas(self, active_branches: list[str]) -> list[str]:
+        """Return non active schema branches that were purged."""
+        removed_branches: list[str] = []
+        for branch_name in list(self._schemas.keys()):
+            if branch_name not in active_branches:
+                del self._schemas[branch_name]
+                removed_branches.append(branch_name)
+
+        return removed_branches
+
     def start_session(self, read_only: bool = False, schemas: list[SchemaBranch] | None = None) -> InfrahubDatabase:
         """Create a new InfrahubDatabase object in Session mode."""
         session_mode = InfrahubDatabaseSessionMode.WRITE

infrahub/events/group_action.py

@@ -2,7 +2,7 @@ from typing import ClassVar
 
 from pydantic import Field
 
-from infrahub.core.constants import MutationAction
+from infrahub.core.constants import InfrahubKind, MutationAction
 
 from .constants import EVENT_NAMESPACE
 from .models import EventNode, InfrahubEvent
@@ -21,6 +21,11 @@ class GroupMutatedEvent(InfrahubEvent):
 
     def get_related(self) -> list[dict[str, str]]:
         related = super().get_related()
+
+        if self.kind == InfrahubKind.GRAPHQLQUERYGROUP:
+            # Temporary workaround to avoid too large payloads for the related field
+            return related
+
         related.append(
             {
                 "prefect.resource.id": self.node_id,

infrahub/events/node_action.py

@@ -7,7 +7,7 @@ from infrahub.core.changelog.models import (
     RelationshipCardinalityManyChangelog,
     RelationshipCardinalityOneChangelog,
 )
-from infrahub.core.constants import DiffAction, MutationAction
+from infrahub.core.constants import DiffAction, InfrahubKind, MutationAction
 
 from .constants import EVENT_NAMESPACE
 from .models import InfrahubEvent
@@ -24,6 +24,10 @@ class NodeMutatedEvent(InfrahubEvent):
 
     def get_related(self) -> list[dict[str, str]]:
         related = super().get_related()
+        if self.kind == InfrahubKind.GRAPHQLQUERYGROUP:
+            # Temporary workaround to avoid too large payloads for the related field
+            return related
+
         for attribute in self.changelog.attributes.values():
             related.append(
                 {

infrahub/git/integrator.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 import hashlib
 import importlib
 import sys
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-import jinja2
 import ujson
 import yaml
 from infrahub_sdk import InfrahubClient  # noqa: TC002
@@ -28,6 +28,8 @@ from infrahub_sdk.schema.repository import (
     InfrahubPythonTransformConfig,
     InfrahubRepositoryConfig,
 )
+from infrahub_sdk.template import Jinja2Template
+from infrahub_sdk.template.exceptions import JinjaTemplateError
 from infrahub_sdk.utils import compare_lists
 from infrahub_sdk.yaml import SchemaFile
 from prefect import flow, task
@@ -1057,14 +1059,14 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
         self.validate_location(commit=commit, worktree_directory=commit_worktree.directory, file_path=location)
 
+        jinja2_template = Jinja2Template(template=Path(location), template_directory=Path(commit_worktree.directory))
         try:
-            templateLoader = jinja2.FileSystemLoader(searchpath=commit_worktree.directory)
-            templateEnv = jinja2.Environment(loader=templateLoader, trim_blocks=True, lstrip_blocks=True)
-            template = templateEnv.get_template(location)
-            return template.render(**data)
-        except Exception as exc:
+            return await jinja2_template.render(variables=data)
+        except JinjaTemplateError as exc:
             log.error(str(exc), exc_info=True)
-            raise TransformError(repository_name=self.name, commit=commit, location=location, message=str(exc)) from exc
+            raise TransformError(
+                repository_name=self.name, commit=commit, location=location, message=exc.message
+            ) from exc
 
     @task(name="python-check-execute", task_run_name="Execute Python Check", cache_policy=NONE)  # type: ignore[arg-type]
     async def execute_python_check(

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/menu/repository.py

@@ -20,9 +20,9 @@ class MenuRepository:
         async def add_children(menu_item: MenuItemDict, menu_node: CoreMenuItem) -> MenuItemDict:
             children = await menu_node.children.get_peers(db=self.db, peer_type=CoreMenuItem)
             for child_id, child_node in children.items():
-                child_menu_item = menu_by_ids[child_id]
-                child = await add_children(child_menu_item, child_node)
-                menu_item.children[str(child.identifier)] = child
+                if child_menu_item := menu_by_ids.get(child_id):
+                    child = await add_children(child_menu_item, child_node)
+                    menu_item.children[str(child.identifier)] = child
             return menu_item
 
         for menu_node in nodes.values():
@@ -33,9 +33,9 @@ class MenuRepository:
 
             children = await menu_node.children.get_peers(db=self.db, peer_type=CoreMenuItem)
             for child_id, child_node in children.items():
-                child_menu_item = menu_by_ids[child_id]
-                child = await add_children(child_menu_item, child_node)
-                menu_item.children[str(child.identifier)] = child
+                if child_menu_item := menu_by_ids.get(child_id):
+                    child = await add_children(child_menu_item, child_node)
+                    menu_item.children[str(child.identifier)] = child
 
             menu.data[str(menu_item.identifier)] = menu_item
 

infrahub/message_bus/messages/__init__.py

@@ -2,7 +2,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
@@ -17,7 +16,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/operations/__init__.py

@@ -18,7 +18,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/event/__init__.py

@@ -1,3 +1,3 @@
-from . import branch, worker
+from . import branch
 
-__all__ = ["branch", "worker"]
+__all__ = ["branch"]

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/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_sdk/client.py

@@ -281,7 +281,7 @@ class InfrahubClient(BaseClient):
         self.schema = InfrahubSchema(self)
         self.branch = InfrahubBranchManager(self)
         self.object_store = ObjectStore(self)
-        self.store = NodeStore()
+        self.store = NodeStore(default_branch=self.default_branch)
         self.task = InfrahubTaskManager(self)
         self.concurrent_execution_limit = asyncio.Semaphore(self.max_concurrent_execution)
         self._request_method: AsyncRequester = self.config.requester or self._default_request_method
@@ -840,11 +840,11 @@ class InfrahubClient(BaseClient):
         if populate_store:
             for node in nodes:
                 if node.id:
-                    self.store.set(key=node.id, node=node)
+                    self.store.set(node=node)
             related_nodes = list(set(related_nodes))
             for node in related_nodes:
                 if node.id:
-                    self.store.set(key=node.id, node=node)
+                    self.store.set(node=node)
         return nodes
 
     def clone(self) -> InfrahubClient:
@@ -1529,7 +1529,7 @@ class InfrahubClientSync(BaseClient):
         self.schema = InfrahubSchemaSync(self)
         self.branch = InfrahubBranchManagerSync(self)
         self.object_store = ObjectStoreSync(self)
-        self.store = NodeStoreSync()
+        self.store = NodeStoreSync(default_branch=self.default_branch)
         self.task = InfrahubTaskManagerSync(self)
         self._request_method: SyncRequester = self.config.sync_requester or self._default_request_method
         self.group_context = InfrahubGroupContextSync(self)
@@ -1997,11 +1997,11 @@ class InfrahubClientSync(BaseClient):
         if populate_store:
             for node in nodes:
                 if node.id:
-                    self.store.set(key=node.id, node=node)
+                    self.store.set(node=node)
             related_nodes = list(set(related_nodes))
             for node in related_nodes:
                 if node.id:
-                    self.store.set(key=node.id, node=node)
+                    self.store.set(node=node)
         return nodes
 
     @overload