infrahub-server 1.3.0b1__py3-none-any.whl → 1.3.0b3__py3-none-any.whl

infrahub/database/validation.py

@@ -0,0 +1,100 @@
+from infrahub.database import InfrahubDatabase
+
+
+async def verify_no_duplicate_relationships(db: InfrahubDatabase) -> None:
+    """
+    Verify that no duplicate active relationships exist at the database level
+    A duplicate is defined as
+    - connecting the same two nodes
+    - having the same identifier
+    - having the same direction (inbound, outbound, bidirectional)
+    - having the same branch
+    A more thorough check that no duplicates exist at any point in time is possible, but more complex
+    """
+    query = """
+MATCH (a:Node)-[e1:IS_RELATED {status: "active"}]-(rel:Relationship)-[e2:IS_RELATED {branch: e1.branch, status: "active"}]-(b:Node)
+WHERE a.uuid <> b.uuid
+AND e1.to IS NULL
+AND e2.to IS NULL
+WITH a, rel.name AS rel_name, b, e1.branch AS branch, CASE
+    WHEN startNode(e1) = a AND startNode(e2) = rel THEN "out"
+    WHEN startNode(e1) = rel AND startNode(e2) = b THEN "in"
+    ELSE "bidir"
+END AS direction, COUNT(*) AS num_duplicates
+WHERE num_duplicates > 1
+RETURN a.uuid AS node_id1, b.uuid AS node_id2, rel_name, branch, direction, num_duplicates
+    """
+    results = await db.execute_query(query=query)
+    for result in results:
+        node_id1 = result.get("node_id1")
+        node_id2 = result.get("node_id2")
+        rel_name = result.get("rel_name")
+        branch = result.get("branch")
+        direction = result.get("direction")
+        num_duplicates = result.get("num_duplicates")
+        raise ValueError(
+            f"{num_duplicates} duplicate relationships ({branch=},{direction=}) between nodes '{node_id1}' and '{node_id2}'"
+            f" with relationship name '{rel_name}'"
+        )
+
+
+async def verify_no_edges_added_after_node_delete(db: InfrahubDatabase) -> None:
+    """
+    Verify that no edges are added to a Node after it is deleted on a given branch
+    """
+    query = """
+// ------------
+// find deleted nodes
+// ------------
+MATCH (n:Node)-[e:IS_PART_OF]->(:Root)
+WHERE e.status = "deleted" OR e.to IS NOT NULL
+WITH DISTINCT n, e.branch AS delete_branch, e.branch_level AS delete_branch_level, CASE
+    WHEN e.status = "deleted" THEN e.from
+    ELSE e.to
+END AS delete_time
+// ------------
+// find the edges added to the deleted node after the delete time
+// ------------
+MATCH (n)-[added_e]-(peer)
+WHERE added_e.from > delete_time
+AND type(added_e) <> "IS_PART_OF"
+// if the node was deleted on a branch (delete_branch_level > 1), and then updated on main/global (added_e.branch_level = 1), we can ignore it
+AND added_e.branch_level >= delete_branch_level
+AND (added_e.branch = delete_branch OR delete_branch_level = 1)
+WITH DISTINCT n, delete_branch, delete_time, added_e, peer AS added_peer
+// ------------
+// get the branched_from for the branch on which the node was deleted
+// ------------
+CALL (added_e) {
+    MATCH (b:Branch {name: added_e.branch})
+    RETURN b.branched_from AS added_e_branched_from
+}
+// ------------
+// account for the following situations, given that the edge update time is after the node delete time
+//  - deleted on main/global, updated on branch
+//    - illegal if the delete is before branch.branched_from
+//  - deleted on branch, updated on branch
+//    - illegal
+// ------------
+WITH n, delete_branch, delete_time, added_e, added_peer
+WHERE delete_branch = added_e.branch
+OR delete_time < added_e_branched_from
+RETURN n.uuid AS n_uuid, delete_branch, delete_time, added_e, added_peer
+    """
+    results = await db.execute_query(query=query)
+    error_messages = []
+    for result in results:
+        n_uuid = result.get("n_uuid")
+        delete_branch = result.get("delete_branch")
+        delete_time = result.get("delete_time")
+        added_e = result.get("added_e")
+        added_e_branch = added_e.get("branch")
+        added_e_from = added_e.get("from")
+        added_peer = result.get("added_peer")
+        message = (
+            f"Node {n_uuid} was deleted on {delete_branch} at {delete_time} but has an {added_e.type} edge added on"
+            f" branch {added_e_branch} at {added_e_from} to {added_peer.element_id}"
+        )
+        error_messages.append(message)
+    if error_messages:
+        raise ValueError(error_messages)

