ipfabric_netbox 3.2.3__py3-none-any.whl → 3.2.4b2__py3-none-any.whl

ipfabric_netbox/migrations/0013_switch_to_branching_plugin.py

@@ -0,0 +1,270 @@
+# Generated by Django 5.1.6 on 2025-04-24 11:46
+import contextlib
+from enum import IntEnum
+from typing import TYPE_CHECKING
+
+import django.db.models.deletion
+from django.db import migrations
+from django.db import models
+
+if TYPE_CHECKING:
+    from django.apps import apps as apps_type
+    from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+
+
+def modify_custom_field(
+    apps: "apps_type",
+    current_name: str,
+    new_name: str,
+    new_label: str,
+    new_object_type: models.Model,
+):
+    CustomField = apps.get_model("extras", "CustomField")
+    ObjectType = apps.get_model("core", "ObjectType")
+
+    try:
+        custom_field = CustomField.objects.get(name=current_name)
+    except CustomField.DoesNotExist:
+        return
+
+    custom_field.name = new_name
+    custom_field.label = new_label
+    custom_field.related_object_type = ObjectType.objects.get_for_model(new_object_type)
+    custom_field.full_clean()
+    custom_field.save()
+
+
+def rename_ipfabric_branch_cf(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    """Forward migration to rename ipfabric_branch CustomField to ipfabric_ingestion."""
+    modify_custom_field(
+        apps,
+        "ipfabric_branch",
+        "ipfabric_ingestion",
+        "IP Fabric Last Ingestion",
+        apps.get_model("ipfabric_netbox", "IPFabricIngestion"),
+    )
+
+
+def rename_ipfabric_ingestion_cf(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    """Forward migration to rename ipfabric_ingestion CustomField to ipfabric_branch."""
+    modify_custom_field(
+        apps,
+        "ipfabric_ingestion",
+        "ipfabric_branch",
+        "IP Fabric Last Sync",
+        apps.get_model("ipfabric_netbox", "IPFabricBranch"),
+    )
+
+
+def clean_redisual_branch_data(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    """
+    Clean up any residual data in the Branch model that have been left behind
+    after the migration.
+    """
+    ContentType = apps.get_model("contenttypes", "contenttype")
+    Permission = apps.get_model("auth", "permission")
+
+    try:
+        branch_content_type = ContentType.objects.get(
+            app_label="ipfabric_netbox", model="ipfabricbranch"
+        )
+    except ContentType.DoesNotExist:
+        return
+
+    Permission.objects.filter(content_type=branch_content_type).delete()
+    branch_content_type.delete()
+
+
+# interface fix templates
+DUPLEX_TEMPLATE_BEFORE = ""
+DUPLEX_TEMPLATE_AFTER = '{% if not object.duplex or object.duplex=="unknown" %}None{% else %}{{ object.duplex }}{% endif %}'
+SPEED_TEMPLATE_BEFORE = "{% if not object.speedValue %}None{% else %}{{ object.speedValue|int // 1000 }}{% endif %}"
+SPEED_TEMPLATE_AFTER = '{% if not object.speedValue or object.speedValue=="unknown" %}None{% else %}{{ object.speedValue|int // 1000 }}{% endif %}'
+
+# devicetype fix templates
+DEVICETYPE_RELATIONSHIP_TEMPLATE_BEFORE = '{% if object.model != none %}{% set SLUG = object.model | string | slugify %}{% else %}{% set SLUG = object.vendor | slugify ~ "-" ~ object.family | slugify ~ "-" ~ object.platform %}{% endif %}{{ dcim.DeviceType.objects.get(slug=SLUG).pk }}'
+DEVICETYPE_RELATIONSHIP_TEMPLATE_AFTER = '{% if object.model %}{% set SLUG = object.model | string | slugify %}{% else %}{% set SLUG = object.vendor | slugify ~ "-" ~ object.family | slugify ~ "-" ~ object.platform | slugify %}{% endif %}{{ dcim.DeviceType.objects.get(slug=SLUG).pk }}'
+MODEL_SLUG_TEMPLATE_BEFORE = "{% if object.model != none %}{{ object.model | string | slugify }}{% else %}{{ object.vendor | slugify }}-{{ object.family | slugify}}-{{ object.platform }}{% endif %}"
+MODEL_SLUG_TEMPLATE_AFTER = "{% if object.model %}{{ object.model | string | slugify }}{% else %}{{ object.vendor | slugify }}-{{ object.family | slugify}}-{{ object.platform | slugify }}{% endif %}"
+MODEL_TEMPLATE_BEFORE = "{% if object.model != none %}{{ object.model | string }}{% else %}{{ object.vendor }} - {{ object.family }} - {{ object.platform }}{% endif %}"
+MODEL_TEMPLATE_AFTER = "{% if object.model %}{{ object.model | string }}{% else %}{{ object.vendor }} - {{ object.family }} - {{ object.platform }}{% endif %}"
+
+TEMPLATES = {
+    "duplex": (DUPLEX_TEMPLATE_BEFORE, DUPLEX_TEMPLATE_AFTER),
+    "speed": (SPEED_TEMPLATE_BEFORE, SPEED_TEMPLATE_AFTER),
+    "devicetype_relationship": (
+        DEVICETYPE_RELATIONSHIP_TEMPLATE_BEFORE,
+        DEVICETYPE_RELATIONSHIP_TEMPLATE_AFTER,
+    ),
+    "model_slug": (MODEL_SLUG_TEMPLATE_BEFORE, MODEL_SLUG_TEMPLATE_AFTER),
+    "model": (MODEL_TEMPLATE_BEFORE, MODEL_TEMPLATE_AFTER),
+}
+
+
+class MigrationType(IntEnum):
+    FORWARD = 0
+    REVERSE = 1
+
+
+def change_transform_maps(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor", migration_type: int
+):
+    """
+    * Ignore 'unknown' values for duplex and speed on Interface.
+    * Correctly set DeviceType value when model is empty (not None!).
+    * Slugify platform when using it for DeviceType slug.
+    """
+    ContentType = apps.get_model("contenttypes", "ContentType")
+    TransformMap = apps.get_model("ipfabric_netbox", "IPFabricTransformMap")
+    TransformField = apps.get_model("ipfabric_netbox", "IPFabricTransformField")
+    RelationshipField = apps.get_model("ipfabric_netbox", "IPFabricRelationshipField")
+
+    with contextlib.suppress(TransformMap.DoesNotExist, TransformField.DoesNotExist):
+        interface_transform_map = TransformMap.objects.get(
+            source_model="interface",
+            target_model__app_label="dcim",
+            target_model__model="interface",
+        )
+        TransformField.objects.filter(
+            transform_map=interface_transform_map,
+            template=TEMPLATES["duplex"][migration_type],
+            source_field="duplex",
+            target_field="duplex",
+        ).update(template=TEMPLATES["duplex"][int(not migration_type)])
+        TransformField.objects.filter(
+            transform_map=interface_transform_map,
+            template=TEMPLATES["speed"][migration_type],
+            source_field="speedValue",
+            target_field="speed",
+        ).update(template=TEMPLATES["speed"][int(not migration_type)])
+
+    with contextlib.suppress(
+        TransformMap.DoesNotExist,
+        TransformField.DoesNotExist,
+        RelationshipField.DoesNotExist,
+    ):
+        device_transform_map = TransformMap.objects.get(
+            source_model="device",
+            target_model__app_label="dcim",
+            target_model__model="device",
+        )
+        RelationshipField.objects.filter(
+            transform_map=device_transform_map,
+            template=TEMPLATES["devicetype_relationship"][migration_type],
+            source_model=ContentType.objects.get(app_label="dcim", model="devicetype"),
+            target_field="device_type",
+        ).update(template=TEMPLATES["devicetype_relationship"][int(not migration_type)])
+
+        devicetype_transform_map = TransformMap.objects.get(
+            source_model="device",
+            target_model__app_label="dcim",
+            target_model__model="devicetype",
+        )
+        TransformField.objects.filter(
+            transform_map=devicetype_transform_map,
+            template=TEMPLATES["model_slug"][migration_type],
+            source_field="model",
+            target_field="slug",
+        ).update(template=TEMPLATES["model_slug"][int(not migration_type)])
+        TransformField.objects.filter(
+            transform_map=devicetype_transform_map,
+            template=TEMPLATES["model"][migration_type],
+            source_field="model",
+            target_field="model",
+        ).update(template=TEMPLATES["model"][int(not migration_type)])
+
+
+def forward_change_transform_maps(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    """
+    * Ignore 'unknown' values for duplex and speed on Interface.
+    * Correctly set DeviceType value when model is empty (not None!).
+    * Slugify platform when using it for DeviceType slug.
+    """
+    change_transform_maps(apps, schema_editor, migration_type=MigrationType.FORWARD)
+
+
+def reverse_change_transform_maps(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    """
+    Return changes done in `change_transform_maps` to the original state.
+    """
+    change_transform_maps(apps, schema_editor, migration_type=MigrationType.REVERSE)
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("core", "0012_job_object_type_optional"),
+        ("ipfabric_netbox", "0012_remove_status_field"),
+        ("netbox_branching", "0003_rename_indexes"),
+        ("extras", "0123_journalentry_kind_default"),
+    ]
+
+    operations = [
+        migrations.RunPython(migrations.RunPython.noop, rename_ipfabric_ingestion_cf),
+        migrations.DeleteModel(
+            name="IPFabricBranch",
+        ),
+        migrations.CreateModel(
+            name="IPFabricIngestion",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False
+                    ),
+                ),
+                (
+                    "branch",
+                    models.OneToOneField(
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        to="netbox_branching.branch",
+                    ),
+                ),
+                (
+                    "job",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        to="core.job",
+                    ),
+                ),
+                (
+                    "sync",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="ipfabric_netbox.ipfabricsync",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "IP Fabric Ingestion",
+                "verbose_name_plural": "IP Fabric Ingestion",
+                "ordering": ("pk",),
+            },
+        ),
+        migrations.AlterField(
+            model_name="ipfabricrelationshipfield",
+            name="template",
+            field=models.TextField(blank=True, default=""),
+        ),
+        migrations.AlterField(
+            model_name="ipfabrictransformfield",
+            name="template",
+            field=models.TextField(blank=True, default=""),
+        ),
+        migrations.RunPython(rename_ipfabric_branch_cf, migrations.RunPython.noop),
+        migrations.RunPython(clean_redisual_branch_data, migrations.RunPython.noop),
+        migrations.RunPython(
+            forward_change_transform_maps, reverse_change_transform_maps
+        ),
+    ]

ipfabric_netbox/models.py

@@ -3,12 +3,13 @@ import json
 import logging
 import traceback
 from copy import deepcopy
+from uuid import uuid4
 
 import httpx
 from core.choices import DataSourceStatusChoices
 from core.exceptions import SyncError
 from core.models import Job
-from core.signals import handle_deleted_object
+from core.models import ObjectType
 from core.signals import pre_sync
 from dcim.models import Device
 from dcim.models import VirtualChassis
@@ -22,23 +23,22 @@ from django.db import models
 from django.db import transaction
 from django.db.models import Q
 from django.db.models import signals
-from django.forms.models import model_to_dict
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.module_loading import import_string
 from django.utils.translation import gettext as _
-from extras.models import Branch
-from extras.models import StagedChange
+from netbox.context import current_request
 from netbox.models import ChangeLoggedModel
 from netbox.models import NetBoxModel
 from netbox.models import PrimaryModel
 from netbox.models.features import JobsMixin
 from netbox.models.features import TagsMixin
 from netbox.registry import registry
-from netbox.staging import checkout
-from utilities.data import shallow_compare_dict
+from netbox_branching.choices import BranchStatusChoices
+from netbox_branching.contextvars import active_branch
+from netbox_branching.models import Branch
 from utilities.querysets import RestrictedQuerySet
-from utilities.serialization import serialize_object
+from utilities.request import NetBoxFakeRequest
 
 from .choices import IPFabricRawDataTypeChoices
 from .choices import IPFabricSnapshotStatusModelChoices
@@ -55,12 +55,13 @@ from .utilities.logging import SyncLogging
 logger = logging.getLogger("ipfabric_netbox.models")
 
 
-def apply_tags(object, tags):
+def apply_tags(object, tags, connection_name=None):
     def _apply(object):
+        object.snapshot()
         for tag in tags:
             if hasattr(object, "tags"):
                 object.tags.add(tag)
-        object.save()
+        object.save(using=connection_name)
 
     _apply(object)
 
@@ -108,9 +109,6 @@ class IPFabricTransformMap(NetBoxModel):
         blank=False,
         null=False,
     )
