slurpit-netbox 0.8.36__tar.gz

slurpit_netbox-0.8.36/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.1
+Name: slurpit_netbox
+Version: 0.8.36
+Summary: 
+Author: Pieter
+Author-email: pieter@slurpit.io
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: djangorestframework-bulk (>=0.2.1,<0.3.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+## Compatibility
+
+| NetBox Version | Plugin Version |
+|----------------|----------------|
+|   NetBox 3.7   |    >= 0.8.0    |
+
+## How to install the plugin on your local NetBox server
+
+### Activate the Virtual Environment
+ 
+Firstly, to make the plugin available within NetBox, we must activate the Python virtual environment that was set up during the NetBox installation; you can do this by finding the path of the virtual environment, which typically is /opt/netbox/venv/ if you followed the default installation guide.
+
+ ```
+$ source /opt/netbox/venv/bin/activate
+ ```
+
+ ### Run setup.py
+
+ ```
+$ python setup.py develop
+ ```
+
+ ### Configure NetBox
+ 
+To enable our new plugin, we have to configure NetBox by opening the configuration.py file located in the netbox/netbox directory and modifying the PLUGINS parameter.
+
+ ```
+# configuration.py
+PLUGINS = [
+    'slurpit_netbox',
+]
+ ``` 
+
+ 
+
+ ### Apply Migrations
+
+Use the 'migrate' management command to apply the migration file.
+
+```
+python manage.py migrate slurpit_netbox
+```
+
+After saving the file, start the NetBox development server if it isn't already running.
+
+ ```
+$ python manage.py runserver 0.0.0.0:8000 --insecure
+ ```
+

slurpit_netbox-0.8.36/README.md

@@ -0,0 +1,48 @@
+## Compatibility
+
+| NetBox Version | Plugin Version |
+|----------------|----------------|
+|   NetBox 3.7   |    >= 0.8.0    |
+
+## How to install the plugin on your local NetBox server
+
+### Activate the Virtual Environment
+ 
+Firstly, to make the plugin available within NetBox, we must activate the Python virtual environment that was set up during the NetBox installation; you can do this by finding the path of the virtual environment, which typically is /opt/netbox/venv/ if you followed the default installation guide.
+
+ ```
+$ source /opt/netbox/venv/bin/activate
+ ```
+
+ ### Run setup.py
+
+ ```
+$ python setup.py develop
+ ```
+
+ ### Configure NetBox
+ 
+To enable our new plugin, we have to configure NetBox by opening the configuration.py file located in the netbox/netbox directory and modifying the PLUGINS parameter.
+
+ ```
+# configuration.py
+PLUGINS = [
+    'slurpit_netbox',
+]
+ ``` 
+
+ 
+
+ ### Apply Migrations
+
+Use the 'migrate' management command to apply the migration file.
+
+```
+python manage.py migrate slurpit_netbox
+```
+
+After saving the file, start the NetBox development server if it isn't already running.
+
+ ```
+$ python manage.py runserver 0.0.0.0:8000 --insecure
+ ```

slurpit_netbox-0.8.36/pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "slurpit_netbox"
+version = "0.8.36"
+description = ""
+authors = ["Pieter <pieter@slurpit.io>"]
+readme = "README.md"
+packages = [{include = "slurpit_netbox", from = "src"}]
+
+
+[tool.poetry.dependencies]
+python = "^3.10"
+requests = "^2.31.0"
+djangorestframework-bulk = "^0.2.1"
+
+
+[tool.poetry.group.develop.dependencies]
+django = "^4.2.6"
+djangorestframework = "^3.14.0"
+django-tables2 = "^2.6.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

slurpit_netbox-0.8.36/src/slurpit_netbox/__init__.py

@@ -0,0 +1,39 @@
+import os
+
+from django.apps import apps
+from django.db.models.signals import post_migrate
+from extras.plugins import PluginConfig, get_plugin_config
+
+class SlurpitConfig(PluginConfig):
+    name = "slurpit_netbox"
+    verbose_name = "Slurp'it Plugin"
+    description = "Sync Slurp'it into NetBox"
+    version = '0.8.36'
+    base_url = "slurpit"   
+    default_settings = {
+        'DeviceType': {'model': "Slurp'it", 'slug': 'slurpit'},
+        'DeviceRole': {'name': "Slurp'it", 'slug': 'slurpit'},
+        'Site': {'name': "Slurp'it", 'slug': 'slurpit'},
+        'Location': {'name': 'Slurp\'it', 'slug': 'slurpit'},
+        'Region': {'name': 'Slurp\'it', 'slug': 'slurpit'},
+        'SiteGroup': {'name': 'Slurp\'it', 'slug': 'slurpit'}, 
+        'Rack': {'name': 'Slurp\'it'},
+        'ConfigTemplate': {'name': 'Slurp\'it'},
+        'Manufacturer': {'name': 'OEM', 'slug': 'oem'},
+        'unattended_import': False,
+        'version': version
+    }
+
+    def ready(self):
+        from .models import post_migration
+        deps_app = apps.get_app_config("virtualization")
+        post_migrate.connect(post_migration, sender=deps_app, weak=False)
+        super().ready()
+
+
+config = SlurpitConfig
+
+
+def get_config(cfg):
+    return get_plugin_config(get_config.__module__, cfg)
+

slurpit_netbox-0.8.36/src/slurpit_netbox/api/__init__.py

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

slurpit_netbox-0.8.36/src/slurpit_netbox/api/serializers.py

@@ -0,0 +1,55 @@
+from core.choices import DataSourceStatusChoices
+from netbox.api.fields import ChoiceField
+from netbox.api.serializers import NetBoxModelSerializer
+from rest_framework import serializers
+
+from slurpit_netbox.models import SlurpitPlanning, SlurpitImportedDevice, SlurpitStagedDevice, SlurpitLog, SlurpitSetting, SlurpitSnapshot, SlurpitMapping
+
+__all__ = (
+    'SlurpitPlanningSerializer',
+    'SlurpitStagedDeviceSerializer',
+    'SlurpitImportedDeviceSerializer',
+    'SlurpitLogSerializer',
+    'SlurpitSettingSerializer',
+    'SlurpitSnapshotSerializer'
+)
+
+class SlurpitPlanningSerializer(NetBoxModelSerializer):
+    id = serializers.IntegerField(source='planning_id')
+    comment = serializers.CharField(source='comments')
+
+    class Meta:
+        model = SlurpitPlanning
+        fields = ['id', "name", "comment", "display"]
+
+class SlurpitStagedDeviceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SlurpitStagedDevice
+        fields = '__all__'
+
+class SlurpitSnapshotSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SlurpitSnapshot
+        fields = '__all__'
+
+
+class SlurpitImportedDeviceSerializer(serializers.ModelSerializer):
+    id = serializers.IntegerField(source='slurpit_id')
+    class Meta:
+        model = SlurpitImportedDevice
+        fields = ['id', 'disabled', 'hostname', 'fqdn', 'ipv4', 'device_os', 'device_type', 'brand', 'createddate', 'changeddate']
+
+class SlurpitLogSerializer(NetBoxModelSerializer):
+    class Meta:
+        model = SlurpitLog
+        fields = '__all__'
+
+class SlurpitSettingSerializer(NetBoxModelSerializer):
+    class Meta:
+        model = SlurpitSetting
+        fields = '__all__'
+
+class SlurpitMappingSerializer(NetBoxModelSerializer):
+    class Meta:
+        model = SlurpitMapping
+        fields = '__all__'

slurpit_netbox-0.8.36/src/slurpit_netbox/api/urls.py

@@ -0,0 +1,11 @@
+from netbox.api.routers import NetBoxRouter
+from . import views
+
+router = NetBoxRouter()
+router.APIRootView = views.SlurpitRootView
+router.register("planning", views.SlurpitPlanningViewSet)
+router.register("planning-data", views.SlurpitSnapshotViewSet)
+router.register("device", views.DeviceViewSet)
+router.register('test', views.SlurpitTestAPIView)
+app_name = 'slurpit-api'
+urlpatterns = router.urls

slurpit_netbox-0.8.36/src/slurpit_netbox/api/views.py

@@ -0,0 +1,172 @@
+
+from netbox.api.viewsets import NetBoxModelViewSet
+from dcim.models import Device
+from dcim.choices import DeviceStatusChoices
+from slurpit_netbox.models import SlurpitPlanning, SlurpitSnapshot, SlurpitImportedDevice, SlurpitStagedDevice, SlurpitLog
+from slurpit_netbox.filtersets import SlurpitPlanningFilterSet, SlurpitSnapshotFilterSet, SlurpitImportedDeviceFilterSet
+from .serializers import SlurpitPlanningSerializer, SlurpitSnapshotSerializer, SlurpitImportedDeviceSerializer
+from rest_framework.routers import APIRootView
+from rest_framework_bulk import BulkCreateModelMixin, BulkDestroyModelMixin
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.views import APIView
+from rest_framework import status
+from django.db import transaction
+from django.http import JsonResponse
+import json
+from ..validator import device_validator
+from ..importer import process_import, import_devices, import_plannings
+from ..management.choices import *
+
+__all__ = (
+    'SlurpitPlanningViewSet',
+    'SlurpitRootView',
+)
+
+class SlurpitRootView(APIRootView):
+    """
+    Slurpit API root view
+    """
+    def get_view_name(self):
+        return 'Slurpit'
+    
+
+class SlurpitPlanningViewSet(
+        NetBoxModelViewSet
+    ):
+    queryset = SlurpitPlanning.objects.all()
+    serializer_class = SlurpitPlanningSerializer
+    filterset_class = SlurpitPlanningFilterSet
+
+    @action(detail=False, methods=['delete'], url_path='delete-all')
+    def delete_all(self, request, *args, **kwargs):
+        """
+        A custom action to delete all SlurpitPlanning objects.
+        Be careful with this operation: it cannot be undone!
+        """
+        self.queryset.delete()
+        SlurpitSnapshot.objects.all().delete()
+        SlurpitLog.info(category=LogCategoryChoices.PLANNING, message=f"Api deleted all snapshots and plannings")
+        return Response(status=status.HTTP_204_NO_CONTENT)
+    
+    def get_queryset(self):
+        if self.request.method == 'GET':
+            # Customize this queryset to suit your requirements for GET requests
+            return SlurpitPlanning.objects.filter(selected=True)
+        # For other methods, use the default queryset
+        return self.queryset
+    
+    @action(detail=False, methods=['delete'], url_path='delete/(?P<planning_id>[^/.]+)')
+    def delete(self, request, *args, **kwargs):
+        planning_id = kwargs.get('planning_id')
+        planning = SlurpitPlanning.objects.filter(planning_id=planning_id).first()
+        if not planning:
+            return Response(f"Unknown planning id {planning_id}", status=status.HTTP_400_BAD_REQUEST)
+
+        planning.delete()
+        count = SlurpitSnapshot.objects.filter(planning_id=planning_id).delete()[0]
+        SlurpitLog.info(category=LogCategoryChoices.PLANNING, message=f"Api deleted all {count} snapshots and planning {planning.name}")
+        return Response(status=status.HTTP_204_NO_CONTENT)
+        
+    @action(detail=False, methods=['post'],  url_path='sync')
+    def sync(self, request):
+        if not isinstance(request.data, list):
+            return Response("Should be a list", status=status.HTTP_400_BAD_REQUEST)
+        import_plannings(request.data)
+        return JsonResponse({'status': 'success'})
+    
+    def create(self, request):
+        if not isinstance(request.data, list):
+            return Response("Should be a list", status=status.HTTP_400_BAD_REQUEST)
+
+        import_plannings(request.data, False)        
+        return JsonResponse({'status': 'success'})
+
+class SlurpitSnapshotViewSet(
+        BulkCreateModelMixin,
+        BulkDestroyModelMixin,
+        NetBoxModelViewSet
+    ):
+    queryset = SlurpitSnapshot.objects.all()
+    serializer_class = SlurpitSnapshotSerializer
+    filterset_class = SlurpitSnapshotFilterSet
+
+    @action(detail=False, methods=['delete'], url_path='delete-all/(?P<hostname>[^/.]+)/(?P<planning_id>[^/.]+)')
+    def delete_all(self, request, *args, **kwargs):
+        planning_id = kwargs.get('planning_id')
+        planning = SlurpitPlanning.objects.filter(planning_id=planning_id).first()
+        if not planning:
+            return Response(f"Unknown planning id {planning_id}", status=status.HTTP_400_BAD_REQUEST)
+            
+        hostname = kwargs.get('hostname')
+        if not hostname:
+            return Response(f"No hostname was given", status=status.HTTP_400_BAD_REQUEST)
+
+        count = SlurpitSnapshot.objects.filter(hostname=hostname, planning_id=planning_id).delete()[0]
+
+        SlurpitLog.info(category=LogCategoryChoices.PLANNING, message=f"Api deleted all {count} snapshots for planning {planning.name} and hostname {hostname}")
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+    
+    @action(detail=False, methods=['delete'], url_path='clear/(?P<planning_id>[^/.]+)')
+    def clear(self, request, *args, **kwargs):
+        planning_id = kwargs.get('planning_id')
+        planning = SlurpitPlanning.objects.filter(planning_id=planning_id).first()
+        if not planning:
+            return Response(f"Unknown planning id {planning_id}", status=status.HTTP_400_BAD_REQUEST)
+        count = SlurpitSnapshot.objects.filter(planning_id=planning_id).delete()[0]
+        SlurpitLog.info(category=LogCategoryChoices.PLANNING, message=f"Api deleted all {count} snapshots for planning {planning.name}")
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+class DeviceViewSet(
+        BulkCreateModelMixin,
+        BulkDestroyModelMixin,
+        NetBoxModelViewSet
+    ):
+    queryset = SlurpitImportedDevice.objects.all()
+    serializer_class = SlurpitImportedDeviceSerializer
+    filterset_class = SlurpitImportedDeviceFilterSet
+
+    @action(detail=False, methods=['delete'], url_path='delete-all')
+    def delete_all(self, request, *args, **kwargs):
+        with transaction.atomic():
+            Device.objects.select_related('slurpitimporteddevice').update(status=DeviceStatusChoices.STATUS_OFFLINE)
+            SlurpitStagedDevice.objects.all().delete()
+            SlurpitImportedDevice.objects.filter(mapped_device__isnull=True).delete()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+    
+    @action(detail=False, methods=['delete'], url_path='delete/(?P<hostname>[^/.]+)')
+    def delete(self, request, *args, **kwargs):
+        hostname_to_delete = kwargs.get('hostname')
+        with transaction.atomic():
+            to_delete = SlurpitImportedDevice.objects.filter(hostname=hostname_to_delete)
+            Device.objects.filter(slurpitimporteddevice__in=to_delete).update(status=DeviceStatusChoices.STATUS_OFFLINE)
+            to_delete.filter(mapped_device__isnull=True).delete()
+            SlurpitStagedDevice.objects.filter(hostname=hostname_to_delete).delete()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+    
+    def create(self, request):
+        errors = device_validator(request.data)
+
+        if errors:
+            return JsonResponse({'status': 'error', 'errors': errors}, status=400)
+
+        import_devices(request.data)
+        process_import(delete=False)
+        
+        return JsonResponse({'status': 'success'})
+    
+class SlurpitTestAPIView(NetBoxModelViewSet):
+    queryset = SlurpitImportedDevice.objects.all()
+    serializer_class = SlurpitImportedDeviceSerializer
+    filterset_class = SlurpitImportedDeviceFilterSet
+
+    permission_classes = [IsAuthenticated]
+
+    @action(detail=False, methods=['get'], url_path='api')
+    def api(self, request, *args, **kwargs):    
+        return JsonResponse({'status': 'success'})

slurpit_netbox-0.8.36/src/slurpit_netbox/decorators.py

@@ -0,0 +1,57 @@
+from functools import wraps
+from .models import SlurpitSetting
+from django.core.exceptions import ObjectDoesNotExist
+from django.contrib import messages
+from account.models import UserToken
+
+def slurpit_plugin_registered(view_func):
+    @wraps(view_func)
+    def _wrapped_view(request, *args, **kwargs):
+        
+        paths = [
+            'plugins/slurpit/settings/',
+            'plugins/slurpit/devices/',
+            'plugins/slurpit/data_mapping/',
+            'plugins/slurpit/reconcile/',
+            'plugins/slurpit/slurpitlog/'
+        ]
+
+        for path in paths:
+            if path in request.path and request.method == 'GET':
+                # Ignore test case
+                test_param = request.GET.get('test',None)
+                if test_param == 'test':
+                    continue
+                
+                appliance_type_param = request.GET.get('appliance_type', None)
+                if appliance_type_param:
+                    continue
+
+                reset_param = request.GET.get('reset', None)
+                if reset_param:
+                    continue
+                
+                tokens = UserToken.objects.filter(user=request.user).count()
+
+                if tokens == 0:
+                    messages.warning(request, "To use the Slurp'it plugin, it is necessary to first generate a Plugin API Key on the Setting Page.")
+                    return view_func(request, *args, **kwargs)
+
+                try:
+                    setting = SlurpitSetting.objects.get()
+                    server_url = setting.server_url
+                    api_key = setting.api_key
+                    appliance_type = setting.appliance_type
+
+                    if appliance_type == '':
+                        messages.warning(request, "To use the Slurp'it plugin, it is necessary to first select the Appliance Type on the Setting Page.")
+                    elif appliance_type != 'cloud' and (api_key == '' or server_url == ''):
+                        messages.warning(request, "To use the Slurp'it plugin, you should first configure the server settings. Go to settings and configure the Slurp'it server in the parameter section.")
+                except Exception as e:
+                    setting = None
+                    messages.warning(request, "To use the Slurp'it plugin, it is necessary to first select the Appliance Type on the Setting Page.")
+
+                return view_func(request, *args, **kwargs)
+
+        return view_func(request, *args, **kwargs)
+    return _wrapped_view

slurpit_netbox-0.8.36/src/slurpit_netbox/filtersets.py

@@ -0,0 +1,79 @@
+import django_filters
+from core.choices import DataSourceStatusChoices
+from django.db.models import Q
+from netbox.filtersets import NetBoxModelFilterSet, BaseFilterSet
+from .models import SlurpitLog, SlurpitPlanning, SlurpitSnapshot, SlurpitImportedDevice
+from django.utils.translation import gettext as _
+
+
+class LoggingFilterSet(BaseFilterSet):
+    q = django_filters.CharFilter(
+        method='search',
+        label=_('Search'),
+    )
+
+    class Meta:
+        model = SlurpitLog
+        fields = [
+            'log_time', 'level', 'category', 'message'
+        ]
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(level__icontains=value) | 
+            Q(category__icontains=value) |
+            Q(message__icontains=value)
+        )
+
+class SlurpitPlanningFilterSet(BaseFilterSet):
+    q = django_filters.CharFilter(
+        method='search',
+        label=_('Search'),
+    )
+
+    class Meta:
+        model = SlurpitPlanning
+        fields = ["id", "name", "planning_id"]
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(name__icontains=value)
+        )
+    
+class SlurpitSnapshotFilterSet(BaseFilterSet):
+    q = django_filters.CharFilter(
+        method='search',
+        label=_('Search'),
+    )
+
+    class Meta:
+        model = SlurpitSnapshot
+        fields = ["id", "hostname", "planning_id"]
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(name__icontains=value)
+        )
+
+class SlurpitImportedDeviceFilterSet(BaseFilterSet):
+    q = django_filters.CharFilter(
+        method='search',
+        label=_('Search'),
+    )
+
+    class Meta:
+        model = SlurpitImportedDevice
+        fields = ["id", "hostname"]
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(name__icontains=value)
+        )