infrahub-server 1.2.12__py3-none-any.whl → 1.3.0__py3-none-any.whl

infrahub/actions/constants.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Self
+
+from infrahub.core.constants import InfrahubKind
+from infrahub.core.schema.dropdown import DropdownChoice
+from infrahub.utils import InfrahubStringEnum
+
+
+class NodeAction(InfrahubStringEnum):
+    CREATED = "created"
+    UPDATED = "updated"
+
+
+class DropdownEnum(Enum):
+    @classmethod
+    def available_types(cls) -> list[DropdownChoice]:
+        return [cls.__members__[member].value for member in list(cls.__members__)]
+
+    @classmethod
+    def from_value(cls, value: str) -> Self:
+        for member in cls.__members__:
+            if value == cls.__members__[member].value.name:
+                return cls.__members__[member]
+
+        raise NotImplementedError(f"The defined value {value} doesn't match a value of {cls.__class__.__name__}")
+
+
+class BranchScope(DropdownEnum):
+    ALL_BRANCHES = DropdownChoice(
+        name="all_branches",
+        label="All Branches",
+        description="All branches",
+        color="#4cd964",
+    )
+    DEFAULT_BRANCH = DropdownChoice(
+        name="default_branch",
+        label="Default Branch",
+        description="Only the default branch",
+        color="#5ac8fa",
+    )
+    OTHER_BRANCHES = DropdownChoice(
+        name="other_branches",
+        label="Other Branches",
+        description="All branches except the default branch",
+        color="#ff2d55",
+    )
+
+
+class MemberAction(DropdownEnum):
+    ADD_MEMBER = DropdownChoice(
+        name="add_member",
+        label="Add member",
+        description="Add impacted member to the selected group",
+        color="#4cd964",
+    )
+    REMOVE_MEMBER = DropdownChoice(
+        name="remove_member",
+        label="Remove member",
+        description="Remove impacted member from the selected group",
+        color="#ff2d55",
+    )
+
+
+class MemberUpdate(DropdownEnum):
+    ADDED = DropdownChoice(
+        name="added",
+        label="Added",
+        description="Trigger when members are added to this group",
+        color="#4cd964",
+    )
+    REMOVED = DropdownChoice(
+        name="removed",
+        label="Removed",
+        description="Trigger when members are removed from this group",
+        color="#ff2d55",
+    )
+
+
+class RelationshipMatch(DropdownEnum):
+    ADDED = DropdownChoice(
+        name="added",
+        label="Added",
+        description="Check if the selected relationship was added",
+        color="#4cd964",
+    )
+    REMOVED = DropdownChoice(
+        name="removed",
+        label="Removed",
+        description="Check if the selected relationship was removed",
+        color="#ff2d55",
+    )
+    UPDATED = DropdownChoice(
+        name="updated",
+        label="Updated",
+        description="Check if the selected relationship was updated, added or removed.",
+        color="#5ac8fa",
+    )
+
+
+class ValueMatch(DropdownEnum):
+    VALUE = DropdownChoice(
+        name="value",
+        label="Value",
+        description="Match against the current value",
+        color="#4cd964",
+    )
+    VALUE_PREVIOUS = DropdownChoice(
+        name="value_previous",
+        label="Value Previous",
+        description="Match against the previous value",
+        color="#ff2d55",
+    )
+    VALUE_FULL = DropdownChoice(
+        name="value_full",
+        label="Full value match",
+        description="Match against both the current and previous values",
+        color="#5ac8fa",
+    )
+
+
+NODES_THAT_TRIGGER_ACTION_RULES_SETUP = [
+    InfrahubKind.GENERATORACTION,
+    InfrahubKind.GROUPACTION,
+    InfrahubKind.GROUPTRIGGERRULE,
+    InfrahubKind.NODETRIGGERRULE,
+    InfrahubKind.NODETRIGGERATTRIBUTEMATCH,
+    InfrahubKind.NODETRIGGERRELATIONSHIPMATCH,
+]

