infrahub-server 1.1.9__tar.gz → 1.1.10__tar.gz

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infrahub-server
-Version: 1.1.9
+Version: 1.1.10
 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.
 Home-page: https://opsmill.com
 License: AGPL-3.0-only

infrahub_server-1.1.10/backend/infrahub/core/graph/__init__.py

@@ -0,0 +1 @@
+GRAPH_VERSION = 22

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/backend/infrahub/core/migrations/__init__.py

@@ -13,6 +13,7 @@ MIGRATION_MAP: dict[str, Optional[type[SchemaMigration]]] = {
     "node.branch.update": None,
     "node.attribute.add": NodeAttributeAddMigration,
     "node.attribute.remove": NodeAttributeRemoveMigration,
+    "node.inherit_from.update": NodeKindUpdateMigration,
     "node.name.update": NodeKindUpdateMigration,
     "node.namespace.update": NodeKindUpdateMigration,
     "node.relationship.remove": PlaceholderDummyMigration,

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/backend/infrahub/core/migrations/graph/__init__.py

@@ -23,6 +23,7 @@ from .m018_uniqueness_nulls import Migration018
 from .m019_restore_rels_to_time import Migration019
 from .m020_duplicate_edges import Migration020
 from .m021_missing_hierarchy_merge import Migration021
+from .m022_missing_hierarchy_backfill import Migration022
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -51,6 +52,7 @@ MIGRATIONS: list[type[Union[GraphMigration, InternalSchemaMigration, ArbitraryMi
     Migration019,
     Migration020,
     Migration021,
+    Migration022,
 ]
 
 

infrahub_server-1.1.10/backend/infrahub/core/migrations/graph/m022_missing_hierarchy_backfill.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core import registry
+from infrahub.core.initialization import initialization
+from infrahub.core.migrations.shared import GraphMigration, MigrationResult
+from infrahub.lock import initialize_lock
+from infrahub.log import get_logger
+
+from ...query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class BackfillMissingHierarchyQuery(Query):
+    name = "backfill_missing_hierarchy"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        # load schemas from database into registry
+        initialize_lock()
+        await initialization(db=db)
+        kind_hierarchy_map: dict[str, str] = {}
+        schema_branch = await registry.schema.load_schema_from_db(db=db)
+        for node_schema_kind in schema_branch.node_names:
+            node_schema = schema_branch.get_node(name=node_schema_kind, duplicate=False)
+            if node_schema.hierarchy:
+                kind_hierarchy_map[node_schema.kind] = node_schema.hierarchy
+
+        self.params = {"hierarchy_map": kind_hierarchy_map}
+        query = """
+        MATCH (r:Root)
+        WITH r.default_branch AS default_branch
+        MATCH (rel:Relationship {name: "parent__child"})-[e:IS_RELATED]-(n:Node)
+        WHERE e.hierarchy IS NULL
+        WITH DISTINCT rel, n, default_branch
+        CALL {
+            WITH rel, n, default_branch
+            MATCH (rel)-[e:IS_RELATED {branch: default_branch}]-(n)
+            RETURN e
+            ORDER BY e.from DESC
+            LIMIT 1
+        }
+        WITH rel, n, e
+        WHERE e.status = "active" AND e.hierarchy IS NULL
+        SET e.hierarchy = $hierarchy_map[n.kind]
+        """
+        self.add_to_query(query)
+
+
+class Migration022(GraphMigration):
+    """
+    A bug in diff merge logic caused the hierarchy information on IS_RELATED edges to be lost when merged into
+    main. This migration backfills the missing hierarchy data and accounts for the case when the branch that
+    created the data has been deleted.
+    """
+
+    name: str = "022_backfill_hierarchy"
+    minimum_version: int = 21
+    queries: Sequence[type[Query]] = [BackfillMissingHierarchyQuery]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        result = MigrationResult()
+        return result

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/backend/infrahub/core/migrations/query/node_duplicate.py

@@ -9,8 +9,6 @@ from infrahub.core.graph.schema import GraphNodeRelationships, GraphRelDirection
 from infrahub.core.query import Query, QueryType
 
 if TYPE_CHECKING:
-    from pydantic.fields import FieldInfo
-
     from infrahub.database import InfrahubDatabase
 
 
@@ -47,37 +45,37 @@ class NodeDuplicateQuery(Query):
         return query
 
     @staticmethod
-    def _render_sub_query_per_rel_type(
-        rel_name: str,
-        rel_type: str,
-        rel_def: FieldInfo,
-    ) -> str:
+    def _render_sub_query_per_rel_type(rel_name: str, rel_type: str, rel_dir: GraphRelDirection) -> str:
         subquery = [
             f"WITH peer_node, {rel_name}, active_node, new_node",
             f"WITH peer_node, {rel_name}, active_node, new_node",
             f'WHERE type({rel_name}) = "{rel_type}"',
         ]
-        if rel_def.default.direction in [GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER]:
+        if rel_dir in [GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER]:
             subquery.append(f"""
                 CREATE (new_node)-[new_active_edge:{rel_type} $rel_props_new ]->(peer_node)
                 SET new_active_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
                 SET new_active_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                SET new_active_edge.hierarchy = COALESCE({rel_name}.hierarchy, NULL)
                 """)
             subquery.append(f"""
                 CREATE (active_node)-[deleted_edge:{rel_type} $rel_props_prev ]->(peer_node)
                 SET deleted_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
                 SET deleted_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                SET deleted_edge.hierarchy = COALESCE({rel_name}.hierarchy, NULL)
                 """)
-        elif rel_def.default.direction in [GraphRelDirection.INBOUND, GraphRelDirection.EITHER]:
+        elif rel_dir in [GraphRelDirection.INBOUND, GraphRelDirection.EITHER]:
             subquery.append(f"""
                 CREATE (new_node)<-[new_active_edge:{rel_type} $rel_props_new ]-(peer_node)
                 SET new_active_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
                 SET new_active_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                SET new_active_edge.hierarchy = COALESCE({rel_name}.hierarchy, NULL)
                 """)
             subquery.append(f"""
                 CREATE (active_node)<-[deleted_edge:{rel_type} $rel_props_prev ]-(peer_node)
-                SET new_active_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
-                SET new_active_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                SET deleted_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
+                SET deleted_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                SET deleted_edge.hierarchy = COALESCE({rel_name}.hierarchy, NULL)
                 """)
         subquery.append("RETURN peer_node as p2")
         return "\n".join(subquery)
@@ -86,11 +84,10 @@ class NodeDuplicateQuery(Query):
     def _render_sub_query_out(cls) -> str:
         sub_queries_out = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_outband",
-                rel_type=rel_type,
-                rel_def=rel_def,
+                rel_name="rel_outband", rel_type=rel_type, rel_dir=GraphRelDirection.OUTBOUND
             )
-            for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
+            for rel_type, field_info in GraphNodeRelationships.model_fields.items()
+            if field_info.default.direction in (GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER)
         ]
         sub_query_out = "\nUNION\n".join(sub_queries_out)
         return sub_query_out
@@ -99,11 +96,10 @@ class NodeDuplicateQuery(Query):
     def _render_sub_query_in(cls) -> str:
         sub_queries_in = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_inband",
-                rel_type=rel_type,
-                rel_def=rel_def,
+                rel_name="rel_inband", rel_type=rel_type, rel_dir=GraphRelDirection.INBOUND
             )
