netbox-toolkit-plugin 0.1.0__py3-none-any.whl

netbox_toolkit/utils/network.py

@@ -0,0 +1,157 @@
+"""Network utility functions."""
+import socket
+import time
+from typing import Tuple, Optional
+
+from ..exceptions import DeviceReachabilityError, SSHBannerError
+from .logging import get_toolkit_logger
+
+logger = get_toolkit_logger(__name__)
+
+
+def check_device_reachability(hostname: str, port: int = 22, timeout: int = 3) -> Tuple[bool, bool, Optional[bytes]]:
+    """
+    Check if a device is reachable and if it's running SSH.
+    
+    Args:
+        hostname: The hostname or IP address to check
+        port: The port to check (default: 22 for SSH)
+        timeout: Connection timeout in seconds
+        
+    Returns:
+        Tuple of (is_reachable, is_ssh_server, ssh_banner)
+        
+    Raises:
+        DeviceReachabilityError: If device is not reachable
+        SSHBannerError: If SSH banner cannot be read
+    """
+    logger.debug(f"Checking device reachability for {hostname}:{port} with timeout {timeout}s")
+    
+    is_reachable = False
+    is_ssh_server = False
+    ssh_banner = None
+    
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    
+    try:
+        sock.settimeout(timeout)
+        
+        # Attempt connection
+        logger.debug(f"Attempting TCP connection to {hostname}:{port}")
+        sock.connect((hostname, port))
+        is_reachable = True
+        logger.debug(f"TCP connection successful to {hostname}:{port}")
+        
+        # Try to read SSH banner
+        ssh_banner, is_ssh_server = _read_ssh_banner(sock, hostname)
+        logger.debug(f"SSH banner check: is_ssh_server={is_ssh_server}, banner_length={len(ssh_banner) if ssh_banner else 0}")
+        
+    except socket.timeout:
+        logger.warning(f"Connection to {hostname}:{port} timed out after {timeout}s")
+        raise DeviceReachabilityError(f"Connection to {hostname}:{port} timed out")
+    except ConnectionRefusedError:
+        logger.warning(f"Connection to {hostname}:{port} refused")
+        raise DeviceReachabilityError(f"Connection to {hostname}:{port} refused")
+    except socket.gaierror as e:
+        logger.error(f"Could not resolve hostname: {hostname} - {str(e)}")
+        raise DeviceReachabilityError(f"Could not resolve hostname: {hostname}")
+    except Exception as e:
+        logger.error(f"Socket error when connecting to {hostname}: {str(e)}")
+        raise DeviceReachabilityError(f"Socket error when connecting to {hostname}: {str(e)}")
+    finally:
+        try:
+            sock.close()
+        except:
+            pass
+    
+    return is_reachable, is_ssh_server, ssh_banner
+
+
+def _read_ssh_banner(sock: socket.socket, hostname: str, attempts: int = 3) -> Tuple[Optional[bytes], bool]:
+    """
+    Try to read SSH banner from socket.
+    
+    Args:
+        sock: Connected socket
+        hostname: Hostname for logging
+        attempts: Number of attempts to read banner
+        
+    Returns:
+        Tuple of (banner, is_ssh_server)
+    """
+    logger.debug(f"Attempting to read SSH banner from {hostname} with {attempts} attempts")
+    
+    ssh_banner = None
+    is_ssh_server = False
+    
+    for i in range(attempts):
+        try:
+            logger.debug(f"SSH banner read attempt {i + 1}/{attempts}")
+            sock.settimeout(1)
+            banner = sock.recv(1024)
+            if banner:
+                ssh_banner = banner
+                logger.debug(f"Received banner: {banner[:50]}..." if len(banner) > 50 else f"Received banner: {banner}")
+                if banner.startswith(b'SSH-'):
+                    is_ssh_server = True
+                    logger.debug("Banner indicates SSH server")
+                    break
+                else:
+                    logger.debug("Banner received but not SSH protocol")
+                    pass  # Non-SSH banner received
+            else:
+                logger.debug("No banner data received")
+            
+            # If no banner received but still connected, pause briefly and try again
+            if i < attempts - 1:
+                logger.debug("Waiting 0.5s before next banner read attempt")
+                time.sleep(0.5)
+        except socket.timeout:
+            logger.debug(f"Banner read attempt {i + 1} timed out")
+            if i < attempts - 1:
+                continue
+        except Exception as e:
+            logger.warning(f"Error reading SSH banner: {str(e)}")
+            break
+    
+    logger.debug(f"SSH banner read completed: is_ssh_server={is_ssh_server}")
+    return ssh_banner, is_ssh_server
+
+
+def validate_device_connectivity(hostname: str, port: int = 22) -> None:
+    """
+    Validate that a device is reachable and has SSH available.
+    
+    Args:
+        hostname: The hostname or IP address to validate
+        port: The port to check (default: 22)
+        
+    Raises:
+        DeviceReachabilityError: If device is not reachable
+        SSHBannerError: If SSH service issues are detected
+    """
+    logger.debug(f"Validating device connectivity for {hostname}:{port}")
+    
+    try:
+        is_reachable, is_ssh_server, ssh_banner = check_device_reachability(hostname, port)
+        
+        if not is_reachable:
+            logger.error(f"Device {hostname}:{port} is not reachable")
+            raise DeviceReachabilityError(
+                f"Cannot connect to {hostname} on port {port}. "
+                f"Please verify the device is reachable and SSH is enabled."
+            )
+        
+        if is_reachable and not is_ssh_server:
+            banner_msg = f" (received banner: {ssh_banner})" if ssh_banner else ""
+            logger.warning(f"Device {hostname}:{port} is reachable but SSH banner not detected{banner_msg}")
+            # Device is reachable but didn't provide SSH banner - connection might fail
+            pass
+        elif is_ssh_server:
+            logger.debug(f"Device {hostname}:{port} is reachable and SSH server detected")
+            
+    except (DeviceReachabilityError, SSHBannerError):
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error validating connectivity to {hostname}: {str(e)}")
+        raise DeviceReachabilityError(f"Unexpected error validating connectivity to {hostname}: {str(e)}")

