infrahub-server 1.3.4__tar.gz → 1.3.5__tar.gz

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.3.4
+Version: 1.3.5
 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: Apache-2.0
 Author: OpsMill

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/backend/infrahub/cli/db.py

@@ -916,5 +916,39 @@ async def run_database_checks(db: InfrahubDatabase, output_dir: Path) -> None:
     else:
         rprint(f"{SUCCESS_BADGE} No duplicated edges found")
 
+    # Check 4: Orphaned Relationships
+    rprint("\n[bold cyan]Check 4: Orphaned Relationships[/bold cyan]")
+    orphaned_rels_query = """
+    MATCH (r:Relationship)-[:IS_RELATED]-(peer:Node)
+    WITH DISTINCT r, peer
+    WITH r, count(*) AS num_peers
+    WHERE num_peers < 2
+    MATCH (r)-[e:IS_RELATED]-(peer:Node)
+    RETURN DISTINCT
+        r.name AS r_name,
+        e.branch AS branch,
+        e.status AS status,
+        e.from AS from_time,
+        e.to AS to_time,
+        peer.uuid AS peer_uuid,
+        peer.kind AS peer_kind
+    """
+    results = await db.execute_query(query=orphaned_rels_query)
+    if results:
+        rprint(f"[red]Found {len(results)} orphaned Relationships[/red]")
+        # Write detailed results to file
+        output_file = output_dir / "orphaned_relationships.csv"
+        with output_file.open(mode="w", newline="") as f:
+            writer = DictWriter(
+                f,
+                fieldnames=["r_name", "branch", "status", "from_time", "to_time", "peer_uuid", "peer_kind"],
+            )
+            writer.writeheader()
+            for result in results:
+                writer.writerow(dict(result))
+        rprint(f"  Detailed results written to: {output_file}")
+    else:
+        rprint(f"{SUCCESS_BADGE} No orphaned relationships found")
+
     rprint(f"\n{SUCCESS_BADGE} Database health checks completed")
     rprint(f"Detailed results saved to: {output_dir.absolute()}")

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/backend/infrahub/core/migrations/query/node_duplicate.py

@@ -37,9 +37,11 @@ class NodeDuplicateQuery(Query):
         super().__init__(**kwargs)
 
     def render_match(self) -> str:
+        labels_str = ":".join(self.previous_node.labels)
         query = f"""
         // Find all the active nodes
-        MATCH (node:{self.previous_node.kind})
+        MATCH (node:{labels_str})
+        WITH DISTINCT node
         """
 
         return query
@@ -145,6 +147,7 @@ class NodeDuplicateQuery(Query):
         WITH active_node, new_node
         // Process Outbound Relationship
         MATCH (active_node)-[]->(peer)