-    status = models.CharField(
-        max_length=50,
-    )
 
     class Meta:
         verbose_name = "IP Fabric Transform Map"
@@ -188,12 +186,34 @@ class IPFabricTransformMap(NetBoxModel):
         context = self.render(new_data)
         return context
 
-    def update_or_create_instance(self, context, tags=[]):
-        instance, _ = self.target_model.model_class().objects.update_or_create(
-            **context
-        )
-        if instance:
-            apply_tags(instance, tags)
+    def update_or_create_instance(self, context, tags=[], connection_name=None):
+        target_class = self.target_model.model_class()
+        queryset = target_class.objects.using(connection_name)
+
+        defaults = context.pop("defaults", {})
+
+        with transaction.atomic(using=connection_name):
+            try:
+                # For correct ObjectChange on UPDATE we need to create snapshot
+                # NetBox does this in UI using views, we need to do it manually
+                # See NetBox docs Customization -> Custom Scripts -> Change Logging
+                instance = queryset.get(**context)
+                instance.snapshot()
+                for attr, value in defaults.items():
+                    setattr(instance, attr, value)
+                instance.full_clean()
+                instance.save(using=connection_name)
+            except target_class.DoesNotExist:
+                for field in list(context.keys()):
+                    # When assigning we need to replace `field__isnull=True` with `field=None`
+                    if field.endswith("__isnull"):
+                        context[field[:-8]] = None
+                        del context[field]
+                instance = queryset.create(**context, **defaults)
+                instance.full_clean()
+
+            apply_tags(instance, tags, connection_name)
+
         return instance
 
     def render(self, source_data):
