infrahub-server 1.3.6__tar.gz → 1.3.8__tar.gz

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.3.6
+Version: 1.3.8
 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.6 → infrahub_server-1.3.8}/backend/infrahub/api/schema.py

@@ -36,6 +36,7 @@ from infrahub.events import EventMeta
 from infrahub.events.schema_action import SchemaUpdatedEvent
 from infrahub.exceptions import MigrationError
 from infrahub.log import get_log_data, get_logger
+from infrahub.permissions import define_global_permission_from_branch
 from infrahub.types import ATTRIBUTE_PYTHON_TYPES
 from infrahub.worker import WORKER_IDENTITY
 from infrahub.workflows.catalogue import SCHEMA_APPLY_MIGRATION, SCHEMA_VALIDATE_MIGRATION
@@ -287,13 +288,8 @@ async def load_schema(
     context: InfrahubContext = Depends(get_context),
 ) -> SchemaUpdate:
     permission_manager.raise_for_permission(
-        permission=GlobalPermission(
-            action=GlobalPermissions.MANAGE_SCHEMA.value,
-            decision=(
-                PermissionDecision.ALLOW_DEFAULT
-                if branch.name in (GLOBAL_BRANCH_NAME, registry.default_branch)
-                else PermissionDecision.ALLOW_OTHER
-            ).value,
+        permission=define_global_permission_from_branch(
+            permission=GlobalPermissions.MANAGE_SCHEMA, branch_name=branch.name
         )
     )
 

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/backend/infrahub/core/diff/model/path.py

@@ -22,8 +22,6 @@ if TYPE_CHECKING:
     from neo4j.graph import Relationship as Neo4jRelationship
     from whenever import TimeDelta
 
-    from infrahub.graphql.initialization import GraphqlContext
-
 
 @dataclass
 class TimeRange:
@@ -314,12 +312,6 @@ class EnrichedDiffRelationship(BaseSummary):
         )
 
 
-@dataclass
-class ParentNodeInfo:
-    node: EnrichedDiffNode
-    relationship_name: str = "undefined"
-
-
 @dataclass
 class EnrichedDiffNode(BaseSummary):
     identifier: NodeIdentifier
@@ -364,37 +356,6 @@ class EnrichedDiffNode(BaseSummary):
             rel.clear_conflicts()
         self.conflict = None
 
-    def get_parent_info(self, graphql_context: GraphqlContext | None = None) -> ParentNodeInfo | None:
-        for r in self.relationships:
-            for n in r.nodes:
-                relationship_name: str = "undefined"
-
-                if not graphql_context:
-                    return ParentNodeInfo(node=n, relationship_name=relationship_name)
-
-                node_schema = graphql_context.db.schema.get(name=self.kind)
-                rel_schema = node_schema.get_relationship(name=r.name)
-
-                parent_schema = graphql_context.db.schema.get(name=n.kind)
-                rels_parent = parent_schema.get_relationships_by_identifier(id=rel_schema.get_identifier())
-
-                if rels_parent and len(rels_parent) == 1:
-                    relationship_name = rels_parent[0].name
-                elif rels_parent and len(rels_parent) > 1:
-                    for rel_parent in rels_parent:
-                        if (
-                            rel_schema.direction == RelationshipDirection.INBOUND
-                            and rel_parent.direction == RelationshipDirection.OUTBOUND
-                        ) or (
-                            rel_schema.direction == RelationshipDirection.OUTBOUND
-                            and rel_parent.direction == RelationshipDirection.INBOUND
-                        ):
-                            relationship_name = rel_parent.name
-                            break
-
-                return ParentNodeInfo(node=n, relationship_name=relationship_name)
-        return None
-
     def get_all_child_nodes(self) -> set[EnrichedDiffNode]:
         all_children = set()
         for r in self.relationships:

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

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

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/backend/infrahub/core/migrations/graph/__init__.py

@@ -36,6 +36,7 @@ from .m031_check_number_attributes import Migration031
 from .m032_cleanup_orphaned_branch_relationships import Migration032
 from .m033_deduplicate_relationship_vertices import Migration033
 from .m034_find_orphaned_schema_fields import Migration034
+from .m035_orphan_relationships import Migration035
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -77,6 +78,7 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration032,
     Migration033,
     Migration034,
