infrahub-server 1.4.13__py3-none-any.whl → 1.5.0__py3-none-any.whl

infrahub/core/manager.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from copy import copy
-from functools import reduce
 from typing import TYPE_CHECKING, Any, Iterable, Literal, TypeVar, overload
 
 from infrahub_sdk.utils import deep_merge_dict, is_valid_uuid
@@ -11,9 +10,7 @@ from infrahub.core.node import Node
 from infrahub.core.node.delete_validator import NodeDeleteValidator
 from infrahub.core.query.node import (
     AttributeFromDB,
-    AttributeNodePropertyFromDB,
     GroupedPeerNodes,
-    NodeAttributesFromDB,
     NodeGetHierarchyQuery,
     NodeGetListQuery,
     NodeListGetAttributeQuery,
@@ -78,60 +75,6 @@ def get_schema(
     return node_schema
 
 
-class ProfileAttributeIndex:
-    def __init__(
-        self,
-        profile_attributes_id_map: dict[str, NodeAttributesFromDB],
-        profile_ids_by_node_id: dict[str, list[str]],
-    ) -> None:
-        self._profile_attributes_id_map = profile_attributes_id_map
-        self._profile_ids_by_node_id = profile_ids_by_node_id
-
-    def apply_profiles(self, node_data_dict: dict[str, Any]) -> dict[str, Any]:
-        updated_data: dict[str, Any] = {**node_data_dict}
-        node_id = node_data_dict.get("id")
-        profile_ids = self._profile_ids_by_node_id.get(node_id, [])
-        if not profile_ids:
-            return updated_data
-        profiles = [
-            self._profile_attributes_id_map[p_id] for p_id in profile_ids if p_id in self._profile_attributes_id_map
-        ]
-
-        def get_profile_priority(nafd: NodeAttributesFromDB) -> tuple[int | float, str]:
-            try:
-                return (int(nafd.attrs.get("profile_priority").value), nafd.node.get("uuid"))
-            except (TypeError, AttributeError):
-                return (float("inf"), "")
-
-        profiles.sort(key=get_profile_priority)
-
-        for attr_name, attr_data in updated_data.items():
-            if not isinstance(attr_data, AttributeFromDB):
-                continue
-            if not attr_data.is_default:
-                continue
-            profile_value, profile_uuid = None, None
-            index = 0
-
-            while profile_value is None and index <= (len(profiles) - 1):
-                try:
-                    profile_value = profiles[index].attrs[attr_name].value
-                    if profile_value != "NULL":
-                        profile_uuid = profiles[index].node["uuid"]
-                        break
-                    profile_value = None
-                except (IndexError, KeyError, AttributeError):
-                    ...
-                index += 1
-
-            if profile_value is not None:
-                attr_data.value = profile_value
-                attr_data.is_from_profile = True
-                attr_data.is_default = False
-                attr_data.node_properties["source"] = AttributeNodePropertyFromDB(uuid=profile_uuid, labels=[])
-        return updated_data
-
-
 class NodeManager:
     @overload
     @classmethod
@@ -1132,21 +1075,11 @@ class NodeManager:
         )
         await query.execute(db=db)
         nodes_info_by_id: dict[str, NodeToProcess] = {node.node_uuid: node async for node in query.get_nodes(db=db)}
-        profile_ids_by_node_id = query.get_profile_ids_by_node_id()
-        all_profile_ids = reduce(
-            lambda all_ids, these_ids: all_ids | set(these_ids), profile_ids_by_node_id.values(), set()
-        )
-
-        if fields and all_profile_ids:
-            if "profile_priority" not in fields:
-                fields["profile_priority"] = {}
-            if "value" not in fields["profile_priority"]:
-                fields["profile_priority"]["value"] = None
 
         # Query list of all Attributes
         query = await NodeListGetAttributeQuery.init(
             db=db,
-            ids=list(nodes_info_by_id.keys()) + list(all_profile_ids),
+            ids=list(nodes_info_by_id.keys()),
             fields=fields,
             branch=branch,
             include_source=include_source,
@@ -1156,17 +1089,7 @@ class NodeManager:
             branch_agnostic=branch_agnostic,
         )
         await query.execute(db=db)
-        all_node_attributes = query.get_attributes_group_by_node()
-        profile_attributes: dict[str, dict[str, AttributeFromDB]] = {}
-        node_attributes: dict[str, dict[str, AttributeFromDB]] = {}
-        for node_id, attribute_dict in all_node_attributes.items():
-            if node_id in all_profile_ids:
-                profile_attributes[node_id] = attribute_dict
-            else:
-                node_attributes[node_id] = attribute_dict
-        profile_index = ProfileAttributeIndex(
-            profile_attributes_id_map=profile_attributes, profile_ids_by_node_id=profile_ids_by_node_id
-        )
+        node_attributes = query.get_attributes_group_by_node()
 
         nodes: dict[str, Node] = {}
 
@@ -1195,11 +1118,10 @@ class NodeManager:
                 for attr_name, attr in node_attributes[node_id].attrs.items():
                     new_node_data[attr_name] = attr
 
-            new_node_data_with_profile_overrides = profile_index.apply_profiles(new_node_data)
             node_class = identify_node_class(node=node)
             node_branch = await registry.get_branch(db=db, branch=node.branch)
             item = await node_class.init(schema=node.schema, branch=node_branch, at=at, db=db)
-            await item.load(**new_node_data_with_profile_overrides, db=db)
+            await item.load(**new_node_data, db=db)
 
             nodes[node_id] = item
 

infrahub/core/migrations/__init__.py

@@ -1,5 +1,6 @@
 from .schema.attribute_kind_update import AttributeKindUpdateMigration
 from .schema.attribute_name_update import AttributeNameUpdateMigration
+from .schema.attribute_supports_profile import AttributeSupportsProfileUpdateMigration
 from .schema.node_attribute_add import NodeAttributeAddMigration
 from .schema.node_attribute_remove import NodeAttributeRemoveMigration
 from .schema.node_kind_update import NodeKindUpdateMigration
@@ -19,6 +20,8 @@ MIGRATION_MAP: dict[str, type[SchemaMigration] | None] = {
     "attribute.name.update": AttributeNameUpdateMigration,
     "attribute.branch.update": None,
     "attribute.kind.update": AttributeKindUpdateMigration,
+    "attribute.optional.update": AttributeSupportsProfileUpdateMigration,
+    "attribute.read_only.update": AttributeSupportsProfileUpdateMigration,
     "relationship.branch.update": None,
     "relationship.direction.update": None,
     "relationship.identifier.update": PlaceholderDummyMigration,

infrahub/core/migrations/exceptions.py

@@ -0,0 +1,4 @@
+class MigrationFailureError(Exception):
+    def __init__(self, errors: list[str]) -> None:
+        super().__init__()
+        self.errors = errors

infrahub/core/migrations/graph/__init__.py

@@ -43,13 +43,15 @@ from .m038_redo_0000_prefix_fix import Migration038
 from .m039_ipam_reconcile import Migration039
 from .m040_duplicated_attributes import Migration040
 from .m041_deleted_dup_edges import Migration041
+from .m042_profile_attrs_in_db import Migration042
+from .m043_create_hfid_display_label_in_db import Migration043
+from .m044_backfill_hfid_display_label_in_db import Migration044
 
 if TYPE_CHECKING:
-    from infrahub.core.root import Root
+    from ..shared import MigrationTypes
 
-    from ..shared import ArbitraryMigration, GraphMigration, InternalSchemaMigration
 
-MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigration]] = [
+MIGRATIONS: list[type[MigrationTypes]] = [
     Migration001,
     Migration002,
     Migration003,
@@ -91,25 +93,24 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration039,
     Migration040,
     Migration041,
+    Migration042,
+    Migration043,
+    Migration044,
 ]
 
 
-async def get_graph_migrations(
-    root: Root,
-) -> Sequence[GraphMigration | InternalSchemaMigration | ArbitraryMigration]:
+async def get_graph_migrations(current_graph_version: int) -> Sequence[MigrationTypes]:
     applicable_migrations = []
     for migration_class in MIGRATIONS:
         migration = migration_class.init()
-        if root.graph_version > migration.minimum_version:
+        if current_graph_version > migration.minimum_version:
             continue
         applicable_migrations.append(migration)
 
     return applicable_migrations
 
 
-def get_migration_by_number(
-    migration_number: int | str,
-) -> GraphMigration | InternalSchemaMigration | ArbitraryMigration:
+def get_migration_by_number(migration_number: int | str) -> MigrationTypes:
     # Convert to string and pad with zeros if needed
     try:
         num = int(migration_number)

infrahub/core/migrations/graph/load_schema_branch.py

@@ -0,0 +1,21 @@
+from infrahub.core import registry
+from infrahub.core.branch import Branch
+from infrahub.core.schema import SchemaRoot, internal_schema
+from infrahub.core.schema.manager import SchemaManager
+from infrahub.core.schema.schema_branch import SchemaBranch
+from infrahub.database import InfrahubDatabase
+from infrahub.exceptions import InitializationError
+
+
+async def get_or_load_schema_branch(db: InfrahubDatabase, branch: Branch) -> SchemaBranch:
+    try:
+        if registry.schema.has_schema_branch(branch.name):
+            return registry.schema.get_schema_branch(branch.name)
+    except InitializationError:
+        schema_manager = SchemaManager()
+        registry.schema = schema_manager
+        internal_schema_root = SchemaRoot(**internal_schema)
+        registry.schema.register_schema(schema=internal_schema_root)
+    schema_branch = await registry.schema.load_schema_from_db(db=db, branch=branch)
+    registry.schema.set_schema_branch(name=branch.name, schema=schema_branch)
+    return schema_branch

infrahub/core/migrations/graph/m013_convert_git_password_credential.py

@@ -286,7 +286,7 @@ class Migration013AddInternalStatusData(AttributeAddQuery):
         kwargs.pop("branch", None)
 
         super().__init__(
-            node_kind="CoreGenericRepository",
+            node_kinds=["CoreGenericRepository"],
             attribute_name="internal_status",
             attribute_kind="Dropdown",
             branch_support=BranchSupportType.LOCAL.value,

infrahub/core/migrations/graph/m037_index_attr_vals.py

@@ -3,13 +3,10 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from rich.console import Console
-
 from infrahub.constants.database import IndexType
 from infrahub.core.attribute import MAX_STRING_LENGTH
-from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.migrations.shared import MigrationResult, get_migration_console
 from infrahub.core.query import Query, QueryType
-from infrahub.core.timestamp import Timestamp
 from infrahub.database.index import IndexItem
 from infrahub.database.neo4j import IndexManagerNeo4j
 from infrahub.log import get_logger
@@ -467,13 +464,11 @@ class Migration037(ArbitraryMigration):
         return result
 
     async def execute(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: PLR0915
-        console = Console()
+        console = get_migration_console()
         result = MigrationResult()
 
         # find the active schema attributes that have a LARGE_ATTRIBUTE_TYPE kind on all branches
-        console.print(
-            f"{Timestamp().to_string()} Determining schema attribute types and timestamps on all branches...", end=""
-        )
+        console.print("Determining schema attribute types and timestamps on all branches...", end="")
         get_large_attribute_types_query = await GetLargeAttributeTypesQuery.init(db=db)
         await get_large_attribute_types_query.execute(db=db)
         schema_attribute_timeframes = get_large_attribute_types_query.get_large_attribute_type_timeframes()
@@ -481,10 +476,7 @@ class Migration037(ArbitraryMigration):
 
         # find which schema attributes are large_types in the default branch, but updated to non-large_type on other branches
         # {(kind, attr_name): SchemaAttributeTimeframe}
-        console.print(
-            f"{Timestamp().to_string()} Determining which schema attributes have been updated to non-large_type on non-default branches...",
-            end="",
-        )
+        console.print("Determining schema attribute updates on non-default branches...", end="")
         main_schema_attribute_timeframes_map: dict[tuple[str, str], SchemaAttributeTimeframe] = {}
         for schema_attr_time in schema_attribute_timeframes:
             if schema_attr_time.is_default_branch:
@@ -508,7 +500,7 @@ class Migration037(ArbitraryMigration):
         console.print("done")
 
         # drop the index on the AttributeValueNonIndexed vertex, there won't be any at this point anyway
-        console.print(f"{Timestamp().to_string()} Dropping index on AttributeValueIndexed vertices...", end="")
+        console.print("Dropping index on AttributeValueIndexed vertices...", end="")
         index_manager = IndexManagerNeo4j(db=db)
         index_manager.init(nodes=[AV_INDEXED_INDEX], rels=[])
         await index_manager.drop()
@@ -516,7 +508,7 @@ class Migration037(ArbitraryMigration):
 
         # create the temporary non-indexed attribute value vertices for LARGE_ATTRIBUTE_TYPE attributes
         # start with default branch
-        console.print(f"{Timestamp().to_string()} Update non-indexed attribute values with temporary label...", end="")
+        console.print("Creating temporary non-indexed attribute values for large attribute types...", end="")
         large_schema_attribute_timeframes = [
             schema_attr_time for schema_attr_time in schema_attribute_timeframes if schema_attr_time.is_large_type
         ]
@@ -528,10 +520,7 @@ class Migration037(ArbitraryMigration):
         console.print("done")
 
         # re-index attribute values on branches where the type was updated to non-large_type
-        console.print(
-            f"{Timestamp().to_string()} Indexing attribute values on branches where the attribute schema was updated to a non-large_type...",
-            end="",
-        )
+        console.print("Re-indexing attribute values on branches updated to non-large types...", end="")
         for schema_attr_time in large_type_reverts:
             revert_non_index_on_branch_query = await RevertNonIndexOnBranchQuery.init(
                 db=db, schema_attribute_timeframe=schema_attr_time
@@ -540,27 +529,19 @@ class Migration037(ArbitraryMigration):
         console.print("done")
 
         # set the AttributeValue vertices to be AttributeValueIndexed
-        console.print(
-            f"{Timestamp().to_string()} Update all AttributeValue vertices to add the AttributeValueIndexed label...",
-            end="",
-        )
+        console.print("Adding AttributeValueIndexed label to AttributeValue vertices...", end="")
         set_attribute_value_indexed_query = await SetAttributeValueIndexedQuery.init(db=db)
         await set_attribute_value_indexed_query.execute(db=db)
         console.print("done")
 
         # set AttributeValueNonIndexed vertices to just AttributeValue
-        console.print(
-            f"{Timestamp().to_string()} Update all AttributeValueNonIndexed vertices to be AttributeValue (no index)...",
-            end="",
-        )
+        console.print("Restoring AttributeValue label on AttributeValueNonIndexed vertices...", end="")
         finalize_attribute_value_non_indexed_query = await FinalizeAttributeValueNonIndexedQuery.init(db=db)
         await finalize_attribute_value_non_indexed_query.execute(db=db)
         console.print("done")
 
         # de-index all attribute values too large to be indexed
-        console.print(
-            f"{Timestamp().to_string()} De-index any legacy attribute data that is too large to be indexed...", end=""
-        )
+        console.print("De-indexing legacy attribute data exceeding index limits...", end="")
         de_index_large_attribute_values_query = await DeIndexLargeAttributeValuesQuery.init(
             db=db, max_value_size=MAX_STRING_LENGTH
         )
@@ -568,7 +549,7 @@ class Migration037(ArbitraryMigration):
         console.print("done")
 
         # add the index back to the AttributeValueNonIndexed vertex
-        console.print(f"{Timestamp().to_string()} Add the index back to the AttributeValueIndexed label...", end="")
+        console.print("Adding index back to the AttributeValueIndexed label...", end="")
         index_manager = IndexManagerNeo4j(db=db)
         index_manager.init(nodes=[AV_INDEXED_INDEX], rels=[])
         await index_manager.add()

infrahub/core/migrations/graph/m039_ipam_reconcile.py

@@ -4,14 +4,13 @@ import ipaddress
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from rich.console import Console
 from rich.progress import Progress
 
 from infrahub.core.branch.models import Branch
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.initialization import initialization
 from infrahub.core.ipam.reconciler import IpamReconciler
-from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.migrations.shared import MigrationResult, get_migration_console
 from infrahub.core.query import Query, QueryType
 from infrahub.lock import initialize_lock
 from infrahub.log import get_logger
@@ -235,13 +234,13 @@ class Migration039(ArbitraryMigration):
         return MigrationResult()
 
     async def execute(self, db: InfrahubDatabase) -> MigrationResult:
-        console = Console()
+        console = get_migration_console()
         result = MigrationResult()
         # load schemas from database into registry
         initialize_lock()
         await initialization(db=db)
 
-        console.print("Identifying IP prefixes/addresses to reconcile...", end="")
+        console.print("Identifying IP prefixes and addresses to reconcile...", end="")
         find_nodes_query = await FindNodesToReconcileQuery.init(db=db)
         await find_nodes_query.execute(db=db)
         console.print("done")
@@ -250,16 +249,17 @@ class Migration039(ArbitraryMigration):
         # reconciler cannot correctly handle a prefix that is its own parent
         ip_node_details_list = find_nodes_query.get_nodes_to_reconcile()
         uuids_to_check = {ip_node_details.node_uuid for ip_node_details in ip_node_details_list}
-        console.print(f"{len(ip_node_details_list)} IP prefixes/addresses will be reconciled")
+        console.log(f"{len(ip_node_details_list)} IP prefixes or addresses will be reconciled.")
 
-        console.print("Deleting any self-parent relationships...", end="")
+        console.print("Deleting self-parent relationships prior to reconciliation...", end="")
         delete_self_parent_relationships_query = await DeleteSelfParentRelationshipsQuery.init(
             db=db, uuids_to_check=list(uuids_to_check)
         )
         await delete_self_parent_relationships_query.execute(db=db)
         console.print("done")
 
-        with Progress() as progress:
+        console.log("Reconciling IP prefixes and addresses across branches...")
+        with Progress(console=console) as progress:
             reconcile_task = progress.add_task("Reconciling IP prefixes/addresses...", total=len(ip_node_details_list))
 
             for ip_node_details in ip_node_details_list:
@@ -271,4 +271,6 @@ class Migration039(ArbitraryMigration):
                 )
                 progress.update(reconcile_task, advance=1)
 
+        console.log("IP prefix and address reconciliation complete.")
+
         return result

infrahub/core/migrations/graph/m042_profile_attrs_in_db.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from rich.progress import Progress
+
+from infrahub.core.branch.models import Branch
+from infrahub.core.initialization import get_root_node
+from infrahub.core.manager import NodeManager
+from infrahub.core.migrations.shared import MigrationResult, get_migration_console
+from infrahub.core.query import Query, QueryType
+from infrahub.core.timestamp import Timestamp
+from infrahub.log import get_logger
+from infrahub.profiles.node_applier import NodeProfilesApplier
+
+from ..shared import MigrationRequiringRebase
+from .load_schema_branch import get_or_load_schema_branch
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class GetUpdatedProfilesForBranchQuery(Query):
+    """
+    Get CoreProfile UUIDs with updated attributes on this branch
+    """
+
+    name = "get_profiles_by_branch"
+    type = QueryType.READ
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        self.params["branch"] = self.branch.name
+        query = """
+MATCH (profile:CoreProfile)-[:HAS_ATTRIBUTE]->(attr:Attribute)-[e:HAS_VALUE]->(:AttributeValue)
+WHERE e.branch = $branch
+WITH DISTINCT profile.uuid AS profile_uuid
+        """
+        self.add_to_query(query)
+        self.return_labels = ["profile_uuid"]
+
+    def get_profile_ids(self) -> list[str]:
+        """Get list of updated profile UUIDs"""
+        return [result.get_as_type("profile_uuid", str) for result in self.get_results()]
+
+
+class GetNodesWithProfileUpdatesForBranchQuery(Query):
+    """
+    Get Node UUIDs by which branches they have updated profiles on
+    """
+
+    name = "get_nodes_with_profile_updates_by_branch"
+    type = QueryType.READ
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        self.params["branch"] = self.branch.name
+        query = """
+MATCH (node:Node)-[e:IS_RELATED]->(:Relationship {name: "node__profile"})
+WHERE NOT node:CoreProfile
+AND e.branch = $branch
+WITH DISTINCT node.uuid AS node_uuid
+        """
+        self.add_to_query(query)
+        self.return_labels = ["node_uuid"]
+
+    def get_node_ids(self) -> list[str]:
+        """Get list of updated node UUIDs"""
+        return [result.get_as_type("node_uuid", str) for result in self.get_results()]
+
+
+class Migration042(MigrationRequiringRebase):
+    """
+    Save profile attribute values on each node using the profile in the database
+    For any profile that has updates on a given branch (including default branch)
+    - run NodeProfilesApplier.apply_profiles on each node related to the profile on that branch
+    For any node that has an updated relationship to a profile on a given branch
+    - run NodeProfilesApplier.apply_profiles on the node on that branch
+    """
+
+    name: str = "042_profile_attrs_in_db"
+    minimum_version: int = 41
+
+    def _get_profile_applier(self, db: InfrahubDatabase, branch: Branch) -> NodeProfilesApplier:
+        return NodeProfilesApplier(db=db, branch=branch)
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        root_node = await get_root_node(db=db, initialize=False)
+        default_branch_name = root_node.default_branch
+        default_branch = await Branch.get_by_name(db=db, name=default_branch_name)
+        return await self._do_execute_for_branch(db=db, branch=default_branch)
+
+    async def execute_against_branch(self, db: InfrahubDatabase, branch: Branch) -> MigrationResult:
+        return await self._do_execute_for_branch(db=db, branch=branch)
+
+    async def _do_execute_for_branch(self, db: InfrahubDatabase, branch: Branch) -> MigrationResult:
+        console = get_migration_console()
+        result = MigrationResult()
+        await get_or_load_schema_branch(db=db, branch=branch)
+
+        console.print(f"Gathering profiles for branch {branch.name}...", end="")
+        get_updated_profiles_for_branch_query = await GetUpdatedProfilesForBranchQuery.init(db=db, branch=branch)
+        await get_updated_profiles_for_branch_query.execute(db=db)
+        profile_ids = get_updated_profiles_for_branch_query.get_profile_ids()
+
+        profiles_map = await NodeManager.get_many(db=db, branch=branch, ids=list(profile_ids))
+        console.print("done")
+
+        node_ids_to_update: set[str] = set()
+        with Progress(console=console) as progress:
+            gather_nodes_task = progress.add_task(
+                f"Gathering affected objects for each profile on branch {branch.name}...", total=len(profiles_map)
+            )
+
+            for profile in profiles_map.values():
+                node_relationship_manager = profile.get_relationship("related_nodes")
+                node_peers = await node_relationship_manager.get_db_peers(db=db)
+                node_ids_to_update.update(str(peer.peer_id) for peer in node_peers)
+                progress.update(gather_nodes_task, advance=1)
+        console.log(f"Collected nodes impacted by profiles on branch {branch.name}.")
+
+        console.print("Identifying nodes with profile updates by branch...", end="")
+        get_nodes_with_profile_updates_by_branch_query = await GetNodesWithProfileUpdatesForBranchQuery.init(
+            db=db, branch=branch
+        )
+        await get_nodes_with_profile_updates_by_branch_query.execute(db=db)
+        node_ids_to_update.update(get_nodes_with_profile_updates_by_branch_query.get_node_ids())
+        console.print("done")
+
+        right_now = Timestamp()
+        console.log("Applying profiles to nodes...")
+        with Progress(console=console) as progress:
+            apply_task = progress.add_task("Applying profiles to nodes...", total=len(node_ids_to_update))
+            applier = self._get_profile_applier(db=db, branch=branch)
+            for node_id in node_ids_to_update:
+                node = await NodeManager.get_one(db=db, branch=branch, id=node_id, at=right_now)
+                if node:
+                    updated_field_names = await applier.apply_profiles(node=node)
+                    if updated_field_names:
+                        await node.save(db=db, fields=updated_field_names, at=right_now)
+                progress.update(apply_task, advance=1)
+        console.log("Completed applying profiles to nodes.")
+
+        return result