netbox_toolkit/views.py

@@ -0,0 +1,385 @@
+from django.shortcuts import render
+from django.views.generic import View
+from django.contrib import messages
+from django.core.exceptions import PermissionDenied
+from dcim.models import Device
+from .models import Command, CommandLog
+from .forms import CommandForm, CommandLogForm, CommandExecutionForm
+from netbox.views.generic import ObjectView, ObjectListView, ObjectEditView, ObjectDeleteView, ObjectChangeLogView
+from utilities.views import ViewTab, register_model_view
+from .services.command_service import CommandExecutionService
+from .services.device_service import DeviceService
+from .services.rate_limiting_service import RateLimitingService
+
+@register_model_view(Device, name='toolkit', path='toolkit')
+class DeviceToolkitView(ObjectView):
+    queryset = Device.objects.all()
+    template_name = 'netbox_toolkit/device_toolkit.html'
+    
+    # Define tab without a badge counter
+    tab = ViewTab(
+        label='Toolkit'
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.command_service = CommandExecutionService()
+        self.device_service = DeviceService()
+        self.rate_limiting_service = RateLimitingService()
+
+    def get_object(self, **kwargs):
+        """Override get_object to properly filter by pk"""
+        return Device.objects.get(pk=self.kwargs.get('pk', kwargs.get('pk')))
+
+    def get(self, request, pk):
+        self.kwargs = {'pk': pk}  # Set kwargs for get_object
+        device = self.get_object()
+        
+        # Validate device is ready for commands
+        is_valid, error_message, validation_checks = self.device_service.validate_device_for_commands(device)
+        if not is_valid:
+            messages.warning(request, f"Device validation warning: {error_message}")
+        
+        # Get connection info for the device
+        connection_info = self.device_service.get_device_connection_info(device)
+        
+        # Get available commands for the device with permission filtering
+        commands = self._get_filtered_commands(request.user, device)
+        
+        # Get rate limit status for UI display
+        rate_limit_status = self.rate_limiting_service.get_rate_limit_status(device, request.user)
+        
+        form = CommandExecutionForm()
+
+        # No credential storage - credentials required for each command execution
+
+        return render(request, self.template_name, {
+            'object': device,
+            'tab': self.tab,
+            'commands': commands,
+            'form': form,
+            'device_valid': is_valid,
+            'validation_message': error_message,
+            'validation_checks': validation_checks,
+            'connection_info': connection_info,
+            'rate_limit_status': rate_limit_status,
+        })
+
+    def _user_has_action_permission(self, user, obj, action):
+        """Check if user has permission for a specific action on an object using NetBox's ObjectPermission system"""
+        from django.contrib.contenttypes.models import ContentType
+        from users.models import ObjectPermission
+        
+        # Get content type for the object
+        content_type = ContentType.objects.get_for_model(obj)
+        
+        # Check if user has any ObjectPermissions with the required action
+        user_permissions = ObjectPermission.objects.filter(
+            object_types__in=[content_type],
+            actions__contains=[action],
+            enabled=True
+        )
+        
+        # Check if user is assigned to any groups with this permission
+        user_groups = user.groups.all()
+        for permission in user_permissions:
+            # Check if permission applies to user or user's groups
+            if (permission.users.filter(id=user.id).exists() or 
+                permission.groups.filter(id__in=user_groups.values_list('id', flat=True)).exists()):
+                
+                # If there are constraints, evaluate them
+                if permission.constraints:
+                    # Create a queryset with the constraints and check if the object matches
+                    queryset = content_type.model_class().objects.filter(**permission.constraints)
+                    if queryset.filter(id=obj.id).exists():
+                        return True
+                else:
+                    # No constraints means permission applies to all objects of this type
+                    return True
+        
+        return False
+
+    def _get_filtered_commands(self, user, device):
+        """Get commands for a device filtered by user permissions"""
+        # Get all available commands for the device
+        all_commands = self.device_service.get_available_commands(device)
+        
+        # Filter commands based on user permissions for custom actions
+        commands = []
+        for command in all_commands:
+            # Check if user has permission for the specific action on this command
+            if command.command_type == 'show':
+                # Check for 'execute_show' action permission
+                if self._user_has_action_permission(user, command, 'execute_show'):
+                    commands.append(command)
+            elif command.command_type == 'config':
+                # Check for 'execute_config' action permission  
+                if self._user_has_action_permission(user, command, 'execute_config'):
+                    commands.append(command)
+        
+        return commands
+
+    def post(self, request, pk):
+        self.kwargs = {'pk': pk}  # Set kwargs for get_object
+        device = self.get_object()
+        command_id = request.POST.get('command_id')
+        
+        try:
+            command = Command.objects.get(id=command_id)
+        except Command.DoesNotExist:
+            messages.error(request, "Selected command not found.")
+            return self.get(request, pk)
+        
+        # Check permissions based on command type using NetBox's object-based permissions
+        if command.command_type == 'config':
+            if not self._user_has_action_permission(request.user, command, 'execute_config'):
+                messages.error(request, "You don't have permission to execute configuration commands.")
+                return self.get(request, pk)
+        elif command.command_type == 'show':
+            if not self._user_has_action_permission(request.user, command, 'execute_show'):
+                messages.error(request, "You don't have permission to execute show commands.")
+                return self.get(request, pk)
+        
+        # Create a form with the POST data
+        form_data = {
+            'username': request.POST.get('username', ''),
+            'password': request.POST.get('password', '')
+        }
+        form = CommandExecutionForm(form_data)
+        commands = self._get_filtered_commands(request.user, device)
+
+        if form.is_valid():
+            username = form.cleaned_data['username']
+            password = form.cleaned_data['password']
+
+            # Check rate limiting before command execution
+            rate_limit_check = self.rate_limiting_service.check_rate_limit(device, request.user)
+            
+            if not rate_limit_check['allowed']:
+                messages.error(request, f"Rate limit exceeded: {rate_limit_check['reason']}")
+                
+                # Get rate limit status and other context for display
+                rate_limit_status = self.rate_limiting_service.get_rate_limit_status(device, request.user)
+                is_valid, error_message, validation_checks = self.device_service.validate_device_for_commands(device)
+                connection_info = self.device_service.get_device_connection_info(device)
+                
+                return render(request, self.template_name, {
+                    'object': device,
+                    'tab': self.tab,
+                    'commands': commands,
+                    'form': form,
+                    'device_valid': is_valid,
+                    'validation_message': error_message,
+                    'validation_checks': validation_checks,
+                    'connection_info': connection_info,
+                    'rate_limit_status': rate_limit_status,
+                })
+
+            # Execute command using the service with retry for socket error recovery
+            result = self.command_service.execute_command_with_retry(
+                command, device, username, password, max_retries=1
+            )
+            
+            # No credential storage for security
+            
+            # Determine overall success and appropriate message
+            overall_success = result.success and not result.has_syntax_error
+            
+            if overall_success:
+                messages.success(request, f"Command '{command.name}' executed successfully.")
+            elif result.has_syntax_error:
+                messages.warning(request, f"Command '{command.name}' executed but syntax error detected: {result.syntax_error_type}")
+            else:
+                messages.error(request, f"Command execution failed: {result.error_message}")
+
+            # Return a new empty form after execution
+            empty_form = CommandExecutionForm()
+            
+            # Get validation checks and rate limit status for display
+            is_valid, error_message, validation_checks = self.device_service.validate_device_for_commands(device)
+            connection_info = self.device_service.get_device_connection_info(device)
+            rate_limit_status = self.rate_limiting_service.get_rate_limit_status(device, request.user)
+            
+            return render(request, self.template_name, {
+                'object': device,
+                'tab': self.tab,
+                'commands': commands,
+                'form': empty_form,  # Use an empty form for the next command
+                'command_output': result.output,
+                'executed_command': command,
+                'execution_success': overall_success,
+                'execution_time': result.execution_time,
+                'has_syntax_error': result.has_syntax_error,
+                'syntax_error_type': result.syntax_error_type,
+                'syntax_error_vendor': result.syntax_error_vendor,
+                'parsed_data': result.parsed_output,
+                'parsing_success': result.parsing_success,
+                'parsing_template': result.parsing_method,
+                'device_valid': is_valid,
+                'validation_message': error_message,
+                'validation_checks': validation_checks,
+                'connection_info': connection_info,
+                'rate_limit_status': rate_limit_status,
+            })
+        else:
+            messages.error(request, "Please correct the form errors.")
+            # Get validation checks and rate limit status for display
+            is_valid, error_message, validation_checks = self.device_service.validate_device_for_commands(device)
+            connection_info = self.device_service.get_device_connection_info(device)
+            rate_limit_status = self.rate_limiting_service.get_rate_limit_status(device, request.user)
+            return render(request, self.template_name, {
+                'object': device,
+                'tab': self.tab,
+                'commands': commands,
+                'form': form,
+                'device_valid': is_valid,
+                'validation_message': error_message,
+                'validation_checks': validation_checks,
+                'connection_info': connection_info,
+                'rate_limit_status': rate_limit_status,
+            })
+
+# Command views
+class CommandListView(ObjectListView):
+    queryset = Command.objects.all()
+    filterset = None  # Will update this after import
+    table = None  # Will update this after import
+    template_name = 'netbox_toolkit/command_list.html'
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        from .filtersets import CommandFilterSet
+        from .tables import CommandTable
+        self.filterset = CommandFilterSet
+        self.table = CommandTable
+
+class CommandEditView(ObjectEditView):
+    queryset = Command.objects.all()
+    form = CommandForm
+    template_name = 'netbox_toolkit/command_edit.html'
+    
+    def get_success_url(self):
+        """Override to use correct plugin namespace"""
+        # Try hardcoded URL first to see if the issue is with reverse()
+        if self.object and self.object.pk:
+            return f'/plugins/toolkit/commands/{self.object.pk}/'
+        return '/plugins/toolkit/commands/'
+    
+    def get_return_url(self, request, instance):
+        """Override to use correct plugin namespace for cancel/return links"""
+        # Check if there's a return URL in the request
+        return_url = request.GET.get('return_url')
+        if return_url:
+            return return_url
+        # Return hardcoded URL
+        return '/plugins/toolkit/commands/'
+    
+    def get_extra_context(self, request, instance):
+        """Override to provide additional context with correct URLs"""
+        context = super().get_extra_context(request, instance)
+        
+        # Override any auto-generated URLs that might be using wrong namespace
+        context['base_template'] = 'generic/object_edit.html'
+        context['return_url'] = self.get_return_url(request, instance)
+        
+        return context
+    
+    def form_valid(self, form):
+        """Override form_valid to ensure correct URL handling"""
+        # Let the parent handle the form saving
+        response = super().form_valid(form)
+        # The parent should redirect to get_success_url()
+        return response
+
+class CommandView(ObjectView):
+    queryset = Command.objects.all()
+    template_name = 'netbox_toolkit/command.html'
+    
+    def get_extra_context(self, request, instance):
+        """Add permission context to the template"""
+        context = super().get_extra_context(request, instance)
+        
+        # Add permission information for the template using NetBox's object-based permissions
+        context['can_execute'] = False
+        if instance.command_type == 'show':
+            context['can_execute'] = self._user_has_action_permission(request.user, instance, 'execute_show')
+        elif instance.command_type == 'config':
+            context['can_execute'] = self._user_has_action_permission(request.user, instance, 'execute_config')
+        
+        # NetBox will automatically handle 'change' and 'delete' permissions through standard actions
+        context['can_edit'] = self._user_has_action_permission(request.user, instance, 'change')
+        context['can_delete'] = self._user_has_action_permission(request.user, instance, 'delete')
+        
+        return context
+
+    def _user_has_action_permission(self, user, obj, action):
+        """Check if user has permission for a specific action on an object using NetBox's ObjectPermission system"""
+        from django.contrib.contenttypes.models import ContentType
+        from users.models import ObjectPermission
+        
+        # Get content type for the object
+        content_type = ContentType.objects.get_for_model(obj)
+        
+        # Check if user has any ObjectPermissions with the required action
+        user_permissions = ObjectPermission.objects.filter(
+            object_types__in=[content_type],
+            actions__contains=[action],
+            enabled=True
+        )
+        
+        # Check if user is assigned to any groups with this permission
+        user_groups = user.groups.all()
+        for permission in user_permissions:
+            # Check if permission applies to user or user's groups
+            if (permission.users.filter(id=user.id).exists() or 
+                permission.groups.filter(id__in=user_groups.values_list('id', flat=True)).exists()):
+                
+                # If there are constraints, evaluate them
+                if permission.constraints:
+                    # Create a queryset with the constraints and check if the object matches
+                    queryset = content_type.model_class().objects.filter(**permission.constraints)
+                    if queryset.filter(id=obj.id).exists():
+                        return True
+                else:
+                    # No constraints means permission applies to all objects of this type
+                    return True
+        
+        return False
+
+class CommandDeleteView(ObjectDeleteView):
+    queryset = Command.objects.all()
+    
+    def get_success_url(self):
+        """Override to use correct plugin namespace"""
+        from django.urls import reverse
+        return reverse('plugins:netbox_toolkit:command_list')
+
+class CommandChangeLogView(ObjectChangeLogView):
+    queryset = Command.objects.all()
+
+# CommandLog views
+class CommandLogListView(ObjectListView):
+    queryset = CommandLog.objects.all()
+    filterset = None  # Will update this after import
+    table = None  # Will update this after import
+    template_name = 'netbox_toolkit/commandlog_list.html'
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        from .filtersets import CommandLogFilterSet
+        from .tables import CommandLogTable
+        self.filterset = CommandLogFilterSet
+        self.table = CommandLogTable
+    
+    def get_extra_context(self, request):
+        """Override to disable 'Add' button since logs are created automatically"""
+        context = super().get_extra_context(request)
+        context['add_button_url'] = None  # Disable the add button
+        return context
+
+class CommandLogView(ObjectView):
+    queryset = CommandLog.objects.all()
+    template_name = 'netbox_toolkit/commandlog.html'
+
+class CommandLogChangeLogView(ObjectChangeLogView):
+    queryset = CommandLog.objects.all()

netbox_toolkit_plugin-0.1.0.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: netbox-toolkit-plugin
+Version: 0.1.0
+Summary: NetBox plugin for running pre-defined commands on network devices
+Author: Andy Norwood
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: System Administrators
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scrapli>=2023.1.30
+Requires-Dist: scrapli-netconf>=2023.1.30
+Requires-Dist: scrapli-community>=2023.1.30
+Requires-Dist: netmiko>=4.0.0
+Dynamic: license-file
+
+# NetBox Command Toolkit Plugin
+
+> ⚠️ **EARLY DEVELOPMENT WARNING** ⚠️  
+> This plugin is in very early development and not recommended for production use. There will be bugs and possible incomplete functionality. Use at your own risk! If you do, give some feedback in [Discussions](https://github.com/bonzo81/netbox-toolkit-plugin/discussions)
+
+A NetBox plugin that allows you to run commands on network devices directly from the device page. 
+
+
+
+### 📋 Feature Overview
+- **🔧 Command Creation**: Define platform-specific commands (show/config types)
+- **🔐 Command Permissions**: Granular access control using NetBox's permission system
+- **⚡ Command Execution**: Run commands directly from device pages via "Toolkit" tab
+- **📄 Raw Output**: View complete, unfiltered command responses
+- **🔍 Parsed Output**: Automatic JSON parsing using textFSM templates
+- **📊 Command Logs**: Complete execution history with timestamps
+- **🐛 Debug Logging**: Optional detailed logging for troubleshooting
+
+
+### Built with:
+- Scrapli for device connections
+- Netmiko as a fallback for problematic devices
+- TextFSM for structured data parsing
+
+### Created with:
+- VSCode
+- Copilot
+- RooCode
+
+>   This project is a work in progress and in early development. It is not recommended for production use. Feedback and contributions are welcome!
+
+## 📚 Essential Guides
+
+#### 🚀 Getting Started
+- [📦 Installation](./docs/user/installation.md) - Install the plugin in your NetBox environment
+- [⚙️ Configuration](./docs/user/configuration.md) - Configure plugin settings and options
+
+#### 📋 Command Management  
+- [📋 Command Creation](./docs/user/command-creation.md) - Create platform-specific commands
+- [🔐 Permissions Setup](./docs/user/PERMISSIONS_SETUP_GUIDE.md) - Configure granular access control
+- [📝 Permission Examples](./docs/user/permission-examples.md) - Example permission configuration
+
+#### 🔧 Troubleshooting
+- [🐛 Debug Logging](./docs/user/debug-logging.md) - Enable detailed logging for debugging
+
+
+## Contributing
+
+**🚀 Want to Contribute?** Start with the [Contributor Guide](./docs/contributing.md) for a fast overview of the codebase.
+
+
+## Future ideas:
+- Enhance API to allow execution of commands and return either parsed or raw data.
+- Enable variable use in the command creation and execution, based on device attributes.
+

netbox_toolkit_plugin-0.1.0.dist-info/RECORD

@@ -0,0 +1,56 @@
+netbox_toolkit/__init__.py,sha256=eRGsuq2UwhZmpxPq-G6JJoW66E4UpATmI1bhY1ztoVw,823
+netbox_toolkit/admin.py,sha256=j0O2hke80XbGCfU3lkxl8__tRmBArNLoQtLyA39hepI,690
+netbox_toolkit/config.py,sha256=IKDDR1CMzTNCL3DQPXVKZ7WCw6kl53PD9D4jrBs6fpc,5481
+netbox_toolkit/exceptions.py,sha256=qh7SxXLTqwsduxUMiTA_pXQ67VHSpxRuQgdlfXMl6Bk,785
+netbox_toolkit/filtersets.py,sha256=ppmnfQ8IUHm60BiJR9_cdn1ygvuFlMfj6YIFLJ-XeMc,2722
+netbox_toolkit/forms.py,sha256=6aUaXuJtx3ZL2iEbIq2zXuiXCu2bAHDUMI2EJJBPsWg,1037
+netbox_toolkit/models.py,sha256=G08tjm6N2Ob8yf3503VvzOy249iWDYlDIpyYwht75JM,2791
+netbox_toolkit/navigation.py,sha256=Ew0rx2vcLqArvEcSb9WLImz0PUBWXNOMCMbPCUMV_Bk,941
+netbox_toolkit/search.py,sha256=v8HPgp_0Nq-s_IoV7n4Kfi63_u535jVAoT-31ntdZlA,564
+netbox_toolkit/tables.py,sha256=qiP2Mub4saH_EhaZd43zf7wOfjgBBlMXA5Rj6iorDQ0,1238
+netbox_toolkit/urls.py,sha256=Kr9xkrK_CXHGjCOTlNRE-8siqFH6nhqi74Um14LHcvA,1079
+netbox_toolkit/views.py,sha256=K-LNcJoSYbAXDstxqA_hRemhR5wIf9-xk8bvqbSt428,17730
+netbox_toolkit/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+netbox_toolkit/api/mixins.py,sha256=Yxog3LQQqmzIiXjxZ5VxSbwV3er-Pxs2GpPEJUipvfY,2241
+netbox_toolkit/api/schemas.py,sha256=Xza5-H2ZqBPCEPyMzDkbmSofY9nE73epu0PKvCB1_Ys,7334
+netbox_toolkit/api/serializers.py,sha256=ZSfBmICUwLEQoMvxPK5348mG7j5v3I5A4Yvu2fLui_Y,5791
+netbox_toolkit/api/urls.py,sha256=sllNjhMFm6pjTXtVphAJg2FU9Am_v0AQy0xtRwrZbQA,273
+netbox_toolkit/api/views/__init__.py,sha256=CksHVk9Jj81kImVlr_JnP9VGwFCAhtrnRzqw7H7pjcI,189
+netbox_toolkit/api/views/command_logs.py,sha256=4PdUQPvle9R9pJcJalYS4MCKYhmG_5EbAUowbjVetgw,6255
+netbox_toolkit/api/views/commands.py,sha256=dv6sjN3L0FTyAWmM4u7zZBPOug6H_WcIR6egd3XE3A4,10939
+netbox_toolkit/connectors/__init__.py,sha256=lL1WCo-rlcjNGVwmwSN1PT592xr5LEPT8k5zEVZlltE,419
+netbox_toolkit/connectors/base.py,sha256=Z88tVG87H8IXdub55t-_uu1ptdhKo0uaz9l9iO-Xi0I,2829
+netbox_toolkit/connectors/factory.py,sha256=XeyIooBu1CwZpvtE9giFaFc5kKODck3fMQwY0OVWALU,13296
+netbox_toolkit/connectors/netmiko_connector.py,sha256=4DZFpvatSQgjG6wp0reYYCwpwjGzVDILvh98QkYsM8o,18793
+netbox_toolkit/connectors/scrapli_connector.py,sha256=ojQgXkUZVQ9vFAdtKEM4aA5HUX7JDO8mLPe4r_YTd7c,22859
+netbox_toolkit/migrations/0001_initial.py,sha256=O8DWY0jMBfRLgxaCETgjOVxbcE0Ngr7nVXVg_zJCJwA,2533
+netbox_toolkit/migrations/0002_alter_command_options_alter_command_unique_together_and_more.py,sha256=8DaaDfzzkVQB4ZEGhoWjyjncvUPjCwNDrKaToFtfmsY,2089
+netbox_toolkit/migrations/0003_permission_system_update.py,sha256=KDhXY9UGiBpXLfL_4yPEQfzm5F_bGXmjy10upuykQ_c,1783
+netbox_toolkit/migrations/0004_remove_django_permissions.py,sha256=o_-5dWkSL1JtASkLpGPFg3bDi_Vx63USMX9sw6zNv_4,2638
+netbox_toolkit/migrations/0005_alter_command_options_and_more.py,sha256=O7VQ0Nq4xpyheX8BmsoOL-Y7fyEvXyPTx503WSce0Is,603
+netbox_toolkit/migrations/0006_commandlog_parsed_data_commandlog_parsing_success_and_more.py,sha256=1NyrQuBdnFEU7oTE_SIOHPLeFzNuOAP51Q5n8y_Sifc,765
+netbox_toolkit/migrations/0007_alter_commandlog_parsing_template.py,sha256=SqVl4LafwmGm2sTKhsAvvrJkjm4cD5Oa3EwTaqZXaeU,471
+netbox_toolkit/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+netbox_toolkit/services/__init__.py,sha256=nzdv0yOAyoAgm3ReKn-zLCbxkzEZfDpfnVDy9UExtyg,273
+netbox_toolkit/services/command_service.py,sha256=3dDrTNmdh1I25ZfzjXFa5-rP4K7sWo9HuimP28LrGMg,15159
+netbox_toolkit/services/device_service.py,sha256=SWqWw7c5cBhbXE_jCJwfgc3KvxchQq_6NeS2hlb3NDA,2945
+netbox_toolkit/services/rate_limiting_service.py,sha256=63plMX25qJkiEztRt8NnJMDRQlp7QVtI6TNSfk8IPTc,8750
+netbox_toolkit/static/netbox_toolkit/css/toolkit.css,sha256=VmyM2_rBJhiP43whtMFaYYP4EW4MUGHPPr84mOo_0Qg,4236
+netbox_toolkit/static/netbox_toolkit/js/toolkit.js,sha256=0oF2p8g1Yu28hKQswj1-2Kctt_09YtT__Xeo39LfQ-I,25721
+netbox_toolkit/templates/netbox_toolkit/command.html,sha256=lTLe4TJmXtiOx1lSbowegwklLY1te7vfieXM3gVtZYs,3387
+netbox_toolkit/templates/netbox_toolkit/command_edit.html,sha256=Dx3QVrtLegViZl9_VWeVayZ1DIgtzWDnrmgS5_TfOCg,175
+netbox_toolkit/templates/netbox_toolkit/command_list.html,sha256=SVgov1SbpBj_hgmnmgpajAT5_ur-lxzK8PinXp5eEIY,368
+netbox_toolkit/templates/netbox_toolkit/commandlog.html,sha256=8qix7GG937QPRxquUEj-GUGDQOxdjX0ERKveQ6OyuMo,5658
+netbox_toolkit/templates/netbox_toolkit/commandlog_list.html,sha256=ggZDtjUOx4kyyD0zAybImF4_gGqe7eTx6JOx_CxjnQ0,105
+netbox_toolkit/templates/netbox_toolkit/device_toolkit.html,sha256=f-hGEXqQhf3FWHQNCUNw1vlA6jJfDWm3AdPgggtuoW0,32314
+netbox_toolkit/utils/__init__.py,sha256=YPk8W2lP8BYeYpZFzemTS4V4BK9s5DqXrAjyQrMAAeg,43
+netbox_toolkit/utils/connection.py,sha256=XWUNOaJ9TBIO6XuESTPi3RSwe8bKlyZ0MLV4_b-ZJiY,4349
+netbox_toolkit/utils/error_parser.py,sha256=tl6QrFW_0bugZKXHl5V_UPY3VDKdp6jDskLtM5oaYAI,16811
+netbox_toolkit/utils/logging.py,sha256=zxLy4c5FXaSR-ndVvY8OnKEn6hyvEDJRMKSDKc8ukjo,1933
+netbox_toolkit/utils/network.py,sha256=__Xz3pYhd7FtMYAsnFZGbW2akQ8uRY2tjs4axIoZMhA,6100
+netbox_toolkit_plugin-0.1.0.dist-info/licenses/LICENSE,sha256=oxRw-SpalZWfCdc8ZALEDboD9OV22cBRrLIpXz2f7a8,11273
+netbox_toolkit_plugin-0.1.0.dist-info/METADATA,sha256=OIKy1epeypZpwW_GTHKySD2GnA0BqgJidd4yNehJ1MI,3157
+netbox_toolkit_plugin-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+netbox_toolkit_plugin-0.1.0.dist-info/entry_points.txt,sha256=QG7lS9AhTN2AdEwFbO-DIyXVW4Q1avIC0Ha-CdNT4VA,69
+netbox_toolkit_plugin-0.1.0.dist-info/top_level.txt,sha256=uPBIiwEx-X6sCRLNFfFtd7LN7zq2zJWIkP-hReJrKfY,15
+netbox_toolkit_plugin-0.1.0.dist-info/RECORD,,