infrahub-server 1.2.9rc0__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

infrahub/actions/schema.py

@@ -0,0 +1,382 @@
+from infrahub.actions.constants import BranchScope, NodeAction, ValueMatch
+from infrahub.core.constants import AllowOverrideType, BranchSupportType, InfrahubKind
+from infrahub.core.constants import RelationshipCardinality as Cardinality
+from infrahub.core.constants import RelationshipKind as RelKind
+from infrahub.core.schema.attribute_schema import AttributeSchema as Attr
+from infrahub.core.schema.generic_schema import GenericSchema
+from infrahub.core.schema.node_schema import NodeSchema
+from infrahub.core.schema.relationship_schema import (
+    RelationshipSchema as Rel,
+)
+
+core_trigger_rule = GenericSchema(
+    name="TriggerRule",
+    namespace="Core",
+    description="A rule that allows you to define a trigger and map it to an action that runs once the trigger condition is met.",
+    include_in_menu=False,
+    icon="mdi:filter-cog-outline",
+    label="Trigger Rule",
+    human_friendly_id=["name__value"],
+    order_by=["name__value"],
+    display_labels=["name__value"],
+    branch=BranchSupportType.AGNOSTIC,
+    uniqueness_constraints=[["name__value"]],
+    generate_profile=False,
+    attributes=[
+        Attr(
+            name="name",
+            kind="Text",
+            description="The name of the trigger rule",
+            unique=True,
+            order_weight=1000,
+        ),
+        Attr(
+            name="description",
+            kind="Text",
+            description="A longer description to define the purpose of this trigger",
+            optional=True,
+            order_weight=2000,
+        ),
+        Attr(
+            name="active",
+            kind="Boolean",
+            description="Indicates if this trigger is enabled or if it's just prepared, could be useful as you are setting up a trigger",
+            optional=False,
+            default_value=True,
+            order_weight=2000,
+        ),
+        Attr(
+            name="branch_scope",
+            kind="Dropdown",
+            description="Limits the scope with regards to what kind of branches to match against",
+            choices=BranchScope.available_types(),
+            default_value=BranchScope.DEFAULT_BRANCH.value.name,
+            optional=False,
+            order_weight=2000,
+            allow_override=AllowOverrideType.NONE,
+        ),
+    ],
+    relationships=[
+        Rel(
+            name="action",
+            peer=InfrahubKind.ACTION,
+            description="The action to execute once the trigger conditions has been met",
+            identifier="core_action__core_triggerrule",
+            kind=RelKind.ATTRIBUTE,
+            cardinality=Cardinality.ONE,
+            optional=False,
+            order_weight=10000,
+        ),
+    ],
+)
+
+core_action = GenericSchema(
+    name="Action",
+    namespace="Core",
+    description="An action that can be executed by a trigger",
+    include_in_menu=False,
+    icon="mdi:cards-diamond-outline",
+    label="Core Action",
+    human_friendly_id=["name__value"],
+    order_by=["name__value"],
+    display_labels=["name__value"],
+    branch=BranchSupportType.AGNOSTIC,
+    uniqueness_constraints=[["name__value"]],
+    generate_profile=False,
+    attributes=[
+        Attr(
+            name="name",
+            description="Short descriptive name",
+            kind="Text",
+            unique=True,
+            order_weight=1000,
+        ),
+        Attr(
+            name="description",
+            description="A detailed description of the action",
+            kind="Text",
+            optional=True,
+            order_weight=2000,
+        ),
+    ],
+    relationships=[
+        Rel(
+            name="triggers",
+            description="The triggers that would execute this action once the triggering condition is met",
+            peer=InfrahubKind.TRIGGERRULE,
+            kind=RelKind.ATTRIBUTE,
+            cardinality=Cardinality.MANY,
+            identifier="core_action__core_triggerrule",
+            optional=True,
+            order_weight=10000,
+        ),
+    ],
+)
+
+core_node_trigger_match = GenericSchema(
+    name="NodeTriggerMatch",
+    namespace="Core",
+    description="A trigger match condition related to changes to nodes within the Infrahub database",
+    include_in_menu=False,
+    icon="mdi:match",
+    label="Node Trigger Match",
+    branch=BranchSupportType.AGNOSTIC,
+    generate_profile=False,
+    attributes=[],
+    relationships=[
+        Rel(
+            name="trigger",
+            peer="CoreNodeTriggerRule",
+            description="The node trigger that this match is connected to",
+            kind=RelKind.PARENT,
+            cardinality=Cardinality.ONE,
+            optional=False,
+            identifier="core_node_trigger_match__core_trigger_rule",
+            order_weight=10000,
+        ),
+    ],
+)
+
+
+core_generator_action = NodeSchema(
+    name="GeneratorAction",
+    namespace="Core",
+    description="An action that runs a generator definition once triggered",
+    include_in_menu=False,
+    icon="mdi:cards-diamond-outline",
+    label="Generator Action",
+    human_friendly_id=["name__value"],
+    order_by=["name__value"],
+    display_labels=["name__value"],
+    branch=BranchSupportType.AGNOSTIC,
+    uniqueness_constraints=[["name__value"]],
+    generate_profile=False,
+    inherit_from=[InfrahubKind.ACTION],
+    relationships=[
+        Rel(
+            name="generator",
+            description="The generator definition to execute once this action gets triggered",
+            peer=InfrahubKind.GENERATORDEFINITION,
+            kind=RelKind.ATTRIBUTE,
+            cardinality=Cardinality.ONE,
+            identifier="core_generator_action__generator_definition",
+            optional=False,
+            order_weight=4000,
+        ),
+    ],
+)
+
+core_group_action = NodeSchema(
+    name="GroupAction",
+    namespace="Core",
+    description="A group action that adds or removes members from a group once triggered",
+    include_in_menu=False,
+    icon="mdi:cards-diamond-outline",
+    label="Group Action",
+    human_friendly_id=["name__value"],
+    order_by=["name__value"],
+    display_labels=["name__value"],
+    branch=BranchSupportType.AGNOSTIC,
+    uniqueness_constraints=[["name__value"]],
+    generate_profile=False,
+    inherit_from=[InfrahubKind.ACTION],
+    attributes=[
+        Attr(
+            name="add_members",
+            kind="Boolean",
+            description="Defines if the action should add or remove members from a group when triggered",
+            unique=False,
+            optional=False,
+            default_value=True,
+            order_weight=3000,
+        ),
+    ],
+    relationships=[
+        Rel(
+            name="group",
+            peer=InfrahubKind.GENERICGROUP,
+            description="The target group of this action",
+            kind=RelKind.ATTRIBUTE,
+            cardinality=Cardinality.ONE,
+            identifier="core_action__group",
+            optional=False,
+            order_weight=4000,
+        ),
+    ],
+)
+
+
+core_node_trigger_rule = NodeSchema(
+    name="NodeTriggerRule",
+    namespace="Core",
+    description="A trigger rule that evaluates modifications to nodes within the Infrahub database",
+    include_in_menu=False,
+    icon="mdi:filter-cog-outline",
+    label="Node Trigger Rule",
+    human_friendly_id=["name__value"],
+    order_by=["name__value"],
+    display_labels=["name__value"],
+    branch=BranchSupportType.AGNOSTIC,
+    uniqueness_constraints=[["name__value"]],
+    generate_profile=False,
+    inherit_from=[InfrahubKind.TRIGGERRULE],
+    attributes=[
+        Attr(
+            name="node_kind",
+            kind="Text",
+            description="The kind of node to match against",
+            unique=False,
+            optional=False,
+            order_weight=3000,
+        ),
+        Attr(
+            name="mutation_action",
+            kind="Text",
+            description="The type of modification to match against",
+            enum=NodeAction.available_types(),
+            unique=False,
+            optional=False,
+            order_weight=4000,
+        ),
+    ],
+    relationships=[
+        Rel(
+            name="matches",
+            peer="CoreNodeTriggerMatch",
+            description="Use matches to configure the match condition for the selected node kind",
+            kind=RelKind.COMPONENT,
+            cardinality=Cardinality.MANY,
+            optional=True,
+            identifier="core_node_trigger_match__core_trigger_rule",
+            order_weight=8000,
+        ),
+    ],
+)
+
+core_node_trigger_attribute_match = NodeSchema(
+    name="NodeTriggerAttributeMatch",
+    namespace="Core",
+    description="A trigger match that matches against attribute changes on a node",
+    include_in_menu=False,
+    icon="mdi:match",
+    label="Node Trigger Attribute Match",
+    branch=BranchSupportType.AGNOSTIC,
+    generate_profile=False,
+    inherit_from=["CoreNodeTriggerMatch"],
+    attributes=[
+        Attr(
+            name="attribute_name",
+            kind="Text",
+            description="The attribue to match against",
+            unique=False,
+            optional=False,
+            order_weight=1000,
+        ),
+        Attr(
+            name="value",
+            kind="Text",
+            description="The value the attribute is updated to",
+            unique=False,
+            optional=True,
+            order_weight=2000,
+        ),
+        Attr(
+            name="value_previous",
+            kind="Text",
+            description="The previous value of the targeted attribute",
+            unique=False,
+            optional=True,
+            order_weight=3000,
+        ),
+        Attr(
+            name="value_match",
+            kind="Dropdown",
+            description="The value_match defines how the update will be evaluated, if it has to match the new value, the previous value or both",
+            choices=ValueMatch.available_types(),
+            default_value=ValueMatch.VALUE.value.name,
+            optional=False,
+            order_weight=5000,
+        ),
+    ],
+    relationships=[],
+)
+
+core_node_trigger_relationship_match = NodeSchema(
+    name="NodeTriggerRelationshipMatch",
+    namespace="Core",
+    description="A trigger match that matches against relationship changes on a node",
+    include_in_menu=False,
+    icon="mdi:match",
+    label="Node Trigger Relationship Match",
+    branch=BranchSupportType.AGNOSTIC,
+    generate_profile=False,
+    inherit_from=["CoreNodeTriggerMatch"],
+    attributes=[
+        Attr(
+            name="relationship_name",
+            kind="Text",
+            description="The name of the relationship to match against",
+            unique=False,
+            optional=False,
+            order_weight=1000,
+        ),
+        Attr(
+            name="added",
+            kind="Boolean",
+            description="Indicates if the relationship was added or removed",
+            unique=False,
+            optional=False,
+            default_value=True,
+            order_weight=2000,
+        ),
+        Attr(
+            name="peer",
+            kind="Text",
+            description="The node_id of the relationship peer to match against",
+            unique=False,
+            optional=True,
+            order_weight=3000,
+        ),
+    ],
+    relationships=[],
+)
+
+
+core_group_trigger_rule = NodeSchema(
+    name="GroupTriggerRule",
+    namespace="Core",
+    description="A trigger rule that matches against updates to memberships within groups",
+    include_in_menu=False,
+    icon="mdi:filter-cog-outline",
+    label="Group Trigger Rule",
+    human_friendly_id=["name__value"],
+    order_by=["name__value"],
+    display_labels=["name__value"],
+    branch=BranchSupportType.AGNOSTIC,
+    uniqueness_constraints=[["name__value"]],
+    generate_profile=False,
+    inherit_from=[InfrahubKind.TRIGGERRULE],
+    attributes=[
+        Attr(
+            name="members_added",
+            kind="Boolean",
+            description="Indicate if the match should be for when members are added or removed",
+            unique=False,
+            optional=False,
+            default_value=True,
+            order_weight=3000,
+        ),
+    ],
+    relationships=[
+        Rel(
+            name="group",
+            peer=InfrahubKind.GENERICGROUP,
+            description="The group to match against",
+            kind=RelKind.ATTRIBUTE,
+            cardinality=Cardinality.ONE,
+            identifier="core_group_trigger__group",
+            optional=False,
+            order_weight=4000,
+        ),
+    ],
+)

