infrahub-server 1.5.0b1__py3-none-any.whl → 1.5.0b2__py3-none-any.whl

infrahub/graphql/mutations/ipam.py

@@ -20,7 +20,7 @@ from infrahub.lock import InfrahubMultiLock
 from infrahub.log import get_logger
 
 from ...core.node.create import create_node
-from ...core.node.lock_utils import build_object_lock_name
+from ...core.node.lock_utils import build_object_lock_name, get_lock_names_on_object_mutation
 from .main import DeleteResult, InfrahubMutationMixin, InfrahubMutationOptions, build_graphql_response
 from .node_getter.by_default_filter import MutationNodeGetterByDefaultFilter
 
@@ -108,11 +108,11 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
     @staticmethod
-    def _get_lock_name(namespace_id: str, branch: Branch) -> str | None:
+    def _get_lock_names(namespace_id: str, branch: Branch) -> list[str]:
         if not branch.is_default:
             # Do not lock on other branches as reconciliation will be performed at least when merging in main branch.
-            return None
-        return build_object_lock_name(InfrahubKind.IPADDRESS + "_" + namespace_id)
+            return []
+        return [build_object_lock_name(InfrahubKind.IPADDRESS + "_" + namespace_id)]
 
     @classmethod
     async def _mutate_create_object_and_reconcile(
@@ -150,17 +150,13 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
         ip_address = ipaddress.ip_interface(data["address"]["value"])
         namespace_id = await validate_namespace(db=db, branch=branch, data=data)
 
-        async with db.start_transaction() as dbt:
-            if lock_name := cls._get_lock_name(namespace_id, branch):
-                async with InfrahubMultiLock(lock_registry=lock.registry, locks=[lock_name]):
-                    reconciled_address = await cls._mutate_create_object_and_reconcile(
-                        data=data, branch=branch, db=dbt, ip_address=ip_address, namespace_id=namespace_id
-                    )
-            else:
+        lock_names = cls._get_lock_names(namespace_id, branch)
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
+            async with db.start_transaction() as dbt:
                 reconciled_address = await cls._mutate_create_object_and_reconcile(
                     data=data, branch=branch, db=dbt, ip_address=ip_address, namespace_id=namespace_id
                 )
-            graphql_response = await build_graphql_response(info=info, db=dbt, obj=reconciled_address)
+                graphql_response = await build_graphql_response(info=info, db=dbt, obj=reconciled_address)
 
         return reconciled_address, cls(**graphql_response)
 
@@ -206,18 +202,28 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
         namespace = await address.ip_namespace.get_peer(db)
         namespace_id = await validate_namespace(db=db, branch=branch, data=data, existing_namespace_id=namespace.id)
 
-        async with db.start_transaction() as dbt:
-            if lock_name := cls._get_lock_name(namespace_id, branch):
-                async with InfrahubMultiLock(lock_registry=lock.registry, locks=[lock_name]):
+        # Prepare a clone to compute locks without triggering pool allocations
+        preview_obj = await NodeManager.get_one_by_id_or_default_filter(
+            db=db,
+            kind=address.get_kind(),
+            id=address.get_id(),
+            branch=branch,
+        )
+        await preview_obj.from_graphql(db=db, data=data, process_pools=False)
+
+        schema_branch = db.schema.get_schema_branch(name=branch.name)
+        lock_names = get_lock_names_on_object_mutation(node=preview_obj, schema_branch=schema_branch)
+
+        namespace_lock_names = cls._get_lock_names(namespace_id, branch)
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=namespace_lock_names):
+            # FIXME: do not lock when data does not contain uniqueness constraint fields or resource pool allocations
+            async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names, metrics=False):
+                async with db.start_transaction() as dbt:
                     reconciled_address = await cls._mutate_update_object_and_reconcile(
                         info=info, data=data, branch=branch, address=address, namespace_id=namespace_id, db=dbt
                     )
-            else:
-                reconciled_address = await cls._mutate_update_object_and_reconcile(
-                    info=info, data=data, branch=branch, address=address, namespace_id=namespace_id, db=dbt
-                )
 
-            result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=reconciled_address)
+                    result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=reconciled_address)
 
         return address, result
 
@@ -269,11 +275,11 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
     @staticmethod
