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

infrahub/trigger/tasks.py

@@ -0,0 +1,85 @@
+from typing import TYPE_CHECKING
+
+from infrahub_sdk.utils import compare_lists
+from prefect import get_run_logger, task
+from prefect.automations import AutomationCore
+from prefect.cache_policies import NONE
+from prefect.client.orchestration import PrefectClient
+from prefect.client.schemas.filters import DeploymentFilter, DeploymentFilterName
+
+from .catalogue import triggers
+from .constants import DEPRECATED_STATIC_TRIGGER_NAMES
+from .models import TriggerType
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+
+@task(name="trigger-setup", task_run_name="Setup triggers in task-manager", cache_policy=NONE)  # type: ignore[arg-type]
+async def setup_triggers(client: PrefectClient) -> None:
+    log = get_run_logger()
+
+    # -------------------------------------------------------------
+    # Retrieve existing Deployments and Automation from the server
+    # -------------------------------------------------------------
+    deployment_names = list({name for trigger in triggers for name in trigger.get_deployment_names()})
+    deployments = {
+        item.name: item
+        for item in await client.read_deployments(
+            deployment_filter=DeploymentFilter(name=DeploymentFilterName(any_=deployment_names))
+        )
+    }
+    deployments_mapping: dict[str, UUID] = {name: item.id for name, item in deployments.items()}
+    existing_automations = {item.name: item for item in await client.read_automations()}
+
+    builtin_automations = [
+        item.name for item in await client.read_automations() if item.name.startswith(TriggerType.BUILTIN.value)
+    ]
+    trigger_names = [trigger.generate_name() for trigger in triggers]
+
+    _, to_delete, _ = compare_lists(list1=builtin_automations, list2=trigger_names)
+
+    # -------------------------------------------------------------
+    # Create or Update all builtin triggers
+    # -------------------------------------------------------------
+    for trigger in triggers:
+        automation = AutomationCore(
+            name=trigger.generate_name(),
+            description=trigger.description,
+            enabled=True,
+            trigger=trigger.trigger.get_prefect(),
+            actions=[action.get_prefect(mapping=deployments_mapping) for action in trigger.actions],
+        )
+
+        existing_automation = existing_automations.get(trigger.name, None)
+
+        if existing_automation:
+            await client.update_automation(automation_id=existing_automation.id, automation=automation)
+            log.info(f"{trigger.name} Updated")
+        else:
+            await client.create_automation(automation=automation)
+            log.info(f"{trigger.name} Created")
+
+    # -------------------------------------------------------------
+    # Delete Builtin Triggers that shouldn't be there
+    # -------------------------------------------------------------
+    for item_to_delete in to_delete:
+        existing_automation = existing_automations.get(item_to_delete)
+
+        if not existing_automation:
+            continue
+
+        await client.delete_automation(automation_id=existing_automation.id)
+        log.info(f"{item_to_delete} Deleted")
+
+    # -------------------------------------------------------------
+    # Delete Deprecated triggers
+    # -------------------------------------------------------------
+    for trigger_name in DEPRECATED_STATIC_TRIGGER_NAMES:
+        existing_automation = existing_automations.get(trigger_name)
+
+        if not existing_automation:
+            continue
+
+        await client.delete_automation(automation_id=existing_automation.id)
+        log.info(f"{trigger_name} Deleted")

infrahub/types.py