infrahub/actions/gather.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from graphql import graphql
+from infrahub_sdk.graphql import Query
+from prefect import task
+from prefect.cache_policies import NONE
+
+from infrahub.core.constants import InfrahubKind
+from infrahub.core.registry import registry
+from infrahub.database import InfrahubDatabase  # noqa: TC001  needed for prefect flow
+from infrahub.graphql.initialization import prepare_graphql_params
+
+from .models import ActionTriggerRuleTriggerDefinition
+from .parsers import parse_trigger_rule_response
+
+
+@task(
+    name="gather-trigger-action-rules",
+    cache_policy=NONE,
+)
+async def gather_trigger_action_rules(db: InfrahubDatabase) -> list[ActionTriggerRuleTriggerDefinition]:
+    trigger_query = Query(
+        name=InfrahubKind.TRIGGERRULE,
+        query={
+            InfrahubKind.TRIGGERRULE: {
+                "edges": {
+                    "node": {
+                        "__typename": None,
+                        "id": None,
+                        "name": {"value": None},
+                        "branch_scope": {"value": None},
+                        "active": {"value": None},
+                        "... on CoreNodeTriggerRule": {
+                            "node_kind": {"value": None},
+                            "mutation_action": {"value": None},
+                            "matches": {
+                                "edges": {
+                                    "node": {
+                                        "__typename": None,
+                                        "id": None,
+                                        "... on CoreNodeTriggerAttributeMatch": {
+                                            "attribute_name": {"value": None},
+                                            "value": {"value": None},
+                                            "value_previous": {"value": None},
+                                            "value_match": {"value": None},
+                                        },
+                                        "... on CoreNodeTriggerRelationshipMatch": {
+                                            "relationship_name": {"value": None},
+                                            "modification_type": {"value": None},
+                                            "peer": {"value": None},
+                                        },
+                                    }
+                                }
+                            },
+                        },
+                        "... on CoreGroupTriggerRule": {
+                            "member_update": {"value": None},
+                            "group": {
+                                "node": {
+                                    "id": None,
+                                    "__typename": None,
+                                }
+                            },
+                        },
+                        "action": {
+                            "node": {
+                                "__typename": None,
+                                "id": None,
+                                "name": {"value": None},
+                                "... on CoreGroupAction": {
+                                    "member_action": {"value": None},
+                                    "group": {
+                                        "node": {
+                                            "id": None,
+                                            "__typename": None,
+                                        }
+                                    },
+                                },
+                                "... on CoreGeneratorAction": {
+                                    "generator": {
+                                        "node": {
+                                            "__typename": None,
+                                            "id": None,
+                                        }
+                                    },
+                                },
+                            }
+                        },
+                    }
+                },
+            }
+        },
+    )
+    gql_params = await prepare_graphql_params(
+        db=db,
+        branch=registry.default_branch,
+    )
+    response = await graphql(
+        schema=gql_params.schema,
+        source=trigger_query.render(),
+        context_value=gql_params.context,
+        root_value=None,
+        variable_values={},
+    )
+
+    data = response.data or {}
+    trigger_rules = parse_trigger_rule_response(data)
+    trigger_candidates = [
+        ActionTriggerRuleTriggerDefinition.from_trigger_rule(trigger_rule=trigger_rule)
+        for trigger_rule in trigger_rules
+        if trigger_rule.active
+    ]
+
+    return [trigger_rule for trigger_rule in trigger_candidates if trigger_rule]

infrahub/actions/models.py