-    def _get_lock_name(namespace_id: str) -> str | None:
+    def _get_lock_names(namespace_id: str) -> list[str]:
         # IPPrefix has some cardinality-one relationships involved (parent/child/ip_address),
         # so we need to lock on any branch to avoid creating multiple peers for these relationships
         # during concurrent ipam reconciliations.
-        return build_object_lock_name(InfrahubKind.IPPREFIX + "_" + namespace_id)
+        return [build_object_lock_name(InfrahubKind.IPPREFIX + "_" + namespace_id)]
 
     @classmethod
     async def _mutate_create_object_and_reconcile(
@@ -306,9 +312,9 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         db = database or graphql_context.db
         namespace_id = await validate_namespace(db=db, branch=branch, data=data)
 
-        async with db.start_transaction() as dbt:
-            lock_name = cls._get_lock_name(namespace_id)
-            async with InfrahubMultiLock(lock_registry=lock.registry, locks=[lock_name]):
+        lock_names = cls._get_lock_names(namespace_id)
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
+            async with db.start_transaction() as dbt:
                 reconciled_prefix = await cls._mutate_create_object_and_reconcile(
                     data=data, branch=branch, db=dbt, namespace_id=namespace_id
                 )
@@ -356,13 +362,26 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         namespace = await prefix.ip_namespace.get_peer(db)
         namespace_id = await validate_namespace(db=db, branch=branch, data=data, existing_namespace_id=namespace.id)
 
-        async with db.start_transaction() as dbt:
-            lock_name = cls._get_lock_name(namespace_id)
-            async with InfrahubMultiLock(lock_registry=lock.registry, locks=[lock_name]):
-                reconciled_prefix = await cls._mutate_update_object_and_reconcile(
-                    info=info, data=data, prefix=prefix, db=dbt, namespace_id=namespace_id, branch=branch
-                )
-            result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=reconciled_prefix)
+        # Prepare a clone to compute locks without triggering pool allocations
+        preview_obj = await NodeManager.get_one_by_id_or_default_filter(
+            db=db,
+            kind=prefix.get_kind(),
+            id=prefix.get_id(),
+            branch=branch,
+        )
+        await preview_obj.from_graphql(db=db, data=data, process_pools=False)
+
+        schema_branch = db.schema.get_schema_branch(name=branch.name)
+        lock_names = get_lock_names_on_object_mutation(node=preview_obj, schema_branch=schema_branch)
+
+        namespace_lock_names = cls._get_lock_names(namespace_id)
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=namespace_lock_names):
+            async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names, metrics=False):
+                async with db.start_transaction() as dbt:
+                    reconciled_prefix = await cls._mutate_update_object_and_reconcile(
+                        info=info, data=data, prefix=prefix, db=dbt, namespace_id=namespace_id, branch=branch
+                    )
+                    result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=reconciled_prefix)
 
         return prefix, result
 
@@ -421,9 +440,9 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         namespace_rels = await prefix.ip_namespace.get_relationships(db=db)
         namespace_id = namespace_rels[0].peer_id
 
-        async with graphql_context.db.start_transaction() as dbt:
-            lock_name = cls._get_lock_name(namespace_id)
-            async with InfrahubMultiLock(lock_registry=lock.registry, locks=[lock_name]):
+        lock_names = cls._get_lock_names(namespace_id)
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
+            async with graphql_context.db.start_transaction() as dbt:
                 reconciled_prefix = await cls._reconcile_prefix(
                     branch=branch, db=dbt, prefix=prefix, namespace_id=namespace_id, is_delete=True
                 )

infrahub/graphql/mutations/main.py

@@ -28,7 +28,7 @@ from infrahub.lock import InfrahubMultiLock
 from infrahub.log import get_log_data, get_logger
 from infrahub.profiles.node_applier import NodeProfilesApplier
 
-from ...core.node.lock_utils import get_kind_lock_names_on_object_mutation
+from ...core.node.lock_utils import get_lock_names_on_object_mutation
 from .node_getter.by_default_filter import MutationNodeGetterByDefaultFilter
 
 if TYPE_CHECKING:
