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

infrahub/task_manager/event.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from prefect.client.orchestration import PrefectClient, get_client
+from prefect.events.schemas.events import Event as PrefectEventModel
+from pydantic import BaseModel, Field, TypeAdapter
+
+from infrahub.log import get_logger
+from infrahub.utils import get_nested_dict
+
+log = get_logger()
+
+if TYPE_CHECKING:
+    from .models import InfrahubEventFilter
+
+
+class PrefectEventData(PrefectEventModel):
+    def get_branch(self) -> str | None:
+        for resource in self.related:
+            if resource.get("prefect.resource.role") != "infrahub.branch":
+                continue
+            if "infrahub.resource.label" not in resource:
+                continue
+            return resource.get("infrahub.resource.label")
+        return None
+
+    def get_level(self) -> int:
+        for resource in self.related:
+            level = resource.get("infrahub.event.level")
+            if level is None:
+                continue
+            try:
+                return int(level)
+            except ValueError:
+                return 0
+
+        return 0
+
+    def get_parent(self) -> str | None:
+        for resource in self.related:
+            if resource.get("prefect.resource.role") != "infrahub.child_event":
+                continue
+            return resource.get("infrahub.event_parent.id")
+        return None
+
+    def get_primary_node(self) -> dict[str, str] | None:
+        node_id = self.resource.get("infrahub.node.id")
+        node_kind = self.resource.get("infrahub.node.kind")
+        if node_id and node_kind:
+            return {"id": node_id, "kind": node_kind}
+
+        return None
+
+    def get_related_nodes(self) -> list[dict[str, str]]:
+        related_nodes = []
+        for resource in self.related:
+            if resource.get("prefect.resource.role") != "infrahub.related.node":
+                continue
+
+            node_id = resource.get("prefect.resource.id")
+            node_kind = resource.get("infrahub.node.kind")
+            if node_id == self.resource.get("infrahub.node.id"):
+                # Don't include the primary node as a related node.
+                continue
+            if node_id and node_kind:
+                related_nodes.append({"id": node_id, "kind": node_kind})
+
+        return related_nodes
+
+    def get_account_id(self) -> str | None:
+        for resource in self.related:
+            if resource.get("prefect.resource.role") != "infrahub.account":
+                continue
+            return resource.get("infrahub.resource.id")
+        return None
+
+    def has_children(self) -> bool:
+        for resource in self.related:
+            if resource.get("prefect.resource.role") != "infrahub.event":
+                continue
+            if resource.get("infrahub.event.has_children") == "true":
+                return True
+            return False
+        return False
+
+    def _return_node_mutation(self) -> dict[str, Any]:
+        attributes = []
+
+        for resource in self.related:
+            if resource.get("prefect.resource.role") == "infrahub.node.field_update" and resource.get(
+                "infrahub.attribute.name"
+            ):
+                attributes.append(
+                    {
+                        "name": resource.get("infrahub.attribute.name", ""),
+                        "kind": resource.get("infrahub.attribute.kind", ""),
+                        "value": None
+                        if resource.get("infrahub.attribute.value") == "NULL"
+                        else resource.get("infrahub.attribute.value"),
+                        "value_previous": None
+                        if resource.get("infrahub.attribute.value_previous") == "NULL"
+                        else resource.get("infrahub.attribute.value_previous"),
+                        "action": resource.get("infrahub.attribute.action", "unchanged"),
+                    }
+                )
+
+        return {"attributes": attributes}
+
+    def _return_event_specifics(self) -> dict[str, Any]:
+        match self.event:
+            case "infrahub.node.created" | "infrahub.node.updated" | "infrahub.node.deleted":
+                return self._return_node_mutation()
+
+        return {}
+
+    def to_graphql(self) -> dict[str, Any]:
+        response = {
+            "id": str(self.id),
+            "event": self.event,
+            "branch": self.get_branch(),
+            "account_id": self.get_account_id(),
+            "occurred_at": self.occurred,
+            "has_children": self.has_children(),
+            "payload": self.payload,
+            "level": self.get_level(),
+            "primary_node": self.get_primary_node(),
+            "parent_id": self.get_parent(),
+            "related_nodes": self.get_related_nodes(),
+        }
+        response.update(self._return_event_specifics())
+        return response
+
+
+class PrefectEventResponse(BaseModel):
+    count: int = Field(..., description="Number of matching events")
+    events: list[PrefectEventData] = Field(..., description="Returned events")
+
+
+class PrefectEvent:
+    @classmethod
+    async def query_events(
+        cls,
+        client: PrefectClient,
+        limit: int,
+        filters: InfrahubEventFilter,
+        offset: int | None = None,
+    ) -> PrefectEventResponse:
+        body = {"limit": limit, "filter": filters.model_dump(mode="json", exclude_none=True), "offset": offset}
+
+        response = await client._client.post("/infrahub/events/filter", json=body)
+        response.raise_for_status()
+        data: dict[str, Any] = response.json()
+
+        return PrefectEventResponse(
+            count=data.get("total", 0),
+            events=TypeAdapter(list[PrefectEventData]).validate_python(data.get("events")),
+        )
+
+    @classmethod
+    async def query(
+        cls,
+        fields: dict[str, Any],
+        event_filter: InfrahubEventFilter,
+        limit: int | None = None,
+        offset: int | None = None,
+    ) -> dict[str, Any]:
+        nodes: list[dict] = []
+        limit = limit or 50
+
+        node_fields = get_nested_dict(nested_dict=fields, keys=["edges", "node"])
+
+        if not node_fields:
+            # This means that it's purely a count query and as such we can override the limit to avoid
+            # returning data that will only be discarded
+            limit = 1
+
+        async with get_client(sync_client=False) as client:
+            response = await cls.query_events(client=client, filters=event_filter, limit=limit, offset=offset)
+            nodes = [{"node": event.to_graphql()} for event in response.events]
+
+        return {"count": response.count, "edges": nodes}