@@ -354,7 +354,7 @@ ATTRIBUTE_PYTHON_TYPES: dict[str, type] = {
     "Color": str,  # Colors often represented as hex strings
     "Number": float,  # Numbers can be floats for general use
     "Bandwidth": float,  # Bandwidth in some units, represented as a float
-    "IPHost": IPvAnyAddress,
+    "IPHost": IPvAnyAddress,  # type: ignore[dict-item]
     "IPNetwork": str,
     "Boolean": bool,
     "Checkbox": bool,  # Checkboxes represent boolean values

infrahub/utils.py

@@ -36,7 +36,7 @@ def format_label(slug: str) -> str:
 class MetaEnum(EnumMeta):
     def __contains__(cls, item: Any) -> bool:
         try:
-            cls(item)  # pylint: disable=no-value-for-parameter
+            cls(item)
         except ValueError:
             return False
         return True

infrahub/webhook/constants.py

@@ -1,3 +1 @@
-AUTOMATION_NAME = "Trigger-webhook-update-configuration"
-
 AUTOMATION_NAME_RUN = "Trigger-webhook-execution"

infrahub/webhook/models.py

@@ -87,11 +87,17 @@ class TransformWebhook(Webhook):
         repo: Union[InfrahubReadOnlyRepository, InfrahubRepository]
         if self.repository_kind == InfrahubKind.READONLYREPOSITORY:
             repo = await InfrahubReadOnlyRepository.init(
-                id=self.repository_id, name=self.repository_name, client=self.service.client
+                id=self.repository_id,
+                name=self.repository_name,
+                client=self.service.client,
+                service=self.service,
             )
         else:
             repo = await InfrahubRepository.init(
-                id=self.repository_id, name=self.repository_name, client=self.service.client
+                id=self.repository_id,
+                name=self.repository_name,
+                client=self.service.client,
+                service=self.service,
             )
 
         default_branch = repo.default_branch

infrahub/webhook/tasks.py

@@ -1,5 +1,5 @@
 from datetime import timedelta
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import ujson
 from infrahub_sdk.protocols import CoreCustomWebhook, CoreStandardWebhook, CoreTransformPython
@@ -12,18 +12,20 @@ from prefect.events.schemas.automations import EventTrigger, Posture
 from prefect.events.schemas.events import ResourceSpecification
 from prefect.logging import get_run_logger
 
-from infrahub.core.constants import InfrahubKind, MutationAction
+from infrahub.core.constants import MutationAction
 from infrahub.exceptions import NodeNotFoundError
-from infrahub.services import services
-from infrahub.workflows.catalogue import WEBHOOK_CONFIGURE, WEBHOOK_SEND, WEBHOOK_TRIGGER
+from infrahub.services import InfrahubServices
+from infrahub.workflows.catalogue import WEBHOOK_SEND, WEBHOOK_TRIGGER
 
-from .constants import AUTOMATION_NAME, AUTOMATION_NAME_RUN
+from .constants import AUTOMATION_NAME_RUN
 from .models import CustomWebhook, SendWebhookData, StandardWebhook, TransformWebhook, Webhook
 
+if TYPE_CHECKING:
+    from prefect.events.schemas.automations import Automation
+
 
 @flow(name="event-send-webhook", flow_run_name="Send Webhook")
-async def send_webhook(model: SendWebhookData) -> None:
-    service = services.service
+async def send_webhook(model: SendWebhookData, service: InfrahubServices) -> None:
     log = get_run_logger()
 
     webhook_definition = await service.cache.get(key=f"webhook:active:{model.webhook_id}")
@@ -49,20 +51,16 @@ async def send_webhook(model: SendWebhookData) -> None:
 
 
 @flow(name="webhook-trigger-actions", flow_run_name="Trigger configured webhooks")
-async def trigger_webhooks(event_type: str, event_data: str) -> None:
-    service = services.service
-    payload: dict = ujson.loads(event_data)
-
+async def trigger_webhooks(event_type: str, event_data: dict, service: InfrahubServices) -> None:
     webhooks = await service.cache.list_keys(filter_pattern="webhook:active:*")
     for webhook in webhooks:
         webhook_id = webhook.split(":")[-1]
-        model = SendWebhookData(webhook_id=webhook_id, event_type=event_type, event_data=payload)
+        model = SendWebhookData(webhook_id=webhook_id, event_type=event_type, event_data=event_data)
         await service.workflow.submit_workflow(workflow=WEBHOOK_SEND, parameters={"model": model})
 
 
 @flow(name="webhook-setup-automations", flow_run_name="Configuration webhook automation and populate cache")
-async def configure_webhooks() -> None:
-    service = services.service
+async def configure_webhooks(service: InfrahubServices) -> None:
     log = get_run_logger()
 
     log.debug("Refreshing webhook configuration")
@@ -135,7 +133,10 @@ async def configure_webhooks() -> None:
 
         deployment_id_webhook_trigger = deployments[WEBHOOK_TRIGGER.name].id
 
-        webhook_configure_automation = await client.find_automation(id_or_name=AUTOMATION_NAME_RUN)
+        webhook_configure_automation: Automation | None = None
+        automations = await client.read_automations_by_name(name=AUTOMATION_NAME_RUN)
+        if automations:
+            webhook_configure_automation = automations[0]
 
         if not has_webhooks:
             if webhook_configure_automation:
@@ -163,7 +164,10 @@ async def configure_webhooks() -> None:
                     deployment_id=deployment_id_webhook_trigger,
                     parameters={
                         "event_type": "{{ event.resource['infrahub.node.kind'] }}.{{ event.resource['infrahub.node.action'] }}",
-                        "event_data": "{{ event.payload['data'] | tojson }}",
+                        "event_data": {
+                            "__prefect_kind": "json",
+                            "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['data'] | tojson }}"},
+                        },
                     },
                     job_variables={},
                 ),
