ipfabric_netbox 3.1.2__py3-none-any.whl

ipfabric_netbox/__init__.py

@@ -0,0 +1,42 @@
+import requests
+from django.db import connection
+from netbox.plugins import PluginConfig
+
+
+class NetboxIPFabricConfig(PluginConfig):
+    name = "ipfabric_netbox"
+    verbose_name = "NetBox IP Fabric SoT Plugin"
+    description = "Sync IP Fabric into NetBox"
+    version = "3.1.1"
+    base_url = "ipfabric"
+    min_version = "4.1"
+
+    def ready(self):
+        super().ready()
+        try:
+            from ipfabric_netbox.signals import ipfabric_netbox_init
+
+            all_tables = connection.introspection.table_names()
+            if all(
+                item in all_tables
+                for item in [
+                    "extras_customfield",
+                    "ipfabric_netbox_ipfabricbranch",
+                    "ipfabric_netbox_ipfabricsource",
+                ]
+            ):
+                ipfabric_netbox_init()
+            if "ipfabric_netbox_ipfabrictransformmap" in all_tables:
+                from ipfabric_netbox.models import IPFabricTransformMap
+                from ipfabric_netbox.utilities.transform_map import BuildTransformMaps
+
+                if IPFabricTransformMap.objects.count() == 0:
+                    data = requests.get(
+                        "https://gitlab.com/ip-fabric/integrations/ipfabric-netbox/-/raw/main/scripts/transform_map.json"
+                    ).json()
+                    BuildTransformMaps(data=data)
+        except Exception as e:
+            print(f"Failed to initialize IP Fabric plugin: {e}.")
+
+
+config = NetboxIPFabricConfig

ipfabric_netbox/api/__init__.py

@@ -0,0 +1,2 @@
+from .nested_serializers import *  # noqa: F401, F403
+from .serializers import *  # noqa: F401, F403

ipfabric_netbox/api/nested_serializers.py

@@ -0,0 +1,99 @@
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import extend_schema_field
+from netbox.api.fields import ContentTypeField
+from netbox.api.serializers import NetBoxModelSerializer
+from netbox.api.serializers import WritableNestedSerializer
+from rest_framework import serializers
+from users.api.serializers_.nested import NestedUserSerializer
+
+from ipfabric_netbox.models import IPFabricBranch
+from ipfabric_netbox.models import IPFabricSnapshot
+from ipfabric_netbox.models import IPFabricSource
+from ipfabric_netbox.models import IPFabricSync
+from ipfabric_netbox.models import IPFabricTransformMap
+
+# from .serializers import IPFabricSyncSerializer
+
+__all__ = (
+    "NestedIPFabricSourceSerializer",
+    "NestedIPFabricSnapshotSerializer",
+    "NestedIPFabricTransformMapSerializer",
+    "NestedIPFabricBranchSerializer",
+    "NestedIPFabricSyncSerializer",
+)
+
+
+class NestedIPFabricSourceSerializer(WritableNestedSerializer):
+    url = serializers.URLField()
+
+    class Meta:
+        model = IPFabricSource
+        fields = ["id", "url", "display", "name", "type"]
+
+
+class NestedIPFabricSnapshotSerializer(NetBoxModelSerializer):
+    source = NestedIPFabricSourceSerializer(read_only=True)
+    display = serializers.SerializerMethodField(read_only=True)
+
+    class Meta:
+        model = IPFabricSnapshot
+        fields = [
+            "id",
+            "name",
+            "source",
+            "snapshot_id",
+            "status",
+            "date",
+            "display",
+            "sites",
+        ]
+
+    @extend_schema_field(OpenApiTypes.STR)
+    def get_display(self, obj):
+        return f"{obj.name} ({obj.snapshot_id})"
+
+
+class NestedIPFabricSyncSerializer(NetBoxModelSerializer):
+    snapshot_data = NestedIPFabricSnapshotSerializer(read_only=True)
+
+    class Meta:
+        model = IPFabricSync
+        fields = [
+            "id",
+            "name",
+            "display",
+            "snapshot_data",
+            "type",
+            "status",
+            "parameters",
+            "last_synced",
+        ]
+
+
+class NestedIPFabricTransformMapSerializer(NetBoxModelSerializer):
+    target_model = ContentTypeField(read_only=True)
+
+    class Meta:
+        model = IPFabricTransformMap
+        fields = [
+            "id",
+            "source_model",
+            "target_model",
+            "status",
+        ]
+
+
+class NestedIPFabricBranchSerializer(NetBoxModelSerializer):
+    user = NestedUserSerializer(read_only=True)
+    sync = NestedIPFabricSyncSerializer(read_only=True)
+
+    class Meta:
+        model = IPFabricBranch
+        fields = [
+            "id",
+            "name",
+            "display",
+            "sync",
+            "description",
+            "user",
+        ]