+    Migration035,
 ]
 
 

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/backend/infrahub/core/migrations/graph/m033_deduplicate_relationship_vertices.py

@@ -89,7 +89,7 @@ class Migration033(GraphMigration):
     """
 
     name: str = "033_deduplicate_relationship_vertices"
-    minimum_version: int = 31
+    minimum_version: int = 32
     queries: Sequence[type[Query]] = [DeduplicateRelationshipVerticesQuery]
 
     async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002

infrahub_server-1.3.8/backend/infrahub/core/migrations/graph/m035_orphan_relationships.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core.migrations.shared import GraphMigration, MigrationResult
+
+from ...query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+
+class CleanupOrphanedRelationshipsQuery(Query):
+    name = "cleanup_orphaned_relationships"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+MATCH (rel:Relationship)-[:IS_RELATED]-(peer:Node)
+WITH DISTINCT rel, peer.uuid AS p_uuid
+WITH rel, count(*) AS num_peers
+WHERE num_peers < 2
+DETACH DELETE rel
+        """
+        self.add_to_query(query)
+
+
+class Migration035(GraphMigration):
+    """
+    Remove Relationship vertices that only have a single peer
+    """
+
+    name: str = "035_clean_up_orphaned_relationships"
+    minimum_version: int = 34
+    queries: Sequence[type[Query]] = [CleanupOrphanedRelationshipsQuery]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        # overrides parent class to skip transaction in case there are a lot of relationships to delete
+        return await self.do_execute(db=db)

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/backend/infrahub/core/node/resource_manager/ip_address_pool.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import ipaddress
 from typing import TYPE_CHECKING, Any
 
+from infrahub import lock
 from infrahub.core import registry
 from infrahub.core.ipam.reconciler import IpamReconciler
 from infrahub.core.query.ipam import get_ip_addresses
@@ -33,54 +34,55 @@ class CoreIPAddressPool(Node):
         prefixlen: int | None = None,
         at: Timestamp | None = None,
     ) -> Node:
-        # Check if there is already a resource allocated with this identifier
-        # if not, pull all existing prefixes and allocated the next available
-
-        if identifier:
-            query_get = await IPAddressPoolGetReserved.init(db=db, pool_id=self.id, identifier=identifier)
-            await query_get.execute(db=db)
-            result = query_get.get_result()
-
-            if result:
-                address = result.get_node("address")
-                # TODO add support for branch, if the node is reserved with this id in another branch we should return an error
-                node = await registry.manager.get_one(db=db, id=address.get("uuid"), branch=branch)
-
-                if node:
-                    return node
-
-        data = data or {}
-
-        address_type = address_type or data.get("address_type") or self.default_address_type.value  # type: ignore[attr-defined]
-        if not address_type:
-            raise ValueError(
-                f"IPAddressPool: {self.name.value} | "  # type: ignore[attr-defined]
-                "An address_type or a default_value type must be provided to allocate a new IP address"
-            )
-
-        ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
-
-        prefixlen = prefixlen or data.get("prefixlen") or self.default_prefix_length.value  # type: ignore[attr-defined]
-
-        next_address = await self.get_next(db=db, prefixlen=prefixlen)
-
-        target_schema = registry.get_node_schema(name=address_type, branch=branch)
-        node = await Node.init(db=db, schema=target_schema, branch=branch, at=at)
-        try:
-            await node.new(db=db, address=str(next_address), ip_namespace=ip_namespace, **data)
-        except ValidationError as exc:
-            raise ValueError(f"IPAddressPool: {self.name.value} | {exc!s}") from exc  # type: ignore[attr-defined]
-        await node.save(db=db, at=at)
-        reconciler = IpamReconciler(db=db, branch=branch)
-        await reconciler.reconcile(ip_value=next_address, namespace=ip_namespace.id, node_uuid=node.get_id())
-
-        if identifier:
-            query_set = await IPAddressPoolSetReserved.init(
-                db=db, pool_id=self.id, identifier=identifier, address_id=node.id, at=at
-            )
-            await query_set.execute(db=db)
-
-        return node
+        async with lock.registry.get(name=self.get_id(), namespace="resource_pool"):
+            # Check if there is already a resource allocated with this identifier
+            # if not, pull all existing prefixes and allocated the next available
+
+            if identifier:
+                query_get = await IPAddressPoolGetReserved.init(db=db, pool_id=self.id, identifier=identifier)
+                await query_get.execute(db=db)
+                result = query_get.get_result()
+
+                if result:
+                    address = result.get_node("address")
+                    # TODO add support for branch, if the node is reserved with this id in another branch we should return an error
+                    node = await registry.manager.get_one(db=db, id=address.get("uuid"), branch=branch)
+
+                    if node:
+                        return node
+
+            data = data or {}
+
+            address_type = address_type or data.get("address_type") or self.default_address_type.value  # type: ignore[attr-defined]
+            if not address_type:
+                raise ValueError(
+                    f"IPAddressPool: {self.name.value} | "  # type: ignore[attr-defined]
+                    "An address_type or a default_value type must be provided to allocate a new IP address"
+                )
+
+            ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
+
+            prefixlen = prefixlen or data.get("prefixlen") or self.default_prefix_length.value  # type: ignore[attr-defined]
+
+            next_address = await self.get_next(db=db, prefixlen=prefixlen)
+
+            target_schema = registry.get_node_schema(name=address_type, branch=branch)
+            node = await Node.init(db=db, schema=target_schema, branch=branch, at=at)
+            try:
+                await node.new(db=db, address=str(next_address), ip_namespace=ip_namespace, **data)
+            except ValidationError as exc:
+                raise ValueError(f"IPAddressPool: {self.name.value} | {exc!s}") from exc  # type: ignore[attr-defined]
+            await node.save(db=db, at=at)
+            reconciler = IpamReconciler(db=db, branch=branch)
+            await reconciler.reconcile(ip_value=next_address, namespace=ip_namespace.id, node_uuid=node.get_id())
+
+            if identifier:
+                query_set = await IPAddressPoolSetReserved.init(
+                    db=db, pool_id=self.id, identifier=identifier, address_id=node.id, at=at
+                )
+                await query_set.execute(db=db)
+
+            return node
 
     async def get_next(self, db: InfrahubDatabase, prefixlen: int | None = None) -> IPAddressType:
         resources = await self.resources.get_peers(db=db)  # type: ignore[attr-defined]