-            for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
+            for rel_type, field_info in GraphNodeRelationships.model_fields.items()
+            if field_info.default.direction in (GraphRelDirection.INBOUND, GraphRelDirection.EITHER)
         ]
         sub_query_in = "\nUNION\n".join(sub_queries_in)
         return sub_query_in
@@ -168,11 +164,12 @@ class NodeDuplicateQuery(Query):
         FOREACH (i in CASE WHEN rel_outband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
             SET rel_outband.to = $current_time
         )
-        WITH active_node, new_node
+        WITH DISTINCT active_node, new_node
+        // Process Inbound Relationship
         MATCH (active_node)<-[]-(peer)
         CALL {
             WITH active_node, peer
-            MATCH (active_node)-[r]->(peer)
+            MATCH (active_node)<-[r]-(peer)
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as rel_inband1, peer as p1
             ORDER BY r.branch_level DESC, r.from DESC

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/backend/infrahub/core/models.py

@@ -19,6 +19,8 @@ if TYPE_CHECKING:
     from infrahub.core.schema import MainSchemaTypes
     from infrahub.core.schema.schema_branch import SchemaBranch
 
+GENERIC_ATTRIBUTES_TO_IGNORE = ["namespace", "name", "branch"]
+
 
 class NodeKind(BaseModel):
     namespace: str
@@ -182,6 +184,15 @@ class SchemaUpdateValidationResult(BaseModel):
 
         for schema_name, schema_diff in self.diff.changed.items():
             schema_node = schema.get(name=schema_name, duplicate=False)
+            if "inherit_from" in schema_diff.changed:
+                self.migrations.append(
+                    SchemaUpdateMigrationInfo(
+                        path=SchemaPath(  # type: ignore[call-arg]
+                            schema_kind=schema_name, path_type=SchemaPathType.NODE
+                        ),
+                        migration_name="node.inherit_from.update",
+                    )
+                )
 
             # Nothing to do today if we add a new attribute to a node in the schema
             # for node_field_name, _ in schema_diff.added.items():
@@ -262,6 +273,10 @@ class SchemaUpdateValidationResult(BaseModel):
         field_info = schema.model_fields[node_field_name]
         field_update = str(field_info.json_schema_extra.get("update"))  # type: ignore[union-attr]
 
+        # No need to execute a migration for generic nodes attributes because they are not stored in the database
+        if schema.is_generic_schema and node_field_name in GENERIC_ATTRIBUTES_TO_IGNORE:
+            return
+
         schema_path = SchemaPath(  # type: ignore[call-arg]
             schema_kind=schema.kind,
             path_type=SchemaPathType.NODE,

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/backend/infrahub/core/validators/interface.py

@@ -1,8 +1,12 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
 
-from infrahub.core.path import GroupedDataPaths
+if TYPE_CHECKING:
+    from infrahub.core.path import GroupedDataPaths
 
-from .model import SchemaConstraintValidatorRequest
+    from .model import SchemaConstraintValidatorRequest
 
 
 class ConstraintCheckerInterface(ABC):

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/backend/infrahub/core/validators/model.py

@@ -5,6 +5,7 @@ from pydantic import BaseModel, Field
 from infrahub.core.branch import Branch
 from infrahub.core.path import SchemaPath
 from infrahub.core.schema import GenericSchema, NodeSchema
+from infrahub.core.schema.schema_branch import SchemaBranch
 
 
 class SchemaConstraintValidatorRequest(BaseModel):
@@ -12,6 +13,7 @@ class SchemaConstraintValidatorRequest(BaseModel):
     constraint_name: str = Field(..., description="The name of the constraint to validate")
     node_schema: Union[NodeSchema, GenericSchema] = Field(..., description="Schema of Node or Generic to validate")
     schema_path: SchemaPath = Field(..., description="SchemaPath to the element of the schema to validate")
+    schema_branch: SchemaBranch = Field(..., description="SchemaBranch of the element to validate")
 
 
 class SchemaViolation(BaseModel):

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/backend/infrahub/core/validators/node/hierarchy.py

@@ -7,9 +7,7 @@ from infrahub.core.path import DataPath, GroupedDataPaths
 from infrahub.core.schema import NodeSchema
 
 from ..interface import ConstraintCheckerInterface
-from ..shared import (
-    SchemaValidatorQuery,
-)
+from ..shared import SchemaValidatorQuery
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/backend/infrahub/core/validators/node/inherit_from.py

@@ -6,7 +6,8 @@ from infrahub_sdk.utils import compare_lists
 
 from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
-from infrahub.core.schema import NodeSchema
+from infrahub.core.schema import MainSchemaTypes, NodeSchema
+from infrahub.exceptions import SchemaNotFoundError
 
 from ..interface import ConstraintCheckerInterface
 
@@ -41,8 +42,29 @@ class NodeInheritFromChecker(ConstraintCheckerInterface):
             return grouped_data_paths_list
 
         _, removed, _ = compare_lists(list1=current_schema.inherit_from, list2=request.node_schema.inherit_from)
-
-        if removed:
+        current_inherit_from_ids = {
+            g.id: g.kind
+            for g in [
+                self.db.schema.get(name=n, branch=request.branch, duplicate=False) for n in current_schema.inherit_from
+            ]
+        }
+
+        # Gather IDs for each inherited node in use for candidate schema
+        request_inherited: list[MainSchemaTypes] = []
+        for n in request.node_schema.inherit_from:
+            try:
+                schema = request.schema_branch.get(name=n, duplicate=False)
+            except SchemaNotFoundError:
+                schema = self.db.schema.get(name=n, branch=request.branch, duplicate=False)
+            request_inherited.append(schema)
+        request_inherit_from_ids = {g.id: g.kind for g in request_inherited}
+
+        # Compare IDs to find out if some inherited nodes were removed
+        # Comparing IDs helps us in understanding if a node was renamed or really removed
+        _, removed_ids, _ = compare_lists(
+            list1=list(current_inherit_from_ids.keys()), list2=list(request_inherit_from_ids.keys())
+        )
+        if removed := [current_inherit_from_ids[k] for k in removed_ids]:
             group_data_path.add_data_path(
                 DataPath(
                     branch=str(request.branch.name),

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/backend/infrahub/core/validators/tasks.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from infrahub_sdk.batch import InfrahubBatch
 from prefect import flow, task
 from prefect.cache_policies import NONE
@@ -18,6 +20,9 @@ from infrahub.workflows.utils import add_tags
 
 from .models.validate_migration import SchemaValidateMigrationData, SchemaValidatorPathResponseData
 
+if TYPE_CHECKING:
+    from infrahub.core.schema.schema_branch import SchemaBranch
+
 
 @flow(name="schema_validate_migrations", flow_run_name="Validate schema migrations", persist_result=True)
 async def schema_validate_migrations(message: SchemaValidateMigrationData) -> list[SchemaValidatorPathResponseData]:
@@ -41,6 +46,7 @@ async def schema_validate_migrations(message: SchemaValidateMigrationData) -> li
             constraint_name=constraint.constraint_name,
             node_schema=schema,
             schema_path=constraint.path,
+            schema_branch=message.schema_branch,
         )
 
     results = [result async for _, result in batch.execute()]
@@ -59,6 +65,7 @@ async def schema_path_validate(
     constraint_name: str,
     node_schema: NodeSchema | GenericSchema,
     schema_path: SchemaPath,
+    schema_branch: SchemaBranch,
 ) -> SchemaValidatorPathResponseData:
     service = services.service
 
@@ -68,6 +75,7 @@ async def schema_path_validate(
             constraint_name=constraint_name,
             node_schema=node_schema,
             schema_path=schema_path,
+            schema_branch=schema_branch,
         )
 
         component_registry = get_component_registry()

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/backend/infrahub/core/validators/uniqueness/checker.py

@@ -1,21 +1,16 @@
+from __future__ import annotations
+
 import asyncio
 from itertools import chain
-from typing import Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 from infrahub.core import registry
 from infrahub.core.branch import Branch
 from infrahub.core.path import DataPath, GroupedDataPaths
-from infrahub.core.query import QueryResult
-from infrahub.core.schema import (
-    AttributeSchema,
-    MainSchemaTypes,
-    RelationshipSchema,
-)
+from infrahub.core.schema import AttributeSchema, MainSchemaTypes, RelationshipSchema
 from infrahub.core.validators.uniqueness.index import UniquenessQueryResultsIndex
-from infrahub.database import InfrahubDatabase
 
 from ..interface import ConstraintCheckerInterface
-from ..model import SchemaConstraintValidatorRequest
 from .model import (
     NodeUniquenessQueryRequest,
     NonUniqueAttribute,
@@ -26,6 +21,12 @@ from .model import (
 )
 from .query import NodeUniqueAttributeConstraintQuery
 
+if TYPE_CHECKING:
+    from infrahub.core.query import QueryResult
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import SchemaConstraintValidatorRequest
+
 
 def get_attribute_path_from_string(
     path: str, schema: MainSchemaTypes

{infrahub_server-1.1.9 → infrahub_server-1.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "infrahub-server"
-version = "1.1.9"
+version = "1.1.10"
 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.1.9/backend/infrahub/core/graph/__init__.py

@@ -1 +0,0 @@
-GRAPH_VERSION = 21