infrahub-server 1.3.2__tar.gz → 1.3.4__tar.gz

infrahub_server-1.3.4/LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 OpsMill SAS
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

{infrahub_server-1.3.2 → infrahub_server-1.3.4}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.3.2
+Version: 1.3.4
 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: AGPL-3.0-only
+License: Apache-2.0
 Author: OpsMill
 Author-email: info@opsmill.com
 Requires-Python: >=3.10,<3.13
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11

{infrahub_server-1.3.2 → infrahub_server-1.3.4}/backend/infrahub/api/schema.py

@@ -151,9 +151,9 @@ def evaluate_candidate_schemas(
     branch_schema: SchemaBranch, schemas_to_evaluate: SchemasLoadAPI
 ) -> tuple[SchemaBranch, SchemaUpdateValidationResult]:
     candidate_schema = branch_schema.duplicate()
-    schema = _merge_candidate_schemas(schemas=schemas_to_evaluate.schemas)
-
     try:
+        schema = _merge_candidate_schemas(schemas=schemas_to_evaluate.schemas)
+
         candidate_schema.load_schema(schema=schema)
         candidate_schema.process()
 

{infrahub_server-1.3.2 → infrahub_server-1.3.4}/backend/infrahub/cli/db.py

@@ -8,7 +8,7 @@ from csv import DictReader, DictWriter
 from datetime import datetime, timezone
 from enum import Enum
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Sequence
 
 import typer
 import ujson
@@ -38,7 +38,7 @@ from infrahub.core.initialization import (
     initialization,
     initialize_registry,
 )
-from infrahub.core.migrations.graph import get_graph_migrations
+from infrahub.core.migrations.graph import get_graph_migrations, get_migration_by_number
 from infrahub.core.migrations.schema.models import SchemaApplyMigrationData
 from infrahub.core.migrations.schema.tasks import schema_apply_migrations
 from infrahub.core.schema import SchemaRoot, core_models, internal_schema
@@ -58,8 +58,15 @@ from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 from .constants import ERROR_BADGE, FAILED_BADGE, SUCCESS_BADGE
 from .patch import patch_app
 
+
+def get_timestamp_string() -> str:
+    """Generate a timestamp string in the format YYYYMMDD-HHMMSS."""
+    return datetime.now(tz=timezone.utc).strftime("%Y%m%d-%H%M%S")
+
+
 if TYPE_CHECKING:
     from infrahub.cli.context import CliContext
+    from infrahub.core.migrations.shared import ArbitraryMigration, GraphMigration, InternalSchemaMigration
     from infrahub.database import InfrahubDatabase
     from infrahub.database.index import IndexManagerBase
 
@@ -154,6 +161,7 @@ async def migrate_cmd(
     ctx: typer.Context,
     check: bool = typer.Option(False, help="Check the state of the database without applying the migrations."),
     config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+    migration_number: int | None = typer.Option(None, help="Apply a specific migration by number"),
 ) -> None:
     """Check the current format of the internal graph and apply the necessary migrations"""
     logging.getLogger("infrahub").setLevel(logging.WARNING)