@@ -0,0 +1,243 @@
+from typing import Self
+
+from pydantic import BaseModel
+
+from infrahub.core.registry import registry
+from infrahub.events import (
+    GroupMemberAddedEvent,
+    GroupMemberRemovedEvent,
+    NodeCreatedEvent,
+    NodeDeletedEvent,
+    NodeUpdatedEvent,
+)
+from infrahub.trigger.models import (
+    EventTrigger,
+    ExecuteWorkflow,
+    TriggerDefinition,
+    TriggerType,
+)
+from infrahub.workflows.catalogue import (
+    ACTION_ADD_NODE_TO_GROUP,
+    ACTION_RUN_GENERATOR,
+    ACTION_RUN_GENERATOR_GROUP_EVENT,
+    REMOVE_ADD_NODE_FROM_GROUP,
+)
+
+from .constants import BranchScope, MemberAction, MemberUpdate, RelationshipMatch, ValueMatch
+
+
+class EventGroupMember(BaseModel):
+    id: str
+    kind: str
+
+
+class CoreAction(BaseModel):
+    """CoreAction generic"""
+
+
+class CoreGeneratorAction(CoreAction):
+    generator_id: str
+
+
+class CoreGroupAction(CoreAction):
+    member_action: MemberAction
+    group_id: str
+
+
+class CoreTriggerRule(BaseModel):
+    name: str
+    branch_scope: BranchScope
+    action: CoreAction
+    active: bool
+
+
+class CoreGroupTriggerRule(CoreTriggerRule):
+    member_update: MemberUpdate
+    group_id: str
+    group_kind: str
+
+
+class CoreNodeTriggerMatch(BaseModel):
+    """Node Trigger Match Generic"""
+
+
+class CoreNodeTriggerAttributeMatch(CoreNodeTriggerMatch):
+    attribute_name: str
+    value: str | None
+    value_previous: str | None
+    value_match: ValueMatch
+
+
+class CoreNodeTriggerRelationshipMatch(CoreNodeTriggerMatch):
+    relationship_name: str
+    modification_type: RelationshipMatch
+    peer: str | None
+
+
+class CoreNodeTriggerRule(CoreTriggerRule):
+    node_kind: str
+    mutation_action: str
+    matches: list[CoreNodeTriggerMatch]
+
+
+class ActionTriggerRuleTriggerDefinition(TriggerDefinition):
+    type: TriggerType = TriggerType.ACTION_TRIGGER_RULE
+
+    @classmethod
+    def from_trigger_rule(cls, trigger_rule: CoreTriggerRule) -> Self | None:
+        if isinstance(trigger_rule, CoreNodeTriggerRule):
+            return cls._from_node_trigger(trigger_rule=trigger_rule)
+
+        if isinstance(trigger_rule, CoreGroupTriggerRule):
+            return cls._from_group_trigger(trigger_rule=trigger_rule)
+
+        return None
+
+    @classmethod
+    def _from_node_trigger(
+        cls,
+        trigger_rule: CoreNodeTriggerRule,
+    ) -> Self:
+        event_trigger = EventTrigger()
+
+        match trigger_rule.mutation_action:
+            case "created":
+                event_trigger.events.add(NodeCreatedEvent.event_name)
+            case "deleted":
+                event_trigger.events.add(NodeDeletedEvent.event_name)
+            case "updated":
+                event_trigger.events.add(NodeUpdatedEvent.event_name)
+
+        event_trigger.match = {"infrahub.node.kind": trigger_rule.node_kind}
+
+        match trigger_rule.branch_scope:
+            case BranchScope.DEFAULT_BRANCH:
+                event_trigger.match["infrahub.branch.name"] = registry.default_branch
+            case BranchScope.OTHER_BRANCHES:
+                event_trigger.match["infrahub.branch.name"] = f"!{registry.default_branch}"
+
+        related_matches: list[dict[str, str | list[str]]] = []
+        for match in trigger_rule.matches:
+            if isinstance(match, CoreNodeTriggerAttributeMatch):
+                match_related: dict[str, str | list[str]] = {
+                    "prefect.resource.role": "infrahub.node.attribute_update",
+                    "infrahub.field.name": match.attribute_name,
+                    "infrahub.attribute.action": ["added", "updated", "removed"],
+                }
+
+                match match.value_match:
+                    case ValueMatch.VALUE:
+                        match_related["infrahub.attribute.value"] = match.value or ""
+                    case ValueMatch.VALUE_PREVIOUS:
+                        match_related["infrahub.attribute.value_previous"] = match.value_previous or ""
+                    case ValueMatch.VALUE_FULL:
+                        match_related["infrahub.attribute.value"] = match.value or ""
+                        match_related["infrahub.attribute.value_previous"] = match.value_previous or ""
+
+            elif isinstance(match, CoreNodeTriggerRelationshipMatch):
+                match_related = {
+                    "prefect.resource.role": "infrahub.node.relationship_update",
+                    "infrahub.field.name": match.relationship_name,
+                }
+                if isinstance(match.peer, str):
+                    match_related["infrahub.relationship.peer_id"] = match.peer
+
+                if match.modification_type != RelationshipMatch.UPDATED:
+                    match_related["infrahub.relationship.peer_status"] = match.modification_type.value.name
+
+            related_matches.append(match_related)
+
+        event_trigger.match_related = related_matches or {}
+
+        if isinstance(trigger_rule.action, CoreGeneratorAction):
+            workflow = ExecuteWorkflow(
+                workflow=ACTION_RUN_GENERATOR,
+                parameters={
+                    "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                    "generator_definition_id": trigger_rule.action.generator_id,
+                    "node_ids": ["{{ event.resource['infrahub.node.id'] }}"],
+                    "context": {
+                        "__prefect_kind": "json",
+                        "value": {
+                            "__prefect_kind": "jinja",
+                            "template": "{{ event.payload['context'] | tojson }}",
+                        },
+                    },
+                },
+            )
+        elif isinstance(trigger_rule.action, CoreGroupAction):
+            if trigger_rule.action.member_action == MemberAction.ADD_MEMBER:
+                flow = ACTION_ADD_NODE_TO_GROUP
+            else:
+                flow = REMOVE_ADD_NODE_FROM_GROUP
+
+            workflow = ExecuteWorkflow(
+                workflow=flow,
+                parameters={
+                    "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                    "group_id": trigger_rule.action.group_id,
+                    "node_id": "{{ event.resource['infrahub.node.id'] }}",
+                    "context": {
+                        "__prefect_kind": "json",
+                        "value": {
+                            "__prefect_kind": "jinja",
+                            "template": "{{ event.payload['context'] | tojson }}",
+                        },
+                    },
+                },
+            )
+
+        return cls(
+            name=trigger_rule.name,
+            trigger=event_trigger,
+            actions=[workflow],
+        )
+
+    @classmethod
+    def _from_group_trigger(
+        cls,
+        trigger_rule: CoreGroupTriggerRule,
+    ) -> Self:
+        event_trigger = EventTrigger()
+
+        if trigger_rule.member_update == MemberUpdate.ADDED:
+            event_trigger.events.add(GroupMemberAddedEvent.event_name)
+        else:
+            event_trigger.events.add(GroupMemberRemovedEvent.event_name)
+
+        event_trigger.match = {"infrahub.node.kind": trigger_rule.group_kind, "infrahub.node.id": trigger_rule.group_id}
+
+        match trigger_rule.branch_scope:
+            case BranchScope.DEFAULT_BRANCH:
+                event_trigger.match["infrahub.branch.name"] = registry.default_branch
+            case BranchScope.OTHER_BRANCHES:
+                event_trigger.match["infrahub.branch.name"] = f"!{registry.default_branch}"
+
+        if isinstance(trigger_rule.action, CoreGeneratorAction):
+            workflow = ExecuteWorkflow(
+                workflow=ACTION_RUN_GENERATOR_GROUP_EVENT,
+                parameters={
+                    "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                    "generator_definition_id": trigger_rule.action.generator_id,
+                    "members": {
+                        "__prefect_kind": "json",
+                        "value": {
+                            "__prefect_kind": "jinja",
+                            "template": "{{ event.payload['data']['members']| tojson }}",
+                        },
+                    },
+                    "context": {
+                        "__prefect_kind": "json",
+                        "value": {
+                            "__prefect_kind": "jinja",
+                            "template": "{{ event.payload['context'] | tojson }}",
+                        },
+                    },
+                },
+            )
+
+        return cls(
+            name=trigger_rule.name,
+            trigger=event_trigger,
+            actions=[workflow],
+        )

