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

infrahub/actions/schema.py

@@ -0,0 +1,393 @@
+from infrahub.actions.constants import (
+    BranchScope,
+    MemberAction,
+    MemberUpdate,
+    NodeAction,
+    RelationshipMatch,
+    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=100,
+        ),
+        Attr(
+            name="description",
+            kind="Text",
+            description="A longer description to define the purpose of this trigger",
+            optional=True,
+            order_weight=200,
+        ),
+        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=200,
+        ),
+        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=200,
+            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=1000,
+        ),
+    ],
+)
+
+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=100,
+        ),
+        Attr(
+            name="description",
+            description="A detailed description of the action",
+            kind="Text",
+            optional=True,
+            order_weight=200,
+        ),
+    ],
+    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=1000,
+        ),
+    ],
+)
+
+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=1000,
+        ),
+    ],
+)
+
+
+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=400,
+        ),
+    ],
+)
+
+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="member_action",
+            kind="Dropdown",
+            description="Defines if the action should add or remove members from a group when triggered",
+            choices=MemberAction.available_types(),
+            default_value=MemberAction.ADD_MEMBER.value.name,
+            unique=False,
+            optional=False,
+            order_weight=300,
+        ),
+    ],
+    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=400,
+        ),
+    ],
+)
+
+
+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=300,
+        ),
+        Attr(
+            name="mutation_action",
+            kind="Text",
+            description="The type of modification to match against",
+            enum=NodeAction.available_types(),
+            unique=False,
+            optional=False,
+            order_weight=400,
+        ),
+    ],
+    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=800,
+        ),
+    ],
+)
+
+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"],
+    display_labels=["attribute_name__value"],
+    attributes=[
+        Attr(
+            name="attribute_name",
+            kind="Text",
+            description="The attribue to match against",
+            unique=False,
+            optional=False,
+            order_weight=100,
+        ),
+        Attr(
+            name="value",
+            kind="Text",
+            description="The value the attribute is updated to",
+            unique=False,
+            optional=True,
+            order_weight=200,
+        ),
+        Attr(
+            name="value_previous",
+            kind="Text",
+            description="The previous value of the targeted attribute",
+            unique=False,
+            optional=True,
+            order_weight=300,
+        ),
+        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=500,
+        ),
+    ],
+    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"],
+    display_labels=["relationship_name__value", "modification_type__value"],
+    attributes=[
+        Attr(
+            name="relationship_name",
+            kind="Text",
+            description="The name of the relationship to match against",
+            unique=False,
+            optional=False,
+            order_weight=100,
+        ),
+        Attr(
+            name="modification_type",
+            kind="Dropdown",
+            description="Indicates if the relationship was added or removed or just updated in any way",
+            choices=RelationshipMatch.available_types(),
+            default_value=RelationshipMatch.ADDED.value.name,
+            optional=False,
+            order_weight=200,
+            allow_override=AllowOverrideType.NONE,
+        ),
+        Attr(
+            name="peer",
+            kind="Text",
+            description="The node_id of the relationship peer to match against",
+            unique=False,
+            optional=True,
+            order_weight=300,
+        ),
+    ],
+    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="member_update",
+            kind="Dropdown",
+            description="Indicate if the match should be for when members are added or removed",
+            choices=MemberUpdate.available_types(),
+            default_value=MemberUpdate.ADDED.value.name,
+            optional=False,
+            order_weight=300,
+        ),
+    ],
+    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=400,
+        ),
+    ],
+)

infrahub/actions/tasks.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from infrahub_sdk.graphql import Mutation
+from prefect import flow
+
+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_specific
+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:
+    await setup_triggers_specific(
+        gatherer=gather_trigger_action_rules, trigger_type=TriggerType.ACTION_TRIGGER_RULE, db=service.database
+    )  # 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/branch/tasks.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from prefect import flow
+from prefect.logging import get_run_logger
+
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
+from infrahub.core.registry import registry
+from infrahub.pools.tasks import validate_schema_number_pools
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.workflows.utils import wait_for_schema_to_converge
+
+
+@flow(
+    name="branch-merged",
+    flow_run_name="Running actions after '{source_branch}' was merged",
+)
+async def branch_merged(
+    source_branch: str,  # noqa: ARG001
+    context: InfrahubContext,
+    service: InfrahubServices,
+    target_branch: str | None = None,
+) -> None:
+    target_branch = target_branch or registry.default_branch
+    log = get_run_logger()
+    await wait_for_schema_to_converge(
+        branch_name=target_branch, component=service.component, db=service.database, log=log
+    )
+
+    await validate_schema_number_pools(branch_name=target_branch, context=context, service=service)

infrahub/branch/triggers.py

@@ -0,0 +1,22 @@
+from infrahub.events.branch_action import BranchMergedEvent
+from infrahub.trigger.models import BuiltinTriggerDefinition, EventTrigger, ExecuteWorkflow
+from infrahub.workflows.catalogue import BRANCH_MERGED
+
+TRIGGER_BRANCH_MERGED = BuiltinTriggerDefinition(
+    name="branch-merged-trigger",
+    trigger=EventTrigger(
+        events={BranchMergedEvent.event_name},
+    ),
+    actions=[
+        ExecuteWorkflow(
+            workflow=BRANCH_MERGED,
+            parameters={
+                "source_branch": "{{ event.payload['data']['branch_name'] }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        ),
+    ],
+)

infrahub/cli/db.py

@@ -326,7 +326,7 @@ async def migrate_database(db: InfrahubDatabase, initialize: bool = False, check
                 root_node.graph_version = migration.minimum_version + 1
                 await root_node.save(db=db)
 
-        if not execution_result.success or validation_result and not validation_result.success:
+        if not execution_result.success or (validation_result and not validation_result.success):
             rprint(f"Migration: {migration.name} {FAILED_BADGE}")
             for error in execution_result.errors:
                 rprint(f"  {error}")
@@ -449,7 +449,7 @@ async def selected_export_cmd(
     ctx: typer.Context,
     kinds: list[str] = typer.Option([], help="Node kinds to export"),  # noqa: B008
     uuids: list[str] = typer.Option([], help="UUIDs of nodes to export"),  # noqa: B008
-    query_limit: int = typer.Option(1000, help="Maximum batch size of export query"),  # noqa: B008
+    query_limit: int = typer.Option(1000, help="Maximum batch size of export query"),
     export_dir: Path = typer.Option(Path("infrahub-exports"), help="Path of directory to save exports"),  # noqa: B008
     config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
 ) -> None:
@@ -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/gather.py

@@ -100,7 +100,9 @@ async def gather_python_transform_attributes(
     name="gather-trigger-computed-attribute-jinja2",
     cache_policy=NONE,
 )
-async def gather_trigger_computed_attribute_jinja2() -> list[ComputedAttrJinja2TriggerDefinition]:
+async def gather_trigger_computed_attribute_jinja2(
+    db: InfrahubDatabase | None = None,  # noqa: ARG001 Needed to have a common function signature for gathering functions
+) -> list[ComputedAttrJinja2TriggerDefinition]:
     log = get_run_logger()
 
     # Build a list of all branches to process based on which branch is different from main