infrahub-server 1.2.5__tar.gz → 1.2.6__tar.gz

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infrahub-server
-Version: 1.2.5
+Version: 1.2.6
 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.2.5 → infrahub_server-1.2.6}/backend/infrahub/core/manager.py

@@ -803,8 +803,21 @@ class NodeManager:
 
         hfid_str = " :: ".join(hfid)
 
-        if not node_schema.human_friendly_id or len(node_schema.human_friendly_id) != len(hfid):
-            raise NodeNotFoundError(branch_name=branch.name, node_type=kind_str, identifier=hfid_str)
+        if not node_schema.human_friendly_id:
+            raise NodeNotFoundError(
+                branch_name=branch.name,
+                node_type=kind_str,
+                identifier=hfid_str,
+                message=f"Unable to lookup node by HFID, schema '{node_schema.kind}' does not have a HFID defined.",
+            )
+
+        if len(node_schema.human_friendly_id) != len(hfid):
+            raise NodeNotFoundError(
+                branch_name=branch.name,
+                node_type=kind_str,
+                identifier=hfid_str,
+                message=f"Unable to lookup node by HFID, schema '{node_schema.kind}' HFID does not contain the same number of elements as {hfid}",
+            )
 
         filters = {}
         for key, item in zip(node_schema.human_friendly_id, hfid, strict=False):

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/backend/infrahub/core/registry.py

@@ -222,7 +222,7 @@ class Registry:
 
     async def purge_inactive_branches(
         self, db: InfrahubDatabase, active_branches: list[Branch] | None = None
-    ) -> list[str]:
+    ) -> set[str]:
         """Return a list of branches that were purged from the registry."""
         active_branches = active_branches or await self.branch_object.get_list(db=db)
         active_branch_names = [branch.name for branch in active_branches]
@@ -235,8 +235,7 @@ class Registry:
 
         purged_branches.update(self.schema.purge_inactive_branches(active_branches=active_branch_names))
         purged_branches.update(db.purge_inactive_schemas(active_branches=active_branch_names))
-
-        return sorted(purged_branches)
+        return purged_branches
 
 
 registry = Registry()

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/backend/infrahub/core/schema/schema_branch.py

@@ -1909,10 +1909,8 @@ class SchemaBranch:
 
                 self.set(name=node_name, schema=node_schema)
 
-    def add_relationships_to_template(self, node: NodeSchema) -> None:
+    def add_relationships_to_template(self, node: NodeSchema | GenericSchema) -> None:
         template_schema = self.get(name=self._get_object_template_kind(node_kind=node.kind), duplicate=False)
-        if template_schema.is_generic_schema:
-            return
 
         # Remove previous relationships to account for new ones
         template_schema.relationships = [
@@ -1954,6 +1952,7 @@ class SchemaBranch:
                     label=f"{relationship.name} template".title()
                     if relationship.kind in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
                     else relationship.name.title(),
+                    inherited=relationship.inherited,
                 )
             )
 
@@ -1983,9 +1982,6 @@ class SchemaBranch:
         need_template_kinds = [n.kind for n in need_templates]
 
         if node.is_generic_schema:
-            # When needing a template for a generic, we generate an empty shell mostly to make sure that schemas (including the GraphQL one) will
-            # look right. We don't really care about applying inheritance of fields as it was already processed and actual templates will have the
-            # correct attributes and relationships
             template = GenericSchema(
                 name=node.kind,
                 namespace="Template",
@@ -1994,43 +1990,44 @@ class SchemaBranch:
                 generate_profile=False,
                 branch=node.branch,
                 include_in_menu=False,
+                display_labels=["template_name__value"],
+                human_friendly_id=["template_name__value"],
+                uniqueness_constraints=[["template_name__value"]],
                 attributes=[template_name_attr],
             )
 
             for used in node.used_by:
                 if used in need_template_kinds:
                     template.used_by.append(self._get_object_template_kind(node_kind=used))