infrahub/dependencies/builder/constraint/grouped/node_runner.py

@@ -4,6 +4,7 @@ from infrahub.dependencies.interface import DependencyBuilder, DependencyBuilder
 from ..node.grouped_uniqueness import NodeGroupedUniquenessConstraintDependency
 from ..relationship_manager.count import RelationshipCountConstraintDependency
 from ..relationship_manager.peer_kind import RelationshipPeerKindConstraintDependency
+from ..relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from ..relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
 
 
@@ -18,5 +19,6 @@ class NodeConstraintRunnerDependency(DependencyBuilder[NodeConstraintRunner]):
                 RelationshipPeerKindConstraintDependency.build(context=context),
                 RelationshipCountConstraintDependency.build(context=context),
                 RelationshipProfilesKindConstraintDependency.build(context=context),
+                RelationshipPeerRelativesConstraintDependency.build(context=context),
             ],
         )

infrahub/dependencies/builder/constraint/relationship_manager/peer_relatives.py

@@ -0,0 +1,8 @@
+from infrahub.core.relationship.constraints.peer_relatives import RelationshipPeerRelativesConstraint
+from infrahub.dependencies.interface import DependencyBuilder, DependencyBuilderContext
+
+
+class RelationshipPeerRelativesConstraintDependency(DependencyBuilder[RelationshipPeerRelativesConstraint]):
+    @classmethod
+    def build(cls, context: DependencyBuilderContext) -> RelationshipPeerRelativesConstraint:
+        return RelationshipPeerRelativesConstraint(db=context.db, branch=context.branch)

infrahub/dependencies/builder/diff/deserializer.py

@@ -6,5 +6,5 @@ from .parent_node_adder import DiffParentNodeAdderDependency
 
 class DiffDeserializerDependency(DependencyBuilder[EnrichedDiffDeserializer]):
     @classmethod
-    def build(cls, context: DependencyBuilderContext) -> EnrichedDiffDeserializer:  # noqa: ARG003
+    def build(cls, context: DependencyBuilderContext) -> EnrichedDiffDeserializer:
         return EnrichedDiffDeserializer(parent_adder=DiffParentNodeAdderDependency.build(context=context))

infrahub/dependencies/registry.py

@@ -3,6 +3,7 @@ from .builder.constraint.node.grouped_uniqueness import NodeGroupedUniquenessCon
 from .builder.constraint.node.uniqueness import NodeAttributeUniquenessConstraintDependency
 from .builder.constraint.relationship_manager.count import RelationshipCountConstraintDependency
 from .builder.constraint.relationship_manager.peer_kind import RelationshipPeerKindConstraintDependency
+from .builder.constraint.relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from .builder.constraint.relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
 from .builder.constraint.schema.aggregated import AggregatedSchemaConstraintsDependency
 from .builder.constraint.schema.attribute_regex import SchemaAttributeRegexConstraintDependency
@@ -37,6 +38,7 @@ def build_component_registry() -> ComponentDependencyRegistry:
     component_registry.track_dependency(RelationshipCountConstraintDependency)
     component_registry.track_dependency(RelationshipProfilesKindConstraintDependency)
     component_registry.track_dependency(RelationshipPeerKindConstraintDependency)
+    component_registry.track_dependency(RelationshipPeerRelativesConstraintDependency)
     component_registry.track_dependency(NodeConstraintRunnerDependency)
     component_registry.track_dependency(NodeDeleteValidatorDependency)
     component_registry.track_dependency(IpamKindsGetterDependency)

infrahub/events/models.py

@@ -8,7 +8,7 @@ from pydantic import BaseModel, Field, PrivateAttr, model_validator
 
 from infrahub import __version__
 from infrahub.auth import AccountSession, AuthType
-from infrahub.context import InfrahubContext  # noqa: TC001
+from infrahub.context import InfrahubContext
 from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.message_bus import InfrahubMessage, Meta
 from infrahub.worker import WORKER_IDENTITY