@@ -176,60 +180,3 @@ async def configure_webhooks() -> None:
         else:
             await client.create_automation(automation=automation)
             log.info(f"{AUTOMATION_NAME_RUN} Created")
-
-
-@flow(name="webhook-setup-configuration-trigger", flow_run_name="Setup automations for webhooks")
-async def trigger_webhook_configuration() -> None:
-    log = get_run_logger()
-
-    async with get_client(sync_client=False) as client:
-        deployments = {
-            item.name: item
-            for item in await client.read_deployments(
-                deployment_filter=DeploymentFilter(
-                    name=DeploymentFilterName(
-                        any_=[
-                            WEBHOOK_CONFIGURE.name,
-                        ]
-                    )
-                )
-            )
-        }
-        if WEBHOOK_CONFIGURE.name not in deployments:
-            raise ValueError("Unable to find the deployment for WEBHOOK_CONFIGURE")
-
-        deployment_id_webhook_setup = deployments[WEBHOOK_CONFIGURE.name].id
-
-        webhook_configure_automation = await client.find_automation(id_or_name=AUTOMATION_NAME)
-
-        automation = AutomationCore(
-            name=AUTOMATION_NAME,
-            description="Trigger actions on schema update event",
-            enabled=True,
-            trigger=EventTrigger(
-                posture=Posture.Reactive,
-                expect={"infrahub.node.*"},
-                within=timedelta(0),
-                match=ResourceSpecification(
-                    {
-                        "infrahub.node.kind": [InfrahubKind.WEBHOOK, InfrahubKind.STANDARDWEBHOOK],
-                    }
-                ),
-                threshold=1,
-            ),
-            actions=[
-                RunDeployment(
-                    source="selected",
-                    deployment_id=deployment_id_webhook_setup,
-                    parameters={},
-                    job_variables={},
-                ),
-            ],
-        )
-
-        if webhook_configure_automation:
-            await client.update_automation(automation_id=webhook_configure_automation.id, automation=automation)
-            log.info(f"{AUTOMATION_NAME} Updated")
-        else:
-            await client.create_automation(automation=automation)
-            log.info(f"{AUTOMATION_NAME} Created")

infrahub/webhook/triggers.py

@@ -0,0 +1,20 @@
+from infrahub.core.constants import InfrahubKind
+from infrahub.trigger.models import BuiltinTriggerDefinition, EventTrigger, ExecuteWorkflow
+from infrahub.workflows.catalogue import (
+    WEBHOOK_CONFIGURE,
+)
+
+TRIGGER_WEBHOOK_SETUP_UPDATE = BuiltinTriggerDefinition(
+    name="webhook-setup-update-configuration",
+    trigger=EventTrigger(
+        events={"infrahub.node.*"},
+        match={
+            "infrahub.node.kind": [InfrahubKind.WEBHOOK, InfrahubKind.STANDARDWEBHOOK],
+        },
+    ),
+    actions=[
+        ExecuteWorkflow(
+            name=WEBHOOK_CONFIGURE.name,
+        ),
+    ],
+)

