ipfabric_netbox 4.1.0b3__tar.gz → 4.1.0b4__tar.gz

{ipfabric_netbox-4.1.0b3 → ipfabric_netbox-4.1.0b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ipfabric_netbox
-Version: 4.1.0b3
+Version: 4.1.0b4
 Summary: NetBox plugin to sync IP Fabric data into NetBox
 License: MIT
 Keywords: netbox,ipfabric,plugin,sync

{ipfabric_netbox-4.1.0b3 → ipfabric_netbox-4.1.0b4}/ipfabric_netbox/__init__.py

@@ -6,7 +6,7 @@ class NetboxIPFabricConfig(PluginConfig):
     name = "ipfabric_netbox"
     verbose_name = "NetBox IP Fabric SoT Plugin"
     description = "Sync IP Fabric into NetBox"
-    version = "4.1.0b3"
+    version = "4.1.0b4"
     base_url = "ipfabric"
     min_version = "4.2.4"
 

{ipfabric_netbox-4.1.0b3 → ipfabric_netbox-4.1.0b4}/ipfabric_netbox/utilities/ipfutils.py

@@ -3,6 +3,7 @@ import logging
 from importlib import metadata
 from typing import Callable
 from typing import TYPE_CHECKING
+from typing import TypeVar
 
 from core.choices import DataSourceStatusChoices
 from core.exceptions import SyncError
@@ -36,9 +37,12 @@ FAILED_CREATE_INSTANCE_TEMPLATE = (
 
 if TYPE_CHECKING:
     from ..models import IPFabricIngestion
+    from ipam.models import IPAddress
 
 logger = logging.getLogger("ipfabric_netbox.utilities.ipf_utils")
 
+ModelTypeVar = TypeVar("ModelTypeVar", bound=Model)
+
 
 def slugify_text(value):
     return slugify(value)
@@ -98,7 +102,7 @@ class IPFabric(object):
                 formatted_snapshots[snapshot_ref] = (description, snapshot.snapshot_id)
         return formatted_snapshots
 
-    def get_sites(self, snapshot=None) -> dict():
+    def get_sites(self, snapshot=None) -> list:
         if snapshot:
             raw_sites = self.ipf.inventory.sites.all(snapshot_id=snapshot)
         else:
@@ -526,11 +530,29 @@ class IPFabricSyncRunner(object):
         )
 
     @handle_errors
-    def sync_model(self, app_label: str, model: str, data: dict | None) -> Model | None:
+    def sync_model(
+        self,
+        app_label: str,
+        model: str,
+        data: dict | None,
+        stats: bool = True,
+        sync: bool = False,
+    ) -> ModelTypeVar | None:
         """Sync a single item to NetBox."""
+        # The `sync` param is a workaround since we need to get some models (Device...) even when not syncing them.
+        if not sync:
+            return None
+
         if not data:
             return None
-        return self.get_model_or_update(app_label, model, data)
+
+        instance = self.get_model_or_update(app_label, model, data)
+
+        # Only log when we successfully synced the item and asked for it
+        if stats:
+            self.logger.increment_statistics(model=model)
+
+        return instance
 
     def sync_items(
         self,
@@ -548,11 +570,14 @@ class IPFabricSyncRunner(object):
             return
 
         for item in items:
-            synced_object = self.sync_model(app_label=app_label, model=model, data=item)
+            synced_object = self.sync_model(
+                app_label=app_label,
+                model=model,
+                data=item,
+                sync=self.settings.get(model),
+            )
             if synced_object is None:
                 continue
-            # Only log when we successfully synced the item
-            self.logger.increment_statistics(model=model)
 
             if cf:
                 synced_object.snapshot()
@@ -588,22 +613,40 @@ class IPFabricSyncRunner(object):
         devices_total = len(devices)
 
         for device in devices:
-            if self.sync_model("dcim", "manufacturer", device) is None:
-                continue
-            if self.sync_model("dcim", "devicetype", device) is None:
-                continue
-            if self.sync_model("dcim", "platform", device) is None:
-                continue
-            if self.sync_model("dcim", "devicerole", device) is None:
-                continue
+            self.sync_model(
+                "dcim", "manufacturer", device, sync=self.settings.get("manufacturer")
+            )
+            self.sync_model(
+                "dcim", "devicetype", device, sync=self.settings.get("devicetype")
+            )
+            self.sync_model(
+                "dcim", "platform", device, sync=self.settings.get("platform")
+            )
+            self.sync_model(
+                "dcim", "devicerole", device, sync=self.settings.get("devicerole")
+            )
 
             virtual_chassis = device.get("virtual_chassis", {})
-            self.sync_model("dcim", "virtualchassis", virtual_chassis)
+            self.sync_model(
+                "dcim",
+                "virtualchassis",
+                virtual_chassis,
+                False,
+                sync=self.settings.get("virtualchassis"),
+            )
 
-            if (device_object := self.sync_model("dcim", "device", device)) is None:
-                continue
+            # We need to get a Device instance even when not syncing it but syncing Interfaces, IPs or MACs
+            device_object: Device | None = self.sync_model(
+                "dcim",
+                "device",
+                device,
+                sync=self.settings.get("device")
+                or self.settings.get("interface")
+                or self.settings.get("ipaddress")
+                or self.settings.get("macaddress"),
+            )
 
-            if self.settings.get("device"):
+            if device_object and self.settings.get("device"):
                 device_object.snapshot()
                 device_object.custom_field_data[
                     "ipfabric_source"
@@ -612,23 +655,26 @@ class IPFabricSyncRunner(object):
                     device_object.custom_field_data["ipfabric_ingestion"] = ingestion.pk
                 device_object.save()
 
-            self.logger.increment_statistics(model="device")
-            logger.info(
-                f"Device {self.logger.log_data.get('statistics', {}).get('device', {}).get('current')} out of {devices_total}"
-            )
+                self.logger.increment_statistics(model="device")
+                logger.info(
+                    f"Device {self.logger.log_data.get('statistics', {}).get('device', {}).get('current')} out of {devices_total}"
+                )
 
-            # The Device exists now, so we can update master of the VC.
-            # The logic is handled in transform maps.
-            self.sync_model("dcim", "virtualchassis", virtual_chassis)
+                # The Device exists now, so we can update the master of the VC.
+                # The logic is handled in transform maps.
+                self.sync_model(
+                    "dcim",
+                    "virtualchassis",
+                    virtual_chassis,
+                    False,
+                    sync=self.settings.get("virtualchassis"),
+                )
 
             device_interfaces = interface_dict.get(device.get("sn"), [])
             for device_interface in device_interfaces:
-                interface_object = self.sync_interface(
+                self.sync_interface(
                     device_interface, managed_ips, device_object, device
                 )
-                if interface_object is None:
-                    continue
-                self.logger.increment_statistics(model="interface")
 
     @handle_errors
     def sync_ipaddress(
@@ -638,22 +684,20 @@ class IPFabricSyncRunner(object):
         primary_ip: str | None,
         login_ip: str | None,
     ):
-        if not self.settings.get("ipaddress") or not managed_ip:
-            return
-        ip_address_obj = self.get_model_or_update(
+        ip_address_obj: "IPAddress | None" = self.sync_model(
             "ipam",
             "ipaddress",
             managed_ip,
+            sync=self.settings.get("ipaddress"),
         )
         if ip_address_obj is None:
-            return
-        self.logger.increment_statistics(model="ipaddress")
+            return None
 
         connection_name = self.get_db_connection_name()
 
         try:
-            # Removing other IP is done in .signals.clear_other_primary_ip
-            # But do it here too so the change is shown in StagedChange diff
+            # Removing another IP is done in .signals.clear_other_primary_ip
+            # But do it here too, so the change is shown in StagedChange diff
             other_device = Device.objects.using(connection_name).get(
                 primary_ip4=ip_address_obj
             )
@@ -669,7 +713,7 @@ class IPFabricSyncRunner(object):
                 device_object.snapshot()
                 device_object.primary_ip4 = ip_address_obj
                 device_object.save(using=connection_name)
-            except ValueError as err:
+            except (ValueError, AttributeError) as err:
                 self.logger.log_failure(
                     f"Error assigning primary IP to device: {err}", obj=self.sync
                 )
@@ -680,17 +724,17 @@ class IPFabricSyncRunner(object):
     def sync_macaddress(
         self, data: dict | None, interface_object: Interface
     ) -> MACAddress | None:
-        if not self.settings.get("macaddress") or not data:
-            return None
         # Need to create MAC Address object before we can assign it to Interface
         # TODO: Figure out how to do this using transform maps
         macaddress_data = {
             "mac": data,
-            "id": interface_object.pk,
+            "id": getattr(interface_object, "pk", None),
         }
-        macaddress_object = self.get_model_or_update(
-            "dcim", "macaddress", macaddress_data
+        macaddress_object: MACAddress | None = self.sync_model(
+            "dcim", "macaddress", macaddress_data, sync=self.settings.get("macaddress")
         )
+        if macaddress_object is None:
+            return None
         try:
             interface_object.snapshot()
             interface_object.primary_mac_address = macaddress_object
@@ -711,15 +755,19 @@ class IPFabricSyncRunner(object):
         device: dict,
     ):
         device_interface["loginIp"] = device.get("loginIp")
-        interface_object = self.get_model_or_update(
-            "dcim", "interface", device_interface
+        # We need to get an Interface instance even when not syncing it but syncing IPs or MACs
+        interface_object: Interface | None = self.sync_model(
+            "dcim",
+            "interface",
+            device_interface,
+            sync=self.settings.get("interface")
+            or self.settings.get("ipaddress")
+            or self.settings.get("macaddress"),
         )
-        if interface_object is None:
-            return None
 
-        for ipaddress in managed_ips.get(device_object.serial, {}).get(
-            interface_object.name, []
-        ):
+        for ipaddress in managed_ips.get(
+            getattr(device_object, "serial", None), {}
+        ).get(getattr(interface_object, "name", None), []):
             self.sync_ipaddress(
                 ipaddress,
                 device_object,

{ipfabric_netbox-4.1.0b3 → ipfabric_netbox-4.1.0b4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ipfabric_netbox"
-version = "4.1.0b3"
+version = "4.1.0b4"
 description = "NetBox plugin to sync IP Fabric data into NetBox"
 authors = ["Solution Architecture <solution.architecture@ipfabric.io>"]
 license = "MIT"