infrahub/actions/tasks.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from infrahub_sdk.graphql import Mutation
+from prefect import flow
+from prefect.client.orchestration import get_client
+
+from infrahub import lock
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.trigger.models import TriggerType
+from infrahub.trigger.setup import setup_triggers
+from infrahub.workflows.utils import add_tags
+
+from .gather import gather_trigger_action_rules
+from .models import EventGroupMember  # noqa: TC001  needed for prefect flow
+
+
+@flow(
+    name="action-add-node-to-group",
+    flow_run_name="Adding node={node_id} to group={group_id}",
+)
+async def add_node_to_group(
+    branch_name: str,
+    node_id: str,
+    group_id: str,
+    context: InfrahubContext,  # noqa: ARG001
+    service: InfrahubServices,
+) -> None:
+    await add_tags(branches=[branch_name], nodes=[node_id, group_id])
+
+    mutation = Mutation(
+        mutation="RelationshipAdd",
+        input_data={"data": {"id": group_id, "name": "members", "nodes": [{"id": node_id}]}},
+        query={"ok": None},
+    )
+
+    await service.client.execute_graphql(query=mutation.render(), branch_name=branch_name)
+
+
+@flow(
+    name="action-remove-node-from-group",
+    flow_run_name="Removing node={node_id} from group={group_id}",
+)
+async def remove_node_from_group(
+    branch_name: str,
+    node_id: str,
+    group_id: str,
+    context: InfrahubContext,  # noqa: ARG001
+    service: InfrahubServices,
+) -> None:
+    await add_tags(branches=[branch_name], nodes=[node_id, group_id])
+
+    mutation = Mutation(
+        mutation="RelationshipRemove",
+        input_data={"data": {"id": group_id, "name": "members", "nodes": [{"id": node_id}]}},
+        query={"ok": None},
+    )
+
+    await service.client.execute_graphql(query=mutation.render(), branch_name=branch_name)
+
+
+@flow(
+    name="action-run-generator",
+    flow_run_name="Running generator generator_definition_id={generator_definition_id} for nodes={node_ids}",
+)
+async def run_generator(
+    branch_name: str,
+    node_ids: list[str],
+    generator_definition_id: str,
+    context: InfrahubContext,  # noqa: ARG001
+    service: InfrahubServices,
+) -> None:
+    await add_tags(branches=[branch_name], nodes=node_ids + [generator_definition_id])
+    await _run_generator(
+        branch_name=branch_name, generator_definition_id=generator_definition_id, node_ids=node_ids, service=service
+    )
+
+
+@flow(
+    name="action-run-generator-group-event",
+    flow_run_name="Running generator",
+)
+async def run_generator_group_event(
+    branch_name: str,
+    members: list[EventGroupMember],
+    generator_definition_id: str,
+    context: InfrahubContext,  # noqa: ARG001
+    service: InfrahubServices,
+) -> None:
+    node_ids = [node.id for node in members]
+    await add_tags(branches=[branch_name], nodes=node_ids + [generator_definition_id])
+    await _run_generator(
+        branch_name=branch_name, generator_definition_id=generator_definition_id, node_ids=node_ids, service=service
+    )
+
+
+@flow(
+    name="configure-action-rules",
+    flow_run_name="Configure updated action rules and triggers",
+)
+async def configure_action_rules(
+    service: InfrahubServices,
+) -> None:
+    async with lock.registry.get(name="configure-action-rules", namespace="trigger-rules", local=False):
+        triggers = await gather_trigger_action_rules(db=service.database)
+        async with get_client(sync_client=False) as prefect_client:
+            await setup_triggers(
+                client=prefect_client,
+                triggers=triggers,
+                trigger_type=TriggerType.ACTION_TRIGGER_RULE,
+            )  # type: ignore[misc]
+
+
+async def _run_generator(
+    branch_name: str,
+    node_ids: list[str],
+    generator_definition_id: str,
+    service: InfrahubServices,
+) -> None:
+    mutation = Mutation(
+        mutation="CoreGeneratorDefinitionRun",
+        input_data={"data": {"id": generator_definition_id, "nodes": node_ids}},
+        query={"ok": None},
+    )
+
+    await service.client.execute_graphql(query=mutation.render(), branch_name=branch_name)