infrahub/task_manager/models.py

@@ -1,11 +1,29 @@
+from __future__ import annotations
+
+import uuid
 from collections import defaultdict
+from typing import TYPE_CHECKING
 from uuid import UUID
 
-from prefect.client.schemas.objects import Log as PrefectLog
+from prefect.client.schemas.objects import Log as PrefectLog  # noqa: TC002
+from prefect.events.filters import (
+    EventFilter,
+    EventIDFilter,
+    EventNameFilter,
+    EventOccurredFilter,
+    EventRelatedFilter,
+    EventResourceFilter,
+)
+from prefect.events.schemas.events import ResourceSpecification
 from pydantic import BaseModel, Field
 
+from infrahub.core.timestamp import Timestamp
+
 from .constants import LOG_LEVEL_MAPPING
 
+if TYPE_CHECKING:
+    from datetime import datetime
+
 
 class RelatedNodeInfo(BaseModel):
     id: str
@@ -63,3 +81,109 @@ class FlowLogs(BaseModel):
 
 class FlowProgress(BaseModel):
     data: dict[UUID, float] = Field(default_factory=dict)
+
+
+class InfrahubEventFilter(EventFilter):
+    matching_related: list[EventRelatedFilter] = Field(default_factory=list)
+
+    def add_account_filter(self, account__ids: list[str] | None) -> None:
+        if account__ids:
+            self.matching_related.append(
+                EventRelatedFilter(
+                    labels=ResourceSpecification(
+                        {"prefect.resource.role": "infrahub.account", "infrahub.resource.id": account__ids}
+                    )
+                )
+            )
+
+    def add_branch_filter(self, branches: list[str] | None = None) -> None:
+        if branches:
+            self.matching_related.append(
+                EventRelatedFilter(
+                    labels=ResourceSpecification(
+                        {"prefect.resource.role": "infrahub.branch", "infrahub.resource.label": branches}
+                    )
+                )
+            )
+
+    def add_event_filter(self, level: int | None = None, has_children: bool | None = None) -> None:
+        event_filter: dict[str, list[str] | str] = {}
+        if level is not None:
+            event_filter["infrahub.event.level"] = str(level)
+
+        if has_children is not None:
+            event_filter["infrahub.event.has_children"] = str(has_children).lower()
+
+        if event_filter:
+            event_filter["prefect.resource.role"] = "infrahub.event"
+            self.matching_related.append(EventRelatedFilter(labels=ResourceSpecification(event_filter)))
+
+    def add_event_id_filter(self, ids: list[str] | None = None) -> None:
+        if ids:
+            self.id = EventIDFilter(id=[uuid.UUID(id) for id in ids])
+
+    def add_event_type_filter(self, event_type: list[str] | None = None) -> None:
+        if event_type:
+            self.event = EventNameFilter(name=event_type)
+
+    def add_primary_node_filter(self, primary_node__ids: list[str] | None) -> None:
+        if primary_node__ids:
+            self.resource = EventResourceFilter(labels=ResourceSpecification({"infrahub.node.id": primary_node__ids}))
+
+    def add_parent_filter(self, parent__ids: list[str] | None) -> None:
+        if parent__ids:
+            self.matching_related.append(
+                EventRelatedFilter(
+                    labels=ResourceSpecification(
+                        {"prefect.resource.role": "infrahub.child_event", "infrahub.event_parent.id": parent__ids}
+                    )
+                )
+            )
+
+    def add_related_node_filter(self, related_node__ids: list[str] | None) -> None:
+        if related_node__ids:
+            self.matching_related.append(
+                EventRelatedFilter(
+                    labels=ResourceSpecification(
+                        {"prefect.resource.role": "infrahub.related.node", "prefect.resource.id": related_node__ids}
+                    )
+                )
+            )
+
+    @classmethod
+    def from_filters(
+        cls,
+        ids: list[str] | None = None,
+        account__ids: list[str] | None = None,
+        related_node__ids: list[str] | None = None,
+        parent__ids: list[str] | None = None,
+        primary_node__ids: list[str] | None = None,
+        event_type: list[str] | None = None,
+        branches: list[str] | None = None,
+        level: int | None = None,
+        has_children: bool | None = None,
+        since: datetime | None = None,
+        until: datetime | None = None,
+    ) -> InfrahubEventFilter:
+        occurred_filter = {}
+        if since:
+            occurred_filter["since"] = Timestamp(since.isoformat()).obj
+
+        if until:
+            occurred_filter["until"] = Timestamp(until.isoformat()).obj
+
+        if occurred_filter:
+            filters = cls(occurred=EventOccurredFilter(**occurred_filter))
+        else:
+            filters = cls()
+
+        filters.add_event_filter(level=level, has_children=has_children)
+        filters.add_event_id_filter(ids=ids)
+        filters.add_event_type_filter(event_type=event_type)
+        filters.add_branch_filter(branches=branches)
+        filters.add_account_filter(account__ids=account__ids)
+        filters.add_parent_filter(parent__ids=parent__ids)
+        filters.add_primary_node_filter(primary_node__ids=primary_node__ids)
+        filters.add_related_node_filter(related_node__ids=related_node__ids)
+
+        return filters