infrahub/workers/infrahub_async.py

@@ -1,4 +1,3 @@
-import importlib
 import logging
 import os
 from typing import Any, Optional
@@ -23,7 +22,7 @@ from infrahub.database import InfrahubDatabase, get_db
 from infrahub.dependencies.registry import build_component_registry
 from infrahub.git import initialize_repositories_directory
 from infrahub.lock import initialize_lock
-from infrahub.services import InfrahubServices, services
+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
@@ -33,6 +32,8 @@ 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
+from infrahub.trace import configure_trace
+from infrahub.workers.utils import inject_service_parameter, load_flow_function
 from infrahub.workflows.models import TASK_RESULT_STORAGE_NAME
 
 WORKER_QUERY_SECONDS = "2"
@@ -65,6 +66,7 @@ class InfrahubWorkerAsync(BaseWorker):
     _documentation_url = "https://example.com/docs"
     _logo_url = "https://example.com/logo"
     _description = "Infrahub worker designed to run the flow in the main async loop."
+    service: InfrahubServices  # keep a reference to `service` so we can inject it within flows parameters.
 
     async def setup(
         self,
@@ -89,6 +91,16 @@ class InfrahubWorkerAsync(BaseWorker):
 
         self._init_logger()
 
+        # Initialize trace
+        if config.SETTINGS.trace.enable:
+            configure_trace(
+                service="infrahub-task-worker",
+                version=infrahub_version,
+                exporter_type=config.SETTINGS.trace.exporter_type,
+                exporter_endpoint=config.SETTINGS.trace.exporter_endpoint,
+                exporter_protocol=config.SETTINGS.trace.exporter_protocol,
+            )
+
         # Start metric endpoint
         if metric_port is None or metric_port != 0:
             metric_port = metric_port or int(os.environ.get("INFRAHUB_METRICS_PORT", 8000))
@@ -107,20 +119,19 @@ class InfrahubWorkerAsync(BaseWorker):
             )
         )
 
-        client = await self._init_infrahub_client(client=client)
-        service = await self._init_services(client=client)
+        await self._init_services(client=client)
 
         if not registry.schema_has_been_initialized():
-            initialize_lock(service=service)
+            initialize_lock(service=self.service)
 
-            async with service.database.start_session() as db:
+            async with self.service.database.start_session() as db:
                 await initialization(db=db)
 
-            await service.component.refresh_schema_hash()
+            await self.service.component.refresh_schema_hash()
 
         initialize_repositories_directory()
         build_component_registry()
-        await service.scheduler.start_schedule()
+        await self.service.scheduler.start_schedule()
         self._logger.info("Worker initialization completed .. ")
 
     async def run(
@@ -136,9 +147,8 @@ class InfrahubWorkerAsync(BaseWorker):
         file_path, flow_name = entrypoint.split(":")
         file_path.replace("/", ".")
         module_path = file_path.replace("backend/", "").replace(".py", "").replace("/", ".")
-        module = importlib.import_module(module_path)
-        flow_func = getattr(module, flow_name)
-
+        flow_func = load_flow_function(module_path=module_path, flow_name=flow_name)
+        inject_service_parameter(func=flow_func, parameters=flow_run.parameters, service=self.service)
         flow_run_logger.debug("Validating parameters")
         params = flow_func.validate_parameters(parameters=flow_run.parameters)
 
@@ -170,9 +180,9 @@ class InfrahubWorkerAsync(BaseWorker):
 
         try:
             await client.branch.all()
-        except SdkError as exc:
-            self._logger.error(f"Error in communication with Infrahub: {exc.message}")
-            raise typer.Exit(1)
+        except SdkError as err:
+            self._logger.error(f"Error in communication with Infrahub: {err.message}")
+            raise typer.Exit(1) from err
 
         return client
 
@@ -186,32 +196,33 @@ class InfrahubWorkerAsync(BaseWorker):
             else WorkflowLocalExecution()
         )
 
