infrahub-server 1.3.0b6__py3-none-any.whl → 1.3.2__py3-none-any.whl

infrahub/core/validators/uniqueness/query.py

@@ -5,10 +5,12 @@ from typing import TYPE_CHECKING, Any
 from infrahub.core.constants.relationship_label import RELATIONSHIP_TO_VALUE_LABEL
 from infrahub.core.query import Query, QueryType
 
+from .model import QueryAttributePathValued, QueryRelationshipPathValued
+
 if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
-    from .model import NodeUniquenessQueryRequest
+    from .model import NodeUniquenessQueryRequest, NodeUniquenessQueryRequestValued
 
 
 class NodeUniqueAttributeConstraintQuery(Query):
@@ -244,3 +246,212 @@ class NodeUniqueAttributeConstraintQuery(Query):
             "attr_value",
             "relationship_identifier",
         ]
+
+
+class UniquenessValidationQuery(Query):
+    name = "uniqueness_constraint_validation"
+    type = QueryType.READ
+
+    def __init__(
+        self,
+        query_request: NodeUniquenessQueryRequestValued,
+        node_ids_to_exclude: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        self.query_request = query_request
+        self.node_ids_to_exclude = node_ids_to_exclude
+        super().__init__(**kwargs)
+
+    def _build_attr_subquery(
+        self, node_kind: str, attr_path: QueryAttributePathValued, index: int, branch_filter: str, is_first_query: bool
+    ) -> tuple[str, dict[str, str | int | float | bool]]:
+        attr_name_var = f"attr_name_{index}"
+        attr_value_var = f"attr_value_{index}"
+        if is_first_query:
+            first_query_filter = "WHERE $node_ids_to_exclude IS NULL OR NOT node.uuid IN $node_ids_to_exclude"
+        else:
+            first_query_filter = ""
+        attribute_query = """
+MATCH (node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})
+%(first_query_filter)s
+WITH DISTINCT node
+CALL (node) {
+    MATCH (node)-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})
+    WHERE %(branch_filter)s
+    WITH attr, r.status = "active" AS is_active
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    WITH attr, is_active
+    LIMIT 1
+    WITH attr, is_active
+    WHERE is_active = TRUE
+    MATCH (attr)-[r:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})
+    WHERE %(branch_filter)s
+    WITH r
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    LIMIT 1
+    WITH r
+    WHERE r.status = "active"
+    RETURN 1 AS is_match_%(index)s
+}
+        """ % {
+            "first_query_filter": first_query_filter,
+            "node_kind": node_kind,
+            "attr_name_var": attr_name_var,
+            "attr_value_var": attr_value_var,
+            "branch_filter": branch_filter,
+            "index": index,
+        }
+        params: dict[str, str | int | float | bool] = {
+            attr_name_var: attr_path.attribute_name,
+            attr_value_var: attr_path.value,
+        }
+        return attribute_query, params
+
+    def _build_rel_subquery(
+        self,
+        node_kind: str,
+        rel_path: QueryRelationshipPathValued,
+        index: int,
+        branch_filter: str,
+        is_first_query: bool,
+    ) -> tuple[str, dict[str, str | int | float | bool]]:
+        params: dict[str, str | int | float | bool] = {}
+        rel_attr_query = ""
+        rel_attr_match = ""
+        if rel_path.attribute_name and rel_path.attribute_value:
+            attr_name_var = f"attr_name_{index}"
+            attr_value_var = f"attr_value_{index}"
+            rel_attr_query = """
+    MATCH (peer)-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})
+    WHERE %(branch_filter)s
+    WITH attr, r.status = "active" AS is_active
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    WITH attr, is_active
+    LIMIT 1
+    WITH attr, is_active
+    WHERE is_active = TRUE
+    MATCH (attr)-[r:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})
+    WHERE %(branch_filter)s
+    WITH r
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    LIMIT 1
+    WITH r
+    WHERE r.status = "active"
+            """ % {"attr_name_var": attr_name_var, "attr_value_var": attr_value_var, "branch_filter": branch_filter}
+            rel_attr_match = (
+                "-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})"
+                % {
+                    "attr_name_var": attr_name_var,
+                    "attr_value_var": attr_value_var,
+                }
+            )
+            params[attr_name_var] = rel_path.attribute_name
+            params[attr_value_var] = rel_path.attribute_value
+        query_arrows = rel_path.relationship_schema.get_query_arrows()
+        rel_name_var = f"rel_name_{index}"
+        # long path MATCH is required to hit an index on the peer or AttributeValue of the peer
+        first_match = (
+            "MATCH (node:%(node_kind)s)%(lstart)s[:IS_RELATED]%(lend)s(:Relationship {name: $%(rel_name_var)s})%(rstart)s[:IS_RELATED]%(rend)s"
+            % {
+                "node_kind": node_kind,
+                "lstart": query_arrows.left.start,
+                "lend": query_arrows.left.end,
+                "rstart": query_arrows.right.start,
+                "rend": query_arrows.right.end,
+                "rel_name_var": rel_name_var,
+            }
+        )
+        peer_where = f"WHERE {branch_filter}"
+        if rel_path.peer_id:
+            peer_id_var = f"peer_id_{index}"
+            peer_where += f" AND peer.uuid = ${peer_id_var}"
+            params[peer_id_var] = rel_path.peer_id
+            first_match += "(:Node {uuid: $%(peer_id_var)s})" % {"peer_id_var": peer_id_var}
+        else:
+            peer_where += " AND peer.uuid <> node.uuid"
+            first_match += "(:Node)"
+        if rel_attr_match:
+            first_match += rel_attr_match
+        if is_first_query:
+            first_query_filter = "WHERE $node_ids_to_exclude IS NULL OR NOT node.uuid IN $node_ids_to_exclude"
+        else:
+            first_query_filter = ""
+        relationship_query = f"""
+{first_match}
+{first_query_filter}
+WITH DISTINCT node
+        """
+        relationship_query += """
+CALL (node) {
+    MATCH (node)%(lstart)s[r:IS_RELATED]%(lend)s(rel:Relationship {name: $%(rel_name_var)s})
+    WHERE %(branch_filter)s
+    WITH rel, r.status = "active" AS is_active
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    WITH rel, is_active
+    LIMIT 1
+    WITH rel, is_active
+    WHERE is_active = TRUE
+    MATCH (rel)%(rstart)s[r:IS_RELATED]%(rend)s(peer:Node)
+    %(peer_where)s
+    WITH peer, r.status = "active" AS is_active
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    WITH peer, is_active
+    LIMIT 1
+    WITH peer, is_active
+    WHERE is_active = TRUE
+%(rel_attr_query)s
+    RETURN 1 AS is_match_%(index)s
+    LIMIT 1
+}
+        """ % {
+            "rel_name_var": rel_name_var,
+            "lstart": query_arrows.left.start,
+            "lend": query_arrows.left.end,
+            "rstart": query_arrows.right.start,
+            "rend": query_arrows.right.end,
+            "peer_where": peer_where,
+            "rel_attr_query": rel_attr_query,
+            "branch_filter": branch_filter,
+            "index": index,
+        }
+        params[rel_name_var] = rel_path.relationship_schema.get_identifier()
+        return relationship_query, params
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        self.params["node_ids_to_exclude"] = self.node_ids_to_exclude
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string(), is_isolated=False)
+        self.params.update(branch_params)
+
+        subqueries = []
+        for index, schema_path in enumerate(self.query_request.unique_valued_paths):
+            is_first_query = index == 0
+            if isinstance(schema_path, QueryAttributePathValued):
+                subquery, params = self._build_attr_subquery(
+                    node_kind=self.query_request.kind,
+                    attr_path=schema_path,
+                    index=index,
+                    branch_filter=branch_filter,
+                    is_first_query=is_first_query,
+                )
+            else:
+                subquery, params = self._build_rel_subquery(
+                    node_kind=self.query_request.kind,
+                    rel_path=schema_path,
+                    index=index,
+                    branch_filter=branch_filter,
+                    is_first_query=is_first_query,
+                )
+            subqueries.append(subquery)
+            self.params.update(params)
+
+        full_query = "\n".join(subqueries)
+        self.add_to_query(full_query)
+        self.return_labels = ["node.uuid AS node_uuid", "node.kind AS node_kind"]
+
+    def get_violation_nodes(self) -> list[tuple[str, str]]:
+        violation_tuples = []
+        for result in self.results:
+            violation_tuples.append(
+                (result.get_as_type("node_uuid", return_type=str), result.get_as_type("node_kind", return_type=str))
+            )
+        return violation_tuples

