infrahub-server 1.4.7__tar.gz → 1.4.9__tar.gz

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/PKG-INFO

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

@@ -50,7 +50,7 @@ core_trigger_rule = GenericSchema(
             description="Indicates if this trigger is enabled or if it's just prepared, could be useful as you are setting up a trigger",
             optional=False,
             default_value=True,
-            order_weight=200,
+            order_weight=250,
         ),
         Attr(
             name="branch_scope",
@@ -59,7 +59,7 @@ core_trigger_rule = GenericSchema(
             choices=BranchScope.available_types(),
             default_value=BranchScope.DEFAULT_BRANCH.value.name,
             optional=False,
-            order_weight=200,
+            order_weight=260,
             allow_override=AllowOverrideType.NONE,
         ),
     ],
@@ -270,8 +270,10 @@ core_node_trigger_attribute_match = NodeSchema(
     label="Node Trigger Attribute Match",
     branch=BranchSupportType.AGNOSTIC,
     generate_profile=False,
-    inherit_from=["CoreNodeTriggerMatch"],
+    inherit_from=[core_node_trigger_match.kind],
     display_labels=["attribute_name__value"],
+    uniqueness_constraints=[["trigger", "attribute_name__value"]],
+    human_friendly_id=["trigger__name__value", "attribute_name__value"],
     attributes=[
         Attr(
             name="attribute_name",
@@ -319,8 +321,10 @@ core_node_trigger_relationship_match = NodeSchema(
     label="Node Trigger Relationship Match",
     branch=BranchSupportType.AGNOSTIC,
     generate_profile=False,
-    inherit_from=["CoreNodeTriggerMatch"],
+    inherit_from=[core_node_trigger_match.kind],
     display_labels=["relationship_name__value", "modification_type__value"],
+    uniqueness_constraints=[["trigger", "relationship_name__value"]],
+    human_friendly_id=["trigger__name__value", "relationship_name__value"],
     attributes=[
         Attr(
             name="relationship_name",

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/backend/infrahub/config.py

@@ -281,7 +281,6 @@ class DatabaseSettings(BaseSettings):
     query_size_limit: int = Field(
         default=5_000,
         ge=1,
-        le=20_000,
         description="The max number of records to fetch in a single query before performing internal pagination.",
     )
     max_depth_search_hierarchy: int = Field(

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

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

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/backend/infrahub/core/migrations/graph/__init__.py

@@ -40,6 +40,7 @@ from .m035_orphan_relationships import Migration035
 from .m036_drop_attr_value_index import Migration036
 from .m037_index_attr_vals import Migration037
 from .m038_redo_0000_prefix_fix import Migration038
+from .m039_ipam_reconcile import Migration039
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -85,6 +86,7 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration036,
     Migration037,
     Migration038,
+    Migration039,
 ]
 
 

infrahub_server-1.4.9/backend/infrahub/core/migrations/graph/m039_ipam_reconcile.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+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.query import Query, QueryType
+from infrahub.lock import initialize_lock
+from infrahub.log import get_logger
+
+from ..shared import ArbitraryMigration
+
+if TYPE_CHECKING:
+    from infrahub.core.ipam.constants import AllIPTypes
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+@dataclass
+class IpNodeDetails:
+    branch: str
+    ip_value: AllIPTypes
+    namespace: str
+    node_uuid: str
+
+
+class FindNodesToReconcileQuery(Query):
+    name = "find_nodes_to_reconcile_query"
+    type = QueryType.READ
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        self.params.update(
+            {
+                "prefix_kind": InfrahubKind.IPPREFIX,
+                "address_kind": InfrahubKind.IPADDRESS,
+                "prefix_attribute_name": "prefix",
+                "address_attribute_name": "address",
+                "attr_names": ["prefix", "address"],
+                "namespace_relationship_names": ["ip_namespace__ip_prefix", "ip_namespace__ip_address"],
+            }
+        )
+        query = """
+MATCH (root:Root)
+LIMIT 1
+WITH root.default_branch AS default_branch
+// ------------------
+// find prefixes and addresses that exist on the default branch
+// ------------------
+MATCH (ip_node:%(prefix_kind)s|%(address_kind)s)-[e:IS_PART_OF {branch: default_branch, status: "active"}]->(:Root)
+WHERE e.to IS NULL
+AND NOT exists((ip_node)-[:IS_PART_OF {branch: default_branch, status: "deleted"}]->(:Root))
+// ------------------
+// check if this node has its prefix/address updated on a branch (or branches)
+// ------------------
+CALL (ip_node, default_branch) {
+    OPTIONAL MATCH (ip_node)-[:HAS_ATTRIBUTE {branch: default_branch, status: "active"}]->
+        (attr:Attribute)-[has_value_e:HAS_VALUE {status: "active"}]->(attr_val)
+    WHERE attr.name IN $attr_names
+    AND has_value_e.branch_level = 2
+    AND (
+        ($prefix_kind IN labels(ip_node) AND attr.name = $prefix_attribute_name)
+        OR ($address_kind IN labels(ip_node) AND attr.name = $address_attribute_name)
+    )
+    RETURN collect(DISTINCT has_value_e.branch) AS attr_update_branches
+}
+CALL (ip_node, default_branch) {
+    OPTIONAL MATCH (ip_node)-[:IS_RELATED {status: "active"}]-
+        (rel:Relationship)-[e2:IS_RELATED {status: "active"}]-(peer:Node)
+    WHERE rel.name IN $namespace_relationship_names
+    AND e2.branch_level = 2
+    RETURN collect(DISTINCT e2.branch) AS namespace_update_branches
+}
+// ------------------
+// filter to only those prefixes/addresses with an update that we care about on a branch
+// ------------------
+WITH DISTINCT ip_node, default_branch, attr_update_branches, namespace_update_branches
+WHERE size(attr_update_branches) > 0 OR size(namespace_update_branches) > 0
+// ------------------
+// deduplicate branch lists and return one row for each branch
+// ------------------
+CALL (attr_update_branches, namespace_update_branches) {
+    UNWIND attr_update_branches + namespace_update_branches AS branch
+    RETURN DISTINCT branch
+}
+WITH default_branch, branch, ip_node
+// ------------------
+// confirm node is still active on this branch
+// ------------------
+MATCH (ip_node)
+WHERE NOT exists((ip_node)-[:IS_PART_OF {branch: branch, status: "deleted"}]->(:Root))
+// ------------------
+// get branched_from time for each branch
+// ------------------
+CALL (branch) {
+    MATCH (b:Branch {name: branch})
+    RETURN b.branched_from AS branched_from
+}
+// ------------------
+// get latest namespace on this branch
+// ------------------
+CALL (default_branch, branch, branched_from, ip_node) {
+    MATCH (ip_node)-[e1:IS_RELATED]-(rel:Relationship)-[e2:IS_RELATED]-(peer:%(namespace_kind)s)
+    WHERE rel.name IN $namespace_relationship_names
+    AND (
+        e1.branch = branch
+        OR (e1.branch = default_branch AND e1.from < branched_from)
+    )
+    AND e1.to IS NULL
+    AND (
+        e2.branch = branch
+        OR (e2.branch = default_branch AND e2.from < branched_from)
+    )
+    AND e2.to IS NULL
+    WITH peer, e1.status = "active" AND e2.status = "active" AS is_active
+    ORDER BY e2.branch_level DESC, e2.from DESC, e2.status ASC, e1.branch_level DESC, e1.from DESC, e1.status ASC
+    LIMIT 1
+    WITH peer
+    WHERE is_active = TRUE
+    RETURN peer.uuid AS namespace_uuid
+}
+// ------------------
+// get latest prefix/address value on this branch
+// ------------------
+CALL (default_branch, branch, branched_from, ip_node) {
+    MATCH (ip_node)-[e1:HAS_ATTRIBUTE]->(attr:Attribute)-[e2:HAS_VALUE]->(av)
+    WHERE attr.name IN $attr_names
+    AND (
+        ($prefix_kind IN labels(ip_node) AND attr.name = $prefix_attribute_name)
+        OR ($address_kind IN labels(ip_node) AND attr.name = $address_attribute_name)
+    )
+    AND (
+        e1.branch = branch
+        OR (e1.branch = default_branch AND e1.from < branched_from)
+    )
+    AND e1.to IS NULL
+    AND (
+        e2.branch = branch
+        OR (e2.branch = default_branch AND e2.from < branched_from)
+    )
+    AND e2.to IS NULL
+    WITH attr, av, e1.status = "active" AND e2.status = "active" AS is_active
+    ORDER BY e2.branch_level DESC, e2.from DESC, e2.status ASC, e1.branch_level DESC, e1.from DESC, e1.status ASC
+    LIMIT 1
+    WITH attr, av
+    WHERE is_active = TRUE
+    RETURN CASE
+        WHEN attr.name = $prefix_attribute_name THEN av.value
+        ELSE NULL
+    END AS prefix_value,
+    CASE
+        WHEN attr.name = $address_attribute_name THEN av.value
+        ELSE NULL
+    END AS address_value
+}
+RETURN branch, namespace_uuid, ip_node.uuid AS node_uuid, prefix_value, address_value
+        """ % {
+            "prefix_kind": InfrahubKind.IPPREFIX,
+            "address_kind": InfrahubKind.IPADDRESS,
+            "namespace_kind": InfrahubKind.IPNAMESPACE,
+        }
+        self.add_to_query(query)
+        self.return_labels = ["branch", "namespace_uuid", "node_uuid", "prefix_value", "address_value"]
+
+    def get_nodes_to_reconcile(self) -> list[IpNodeDetails]:
+        ip_node_details = []
+        for result in self.get_results():
+            prefix_value = result.get_as_str("prefix_value")
+            address_value = result.get_as_str("address_value")
+            if prefix_value:
+                ip_value: AllIPTypes = ipaddress.ip_network(address=prefix_value)
+            elif address_value:
+                ip_value = ipaddress.ip_interface(address=address_value)
+            else:
+                continue
+            ip_node_details.append(
+                IpNodeDetails(
+                    branch=result.get_as_type("branch", str),
+                    ip_value=ip_value,
+                    namespace=result.get_as_type("namespace_uuid", str),
+                    node_uuid=result.get_as_type("node_uuid", str),
+                )
+            )
+        return ip_node_details
+
+
+class DeleteSelfParentRelationshipsQuery(Query):
+    name = "delete_self_parent_relationships"
+    type = QueryType.WRITE
+    insert_return = False
+
+    def __init__(self, uuids_to_check: list[str], **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.uuids_to_check = uuids_to_check
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        self.params["uuids_to_check"] = self.uuids_to_check
+        query = """
+MATCH (n:Node)-[e1:IS_RELATED]->(:Relationship {name: "parent__child"})-[e2:IS_RELATED {branch: e1.branch, status: e1.status, from: e1.from}]->(n)
+WHERE n.uuid IN $uuids_to_check
+DELETE e1, e2
+        """
+        self.add_to_query(query)
+
+
+class Migration039(ArbitraryMigration):
+    """
+    Identify all IP prefixes/addresses that have been updated on a branch and reconcile them on that branch
+    If any of the identified IP prefixes/addresses are their own parent/child, delete those illegal edges before reconciling.
+    """
+
+    name: str = "039_ipam_reconcile_updated"
+    minimum_version: int = 38
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._reconcilers_by_branch: dict[str, IpamReconciler] = {}
+
+    async def _get_reconciler(self, db: InfrahubDatabase, branch_name: str) -> IpamReconciler:
+        if branch_name not in self._reconcilers_by_branch:
+            branch = await Branch.get_by_name(db=db, name=branch_name)
+            self._reconcilers_by_branch[branch_name] = IpamReconciler(db=db, branch=branch)
+        return self._reconcilers_by_branch[branch_name]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        console = Console()
+        result = MigrationResult()
+        # load schemas from database into registry
+        initialize_lock()
+        await initialization(db=db)
+
+        console.print("Identifying IP prefixes/addresses to reconcile...", end="")
+        find_nodes_query = await FindNodesToReconcileQuery.init(db=db)
+        await find_nodes_query.execute(db=db)
+        console.print("done")
+
+        # we need to delete the self-parent relationships before reconciling b/c the
+        # 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.print("Deleting any self-parent relationships...", 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:
+            reconcile_task = progress.add_task("Reconciling IP prefixes/addresses...", total=len(ip_node_details_list))
+
+            for ip_node_details in ip_node_details_list:
+                reconciler = await self._get_reconciler(db=db, branch_name=ip_node_details.branch)
+                await reconciler.reconcile(
+                    ip_value=ip_node_details.ip_value,
+                    namespace=ip_node_details.namespace,
+                    node_uuid=ip_node_details.node_uuid,
+                )
+                progress.update(reconcile_task, advance=1)
+
+        return result

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/backend/infrahub/core/query/branch.py

@@ -31,7 +31,7 @@ WHERE e.branch = $branch_name
 CALL (n) {
     OPTIONAL MATCH (n)-[:IS_RELATED {branch: $global_branch_name}]-(rel:Relationship)
     DETACH DELETE rel
-} IN TRANSACTIONS
+} IN TRANSACTIONS OF 500 ROWS
 
 // reduce the results to a single row
 WITH 1 AS one
@@ -44,7 +44,7 @@ MATCH (s)-[r]->(d)
 WHERE r.branch = $branch_name
 CALL (r) {
     DELETE r
-} IN TRANSACTIONS
+} IN TRANSACTIONS OF 500 ROWS
 
 // --------------
 // get the database IDs of every vertex linked to a deleted edge
@@ -61,7 +61,7 @@ CALL (vertex_id) {
     WHERE elementId(n) = vertex_id
     AND NOT exists((n)--())
     DELETE n
-} IN TRANSACTIONS
+} IN TRANSACTIONS OF 500 ROWS
         """
         self.params["branch_name"] = self.branch_name
         self.params["global_branch_name"] = GLOBAL_BRANCH_NAME

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/backend/infrahub/core/query/relationship.py

@@ -871,6 +871,9 @@ class RelationshipGetQuery(RelationshipQuery):
         query = """
         MATCH (s)%s(rl:Relationship { name: $name })%s(d)
         WHERE %s
+        ORDER BY r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
+        WITH *, r1.status = "active" AND r2.status = "active" AS is_active
+        LIMIT 1
         """ % (
             r1,
             r2,
@@ -880,7 +883,20 @@ class RelationshipGetQuery(RelationshipQuery):
         self.params["at"] = self.at.to_string()
 
         self.add_to_query(query)
-        self.return_labels = ["s", "d", "rl", "r1", "r2"]
+        self.return_labels = ["s", "d", "rl", "r2", "is_active"]
+
+    def is_already_deleted(self) -> bool:
+        result = self.get_result()
+        if not result:
+            return False
+        return result.get("is_active") is False
+
+    def get_relationships_ids_for_branch(self, branch_name: str) -> list[str] | None:
+        result = self.get_result()
+        if not result:
+            return None
+
+        return [rel.element_id for rel in result.get_rels() if rel.get("branch") == branch_name]
 
 
 class RelationshipGetByIdentifierQuery(Query):

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/backend/infrahub/core/query/subquery.py

@@ -90,7 +90,7 @@ async def build_subquery_filter(
         {branch_level_str} AS branch_level,
         {froms_str} AS froms,
         all(r IN relationships(path) WHERE r.status = "active") AS is_active{with_extra}
-    ORDER BY branch_level DESC, froms[-1] DESC, froms[-2] DESC
+    ORDER BY branch_level DESC, froms[-1] DESC, froms[-2] DESC, is_active DESC
     WITH head(collect([is_active, {node_alias}{with_extra}])) AS latest_node_details
     WHERE {is_active_filter}
     WITH latest_node_details[1] AS {prefix}{final_with_extra}
@@ -176,7 +176,7 @@ async def build_subquery_order(
     OPTIONAL MATCH path = {filter_str}
     WHERE {where_str}
     WITH {with_str_to_alias}
-    ORDER BY branch_level DESC, froms[-1] DESC, froms[-2] DESC
+    ORDER BY branch_level DESC, froms[-1] DESC, froms[-2] DESC, is_active DESC
     WITH head(collect([is_active, {with_str_alias}])) AS latest_node_details
     WITH {with_str_from_list}
     RETURN {to_return_str}

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/backend/infrahub/core/relationship/model.py

@@ -404,17 +404,21 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
             db=db, source=node, destination=peer, rel=self, branch=self.branch, at=delete_at
         )
         await get_query.execute(db=db)
-        result = get_query.get_result()
-        if not result:
+
+        rel_ids_to_update = get_query.get_relationships_ids_for_branch(branch_name=branch.name)
+        if rel_ids_to_update is None:
             raise Error(
                 f"Unable to find the relationship to delete. id: {self.id}, source: {node.id}, destination: {peer.id}"
             )
 
+        if get_query.is_already_deleted():
+            return
+
         # when we remove a relationship we need to :
         # - Update the existing relationship if we are on the same branch
         # - Create a new rel of type DELETED in the right branch
 
-        if rel_ids_to_update := [rel.element_id for rel in result.get_rels() if rel.get("branch") == branch.name]:
+        if rel_ids_to_update:
             await update_relationships_to(rel_ids_to_update, to=delete_at, db=db)
 
         delete_query = await RelationshipDeleteQuery.init(

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/backend/infrahub/database/__init__.py

@@ -28,6 +28,9 @@ from typing_extensions import Self
 from infrahub import config, lock
 from infrahub.constants.database import DatabaseType, Neo4jRuntime
 from infrahub.core import registry
+from infrahub.core.constants import (
+    GLOBAL_BRANCH_NAME,
+)
 from infrahub.core.query import QueryType
 from infrahub.exceptions import DatabaseError
 from infrahub.log import get_logger
@@ -125,9 +128,14 @@ class DatabaseSchemaManager:
         return self.get_full(branch=branch, duplicate=duplicate)
 
     def get_schema_branch(self, name: str) -> SchemaBranch:
-        if name not in self._db._schemas:
-            return registry.schema.get_schema_branch(name=name)
-        return self._db._schemas[name]
+        """Return a schema branch object based on its name.
+
+        If the branch is the global one, the default branch will be returned.
+        """
+        branch_name = registry.default_branch if name == GLOBAL_BRANCH_NAME else name
+        if branch_name not in self._db._schemas:
+            return registry.schema.get_schema_branch(name=branch_name)
+        return self._db._schemas[branch_name]
 
 
 class InfrahubDatabase:

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/backend/infrahub/git/base.py

@@ -716,7 +716,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):
 
         repo = self.get_git_repo_main()
         try:
-            repo.remotes.origin.fetch()
+            repo.remotes.origin.fetch(prune=True)
         except GitCommandError as exc:
             await self._raise_enriched_error(error=exc)
 

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/backend/infrahub/graphql/mutations/ipam.py

@@ -44,6 +44,11 @@ async def validate_namespace(
             db=db, branch=branch, kind=InfrahubKind.IPNAMESPACE, id=data["ip_namespace"]["id"]
         )
         namespace_id = namespace.id
+    elif "hfid" in data["ip_namespace"]:
+        namespace = await registry.manager.get_one_by_hfid(
+            db=db, branch=branch, kind=InfrahubKind.IPNAMESPACE, hfid=data["ip_namespace"]["hfid"]
+        )
+        namespace_id = namespace.id
     else:
         raise ValidationError(
             "A valid ip_namespace must be provided or ip_namespace should be left empty in order to use the default value."

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/backend/infrahub/proposed_change/tasks.py

@@ -441,9 +441,6 @@ async def run_proposed_change_schema_integrity_check(model: RequestProposedChang
                 )
             )
 
-    if not conflicts:
-        return
-
     database = await get_database()
     async with database.start_transaction() as db:
         object_conflict_validator_recorder = ObjectConflictValidatorRecorder(

infrahub_server-1.4.9/backend/infrahub/worker.py

@@ -0,0 +1,14 @@
+import uuid
+
+from prometheus_client import Gauge
+
+from infrahub import __version__ as infrahub_version
+
+WORKER_IDENTITY = str(uuid.uuid4())
+
+INFO_METRIC = Gauge(
+    "infrahub_info",
+    "Information about this Infrahub instance",
+    labelnames=["version", "worker_id"],
+)
+INFO_METRIC.labels(version=infrahub_version, worker_id=WORKER_IDENTITY).set(1)

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/backend/infrahub/workflows/catalogue.py

@@ -299,7 +299,7 @@ PROPOSED_CHANGE_MERGE = WorkflowDefinition(
 
 GRAPHQL_QUERY_GROUP_UPDATE = WorkflowDefinition(
     name="graphql-query-group-update",
-    type=WorkflowType.CORE,
+    type=WorkflowType.INTERNAL,
     module="infrahub.groups.tasks",
     function="update_graphql_query_group",
 )

{infrahub_server-1.4.7 → infrahub_server-1.4.9}/pyproject.toml

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

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

infrahub_server-1.4.7/backend/infrahub/worker.py

@@ -1,3 +0,0 @@
-import uuid
-
-WORKER_IDENTITY = str(uuid.uuid4())