@@ -180,41 +180,40 @@ class InfrahubMutationMixin:
         Wrapper around mutate_update to potentially activate locking and call it within a database transaction.
         """
 
-        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, data=dict(data)
+        # Prepare a clone to compute locks without triggering pool allocations
+        preview_obj = await NodeManager.get_one_by_id_or_default_filter(
+            db=db,
+            kind=obj.get_kind(),
+            id=obj.get_id(),
+            branch=branch,
         )
+        await preview_obj.from_graphql(db=db, data=data, process_pools=False)
 
-        if db.is_transaction:
-            if lock_names:
-                async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
-                    obj = await cls.mutate_update_object(
-                        db=db, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
-                    )
-            else:
+        schema_branch = db.schema.get_schema_branch(name=branch.name)
+        lock_names = get_lock_names_on_object_mutation(node=preview_obj, schema_branch=schema_branch)
+
+        # FIXME: do not lock when data does not contain uniqueness constraint fields or resource pool allocations
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names, metrics=False):
+            if db.is_transaction:
                 obj = await cls.mutate_update_object(
                     db=db, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
                 )
-            result = await cls.mutate_update_to_graphql(db=db, info=info, obj=obj)
-            return obj, result
 
-        async with db.start_transaction() as dbt:
-            if lock_names:
-                async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
-                    obj = await cls.mutate_update_object(
-                        db=dbt,
-                        info=info,
-                        data=data,
-                        branch=branch,
-                        obj=obj,
-                        skip_uniqueness_check=skip_uniqueness_check,
-                    )
-            else:
+                result = await cls.mutate_update_to_graphql(db=db, info=info, obj=obj)
+                return obj, result
+
+            async with db.start_transaction() as dbt:
                 obj = await cls.mutate_update_object(
-                    db=dbt, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
+                    db=dbt,
+                    info=info,
+                    data=data,
+                    branch=branch,
+                    obj=obj,
+                    skip_uniqueness_check=skip_uniqueness_check,
                 )
-            result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=obj)
-            return obj, result
+
+                result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=obj)
+                return obj, result
 
     @classmethod
     @retry_db_transaction(name="object_update")

infrahub/graphql/schema_sort.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from graphql.language.ast import (
+    DocumentNode,
+    EnumTypeDefinitionNode,
+    EnumValueDefinitionNode,
+    FieldDefinitionNode,
+    InputObjectTypeDefinitionNode,
+    InputValueDefinitionNode,
+    InterfaceTypeDefinitionNode,
+    NamedTypeNode,
+    ObjectTypeDefinitionNode,
+)
+
+if TYPE_CHECKING:
+    from graphql import DefinitionNode
+
+
+def _sort_arguments(args: tuple[InputValueDefinitionNode, ...] | None) -> list[InputValueDefinitionNode] | None:
+    """Sort arguments (filters) of a field alphabetically by name.
+
+    Args:
+        args: List of input value definition nodes to sort, or None.
+
+    Returns:
+        Sorted list of input value definition nodes, or None if input was None.
+    """
+    if not args:
+        return None
+    return sorted(args, key=lambda a: a.name.value)
+
+
+def _sort_fields(fields: tuple[FieldDefinitionNode, ...] | None) -> list[FieldDefinitionNode] | None:
+    """Sort fields and their arguments alphabetically.
+
+    Args:
+        fields: List of field definition nodes to sort, or None.
+
+    Returns:
+        Sorted list of field definition nodes with sorted arguments, or None if input was None.
+    """
+    if not fields:
+        return None
+    sorted_fields = []
+    for field in sorted(fields, key=lambda fld: fld.name.value):
+        sorted_args = _sort_arguments(field.arguments)
+        sorted_fields.append(
+            FieldDefinitionNode(
+                name=field.name,
+                type=field.type,
+                arguments=sorted_args,
+                directives=field.directives,
+                description=field.description,
+                loc=field.loc,
+            )
+        )
+    return sorted_fields
+
+
+def _sort_enum_values(values: tuple[EnumValueDefinitionNode, ...] | None) -> list[EnumValueDefinitionNode] | None:
+    """Sort enum values alphabetically by name.
+
+    Args:
+        values: List of enum value definition nodes to sort, or None.
+
+    Returns:
+        Sorted list of enum value definition nodes, or None if input was None.
+    """
+    if not values:
+        return None
+    return sorted(values, key=lambda v: v.name.value)
+
+
+def _sort_input_fields(fields: tuple[InputValueDefinitionNode, ...] | None) -> list[InputValueDefinitionNode] | None:
+    """Sort input object fields alphabetically by name.
+
+    Args:
+        fields: List of input value definition nodes to sort, or None.
+
+    Returns:
+        Sorted list of input value definition nodes, or None if input was None.
+    """
+    if not fields:
+        return None
+    return sorted(fields, key=lambda f: f.name.value)
+
+
+def _sort_interfaces(interfaces: tuple[NamedTypeNode, ...] | None) -> list[NamedTypeNode] | None:
+    """Sort interface implementations alphabetically by name.
+
+    Args:
+        interfaces: Tuple of named type nodes representing interfaces, or None.
+
+    Returns:
+        Sorted list of named type nodes, or None if input was None.
+    """
+    if not interfaces:
+        return None
+    return sorted(interfaces, key=lambda i: i.name.value)
+
+
+def sort_schema_ast(document: DocumentNode) -> DocumentNode:
+    """Return a new DocumentNode with all definitions, fields, and arguments sorted alphabetically.
+
+    This function recursively sorts all GraphQL schema elements including:
+    - Type definitions (objects, interfaces, enums, input objects)
+    - Field definitions and their arguments
+    - Enum values
+    - Input object fields
+
+    Args:
+        document: The GraphQL document node containing schema definitions.
+
+    Returns:
+        A new DocumentNode with all elements sorted alphabetically by name.
+    """
+
+    sorted_definitions: list[
+        ObjectTypeDefinitionNode
+        | InterfaceTypeDefinitionNode
+        | EnumTypeDefinitionNode
+        | InputObjectTypeDefinitionNode
+        | DefinitionNode
+    ] = []
+
+    for definition in sorted(
+        document.definitions, key=lambda d: getattr(d.name, "value", "") if hasattr(d, "name") and d.name else ""
+    ):
+        if isinstance(definition, (ObjectTypeDefinitionNode, InterfaceTypeDefinitionNode)):
+            sorted_fields = _sort_fields(definition.fields)
+            sorted_interfaces = _sort_interfaces(definition.interfaces)
+            sorted_definitions.append(
+                definition.__class__(
+                    name=definition.name,
+                    interfaces=sorted_interfaces,
+                    directives=definition.directives,
+                    fields=sorted_fields,
+                    description=definition.description,
+                    loc=definition.loc,
+                )
+            )
+
+        elif isinstance(definition, EnumTypeDefinitionNode):
+            sorted_values = _sort_enum_values(definition.values)
+            sorted_definitions.append(
+                EnumTypeDefinitionNode(
+                    name=definition.name,
+                    directives=definition.directives,
+                    values=sorted_values,
+                    description=definition.description,
+                    loc=definition.loc,
+                )
+            )
+        elif isinstance(definition, InputObjectTypeDefinitionNode):
+            sorted_inputs = _sort_input_fields(definition.fields)
+            sorted_definitions.append(
+                InputObjectTypeDefinitionNode(
+                    name=definition.name,
+                    directives=definition.directives,
+                    fields=sorted_inputs,
+                    description=definition.description,
+                    loc=definition.loc,
+                )
+            )
+        else:
+            sorted_definitions.append(definition)
+
+    return DocumentNode(definitions=sorted_definitions)

infrahub/graphql/types/branch.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Boolean, Field, String
+from graphene import Boolean, Field, Int, String
 
 from infrahub.core.branch import Branch
 from infrahub.core.constants import GLOBAL_BRANCH_NAME
 
+from .enums import InfrahubBranchStatus
 from .standard_node import InfrahubObjectType
 
 if TYPE_CHECKING:
@@ -19,6 +20,8 @@ class BranchType(InfrahubObjectType):
     description = String(required=False)
     origin_branch = String(required=False)
     branched_from = String(required=False)
+    status = InfrahubBranchStatus(required=True)
+    graph_version = Int(required=False)
     created_at = String(required=False)
     sync_with_git = Boolean(required=False)
     is_default = Boolean(required=False)

infrahub/graphql/types/enums.py

@@ -1,6 +1,7 @@
 from graphene import Enum
 
 from infrahub.core import constants
+from infrahub.core.branch.enums import BranchStatus
 from infrahub.permissions import constants as permission_constants
 
 CheckType = Enum.from_enum(constants.CheckType)
@@ -10,3 +11,5 @@ DiffAction = Enum.from_enum(constants.DiffAction)
 Severity = Enum.from_enum(constants.Severity)
 
 BranchRelativePermissionDecision = Enum.from_enum(permission_constants.BranchRelativePermissionDecision)
+
+InfrahubBranchStatus = Enum.from_enum(BranchStatus)

infrahub/hfid/tasks.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import cast
 
+from infrahub_sdk.exceptions import URLNotFoundError
 from prefect import flow
 from prefect.logging import get_run_logger
 
@@ -56,12 +57,17 @@ async def hfid_update_value(
         log.debug(f"Ignoring to update {obj} with existing value on human_friendly_id={obj.hfid_value}")
         return
 
-    await client.execute_graphql(
-        query=UPDATE_HFID,
-        variables={"id": obj.node_id, "kind": node_kind, "value": rendered_hfid},
-        branch_name=branch_name,
-    )
-    log.info(f"Updating {node_kind}.human_friendly_id='{rendered_hfid}' ({obj.node_id})")
+    try:
+        await client.execute_graphql(
+            query=UPDATE_HFID,
+            variables={"id": obj.node_id, "kind": node_kind, "value": rendered_hfid},
+            branch_name=branch_name,
+        )
+        log.info(f"Updating {node_kind}.human_friendly_id='{rendered_hfid}' ({obj.node_id})")
+    except URLNotFoundError:
+        log.warning(
+            f"Updating {node_kind}.human_friendly_id='{rendered_hfid}' ({obj.node_id}) failed for branch {branch_name} (branch not found)"
+        )
 
 
 @flow(
@@ -151,7 +157,7 @@ async def hfid_setup(context: InfrahubContext, branch_name: str | None = None, e
 
 @flow(
     name="trigger-update-hfid",
-    flow_run_name="Trigger updates for display labels for kind",
+    flow_run_name="Trigger updates for HFID for {kind}",
 )
 async def trigger_update_hfid(
     branch_name: str,

infrahub/lock.py

@@ -5,6 +5,7 @@ import time
 import uuid
 from asyncio import Lock as LocalLock
 from asyncio import sleep
+from contextvars import ContextVar
 from typing import TYPE_CHECKING
 
 import redis.asyncio as redis
@@ -50,9 +51,12 @@ GLOBAL_GRAPH_LOCK = "global.graph"
 class InfrahubMultiLock:
     """Context manager to allow multiple locks to be reserved together"""
 
-    def __init__(self, lock_registry: InfrahubLockRegistry, locks: list[str] | None = None) -> None:
+    def __init__(
+        self, lock_registry: InfrahubLockRegistry, locks: list[str] | None = None, metrics: bool = True
+    ) -> None:
         self.registry = lock_registry
         self.locks = locks or []
+        self.metrics = metrics
 
     async def __aenter__(self):
         await self.acquire()
@@ -67,11 +71,11 @@ class InfrahubMultiLock:
 
     async def acquire(self) -> None:
         for lock in self.locks:
-            await self.registry.get(name=lock).acquire()
+            await self.registry.get(name=lock, metrics=self.metrics).acquire()
 
     async def release(self) -> None:
         for lock in reversed(self.locks):
-            await self.registry.get(name=lock).release()
+            await self.registry.get(name=lock, metrics=self.metrics).release()
 
 
 class NATSLock:
@@ -123,6 +127,7 @@ class InfrahubLock:
         connection: redis.Redis | InfrahubServices | None = None,
         local: bool | None = None,
         in_multi: bool = False,
+        metrics: bool = True,
     ) -> None:
         self.use_local: bool | None = local
         self.local: LocalLock = None
@@ -133,6 +138,8 @@ class InfrahubLock:
         self.lock_type: str = "multi" if self.in_multi else "individual"
         self._acquire_time: int | None = None
         self.event = asyncio.Event()
+        self._recursion_var: ContextVar[int | None] = ContextVar(f"infrahub_lock_recursion_{self.name}", default=None)
+        self.metrics = metrics
 
         if not self.connection or (self.use_local is None and name.startswith("local.")):
             self.use_local = True
@@ -167,21 +174,47 @@ class InfrahubLock:
         await self.release()
 
     async def acquire(self) -> None:
-        with LOCK_ACQUIRE_TIME_METRICS.labels(self.name, self.lock_type).time():
-            if not self.use_local:
-                await self.remote.acquire(token=f"{current_timestamp()}::{WORKER_IDENTITY}")
-            else:
-                await self.local.acquire()
+        depth = self._recursion_var.get()
+        if depth is not None:
+            self._recursion_var.set(depth + 1)
+            return
+
+        if self.metrics:
+            with LOCK_ACQUIRE_TIME_METRICS.labels(self.name, self.lock_type).time():
+                if not self.use_local:
+                    await self.remote.acquire(token=f"{current_timestamp()}::{WORKER_IDENTITY}")
+                else:
+                    await self.local.acquire()
+        elif not self.use_local:
+            await self.remote.acquire(token=f"{current_timestamp()}::{WORKER_IDENTITY}")
+        else:
+            await self.local.acquire()
+
         self.acquire_time = time.time_ns()
         self.event.clear()
+        self._recursion_var.set(1)
 
     async def release(self) -> None:
-        duration_ns = time.time_ns() - self.acquire_time
-        LOCK_RESERVE_TIME_METRICS.labels(self.name, self.lock_type).observe(duration_ns / 1000000000)
+        depth = self._recursion_var.get()
+        if depth is None:
+            raise RuntimeError("Lock release attempted without ownership context.")
+
+        if depth > 1:
+            self._recursion_var.set(depth - 1)
+            return
+
+        if self.acquire_time is not None:
+            duration_ns = time.time_ns() - self.acquire_time
+            if self.metrics:
+                LOCK_RESERVE_TIME_METRICS.labels(self.name, self.lock_type).observe(duration_ns / 1000000000)
+            self.acquire_time = None
+
         if not self.use_local:
             await self.remote.release()
         else:
             self.local.release()
+
+        self._recursion_var.set(None)
         self.event.set()
 
     async def locked(self) -> bool:
@@ -272,11 +305,18 @@ class InfrahubLockRegistry:
         return self.locks[lock_name]
 
     def get(
-        self, name: str, namespace: str | None = None, local: bool | None = None, in_multi: bool = False
+        self,
+        name: str,
+        namespace: str | None = None,
+        local: bool | None = None,
+        in_multi: bool = False,
+        metrics: bool = True,
     ) -> InfrahubLock:
         lock_name = self.name_generator.generate_name(name=name, namespace=namespace, local=local)
         if lock_name not in self.locks:
-            self.locks[lock_name] = InfrahubLock(name=lock_name, connection=self.connection, in_multi=in_multi)
+            self.locks[lock_name] = InfrahubLock(
+                name=lock_name, connection=self.connection, in_multi=in_multi, metrics=metrics
+            )
         return self.locks[lock_name]
 
     def local_schema_lock(self) -> LocalLock:

infrahub/message_bus/types.py

@@ -89,7 +89,8 @@ class ProposedChangeArtifactDefinition(BaseModel):
     definition_id: str
     definition_name: str
     artifact_name: str
-    query_name: str
+    query_name: str  # Deprecated
+    query_id: str
     query_models: list[str]
     repository_id: str
     transform_kind: str

infrahub/permissions/constants.py

@@ -30,6 +30,7 @@ GLOBAL_PERMISSION_DENIAL_MESSAGE = {
     GlobalPermissions.MANAGE_ACCOUNTS.value: "You are not allowed to manage user accounts, groups or roles",
     GlobalPermissions.MANAGE_PERMISSIONS.value: "You are not allowed to manage permissions",
     GlobalPermissions.MANAGE_REPOSITORIES.value: "You are not allowed to manage repositories",
+    GlobalPermissions.UPDATE_OBJECT_HFID_DISPLAY_LABEL.value: "You are not allowed to update human friendly IDs and display labels ad hoc",
 }
 
 GLOBAL_PERMISSION_DESCRIPTION = {
@@ -42,4 +43,5 @@ GLOBAL_PERMISSION_DESCRIPTION = {
     GlobalPermissions.MANAGE_PERMISSIONS: "Allow a user to manage permissions",
     GlobalPermissions.MANAGE_REPOSITORIES: "Allow a user to manage repositories",
     GlobalPermissions.SUPER_ADMIN: "Allow a user to do anything",
+    GlobalPermissions.UPDATE_OBJECT_HFID_DISPLAY_LABEL: "Allow a user to update objects' display labels and human friendly IDs ad hoc",
 }