infrahub/graphql/app.py

@@ -88,6 +88,8 @@ GQL_STOP = "stop"
 ContextValue = Any | Callable[[HTTPConnection], Any]
 RootValue = Any
 
+subscription_tasks = set()
+
 
 class InfrahubGraphQLApp:
     def __init__(
@@ -446,7 +448,9 @@ class InfrahubGraphQLApp:
 
         asyncgen = cast(AsyncGenerator[Any, None], result)
         subscriptions[operation_id] = asyncgen
-        asyncio.create_task(self._observe_subscription(asyncgen, operation_id, websocket))
+        task = asyncio.create_task(self._observe_subscription(asyncgen, operation_id, websocket))
+        subscription_tasks.add(task)
+        task.add_done_callback(subscription_tasks.discard)
         return []
 
     async def _observe_subscription(

infrahub/graphql/mutations/main.py

@@ -25,7 +25,7 @@ from infrahub.core.timestamp import Timestamp
 from infrahub.database import retry_db_transaction
 from infrahub.dependencies.registry import get_component_registry
 from infrahub.events.generator import generate_node_mutation_events
-from infrahub.exceptions import HFIDViolatedError, InitializationError
+from infrahub.exceptions import HFIDViolatedError, InitializationError, NodeNotFoundError
 from infrahub.graphql.context import apply_external_context
 from infrahub.lock import InfrahubMultiLock, build_object_lock_name
 from infrahub.log import get_log_data, get_logger
@@ -384,7 +384,23 @@ class InfrahubMutationMixin:
             if len(exc.matching_nodes_ids) > 1:
                 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)
+
+            try:
+                node = await NodeManager.get_one(
+                    db=db, id=node_id, kind=schema_name, branch=branch, raise_on_error=True
+                )
+            except NodeNotFoundError as exc:
+                if branch.is_default:
+                    raise
+                raise NodeNotFoundError(
+                    node_type=exc.node_type,
+                    identifier=exc.identifier,
+                    branch_name=branch.name,
+                    message=(
+                        f"Node {exc.identifier} / {exc.node_type} uses this human-friendly ID, but does not exist on"
+                        f" this branch. Please rebase this branch to access {exc.identifier} / {exc.node_type}"
+                    ),
+                ) from exc
             updated_obj, mutation = await cls._call_mutate_update(
                 info=info,
                 data=data,

infrahub/services/adapters/message_bus/nats.py

@@ -26,6 +26,8 @@ if TYPE_CHECKING:
 MessageFunction = Callable[[InfrahubMessage], Awaitable[None]]
 ResponseClass = TypeVar("ResponseClass")
 
+publish_tasks = set()
+
 
 async def _add_request_id(message: InfrahubMessage) -> None:
     log_data = get_log_data()
@@ -223,7 +225,9 @@ class NATSMessageBus(InfrahubMessageBus):
                     # Delayed retries are directly handled in the callback using Nack
                     return
                 # Use asyncio task for delayed publish since NATS does not support that out of the box
-                asyncio.create_task(self._publish_with_delay(message, routing_key, delay))
+                task = asyncio.create_task(self._publish_with_delay(message, routing_key, delay))
+                publish_tasks.add(task)
+                task.add_done_callback(publish_tasks.discard)
                 return
 
             for enricher in self.message_enrichers:

infrahub/services/scheduler.py

@@ -16,6 +16,8 @@ if TYPE_CHECKING:
 
 log = get_logger()
 
+background_tasks = set()
+
 
 @dataclass
 class Schedule:
@@ -56,7 +58,9 @@ class InfrahubScheduler:
 
     async def start_schedule(self) -> None:
         for schedule in self.schedules:
-            asyncio.create_task(self.run_schedule(schedule=schedule), name=f"scheduled_task_{schedule.name}")
+            task = asyncio.create_task(self.run_schedule(schedule=schedule), name=f"scheduled_task_{schedule.name}")
+            background_tasks.add(task)
+            task.add_done_callback(background_tasks.discard)
 
     async def shutdown(self) -> None:
         self.running = False

infrahub_sdk/node/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from .attribute import Attribute
 from .constants import (
     ARTIFACT_DEFINITION_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE,
     ARTIFACT_FETCH_FEATURE_NOT_SUPPORTED_MESSAGE,
@@ -25,6 +26,7 @@ __all__ = [
     "PROPERTIES_FLAG",
     "PROPERTIES_OBJECT",
     "SAFE_VALUE",
+    "Attribute",
     "InfrahubNode",
     "InfrahubNodeBase",
     "InfrahubNodeSync",

infrahub_sdk/node/node.py

@@ -501,11 +501,27 @@ class InfrahubNode(InfrahubNodeBase):
 
         return cls(client=client, schema=schema, branch=branch, data=cls._strip_alias(data))
 
-    def _init_relationships(self, data: dict | None = None) -> None:
+    def _init_relationships(self, data: dict | RelatedNode | None = None) -> None:
         for rel_schema in self._schema.relationships:
             rel_data = data.get(rel_schema.name, None) if isinstance(data, dict) else None
 
             if rel_schema.cardinality == "one":
+                if isinstance(rel_data, RelatedNode):
+                    peer_id_data: dict[str, Any] = {
+                        key: value
+                        for key, value in (
+                            ("id", rel_data.id),
+                            ("hfid", rel_data.hfid),
+                            ("__typename", rel_data.typename),
+                            ("kind", rel_data.kind),
+                            ("display_label", rel_data.display_label),
+                        )
+                        if value is not None
+                    }
+                    if peer_id_data:
+                        rel_data = peer_id_data
+                    else:
+                        rel_data = None
                 self._relationship_cardinality_one_data[rel_schema.name] = RelatedNode(
                     name=rel_schema.name, branch=self._branch, client=self._client, schema=rel_schema, data=rel_data
                 )
@@ -1079,10 +1095,25 @@ class InfrahubNodeSync(InfrahubNodeBase):
             rel_data = data.get(rel_schema.name, None) if isinstance(data, dict) else None
 
             if rel_schema.cardinality == "one":
+                if isinstance(rel_data, RelatedNodeSync):
+                    peer_id_data: dict[str, Any] = {
+                        key: value
+                        for key, value in (
+                            ("id", rel_data.id),
+                            ("hfid", rel_data.hfid),
+                            ("__typename", rel_data.typename),
+                            ("kind", rel_data.kind),
+                            ("display_label", rel_data.display_label),
+                        )
+                        if value is not None
+                    }
+                    if peer_id_data:
+                        rel_data = peer_id_data
+                    else:
+                        rel_data = None
                 self._relationship_cardinality_one_data[rel_schema.name] = RelatedNodeSync(
                     name=rel_schema.name, branch=self._branch, client=self._client, schema=rel_schema, data=rel_data
                 )
-
             else:
                 self._relationship_cardinality_many_data[rel_schema.name] = RelationshipManagerSync(
                     name=rel_schema.name,

infrahub_sdk/node/related_node.py

@@ -39,6 +39,7 @@ class RelatedNodeBase:
         self._hfid: list[str] | None = None
         self._display_label: str | None = None
         self._typename: str | None = None
+        self._kind: str | None = None
 
         if isinstance(data, (CoreNodeBase)):
             self._peer = data
@@ -118,6 +119,12 @@ class RelatedNodeBase:
             return self._peer.typename
         return self._typename
 
+    @property
+    def kind(self) -> str | None:
+        if self._peer:
+            return self._peer.get_kind()
+        return self._kind
+
     def _generate_input_data(self, allocate_from_pool: bool = False) -> dict[str, Any]:
         data: dict[str, Any] = {}
 

{infrahub_server-1.3.0b6.dist-info → infrahub_server-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.3.0b6
+Version: 1.3.2
 Summary: Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.
 License: AGPL-3.0-only
 Author: OpsMill