ipfabric_netbox/api/serializers.py

@@ -0,0 +1,160 @@
+from core.choices import DataSourceStatusChoices
+from netbox.api.fields import ChoiceField
+from netbox.api.fields import ContentTypeField
+from netbox.api.serializers import NetBoxModelSerializer
+from rest_framework import serializers
+from users.api.serializers_.nested import NestedUserSerializer
+
+from .nested_serializers import NestedIPFabricBranchSerializer  # noqa: F401
+from .nested_serializers import NestedIPFabricSnapshotSerializer
+from .nested_serializers import NestedIPFabricSourceSerializer
+from .nested_serializers import NestedIPFabricTransformMapSerializer
+from ipfabric_netbox.models import IPFabricBranch
+from ipfabric_netbox.models import IPFabricRelationshipField
+from ipfabric_netbox.models import IPFabricSnapshot
+from ipfabric_netbox.models import IPFabricSource
+from ipfabric_netbox.models import IPFabricSync
+from ipfabric_netbox.models import IPFabricTransformField
+from ipfabric_netbox.models import IPFabricTransformMap
+
+__all__ = (
+    "IPFabricSyncSerializer",
+    "IPFabricSnapshotSerializer",
+    "IPFabricRelationshipFieldSerializer",
+    "IPFabricTransformFieldSerializer",
+    "IPFabricTransformMapSerializer",
+    "IPFabricBranchSerializer",
+    "IPFabricSourceSerializer",
+)
+
+
+class IPFabricSyncSerializer(NetBoxModelSerializer):
+    snapshot_data = NestedIPFabricSnapshotSerializer(read_only=True)
+
+    class Meta:
+        model = IPFabricSync
+        fields = [
+            "id",
+            "name",
+            "display",
+            "snapshot_data",
+            "type",
+            "status",
+            "parameters",
+            "last_synced",
+            "created",
+            "last_updated",
+        ]
+
+
+class IPFabricSnapshotSerializer(NetBoxModelSerializer):
+    source = NestedIPFabricSourceSerializer()
+    data = serializers.JSONField()
+    date = serializers.DateTimeField()
+    last_updated = serializers.DateTimeField()
+
+    class Meta:
+        model = IPFabricSnapshot
+        fields = [
+            "id",
+            "name",
+            "source",
+            "snapshot_id",
+            "status",
+            "date",
+            "display",
+            "sites",
+            "data",
+            "created",
+            "last_updated",
+        ]
+
+        extra_kwargs = {
+            "raw_data": {"write_only": True},
+        }
+
+
+class IPFabricRelationshipFieldSerializer(NetBoxModelSerializer):
+    transform_map = NestedIPFabricTransformMapSerializer(read_only=True)
+    source_model = ContentTypeField(read_only=True)
+
+    class Meta:
+        model = IPFabricRelationshipField
+        fields = [
+            "id",
+            "transform_map",
+            "source_model",
+            "target_field",
+            "coalesce",
+            "template",
+        ]
+
+
+class IPFabricTransformMapSerializer(NetBoxModelSerializer):
+    target_model = ContentTypeField(read_only=True)
+
+    class Meta:
+        model = IPFabricTransformMap
+        fields = [
+            "id",
+            "source_model",
+            "target_model",
+            "status",
+            "created",
+            "last_updated",
+        ]
+
+
+class IPFabricTransformFieldSerializer(NetBoxModelSerializer):
+    transform_map = NestedIPFabricTransformMapSerializer(read_only=True)
+
+    class Meta:
+        model = IPFabricTransformField
+        fields = [
+            "id",
+            "transform_map",
+            "source_field",
+            "target_field",
+            "coalesce",
+            "template",
+        ]
+
+
+class IPFabricBranchSerializer(NetBoxModelSerializer):
+    user = NestedUserSerializer(read_only=True)
+    sync = IPFabricSyncSerializer(read_only=True)
+
+    class Meta:
+        model = IPFabricBranch
+        fields = [
+            "id",
+            "name",
+            "display",
+            "sync",
+            "description",
+            "user",
+            "created",
+            "last_updated",
+        ]
+
+
+class IPFabricSourceSerializer(NetBoxModelSerializer):
+    status = ChoiceField(choices=DataSourceStatusChoices)
+    url = serializers.URLField()
+
+    class Meta:
+        model = IPFabricSource
+        fields = [
+            "id",
+            "url",
+            "display",
+            "name",
+            "type",
+            "status",
+            "last_synced",
+            "description",
+            "comments",
+            "parameters",
+            "created",
+            "last_updated",
+        ]

