infrahub-server 1.2.11__py3-none-any.whl → 1.3.0b1__py3-none-any.whl

infrahub/actions/constants.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from enum import Enum
+
+from infrahub.core.constants import InfrahubKind
+from infrahub.core.schema.dropdown import DropdownChoice
+from infrahub.utils import InfrahubStringEnum
+
+
+class NodeAction(InfrahubStringEnum):
+    CREATED = "created"
+    DELETED = "deleted"
+    UPDATED = "updated"
+
+
+class BranchScope(Enum):
+    ALL_BRANCHES = DropdownChoice(
+        name="all_branches",
+        label="All Branches",
+        description="All branches",
+        color="#fef08a",
+    )
+    DEFAULT_BRANCH = DropdownChoice(
+        name="default_branch",
+        label="Default Branch",
+        description="Only the default branch",
+        color="#86efac",
+    )
+    OTHER_BRANCHES = DropdownChoice(
+        name="other_branches",
+        label="Other Branches",
+        description="All branches except the default branch",
+        color="#e5e7eb",
+    )
+
+    @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) -> BranchScope:
+        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 branch scope")
+
+
+class ValueMatch(Enum):
+    VALUE = DropdownChoice(
+        name="value",
+        label="Value",
+        description="Match against the current value",
+        color="#fef08a",
+    )
+    VALUE_PREVIOUS = DropdownChoice(
+        name="value_previous",
+        label="Value Previous",
+        description="Match against the previous value",
+        color="#86efac",
+    )
+    VALUE_FULL = DropdownChoice(
+        name="value_full",
+        label="Full value match",
+        description="Match against both the current and previous values",
+        color="#e5e7eb",
+    )
+
+    @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) -> ValueMatch:
+        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 ValueMatch")
+
+
+NODES_THAT_TRIGGER_ACTION_RULES_SETUP = [
+    InfrahubKind.GROUPACTION,
+    InfrahubKind.GROUPTRIGGERRULE,
+    InfrahubKind.NODETRIGGERRULE,
+]

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},
+                                            "added": {"value": None},
+                                            "peer": {"value": None},
+                                        },
+                                    }
+                                }
+                            },
+                        },
+                        "... on CoreGroupTriggerRule": {
+                            "members_added": {"value": None},
+                            "group": {
+                                "node": {
+                                    "id": None,
+                                    "__typename": None,
+                                }
+                            },
+                        },
+                        "action": {
+                            "node": {
+                                "__typename": None,
+                                "id": None,
+                                "name": {"value": None},
+                                "... on CoreGroupAction": {
+                                    "add_members": {"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,241 @@
+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, ValueMatch
+
+
+class EventGroupMember(BaseModel):
+    id: str
+    kind: str
+
+
+class CoreAction(BaseModel):
+    """CoreAction generic"""
+
+
+class CoreGeneratorAction(CoreAction):
+    generator_id: str
+
+
+class CoreGroupAction(CoreAction):
+    add_members: bool
+    group_id: str
+
+
+class CoreTriggerRule(BaseModel):
+    name: str
+    branch_scope: BranchScope
+    action: CoreAction
+    active: bool
+
+
+class CoreGroupTriggerRule(CoreTriggerRule):
+    members_added: bool
+    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
+    added: bool
+    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):
+                peer_status = "added" if match.added else "removed"
+                match_related = {
+                    "prefect.resource.role": "infrahub.node.relationship_update",
+                    "infrahub.field.name": match.relationship_name,
+                    "infrahub.relationship.peer_status": peer_status,
+                }
+                if isinstance(match.peer, str):
+                    match_related["infrahub.relationship.peer_id"] = match.peer
+            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.add_members:
+                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.members_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, 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":
+            members_added = data["members_added"]["value"]
+            group_id = data["group"]["node"]["id"]
+            group_kind = data["group"]["node"]["__typename"]
+            return CoreGroupTriggerRule(
+                name=name,
+                branch_scope=branch_scope,
+                action=action,
+                members_added=members_added,
+                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":
+            add_members = data["add_members"]["value"]
+            group_id = data["group"]["node"]["id"]
+            return CoreGroupAction(add_members=add_members, 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"],
+                        added=node["added"]["value"],
+                        peer=node["peer"]["value"],
+                    )
+                )
+
+    return matches