+        else:
+            template = TemplateSchema(
+                name=node.kind,
+                namespace="Template",
+                label=f"Object template {node.label}",
+                description=f"Object template for {node.kind}",
+                branch=node.branch,
+                include_in_menu=False,
+                display_labels=["template_name__value"],
+                human_friendly_id=["template_name__value"],
+                uniqueness_constraints=[["template_name__value"]],
+                inherit_from=[InfrahubKind.LINEAGESOURCE, InfrahubKind.NODE, core_template_schema.kind],
+                default_filter="template_name__value",
+                attributes=[template_name_attr],
+                relationships=[
+                    RelationshipSchema(
+                        name="related_nodes",
+                        identifier="node__objecttemplate",
+                        peer=node.kind,
+                        kind=RelationshipKind.TEMPLATE,
+                        cardinality=RelationshipCardinality.MANY,
+                        branch=BranchSupportType.AWARE,
+                    )
+                ],
+            )
 
-            return template
-
-        template = TemplateSchema(
-            name=node.kind,
-            namespace="Template",
-            label=f"Object template {node.label}",
-            description=f"Object template for {node.kind}",
-            branch=node.branch,
-            include_in_menu=False,
-            display_labels=["template_name__value"],
-            human_friendly_id=["template_name__value"],
-            uniqueness_constraints=[["template_name__value"]],
-            inherit_from=[InfrahubKind.LINEAGESOURCE, InfrahubKind.NODE, core_template_schema.kind],
-            default_filter="template_name__value",
-            attributes=[template_name_attr],
-            relationships=[
-                RelationshipSchema(
-                    name="related_nodes",
-                    identifier="node__objecttemplate",
-                    peer=node.kind,
-                    kind=RelationshipKind.TEMPLATE,
-                    cardinality=RelationshipCardinality.MANY,
-                    branch=BranchSupportType.AWARE,
-                )
-            ],
-        )
-
-        for inherited in node.inherit_from:
-            if inherited in need_template_kinds:
-                template.inherit_from.append(self._get_object_template_kind(node_kind=inherited))
+            for inherited in node.inherit_from:
+                if inherited in need_template_kinds:
+                    template.inherit_from.append(self._get_object_template_kind(node_kind=inherited))
 
         for node_attr in node.attributes:
             if node_attr.unique or node_attr.read_only:
@@ -2038,7 +2035,7 @@ class SchemaBranch:
 
             attr = AttributeSchema(
                 optional=node_attr.optional if is_autogenerated_subtemplate else True,
-                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only", "inherited"]),
+                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only"]),
             )
             template.attributes.append(attr)
 

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/backend/infrahub/database/__init__.py

@@ -394,8 +394,10 @@ class InfrahubDatabase:
             with QUERY_EXECUTION_METRICS.labels(**labels).time():
                 response = await self.run_query(query=query, params=params, name=name)
                 if response is None:
+                    span.set_attribute("rows", "empty")
                     return [], {}
                 results = [item async for item in response]