infrahub/graphql/mutations/main.py

@@ -382,7 +382,7 @@ class InfrahubMutationMixin:
         except HFIDViolatedError as exc:
             # Only the HFID constraint has been violated, it means the node exists and we can update without rerunning constraints
             if len(exc.matching_nodes_ids) > 1:
-                raise RuntimeError(f"Multiple {schema_name} nodes have the same hfid (database corrupted)") from exc
+                raise RuntimeError(f"Multiple {schema_name} nodes have the same hfid") from exc
             node_id = list(exc.matching_nodes_ids)[0]
             node = await NodeManager.get_one(db=db, id=node_id, kind=schema_name, branch=branch, raise_on_error=True)
             updated_obj, mutation = await cls._call_mutate_update(

infrahub/graphql/mutations/resource_manager.py

@@ -7,13 +7,14 @@ from graphene.types.generic import GenericScalar
 from typing_extensions import Self
 
 from infrahub.core import protocols, registry
-from infrahub.core.constants import InfrahubKind
+from infrahub.core.constants import InfrahubKind, NumberPoolType
 from infrahub.core.ipam.constants import PrefixMemberType
 from infrahub.core.manager import NodeManager
 from infrahub.core.schema import NodeSchema
 from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
 from infrahub.database import retry_db_transaction
 from infrahub.exceptions import QueryValidationError, SchemaNotFoundError, ValidationError
+from infrahub.pools.registration import get_branches_with_schema_number_pool
 
 from ..queries.resource_manager import PoolAllocatedNode
 from .main import DeleteResult, InfrahubMutationMixin, InfrahubMutationOptions
@@ -234,6 +235,14 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
             number_pool, result = await super().mutate_update(
                 info=info, data=data, branch=branch, database=dbt, node=node
             )
+
+            if number_pool.pool_type.value.value == NumberPoolType.SCHEMA.value and (  # type: ignore[attr-defined]
+                "start_range" in data.keys() or "end_range" in data.keys()
+            ):
+                raise ValidationError(
+                    input_value="start_range or end_range can't be updated on schema defined pools, update the schema in the default branch instead"
+                )
+
             if number_pool.start_range.value > number_pool.end_range.value:  # type: ignore[attr-defined]
                 raise ValidationError(input_value="start_range can't be larger than end_range")
 
@@ -257,18 +266,9 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
             branch=branch,
         )
 
-        active_branches = registry.schema.get_branches()
-        violating_branches = []
-        for active_branch in active_branches:
-            try:
-                schema = registry.schema.get(name=number_pool.node.value, branch=active_branch)
-            except SchemaNotFoundError:
-                continue
-
-            if number_pool.node_attribute.value in schema.attribute_names:
-                attribute = schema.get_attribute(name=number_pool.node_attribute.value)
-                if attribute.kind == "NumberPool":
-                    violating_branches.append(active_branch)
+        violating_branches = get_branches_with_schema_number_pool(
+            kind=number_pool.node.value, attribute_name=number_pool.node_attribute.value
+        )
 
         if violating_branches:
             raise ValidationError(

infrahub/graphql/resolvers/many_relationship.py

@@ -99,7 +99,7 @@ class ManyRelationshipResolver:
         filters = {
             f"{info.field_name}__{key}": value
             for key, value in kwargs.items()
-            if "__" in key and value or key in ["id", "ids"]
+            if ("__" in key and value) or key in ["id", "ids"]
         }
 
         response: dict[str, Any] = {"edges": [], "count": None}

infrahub/graphql/resolvers/resolver.py

@@ -99,7 +99,7 @@ async def default_resolver(*args: Any, **kwargs) -> dict | list[dict] | None:
     filters = {
         f"{info.field_name}__{key}": value
         for key, value in kwargs.items()
-        if "__" in key and value or key in ["id", "ids"]
+        if ("__" in key and value) or key in ["id", "ids"]
     }
 
     async with graphql_context.db.start_session(read_only=True) as db:
@@ -288,7 +288,7 @@ async def hierarchy_resolver(
     filters = {
         f"{info.field_name}__{key}": value
         for key, value in kwargs.items()
-        if "__" in key and value or key in ["id", "ids"]
+        if ("__" in key and value) or key in ["id", "ids"]
     }
 
     response: dict[str, Any] = {"edges": [], "count": None}

infrahub/graphql/resolvers/single_relationship.py

@@ -107,7 +107,7 @@ class SingleRelationshipResolver:
         filters = {
             f"{field_name}__{key}": value
             for key, value in kwargs.items()
-            if "__" in key and value or key in ["id", "ids"]
+            if ("__" in key and value) or key in ["id", "ids"]
         }
         async with db.start_session(read_only=True) as dbs:
             objs = await NodeManager.query_peers(

infrahub/menu/menu.py

@@ -57,7 +57,7 @@ default_menu = [
                 name="IPPrefix",
                 label="IP Prefixes",
                 kind=InfrahubKind.IPPREFIX,
-                path="/ipam/prefixes",
+                path="/ipam",
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.IPPREFIX)),
                 protected=True,
                 section=MenuSection.INTERNAL,
@@ -68,7 +68,7 @@ default_menu = [
                 name="IPAddress",
                 label="IP Addresses",
                 kind=InfrahubKind.IPPREFIX,
-                path="/ipam/addresses?ipam-tab=ip-details",
+                path="/ipam/ip_addresses",
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.IPADDRESS)),
                 protected=True,
                 section=MenuSection.INTERNAL,
@@ -79,6 +79,7 @@ default_menu = [
                 name="Namespaces",
                 label="Namespaces",
                 kind=InfrahubKind.IPNAMESPACE,
+                path="/ipam/namespaces",
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.IPNAMESPACE)),
                 protected=True,
                 section=MenuSection.INTERNAL,