ipfabric_netbox/api/urls.py

@@ -0,0 +1,21 @@
+# api/urls.py
+from netbox.api.routers import NetBoxRouter
+
+from ipfabric_netbox.api.views import IPFabricBranchViewSet
+from ipfabric_netbox.api.views import IPFabricRelationshipFieldiewSet
+from ipfabric_netbox.api.views import IPFabricSnapshotViewSet
+from ipfabric_netbox.api.views import IPFabricSourceViewSet
+from ipfabric_netbox.api.views import IPFabricSyncViewSet
+from ipfabric_netbox.api.views import IPFabricTransformFieldiewSet
+from ipfabric_netbox.api.views import IPFabricTransformMapViewSet
+
+
+router = NetBoxRouter()
+router.register("source", IPFabricSourceViewSet)
+router.register("snapshot", IPFabricSnapshotViewSet)
+router.register("transform-map", IPFabricTransformMapViewSet)
+router.register("sync", IPFabricSyncViewSet)
+router.register("branch", IPFabricBranchViewSet)
+router.register("transform-field", IPFabricTransformFieldiewSet)
+router.register("relationship-field", IPFabricRelationshipFieldiewSet)
+urlpatterns = router.urls

ipfabric_netbox/api/views.py

@@ -0,0 +1,111 @@
+from django.db import transaction
+from netbox.api.viewsets import NetBoxModelViewSet
+from netbox.api.viewsets import NetBoxReadOnlyModelViewSet
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from utilities.query import count_related
+
+from .serializers import IPFabricBranchSerializer
+from .serializers import IPFabricRelationshipFieldSerializer
+from .serializers import IPFabricSnapshotSerializer
+from .serializers import IPFabricSourceSerializer
+from .serializers import IPFabricSyncSerializer
+from .serializers import IPFabricTransformFieldSerializer
+from .serializers import IPFabricTransformMapSerializer
+from ipfabric_netbox.filtersets import IPFabricSnapshotFilterSet
+from ipfabric_netbox.filtersets import IPFabricSourceFilterSet
+from ipfabric_netbox.filtersets import IPFabricTransformFieldFilterSet
+from ipfabric_netbox.models import IPFabricBranch
+from ipfabric_netbox.models import IPFabricData
+from ipfabric_netbox.models import IPFabricRelationshipField
+from ipfabric_netbox.models import IPFabricSnapshot
+from ipfabric_netbox.models import IPFabricSource
+from ipfabric_netbox.models import IPFabricSync
+from ipfabric_netbox.models import IPFabricTransformField
+from ipfabric_netbox.models import IPFabricTransformMap
+
+
+class IPFabricTransformMapViewSet(NetBoxReadOnlyModelViewSet):
+    queryset = IPFabricTransformMap.objects.all()
+    serializer_class = IPFabricTransformMapSerializer
+
+
+class IPFabricTransformFieldiewSet(NetBoxReadOnlyModelViewSet):
+    queryset = IPFabricTransformField.objects.all()
+    serializer_class = IPFabricTransformFieldSerializer
+    filterset_class = IPFabricTransformFieldFilterSet
+
+
+class IPFabricRelationshipFieldiewSet(NetBoxReadOnlyModelViewSet):
+    queryset = IPFabricRelationshipField.objects.all()
+    serializer_class = IPFabricRelationshipFieldSerializer
+    filterset_class = IPFabricTransformFieldFilterSet
+
+
+class IPFabricSyncViewSet(NetBoxReadOnlyModelViewSet):
+    queryset = IPFabricSync.objects.all()
+    serializer_class = IPFabricSyncSerializer
+
+
+class IPFabricBranchViewSet(NetBoxReadOnlyModelViewSet):
+    queryset = IPFabricBranch.objects.all()
+    serializer_class = IPFabricBranchSerializer
+
+
+class IPFabricSnapshotViewSet(NetBoxModelViewSet):
+    queryset = IPFabricSnapshot.objects.all()
+    serializer_class = IPFabricSnapshotSerializer
+    filterset_class = IPFabricSnapshotFilterSet
+
+    @action(detail=True, methods=["patch", "delete"], url_path="raw")
+    def raw(self, request, pk):
+        snapshot = self.get_object()
+        if request.method == "DELETE":
+            raw_data = IPFabricData.objects.filter(snapshot_data=snapshot)
+            raw_data._raw_delete(raw_data.db)
+            return Response({"status": "success"})
+        elif request.method == "PATCH":
+            transaction.set_autocommit(False)
+            IPFabricData.objects.bulk_create(
+                [
+                    IPFabricData(
+                        snapshot_data=snapshot, data=item["data"], type=item["type"]
+                    )
+                    for item in request.data["data"]
+                ],
+                batch_size=5000,
+            )
+            transaction.commit()
+            return Response({"status": "success"})
+
+    @action(detail=True, methods=["get"], url_path="sites")
+    def sites(self, request, pk):
+        q = request.GET.get("q", None)
+        snapshot = IPFabricSnapshot.objects.get(pk=pk)
+        new_sites = {"results": []}
+        if snapshot.data:
+            sites = snapshot.data.get("sites", None)
+            num = 0
+            if sites:
+                for site in sites:
+                    if q:
+                        if q.lower() in site.lower():
+                            new_sites["results"].append(
+                                {"display": site, "name": site, "id": site}
+                            )
+                    else:
+                        new_sites["results"].append(
+                            {"display": site, "name": site, "id": site}
+                        )
+                    num += 1
+                return Response(new_sites)
+        else:
+            return Response([])
+
+
+class IPFabricSourceViewSet(NetBoxModelViewSet):
+    queryset = IPFabricSource.objects.annotate(
+        snapshot_count=count_related(IPFabricSnapshot, "source")
+    )
+    serializer_class = IPFabricSourceSerializer
+    filterset_class = IPFabricSourceFilterSet