+                span.set_attribute("rows", len(results))
                 return results, response._metadata or {}
 
     async def run_query(

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/backend/infrahub/graphql/manager.py

@@ -113,6 +113,16 @@ class GraphQLSchemaManager:
     def clear_cache(cls) -> None:
         cls._branch_details_by_name = {}
 
+    @classmethod
+    def purge_inactive(cls, active_branches: list[str]) -> set[str]:
+        """Return inactive branches that were purged"""
+        inactive_branches: set[str] = set()
+        for branch_name in list(cls._branch_details_by_name):
+            if branch_name not in active_branches:
+                inactive_branches.add(branch_name)
+                del cls._branch_details_by_name[branch_name]
+        return inactive_branches
+
     @classmethod
     def _cache_branch(
         cls, branch: Branch, schema_branch: SchemaBranch, schema_hash: str | None = None

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/backend/infrahub/graphql/mutations/main.py

@@ -489,7 +489,8 @@ class InfrahubMutationMixin:
         we would update the node without rerunning uniqueness constraint.
         """
 
-        schema_name = cls._meta.active_schema.kind
+        schema = cls._meta.active_schema
+        schema_name = schema.kind
 
         graphql_context: GraphqlContext = info.context
         db = database or graphql_context.db
@@ -509,10 +510,8 @@ class InfrahubMutationMixin:
             )
             return updated_obj, mutation, False
 
-        if cls._meta.active_schema.default_filter is not None:
-            node = await node_getter_default_filter.get_node(
-                node_schema=cls._meta.active_schema, data=data, branch=branch
-            )
+        if not schema.human_friendly_id and schema.default_filter is not None:
+            node = await node_getter_default_filter.get_node(node_schema=schema, data=data, branch=branch)
 
         if "hfid" in data:
             node = await NodeManager.get_one_by_hfid(db=db, hfid=dict_data["hfid"], kind=schema_name, branch=branch)

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/backend/infrahub/graphql/mutations/resource_manager.py

@@ -177,9 +177,9 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         database: InfrahubDatabase | None = None,  # noqa: ARG003
     ) -> Any:
         try:
-            pool_node = registry.get_node_schema(name=data["node"].value)
-        except ValueError as exc:
-            raise ValidationError(input_value="The selected model is not a Node") from exc
+            pool_node = registry.schema.get(name=data["node"].value)
+            if not pool_node.is_generic_schema and not pool_node.is_node_schema:
+                raise ValidationError(input_value="The selected model is not a Node or a Generic")
         except SchemaNotFoundError as exc:
             exc.message = "The selected model does not exist"
             raise exc

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/backend/infrahub/tasks/registry.py

@@ -61,5 +61,8 @@ async def refresh_branches(db: InfrahubDatabase) -> None:
                 )
 
         purged_branches = await registry.purge_inactive_branches(db=db, active_branches=branches)
-        for branch_name in purged_branches:
+        purged_branches.update(
+            GraphQLSchemaManager.purge_inactive(active_branches=[branch.name for branch in branches])
+        )
+        for branch_name in sorted(purged_branches):
             log.info(f"Removed branch {branch_name!r} from the registry", branch=branch_name, worker=WORKER_IDENTITY)

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "infrahub-server"
-version = "1.2.5"
+version = "1.2.6"
 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.2.5 → infrahub_server-1.2.6}/python_testcontainers/infrahub_testcontainers/container.py

@@ -1,5 +1,6 @@
 import os
 import shutil
+import time
 import uuid
 from dataclasses import dataclass, field
 from functools import cached_property
@@ -265,9 +266,58 @@ class InfrahubDockerCompose(DockerCompose):
         )
 
         self.exec_in_container(
-            command=["cypher-shell", "-d", "system", "-u", "neo4j", "-p", "admin", "START DATABASE neo4j;"],
+            command=["chown", "-R", "neo4j:neo4j", "/data"],
             service_name=service_name,
         )
 
+        (restore_output, _, _) = self.exec_in_container(
+            command=[
+                "cypher-shell",
+                "--format",
+                "plain",
+                "-d",
+                "system",
+                "-u",
+                "neo4j",
+                "-p",
+                "admin",
+                "START DATABASE neo4j;",
+            ],
+            service_name=service_name,
+        )
+
+        for _ in range(3):
+            (stdout, _, _) = self.exec_in_container(
+                command=[
+                    "cypher-shell",
+                    "--format",
+                    "plain",
+                    "-d",
+                    "system",
+                    "-u",
+                    "neo4j",
+                    "-p",
+                    "admin",
+                    "SHOW DATABASES WHERE name = 'neo4j' AND currentStatus = 'online';",
+                ],
+                service_name=service_name,
+            )
+            if stdout:
+                break
+            time.sleep(5)
+        else:
+            (debug_logs, _, _) = self.exec_in_container(
+                command=["cat", "logs/debug.log"],
+                service_name=service_name,
+            )
+            raise Exception(f"Failed to restore database:\n{restore_output}\nDebug logs:\n{debug_logs}")
+
+        old_services = self.services
+        self.services = ["infrahub-server", "task-worker"]
         self.stop(down=False)
-        self.start()
+        try:
+            self.start()
+        except Exception as exc:
+            stdout, stderr = self.get_logs()
+            raise Exception(f"Failed to start docker compose:\nStdout:\n{stdout}\nStderr:\n{stderr}") from exc
+        self.services = old_services

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/python_testcontainers/infrahub_testcontainers/docker-compose.test.yml

@@ -45,6 +45,11 @@ services:
       - ${INFRAHUB_TESTING_SERVER_PORT:-0}:8000
 
   database:
+    deploy:
+      resources:
+        limits:
+          cpus: ${INFRAHUB_TESTING_DB_CPU_LIMIT:-0.0}
+          memory: ${INFRAHUB_TESTING_DB_MEMORY_LIMIT:-0}
     image: ${NEO4J_DOCKER_IMAGE:-neo4j:5.20.0-community}
     restart: unless-stopped
     environment:
@@ -52,6 +57,8 @@ services:
       NEO4J_dbms_security_procedures_unrestricted: "apoc.*"
       NEO4J_dbms_security_auth__minimum__password__length: 4
       NEO4J_ACCEPT_LICENSE_AGREEMENT: "yes"
+      NEO4J_dbms_memory_heap_initial__size: ${INFRAHUB_TESTING_DB_HEAP_INITIAL_SIZE}
+      NEO4J_dbms_memory_heap_max__size: ${INFRAHUB_TESTING_DB_HEAP_MAX_SIZE}
     volumes:
       - "database_data:/data"
       - "database_logs:/logs"
@@ -116,6 +123,13 @@ services:
       INFRAHUB_INITIAL_AGENT_TOKEN: ${INFRAHUB_TESTING_INITIAL_AGENT_TOKEN}
       INFRAHUB_SECURITY_SECRET_KEY: ${INFRAHUB_TESTING_SECURITY_SECRET_KEY}
       PREFECT_API_URL: ${INFRAHUB_TESTING_PREFECT_API}
+      # Tracing
+      INFRAHUB_TRACE_ENABLE: ${INFRAHUB_TRACE_ENABLE:-false}
+      INFRAHUB_TRACE_EXPORTER_ENDPOINT:
+      INFRAHUB_TRACE_EXPORTER_PROTOCOL: ${INFRAHUB_TRACE_EXPORTER_PROTOCOL:-grpc}
+      INFRAHUB_TRACE_EXPORTER_TYPE: ${INFRAHUB_TRACE_EXPORTER_TYPE:-console}
+      INFRAHUB_TRACE_INSECURE: ${INFRAHUB_TRACE_INSECURE:-true}
+      OTEL_RESOURCE_ATTRIBUTES:
     depends_on:
       database:
         condition: service_healthy
@@ -155,6 +169,13 @@ services:
       INFRAHUB_WORKFLOW_ADDRESS: ${INFRAHUB_TESTING_WORKFLOW_ADDRESS}
       INFRAHUB_TIMEOUT: ${INFRAHUB_TESTING_TIMEOUT}
       PREFECT_API_URL: ${INFRAHUB_TESTING_PREFECT_API}
+      # Tracing
+      INFRAHUB_TRACE_ENABLE: ${INFRAHUB_TRACE_ENABLE:-false}
+      INFRAHUB_TRACE_EXPORTER_ENDPOINT:
+      INFRAHUB_TRACE_EXPORTER_PROTOCOL: ${INFRAHUB_TRACE_EXPORTER_PROTOCOL:-grpc}
+      INFRAHUB_TRACE_EXPORTER_TYPE: ${INFRAHUB_TRACE_EXPORTER_TYPE:-console}
+      INFRAHUB_TRACE_INSECURE: ${INFRAHUB_TRACE_INSECURE:-true}
+      OTEL_RESOURCE_ATTRIBUTES:
     depends_on:
       - infrahub-server
     volumes:
@@ -187,6 +208,12 @@ services:
       - "--promscrape.config=/etc/prometheus/prometheus.yml"
     ports:
       - ${INFRAHUB_TESTING_SCRAPER_PORT:-0}:8428
+    healthcheck:
+      test: wget -qO- http://127.0.0.1:8428/-/healthy
+      start_period: 10s
+      interval: 5s
+      timeout: 5s
+      retries: 10
 
 volumes:
   database_data:

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/python_testcontainers/infrahub_testcontainers/performance_test.py

@@ -100,7 +100,7 @@ class InfrahubPerformanceTest:
         return self
 
     def fetch_metrics(self) -> None:
-        with httpx.Client() as client:
+        with httpx.Client(timeout=30.0) as client:
             # Get Infrahub metrics
             response = client.post(
                 url=self.scraper_endpoint,

{infrahub_server-1.2.5 → infrahub_server-1.2.6}/python_testcontainers/infrahub_testcontainers/plugin.py

@@ -125,7 +125,7 @@ def pytest_terminal_summary(
     performance_test = terminalreporter._session.infrahub_performance_test
 
     report = [
-        f"{measurement.name}: {measurement.value} {measurement.unit.value}"
+        f"{measurement.name} ({measurement.context}): {measurement.value} {measurement.unit.value}"
         for measurement in performance_test.measurements
     ]
     terminalreporter.write("\n" + "\n".join(report) + "\n")