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

infrahub/trace.py

@@ -9,7 +9,7 @@ from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
 )
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter, SpanExporter
 from opentelemetry.trace import StatusCode
 
 from infrahub.worker import WORKER_IDENTITY
@@ -19,7 +19,7 @@ def get_current_span_with_context() -> trace.Span:
     return trace.get_current_span()
 
 
-def get_traceid() -> str:
+def get_traceid() -> str | None:
     current_span = get_current_span_with_context()
     trace_id = current_span.get_span_context().trace_id
     if trace_id == 0:
@@ -63,7 +63,7 @@ def create_tracer_provider(
 ) -> TracerProvider:
     # Create a BatchSpanProcessor exporter based on the type
     if exporter_type == "console":
-        exporter = ConsoleSpanExporter()
+        exporter: SpanExporter = ConsoleSpanExporter()
     elif exporter_type == "otlp":
         if not exporter_endpoint:
             raise ValueError("Exporter type is set to otlp but endpoint is not set")
@@ -76,7 +76,7 @@ def create_tracer_provider(
 
     extra_attributes = {}
     if os.getenv("OTEL_RESOURCE_ATTRIBUTES"):
-        extra_attributes = dict(attr.split("=") for attr in os.getenv("OTEL_RESOURCE_ATTRIBUTES").split(","))
+        extra_attributes = dict(attr.split("=") for attr in os.getenv("OTEL_RESOURCE_ATTRIBUTES", "").split(","))
 
     # Resource can be required for some backends, e.g. Jaeger
     resource = Resource(

infrahub/transformations/tasks.py

@@ -30,7 +30,7 @@ async def transform_python(message: TransformPythonData, service: InfrahubServic
         location=message.transform_location,
         data=message.data,
         client=service.client,
-    )
+    )  # type: ignore[misc]
 
     return transformed_data
 
@@ -49,6 +49,6 @@ async def transform_render_jinja2_template(message: TransformJinjaTemplateData,
 
     rendered_template = await repo.render_jinja2_template.with_options(timeout_seconds=message.timeout)(
         commit=message.commit, location=message.template_location, data={"data": message.data}
-    )
+    )  # type: ignore[misc]
 
     return rendered_template

infrahub/trigger/catalogue.py

@@ -1,15 +1,13 @@
 from infrahub.computed_attribute.triggers import (
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
-    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_CLEAN_BRANCH,
-    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_BRANCH,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
 )
-from infrahub.webhook.triggers import TRIGGER_WEBHOOK_SETUP_UPDATE
+from infrahub.trigger.models import TriggerDefinition
+from infrahub.webhook.triggers import TRIGGER_WEBHOOK_DELETE, TRIGGER_WEBHOOK_SETUP_UPDATE
 
-triggers = [
+builtin_triggers: list[TriggerDefinition] = [
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
-    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_CLEAN_BRANCH,
-    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_BRANCH,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
+    TRIGGER_WEBHOOK_DELETE,
     TRIGGER_WEBHOOK_SETUP_UPDATE,
 ]

infrahub/trigger/constants.py

@@ -1,9 +1 @@
-DEPRECATED_STATIC_TRIGGER_NAMES = [
-    "Trigger-branch-create-events",  # used in 1.1.x
-    "Trigger-branch-remove-events",  # used in 1.1.x
-    "Trigger-webhook-update-configuration",  # used in 1.1.x
-    "Trigger-repository-commit-update-event",  # used in 1.1.x
-    "Trigger-schema-update-event",  # used in 1.1.x
-]
-
 NAME_SEPARATOR = "::"

infrahub/trigger/models.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
+
 from datetime import timedelta
 from enum import Enum
-from typing import Any
-from uuid import UUID
+from typing import TYPE_CHECKING, Any
 
 from prefect.events.actions import RunDeployment
 from prefect.events.schemas.automations import EventTrigger as PrefectEventTrigger
@@ -9,13 +10,22 @@ from prefect.events.schemas.automations import Posture
 from prefect.events.schemas.events import ResourceSpecification
 from pydantic import BaseModel, Field
 
+from infrahub import __version__
+from infrahub.workflows.models import WorkflowDefinition  # noqa: TC001
+
 from .constants import NAME_SEPARATOR
 
+if TYPE_CHECKING:
+    from uuid import UUID
+
 
 class TriggerType(str, Enum):
     BUILTIN = "builtin"
+    WEBHOOK = "webhook"
+    COMPUTED_ATTR_JINJA2 = "computed_attr_jinja2"
+    COMPUTED_ATTR_PYTHON = "computed_attr_python"
+    COMPUTED_ATTR_PYTHON_QUERY = "computed_attr_python_query"
     # OBJECT = "object"
-    # COMPUTED_ATTR = "computed_attr"
 
 
 class EventTrigger(BaseModel):
@@ -35,19 +45,44 @@ class EventTrigger(BaseModel):
 
 
 class ExecuteWorkflow(BaseModel):
-    name: str
+    workflow: WorkflowDefinition
     parameters: dict[str, Any] = Field(default_factory=dict)
 
+    @property
+    def name(self) -> str:
+        return self.workflow.name
+
     def get_prefect(self, mapping: dict[str, UUID]) -> RunDeployment:
         deployment_id = mapping[self.name]
+        return self.get(deployment_id)
 
+    def get(self, id: UUID) -> RunDeployment:
         return RunDeployment(
             source="selected",
-            deployment_id=deployment_id,
+            deployment_id=id,
             parameters=self.parameters,
             job_variables={},
         )
 
+    def validate_parameters(self) -> None:
+        if not self.parameters:
+            return
+
+        workflow_params = self.workflow.get_parameters()
+        workflow_required_params = [p.name for p in workflow_params.values() if p.required]
+        trigger_params = list(self.parameters.keys())
+
+        missing_required_params = set(workflow_required_params) - set(trigger_params)
+        wrong_params = set(trigger_params) - set(workflow_params)
+
+        if missing_required_params:
+            raise ValueError(
+                f"Missing required parameters: {missing_required_params} for workflow {self.workflow.name}"
+            )
+
+        if wrong_params:
+            raise ValueError(f"Workflow {self.workflow.name} doesn't support parameters: {wrong_params}")
+
 
 class TriggerDefinition(BaseModel):
     name: str
@@ -61,9 +96,23 @@ class TriggerDefinition(BaseModel):
         """Return the name of all deployments used by this trigger"""
         return [action.name for action in self.actions]
 
+    def get_description(self) -> str:
+        return f"Automation for Trigger {self.name} of type {self.type.value} (v{__version__})"
+
     def generate_name(self) -> str:
         return f"{self.type.value}{NAME_SEPARATOR}{self.name}"
 
+    def validate_actions(self) -> None:
+        for action in self.actions:
+            action.validate_parameters()
+
+
+class TriggerBranchDefinition(TriggerDefinition):
+    branch: str
+
+    def generate_name(self) -> str:
+        return f"{self.type.value}{NAME_SEPARATOR}{self.branch}{NAME_SEPARATOR}{self.name}"
+
 
 class BuiltinTriggerDefinition(TriggerDefinition):
     type: TriggerType = TriggerType.BUILTIN

infrahub/trigger/setup.py

@@ -0,0 +1,90 @@
+from typing import TYPE_CHECKING
+
+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 infrahub.trigger.models import TriggerDefinition
+
+from .models import TriggerType
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+
+@task(name="trigger-setup", task_run_name="Setup triggers", cache_policy=NONE)  # type: ignore[arg-type]
+async def setup_triggers(
+    client: PrefectClient,
+    triggers: list[TriggerDefinition],
+    trigger_type: TriggerType | None = None,
+) -> None:
+    log = get_run_logger()
+
+    if trigger_type:
+        log.info(f"Setting up triggers of type {trigger_type.value}")
+    else:
+        log.info("Setting up all triggers")
+
+    # -------------------------------------------------------------
+    # 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()}
+
+    # If a trigger type is provided, narrow down the list of existing triggers to know which one to delete
+    if trigger_type:
+        trigger_automations = [
+            item.name for item in await client.read_automations() if item.name.startswith(trigger_type.value)
+        ]
+    else:
+        trigger_automations = [item.name for item in await client.read_automations()]
+
+    trigger_names = [trigger.generate_name() for trigger in triggers]
+
+    log.debug(f"{len(trigger_automations)} existing triggers ({trigger_automations})")
+    log.debug(f"{len(trigger_names)}  triggers to configure ({trigger_names})")
+
+    to_delete = set(trigger_automations) - set(trigger_names)
+    log.debug(f"{len(trigger_names)} triggers to delete ({to_delete})")
+
+    # -------------------------------------------------------------
+    # Create or Update all triggers
+    # -------------------------------------------------------------
+    for trigger in triggers:
+        automation = AutomationCore(
+            name=trigger.generate_name(),
+            description=trigger.get_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.generate_name(), None)
+
+        if existing_automation:
+            await client.update_automation(automation_id=existing_automation.id, automation=automation)
+            log.info(f"{trigger.generate_name()} Updated")
+        else:
+            await client.create_automation(automation=automation)
+            log.info(f"{trigger.generate_name()} Created")
+
+    # -------------------------------------------------------------
+    # Delete 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")

infrahub/trigger/tasks.py

@@ -1,85 +1,36 @@
-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],
+from prefect import flow
+from prefect.client.orchestration import get_client
+
+from infrahub.computed_attribute.gather import (
+    gather_trigger_computed_attribute_jinja2,
+    gather_trigger_computed_attribute_python,
+)
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.trigger.catalogue import builtin_triggers
+from infrahub.webhook.gather import gather_trigger_webhook
+
+from .setup import setup_triggers
+
+
+@flow(name="trigger-configure-all", flow_run_name="Configure all triggers")
+async def trigger_configure_all(service: InfrahubServices) -> None:
+    webhook_trigger = await gather_trigger_webhook(db=service.database)
+    computed_attribute_j2_triggers = await gather_trigger_computed_attribute_jinja2()
+    (
+        computed_attribute_python_triggers,
+        computed_attribute_python_query_triggers,
+    ) = await gather_trigger_computed_attribute_python(db=service.database)
+
+    triggers = (
+        computed_attribute_j2_triggers
+        + computed_attribute_python_triggers
+        + computed_attribute_python_query_triggers
+        + builtin_triggers
+        + webhook_trigger
+    )
+
+    async with get_client(sync_client=False) as prefect_client:
+        await setup_triggers(
+            client=prefect_client,
+            triggers=triggers,
         )
-
-        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/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