infrahub/actions/parsers.py

@@ -0,0 +1,104 @@
+from typing import Any
+
+from infrahub.core.constants import InfrahubKind
+
+from .constants import BranchScope, MemberAction, MemberUpdate, RelationshipMatch, ValueMatch
+from .models import (
+    CoreAction,
+    CoreGeneratorAction,
+    CoreGroupAction,
+    CoreGroupTriggerRule,
+    CoreNodeTriggerAttributeMatch,
+    CoreNodeTriggerMatch,
+    CoreNodeTriggerRelationshipMatch,
+    CoreNodeTriggerRule,
+    CoreTriggerRule,
+)
+
+
+def parse_trigger_rule_response(data: dict[str, Any]) -> list[CoreTriggerRule]:
+    rules: list[CoreTriggerRule] = []
+    if kind := data.get(InfrahubKind.TRIGGERRULE):
+        if edges := kind.get("edges"):
+            for edge in edges:
+                if rule := _parse_graphql_node(edge["node"]):
+                    rules.append(rule)
+
+    return rules
+
+
+def _parse_graphql_node(data: dict[str, Any]) -> CoreTriggerRule | None:
+    typename = data.get("__typename")
+    name = data["name"]["value"]
+    active = data["active"]["value"]
+    branch_scope = BranchScope.from_value(value=data["branch_scope"]["value"])
+    action = _parse_graphql_action_response(data=data["action"]["node"])
+    match typename:
+        case "CoreGroupTriggerRule":
+            member_update = MemberUpdate.from_value(data["member_update"]["value"])
+            group_id = data["group"]["node"]["id"]
+            group_kind = data["group"]["node"]["__typename"]
+            return CoreGroupTriggerRule(
+                name=name,
+                branch_scope=branch_scope,
+                action=action,
+                member_update=member_update,
+                group_id=group_id,
+                group_kind=group_kind,
+                active=active,
+            )
+        case "CoreNodeTriggerRule":
+            node_kind = data["node_kind"]["value"]
+            mutation_action = data["mutation_action"]["value"]
+            matches = _parse_node_trigger_matches(data=data["matches"]["edges"])
+            return CoreNodeTriggerRule(
+                name=name,
+                branch_scope=branch_scope,
+                action=action,
+                node_kind=node_kind,
+                mutation_action=mutation_action,
+                matches=matches,
+                active=active,
+            )
+    return None
+
+
+def _parse_graphql_action_response(data: dict[str, Any]) -> CoreAction:
+    typename = data["__typename"]
+    match typename:
+        case "CoreGeneratorAction":
+            generator_id = data["generator"]["node"]["id"]
+            return CoreGeneratorAction(generator_id=generator_id)
+        case "CoreGroupAction":
+            member_action = MemberAction.from_value(data["member_action"]["value"])
+            group_id = data["group"]["node"]["id"]
+            return CoreGroupAction(member_action=member_action, group_id=group_id)
+
+    raise NotImplementedError(f"{typename} is not a valid CoreAction")
+
+
+def _parse_node_trigger_matches(data: list[dict[str, Any]]) -> list[CoreNodeTriggerMatch]:
+    matches: list[CoreNodeTriggerMatch] = []
+    for entry in data:
+        node = entry["node"]
+        typename = node["__typename"]
+        match typename:
+            case "CoreNodeTriggerAttributeMatch":
+                matches.append(
+                    CoreNodeTriggerAttributeMatch(
+                        attribute_name=node["attribute_name"]["value"],
+                        value=node["value"]["value"],
+                        value_previous=node["value_previous"]["value"],
+                        value_match=ValueMatch.from_value(value=node["value_match"]["value"]),
+                    )
+                )
+            case "CoreNodeTriggerRelationshipMatch":
+                matches.append(
+                    CoreNodeTriggerRelationshipMatch(
+                        relationship_name=node["relationship_name"]["value"],
+                        modification_type=RelationshipMatch.from_value(node["modification_type"]["value"]),
+                        peer=node["peer"]["value"],
+                    )
+                )
+
+    return matches