@@ -256,7 +257,7 @@ default_menu = [
                 order_weight=6000,
                 children=[
                     MenuItemDefinition(
-                        namespace="Core",
+                        namespace="Builtin",
                         name="TriggerRule",
                         label="Rules",
                         kind=InfrahubKind.TRIGGERRULE,
@@ -266,7 +267,7 @@ default_menu = [
                         order_weight=1000,
                     ),
                     MenuItemDefinition(
-                        namespace="Core",
+                        namespace="Builtin",
                         name="Action",
                         label="Actions",
                         kind=InfrahubKind.ACTION,

infrahub/message_bus/operations/refresh/registry.py

@@ -26,6 +26,6 @@ async def rebased_branch(message: messages.RefreshRegistryRebasedBranch, service
 
     async with lock.registry.local_schema_lock():
         service.log.info("Refreshing rebased branch")
-        registry.branch[message.branch] = await registry.branch_object.get_by_name(
-            name=message.branch, db=service.database
-        )
+
+        async with service.database.start_session(read_only=True) as db:
+            registry.branch[message.branch] = await registry.branch_object.get_by_name(name=message.branch, db=db)

infrahub/patch/queries/delete_duplicated_edges.py

@@ -4,7 +4,7 @@ from .base import PatchQuery
 
 class DeleteDuplicatedEdgesPatchQuery(PatchQuery):
     """
-    Find duplicated or overlapping edges of the same status, type, and branch to update and delete
+    For all Node vertices, find duplicated or overlapping edges of the same status, type, and branch to update and delete
     - one edge will be kept for each pair of nodes and a given status, type, and branch. it will be
         updated to have the earliest "from" and "to" times in this group
     - all the other duplicate/overlapping edges will be deleted
@@ -17,9 +17,9 @@ class DeleteDuplicatedEdgesPatchQuery(PatchQuery):
     async def plan(self) -> PatchPlan:
         query = """
 // ------------
-// Find node pairs that have duplicate edges
+// Find vertex pairs that have duplicate edges
 // ------------
-MATCH (node_with_dup_edges:Node)-[edge]->(peer)
+MATCH (node_with_dup_edges:Node)-[edge]-(peer)
 WITH node_with_dup_edges, type(edge) AS edge_type, edge.status AS edge_status, edge.branch AS edge_branch, peer, count(*) AS num_dup_edges
 WHERE num_dup_edges > 1
 WITH DISTINCT node_with_dup_edges, edge_type, edge_branch, peer
@@ -27,12 +27,12 @@ CALL (node_with_dup_edges, edge_type, edge_branch, peer) {
     // ------------
     // Get the earliest active and deleted edges for this branch
     // ------------
-    MATCH (node_with_dup_edges)-[active_edge {branch: edge_branch, status: "active"}]->(peer)
+    OPTIONAL MATCH (node_with_dup_edges)-[active_edge {branch: edge_branch, status: "active"}]->(peer)
     WHERE type(active_edge) = edge_type
     WITH node_with_dup_edges, edge_type, edge_branch, peer, active_edge
     ORDER BY active_edge.from ASC
     WITH node_with_dup_edges, edge_type, edge_branch, peer, head(collect(active_edge.from)) AS active_from
-    OPTIONAL MATCH (node_with_dup_edges)-[deleted_edge {branch: edge_branch, status: "deleted"}]->(peer)
+    OPTIONAL MATCH (node_with_dup_edges)-[deleted_edge {branch: edge_branch, status: "deleted"}]-(peer)
     WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_edge
     ORDER BY deleted_edge.from ASC
     WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, head(collect(deleted_edge.from)) AS deleted_from
@@ -40,71 +40,82 @@ CALL (node_with_dup_edges, edge_type, edge_branch, peer) {
     // Plan one active edge update with correct from and to times
     // ------------
     CALL (node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_from) {
-        MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
+        OPTIONAL MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
         WHERE type(active_e) = edge_type
         WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_from, active_e
         ORDER BY %(id_func_name)s(active_e)
         LIMIT 1
         WITH active_e, properties(active_e) AS before_props, {from: active_from, to: deleted_from} AS prop_updates
-        RETURN [
-            {
-                db_id: %(id_func_name)s(active_e), before_props: before_props, prop_updates: prop_updates
-            }
-        ] AS active_edges_to_update
+        RETURN CASE
+            WHEN active_e IS NOT NULL THEN [
+                {
+                    db_id: %(id_func_name)s(active_e), before_props: before_props, prop_updates: prop_updates
+                }
+            ]
+            ELSE []
+        END AS active_edges_to_update
     }
     // ------------
     // Plan deletes for all the other active edges of this type on this branch
     // ------------
     CALL (node_with_dup_edges, edge_type, edge_branch, peer) {
-        MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
+        OPTIONAL MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
         WHERE type(active_e) = edge_type
         WITH node_with_dup_edges, peer, active_e
         ORDER BY %(id_func_name)s(active_e)
         SKIP 1
-        RETURN collect(
-            {
+        WITH CASE
+            WHEN active_e IS NOT NULL THEN {
                 db_id: %(id_func_name)s(active_e),
-                from_id: %(id_func_name)s(node_with_dup_edges),
-                to_id: %(id_func_name)s(peer),
+                from_id: %(id_func_name)s(startNode(active_e)),
+                to_id: %(id_func_name)s(endNode(active_e)),
                 edge_type: type(active_e),
                 before_props: properties(active_e)
             }
-        ) AS active_edges_to_delete
+            ELSE NULL
+        END AS serialized_edge
+        RETURN collect(serialized_edge) AS active_edges_to_delete
     }
     // ------------
     // Plan one deleted edge update with correct from time
     // ------------
     CALL (node_with_dup_edges, edge_type, edge_branch, peer, deleted_from) {
-        MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
+        OPTIONAL MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
         WHERE type(deleted_e) = edge_type
         WITH node_with_dup_edges, edge_type, edge_branch, peer, deleted_from, deleted_e
         ORDER BY %(id_func_name)s(deleted_e)
         LIMIT 1
         WITH deleted_e, properties(deleted_e) AS before_props, {from: deleted_from} AS prop_updates
-        RETURN [
-            {
-                db_id: %(id_func_name)s(deleted_e), before_props: before_props, prop_updates: prop_updates
-            }
-        ] AS deleted_edges_to_update
+        RETURN CASE
+            WHEN deleted_e IS NOT NULL THEN [
+                {
+                    db_id: %(id_func_name)s(deleted_e), before_props: before_props, prop_updates: prop_updates
+                }
+            ]
+            ELSE []
+        END AS deleted_edges_to_update
     }
     // ------------
     // Plan deletes for all the other deleted edges of this type on this branch
     // ------------
     CALL (node_with_dup_edges, edge_type, edge_branch, peer) {
-        MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
+        OPTIONAL MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
         WHERE type(deleted_e) = edge_type
         WITH node_with_dup_edges, peer, deleted_e
         ORDER BY %(id_func_name)s(deleted_e)
         SKIP 1
-        RETURN collect(
-            {
+        WITH CASE
+            WHEN deleted_e IS NOT NULL THEN {
                 db_id: %(id_func_name)s(deleted_e),
-                from_id: %(id_func_name)s(node_with_dup_edges),
-                to_id: %(id_func_name)s(peer),
+                from_id: %(id_func_name)s(startNode(deleted_e)),
+                to_id: %(id_func_name)s(endNode(deleted_e)),
                 edge_type: type(deleted_e),
                 before_props: properties(deleted_e)
             }
-        ) AS deleted_edges_to_delete
+            ELSE NULL
+        END AS serialized_edge
+
+        RETURN collect(serialized_edge) AS deleted_edges_to_delete
     }
     RETURN
         active_edges_to_update + deleted_edges_to_update AS edges_to_update,

infrahub/pools/registration.py

@@ -0,0 +1,22 @@
+from infrahub.core.registry import registry
+from infrahub.exceptions import SchemaNotFoundError
+
+
+def get_branches_with_schema_number_pool(kind: str, attribute_name: str) -> list[str]:
+    """Return branches where schema defined NumberPool exists"""
+
+    registered_branches = []
+    active_branches = registry.schema.get_branches()
+
+    for active_branch in active_branches:
+        try:
+            schema = registry.schema.get(name=kind, branch=active_branch)
+        except SchemaNotFoundError:
+            continue
+
+        if attribute_name in schema.attribute_names:
+            attribute = schema.get_attribute(name=attribute_name)
+            if attribute.kind == "NumberPool":
+                registered_branches.append(active_branch)
+
+    return registered_branches

infrahub/pools/tasks.py

@@ -0,0 +1,56 @@
+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.constants import NumberPoolType
+from infrahub.core.manager import NodeManager
+from infrahub.core.protocols import CoreNumberPool
+from infrahub.core.registry import registry
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
+from infrahub.pools.registration import get_branches_with_schema_number_pool
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+
+
+@flow(
+    name="validate-schema-number-pools",
+    flow_run_name="Validate schema number pools on {branch_name}",
+)
+async def validate_schema_number_pools(
+    branch_name: str,  # noqa: ARG001
+    context: InfrahubContext,  # noqa: ARG001
+    service: InfrahubServices,
+) -> None:
+    log = get_run_logger()
+
+    async with service.database.start_session() as dbs:
+        schema_number_pools = await NodeManager.query(
+            db=dbs, schema=CoreNumberPool, filters={"pool_type__value": NumberPoolType.SCHEMA.value}
+        )
+
+    for schema_number_pool in list(schema_number_pools):
+        defined_on_branches = get_branches_with_schema_number_pool(
+            kind=schema_number_pool.node.value, attribute_name=schema_number_pool.node_attribute.value
+        )
+        if registry.default_branch in defined_on_branches:
+            schema = registry.schema.get(name=schema_number_pool.node.value, branch=registry.default_branch)
+            attribute = schema.get_attribute(name=schema_number_pool.node_attribute.value)
+            number_pool_updated = False
+            if isinstance(attribute.parameters, NumberPoolParameters):
+                if schema_number_pool.start_range.value != attribute.parameters.start_range:
+                    schema_number_pool.start_range.value = attribute.parameters.start_range
+                    number_pool_updated = True
+                if schema_number_pool.end_range.value != attribute.parameters.end_range:
+                    schema_number_pool.end_range.value = attribute.parameters.end_range
+                    number_pool_updated = True
+
+            if number_pool_updated:
+                log.info(
+                    f"Updating NumberPool={schema_number_pool.id} based on changes in the schema on {registry.default_branch}"
+                )
+                await schema_number_pool.save(db=service.database)
+
+        elif not defined_on_branches:
+            log.info(f"Deleting number pool (id={schema_number_pool.id}) as it is no longer defined in the schema")
+            await schema_number_pool.delete(db=service.database)

infrahub/proposed_change/tasks.py

@@ -254,12 +254,12 @@ async def run_proposed_change_data_integrity_check(
     """Triggers a data integrity validation check on the provided proposed change to start."""
     await add_tags(branches=[model.source_branch], nodes=[model.proposed_change])
 
-    async with service.database.start_transaction() as dbt:
-        destination_branch = await registry.get_branch(db=dbt, branch=model.destination_branch)
-        source_branch = await registry.get_branch(db=dbt, branch=model.source_branch)
+    async with service.database.start_session() as dbs:
+        destination_branch = await registry.get_branch(db=dbs, branch=model.destination_branch)
+        source_branch = await registry.get_branch(db=dbs, branch=model.source_branch)
         component_registry = get_component_registry()
 
-        diff_coordinator = await component_registry.get_component(DiffCoordinator, db=dbt, branch=source_branch)
+        diff_coordinator = await component_registry.get_component(DiffCoordinator, db=dbs, branch=source_branch)
         await diff_coordinator.update_branch_diff(base_branch=destination_branch, diff_branch=source_branch)
 
 
@@ -1006,11 +1006,11 @@ async def run_proposed_change_pipeline(
 
     await _gather_repository_repository_diffs(repositories=repositories, service=service)
 
-    async with service.database.start_transaction() as dbt:
-        destination_branch = await registry.get_branch(db=dbt, branch=model.destination_branch)
-        source_branch = await registry.get_branch(db=dbt, branch=model.source_branch)
+    async with service.database.start_session() as dbs:
+        destination_branch = await registry.get_branch(db=dbs, branch=model.destination_branch)
+        source_branch = await registry.get_branch(db=dbs, branch=model.source_branch)
         component_registry = get_component_registry()
-        diff_coordinator = await component_registry.get_component(DiffCoordinator, db=dbt, branch=source_branch)
+        diff_coordinator = await component_registry.get_component(DiffCoordinator, db=dbs, branch=source_branch)
         await diff_coordinator.update_branch_diff(base_branch=destination_branch, diff_branch=source_branch)
 
     diff_summary = await service.client.get_diff_summary(branch=model.source_branch)

infrahub/schema/tasks.py

@@ -0,0 +1,27 @@
+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.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="schema-updated",
+    flow_run_name="Running actions after the schema was updated on '{branch_name}'",
+)
+async def schema_updated(
+    branch_name: str,
+    schema_hash: str,  # noqa: ARG001
+    context: InfrahubContext,
+    service: InfrahubServices,
+) -> None:
+    log = get_run_logger()
+    await wait_for_schema_to_converge(
+        branch_name=branch_name, component=service.component, db=service.database, log=log
+    )
+
+    await validate_schema_number_pools(branch_name=branch_name, context=context, service=service)

infrahub/schema/triggers.py

@@ -0,0 +1,23 @@
+from infrahub.events.schema_action import SchemaUpdatedEvent
+from infrahub.trigger.models import BuiltinTriggerDefinition, EventTrigger, ExecuteWorkflow
+from infrahub.workflows.catalogue import SCHEMA_UPDATED
+
+TRIGGER_SCHEMA_UPDATED = BuiltinTriggerDefinition(
+    name="schema-updated-trigger",
+    trigger=EventTrigger(
+        events={SchemaUpdatedEvent.event_name},
+    ),
+    actions=[
+        ExecuteWorkflow(
+            workflow=SCHEMA_UPDATED,
+            parameters={
+                "branch_name": "{{ event.payload['data']['branch_name'] }}",
+                "schema_hash": "{{ event.payload['data']['schema_hash'] }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        ),
+    ],
+)

infrahub/trigger/catalogue.py

@@ -1,15 +1,19 @@
 from infrahub.actions.triggers import TRIGGER_ACTION_RULE_UPDATE
+from infrahub.branch.triggers import TRIGGER_BRANCH_MERGED
 from infrahub.computed_attribute.triggers import (
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
 )
+from infrahub.schema.triggers import TRIGGER_SCHEMA_UPDATED
 from infrahub.trigger.models import TriggerDefinition
 from infrahub.webhook.triggers import TRIGGER_WEBHOOK_DELETE, TRIGGER_WEBHOOK_SETUP_UPDATE
 
 builtin_triggers: list[TriggerDefinition] = [
     TRIGGER_ACTION_RULE_UPDATE,
+    TRIGGER_BRANCH_MERGED,
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
+    TRIGGER_SCHEMA_UPDATED,
     TRIGGER_WEBHOOK_DELETE,
     TRIGGER_WEBHOOK_SETUP_UPDATE,
 ]