ipfabric_netbox/choices.py

@@ -0,0 +1,226 @@
+from django.utils.translation import gettext_lazy as _
+from utilities.choices import ChoiceSet
+
+transform_field_source_columns = {
+    "site": [
+        "id",
+        "siteName",
+        "devicesCount",
+        "usersCount",
+        "stpDCount",
+        "switchesCount",
+        "vlanCount",
+        "rDCount",
+        "routersCount",
+        "networksCount",
+    ],
+    "device": [
+        "id",
+        "sn",
+        "hostname",
+        "siteName",
+        "rd",
+        "stpDomain",
+        "snHw",
+        "loginIp",
+        "objectId",
+        "loginType",
+        "uptime",
+        "reload",
+        "memoryUtilization",
+        "memoryTotalBytes",
+        "memoryUsedBytes",
+        "vendor",
+        "family",
+        "platform",
+        "model",
+        "configReg",
+        "version",
+        "image",
+        "processor",
+        "mac",
+        "devType",
+        "hostnameOriginal",
+        "hostnameProcessed",
+        "domain",
+        "fqdn",
+    ],
+    "inventory": [
+        "id",
+        "deviceSn",
+        "hostname",
+        "siteName",
+        "deviceId",
+        "name",
+        "dscr",
+        "pid",
+        "sn",
+        "vid",
+        "vendor",
+        "platform",
+        "model",
+    ],
+    "interface": [
+        "id",
+        "dscr",
+        "duplex",
+        "errDisabled",
+        "hasTransceiver",
+        "hostname",
+        "intName",
+        "intNameAlias",
+        "l1",
+        "l2",
+        "loginIp",
+        "loginType",
+        "mac",
+        "media",
+        "mtu",
+        "nameOriginal",
+        "primaryIp",
+        "reason",
+        "rel",
+        "siteName",
+        "sn",
+        "speed",
+        "speedValue",
+        "transceiverPn",
+        "transceiverSn",
+        "transceiverType",
+    ],
+    "part_number": [
+        "id",
+        "deviceSn",
+        "hostname",
+        "siteName",
+        "deviceId",
+        "name",
+        "dscr",
+        "pid",
+        "sn",
+        "vid",
+        "vendor",
+        "platform",
+        "model",
+    ],
+    "vlan": ["id", "siteName", "vlanId", "vlanName", "dscr", "devCount"],
+    "vrf": ["id", "sn", "hostname", "siteName", "vrf", "rd", "intCount"],
+    "prefix": ["id", "siteName", "net", "hosts", "gw", "gwV", "vrf", "vlanId"],
+    "virtualchassis": [
+        "id",
+        "sn",
+        "master",
+        "siteName",
+        "uptime",
+        "member",
+        "connectionsCount",
+        "pn",
+        "memberSn",
+        "role",
+        "state",
+        "mac",
+        "ver",
+        "image",
+        "hwVer",
+    ],
+    "ipaddress": [
+        "hostname",
+        "sn",
+        "intName",
+        "stateL1",
+        "stateL2",
+        "siteName",
+        "dnsName",
+        "dnsHostnameMatch",
+        "vlanId",
+        "dnsReverseMatch",
+        "mac",
+        "ip",
+        "net",
+        "type",
+        "vrf",
+    ],
+}
+
+
+class IPFabricTransformMapSourceModelChoices(ChoiceSet):
+    SITE = "site"
+    INVENTORY = "inventory"
+    DEVICE = "device"
+    VIRTUALCHASSIS = "virtualchassis"
+    INTERFACE = "interface"
+    VLAN = "vlan"
+    VRF = "vrf"
+    PREFIX = "prefix"
+    IPADDRESS = "ipaddress"
+    # PARTNUMBERS = "part_number"
+
+    CHOICES = (
+        (SITE, "Site", "cyan"),
+        (INVENTORY, "Inventory", "gray"),
+        (DEVICE, "Device", "gray"),
+        (VIRTUALCHASSIS, "Virtual Chassis", "grey"),
+        (INTERFACE, "Interface", "gray"),
+        (VLAN, "VLAN", "gray"),
+        (VRF, "VRF", "gray"),
+        (PREFIX, "Prefix", "gray"),
+        (IPADDRESS, "IP Address", "gray"),
+        # (PARTNUMBERS, "Part Number", "gray"),
+    )
+
+
+class IPFabricSnapshotStatusModelChoices(ChoiceSet):
+    key = "IPFabricSnapshot.status"
+
+    STATUS_LOADED = "loaded"
+    STATUS_UNLOADED = "unloaded"
+
+    CHOICES = [
+        (STATUS_LOADED, _("Loaded"), "green"),
+        (STATUS_UNLOADED, _("Unloaded"), "red"),
+    ]
+
+
+class IPFabricSyncTypeChoices(ChoiceSet):
+    ALL = "all"
+    DCIM = "dcim"
+    IPAM = "ipam"
+
+    CHOICES = (
+        (ALL, _("All"), "gray"),
+        (DCIM, _("DCIM"), "blue"),
+        (IPAM, _("IPAM"), "blue"),
+    )
+
+
+class IPFabricSourceTypeChoices(ChoiceSet):
+    LOCAL = "local"
+    REMOTE = "remote"
+
+    CHOICES = (
+        (LOCAL, "Local", "cyan"),
+        (REMOTE, "Remote", "gray"),
+    )
+
+
+class IPFabricRawDataTypeChoices(ChoiceSet):
+    DEVICE = "device"
+    VLAN = "vlan"
+    VRF = "vrf"
+    VIRTUALCHASSIS = "virtualchassis"
+    PREFIX = "prefix"
+    INTERFACE = "interface"
+    IPADDRESS = "ipaddress"
+    INVENTORYITEM = "inventoryitem"
+    SITE = "site"
+
+    CHOICES = (
+        (DEVICE, "Local", "cyan"),
+        (VLAN, "VLAN", "gray"),
+        (VIRTUALCHASSIS, "Virtual Chassis", "gray"),
+        (PREFIX, "Prefix", "gray"),
+        (INTERFACE, "Interface", "gray"),
+        (INVENTORYITEM, "Inventory Item", "gray"),
+        (IPADDRESS, "IP Address", "gray"),
+        (SITE, "Site", "gray"),
+    )