Merge pull request #48 from keeganwhite/main

feat: Add port management endpoints and UI

Author: keeganwhite

backend/control_center/ansible/playbooks/check-port-details.yml

@@ -0,0 +1,6 @@
+---
+- name: Check port details (speed and status)
+  become: true
+  hosts: localserver
+  roles:
+    - ../roles/check-port-details

backend/control_center/ansible/roles/check-port-details/tasks/main.yml

@@ -0,0 +1,29 @@
+---
+- name: Get port speed from sysfs
+  shell: |
+    if [ -f /sys/class/net/{{ port_name }}/speed ]; then
+      speed=$(cat /sys/class/net/{{ port_name }}/speed 2>/dev/null || echo "")
+      if [ -n "$speed" ] && [ "$speed" != "-1" ]; then
+        echo "$speed"
+      else
+        echo ""
+      fi
+    else
+      echo ""
+    fi
+  register: port_speed_output
+  changed_when: false
+
+- name: Get port status using ip link show
+  shell: ip link show {{ port_name }} 2>/dev/null || echo "NOT_FOUND"
+  register: port_status_output
+  changed_when: false
+  failed_when: false
+
+- name: Debug port speed
+  debug:
+    var: port_speed_output.stdout
+
+- name: Debug port status
+  debug:
+    var: port_status_output.stdout_lines

backend/control_center/general/migrations/0032_port_is_up.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.0.1 on 2025-01-XX XX:XX
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('general', '0031_port_link_speed'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='port',
+            name='is_up',
+            field=models.BooleanField(blank=True, help_text='Port status: True if up, False if down, None if unknown', null=True),
+        ),
+    ]
+

backend/control_center/general/models.py

@@ -81,6 +81,7 @@ class Port(models.Model):
     name = models.CharField(max_length=100)
     ovs_port_number = models.IntegerField(null=True, blank=True)
     link_speed = models.IntegerField(null=True, blank=True, help_text="Link speed in Mb/s")
+    is_up = models.BooleanField(null=True, blank=True, help_text="Port status: True if up, False if down, None if unknown")
 
     class Meta:
         unique_together = ('device', 'name')

backend/control_center/general/serializers.py

@@ -38,7 +38,38 @@ def get_lan_ip_address(self, obj):
 class PortSerializer(serializers.ModelSerializer):
     class Meta:
         model = Port
-        fields = ['id', 'name', 'ovs_port_number', 'link_speed']
+        fields = ['id', 'name', 'ovs_port_number', 'link_speed', 'is_up']
+
+
+class PortUpdateSerializer(serializers.ModelSerializer):
+    """
+    Serializer for updating port link_speed only.
+    All other fields are read-only.
+    """
+
+    class Meta:
+        model = Port
+        fields = ['id', 'name', 'ovs_port_number', 'link_speed', 'is_up']
+        read_only_fields = ['id', 'name', 'ovs_port_number', 'is_up']
+
+    def save(self, **kwargs):
+        # Only save link_speed, filter validated_data to just link_speed
+        if 'link_speed' in self.validated_data:
+            # Filter validated_data to only include link_speed
+            filtered_data = {'link_speed': self.validated_data['link_speed']}
+            # Temporarily store original validated_data
+            original_validated_data = self.validated_data
+            # Replace with filtered data
+            self._validated_data = filtered_data
+            try:
+                instance = super().save(**kwargs)
+                # Ensure only link_speed was updated in the database
+                instance.save(update_fields=['link_speed'])
+                return instance
+            finally:
+                # Restore original validated_data
+                self._validated_data = original_validated_data
+        return super().save(**kwargs)
 
 
 class DeviceSerializer(serializers.ModelSerializer):

backend/control_center/general/urls.py

@@ -1,13 +1,14 @@
 from django.urls import path, include
 from rest_framework.routers import DefaultRouter
-from .views import ControllerViewSet, SwitchViewSet
+from .views import ControllerViewSet, SwitchViewSet, PortViewSet
 
 app_name = 'general'
 
-# Create a router and register the ControllerViewSet
+# Create a router and register the ViewSets
 router = DefaultRouter()
 router.register(r'controllers', ControllerViewSet, basename='controller')
 router.register(r'switches', SwitchViewSet, basename='switch')