@@ -240,9 +260,6 @@ class IPFabricTransformMap(NetBoxModel):
         if relationship_coalesce := source_data.get("relationship_coalesce"):
             data.update(relationship_coalesce)
 
-        if self.status:
-            data["defaults"]["status"] = self.status
-
         return data
 
 
@@ -269,7 +286,7 @@ class IPFabricRelationshipField(models.Model):
             "Jinja2 template code, return an integer to create a relationship between the source and target model. True, False and None are also supported."
         ),
         blank=True,
-        null=True,
+        default="",
     )
 
     objects = RestrictedQuerySet.as_manager()
@@ -301,7 +318,7 @@ class IPFabricTransformField(models.Model):
     template = models.TextField(
         help_text=_("Jinja2 template code to be rendered into the target field."),
         blank=True,
-        null=True,
+        default="",
     )
 
     class Meta:
@@ -671,14 +688,28 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
         logger.info(f"Syncing with the following data {json.dumps(self.parameters)}")
 
         current_time = str(timezone.now())
+        ingestion = IPFabricIngestion.objects.create(sync=self, job=job)
+        try:
+            branch = Branch(name=f"IP Fabric Sync {current_time}")
+            branch.save(provision=False)
+            ingestion.branch = branch
+            ingestion.save()
 
-        branch = IPFabricBranch.objects.create(
-            name=f"{current_time}", sync=self, job=job, user=user
-        )
-        self.logger.log_info(f"New branch Created {branch.name}", obj=branch)
-        logger.info(f"New branch Created {branch.name}")
+            if job:
+                # Re-assign the Job from IPFSync to IPFabricIngestion so it is listed in the ingestion
+                job.object_type = ObjectType.objects.get_for_model(ingestion)
+                job.object_id = ingestion.pk
+                job.save()
+            branch.provision(user=user)
+            branch.refresh_from_db()
+            if branch.status == BranchStatusChoices.FAILED:
+                print("Branch Failed")
+                self.logger.log_failure(f"Branch Failed: `{branch}`", obj=branch)
+                raise SyncError("Branch Creation Failed")
+
+            self.logger.log_info(f"New branch Created {branch.name}", obj=branch)
+            logger.info(f"New branch Created {branch.name}")
 
