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

infrahub/dependencies/component/registry.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Optional, TypeVar
+from typing import TYPE_CHECKING, TypeVar
 
 from ..interface import DependencyBuilderContext
 from .exceptions import UntrackedDependencyError
@@ -17,7 +17,7 @@ T = TypeVar("T")
 
 
 class ComponentDependencyRegistry:
-    the_instance: Optional[ComponentDependencyRegistry] = None
+    the_instance: ComponentDependencyRegistry | None = None
 
     def __init__(self) -> None:
         self._available_components: dict[type, type[DependencyBuilder]] = {}

infrahub/events/__init__.py

@@ -1,4 +1,27 @@
+from .artifact_action import ArtifactCreatedEvent, ArtifactUpdatedEvent
+from .branch_action import BranchCreatedEvent, BranchDeletedEvent, BranchMergedEvent, BranchRebasedEvent
+from .group_action import GroupMemberAddedEvent, GroupMemberRemovedEvent
 from .models import EventMeta, InfrahubEvent
-from .node_action import NodeMutatedEvent
+from .node_action import NodeCreatedEvent, NodeDeletedEvent, NodeUpdatedEvent
+from .repository_action import CommitUpdatedEvent
+from .validator_action import ValidatorFailedEvent, ValidatorPassedEvent, ValidatorStartedEvent
 
-__all__ = ["EventMeta", "InfrahubEvent", "NodeMutatedEvent"]
+__all__ = [
+    "ArtifactCreatedEvent",
+    "ArtifactUpdatedEvent",
+    "BranchCreatedEvent",
+    "BranchDeletedEvent",
+    "BranchMergedEvent",
+    "BranchRebasedEvent",
+    "CommitUpdatedEvent",
+    "EventMeta",
+    "GroupMemberAddedEvent",
+    "GroupMemberRemovedEvent",
+    "InfrahubEvent",
+    "NodeCreatedEvent",
+    "NodeDeletedEvent",
+    "NodeUpdatedEvent",
+    "ValidatorFailedEvent",
+    "ValidatorPassedEvent",
+    "ValidatorStartedEvent",
+]

infrahub/events/artifact_action.py

@@ -0,0 +1,64 @@
+from typing import ClassVar
+
+from pydantic import Field
+
+from .constants import EVENT_NAMESPACE
+from .models import InfrahubEvent
+
+
+class ArtifactEvent(InfrahubEvent):
+    """Event generated when an artifact has been created or updated."""
+
+    node_id: str = Field(..., description="The ID of the artifact")
+    artifact_definition_id: str = Field(..., description="The ID of the artifact definition")
+    target_id: str = Field(..., description="The ID of the target of the artifact")
+    target_kind: str = Field(..., description="The kind of the target of the artifact")
+    checksum: str = Field(..., description="The current checksum of the artifact")
+    checksum_previous: str | None = Field(default=None, description="The previous checksum of the artifact")
+    storage_id: str = Field(..., description="The current storage id of the artifact")
+    storage_id_previous: str | None = Field(default=None, description="The previous storage id of the artifact")
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        related.append(
+            {
+                "prefect.resource.id": self.target_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": self.target_kind,
+            }
+        )
+        related.append(
+            {
+                "prefect.resource.id": self.target_id,
+                "prefect.resource.role": "infrahub.artifact",
+                "infrahub.artifact.checksum": self.checksum,
+                "infrahub.artifact.checksum_previous": self.checksum_previous or "",
+                "infrahub.artifact.storage_id": self.storage_id,
+                "infrahub.artifact.storage_id_previous": self.storage_id_previous or "",
+                "infrahub.artifact.artifact_definition_id": self.artifact_definition_id,
+            }
+        )
+
+        return related
+
+    def get_resource(self) -> dict[str, str]:
+        return {
+            "prefect.resource.id": self.node_id,
+            "infrahub.node.kind": "CoreArtifact",
+            "infrahub.node.id": self.node_id,
+            "infrahub.branch.name": self.meta.context.branch.name,
+        }
+
+
+class ArtifactCreatedEvent(ArtifactEvent):
+    """Event generated when an artifact has been created"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.artifact.created"
+    infrahub_node_kind_event: ClassVar[bool] = True
+
+
+class ArtifactUpdatedEvent(ArtifactEvent):
+    """Event generated when an artifact has been updated"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.artifact.updated"
+    infrahub_node_kind_event: ClassVar[bool] = True

infrahub/events/branch_action.py

@@ -1,5 +1,8 @@
-from pydantic import Field, computed_field
+from typing import ClassVar
 