+router.register(r'ports', PortViewSet, basename='port')
 
 urlpatterns = [
     path('', include(router.urls)),

backend/control_center/general/views.py

@@ -34,7 +34,7 @@
 from django.core.validators import validate_ipv4_address
 from django.core.exceptions import ValidationError
 import logging
-from .serializers import BridgeSerializer, ControllerSerializer
+from .serializers import BridgeSerializer, ControllerSerializer, PortSerializer, PortUpdateSerializer
 from .models import Controller, Plugins
 from .serializers import DeviceSerializer
 
@@ -44,6 +44,7 @@
 from rest_framework.permissions import IsAuthenticated
 from knox.auth import TokenAuthentication
 from utils.ansible_utils import run_playbook_with_extravars, create_temp_inv, create_inv_data
+from utils.ansible_formtter import get_single_port_speed_from_results, get_port_status_from_results
 # Import the model manager
 from classifier.model_manager import model_manager
 from odl.models import Category
@@ -615,4 +616,132 @@ def bridges(self, request, pk=None):
             return Response({"bridges": data}, status=200)
         except Exception as e:
             logger.exception('Error getting switch bridges...')
-            return Response({"error": str(e)}, status=500)
+            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @action(detail=True, methods=['get'], url_path='bridge-ports')
+    def bridge_ports(self, request, pk=None):
+        """
+        Custom action to fetch all ports on a switch that are assigned to bridges.
+        Returns ports where bridge is not null.
+        """
+        try:
+            switch = self.get_object()
+            # Get all ports on this switch that have a bridge assigned
+            ports = Port.objects.filter(device=switch, bridge__isnull=False)
+            serializer = PortSerializer(ports, many=True)
+            return Response({"ports": serializer.data}, status=status.HTTP_200_OK)
+        except Exception as e:
+            logger.exception('Error getting switch bridge ports...')
+            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+# ----- PORT VIEWS ------
+class PortViewSet(ModelViewSet):
+    """
+    A viewset that provides actions for Port model.
+    """
+    queryset = Port.objects.all()
+    serializer_class = PortSerializer
+    authentication_classes = (TokenAuthentication,)
+    permission_classes = (IsAuthenticated,)
+
+    def get_serializer_class(self):
+        """
+        Use PortUpdateSerializer for partial updates (PATCH).
+        """
+        if self.action == 'partial_update':
+            return PortUpdateSerializer
+        return PortSerializer
+
+    def partial_update(self, request, pk=None):
+        """
+        Update port link_speed only.
+        All other fields are read-only.
+        """
+        try:
+            port = self.get_object()
+            serializer = PortUpdateSerializer(port, data=request.data, partial=True)
+            
+            if serializer.is_valid():
+                # Only allow link_speed to be updated
+                if 'link_speed' in serializer.validated_data:
+                    updated_port = serializer.save()
+                    return Response(PortSerializer(updated_port).data, status=status.HTTP_200_OK)
+                else:
+                    return Response(
+                        {"error": "Only link_speed can be updated"},
+                        status=status.HTTP_400_BAD_REQUEST
+                    )
+            else:
+                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except Exception as e:
+            logger.exception(f'Error updating port: {str(e)}')
+            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @action(detail=True, methods=['post'], url_path='sync')
+    def sync(self, request, pk=None):
+        """
+        Sync port details (speed and status) from the switch.
+        Connects to the device and checks the current port speed and status.
+        """
+        try:
+            port = self.get_object()
+            device = port.device
+            
+            if device.device_type != 'switch':
+                return Response(
+                    {"error": "Port sync is only available for switch devices"},
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+            
+            # Create inventory for the device
+            inv_content = create_inv_data(device.lan_ip_address, device.username, device.password)
+            inv_path = create_temp_inv(inv_content)
+            
+            # Run the check-port-details playbook with port name as extravar
+            playbook_name = "check-port-details"
+            extra_vars = {
+                'port_name': port.name,
+                'ip_address': device.lan_ip_address,
+            }
+            
+            result = run_playbook_with_extravars(
+                playbook_name,
+                playbook_dir_path,
+                inv_path,
+                extra_vars,
+                quiet=True
+            )
+            
+            if result.get('status') != 'success':
+                error_msg = result.get('error', 'Unknown error occurred')
+                logger.error(f"Failed to sync port {port.name}: {error_msg}")
+                return Response(
+                    {"error": f"Failed to sync port details: {error_msg}"},
+                    status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                )
+            
+            # Parse results
+            port_speed = get_single_port_speed_from_results(result, port.name)
+            port_status = get_port_status_from_results(result, port.name)
+            
+            # Update port in database
+            update_fields = []
+            if port_speed is not None:
+                port.link_speed = port_speed
+                update_fields.append('link_speed')
+            if port_status is not None:
+                port.is_up = port_status
+                update_fields.append('is_up')
+            
+            if update_fields:
+                port.save(update_fields=update_fields)
+                logger.debug(f"Updated port {port.name}: speed={port_speed}, status={port_status}")
+            
+            # Return updated port data
+            serializer = PortSerializer(port)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+            
+        except Exception as e:
+            logger.exception(f'Error syncing port: {str(e)}')
+            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

backend/control_center/utils/ansible_formtter.py

@@ -181,4 +181,100 @@ def extract_ovs_port_map(playbook_result):
         logger.exception(f"Error accessing top-level results for ovs_port_map: {e}")
 
     logger.warning("Could not find 'ovs_port_map' in any expected location within the playbook results.")
-    return ovs_map  # Return empty dict if not found
+    return ovs_map  # Return empty dict if not found
+
+
+def get_single_port_speed_from_results(results, port_name):
+    """
+    Extract the speed for a specific port from Ansible playbook results.
+    
+    Parameters:
+        results (dict): Ansible playbook result dictionary containing a 'results' mapping
+            with the key "Get port speed from sysfs" whose value provides 'stdout'.
+        port_name (str): Name of the port to get speed for.
+    
+    Returns:
+        int or None: Port speed in megabits per second, or None if not found or invalid.
+    """
+    results_data = results.get('results', results) if isinstance(results, dict) else results
+    
+    command_key = "Get port speed from sysfs"
+    
+    if command_key in results_data:
+        speed_output = results_data[command_key].get('stdout', '').strip()
+        if speed_output and speed_output != '':
+            try:
+                speed = int(speed_output)
+                if speed > 0:  # Valid speed (exclude -1 or 0)
+                    logger.debug(f"Extracted port speed for {port_name}: {speed} Mb/s")
+                    return speed
+            except ValueError:
+                logger.warning(f"Invalid speed value for {port_name}: {speed_output}")
+    
+    logger.debug(f"No valid speed found for port {port_name}")
+    return None
+
+
+def get_port_status_from_results(results, port_name):
+    """
+    Extract the port status (up/down) from Ansible playbook results.
+    
+    Parameters:
+        results (dict): Ansible playbook result dictionary containing a 'results' mapping
+            with the key "Get port status using ip link show" whose value provides 'stdout_lines'.
+        port_name (str): Name of the port to get status for.
+    
+    Returns:
+        bool or None: True if port is up, False if down, None if status cannot be determined.
+    """
+    results_data = results.get('results', results) if isinstance(results, dict) else results
+    
+    command_key = "Get port status using ip link show"
+    
+    if command_key in results_data:
+        output_lines = results_data[command_key].get('stdout_lines', [])
+        output_str = ' '.join(output_lines) if output_lines else ''
+        
+        # Check if port was not found
+        if 'NOT_FOUND' in output_str or not output_lines:
+            logger.warning(f"Port {port_name} not found on device")
+            return None
+        
+        # Parse ip link show output to find state
+        # Example formats:
+        # "2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000"
+        # "2: eth0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc mq state DOWN group default qlen 1000"
+        for line in output_lines:
+            line_lower = line.lower()
+            # Check for explicit state UP or DOWN
+            if 'state up' in line_lower:
+                logger.debug(f"Port {port_name} is UP (from state)")
+                return True
+            elif 'state down' in line_lower:
+                logger.debug(f"Port {port_name} is DOWN (from state)")
+                return False
+        
+        # If no explicit state found, check flags in angle brackets
+        # UP flag without NO-CARRIER usually means the interface is up
+        # But we need to be careful - LOWER_UP alone doesn't mean the interface is up
+        for line in output_lines:
+            line_lower = line.lower()
+            if '<' in line and '>' in line:
+                flags_section = line[line.find('<'):line.find('>')+1]
+                flags_lower = flags_section.lower()
+                # If we see UP in flags and no NO-CARRIER, it's likely up
+                # But state takes precedence, so only use flags if state wasn't found
+                # Split flags and check for exact 'up' flag (not lower_up, upper_up, etc.)
+                flags_list = [f.strip() for f in flags_lower.replace('<', '').replace('>', '').split(',')]
+                if 'up' in flags_list and 'no-carrier' not in flags_list:
+                    # Check if there's a state mentioned elsewhere in the line
+                    if 'state' not in line_lower:
+                        logger.debug(f"Port {port_name} appears to be UP (from flags)")
+                        return True
+        
+        # If we have output but couldn't determine state, default to None
+        logger.warning(f"Could not determine status for port {port_name} from output: {output_str}")
+        return None
+    
+    logger.warning(f"Could not find port status task results for {port_name}")
+    return None