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

infrahub/events/models.py

@@ -1,93 +1,201 @@
-from typing import Any
+from __future__ import annotations
 
-from pydantic import BaseModel, Field
+from copy import deepcopy
+from typing import Any, Self, cast, final
+from uuid import UUID, uuid4
 
+from pydantic import BaseModel, Field, PrivateAttr, computed_field, model_validator
+
+from infrahub import __version__
+from infrahub.auth import AccountSession, AuthType
+from infrahub.context import InfrahubContext  # noqa: TC001
+from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.message_bus import InfrahubMessage, Meta
+from infrahub.worker import WORKER_IDENTITY
 
 from .constants import EVENT_NAMESPACE
 
 
+class EventNode(BaseModel):
+    id: str
+    kind: str
+
+
+class ParentEvent(BaseModel):
+    id: str
+    name: str
+
+
 class EventMeta(BaseModel):
+    branch: Branch | None = Field(default=None)
     request_id: str = ""
-    account_id: str = ""
-    initiator_id: str | None = Field(
-        default=None, description="The worker identity of the initial sender of this message"
+    account_id: str | None = Field(default=None, description="The ID of the account triggering this event")
+    initiator_id: str = Field(
+        default=WORKER_IDENTITY, description="The worker identity of the initial sender of this message"
+    )
+    context: InfrahubContext = Field(..., description="The context used when originating this event")
+    level: int = Field(default=0)
+    has_children: bool = Field(
+        default=False, description="Indicates if this event might potentially have child events under it."
     )
 
+    id: UUID = Field(
+        default_factory=uuid4,
+        description="UUID of the event",
+    )
 
-class InfrahubEvent(BaseModel):
-    meta: EventMeta | None = None
+    parent: UUID | None = Field(default=None, description="The UUID of the parent event if applicable")
+    ancestors: list[ParentEvent] = Field(default_factory=list, description="Any event used to trigger this event")
+    _created_with_context: bool = PrivateAttr(default=False)
 
-    def get_event_namespace(self) -> str:
-        return EVENT_NAMESPACE
+    def get_branch_id(self) -> str:
+        if self.context.branch.id:
+            return self.context.branch.id
 
-    def get_name(self) -> str:
-        return f"{self.get_event_namespace()}.unknown"
+        if self.branch:
+            return str(self.branch.get_uuid())
 
-    def get_resource(self) -> dict[str, str]:
-        raise NotImplementedError
+        return ""
 
-    def get_messages(self) -> list[InfrahubMessage]:
-        raise NotImplementedError
+    def get_id(self) -> str:
+        return str(self.id)
 
     def get_related(self) -> list[dict[str, str]]:
-        related: list[dict[str, str]] = []
-
-        if not self.meta:
-            return related
-
-        if self.meta.account_id:
-            related.append(
-                {
-                    "prefect.resource.id": f"infrahub.account.{self.meta.account_id}",
-                    "prefect.resource.role": "account",
-                }
-            )
-
-        if self.meta.request_id:
+        related: list[dict[str, str]] = [
+            {"prefect.resource.id": __version__, "prefect.resource.role": "infrahub.version"},
+            {
+                "prefect.resource.id": self.get_id(),
+                "prefect.resource.role": "infrahub.event",
+                "infrahub.event.has_children": str(self.has_children).lower(),
+                "infrahub.event.level": str(self.level),
+            },
+            {
+                "prefect.resource.id": f"infrahub.account.{self.context.account.account_id}",
+                "prefect.resource.role": "infrahub.account",
+                "infrahub.resource.id": self.context.account.account_id,
+            },
+            {
+                "prefect.resource.id": f"infrahub.branch.{self.get_branch_id()}",
+                "prefect.resource.role": "infrahub.branch",
+                "infrahub.resource.id": self.get_branch_id(),
+                "infrahub.resource.label": self.context.branch.name,
+            },
+        ]
+
+        if self.parent:
             related.append(
                 {
-                    "prefect.resource.id": f"infrahub.request.{self.meta.request_id}",
-                    "prefect.resource.role": "request",
+                    "prefect.resource.id": self.get_id(),
+                    "prefect.resource.role": "infrahub.child_event",
+                    "infrahub.event_parent.id": str(self.parent),
                 }
             )
 
-        if self.meta.initiator_id:
+        for ancestor in self.ancestors:
             related.append(
                 {
-                    "prefect.resource.id": f"infrahub.source.{self.meta.initiator_id}",
-                    "prefect.resource.role": "event_source",
+                    "prefect.resource.id": ancestor.id,
+                    "prefect.resource.role": "infrahub.ancestor_event",
+                    "infrahub.ancestor_event.name": ancestor.name,
                 }
             )
 
         return related
 
+    @classmethod
+    def with_dummy_context(cls, branch: Branch) -> EventMeta:
+        return cls(
+            branch=branch,
+            context=InfrahubContext.init(
+                branch=branch, account=AccountSession(auth_type=AuthType.NONE, authenticated=False, account_id="")
+            ),
+        )
+
+    @classmethod
+    def from_parent(cls, parent: InfrahubEvent) -> EventMeta:
+        """Create the metadata from an existing event
+
+        Note that this action will modify the existing event to indicate that children might be attached to the event
+        """
+        parent.meta.has_children = True
+        return cls(
+            parent=parent.meta.id,
+            branch=parent.meta.branch,
+            request_id=parent.meta.request_id,
+            initiator_id=parent.meta.initiator_id,
+            account_id=parent.meta.account_id,
+            level=parent.meta.level + 1,
+            context=deepcopy(parent.meta.context),
+            ancestors=[ParentEvent(id=parent.get_id(), name=parent.get_name())] + parent.meta.ancestors,
+        )
+
+    @classmethod
+    def from_context(cls, context: InfrahubContext, branch: Branch | None = None) -> EventMeta:
+        # Create a copy of the context so local changes aren't brought back to a parent object
+        meta = cls(context=deepcopy(context))
+        meta._created_with_context = True
+        if branch:
+            meta.context.branch.name = branch.name
+            meta.context.branch.id = str(branch.get_uuid())
+        return meta
+
+
+class InfrahubEvent(BaseModel):
+    meta: EventMeta = Field(..., description="Metadata for the event")
+
+    def get_id(self) -> str:
+        return self.meta.get_id()
+
+    def get_event_namespace(self) -> str:
+        return EVENT_NAMESPACE
+
+    def get_name(self) -> str:
+        # Convince linters that @computed_field is a property and not a method...
+        return cast(str, self.event_name)
+
+    def get_resource(self) -> dict[str, str]:
+        raise NotImplementedError
+
+    def get_messages(self) -> list[InfrahubMessage]:
+        raise NotImplementedError
+
+    def get_related(self) -> list[dict[str, str]]:
+        if not self.meta:
+            return []
+        return self.meta.get_related()
+
     def get_payload(self) -> dict[str, Any]:
+        """The purpose if this method is to allow subclasses to define their own payload.
+
+        It should not be used to get the complete payload instead .get_event_payload() should
+        be used for that as it will always contain the 'context' key regardless of changes
+        in child classes
+        """
         return {}
 
+    @final
+    def get_event_payload(self) -> dict[str, Any]:
+        """This method should be used when emitting the event to the event broker"""
+        event_payload = self.get_payload()
+        event_payload["context"] = self.meta.context.model_dump(mode="json")
+        return event_payload
+
     def get_message_meta(self) -> Meta:
         meta = Meta()
-        if not self.meta:
-            return meta
 
-        if self.meta.initiator_id:
-            meta.initiator_id = self.meta.initiator_id
+        meta.initiator_id = self.meta.initiator_id
         if self.meta.request_id:
             meta.initiator_id = self.meta.request_id
 
         return meta
 
+    @computed_field
+    def event_name(self) -> str:
+        raise NotImplementedError("The event name has not been defined")
 
-class InfrahubBranchEvent(InfrahubEvent):  # pylint: disable=abstract-method
-    branch: str = Field(..., description="The branch on which the event happend")
-
-    def get_related(self) -> list[dict[str, str]]:
-        related = super().get_related()
-        related.append(
-            {
-                "prefect.resource.id": "infrahub.branch",
-                "prefect.resource.name": self.branch,
-                "prefect.resource.role": "branch",
-            }
-        )
-        return related
+    @model_validator(mode="after")
+    def update_context(self) -> Self:
+        """Update the context object using this event provided that the meta data was created with a context."""
+        if self.meta._created_with_context:
+            self.meta.context.set_event(self.get_name(), id=self.get_id())
+        return self

infrahub/events/node_action.py

@@ -1,24 +1,74 @@
 from typing import Any
 
-from pydantic import Field
+from pydantic import Field, computed_field
 
+from infrahub.core.branch import Branch
+from infrahub.core.changelog.models import NodeChangelog
 from infrahub.core.constants import MutationAction
 from infrahub.message_bus import InfrahubMessage
 
-from .models import InfrahubBranchEvent
+from .constants import EVENT_NAMESPACE
+from .models import InfrahubEvent
 
 
-class NodeMutatedEvent(InfrahubBranchEvent):
+class NodeMutatedEvent(InfrahubEvent):
     """Event generated when a node has been mutated"""
 
     kind: str = Field(..., description="The type of object modified")
     node_id: str = Field(..., description="The ID of the mutated node")
     action: MutationAction = Field(..., description="The action taken on the node")
-    data: dict[str, Any] = Field(..., description="Data on modified object")
+    data: NodeChangelog = Field(..., description="Data on modified object")
     fields: list[str] = Field(default_factory=list, description="Fields provided in the mutation")
 
-    def get_name(self) -> str:
-        return f"{self.get_event_namespace()}.node.{self.action.value}"
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        for attribute in self.data.attributes.values():
+            related.append(
+                {
+                    "prefect.resource.id": f"infrahub.node.{self.node_id}",
+                    "prefect.resource.role": "infrahub.node.field_update",
+                    "infrahub.attribute.name": attribute.name,
+                    "infrahub.attribute.value": "NULL" if attribute.value is None else str(attribute.value),
+                    "infrahub.attribute.kind": attribute.kind,
+                    "infrahub.attribute.value_previous": "NULL"
+                    if attribute.value_previous is None
+                    else str(attribute.value_previous),
+                    # Mypy doesn't understand that .value_update_status is a @computed_attribute
+                    "infrahub.attribute.action": attribute.value_update_status.value,  # type: ignore[attr-defined]
+                }
+            )
+        if self.data.parent:
+            related.append(
+                {
+                    "prefect.resource.id": self.data.parent.node_id,
+                    "prefect.resource.role": "infrahub.node.parent",
+                    "infrahub.parent.kind": self.data.parent.node_kind,
+                    "infrahub.parent.id": self.data.parent.node_id,
+                }
+            )
+
+        related.append(
+            {
+                "prefect.resource.id": self.node_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": self.kind,
+            }
+        )
+
+        for related_node in self.data.get_related_nodes():
+            related.append(
+                {
+                    "prefect.resource.id": related_node.node_id,
+                    "prefect.resource.role": "infrahub.related.node",
+                    "infrahub.node.kind": related_node.node_kind,
+                }
+            )
+
+        return related
+
+    @computed_field
+    def event_name(self) -> str:
+        return f"{EVENT_NAMESPACE}.node.{self.action.value}"
 
     def get_resource(self) -> dict[str, str]:
         return {
@@ -26,11 +76,11 @@ class NodeMutatedEvent(InfrahubBranchEvent):
             "infrahub.node.kind": self.kind,
             "infrahub.node.id": self.node_id,
             "infrahub.node.action": self.action.value,
-            "infrahub.branch.name": self.branch,
+            "infrahub.node.root_id": self.data.root_node_id,
         }
 
     def get_payload(self) -> dict[str, Any]:
-        return {"data": self.data, "fields": self.fields}
+        return {"data": self.data.model_dump(), "fields": self.fields}
 
     def get_messages(self) -> list[InfrahubMessage]:
         return [
@@ -43,3 +93,19 @@ class NodeMutatedEvent(InfrahubBranchEvent):
             #     meta=self.get_message_meta(),
             # )
         ]
+
+    def set_context_branch(self, branch: Branch) -> None:
+        self.meta.context.branch.id = str(branch.get_uuid())
+        self.meta.context.branch.name = branch.name
+
+
+class NodeCreatedEvent(NodeMutatedEvent):
+    action: MutationAction = MutationAction.CREATED
+
+
+class NodeUpdatedEvent(NodeMutatedEvent):
+    action: MutationAction = MutationAction.UPDATED
+
+
+class NodeDeletedEvent(NodeMutatedEvent):
+    action: MutationAction = MutationAction.DELETED

infrahub/events/repository_action.py

@@ -1,33 +1,29 @@
 from typing import Any
 
-from pydantic import Field
+from pydantic import Field, computed_field
 
 from infrahub.message_bus import InfrahubMessage
 
-from .models import InfrahubBranchEvent
+from .constants import EVENT_NAMESPACE
+from .models import InfrahubEvent
 
 
-class CommitUpdatedEvent(InfrahubBranchEvent):
+class CommitUpdatedEvent(InfrahubEvent):
     """Event generated when the the commit within a repository has been updated."""
 
     commit: str = Field(..., description="The commit the repository was updated to")
     repository_id: str = Field(..., description="The ID of the repository")
     repository_name: str = Field(..., description="The name of the repository")
 
-    def get_name(self) -> str:
-        return f"{self.get_event_namespace()}.repository.update_commit"
-
     def get_resource(self) -> dict[str, str]:
         return {
             "prefect.resource.id": f"infrahub.repository.{self.repository_id}",
-            "infrahub.branch.name": self.branch,
             "infrahub.repository.name": self.repository_name,
             "infrahub.repository.id": self.repository_id,
         }
 
     def get_payload(self) -> dict[str, Any]:
         return {
-            "branch": self.branch,
             "commit": self.commit,
             "repository_id": self.repository_id,
             "repository_name": self.repository_name,
@@ -35,3 +31,7 @@ class CommitUpdatedEvent(InfrahubBranchEvent):
 
     def get_messages(self) -> list[InfrahubMessage]:
         return []
+
+    @computed_field
+    def event_name(self) -> str:
+        return f"{EVENT_NAMESPACE}.repository.update_commit"

infrahub/events/schema_action.py

@@ -1,30 +1,39 @@
 from typing import Any
 
-from pydantic import Field
+from pydantic import Field, computed_field
 
 from infrahub.message_bus import InfrahubMessage
 from infrahub.message_bus.messages.refresh_registry_branches import RefreshRegistryBranches
 
-from .models import InfrahubBranchEvent
+from .constants import EVENT_NAMESPACE
+from .models import InfrahubEvent
 
 
-class SchemaUpdatedEvent(InfrahubBranchEvent):
+class SchemaUpdatedEvent(InfrahubEvent):
     """Event generated when the schema within a branch has been updated."""
 
+    branch_name: str = Field(..., description="The name of the branch")
     schema_hash: str = Field(..., description="Schema hash after the update")
 
-    def get_name(self) -> str:
-        return f"{self.get_event_namespace()}.schema.update"
+    # NOTE
+    # We could add to the payload
+    # - Hash before and after the change
+    # - List of nodes and generics that have been modified
+    # - Diff of the change
+
+    # NOTE 2
+    # Should schema_update be a branch event ?
+    # if feels like the main resource should be the branch
 
     def get_resource(self) -> dict[str, str]:
         return {
-            "prefect.resource.id": f"infrahub.schema_branch.{self.branch}",
-            "infrahub.branch.name": self.branch,
+            "prefect.resource.id": f"infrahub.schema_branch.{self.branch_name}",
+            "infrahub.branch.name": self.branch_name,
             "infrahub.branch.schema_hash": self.schema_hash,
         }
 
     def get_payload(self) -> dict[str, Any]:
-        return {"branch": self.branch, "schema_hash": self.schema_hash}
+        return {"branch": self.branch_name, "schema_hash": self.schema_hash}
 
     def get_messages(self) -> list[InfrahubMessage]:
         return [
@@ -34,3 +43,7 @@ class SchemaUpdatedEvent(InfrahubBranchEvent):
             #     meta=self.get_message_meta(),
             # )
         ]
+
+    @computed_field
+    def event_name(self) -> str:
+        return f"{EVENT_NAMESPACE}.schema.update"

infrahub/generators/tasks.py

@@ -8,6 +8,7 @@ from prefect import flow, task
 from prefect.cache_policies import NONE
 
 from infrahub import lock
+from infrahub.context import InfrahubContext  # noqa: TC001 needed for prefect flow
 from infrahub.core.constants import GeneratorInstanceStatus, InfrahubKind
 from infrahub.generators.models import (
     ProposedChangeGeneratorDefinition,
@@ -16,7 +17,7 @@ from infrahub.generators.models import (
 )
 from infrahub.git.base import extract_repo_file_information
 from infrahub.git.repository import get_initialized_repo
-from infrahub.services import InfrahubServices, services
+from infrahub.services import InfrahubServices  # noqa: TC001 needed for prefect flow
 from infrahub.workflows.catalogue import REQUEST_GENERATOR_DEFINITION_RUN, REQUEST_GENERATOR_RUN
 from infrahub.workflows.utils import add_tags
 
@@ -25,9 +26,7 @@ from infrahub.workflows.utils import add_tags
     name="generator-run",
     flow_run_name="Run generator {model.generator_definition.definition_name}",
 )
-async def run_generator(model: RequestGeneratorRun) -> None:
-    service = services.service
-
+async def run_generator(model: RequestGeneratorRun, service: InfrahubServices) -> None:
     await add_tags(branches=[model.branch_name], nodes=[model.target_id])
 
     repository = await get_initialized_repo(
@@ -80,7 +79,7 @@ async def run_generator(model: RequestGeneratorRun) -> None:
     await generator_instance.update(do_full_update=True)
 
 
-@task(name="generator-define-instance", task_run_name="Define Instance", cache_policy=NONE)
+@task(name="generator-define-instance", task_run_name="Define Instance", cache_policy=NONE)  # type: ignore[arg-type]
 async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices) -> CoreGeneratorInstance:
     if model.generator_instance:
         instance = await service.client.get(
@@ -119,9 +118,7 @@ async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices
 
 
 @flow(name="generator-definition-run", flow_run_name="Run all generators")
-async def run_generator_definition(branch: str) -> None:
-    service = services.service
-
+async def run_generator_definition(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:
     await add_tags(branches=[branch])
 
     generators = await service.client.filters(
@@ -146,16 +143,18 @@ async def run_generator_definition(branch: str) -> None:
 
     for generator_definition in generator_definitions:
         model = RequestGeneratorDefinitionRun(branch=branch, generator_definition=generator_definition)
-        await service.workflow.submit_workflow(workflow=REQUEST_GENERATOR_DEFINITION_RUN, parameters={"model": model})
+        await service.workflow.submit_workflow(
+            workflow=REQUEST_GENERATOR_DEFINITION_RUN, context=context, parameters={"model": model}
+        )
 
 
 @flow(
     name="request-generator-definition-run",
     flow_run_name="Execute generator {model.generator_definition.definition_name}",
 )
-async def request_generator_definition_run(model: RequestGeneratorDefinitionRun) -> None:
-    service = services.service
-
+async def request_generator_definition_run(
+    model: RequestGeneratorDefinitionRun, context: InfrahubContext, service: InfrahubServices
+) -> None:
     await add_tags(branches=[model.branch], nodes=[model.generator_definition.definition_id])
 
     group = await service.client.get(
@@ -208,5 +207,5 @@ async def request_generator_definition_run(model: RequestGeneratorDefinitionRun)
             target_name=member.display_label,
         )
         await service.workflow.submit_workflow(
-            workflow=REQUEST_GENERATOR_RUN, parameters={"model": request_generator_run_model}
+            workflow=REQUEST_GENERATOR_RUN, context=context, parameters={"model": request_generator_run_model}
         )

infrahub/git/base.py

@@ -122,7 +122,7 @@ class BranchInLocal(BaseModel):
     has_worktree: bool = False
 
 
-class InfrahubRepositoryBase(BaseModel, ABC):  # pylint: disable=too-many-public-methods
+class InfrahubRepositoryBase(BaseModel, ABC):
     """
     Local version of a Git repository organized to work with Infrahub.
     The idea is that all commits that are being tracked in the graph will be checkout out
@@ -395,9 +395,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):  # pylint: disable=too-many-public
         return [Worktree.init(response) for response in responses]
 
     def get_client(self) -> InfrahubClient:
-        if self.client:
-            return self.client
-        return self.service.client
+        return self.sdk
 
     def get_location(self) -> str:
         if self.location:
@@ -702,7 +700,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):  # pylint: disable=too-many-public
                 log.info("New commit detected", repository=self.name, branch=branch_name)
                 updated_branches.append(branch_name)
 
-        return sorted(list(new_branches)), sorted(updated_branches)
+        return sorted(new_branches), sorted(updated_branches)
 
     def validate_remote_branch(self, branch_name: str) -> bool:
         """Process a remote branch to validate that we can use it safely.

infrahub/git/constants.py

@@ -1,4 +1,3 @@
-AUTOMATION_NAME = "Trigger-repository-commit-update-event"
 COMMITS_DIRECTORY_NAME = "commits"
 BRANCHES_DIRECTORY_NAME = "branches"
 TEMPORARY_DIRECTORY_NAME = "temp"