+from pydantic import Field
+
+from infrahub.core.constants import InfrahubKind
 from infrahub.message_bus import InfrahubMessage
 from infrahub.message_bus.messages.refresh_registry_branches import RefreshRegistryBranches
 from infrahub.message_bus.messages.refresh_registry_rebasedbranch import RefreshRegistryRebasedBranch
@@ -11,6 +14,8 @@ from .models import InfrahubEvent
 class BranchDeletedEvent(InfrahubEvent):
     """Event generated when a branch has been deleted"""
 
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.branch.deleted"
+
     branch_name: str = Field(..., description="The name of the branch")
     branch_id: str = Field(..., description="The ID of the mutated node")
     sync_with_git: bool = Field(..., description="Indicates if the branch was extended to Git")
@@ -34,14 +39,12 @@ class BranchDeletedEvent(InfrahubEvent):
         ]
         return events
 
-    @computed_field
-    def event_name(self) -> str:
-        return f"{EVENT_NAMESPACE}.branch.deleted"
-
 
 class BranchCreatedEvent(InfrahubEvent):
     """Event generated when a branch has been created"""
 
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.branch.created"
+
     branch_name: str = Field(..., description="The name of the branch")
     branch_id: str = Field(..., description="The ID of the branch")
     sync_with_git: bool = Field(..., description="Indicates if the branch was extended to Git")
@@ -65,33 +68,44 @@ class BranchCreatedEvent(InfrahubEvent):
         ]
         return events
 
-    @computed_field
-    def event_name(self) -> str:
-        return f"{EVENT_NAMESPACE}.branch.created"
-
 
 class BranchMergedEvent(InfrahubEvent):
     """Event generated when a branch has been merged"""
 
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.branch.merged"
+
+    branch_name: str = Field(..., description="The name of the branch")
+    branch_id: str = Field(..., description="The ID of the branch")
+    proposed_change_id: str | None = Field(
+        default=None, description="The ID of the proposed change that merged this branch if applicable"
+    )
+
     def get_resource(self) -> dict[str, str]:
         return {
-            "prefect.resource.id": f"infrahub.branch.{self.meta.get_branch_id()}",
-            "infrahub.node.kind": "Branch",
-            "infrahub.node.id": self.meta.get_branch_id(),
-            "infrahub.node.label": self.meta.context.branch.name,
+            "prefect.resource.id": f"infrahub.branch.{self.branch_name}",
+            "infrahub.branch.id": self.branch_id,
+            "infrahub.branch.name": self.branch_name,
         }
 
-    def get_messages(self) -> list[InfrahubMessage]:
-        return []
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        if self.proposed_change_id:
+            related.append(
+                {
+                    "prefect.resource.id": self.proposed_change_id,
+                    "prefect.resource.role": "infrahub.related.node",
+                    "infrahub.node.kind": InfrahubKind.PROPOSEDCHANGE,
+                }
+            )
 
-    @computed_field
-    def event_name(self) -> str:
-        return f"{EVENT_NAMESPACE}.branch.merged"
+        return related
 
 
 class BranchRebasedEvent(InfrahubEvent):
     """Event generated when a branch has been rebased"""
 
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.branch.rebased"
+
     branch_id: str = Field(..., description="The ID of the mutated node")
     branch_name: str = Field(..., description="The name of the branch")
 
@@ -99,6 +113,7 @@ class BranchRebasedEvent(InfrahubEvent):
         return {
             "prefect.resource.id": f"infrahub.branch.{self.branch_name}",
             "infrahub.branch.id": self.branch_id,
+            "infrahub.branch.name": self.branch_name,
         }
 
     def get_messages(self) -> list[InfrahubMessage]:
@@ -110,7 +125,3 @@ class BranchRebasedEvent(InfrahubEvent):
             RefreshRegistryRebasedBranch(branch=self.branch_name),
         ]
         return events
-
-    @computed_field
-    def event_name(self) -> str:
-        return f"{EVENT_NAMESPACE}.branch.rebased"

infrahub/events/generator.py