-    async def _init_message_bus(self) -> InfrahubMessageBus:
+    async def _init_message_bus(self, component_type: ComponentType) -> InfrahubMessageBus:
         return config.OVERRIDE.message_bus or (
-            NATSMessageBus() if config.SETTINGS.broker.driver == config.BrokerDriver.NATS else RabbitMQMessageBus()
+            await NATSMessageBus.new(component_type=component_type)
+            if config.SETTINGS.broker.driver == config.BrokerDriver.NATS
+            else await RabbitMQMessageBus.new(component_type=component_type)
         )
 
     async def _init_cache(self) -> InfrahubCache:
         return config.OVERRIDE.cache or (
-            NATSCache() if config.SETTINGS.cache.driver == config.CacheDriver.NATS else RedisCache()
+            await NATSCache.new() if config.SETTINGS.cache.driver == config.CacheDriver.NATS else RedisCache()
         )
 
-    async def _init_services(self, client: InfrahubClient) -> InfrahubServices:
+    async def _init_services(self, client: InfrahubClient) -> None:
+        component_type = ComponentType.GIT_AGENT
+        client = await self._init_infrahub_client(client=client)
         database = await self._init_database()
         workflow = await self._init_workflow()
-        message_bus = await self._init_message_bus()
+        message_bus = await self._init_message_bus(component_type=component_type)
         cache = await self._init_cache()
 
-        service = InfrahubServices(
+        service = await InfrahubServices.new(
             cache=cache,
             client=client,
             database=database,
             message_bus=message_bus,
             workflow=workflow,
-            component_type=ComponentType.GIT_AGENT,
+            component_type=component_type,
         )
 
-        services.service = service
-        await service.initialize()
-
-        return service
+        self.service = service

infrahub/workers/utils.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+from typing import TYPE_CHECKING, Any
+
+from prefect import Flow
+
+from infrahub.context import InfrahubContext
+
+if TYPE_CHECKING:
+    from infrahub.services import InfrahubServices
+
+
+def inject_service_parameter(func: Flow, parameters: dict[str, Any], service: InfrahubServices) -> None:
+    """
+    `service` object instantiates connections to various services (db, cache...) at worker startup,
+    so it is not meant to be sent by the server payload. We inject it here to avoid relying on a global variable.
+    This mutates input `parameters`.
+    """
+
+    # avoid circular imports
+    from infrahub.services import InfrahubServices  # pylint: disable=C0415
+
+    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")
+        parameters[service_parameter_name] = service
+        return
+
+
+def inject_context_parameter(func: Flow, parameters: dict[str, Any], context: InfrahubContext | None = None) -> None:
+    service_parameter_name = get_parameter_name(func=func, types=[InfrahubContext.__name__, InfrahubContext])
+    if service_parameter_name and context:
+        parameters[service_parameter_name] = context
+        return
+
+    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"
+        )
+
+
+def load_flow_function(module_path: str, flow_name: str) -> Flow:
+    module = importlib.import_module(module_path)
+    flow_func = getattr(module, flow_name)
+    if not isinstance(flow_func, Flow):
+        raise ValueError(
+            f"Function loaded at {module_path=} with {flow_name=} has type {type(flow_func)}, expected {Flow}"
+        )
+    return flow_func
+
+
+def get_parameter_name(func: Flow, types: list[Any]) -> str | None:
+    sig = inspect.signature(func)
+    for sig_param in sig.parameters.values():
+        if sig_param.annotation in types:
+            return sig_param.name
+    return None
+
+
+def has_parameter(func: Flow, types: list[Any]) -> bool:
+    return get_parameter_name(func=func, types=types) is not None