infrahub/task_manager/task.py

@@ -250,7 +250,7 @@ class PrefectTask:
                             "node": {
                                 "title": flow.name,
                                 "conclusion": CONCLUSION_STATE_MAPPING.get(
-                                    flow.state_name, TaskConclusion.UNKNOWN
+                                    str(flow.state_name), TaskConclusion.UNKNOWN
                                 ).value,
                                 "state": flow.state_type,
                                 "progress": progress_flow.data.get(flow.id, None),

infrahub/tasks/artifact.py

@@ -5,40 +5,38 @@ from prefect import task
 from prefect.cache_policies import NONE
 
 from infrahub import lock
+from infrahub.artifacts.models import CheckArtifactCreate
 from infrahub.core.constants import InfrahubKind
 from infrahub.git.models import RequestArtifactGenerate
-from infrahub.message_bus import messages
 from infrahub.services import InfrahubServices
 
 
-@task(name="define-artifact", task_run_name="Define Artifact", cache_policy=NONE)
+@task(name="define-artifact", task_run_name="Define Artifact", cache_policy=NONE)  # type: ignore[arg-type]
 async def define_artifact(
-    message: Union[messages.CheckArtifactCreate, RequestArtifactGenerate], service: InfrahubServices
+    model: Union[CheckArtifactCreate, RequestArtifactGenerate], service: InfrahubServices
 ) -> InfrahubNode:
-    if message.artifact_id:
-        artifact = await service.client.get(
-            kind=InfrahubKind.ARTIFACT, id=message.artifact_id, branch=message.branch_name
-        )
+    if model.artifact_id:
+        artifact = await service.client.get(kind=InfrahubKind.ARTIFACT, id=model.artifact_id, branch=model.branch_name)
     else:
-        async with lock.registry.get(f"{message.target_id}-{message.artifact_definition}", namespace="artifact"):
+        async with lock.registry.get(f"{model.target_id}-{model.artifact_definition}", namespace="artifact"):
             artifacts = await service.client.filters(
                 kind=InfrahubKind.ARTIFACT,
-                branch=message.branch_name,
-                definition__ids=[message.artifact_definition],
-                object__ids=[message.target_id],
+                branch=model.branch_name,
+                definition__ids=[model.artifact_definition],
+                object__ids=[model.target_id],
             )
             if artifacts:
                 artifact = artifacts[0]
             else:
                 artifact = await service.client.create(
                     kind=InfrahubKind.ARTIFACT,
-                    branch=message.branch_name,
+                    branch=model.branch_name,
                     data={
-                        "name": message.artifact_name,
+                        "name": model.artifact_name,
                         "status": "Pending",
-                        "object": message.target_id,
-                        "definition": message.artifact_definition,
-                        "content_type": message.content_type,
+                        "object": model.target_id,
+                        "definition": model.artifact_definition,
+                        "content_type": model.content_type,
                     },
                 )
                 await artifact.save()

infrahub/tasks/registry.py

@@ -18,7 +18,7 @@ async def refresh_branches(db: InfrahubDatabase) -> None:
     If a branch is already present with a different value for the hash
     We pull the new schema from the database and we update the registry.
     """
-    from infrahub.graphql.manager import GraphQLSchemaManager  # pylint: disable=import-outside-toplevel,cyclic-import
+    from infrahub.graphql.manager import GraphQLSchemaManager
 
     async with lock.registry.local_schema_lock():
         branches = await registry.branch_object.get_list(db=db)

infrahub/tasks/telemetry.py

@@ -13,14 +13,14 @@ from infrahub.core import registry, utils
 from infrahub.core.branch import Branch
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.graph.schema import GRAPH_SCHEMA
-from infrahub.services import InfrahubServices, services
+from infrahub.services import InfrahubServices
 
 TELEMETRY_KIND: str = "community"
 TELEMETRY_VERSION: str = "20240524"
 
 
-@task(name="telemetry-gather-db", task_run_name="Gather Database Information", cache_policy=NONE)
-async def gather_database_information(service: InfrahubServices, branch: Branch) -> dict:  # pylint: disable=unused-argument
+@task(name="telemetry-gather-db", task_run_name="Gather Database Information", cache_policy=NONE)  # type: ignore[arg-type]
+async def gather_database_information(service: InfrahubServices) -> dict:
     async with service.database.start_session() as db:
         data: dict[str, Any] = {
             "database_type": db.db_type.value,
@@ -37,8 +37,8 @@ async def gather_database_information(service: InfrahubServices, branch: Branch)
         return data
 
 
-@task(name="telemetry-schema-information", task_run_name="Gather Schema Information", cache_policy=NONE)
-async def gather_schema_information(service: InfrahubServices, branch: Branch) -> dict:  # pylint: disable=unused-argument
+@task(name="telemetry-schema-information", task_run_name="Gather Schema Information", cache_policy=NONE)  # type: ignore[arg-type]
+async def gather_schema_information(branch: Branch) -> dict:
     data: dict[str, Any] = {}
     main_schema = registry.schema.get_schema_branch(name=branch.name)
     data["node_count"] = len(main_schema.node_names)
@@ -48,8 +48,8 @@ async def gather_schema_information(service: InfrahubServices, branch: Branch) -
     return data
 
 
-@task(name="telemetry-feature-information", task_run_name="Gather Feature Information", cache_policy=NONE)
-async def gather_feature_information(service: InfrahubServices, branch: Branch) -> dict:  # pylint: disable=unused-argument
+@task(name="telemetry-feature-information", task_run_name="Gather Feature Information", cache_policy=NONE)  # type: ignore[arg-type]
+async def gather_feature_information(service: InfrahubServices) -> dict:
     async with service.database.start_session() as db:
         data = {}
         features_to_count = [
@@ -67,7 +67,7 @@ async def gather_feature_information(service: InfrahubServices, branch: Branch)
         return data
 
 
-@task(name="telemetry-gather-data", task_run_name="Gather Anonynous Data", cache_policy=NONE)
+@task(name="telemetry-gather-data", task_run_name="Gather Anonynous Data", cache_policy=NONE)  # type: ignore[arg-type]
 async def gather_anonymous_telemetry_data(service: InfrahubServices) -> dict:
     start_time = time.time()
 
@@ -87,9 +87,9 @@ async def gather_anonymous_telemetry_data(service: InfrahubServices) -> dict:
         "branches": {
             "total": len(registry.branch),
         },
-        "features": await gather_feature_information(service=service, branch=default_branch),
-        "schema": await gather_schema_information(service=service, branch=default_branch),
-        "database": await gather_database_information(service=service, branch=default_branch),
+        "features": await gather_feature_information(service=service),
+        "schema": await gather_schema_information(branch=default_branch),
+        "database": await gather_database_information(service=service),
     }
 
     data["execution_time"] = time.time() - start_time
@@ -97,7 +97,7 @@ async def gather_anonymous_telemetry_data(service: InfrahubServices) -> dict:
     return data
 
 
-@task(name="telemetry-post-data", task_run_name="Upload data", retries=5, cache_policy=NONE)
+@task(name="telemetry-post-data", task_run_name="Upload data", retries=5, cache_policy=NONE)  # type: ignore[arg-type]
 async def post_telemetry_data(service: InfrahubServices, url: str, payload: dict[str, Any]) -> None:
     """Send the telemetry data to the specified URL, using HTTP POST."""
     response = await service.http.post(url=url, json=payload)
@@ -105,8 +105,7 @@ async def post_telemetry_data(service: InfrahubServices, url: str, payload: dict
 
 
 @flow(name="anonymous_telemetry_send", flow_run_name="Send anonymous telemetry")
-async def send_telemetry_push() -> None:
-    service = services.service
+async def send_telemetry_push(service: InfrahubServices) -> None:
     log = get_run_logger()
     if config.SETTINGS.main.telemetry_optout:
         log.info("Skipping, User opted out of this service.")

infrahub/transformations/tasks.py

@@ -4,7 +4,7 @@ from prefect import flow
 
 from infrahub.git.repository import get_initialized_repo
 from infrahub.log import get_logger
-from infrahub.services import services
+from infrahub.services import InfrahubServices
 from infrahub.workflows.utils import add_branch_tag
 
 from .models import TransformJinjaTemplateData, TransformPythonData
@@ -13,8 +13,7 @@ log = get_logger()
 
 
 @flow(name="transform_render_python", flow_run_name="Render transform python", persist_result=True)
-async def transform_python(message: TransformPythonData) -> Any:
-    service = services.service
+async def transform_python(message: TransformPythonData, service: InfrahubServices) -> Any:
     await add_branch_tag(branch_name=message.branch)
 
     repo = await get_initialized_repo(
@@ -37,8 +36,7 @@ async def transform_python(message: TransformPythonData) -> Any:
 
 
 @flow(name="transform_render_jinja2_template", flow_run_name="Render transform Jinja2", persist_result=True)
-async def transform_render_jinja2_template(message: TransformJinjaTemplateData) -> str:
-    service = services.service
+async def transform_render_jinja2_template(message: TransformJinjaTemplateData, service: InfrahubServices) -> str:
     await add_branch_tag(branch_name=message.branch)
 
     repo = await get_initialized_repo(

infrahub/trigger/catalogue.py

@@ -0,0 +1,15 @@
+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
+
+triggers = [
+    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_SETUP_UPDATE,
+]

infrahub/trigger/constants.py

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,69 @@
+from datetime import timedelta
+from enum import Enum
+from typing import Any
+from uuid import UUID
+
+from prefect.events.actions import RunDeployment
+from prefect.events.schemas.automations import EventTrigger as PrefectEventTrigger
+from prefect.events.schemas.automations import Posture
+from prefect.events.schemas.events import ResourceSpecification
+from pydantic import BaseModel, Field
+
+from .constants import NAME_SEPARATOR
+
+
+class TriggerType(str, Enum):
+    BUILTIN = "builtin"
+    # OBJECT = "object"
+    # COMPUTED_ATTR = "computed_attr"
+
+
+class EventTrigger(BaseModel):
+    events: set = Field(default_factory=set)
+    match: dict[str, Any] = Field(default_factory=dict)
+    match_related: dict[str, Any] = Field(default_factory=dict)
+
+    def get_prefect(self) -> PrefectEventTrigger:
+        return PrefectEventTrigger(
+            posture=Posture.Reactive,
+            expect=self.events,
+            within=timedelta(0),
+            match=ResourceSpecification(self.match),
+            match_related=ResourceSpecification(self.match_related),
+            threshold=1,
+        )
+
+
+class ExecuteWorkflow(BaseModel):
+    name: str
+    parameters: dict[str, Any] = Field(default_factory=dict)
+
+    def get_prefect(self, mapping: dict[str, UUID]) -> RunDeployment:
+        deployment_id = mapping[self.name]
+
+        return RunDeployment(
+            source="selected",
+            deployment_id=deployment_id,
+            parameters=self.parameters,
+            job_variables={},
+        )
+
+
+class TriggerDefinition(BaseModel):
+    name: str
+    type: TriggerType
+    previous_names: set = Field(default_factory=set)
+    description: str = ""
+    trigger: EventTrigger
+    actions: list[ExecuteWorkflow]
+
+    def get_deployment_names(self) -> list[str]:
+        """Return the name of all deployments used by this trigger"""
+        return [action.name for action in self.actions]
+
+    def generate_name(self) -> str:
+        return f"{self.type.value}{NAME_SEPARATOR}{self.name}"
+
+
+class BuiltinTriggerDefinition(TriggerDefinition):
+    type: TriggerType = TriggerType.BUILTIN