+        WITH DISTINCT active_node, new_node, peer
         CALL (active_node, peer) {
             MATCH (active_node)-[r]->(peer)
             WHERE %(branch_filter)s
@@ -164,6 +167,7 @@ class NodeDuplicateQuery(Query):
         WITH DISTINCT active_node, new_node
         // Process Inbound Relationship
         MATCH (active_node)<-[]-(peer)
+        WITH DISTINCT active_node, new_node, peer
         CALL (active_node, peer) {
             MATCH (active_node)<-[r]-(peer)
             WHERE %(branch_filter)s

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/backend/infrahub/core/query/diff.py

@@ -148,7 +148,14 @@ CALL (diff_path) {
         OR type(base_r_node) <> "IS_RELATED" OR type(base_r_prop) <> "IS_RELATED"
     )
     WITH latest_base_path, base_r_root, base_r_node, base_r_prop
-    ORDER BY base_r_prop.from DESC, base_r_node.from DESC, base_r_root.from DESC
+    // status="active" ordering is for tie-breaking edges added and deleted at the same time, we want the active one
+    ORDER BY
+        base_r_prop.from DESC,
+        base_r_prop.status = "active" DESC,
+        base_r_node.from DESC,
+        base_r_node.status = "active" DESC,
+        base_r_root.from DESC,
+        base_r_root.status = "active" DESC
     LIMIT 1
     RETURN latest_base_path
 }
@@ -172,8 +179,6 @@ CALL (penultimate_path) {
     AND %(id_func)s(peer_r_node) = %(id_func)s(r_node)
     AND [%(id_func)s(n), type(peer_r_node)] <> [%(id_func)s(peer), type(r_peer)]
     AND r_peer.from < $to_time
-    // filter out paths where an earlier from time follows a later from time
-    AND peer_r_node.from <= r_peer.from
     // filter out paths where a base branch edge follows a branch edge
     AND (peer_r_node.branch = $base_branch_name OR r_peer.branch = $branch_name)
     // filter out paths where an active edge follows a deleted edge
@@ -663,6 +668,15 @@ AND ALL(
     AND ((r_pair[0]).status = "active" OR (r_pair[1]).status = "deleted")
     // filter out paths where an earlier from time follows a later from time
     AND (r_pair[0]).from <= (r_pair[1]).from
+    // if both are deleted, then the deeper edge must have been deleted first
+    AND ((r_pair[0]).status = "active" OR (r_pair[1]).status = "active" OR (r_pair[0]).from >= (r_pair[1].from))
+    AND (
+        (r_pair[0]).status = (r_pair[1]).status
+        OR (
+            (r_pair[0]).from <= (r_pair[1]).from
+            AND ((r_pair[0]).to IS NULL OR (r_pair[0]).to >= (r_pair[1]).from)
+        )
+    )
     // require adjacent edge pairs to have overlapping times, but only if on the same branch
     AND (
         (r_pair[0]).branch <> (r_pair[1]).branch

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/backend/infrahub/core/query/relationship.py

@@ -643,12 +643,9 @@ class RelationshipGetPeerQuery(Query):
 
         arrows = self.schema.get_query_arrows()
 
-        path_str = (
-            f"{arrows.left.start}[:IS_RELATED]{arrows.left.end}(rl){arrows.right.start}[:IS_RELATED]{arrows.right.end}"
-        )
+        path_str = f"{arrows.left.start}[r1:IS_RELATED]{arrows.left.end}(rl){arrows.right.start}[r2:IS_RELATED]{arrows.right.end}"
 
         branch_level_str = "reduce(br_lvl = 0, r in relationships(path) | br_lvl + r.branch_level)"
-        froms_str = db.render_list_comprehension(items="relationships(path)", item_name="from")
         query = """
         MATCH (source_node:Node)%(arrow_left_start)s[:IS_RELATED]%(arrow_left_end)s(rl:Relationship { name: $rel_identifier })
         WHERE source_node.uuid IN $source_ids
@@ -659,24 +656,24 @@ class RelationshipGetPeerQuery(Query):
                 $source_kind IN LABELS(source_node) AND
                 peer.uuid <> source_node.uuid AND
                 $peer_kind IN LABELS(peer) AND
-                all(r IN relationships(path) WHERE (%(branch_filter)s))
-            WITH source_node, peer, rl, relationships(path) as rels, %(branch_level)s AS branch_level, %(froms)s AS froms
-            RETURN peer as peer, rels, rl as rl1
-            ORDER BY branch_level DESC, froms[-1] DESC, froms[-2] DESC
+                all(r IN [r1, r2] WHERE (%(branch_filter)s))
+            WITH source_node, peer, rl, r1, r2, %(branch_level)s AS branch_level
+            RETURN peer as peer, r1.status = "active" AND r2.status = "active" AS is_active, [r1, r2] AS rels
+            // status is required as a tiebreaker for migrated-kind nodes
+            ORDER BY branch_level DESC, r2.from DESC, r2.status ASC, r1.from DESC, r1.status ASC
             LIMIT 1
         }
-        WITH peer, rl1 as rl, rels, source_node
+        WITH peer, rl, is_active, rels, source_node
         """ % {
             "path": path_str,
             "branch_filter": branch_filter,
             "branch_level": branch_level_str,
-            "froms": froms_str,
             "arrow_left_start": arrows.left.start,
             "arrow_left_end": arrows.left.end,
         }
 
         self.add_to_query(query)
-        where_clause = ['all(r IN rels WHERE r.status = "active")']
+        where_clause = ["is_active = TRUE"]
         clean_filters = extract_field_filters(field_name=self.schema.name, filters=self.filters)
 
         if (clean_filters and "id" in clean_filters) or "ids" in clean_filters:

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/backend/infrahub/core/schema/schema_branch.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import copy
 import hashlib
+import keyword
 from collections import defaultdict
 from itertools import chain, combinations
 from typing import Any
@@ -518,6 +519,7 @@ class SchemaBranch:
 
     def process_validate(self) -> None:
         self.validate_names()
+        self.validate_python_keywords()
         self.validate_kinds()
         self.validate_computed_attributes()
         self.validate_attribute_parameters()
@@ -987,6 +989,26 @@ class SchemaBranch:
                 ):
                     raise ValueError(f"{node.kind}: {rel.name} isn't allowed as a relationship name.")
 
+    def validate_python_keywords(self) -> None:
+        """Validate that attribute and relationship names don't use Python keywords."""
+        for name in self.all_names:
+            node = self.get(name=name, duplicate=False)
+
+            # Check for Python keywords in attribute names
+            for attribute in node.attributes:
+                if keyword.iskeyword(attribute.name):
+                    raise ValueError(
+                        f"Python keyword '{attribute.name}' cannot be used as an attribute name on '{node.kind}'"
+                    )
+
+            # Check for Python keywords in relationship names
+            if config.SETTINGS.main.schema_strict_mode:
+                for relationship in node.relationships:
+                    if keyword.iskeyword(relationship.name):
+                        raise ValueError(
+                            f"Python keyword '{relationship.name}' cannot be used as a relationship name on '{node.kind}' when using strict mode"
+                        )
+
     def _validate_common_parent(self, node: NodeSchema, rel: RelationshipSchema) -> None:
         if not rel.common_parent:
             return

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/backend/infrahub/generators/tasks.py

@@ -214,7 +214,7 @@ async def request_generator_definition_run(
             repository_kind=repository.typename,
             branch_name=model.branch,
             query=model.generator_definition.query_name,
-            variables=member.extract(params=model.generator_definition.parameters),
+            variables=await member.extract(params=model.generator_definition.parameters),
             target_id=member.id,
             target_name=member.display_label,
         )

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/backend/infrahub/git/integrator.py

@@ -1294,7 +1294,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         query: CoreGraphQLQuery,
     ) -> ArtifactGenerateResult:
         """It doesn't look like this is used anywhere today ... we should either remove it or refactor render_artifact below to use this."""
-        variables = target.extract(params=definition.parameters.value)
+        variables = await target.extract(params=definition.parameters.value)
         response = await self.sdk.query_gql_query(
             name=query.name.value,
             variables=variables,

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/backend/infrahub/git/tasks.py

@@ -365,7 +365,7 @@ async def generate_request_artifact_definition(
             repository_kind=repository.get_kind(),
             branch_name=model.branch,
             query=query.name.value,
-            variables=member.extract(params=artifact_definition.parameters.value),
+            variables=await member.extract(params=artifact_definition.parameters.value),
             target_id=member.id,
             target_name=member.display_label,
             target_kind=member.get_kind(),
@@ -583,7 +583,7 @@ async def trigger_repository_user_checks_definitions(
                 branch_name=model.branch_name,
                 check_definition_id=model.check_definition_id,
                 proposed_change=model.proposed_change,
-                variables=member.extract(params=definition.parameters.value),
+                variables=await member.extract(params=definition.parameters.value),
                 branch_diff=model.branch_diff,
                 timeout=definition.timeout.value,
             )

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/backend/infrahub/graphql/mutations/main.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import hashlib
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
@@ -152,7 +153,7 @@ class InfrahubMutationMixin:
         """
         schema_branch = db.schema.get_schema_branch(name=branch.name)
         lock_names = _get_kind_lock_names_on_object_mutation(
-            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch
+            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch, data=data
         )
         if lock_names:
             async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
@@ -216,7 +217,7 @@ class InfrahubMutationMixin:
 
         schema_branch = db.schema.get_schema_branch(name=branch.name)
         lock_names = _get_kind_lock_names_on_object_mutation(
-            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch
+            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch, data=data
         )
 
         if db.is_transaction:
@@ -266,7 +267,6 @@ class InfrahubMutationMixin:
         obj = node or await NodeManager.find_object(
             db=db, kind=cls._meta.active_schema.kind, id=data.get("id"), hfid=data.get("hfid"), branch=branch
         )
-
         obj, result = await cls._call_mutate_update(info=info, data=data, db=db, branch=branch, obj=obj)
 
         return obj, result
@@ -517,15 +517,34 @@ def _should_kind_be_locked_on_any_branch(kind: str, schema_branch: SchemaBranch)
     return False
 
 
-def _get_kind_lock_names_on_object_mutation(kind: str, branch: Branch, schema_branch: SchemaBranch) -> list[str]:
+def _hash(value: str) -> str:
+    # Do not use builtin `hash` for lock names as due to randomization results would differ between
+    # different processes.
+    return hashlib.sha256(value.encode()).hexdigest()
+
+
+def _get_kind_lock_names_on_object_mutation(
+    kind: str, branch: Branch, schema_branch: SchemaBranch, data: InputObjectType
+) -> list[str]:
     """
     Return objects kind for which we want to avoid concurrent mutation (create/update). Except for some specific kinds,
     concurrent mutations are only allowed on non-main branch as objects validations will be performed at least when merging in main branch.
     """
 
-    if not branch.is_default and not _should_kind_be_locked_on_any_branch(kind, schema_branch):
+    if not branch.is_default and not _should_kind_be_locked_on_any_branch(kind=kind, schema_branch=schema_branch):
         return []
 
+    if kind == InfrahubKind.GRAPHQLQUERYGROUP:
+        # Lock on name as well to improve performances
+        try:
+            name = data.name.value
+            return [build_object_lock_name(kind + "." + _hash(name))]
+        except AttributeError:
+            # We might reach here if we are updating a CoreGraphQLQueryGroup without updating the name,
+            # in which case we would not need to lock. This is not supposed to happen as current `update`
+            # logic first fetches the node with its name.
+            return []
+
     lock_kinds = _get_kinds_to_lock_on_object_mutation(kind, schema_branch)
     lock_names = [build_object_lock_name(kind) for kind in lock_kinds]
     return lock_names

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/backend/infrahub/proposed_change/tasks.py

@@ -652,7 +652,7 @@ async def validate_artifacts_generation(
                 repository_kind=repository.kind,
                 branch_name=model.source_branch,
                 query=model.artifact_definition.query_name,
-                variables=member.extract(params=artifact_definition.parameters.value),
+                variables=await member.extract(params=artifact_definition.parameters.value),
                 target_id=member.id,
                 target_kind=member.get_kind(),
                 target_name=member.display_label,
@@ -913,7 +913,7 @@ async def request_generator_definition_check(
                 repository_kind=repository.kind,
                 branch_name=model.source_branch,
                 query=model.generator_definition.query_name,
-                variables=member.extract(params=model.generator_definition.parameters),
+                variables=await member.extract(params=model.generator_definition.parameters),
                 target_id=member.id,
                 target_name=member.display_label,
                 validator_id=validator.id,

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "infrahub-server"
-version = "1.3.4"
+version = "1.3.5"
 description = "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."
 authors = ["OpsMill <info@opsmill.com>"]
 readme = "README.md"

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/python_sdk/infrahub_sdk/node/node.py

@@ -8,7 +8,7 @@ from ..constants import InfrahubClientMode
 from ..exceptions import FeatureNotSupportedError, NodeNotFoundError, ResourceNotDefinedError, SchemaNotFoundError
 from ..graphql import Mutation, Query
 from ..schema import GenericSchemaAPI, RelationshipCardinality, RelationshipKind
-from ..utils import compare_lists, generate_short_id, get_flat_value
+from ..utils import compare_lists, generate_short_id
 from .attribute import Attribute
 from .constants import (
     ARTIFACT_DEFINITION_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE,
@@ -418,14 +418,6 @@ class InfrahubNodeBase:
 
         return data
 
-    def extract(self, params: dict[str, str]) -> dict[str, Any]:
-        """Extract some datapoints defined in a flat notation."""
-        result: dict[str, Any] = {}
-        for key, value in params.items():
-            result[key] = get_flat_value(self, key=value)
-
-        return result
-
     def __hash__(self) -> int:
         return hash(self.id)
 
@@ -1036,6 +1028,46 @@ class InfrahubNode(InfrahubNodeBase):
 
         raise ResourceNotDefinedError(message=f"The node doesn't have a cardinality=one relationship for {name}")
 
+    async def get_flat_value(self, key: str, separator: str = "__") -> Any:
+        """Query recursively a value defined in a flat notation (string), on a hierarchy of objects
+
+        Examples:
+            name__value
+            module.object.value
+        """
+        if separator not in key:
+            return getattr(self, key)
+
+        first, remaining = key.split(separator, maxsplit=1)
+
+        if first in self._schema.attribute_names:
+            attr = getattr(self, first)
+            for part in remaining.split(separator):
+                attr = getattr(attr, part)
+            return attr
+
+        try:
+            rel = self._schema.get_relationship(name=first)
+        except ValueError as exc:
+            raise ValueError(f"No attribute or relationship named '{first}' for '{self._schema.kind}'") from exc
+
+        if rel.cardinality != RelationshipCardinality.ONE:
+            raise ValueError(
+                f"Can only look up flat value for relationships of cardinality {RelationshipCardinality.ONE.value}"
+            )
+
+        related_node: RelatedNode = getattr(self, first)
+        await related_node.fetch()
+        return await related_node.peer.get_flat_value(key=remaining, separator=separator)
+
+    async def extract(self, params: dict[str, str]) -> dict[str, Any]:
+        """Extract some datapoints defined in a flat notation."""
+        result: dict[str, Any] = {}
+        for key, value in params.items():
+            result[key] = await self.get_flat_value(key=value)
+
+        return result
+
     def __dir__(self) -> Iterable[str]:
         base = list(super().__dir__())
         return sorted(
@@ -1622,6 +1654,46 @@ class InfrahubNodeSync(InfrahubNodeBase):
 
         raise ResourceNotDefinedError(message=f"The node doesn't have a cardinality=one relationship for {name}")
 
+    def get_flat_value(self, key: str, separator: str = "__") -> Any:
+        """Query recursively a value defined in a flat notation (string), on a hierarchy of objects
+
+        Examples:
+            name__value
+            module.object.value
+        """
+        if separator not in key:
+            return getattr(self, key)
+
+        first, remaining = key.split(separator, maxsplit=1)
+
+        if first in self._schema.attribute_names:
+            attr = getattr(self, first)
+            for part in remaining.split(separator):
+                attr = getattr(attr, part)
+            return attr
+
+        try:
+            rel = self._schema.get_relationship(name=first)
+        except ValueError as exc:
+            raise ValueError(f"No attribute or relationship named '{first}' for '{self._schema.kind}'") from exc
+
+        if rel.cardinality != RelationshipCardinality.ONE:
+            raise ValueError(
+                f"Can only look up flat value for relationships of cardinality {RelationshipCardinality.ONE.value}"
+            )
+
+        related_node: RelatedNodeSync = getattr(self, first)
+        related_node.fetch()
+        return related_node.peer.get_flat_value(key=remaining, separator=separator)
+
+    def extract(self, params: dict[str, str]) -> dict[str, Any]:
+        """Extract some datapoints defined in a flat notation."""
+        result: dict[str, Any] = {}
+        for key, value in params.items():
+            result[key] = self.get_flat_value(key=value)
+
+        return result
+
     def __dir__(self) -> Iterable[str]:
         base = list(super().__dir__())
         return sorted(

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/python_sdk/infrahub_sdk/protocols_base.py

@@ -204,8 +204,6 @@ class CoreNodeBase(Protocol):
 
     def get_raw_graphql_data(self) -> dict | None: ...
 
-    def extract(self, params: dict[str, str]) -> dict[str, Any]: ...
-
 
 @runtime_checkable
 class CoreNode(CoreNodeBase, Protocol):

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/python_sdk/infrahub_sdk/protocols_generator/constants.py

@@ -22,6 +22,7 @@ ATTRIBUTE_KIND_MAP = {
     "List": "ListAttribute",
     "JSON": "JSONAttribute",
     "Any": "AnyAttribute",
+    "NumberPool": "Integer",
 }
 
 # The order of the classes in the list determines the order of the classes in the generated code

{infrahub_server-1.3.4 → infrahub_server-1.3.5}/python_sdk/infrahub_sdk/utils.py

@@ -190,23 +190,6 @@ def str_to_bool(value: str) -> bool:
         raise ValueError(f"{value} can not be converted into a boolean") from exc
 
 
-def get_flat_value(obj: Any, key: str, separator: str = "__") -> Any:
-    """Query recursively an value defined in a flat notation (string), on a hierarchy of objects
-
-    Examples:
-        name__value
-        module.object.value
-    """
-    if separator not in key:
-        return getattr(obj, key)
-
-    first_part, remaining_part = key.split(separator, maxsplit=1)
-    sub_obj = getattr(obj, first_part)
-    if not sub_obj:
-        return None
-    return get_flat_value(obj=sub_obj, key=remaining_part, separator=separator)
-
-
 def generate_request_filename(request: httpx.Request) -> str:
     """Return a filename for a request sent to the Infrahub API