infrahub-server 1.2.0b1__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/utils.py

@@ -2,9 +2,10 @@ import hashlib
 from enum import Enum, EnumMeta
 from pathlib import Path
 from re import finditer
-from typing import Any
+from typing import Any, TypeVar
 
 KWARGS_TO_DROP = ["session"]
+AnyClass = TypeVar("AnyClass", bound=type)
 
 
 def get_fixtures_dir() -> Path:
@@ -73,3 +74,12 @@ def get_nested_dict(nested_dict: dict[str, Any], keys: list[str]) -> dict[str, A
         else:
             return {}
     return current_level if isinstance(current_level, dict) else {}
+
+
+def get_all_subclasses(cls: AnyClass) -> list[AnyClass]:
+    """Recursively get all subclasses of the given class."""
+    subclasses: list[AnyClass] = []
+    for subclass in cls.__subclasses__():
+        subclasses.append(subclass)
+        subclasses.extend(get_all_subclasses(subclass))
+    return subclasses

infrahub/validators/events.py

@@ -0,0 +1,42 @@
+from infrahub_sdk.protocols import CoreValidator
+
+from infrahub.context import InfrahubContext
+from infrahub.events.models import EventMeta
+from infrahub.events.validator_action import ValidatorFailedEvent, ValidatorPassedEvent, ValidatorStartedEvent
+from infrahub.services import InfrahubServices
+
+
+async def send_failed_validator(
+    service: InfrahubServices, validator: CoreValidator, proposed_change_id: str, context: InfrahubContext
+) -> None:
+    event = ValidatorFailedEvent(
+        node_id=validator.id,
+        kind=validator.get_kind(),
+        proposed_change_id=proposed_change_id,
+        meta=EventMeta.from_context(context=context),
+    )
+    await service.event.send(event=event)
+
+
+async def send_passed_validator(
+    service: InfrahubServices, validator: CoreValidator, proposed_change_id: str, context: InfrahubContext
+) -> None:
+    event = ValidatorPassedEvent(
+        node_id=validator.id,
+        kind=validator.get_kind(),
+        proposed_change_id=proposed_change_id,
+        meta=EventMeta.from_context(context=context),
+    )
+    await service.event.send(event=event)
+
+
+async def send_start_validator(
+    service: InfrahubServices, validator: CoreValidator, proposed_change_id: str, context: InfrahubContext
+) -> None:
+    event = ValidatorStartedEvent(
+        node_id=validator.id,
+        kind=validator.get_kind(),
+        proposed_change_id=proposed_change_id,
+        meta=EventMeta.from_context(context=context),
+    )
+    await service.event.send(event=event)

infrahub/validators/tasks.py

@@ -0,0 +1,41 @@
+from typing import Any, TypeVar, cast
+
+from infrahub_sdk.protocols import CoreValidator
+
+from infrahub.context import InfrahubContext
+from infrahub.core.constants import ValidatorConclusion, ValidatorState
+from infrahub.services import InfrahubServices
+
+from .events import send_start_validator
+
+ValidatorType = TypeVar("ValidatorType", bound=CoreValidator)
+
+
+async def start_validator(
+    service: InfrahubServices,
+    validator: CoreValidator | None,
+    validator_type: type[ValidatorType],
+    proposed_change: str,
+    context: InfrahubContext,
+    data: dict[str, Any],
+) -> ValidatorType:
+    if validator:
+        validator.conclusion.value = ValidatorConclusion.UNKNOWN.value
+        validator.state.value = ValidatorState.QUEUED.value
+        validator.started_at.value = ""
+        validator.completed_at.value = ""
+        await validator.save()
+        validator = cast(ValidatorType, validator)
+    else:
+        data["proposed_change"] = proposed_change
+        validator = await service.client.create(
+            kind=validator_type,
+            data=data,
+        )
+        await validator.save()
+
+    await send_start_validator(
+        service=service, validator=validator, proposed_change_id=proposed_change, context=context
+    )
+
+    return validator

infrahub/webhook/gather.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from prefect import task
+from prefect.cache_policies import NONE
+
+from infrahub.core.manager import NodeManager
+from infrahub.core.protocols import CoreWebhook
+from infrahub.database import InfrahubDatabase  # noqa: TC001  needed for prefect flow
+
+from .models import WebhookTriggerDefinition
+
+
+@task(name="gather-trigger-webhook", task_run_name="Gather webhook triggers", cache_policy=NONE)
+async def gather_trigger_webhook(db: InfrahubDatabase) -> list[WebhookTriggerDefinition]:
+    webhooks = await NodeManager.query(db=db, schema=CoreWebhook)
+    triggers = [WebhookTriggerDefinition.from_object(webhook) for webhook in webhooks]
+    return triggers

infrahub/webhook/models.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import base64
 import hashlib
 import hmac
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 from uuid import UUID, uuid4
 
 from pydantic import BaseModel, ConfigDict, Field, computed_field
@@ -12,7 +12,9 @@ from typing_extensions import Self
 from infrahub.core import registry
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.timestamp import Timestamp
+from infrahub.events.utils import get_all_infrahub_node_kind_events
 from infrahub.git.repository import InfrahubReadOnlyRepository, InfrahubRepository
+from infrahub.trigger.constants import NAME_SEPARATOR
 from infrahub.trigger.models import EventTrigger, ExecuteWorkflow, TriggerDefinition, TriggerType
 from infrahub.workflows.catalogue import WEBHOOK_PROCESS
 
@@ -20,14 +22,23 @@ if TYPE_CHECKING:
     from httpx import Response
     from infrahub_sdk.protocols import CoreCustomWebhook, CoreStandardWebhook, CoreTransformPython, CoreWebhook
 
+    from infrahub.core.protocols import CoreWebhook as CoreWebhookNode
     from infrahub.services import InfrahubServices
 
 
 class WebhookTriggerDefinition(TriggerDefinition):
+    id: str
     type: TriggerType = TriggerType.WEBHOOK
 
+    def generate_name(self) -> str:
+        return f"{self.type.value}{NAME_SEPARATOR}{self.id}"
+
+    @classmethod
+    def generate_name_from_id(cls, id: str) -> str:
+        return f"{TriggerType.WEBHOOK.value}{NAME_SEPARATOR}{id}"
+
     @classmethod
-    def from_object(cls, obj: CoreWebhook) -> Self:
+    def from_object(cls, obj: CoreWebhook | CoreWebhookNode) -> Self:
         event_trigger = EventTrigger()
         if obj.event_type.value == "all":
             event_trigger.events.add("infrahub.*")
@@ -45,7 +56,11 @@ class WebhookTriggerDefinition(TriggerDefinition):
                 "infrahub.resource.label": f"!{registry.default_branch}",
             }
 