infrahub_server-1.3.8/backend/infrahub/core/node/resource_manager/ip_prefix_pool.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import ipaddress
+from typing import TYPE_CHECKING, Any
+
+from netaddr import IPSet
+
+from infrahub import lock
+from infrahub.core import registry
+from infrahub.core.ipam.reconciler import IpamReconciler
+from infrahub.core.query.ipam import get_subnets
+from infrahub.core.query.resource_manager import (
+    PrefixPoolGetReserved,
+    PrefixPoolSetReserved,
+)
+from infrahub.exceptions import ValidationError
+from infrahub.pools.prefix import get_next_available_prefix
+
+from .. import Node
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.core.ipam.constants import IPNetworkType
+    from infrahub.core.timestamp import Timestamp
+    from infrahub.database import InfrahubDatabase
+
+
+class CoreIPPrefixPool(Node):
+    async def get_resource(
+        self,
+        db: InfrahubDatabase,
+        branch: Branch,
+        identifier: str | None = None,
+        data: dict[str, Any] | None = None,
+        prefixlen: int | None = None,
+        member_type: str | None = None,
+        prefix_type: str | None = None,
+        at: Timestamp | None = None,
+    ) -> Node:
+        async with lock.registry.get(name=self.get_id(), namespace="resource_pool"):
+            # Check if there is already a resource allocated with this identifier
+            # if not, pull all existing prefixes and allocated the next available
+            if identifier:
+                query_get = await PrefixPoolGetReserved.init(db=db, pool_id=self.id, identifier=identifier)
+                await query_get.execute(db=db)
+                result = query_get.get_result()
+                if result:
+                    prefix = result.get_node("prefix")
+                    # TODO add support for branch, if the node is reserved with this id in another branch we should return an error
+                    node = await registry.manager.get_one(db=db, id=prefix.get("uuid"), branch=branch)
+                    if node:
+                        return node
+
+            ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
+
+            data = data or {}
+
+            prefixlen = prefixlen or data.get("prefixlen", None) or self.default_prefix_length.value  # type: ignore[attr-defined]
+            if not prefixlen:
+                raise ValueError(
+                    f"IPPrefixPool: {self.name.value} | "  # type: ignore[attr-defined]
+                    "A prefixlen or a default_value must be provided to allocate a new prefix"
+                )
+
+            next_prefix = await self.get_next(db=db, prefixlen=prefixlen)
+
+            prefix_type = prefix_type or data.get("prefix_type", None) or self.default_prefix_type.value  # type: ignore[attr-defined]
+            if not prefix_type:
+                raise ValueError(
+                    f"IPPrefixPool: {self.name.value} | "  # type: ignore[attr-defined]
+                    "A prefix_type or a default_value type must be provided to allocate a new prefix"
+                )
+
+            member_type = member_type or data.get("member_type", None) or self.default_member_type.value.value  # type: ignore[attr-defined]
+            data["member_type"] = member_type
+
+            target_schema = registry.get_node_schema(name=prefix_type, branch=branch)
+            node = await Node.init(db=db, schema=target_schema, branch=branch, at=at)
+            try:
+                await node.new(db=db, prefix=str(next_prefix), ip_namespace=ip_namespace, **data)
+            except ValidationError as exc:
+                raise ValueError(f"IPPrefixPool: {self.name.value} | {exc!s}") from exc  # type: ignore[attr-defined]
+            await node.save(db=db, at=at)
+            reconciler = IpamReconciler(db=db, branch=branch)
+            await reconciler.reconcile(ip_value=next_prefix, namespace=ip_namespace.id, node_uuid=node.get_id())
+
+            if identifier:
+                query_set = await PrefixPoolSetReserved.init(
+                    db=db, pool_id=self.id, identifier=identifier, prefix_id=node.id, at=at
+                )
+                await query_set.execute(db=db)
+
+            return node
+
+    async def get_next(self, db: InfrahubDatabase, prefixlen: int) -> IPNetworkType:
+        resources = await self.resources.get_peers(db=db)  # type: ignore[attr-defined]
+        ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
+
+        try:
+            weighted_resources = sorted(resources.values(), key=lambda r: r.allocation_weight.value or 0, reverse=True)
+        except AttributeError:
+            weighted_resources = list(resources.values())
+
+        for resource in weighted_resources:
+            subnets = await get_subnets(
+                db=db,
+                ip_prefix=ipaddress.ip_network(resource.prefix.value),  # type: ignore[attr-defined]
+                namespace=ip_namespace,
+                branch=self._branch,
+                branch_agnostic=True,
+            )
+
+            pool = IPSet([resource.prefix.value])
+            for subnet in subnets:
+                pool.remove(addr=str(subnet.prefix))
+
+            try:
+                prefix_ver = ipaddress.ip_network(resource.prefix.value).version
+                next_available = get_next_available_prefix(pool=pool, prefix_length=prefixlen, prefix_ver=prefix_ver)
+                return next_available
+            except ValueError:
+                continue
+
+        raise IndexError("No more resources available")

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/backend/infrahub/core/node/resource_manager/number_pool.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from infrahub import lock
 from infrahub.core import registry
 from infrahub.core.query.resource_manager import NumberPoolGetReserved, NumberPoolGetUsed, NumberPoolSetReserved
 from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