-        try:
             self.logger.log_info("Fetching IP Fabric Client", obj=branch)
             logger.info("Fetching IP Fabric Client")
 
@@ -695,58 +726,62 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
 
             runner = IPFabricSyncRunner(
                 client=ipf,
+                ingestion=ingestion,
                 settings=self.parameters,
                 transform_map=IPFabricTransformMap,
                 sync=self,
             )
 
-            with checkout(branch):
-                runner.collect_and_sync(branch=branch)
+            # Not using `deactivate_branch` since that does not clean up on Exception
+            current_branch = active_branch.get()
+            if not (token := current_request.get()):
+                # This allows for ChangeLoggingMiddleware to create ObjectChanges
+                token = current_request.set(
+                    NetBoxFakeRequest({"id": uuid4(), "user": user})
+                )
+            try:
+                active_branch.set(branch)
+                try:
+                    runner.collect_and_sync(
+                        ingestion=IPFabricIngestion.objects.get(pk=ingestion.pk)
+                    )
+                finally:
+                    active_branch.set(None)
+            finally:
+                current_request.set(token.old_value)
+                active_branch.set(current_branch)
 
             if self.status != DataSourceStatusChoices.FAILED:
                 self.status = DataSourceStatusChoices.COMPLETED
 
         except Exception as e:
             self.status = DataSourceStatusChoices.FAILED