+        if obj.node_kind.value and obj.event_type.value in get_all_infrahub_node_kind_events():
+            event_trigger.match = {"infrahub.node.kind": obj.node_kind.value}
+
         definition = cls(
+            id=obj.id,
             name=obj.name.value,
             trigger=event_trigger,
             actions=[
@@ -53,7 +68,9 @@ class WebhookTriggerDefinition(TriggerDefinition):
                     workflow=WEBHOOK_PROCESS,
                     parameters={
                         "webhook_id": obj.id,
+                        "webhook_name": obj.name.value,
                         "webhook_kind": obj.get_kind(),
+                        "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
                         "event_id": "{{ event.id }}",
                         "event_type": "{{ event.event }}",
                         "event_occured_at": "{{ event.occurred }}",
@@ -102,7 +119,7 @@ class Webhook(BaseModel):
     event_type: str = Field(...)
     validate_certificates: bool = Field(...)
     _payload: Any = None
-    _headers: Optional[dict[str, Any]] = None
+    _headers: dict[str, Any] | None = None
 
     async def _prepare_payload(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:  # noqa: ARG002
         self._payload = {"data": data, **context.model_dump()}
@@ -189,7 +206,7 @@ class TransformWebhook(Webhook):
     transform_timeout: int = Field(...)
 
     async def _prepare_payload(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:
-        repo: Union[InfrahubReadOnlyRepository, InfrahubRepository]
+        repo: InfrahubReadOnlyRepository | InfrahubRepository
         if self.repository_kind == InfrahubKind.READONLYREPOSITORY:
             repo = await InfrahubReadOnlyRepository.init(
                 id=self.repository_id,
@@ -214,7 +231,7 @@ class TransformWebhook(Webhook):
             location=f"{self.transform_file}::{self.transform_class}",
             data={"data": data, **context.model_dump()},
             client=service.client,
-        )
+        )  # type: ignore[misc]
 
     @classmethod
     def from_object(cls, obj: CoreCustomWebhook, transform: CoreTransformPython) -> Self:

infrahub/webhook/tasks.py

@@ -14,9 +14,10 @@ from prefect.logging import get_run_logger
 from infrahub.message_bus.types import KVTTL
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.trigger.models import TriggerType
-from infrahub.trigger.tasks import setup_triggers
+from infrahub.trigger.setup import setup_triggers
+from infrahub.workflows.utils import add_tags
 
-from .constants import AUTOMATION_NAME_RUN
+from .gather import gather_trigger_webhook
 from .models import CustomWebhook, EventContext, StandardWebhook, TransformWebhook, Webhook, WebhookTriggerDefinition
 
 if TYPE_CHECKING:
@@ -61,18 +62,23 @@ async def convert_node_to_webhook(webhook_node: CoreWebhook, client: InfrahubCli
     return CustomWebhook.from_object(obj=webhook_node)
 
 
-@flow(name="webhook-process", flow_run_name="Send webhook")
+@flow(name="webhook-process", flow_run_name="Send webhook for {webhook_name}")
 async def webhook_process(
     webhook_id: str,
+    webhook_name: str,  # noqa: ARG001
     webhook_kind: str,
     event_id: str,
     event_type: str,
     event_occured_at: str,
     event_payload: dict,
     service: InfrahubServices,
+    branch_name: str | None = None,
 ) -> None:
     log = get_run_logger()
 
+    if branch_name:
+        await add_tags(branches=[branch_name])
+
     webhook_data_str = await service.cache.get(key=f"webhook:{webhook_id}")
     if not webhook_data_str:
         log.info(f"Webhook {webhook_id} not found in cache")
@@ -101,33 +107,33 @@ async def webhook_process(
     log.info(f"Successfully sent webhook to {response.url} with status {response.status_code}")
 
 
-@flow(name="webhook-setup-automation-all", flow_run_name="Configuration webhook automation for all webhooks")
+@flow(name="webhook-setup-automation-all", flow_run_name="Configure all webhooks")
 async def configure_webhook_all(service: InfrahubServices) -> None:
     log = get_run_logger()
 
-    webhooks = await service.client.all(kind=CoreWebhook)
-    triggers = [WebhookTriggerDefinition.from_object(webhook) for webhook in webhooks]
+    triggers = await gather_trigger_webhook(db=service.database)
 
     async with get_client(sync_client=False) as prefect_client:
         await setup_triggers(
             client=prefect_client,
             triggers=triggers,
             trigger_type=TriggerType.WEBHOOK,
-            deprecated_triggers=[AUTOMATION_NAME_RUN],
-        )
+        )  # type: ignore[misc]
 
     log.info(f"{len(triggers)} Webhooks automation configuration completed")
 
 
-@flow(name="webhook-setup-automation-one", flow_run_name="Configuration webhook automation for one webhook")
-async def configure_webhook_one(event_type: str, event_data: dict, service: InfrahubServices) -> None:
+@flow(name="webhook-setup-automation-one", flow_run_name="Configurate webhook for {webhook_name}")
+async def configure_webhook_one(
+    webhook_name: str,  # noqa: ARG001
+    event_data: dict,
+    service: InfrahubServices,
+) -> None:
     log = get_run_logger()
 
     webhook = await service.client.get(kind=CoreWebhook, id=event_data["node_id"])
     trigger = WebhookTriggerDefinition.from_object(webhook)
 
-    delete_automation: bool = "infrahub.node.deleted" in event_type
-
     async with get_client(sync_client=False) as prefect_client:
         # Query the deployment associated with the trigger to have its ID
         deployment_name = trigger.get_deployment_names()[0]
@@ -135,22 +141,41 @@ async def configure_webhook_one(event_type: str, event_data: dict, service: Infr
 
         automation = AutomationCore(
             name=trigger.generate_name(),
-            description=trigger.description,
+            description=trigger.get_description(),
             enabled=True,
             trigger=trigger.trigger.get_prefect(),
             actions=[action.get(deployment.id) for action in trigger.actions],
         )
 
         existing_automations = await prefect_client.read_automations_by_name(trigger.generate_name())
+        existing_automation = existing_automations[0] if existing_automations else None
 
-        if existing_automations and not delete_automation:
-            existing_automation = existing_automations[0]
+        if existing_automation:
             await prefect_client.update_automation(automation_id=existing_automation.id, automation=automation)
             log.info(f"Automation {trigger.generate_name()} updated")
-        elif existing_automations and delete_automation:
-            existing_automation = existing_automations[0]
-            await prefect_client.delete_automation(automation_id=existing_automation.id)
-            log.info(f"Automation {trigger.generate_name()} deleted")
         else:
             await prefect_client.create_automation(automation=automation)
             log.info(f"Automation {trigger.generate_name()} created")
+
+        await service.cache.delete(key=f"webhook:{webhook.id}")
+
+
+@flow(name="webhook-delete-automation", flow_run_name="Delete webhook automation for {webhook_name}")
+async def delete_webhook_automation(
+    webhook_id: str,
+    webhook_name: str,  # noqa: ARG001
+    service: InfrahubServices,
+) -> None:
+    log = get_run_logger()
+
+    async with get_client(sync_client=False) as prefect_client:
+        automation_name = WebhookTriggerDefinition.generate_name_from_id(id=webhook_id)
+
+        existing_automations = await prefect_client.read_automations_by_name(automation_name)
+        existing_automation = existing_automations[0] if existing_automations else None
+
+        if existing_automation:
+            await prefect_client.delete_automation(automation_id=existing_automation.id)
+            log.info(f"Automation {automation_name} deleted")
+
+        await service.cache.delete(key=f"webhook:{webhook_id}")

infrahub/webhook/triggers.py

@@ -1,13 +1,11 @@
 from infrahub.core.constants import InfrahubKind
 from infrahub.trigger.models import BuiltinTriggerDefinition, EventTrigger, ExecuteWorkflow
-from infrahub.workflows.catalogue import (
-    WEBHOOK_CONFIGURE_ONE,
-)
+from infrahub.workflows.catalogue import WEBHOOK_CONFIGURE_ONE, WEBHOOK_DELETE_AUTOMATION
 
 TRIGGER_WEBHOOK_SETUP_UPDATE = BuiltinTriggerDefinition(
     name="webhook-configure-one",
     trigger=EventTrigger(
-        events={"infrahub.node.*"},
+        events={"infrahub.node.created", "infrahub.node.updated"},
         match={
             "infrahub.node.kind": [InfrahubKind.CUSTOMWEBHOOK, InfrahubKind.STANDARDWEBHOOK],
         },
@@ -16,7 +14,7 @@ TRIGGER_WEBHOOK_SETUP_UPDATE = BuiltinTriggerDefinition(
         ExecuteWorkflow(
             workflow=WEBHOOK_CONFIGURE_ONE,
             parameters={
-                "event_type": "{{ event.event }}",
+                "webhook_name": "{{ event.payload['data']['changelog']['display_label'] }}",
                 "event_data": {
                     "__prefect_kind": "json",
                     "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['data'] | tojson }}"},
@@ -25,3 +23,22 @@ TRIGGER_WEBHOOK_SETUP_UPDATE = BuiltinTriggerDefinition(
         ),
     ],
 )
+
+TRIGGER_WEBHOOK_DELETE = BuiltinTriggerDefinition(
+    name="webhook-delete",
+    trigger=EventTrigger(
+        events={"infrahub.node.deleted"},
+        match={
+            "infrahub.node.kind": [InfrahubKind.CUSTOMWEBHOOK, InfrahubKind.STANDARDWEBHOOK],
+        },
+    ),
+    actions=[
+        ExecuteWorkflow(
+            workflow=WEBHOOK_DELETE_AUTOMATION,
+            parameters={
+                "webhook_id": "{{ event.payload['data']['node_id'] }}",
+                "webhook_name": "{{ event.payload['data']['changelog']['display_label'] }}",
+            },
+        ),
+    ],
+)

infrahub/workers/infrahub_async.py

@@ -1,6 +1,6 @@
 import logging
 import os
-from typing import Any, Optional
+from typing import Any
 
 import typer
 from anyio.abc import TaskStatus
@@ -138,7 +138,7 @@ class InfrahubWorkerAsync(BaseWorker):
         self,
         flow_run: FlowRun,
         configuration: BaseJobConfiguration,
-        task_status: Optional[TaskStatus] = None,
+        task_status: TaskStatus | None = None,
     ) -> BaseWorkerResult:
         flow_run_logger = self.get_flow_run_logger(flow_run)
 

infrahub/workers/utils.py

@@ -24,7 +24,7 @@ def inject_service_parameter(func: Flow, parameters: dict[str, Any], service: In
 
     if service_parameter_name := get_parameter_name(func=func, types=[InfrahubServices.__name__, InfrahubServices]):
         if any(isinstance(param_value, InfrahubServices) for param_value in parameters):
-            raise ValueError(f"{func} parameters contains an InfrahubServices object while it should be injected")
+            raise ValueError(f"{func.name} parameters contains an InfrahubServices object while it should be injected")
         parameters[service_parameter_name] = service
         return
 
@@ -37,7 +37,7 @@ def inject_context_parameter(func: Flow, parameters: dict[str, Any], context: In
 
     if service_parameter_name and not context:
         raise ValueError(
-            f"{func} has a {service_parameter_name} parameter of type InfrahubContext, while context is not provided"
+            f"{func.name} has a {service_parameter_name} parameter of type InfrahubContext, while context is not provided"
         )
 
 

infrahub/workflows/catalogue.py

@@ -24,7 +24,7 @@ ANONYMOUS_TELEMETRY_SEND = WorkflowDefinition(
     name="anonymous_telemetry_send",
     type=WorkflowType.INTERNAL,
     cron=f"{random.randint(0, 59)} 2 * * *",
-    module="infrahub.tasks.telemetry",
+    module="infrahub.telemetry.tasks",
     function="send_telemetry_push",
 )
 
@@ -234,8 +234,8 @@ GRAPHQL_QUERY_GROUP_UPDATE = WorkflowDefinition(
     function="update_graphql_query_group",
 )
 
-PROCESS_COMPUTED_MACRO = WorkflowDefinition(
-    name="process_computed_attribute_jinja2",
+COMPUTED_ATTRIBUTE_PROCESS_JINJA2 = WorkflowDefinition(
+    name="computed_attribute_process_jinja2",
     type=WorkflowType.CORE,
     module="infrahub.computed_attribute.tasks",
     function="process_jinja2",
@@ -256,11 +256,11 @@ TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES = WorkflowDefinition(
     function="trigger_update_python_computed_attributes",
 )
 
-COMPUTED_ATTRIBUTE_SETUP = WorkflowDefinition(
-    name="computed-attribute-setup",
+COMPUTED_ATTRIBUTE_SETUP_JINJA2 = WorkflowDefinition(
+    name="computed-attribute-setup-jinja2",
     type=WorkflowType.CORE,
     module="infrahub.computed_attribute.tasks",
-    function="computed_attribute_setup",
+    function="computed_attribute_setup_jinja2",
 )
 
 COMPUTED_ATTRIBUTE_SETUP_PYTHON = WorkflowDefinition(
@@ -270,15 +270,8 @@ COMPUTED_ATTRIBUTE_SETUP_PYTHON = WorkflowDefinition(
     function="computed_attribute_setup_python",
 )
 
-COMPUTED_ATTRIBUTE_REMOVE_PYTHON = WorkflowDefinition(
-    name="computed-attribute-remove-python",
-    type=WorkflowType.CORE,
-    module="infrahub.computed_attribute.tasks",
-    function="computed_attribute_remove_python",
-)
-
-UPDATE_COMPUTED_ATTRIBUTE_TRANSFORM = WorkflowDefinition(
-    name="process_computed_attribute_transform",
+COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM = WorkflowDefinition(
+    name="computed_attribute_process_transform",
     type=WorkflowType.USER,
     module="infrahub.computed_attribute.tasks",
     function="process_transform",
@@ -366,12 +359,19 @@ WEBHOOK_CONFIGURE_ONE = WorkflowDefinition(
 
 WEBHOOK_CONFIGURE_ALL = WorkflowDefinition(
     name="webhook-setup-automation-all",
-    type=WorkflowType.CORE,
+    type=WorkflowType.INTERNAL,
     cron=f"{random.randint(0, 59)} 3 * * *",
     module="infrahub.webhook.tasks",
     function="configure_webhook_all",
 )
 
+WEBHOOK_DELETE_AUTOMATION = WorkflowDefinition(
+    name="webhook-delete-automation",
+    type=WorkflowType.CORE,
+    module="infrahub.webhook.tasks",
+    function="delete_webhook_automation",
+)
+
 GIT_REPOSITORIES_CHECK_ARTIFACT_CREATE = WorkflowDefinition(
     name="git-repository-check-artifact-create",
     type=WorkflowType.USER,
@@ -414,6 +414,13 @@ GIT_REPOSITORY_MERGE_CONFLICTS_CHECKS_RUN = WorkflowDefinition(
     function="run_check_merge_conflicts",
 )
 
+TRIGGER_CONFIGURE_ALL = WorkflowDefinition(
+    name="trigger-configure-all",
+    type=WorkflowType.CORE,
+    module="infrahub.trigger.tasks",
+    function="trigger_configure_all",
+)
+
 
 worker_pools = [INFRAHUB_WORKER_POOL]
 
@@ -426,8 +433,9 @@ workflows = [
     BRANCH_MERGE_MUTATION,
     BRANCH_REBASE,
     BRANCH_VALIDATE,
-    COMPUTED_ATTRIBUTE_REMOVE_PYTHON,
-    COMPUTED_ATTRIBUTE_SETUP,
+    COMPUTED_ATTRIBUTE_PROCESS_JINJA2,
+    COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM,
+    COMPUTED_ATTRIBUTE_SETUP_JINJA2,
     COMPUTED_ATTRIBUTE_SETUP_PYTHON,
     DIFF_REFRESH,
     DIFF_REFRESH_ALL,
@@ -448,7 +456,6 @@ workflows = [
     GIT_REPOSITORY_USER_CHECK_RUN,
     GRAPHQL_QUERY_GROUP_UPDATE,
     IPAM_RECONCILIATION,
-    PROCESS_COMPUTED_MACRO,
     PROPOSED_CHANGE_MERGE,
     QUERY_COMPUTED_ATTRIBUTE_TRANSFORM_TARGETS,
     REQUEST_ARTIFACT_DEFINITION_CHECK,
@@ -466,11 +473,12 @@ workflows = [
     TRANSFORM_JINJA2_RENDER,
     TRANSFORM_PYTHON_RENDER,
     TRIGGER_ARTIFACT_DEFINITION_GENERATE,
+    TRIGGER_CONFIGURE_ALL,
     TRIGGER_GENERATOR_DEFINITION_RUN,
     TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
     TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
-    UPDATE_COMPUTED_ATTRIBUTE_TRANSFORM,
     WEBHOOK_CONFIGURE_ALL,
     WEBHOOK_CONFIGURE_ONE,
+    WEBHOOK_DELETE_AUTOMATION,
     WEBHOOK_PROCESS,
 ]

infrahub/workflows/initialization.py

@@ -8,9 +8,8 @@ from prefect.logging import get_run_logger
 
 from infrahub import config
 from infrahub.trigger.catalogue import builtin_triggers
-from infrahub.trigger.constants import DEPRECATED_STATIC_TRIGGER_NAMES
 from infrahub.trigger.models import TriggerType
-from infrahub.trigger.tasks import setup_triggers
+from infrahub.trigger.setup import setup_triggers
 
 from .catalogue import worker_pools, workflows
 from .models import TASK_RESULT_STORAGE_NAME
@@ -75,5 +74,4 @@ async def setup_task_manager() -> None:
             client=client,
             triggers=builtin_triggers,
             trigger_type=TriggerType.BUILTIN,
-            deprecated_triggers=DEPRECATED_STATIC_TRIGGER_NAMES,
         )

infrahub/workflows/models.py

@@ -51,7 +51,7 @@ class WorkflowDefinition(BaseModel):
 
     @property
     def entrypoint(self) -> str:
-        return f'backend/{self.module.replace(".", "/")}:{self.function}'
+        return f"backend/{self.module.replace('.', '/')}:{self.function}"
 
     @property
     def full_name(self) -> str:

infrahub/workflows/utils.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING
 from prefect import get_client
 from prefect.runtime import flow_run
 
+from infrahub.core.constants import GLOBAL_BRANCH_NAME
 from infrahub.core.registry import registry
 from infrahub.tasks.registry import refresh_branches
 
@@ -27,7 +28,15 @@ async def add_tags(
     client = get_client(sync_client=False)
     current_flow_run_id = flow_run.id
     current_tags: list[str] = flow_run.tags
-    branch_tags = [WorkflowTag.BRANCH.render(identifier=branch_name) for branch_name in branches] if branches else []
+    branch_tags = (
+        [
+            WorkflowTag.BRANCH.render(identifier=branch_name)
+            for branch_name in branches
+            if branch_name != GLOBAL_BRANCH_NAME
+        ]
+        if branches
+        else []
+    )
     node_tags = [WorkflowTag.RELATED_NODE.render(identifier=node_id) for node_id in nodes] if nodes else []
     others_tags = others or []
     new_tags = set(current_tags + branch_tags + node_tags + others_tags)