@@ -62,24 +63,25 @@ class CoreNumberPool(Node):
         identifier: str | None = None,
         at: Timestamp | None = None,
     ) -> int:
-        # NOTE: ideally we should use the HFID as the identifier (if available)
-        # one of the challenge with using the HFID is that it might change over time
-        # so we need to ensure that the identifier is stable, or we need to handle the case where the identifier changes
-        identifier = identifier or node.get_id()
-
-        # Check if there is already a resource allocated with this identifier
-        # if not, pull all existing number and allocate the next available
-        # TODO add support for branch, if the node is reserved with this id in another branch we should return an error
-        query_get = await NumberPoolGetReserved.init(db=db, branch=branch, pool_id=self.id, identifier=identifier)
-        await query_get.execute(db=db)
-        reservation = query_get.get_reservation()
-        if reservation is not None:
-            return reservation
-
-        # If we have not returned a value we need to find one if avaiable
-        number = await self.get_next(db=db, branch=branch, attribute=attribute)
-        await self.reserve(db=db, number=number, identifier=identifier, at=at)
-        return number
+        async with lock.registry.get(name=self.get_id(), namespace="resource_pool"):
+            # NOTE: ideally we should use the HFID as the identifier (if available)
+            # one of the challenge with using the HFID is that it might change over time
+            # so we need to ensure that the identifier is stable, or we need to handle the case where the identifier changes
+            identifier = identifier or node.get_id()
+
+            # Check if there is already a resource allocated with this identifier
+            # if not, pull all existing number and allocate the next available
+            # TODO add support for branch, if the node is reserved with this id in another branch we should return an error
+            query_get = await NumberPoolGetReserved.init(db=db, branch=branch, pool_id=self.id, identifier=identifier)
+            await query_get.execute(db=db)
+            reservation = query_get.get_reservation()
+            if reservation is not None:
+                return reservation
+
+            # If we have not returned a value we need to find one if avaiable
+            number = await self.get_next(db=db, branch=branch, attribute=attribute)
+            await self.reserve(db=db, number=number, identifier=identifier, at=at)
+            return number
 
     async def get_next(self, db: InfrahubDatabase, branch: Branch, attribute: AttributeSchema) -> int:
         taken = await self.get_used(db=db, branch=branch)

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/backend/infrahub/core/query/branch.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from infrahub import config
+from infrahub.core.constants import GLOBAL_BRANCH_NAME
 from infrahub.core.query import Query, QueryType
 
 if TYPE_CHECKING:
@@ -21,33 +22,49 @@ class DeleteBranchRelationshipsQuery(Query):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         query = """
-// delete all relationships on this branch
-MATCH (s)-[r1]-(d)
-WHERE r1.branch = $branch_name
-CALL (r1) {
-  DELETE r1
+// --------------
+// for every Node created on this branch (it's about to be deleted), find any agnostic relationships
+// connected to the Node and delete them
+// --------------
+OPTIONAL MATCH (:Root)<-[e:IS_PART_OF {status: "active"}]-(n:Node)
+WHERE e.branch = $branch_name
+CALL (n) {
+    OPTIONAL MATCH (n)-[:IS_RELATED {branch: $global_branch_name}]-(rel:Relationship)
+    DETACH DELETE rel
 } IN TRANSACTIONS
 
-// check for any orphaned Node vertices and delete them
-WITH collect(DISTINCT s.uuid) + collect(DISTINCT d.uuid) AS nodes_uuids
-MATCH (s2:Node)-[r2]-(d2)
-WHERE NOT exists((s2)-[:IS_PART_OF]-(:Root))
-AND s2.uuid IN nodes_uuids
-CALL (r2) {
-  DELETE r2
+// reduce the results to a single row
+WITH 1 AS one
+LIMIT 1
+
+// --------------
+// for every edge on this branch, delete it
+// --------------
+MATCH (s)-[r]->(d)
+WHERE r.branch = $branch_name
+CALL (r) {
+    DELETE r
 } IN TRANSACTIONS
 
-// reduce results to a single row
-WITH 1 AS one LIMIT 1
-
-// find any orphaned vertices and delete them
-MATCH (n)
-WHERE NOT exists((n)--())
-CALL (n) {
-  DELETE n
+// --------------
+// get the database IDs of every vertex linked to a deleted edge
+// --------------
+WITH DISTINCT elementId(s) AS s_id, elementId(d) AS d_id
+WITH collect(s_id) + collect(d_id) AS vertex_ids
+UNWIND vertex_ids AS vertex_id
+
+// --------------
+// delete any vertices that are now orphaned
+// --------------
+CALL (vertex_id) {
+    MATCH (n)
+    WHERE elementId(n) = vertex_id
+    AND NOT exists((n)--())
+    DELETE n
 } IN TRANSACTIONS
         """
         self.params["branch_name"] = self.branch_name
+        self.params["global_branch_name"] = GLOBAL_BRANCH_NAME
         self.add_to_query(query)
 
 

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/backend/infrahub/core/query/node.py

@@ -157,19 +157,21 @@ class NodeCreateAllQuery(NodeQuery):
         relationships: list[RelationshipCreateData] = []
         for rel_name in self.node._relationships:
             rel_manager: RelationshipManager = getattr(self.node, rel_name)