@@ -0,0 +1,71 @@
+from infrahub.context import InfrahubContext
+from infrahub.core.branch import Branch
+from infrahub.core.changelog.models import RelationshipChangelogGetter
+from infrahub.core.constants import MutationAction
+from infrahub.core.node import Node
+from infrahub.database import InfrahubDatabase
+from infrahub.events.node_action import NodeDeletedEvent, NodeMutatedEvent, NodeUpdatedEvent, get_node_event
+from infrahub.groups.parsers import GroupNodeMutationParser
+from infrahub.worker import WORKER_IDENTITY
+
+from .models import EventMeta, InfrahubEvent
+
+
+async def generate_node_mutation_events(
+    node: Node,
+    deleted_nodes: list[Node],
+    db: InfrahubDatabase,
+    branch: Branch,
+    context: InfrahubContext,
+    request_id: str,
+    action: MutationAction,
+) -> list[InfrahubEvent]:
+    meta = EventMeta(
+        account_id=context.account.account_id,
+        initiator_id=WORKER_IDENTITY,
+        request_id=request_id,
+        branch=branch,
+        context=context,
+    )
+    node_event_class = get_node_event(action)
+    main_event = node_event_class(
+        kind=node.get_kind(),
+        node_id=node.id,
+        changelog=node.node_changelog,
+        fields=node.node_changelog.updated_fields,
+        meta=meta,
+    )
+    relationship_changelogs = RelationshipChangelogGetter(db=db, branch=branch)
+    node_changelogs = await relationship_changelogs.get_changelogs(primary_changelog=node.node_changelog)
+
+    events: list[NodeMutatedEvent] = [main_event]
+
+    deleted_changelogs = [deleted_node.node_changelog for deleted_node in deleted_nodes if deleted_node.id != node.id]
+    deleted_ids = {deleted_node.node_id for deleted_node in deleted_changelogs}
+
+    for node_changelog in deleted_changelogs:
+        meta = EventMeta.from_parent(parent=main_event)
+        delete_event = NodeDeletedEvent(
+            kind=node_changelog.node_kind,
+            node_id=node_changelog.node_id,
+            changelog=node_changelog,
+            fields=node_changelog.updated_fields,
+            meta=meta,
+        )
+        events.append(delete_event)
+
+    for node_changelog in node_changelogs:
+        if node_changelog.node_id not in deleted_ids:
+            meta = EventMeta.from_parent(parent=main_event)
+            update_event = NodeUpdatedEvent(
+                kind=node_changelog.node_kind,
+                node_id=node_changelog.node_id,
+                changelog=node_changelog,
+                fields=node_changelog.updated_fields,
+                meta=meta,
+            )
+            events.append(update_event)
+
+    group_parser = GroupNodeMutationParser(db=db, branch=branch)
+    group_events = await group_parser.group_events_from_node_actions(events=events)
+    return events + group_events

infrahub/events/group_action.py

@@ -1,9 +1,8 @@
-from typing import Any
+from typing import ClassVar
 
-from pydantic import Field, computed_field
+from pydantic import Field
 
 from infrahub.core.constants import MutationAction
-from infrahub.message_bus import InfrahubMessage
 
 from .constants import EVENT_NAMESPACE
 from .models import EventNode, InfrahubEvent
@@ -16,6 +15,9 @@ class GroupMutatedEvent(InfrahubEvent):
     node_id: str = Field(..., description="The ID of the updated group")
     action: MutationAction = Field(..., description="The action taken on the node")
     members: list[EventNode] = Field(default_factory=list, description="Updated members during this event.")
+    ancestors: list[EventNode] = Field(
+        default_factory=list, description="A list of groups that are ancestors of this group."
+    )
 
     def get_related(self) -> list[dict[str, str]]:
         related = super().get_related()
@@ -26,7 +28,22 @@ class GroupMutatedEvent(InfrahubEvent):
                 "infrahub.node.kind": self.kind,
             }
         )
+        related.append(
+            {
+                "prefect.resource.id": self.node_id,
+                "prefect.resource.role": "infrahub.group.update",
+                "infrahub.node.kind": self.kind,
+            }
+        )
+
         for member in self.members:
+            related.append(
+                {
+                    "prefect.resource.id": member.id,
+                    "prefect.resource.role": "infrahub.group.member",
+                    "infrahub.node.kind": member.kind,
+                }
+            )
             related.append(
                 {
                     "prefect.resource.id": member.id,
@@ -35,11 +52,30 @@ class GroupMutatedEvent(InfrahubEvent):
                 }
             )
 
-        return related
+        for ancestor in self.ancestors:
+            related.append(
+                {
+                    "prefect.resource.id": ancestor.id,
+                    "prefect.resource.role": "infrahub.group.ancestor",
+                    "infrahub.node.kind": ancestor.kind,
+                }
+            )
+            related.append(
+                {
+                    "prefect.resource.id": ancestor.id,
+                    "prefect.resource.role": "infrahub.related.node",
+                    "infrahub.node.kind": ancestor.kind,
+                }
+            )
+            related.append(
+                {
+                    "prefect.resource.id": ancestor.id,
+                    "prefect.resource.role": "infrahub.group.update",
+                    "infrahub.node.kind": ancestor.kind,
+                }
+            )
 