infrahub/workflows/catalogue.py

@@ -319,27 +319,6 @@ REQUEST_PROPOSED_CHANGE_USER_TESTS = WorkflowDefinition(
     function="run_proposed_change_user_tests",
 )
 
-AUTOMATION_BRANCH_ACTIONS = WorkflowDefinition(
-    name="branch-actions-setup",
-    type=WorkflowType.CORE,
-    module="infrahub.core.branch.tasks",
-    function="branch_actions_setup",
-)
-
-AUTOMATION_SCHEMA_UPDATED = WorkflowDefinition(
-    name="schema-updated-setup",
-    type=WorkflowType.CORE,
-    module="infrahub.schema.tasks",
-    function="schema_updated_setup",
-)
-
-AUTOMATION_GIT_UPDATED = WorkflowDefinition(
-    name="git-commit-automation-setup",
-    type=WorkflowType.CORE,
-    module="infrahub.git.tasks",
-    function="setup_commit_automation",
-)
-
 GIT_REPOSITORIES_DIFF_NAMES_ONLY = WorkflowDefinition(
     name="git-repository-diff-names-only",
     type=WorkflowType.INTERNAL,
@@ -370,6 +349,13 @@ REQUEST_PROPOSED_CHANGE_REPOSITORY_CHECKS = WorkflowDefinition(
     function="repository_checks",
 )
 
+REQUEST_ARTIFACT_DEFINITION_CHECK = WorkflowDefinition(
+    name="artifacts-generation-validation",
+    type=WorkflowType.INTERNAL,
+    module="infrahub.proposed_change.tasks",
+    function="validate_artifacts_generation",
+)
+
 WEBHOOK_CONFIGURE = WorkflowDefinition(
     name="webhook-setup-automations",
     type=WorkflowType.USER,
@@ -384,22 +370,17 @@ WEBHOOK_TRIGGER = WorkflowDefinition(
     function="trigger_webhooks",
 )
 
-AUTOMATION_SETUP_WEBHOOK_CONFIGURATION_TRIGGER = WorkflowDefinition(
-    name="webhook-setup-configuration-trigger",
+GIT_REPOSITORIES_CHECK_ARTIFACT_CREATE = WorkflowDefinition(
+    name="git-repository-check-artifact-create",
     type=WorkflowType.USER,
-    module="infrahub.webhook.tasks",
-    function="trigger_webhook_configuration",
+    module="infrahub.artifacts.tasks",
+    function="create",
 )
 
-
 worker_pools = [INFRAHUB_WORKER_POOL]
 
 workflows = [
     ANONYMOUS_TELEMETRY_SEND,
-    AUTOMATION_BRANCH_ACTIONS,
-    AUTOMATION_GIT_UPDATED,
-    AUTOMATION_SCHEMA_UPDATED,
-    AUTOMATION_SETUP_WEBHOOK_CONFIGURATION_TRIGGER,
     BRANCH_CANCEL_PROPOSED_CHANGES,
     BRANCH_CREATE,
     BRANCH_DELETE,
@@ -413,6 +394,7 @@ workflows = [
     DIFF_REFRESH,
     DIFF_REFRESH_ALL,
     DIFF_UPDATE,
+    GIT_REPOSITORIES_CHECK_ARTIFACT_CREATE,
     GIT_REPOSITORIES_CREATE_BRANCH,
     GIT_REPOSITORIES_DIFF_NAMES_ONLY,
     GIT_REPOSITORIES_IMPORT_OBJECTS,
@@ -426,6 +408,7 @@ workflows = [
     PROCESS_COMPUTED_MACRO,
     PROPOSED_CHANGE_MERGE,
     QUERY_COMPUTED_ATTRIBUTE_TRANSFORM_TARGETS,
+    REQUEST_ARTIFACT_DEFINITION_CHECK,
     REQUEST_ARTIFACT_DEFINITION_GENERATE,
     REQUEST_ARTIFACT_GENERATE,
     REQUEST_GENERATOR_DEFINITION_RUN,
@@ -448,10 +431,3 @@ workflows = [
     WEBHOOK_SEND,
     WEBHOOK_TRIGGER,
 ]
-
-automation_setup_workflows = [
-    AUTOMATION_BRANCH_ACTIONS,
-    AUTOMATION_GIT_UPDATED,
-    AUTOMATION_SCHEMA_UPDATED,
-    AUTOMATION_SETUP_WEBHOOK_CONFIGURATION_TRIGGER,
-]

infrahub/workflows/initialization.py

@@ -7,12 +7,13 @@ from prefect.exceptions import ObjectAlreadyExists
 from prefect.logging import get_run_logger
 
 from infrahub import config
+from infrahub.trigger.tasks import setup_triggers
 
-from .catalogue import automation_setup_workflows, worker_pools, workflows
+from .catalogue import worker_pools, workflows
 from .models import TASK_RESULT_STORAGE_NAME
 
 
-@task(name="task-manager-setup-worker-pools", task_run_name="Setup Worker pools", cache_policy=NONE)
+@task(name="task-manager-setup-worker-pools", task_run_name="Setup Worker pools", cache_policy=NONE)  # type: ignore[arg-type]
 async def setup_worker_pools(client: PrefectClient) -> None:
     log = get_run_logger()
     for worker in worker_pools:
@@ -28,7 +29,7 @@ async def setup_worker_pools(client: PrefectClient) -> None:
             log.warning(f"Work pool {worker.name} already present ")
 
 
-@task(name="task-manager-setup-deployments", task_run_name="Setup Deployments", cache_policy=NONE)
+@task(name="task-manager-setup-deployments", task_run_name="Setup Deployments", cache_policy=NONE)  # type: ignore[arg-type]
 async def setup_deployments(client: PrefectClient) -> None:
     log = get_run_logger()
     for workflow in workflows:
@@ -38,12 +39,8 @@ async def setup_deployments(client: PrefectClient) -> None:
         await workflow.save(client=client, work_pool=work_pool)
         log.info(f"Flow {workflow.name}, created successfully ... ")
 
-    for automation_setup_workflow in automation_setup_workflows:
-        automation_setup = automation_setup_workflow.get_function()
-        await automation_setup()
 
-
-@task(name="task-manager-setup-blocks", task_run_name="Setup Blocks", cache_policy=NONE)
+@task(name="task-manager-setup-blocks", task_run_name="Setup Blocks", cache_policy=NONE)  # type: ignore[arg-type]
 async def setup_blocks() -> None:
     log = get_run_logger()
 
@@ -71,3 +68,4 @@ async def setup_task_manager() -> None:
         await setup_blocks()
         await setup_worker_pools(client=client)
         await setup_deployments(client=client)
+        await setup_triggers(client=client)

infrahub/workflows/models.py

@@ -1,7 +1,8 @@
 import importlib
-from typing import Any, Awaitable, Callable, TypeVar
+from typing import Any, Awaitable, TypeVar
 from uuid import UUID
 
+from prefect import Flow
 from prefect.client.orchestration import PrefectClient
 from prefect.client.schemas.actions import DeploymentScheduleCreate
 from prefect.client.schemas.objects import FlowRun
@@ -72,9 +73,6 @@ class WorkflowDefinition(BaseModel):
         data["work_pool_name"] = work_pool.name
         return await client.create_deployment(flow_id=flow_id, **data)
 
-    def get_function(self) -> Callable[..., Awaitable[Any]]:
+    def load_function(self) -> Flow[Any, Awaitable]:
         module = importlib.import_module(self.module)
         return getattr(module, self.function)
-
-    def validate_workflow(self) -> None:
-        self.get_function()

infrahub/workflows/utils.py

@@ -76,4 +76,4 @@ async def wait_for_schema_to_converge(
 
         iteration += 1
 
-    log.info(f"Schema converged after {delay * iteration} seconds")
+    log.info(f"Schema converged after {delay * iteration:.2f} seconds")