@@ -165,7 +173,7 @@ async def migrate_cmd(
     context: CliContext = ctx.obj
     dbdriver = await context.init_db(retry=1)
 
-    await migrate_database(db=dbdriver, initialize=True, check=check)
+    await migrate_database(db=dbdriver, initialize=True, check=check, migration_number=migration_number)
 
     await dbdriver.close()
 
@@ -287,7 +295,9 @@ async def index(
     await dbdriver.close()
 
 
-async def migrate_database(db: InfrahubDatabase, initialize: bool = False, check: bool = False) -> bool:
+async def migrate_database(
+    db: InfrahubDatabase, initialize: bool = False, check: bool = False, migration_number: int | str | None = None
+) -> bool:
     """Apply the latest migrations to the database, this function will print the status directly in the console.
 
     Returns a boolean indicating whether a migration failed or if all migrations succeeded.
@@ -295,6 +305,7 @@ async def migrate_database(db: InfrahubDatabase, initialize: bool = False, check
     Args:
         db: The database object.
         check: If True, the function will only check the status of the database and not apply the migrations. Defaults to False.
+        migration_number: If provided, the function will only apply the migration with the given number. Defaults to None.
     """
     rprint("Checking current state of the Database")
 
@@ -302,15 +313,28 @@ async def migrate_database(db: InfrahubDatabase, initialize: bool = False, check
         await initialize_registry(db=db)
 
     root_node = await get_root_node(db=db)
-    migrations = await get_graph_migrations(root=root_node)
-
-    if not migrations:
-        rprint(f"Database up-to-date (v{root_node.graph_version}), no migration to execute.")
-        return True
+    if migration_number:
+        migration = get_migration_by_number(migration_number)
+        migrations: Sequence[GraphMigration | InternalSchemaMigration | ArbitraryMigration] = [migration]
+        if check:
+            if root_node.graph_version > migration.minimum_version:
+                rprint(
+                    f"Migration {migration_number} already applied. To apply again, run the command without the --check flag."
+                )
+                return True
+            rprint(
+                f"Migration {migration_number} needs to be applied. Run `infrahub db migrate` to apply all outstanding migrations."
+            )
+            return False
+    else:
+        migrations = await get_graph_migrations(root=root_node)
+        if not migrations:
+            rprint(f"Database up-to-date (v{root_node.graph_version}), no migration to execute.")
+            return True
 
-    rprint(
-        f"Database needs to be updated (v{root_node.graph_version} -> v{GRAPH_VERSION}), {len(migrations)} migrations pending"
-    )
+        rprint(
+            f"Database needs to be updated (v{root_node.graph_version} -> v{GRAPH_VERSION}), {len(migrations)} migrations pending"
+        )
 
     if check:
         return True
@@ -529,7 +553,7 @@ WITH n, edges + root_edges AS edges, CASE
 END AS vertices
 RETURN vertices, edges
     """ % {"id_func": db.get_id_function_name()}
-    timestamp_str = datetime.now(tz=timezone.utc).strftime("%Y%m%d-%H%M%S")
+    timestamp_str = get_timestamp_string()
     export_dir /= Path(f"export-{timestamp_str}")
     if not export_dir.exists():
         export_dir.mkdir(parents=True)
@@ -737,3 +761,160 @@ async def load_export(db: InfrahubDatabase, export_dir: Path, query_limit: int =
             await load_edges(db=db, edge_type=edge_type, edge_dicts=edge_dicts)
     rprint("Edges loaded")
     rprint(f"{SUCCESS_BADGE} Export loaded")
+
+
+@app.command(name="check")
+async def check_cmd(
+    ctx: typer.Context,
+    output_dir: Path = typer.Option(  # noqa: B008
+        None, help="Directory to save detailed check results (defaults to infrahub_db_check_YYYYMMDD-HHMMSS)"
+    ),
+    config_file: str = typer.Option(
+        "infrahub.toml", envvar="INFRAHUB_CONFIG", help="Location of the configuration file to use for Infrahub"
+    ),
+) -> None:
+    """Run database sanity checks and output the results to the CSV files."""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+
+    config.load_and_exit(config_file_name=config_file)
+
+    # Create output directory if not specified
+    if output_dir is None:
+        timestamp_str = get_timestamp_string()
+        output_dir = Path(f"infrahub_db_check_{timestamp_str}")
+
+    if not output_dir.exists():
+        output_dir.mkdir(parents=True)
+
+    context: CliContext = ctx.obj
+    dbdriver = await context.init_db(retry=1)
+
+    await run_database_checks(db=dbdriver, output_dir=output_dir)
+
+    await dbdriver.close()
+
+
+async def run_database_checks(db: InfrahubDatabase, output_dir: Path) -> None:
+    """Run a series of database health checks and output the results to the terminal.
+
+    Args:
+        db: The database object.
+        output_dir: Directory to save detailed check results.
+    """
+    rprint("Running database health checks...")
+
+    # Check 1: Duplicate active relationships
+    rprint("\n[bold cyan]Check 1: Duplicate Active Relationships[/bold cyan]")
+    duplicate_active_rels_query = """
+    MATCH (a:Node)-[e1:IS_RELATED {status: "active"}]-(r:Relationship)-[e2:IS_RELATED {branch: e1.branch, status: "active"}]-(b:Node)
+    WHERE a.uuid < b.uuid
+    AND e1.to IS NULL
+    AND e2.to IS NULL
+    WITH DISTINCT a.uuid AS a_uuid,
+        b.uuid AS b_uuid,
+        r.name AS r_name,
+        e1.branch AS branch,
+        CASE
+        WHEN startNode(e1) = a AND startNode(e2) = r THEN "out"
+            WHEN startNode(e1) = r AND startNode(e2) = b THEN "in"
+            ELSE "bidir"
+        END AS direction,
+        count(*) AS num_paths,
+        collect(DISTINCT a.kind) AS a_kinds,
+        collect(DISTINCT b.kind) AS b_kinds
+    WHERE num_paths > 1
+    RETURN a_uuid, a_kinds, b_uuid, b_kinds, r_name, branch, direction, num_paths
+    """
+
+    results = await db.execute_query(query=duplicate_active_rels_query)
+    if results:
+        rprint(f"[red]Found {len(results)} duplicate active relationships[/red]")
+        # Write detailed results to file
+        output_file = output_dir / "duplicate_active_relationships.csv"
+        with output_file.open(mode="w", newline="") as f:
+            writer = DictWriter(
+                f, fieldnames=["a_uuid", "a_kinds", "b_uuid", "b_kinds", "r_name", "branch", "direction", "num_paths"]
+            )
+            writer.writeheader()
+            for result in results:
+                writer.writerow(dict(result))
+        rprint(f"  Detailed results written to: {output_file}")
+    else:
+        rprint(f"{SUCCESS_BADGE} No duplicate active relationships found")
+
+    # Check 2: Duplicated relationship nodes
+    rprint("\n[bold cyan]Check 2: Duplicated Relationship Nodes[/bold cyan]")
+    duplicate_rel_nodes_query = """
+    MATCH (r:Relationship)
+    WITH r.uuid AS r_uuid, COUNT(*) AS num_rels
+    WHERE num_rels > 1
+    MATCH (n:Node)-[:IS_RELATED]-(r:Relationship {uuid: r_uuid})
+    WITH DISTINCT r_uuid, n.uuid AS n_uuid, n.kind AS n_kind
+    WITH r_uuid, collect([n_uuid, n_kind]) AS node_details
+    RETURN r_uuid, node_details
+    """
+
+    results = await db.execute_query(query=duplicate_rel_nodes_query)
+    if results:
+        rprint(f"[red]Found {len(results)} duplicated relationship nodes[/red]")
+        # Write detailed results to file
+        output_file = output_dir / "duplicated_relationship_nodes.csv"
+        with output_file.open(mode="w", newline="") as f:
+            writer = DictWriter(f, fieldnames=["r_uuid", "node_details"])
+            writer.writeheader()
+            for result in results:
+                writer.writerow(dict(result))
+        rprint(f"  Detailed results written to: {output_file}")
+    else:
+        rprint(f"{SUCCESS_BADGE} No duplicated relationship nodes found")
+
+    # Check 3: Duplicated edges
+    rprint("\n[bold cyan]Check 3: Duplicated Edges[/bold cyan]")
+    duplicate_edges_query = """
+    MATCH (a)
+    CALL (a) {
+        MATCH (a)-[e]->(b)
+        WHERE elementId(a) < elementId(b)
+        WITH DISTINCT a, b, type(e) AS e_type, count(*) AS total_num_edges
+        WHERE total_num_edges > 1
+        MATCH (a)-[e]->(b)
+        WHERE type(e) = e_type
+        WITH
+            elementId(a) AS a_id,
+            labels(a) AS a_labels,
+            elementId(b) AS b_id,
+            labels(b) AS b_labels,
+            type(e) AS e_type,
+            e.branch AS branch,
+            e.status AS status,
+            e.from AS time,
+            collect(e) AS edges
+        WITH a_id, a_labels, b_id, b_labels, e_type, branch, status, time, size(edges) AS num_edges
+        WHERE num_edges > 1
+        WITH a_id, a_labels, b_id, b_labels, e_type, branch, status, time, num_edges
+        RETURN a_id, a_labels, b_id, b_labels, e_type, branch, status, time, num_edges
+    }
+    RETURN a_id, a_labels, b_id, b_labels, e_type, branch, status, time, num_edges
+    """
+
+    results = await db.execute_query(query=duplicate_edges_query)
+    if results:
+        rprint(f"[red]Found {len(results)} sets of duplicated edges[/red]")
+        # Write detailed results to file
+        output_file = output_dir / "duplicated_edges.csv"
+        with output_file.open(mode="w", newline="") as f:
+            writer = DictWriter(
+                f,
+                fieldnames=["a_id", "a_labels", "b_id", "b_labels", "e_type", "branch", "status", "time", "num_edges"],
+            )
+            writer.writeheader()
+            for result in results:
+                writer.writerow(dict(result))
+        rprint(f"  Detailed results written to: {output_file}")
+    else:
+        rprint(f"{SUCCESS_BADGE} No duplicated edges found")
+
+    rprint(f"\n{SUCCESS_BADGE} Database health checks completed")
+    rprint(f"Detailed results saved to: {output_dir.absolute()}")

infrahub_server-1.3.4/backend/infrahub/core/branch/enums.py

@@ -0,0 +1,8 @@
+from infrahub.utils import InfrahubStringEnum
+
+
+class BranchStatus(InfrahubStringEnum):
+    OPEN = "OPEN"
+    NEED_REBASE = "NEED_REBASE"
+    CLOSED = "CLOSED"
+    DELETING = "DELETING"

{infrahub_server-1.3.2 → infrahub_server-1.3.4}/backend/infrahub/core/branch/models.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Self, Union
 
 from pydantic import Field, field_validator
 
@@ -21,6 +21,8 @@ from infrahub.core.registry import registry
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import BranchNotFoundError, InitializationError, ValidationError
 
+from .enums import BranchStatus
+
 if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
@@ -29,7 +31,7 @@ class Branch(StandardNode):
     name: str = Field(
         max_length=250, min_length=3, description="Name of the branch (git ref standard)", validate_default=True
     )
-    status: str = "OPEN"  # OPEN, CLOSED
+    status: BranchStatus = BranchStatus.OPEN
     description: str = ""
     origin_branch: str = "main"
     branched_from: Optional[str] = Field(default=None, validate_default=True)
@@ -131,14 +133,17 @@ class Branch(StandardNode):
         return True
 
     @classmethod
-    async def get_by_name(cls, name: str, db: InfrahubDatabase) -> Branch:
+    async def get_by_name(cls, name: str, db: InfrahubDatabase, ignore_deleting: bool = True) -> Branch:
         query = """
         MATCH (n:Branch)
         WHERE n.name = $name
+        AND NOT n.status IN $ignore_statuses
         RETURN n
         """
 
-        params = {"name": name}
+        params: dict[str, Any] = {"name": name}
+        if ignore_deleting:
+            params["ignore_statuses"] = [BranchStatus.DELETING.value]
 
         results = await db.execute_query(query=query, params=params, name="branch_get_by_name", type=QueryType.READ)
 
@@ -147,6 +152,20 @@ class Branch(StandardNode):
 
         return cls.from_db(results[0].values()[0])
 
+    @classmethod
+    async def get_list(
+        cls,
+        db: InfrahubDatabase,
+        limit: int = 1000,
+        ids: list[str] | None = None,
+        name: str | None = None,
+        **kwargs: dict[str, Any],
+    ) -> list[Self]:
+        branches = await super().get_list(db=db, limit=limit, ids=ids, name=name, **kwargs)
+        branches = [branch for branch in branches if branch.status != BranchStatus.DELETING]
+
+        return branches
+
     @classmethod
     def isinstance(cls, obj: Any) -> bool:
         return isinstance(obj, cls)
@@ -248,9 +267,13 @@ class Branch(StandardNode):
             raise ValidationError(f"Unable to delete {self.name} it is the default branch.")
         if self.is_global:
             raise ValidationError(f"Unable to delete {self.name} this is an internal branch.")
-        await super().delete(db=db)
+
+        self.status = BranchStatus.DELETING
+        await self.save(db=db)
+
         query = await DeleteBranchRelationshipsQuery.init(db=db, branch_name=self.name)
         await query.execute(db=db)
+        await super().delete(db=db)
 
     def get_query_filter_relationships(
         self, rel_labels: list, at: Optional[Union[Timestamp, str]] = None, include_outside_parentheses: bool = False

{infrahub_server-1.3.2 → infrahub_server-1.3.4}/backend/infrahub/core/branch/tasks.py

@@ -15,6 +15,7 @@ from infrahub.core.branch import Branch
 from infrahub.core.changelog.diff import DiffChangelogCollector, MigrationTracker
 from infrahub.core.constants import MutationAction
 from infrahub.core.diff.coordinator import DiffCoordinator
+from infrahub.core.diff.diff_locker import DiffLocker
 from infrahub.core.diff.ipam_diff_parser import IpamDiffParser
 from infrahub.core.diff.merger.merger import DiffMerger
 from infrahub.core.diff.model.path import BranchTrackingId, EnrichedDiffRoot, EnrichedDiffRootMetadata
@@ -31,7 +32,7 @@ from infrahub.dependencies.registry import get_component_registry
 from infrahub.events.branch_action import BranchCreatedEvent, BranchDeletedEvent, BranchMergedEvent, BranchRebasedEvent
 from infrahub.events.models import EventMeta, InfrahubEvent
 from infrahub.events.node_action import get_node_event
-from infrahub.exceptions import BranchNotFoundError, MergeFailedError, ValidationError
+from infrahub.exceptions import BranchNotFoundError, ValidationError
 from infrahub.graphql.mutations.models import BranchCreateModel  # noqa: TC001
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.workflows.catalogue import (
@@ -65,6 +66,7 @@ async def rebase_branch(branch: str, context: InfrahubContext, service: Infrahub
             diff_merger=diff_merger,
             diff_repository=diff_repository,
             source_branch=obj,
+            diff_locker=DiffLocker(),
             service=service,
         )
 
@@ -221,14 +223,10 @@ async def merge_branch(
                 diff_merger=diff_merger,
                 diff_repository=diff_repository,
                 source_branch=obj,
+                diff_locker=DiffLocker(),
                 service=service,
             )
-            try:
-                branch_diff = await merger.merge()
-            except Exception as exc:
-                log.exception("Merge failed, beginning rollback")
-                await merger.rollback()
-                raise MergeFailedError(branch_name=branch) from exc
+            branch_diff = await merger.merge()
             await merger.update_schema()
 
         changelog_collector = DiffChangelogCollector(diff=branch_diff, branch=obj, db=db)

{infrahub_server-1.3.2 → infrahub_server-1.3.4}/backend/infrahub/core/convert_object_type/conversion.py

@@ -9,6 +9,7 @@ from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
 from infrahub.core.node.create import create_node
 from infrahub.core.query.relationship import GetAllPeersIds
+from infrahub.core.query.resource_manager import PoolChangeReserved
 from infrahub.core.relationship import RelationshipManager
 from infrahub.core.schema import NodeSchema
 from infrahub.database import InfrahubDatabase
@@ -121,4 +122,13 @@ async def convert_object_type(
         for peer in peers.values():
             peer.validate_relationships()
 
+        # If the node had some value reserved in any Pools / Resource Manager, we need to change the identifier of the reservation(s)
+        query = await PoolChangeReserved.init(
+            db=dbt,
+            existing_identifier=node.get_id(),
+            new_identifier=node_created.get_id(),
+            branch=branch,
+        )
+        await query.execute(db=dbt)
+
         return node_created