-            # Fetch all relationship peers through a single database call for performances.
-            peers = await rel_manager.get_peers(db=db, branch_agnostic=self.branch_agnostic)
+            if rel_manager.schema.cardinality == "many":
+                # Fetch all relationship peers through a single database call for performances.
+                peers = await rel_manager.get_peers(db=db, branch_agnostic=self.branch_agnostic)
 
             for rel in rel_manager._relationships:
-                try:
-                    rel.set_peer(value=peers[rel.get_peer_id()])
-                except KeyError:
-                    pass
-                except ValueError:
-                    # Relationship has not been initialized yet, it means the peer does not exist in db yet
-                    # typically because it will be allocated from a ressource pool. In that case, the peer
-                    # will be fetched using `rel.resolve` later.
-                    pass
+                if rel_manager.schema.cardinality == "many":
+                    try:
+                        rel.set_peer(value=peers[rel.get_peer_id()])
+                    except KeyError:
+                        pass
+                    except ValueError:
+                        # Relationship has not been initialized yet, it means the peer does not exist in db yet
+                        # typically because it will be allocated from a ressource pool. In that case, the peer
+                        # will be fetched using `rel.resolve` later.
+                        pass
 
                 rel_create_data = await rel.get_create_data(db=db, at=at)
                 if rel_create_data.peer_branch_level > deepest_branch_level or (

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/backend/infrahub/core/schema/node_schema.py

@@ -53,11 +53,6 @@ class NodeSchema(GeneratedNodeSchema):
                         f"{self.kind}.{attribute.name} inherited from {interface.namespace}{interface.name} must be the same kind "
                         f'["{interface_attr.kind}", "{attribute.kind}"]'
                     )
-                if attribute.optional != interface_attr.optional:
-                    raise ValueError(
-                        f"{self.kind}.{attribute.name} inherited from {interface.namespace}{interface.name} must have the same value for property "
-                        f'"optional" ["{interface_attr.optional}", "{attribute.optional}"]'
-                    )
 
         for relationship in self.relationships:
             if (

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/backend/infrahub/core/schema/schema_branch.py

@@ -226,8 +226,8 @@ class SchemaBranch:
     def update(self, schema: SchemaBranch) -> None:
         """Update another SchemaBranch into this one."""
 
-        local_kinds = list(self.nodes.keys()) + list(self.generics.keys())
-        other_kinds = list(schema.nodes.keys()) + list(schema.generics.keys())
+        local_kinds = self.all_names
+        other_kinds = schema.all_names
 
         in_both, _, other_only = compare_lists(list1=local_kinds, list2=other_kinds)
 

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/backend/infrahub/graphql/app.py

@@ -231,6 +231,7 @@ class InfrahubGraphQLApp:
                 operation_name=operation_name,
                 branch=branch,
             )
+        impacted_models = analyzed_query.query_report.impacted_models
 
         await self._evaluate_permissions(
             db=db,
@@ -282,7 +283,7 @@ class InfrahubGraphQLApp:
         GRAPHQL_QUERY_HEIGHT_METRICS.labels(**labels).observe(await analyzed_query.calculate_height())
         # GRAPHQL_QUERY_VARS_METRICS.labels(**labels).observe(len(analyzed_query.variables))
         GRAPHQL_TOP_LEVEL_QUERIES_METRICS.labels(**labels).observe(analyzed_query.nbr_queries)
-        GRAPHQL_QUERY_OBJECTS_METRICS.labels(**labels).observe(len(analyzed_query.query_report.impacted_models))
+        GRAPHQL_QUERY_OBJECTS_METRICS.labels(**labels).observe(len(impacted_models))
 
         _, errors = analyzed_query.is_valid
         if errors:

{infrahub_server-1.3.6 → infrahub_server-1.3.8}/backend/infrahub/graphql/context.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from infrahub.core.constants import GlobalPermissions, InfrahubKind
 from infrahub.core.manager import NodeManager
 from infrahub.exceptions import NodeNotFoundError, ValidationError
-from infrahub.permissions.globals import define_global_permission_from_branch
+from infrahub.permissions import define_global_permission_from_branch
 
 if TYPE_CHECKING:
     from .initialization import GraphqlContext