-            self.logger.log_failure(f"Branch Failed: `{e}`", obj=branch)
+            self.logger.log_failure(f"Ingestion Failed: `{e}`", obj=ingestion)
             self.logger.log_failure(
-                f"Stack Trace: `{traceback.format_exc()}`", obj=branch
+                f"Stack Trace: `{traceback.format_exc()}`", obj=ingestion
             )
-            logger.debug(f"Branch Failed: `{e}`")
+            logger.debug(f"Ingestion Failed: `{e}`")
 
         logger.debug(f"Completed ingesting data from {self.snapshot_data.source.name}")
         self.logger.log_info(
             f"Completed ingesting data from {self.snapshot_data.source.name}", obj=self
         )
 
-        for change in branch.staged_changes.all():
-            if hasattr(change.object, "pk"):
-                prechange_data = prechange_data = serialize_object(
-                    change.object, resolve_tags=False
-                )
-                prechange_data = dict(sorted(prechange_data.items()))
-            else:
-                prechange_data = None
-            if hasattr(change, "data"):
-                postchange_data = dict(sorted(change.data.items()))
-
-            diff_added = shallow_compare_dict(
-                prechange_data or dict(),
-                postchange_data or dict(),
-                exclude=["last_updated"],
-            )
-
-            if not diff_added:
-                change.delete()
-
         self.last_synced = timezone.now()
 
         if self.auto_merge and self.status == DataSourceStatusChoices.COMPLETED:
-            self.logger.log_info("Auto Merging Branch", obj=branch)
-            logger.info("Auto Merging Branch")
-            branch.enqueue_merge_job(user=user)
-            self.logger.log_info("Auto Merge Job Enqueued", obj=branch)
-            logger.info("Auto Merge Job Enqueued")
+            self.logger.log_info("Auto Merging Ingestion", obj=ingestion)
+            logger.info("Auto Merging Ingestion")
+            try:
+                ingestion.enqueue_merge_job(user=user)
+                self.logger.log_info("Auto Merge Job Enqueued", obj=ingestion)
+                logger.info("Auto Merge Job Enqueued")
+            except NameError:
+                self.logger.log_failure(
+                    "Failed to Auto Merge, IPFabricIngestion does not exist",
+                    obj=ingestion,
+                )
+                logger.debug("Failed to Auto Merge, IPFabricIngestion does not exist")
 
         IPFabricSync.objects.filter(pk=self.pk).update(
             status=self.status, last_synced=self.last_synced
@@ -755,36 +790,48 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
             job.data = self.logger.log_data
 
 
-class IPFabricBranch(JobsMixin, Branch):
+class IPFabricIngestion(JobsMixin, models.Model):
     """
-    A collection of related StagedChanges.
+    Links IP Fabric Sync to its Branches.
     """
 
+    objects = RestrictedQuerySet.as_manager()
+
     sync = models.ForeignKey(IPFabricSync, on_delete=models.CASCADE)
     job = models.ForeignKey(Job, on_delete=models.SET_NULL, null=True)
+    branch = models.OneToOneField(Branch, on_delete=models.SET_NULL, null=True)
 
     class Meta:
-        ordering = ("name",)
-        verbose_name = "IP Fabric Branch"
-        verbose_name_plural = "IP Fabric Branches"
+        ordering = ("pk",)
+        verbose_name = "IP Fabric Ingestion"
+        verbose_name_plural = "IP Fabric Ingestions"
 
     def __str__(self):
-        return f"{self.name} ({self.pk})"
+        return self.name
+
+    @property
+    def name(self):
+        if self.branch:
+            return self.branch.name
+        return f"{self.sync.name} (Ingestion {self.pk})"
 
     def get_absolute_url(self):
-        return reverse("plugins:ipfabric_netbox:ipfabricbranch", args=[self.pk])
+        return reverse("plugins:ipfabric_netbox:ipfabricingestion", args=[self.pk])
 
-    def enqueue_merge_job(self, user):
-        # Set the status to "syncing"
+    def enqueue_merge_job(self, user, remove_branch=False):
+        # Set the status to "queued"
         self.status = DataSourceStatusChoices.QUEUED
-        IPFabricSync.objects.filter(ipfabricbranch=self.pk).update(status=self.status)
+        IPFabricSync.objects.filter(ipfabricingestion=self.pk).update(
+            status=self.status
+        )
 
         # Enqueue a sync job
         return Job.enqueue(
-            import_string("ipfabric_netbox.jobs.merge_ipfabric_branch"),
+            import_string("ipfabric_netbox.jobs.merge_ipfabric_ingestion"),
             name=f"{self.name} Merge",
             instance=self,
             user=user,
+            remove_branch=remove_branch,
         )
 
     def get_logs(self):
@@ -809,24 +856,6 @@ class IPFabricBranch(JobsMixin, Branch):
                     statistics[model] = stats["current"] / 1 * 100
         return {"job_results": job_results, "statistics": statistics}
 
-    def merge(self):
-        logger.info(f"Merging changes in branch {self}")
-        with transaction.atomic():
-            for change in self.staged_changes.all():
-                logger.debug("Applying change: %s", change)
-                try:
-                    change.apply()
-                except Exception as err:
-                    content_type = ContentType.objects.get(pk=change.object_type.pk)
-                    data = model_to_dict(change)["data"]
-                    logger.error(
-                        f"Got error applying change ({content_type}: {data}): {err}"
-                    )
-                    raise
-        signals.pre_delete.disconnect(handle_deleted_object)
-        self.staged_changes.all().delete()
-        signals.pre_delete.connect(handle_deleted_object, sender=StagedChange)
-
     def sync_merge(self):
         ipfabricsync = self.sync
         if ipfabricsync.status == DataSourceStatusChoices.SYNCING:
@@ -835,7 +864,7 @@ class IPFabricBranch(JobsMixin, Branch):
         pre_sync.send(sender=self.__class__, instance=self)
 
         ipfabricsync.status = DataSourceStatusChoices.SYNCING
-        IPFabricSync.objects.filter(ipfabricbranch=self.pk).update(
+        IPFabricSync.objects.filter(ipfabricingestion=self.pk).update(
             status=self.sync.status
         )
 
@@ -846,7 +875,7 @@ class IPFabricBranch(JobsMixin, Branch):
             signals.post_save.disconnect(
                 assign_virtualchassis_master, sender=VirtualChassis
             )
-            self.merge()
+            self.branch.merge(user=self.sync.user)
             signals.post_save.connect(
                 assign_virtualchassis_master, sender=VirtualChassis
             )
@@ -859,7 +888,7 @@ class IPFabricBranch(JobsMixin, Branch):
         logger.debug(f"Completed merge {self.name}")
 
         ipfabricsync.last_synced = timezone.now()
-        IPFabricSync.objects.filter(ipfabricbranch=self.pk).update(
+        IPFabricSync.objects.filter(ipfabricingestion=self.pk).update(
             status=ipfabricsync.status, last_synced=ipfabricsync.last_synced
         )
 

ipfabric_netbox/navigation.py

@@ -37,7 +37,7 @@ snapshot = PluginMenuItem(
 
 ingestion = PluginMenuItem(
     link="plugins:ipfabric_netbox:ipfabricsync_list",
-    link_text="Ingestion",
+    link_text="Syncs",
     buttons=sync_buttons,
     permissions=["ipfabric_netbox.view_ipfabricsync"],
 )

ipfabric_netbox/signals.py

@@ -2,6 +2,7 @@ import logging
 
 from dcim.models import Device
 from ipam.models import IPAddress
+from netbox_branching.contextvars import active_branch
 
 logger = logging.getLogger("ipfabric_netbox.utilities.ipf_utils")
 
@@ -21,9 +22,15 @@ def clear_other_primary_ip(instance: Device, **kwargs) -> None:
         # THe IP is not created yet, cannot be assigned
         return
     try:
-        other_device = Device.objects.get(primary_ip4=instance.primary_ip)
+        connection_name = None
+        if branch := active_branch.get():
+            connection_name = branch.connection_name
+        other_device = Device.objects.using(connection_name).get(
+            primary_ip4=instance.primary_ip
+        )
         if other_device and instance != other_device:
+            other_device.snapshot()
             other_device.primary_ip4 = None
-            other_device.save()
+            other_device.save(using=connection_name)
     except Device.DoesNotExist:
         pass