infrahub/actions/triggers.py

@@ -0,0 +1,21 @@
+from infrahub.events.node_action import NodeCreatedEvent, NodeDeletedEvent, NodeUpdatedEvent
+from infrahub.trigger.models import BuiltinTriggerDefinition, EventTrigger, ExecuteWorkflow
+from infrahub.workflows.catalogue import CONFIGURE_ACTION_RULES
+
+from .constants import NODES_THAT_TRIGGER_ACTION_RULES_SETUP
+
+TRIGGER_ACTION_RULE_UPDATE = BuiltinTriggerDefinition(
+    name="action-trigger-setup-all",
+    trigger=EventTrigger(
+        events={NodeCreatedEvent.event_name, NodeDeletedEvent.event_name, NodeUpdatedEvent.event_name},
+        match={
+            "infrahub.node.kind": NODES_THAT_TRIGGER_ACTION_RULES_SETUP,
+        },
+    ),
+    actions=[
+        ExecuteWorkflow(
+            workflow=CONFIGURE_ACTION_RULES,
+            parameters={},
+        ),
+    ],
+)

infrahub/cli/db.py

@@ -489,11 +489,10 @@ WITH n
 ORDER BY %(id_func)s(n)
 SKIP toInteger($offset)
 LIMIT toInteger($limit)
