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

infrahub/events/group_action.py

@@ -0,0 +1,117 @@
+from typing import Any
+
+from pydantic import Field, computed_field
+
+from infrahub.core.constants import MutationAction
+from infrahub.message_bus import InfrahubMessage
+
+from .constants import EVENT_NAMESPACE
+from .models import EventNode, InfrahubEvent
+
+
+class GroupMutatedEvent(InfrahubEvent):
+    """Event generated when a node has been mutated"""
+
+    kind: str = Field(..., description="The type of updated group")
+    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()
+        related.append(
+            {
+                "prefect.resource.id": self.node_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "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,
+                    "prefect.resource.role": "infrahub.related.node",
+                    "infrahub.node.kind": member.kind,
+                }
+            )
+
+        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,
+                }
+            )
+
+        return related
+
+    @computed_field
+    def event_name(self) -> str:
+        return f"{EVENT_NAMESPACE}.group.{self.action.value}"
+
+    def get_resource(self) -> dict[str, str]:
+        return {
+            "prefect.resource.id": f"infrahub.node.{self.node_id}",
+            "infrahub.node.kind": self.kind,
+            "infrahub.node.id": self.node_id,
+            "infrahub.node.action": self.action.value,
+            "infrahub.node.root_id": self.node_id,
+        }
+
+    def get_payload(self) -> dict[str, Any]:
+        return {
+            "ancestors": [ancestor.model_dump() for ancestor in self.ancestors],
+            "members": [member.model_dump() for member in self.members],
+        }
+
+    def get_messages(self) -> list[InfrahubMessage]:
+        return []
+
+
+class GroupMemberAddedEvent(GroupMutatedEvent):
+    action: MutationAction = MutationAction.CREATED
+
+    @computed_field
+    def event_name(self) -> str:
+        return f"{EVENT_NAMESPACE}.group.member_added"
+
+
+class GroupMemberRemovedEvent(GroupMutatedEvent):
+    action: MutationAction = MutationAction.DELETED
+
+    @computed_field
+    def event_name(self) -> str:
+        return f"{EVENT_NAMESPACE}.group.member_removed"

infrahub/events/models.py

@@ -1,93 +1,206 @@
-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, description="The branch on which originate this event")
     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, 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,
+            request_id=parent.meta.request_id,
+            initiator_id=parent.meta.initiator_id,
+            account_id=parent.meta.account_id,
+            level=parent.meta.level + 1,
+            context=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,73 @@
 from typing import Any
 
-from pydantic import Field
+from pydantic import Field, computed_field
 
+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 +75,12 @@ 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,
+            "infrahub.branch.name": self.meta.context.branch.name,
         }
 
     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,15 @@ class NodeMutatedEvent(InfrahubBranchEvent):
             #     meta=self.get_message_meta(),
             # )
         ]
+
+
+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/exceptions.py

@@ -49,6 +49,15 @@ class DatabaseError(Error):
         super().__init__(self.message)
 
 
+class ServiceUnavailableError(Error):
+    HTTP_CODE: int = 503
+    DESCRIPTION = "Service unavailable"
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__(self.message)
+
+
 class LockError(Error):
     pass
 

infrahub/generators/models.py

@@ -30,6 +30,7 @@ class RequestGeneratorDefinitionRun(BaseModel):
 
     generator_definition: ProposedChangeGeneratorDefinition = Field(..., description="The Generator Definition")
     branch: str = Field(..., description="The branch to target")
+    target_members: list[str] = Field(default_factory=list, description="List of targets to run the generator for")
 
 
 class ProposedChangeGeneratorDefinition(BaseModel):