-    @computed_field
-    def event_name(self) -> str:
-        return f"{EVENT_NAMESPACE}.group.{self.action.value}"
+        return related
 
     def get_resource(self) -> dict[str, str]:
         return {
@@ -50,24 +86,18 @@ class GroupMutatedEvent(InfrahubEvent):
             "infrahub.node.root_id": self.node_id,
         }
 
-    def get_payload(self) -> dict[str, Any]:
-        return {"members": [member.model_dump() for member in self.members]}
-
-    def get_messages(self) -> list[InfrahubMessage]:
-        return []
-
 
 class GroupMemberAddedEvent(GroupMutatedEvent):
-    action: MutationAction = MutationAction.CREATED
+    """Event generated when a one or more members have been added to a group"""
 
-    @computed_field
-    def event_name(self) -> str:
-        return f"{EVENT_NAMESPACE}.group.member_added"
+    action: MutationAction = MutationAction.CREATED
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.group.member_added"
+    infrahub_node_kind_event: ClassVar[bool] = True
 
 
 class GroupMemberRemovedEvent(GroupMutatedEvent):
-    action: MutationAction = MutationAction.DELETED
+    """Event generated when a one or more members have been removed to a group"""
 
-    @computed_field
-    def event_name(self) -> str:
-        return f"{EVENT_NAMESPACE}.group.member_removed"
+    action: MutationAction = MutationAction.DELETED
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.group.member_removed"
+    infrahub_node_kind_event: ClassVar[bool] = True

infrahub/events/models.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 from copy import deepcopy
-from typing import Any, Self, cast, final
+from typing import Any, ClassVar, Self, final
 from uuid import UUID, uuid4
 
-from pydantic import BaseModel, Field, PrivateAttr, computed_field, model_validator
+from pydantic import BaseModel, Field, PrivateAttr, model_validator
 
 from infrahub import __version__
 from infrahub.auth import AccountSession, AuthType
@@ -27,7 +27,7 @@ class ParentEvent(BaseModel):
 
 
 class EventMeta(BaseModel):
-    branch: Branch | None = Field(default=None)
+    branch: Branch | None = Field(default=None, description="The branch on which originate this event")
     request_id: str = ""
     account_id: str | None = Field(default=None, description="The ID of the account triggering this event")
     initiator_id: str = Field(
@@ -112,12 +112,17 @@ class EventMeta(BaseModel):
         )
 
     @classmethod
-    def from_parent(cls, parent: InfrahubEvent) -> EventMeta:
+    def from_parent(cls, parent: InfrahubEvent, branch: Branch | None = None) -> 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
+        context = deepcopy(parent.meta.context)
+        if branch:
+            context.branch.name = branch.name
+            context.branch.id = str(branch.get_uuid())
+
         return cls(
             parent=parent.meta.id,
             branch=parent.meta.branch,
@@ -125,8 +130,8 @@ class EventMeta(BaseModel):
             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,
+            context=context,
+            ancestors=[ParentEvent(id=parent.get_id(), name=parent.event_name)] + parent.meta.ancestors,
         )
 
     @classmethod
@@ -143,21 +148,20 @@ class EventMeta(BaseModel):
 class InfrahubEvent(BaseModel):
     meta: EventMeta = Field(..., description="Metadata for the event")
 
+    event_name: ClassVar[str] = Field(..., description="The name of the event")
+    infrahub_node_kind_event: ClassVar[bool] = False
+
     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
+        return []
 
     def get_related(self) -> list[dict[str, str]]:
         if not self.meta:
@@ -171,13 +175,12 @@ class InfrahubEvent(BaseModel):
         be used for that as it will always contain the 'context' key regardless of changes
         in child classes
         """
-        return {}
+        return self.model_dump(exclude={"meta"})
 
     @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")
+        event_payload = {"data": self.get_payload(), "context": self.meta.context.to_event()}
         return event_payload
 
     def get_message_meta(self) -> Meta:
@@ -189,13 +192,9 @@ class InfrahubEvent(BaseModel):
 
         return meta
 
-    @computed_field
-    def event_name(self) -> str:
-        raise NotImplementedError("The event name has not been defined")
-
     @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())
+            self.meta.context.set_event(self.event_name, id=self.get_id())
         return self