-CALL {
+CALL (n) {
     // --------------
     // get all the nodes and edges linked to this node up to 2 steps away, excluding IS_PART_OF
     // --------------
-    WITH n
     MATCH (n)-[r1]-(v1)-[r2]-(v2)
     WHERE type(r1) <> "IS_PART_OF"
     WITH collect([v1, v2]) AS vertex_pairs, collect([r1, r2]) AS edge_pairs

infrahub/computed_attribute/models.py

@@ -118,6 +118,10 @@ class PythonTransformTarget:
 class ComputedAttrJinja2TriggerDefinition(TriggerBranchDefinition):
     type: TriggerType = TriggerType.COMPUTED_ATTR_JINJA2
     computed_attribute: ComputedAttributeTarget
+    template_hash: str
+
+    def get_description(self) -> str:
+        return f"{super().get_description()} | hash:{self.template_hash}"
 
     @classmethod
     def from_computed_attribute(
@@ -139,6 +143,14 @@ class ComputedAttrJinja2TriggerDefinition(TriggerBranchDefinition):
             # node creation events if the attribute is optional.
             event_trigger.events.add(NodeCreatedEvent.event_name)
 
+        if (
+            computed_attribute.attribute.computed_attribute
+            and computed_attribute.attribute.computed_attribute.jinja2_template is None
+        ) or not computed_attribute.attribute.computed_attribute:
+            raise ValueError("Jinja2 template is required for computed attribute")
+
+        template_hash = computed_attribute.attribute.computed_attribute.get_hash()
+
         event_trigger.match = {"infrahub.node.kind": trigger_node.kind}
         if branches_out_of_scope:
             event_trigger.match["infrahub.branch.name"] = [f"!{branch}" for branch in branches_out_of_scope]
@@ -177,6 +189,7 @@ class ComputedAttrJinja2TriggerDefinition(TriggerBranchDefinition):
 
         definition = cls(
             name=f"{computed_attribute.key_name}{NAME_SEPARATOR}kind{NAME_SEPARATOR}{trigger_node.kind}",
+            template_hash=template_hash,
             branch=branch,
             computed_attribute=computed_attribute,
             trigger=event_trigger,