django-cfg 1.3.13__py3-none-any.whl → 1.4.3__py3-none-any.whl

django_cfg/modules/django_ipc_client/dashboard/views.py

@@ -0,0 +1,251 @@
+"""
+Django views for RPC Dashboard.
+
+Provides both template views and JSON API endpoints.
+"""
+
+import logging
+from django.shortcuts import render
+from django.http import JsonResponse
+from django.contrib.admin.views.decorators import staff_member_required
+from django.views.decorators.http import require_http_methods
+
+from .monitor import RPCMonitor
+
+logger = logging.getLogger(__name__)
+
+
+@staff_member_required
+def dashboard_view(request):
+    """
+    Main RPC dashboard view.
+
+    Renders dashboard template with initial data.
+    JavaScript will poll API endpoints for live updates.
+    """
+    try:
+        monitor = RPCMonitor()
+
+        # Get initial data
+        overview_stats = monitor.get_overview_stats()
+        health = monitor.health_check()
+
+        # Build navigation items (can be extended later)
+        rpc_nav_items = []
+
+        context = {
+            'overview_stats': overview_stats,
+            'health': health,
+            'page_title': 'RPC Monitor Dashboard',
+            'rpc_nav_items': rpc_nav_items,
+        }
+
+        return render(request, 'django_ipc_dashboard/dashboard.html', context)
+
+    except Exception as e:
+        logger.error(f"Dashboard view error: {e}", exc_info=True)
+
+        # Build navigation items (can be extended later)
+        rpc_nav_items = []
+
+        # Fallback context
+        context = {
+            'overview_stats': {
+                'redis_connected': False,
+                'error': str(e),
+            },
+            'health': {
+                'redis_connected': False,
+                'error': str(e),
+            },
+            'page_title': 'RPC Monitor Dashboard - Error',
+            'rpc_nav_items': rpc_nav_items,
+        }
+
+        return render(request, 'django_ipc_dashboard/dashboard.html', context)
+
+
+# === JSON API Endpoints ===
+
+@staff_member_required
+@require_http_methods(["GET"])
+def api_overview_stats(request):
+    """
+    API endpoint for overview statistics.
+
+    Returns JSON with current RPC metrics.
+    """
+    try:
+        monitor = RPCMonitor()
+        stats = monitor.get_overview_stats()
+
+        return JsonResponse({
+            'success': True,
+            'data': stats,
+        })
+
+    except ValueError as e:
+        logger.warning(f"API overview stats validation error: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': str(e),
+        }, status=400)  # Bad Request
+
+    except ConnectionError as e:
+        logger.error(f"API overview stats connection error: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': 'Redis connection unavailable',
+        }, status=503)  # Service Unavailable
+
+    except Exception as e:
+        logger.error(f"API overview stats error: {e}", exc_info=True)
+        return JsonResponse({
+            'success': False,
+            'error': 'Internal server error',
+        }, status=500)
+
+
+@staff_member_required
+@require_http_methods(["GET"])
+def api_recent_requests(request):
+    """
+    API endpoint for recent RPC requests.
+
+    Query params:
+        - count: Number of requests to return (default: 50, max: 200)
+    """
+    try:
+        count = int(request.GET.get('count', 50))
+        count = min(count, 200)  # Max 200
+
+        monitor = RPCMonitor()
+        requests_list = monitor.get_recent_requests(count=count)
+
+        return JsonResponse({
+            'success': True,
+            'data': {
+                'requests': requests_list,
+                'count': len(requests_list),
+            },
+        })
+
+    except ValueError as e:
+        logger.warning(f"API recent requests validation error: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': 'Invalid count parameter',
+        }, status=400)
+
+    except ConnectionError as e:
+        logger.error(f"API recent requests connection error: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': 'Redis connection unavailable',
+        }, status=503)
+
+    except Exception as e:
+        logger.error(f"API recent requests error: {e}", exc_info=True)
+        return JsonResponse({
+            'success': False,
+            'error': 'Internal server error',
+        }, status=500)
+
+
+@staff_member_required
+@require_http_methods(["GET"])
+def api_notification_stats(request):
+    """
+    API endpoint for notification statistics.
+
+    Returns stats about sent notifications.
+    """
+    try:
+        monitor = RPCMonitor()
+        stats = monitor.get_notification_stats()
+
+        return JsonResponse({
+            'success': True,
+            'data': stats,
+        })
+
+    except ConnectionError as e:
+        logger.error(f"API notification stats connection error: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': 'Redis connection unavailable',
+        }, status=503)
+
+    except Exception as e:
+        logger.error(f"API notification stats error: {e}", exc_info=True)
+        return JsonResponse({
+            'success': False,
+            'error': 'Internal server error',
+        }, status=500)
+
+
+@staff_member_required
+@require_http_methods(["GET"])
+def api_method_stats(request):
+    """
+    API endpoint for method statistics.
+
+    Returns stats grouped by RPC method.
+    """
+    try:
+        monitor = RPCMonitor()
+        stats = monitor.get_method_stats()
+
+        return JsonResponse({
+            'success': True,
+            'data': {
+                'methods': stats,
+                'count': len(stats),
+            },
+        })
+
+    except ConnectionError as e:
+        logger.error(f"API method stats connection error: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': 'Redis connection unavailable',
+        }, status=503)
+
+    except Exception as e:
+        logger.error(f"API method stats error: {e}", exc_info=True)
+        return JsonResponse({
+            'success': False,
+            'error': 'Internal server error',
+        }, status=500)
+
+
+@staff_member_required
+@require_http_methods(["GET"])
+def api_health_check(request):
+    """
+    API endpoint for health check.
+
+    Returns current health status of RPC monitoring.
+    """
+    try:
+        monitor = RPCMonitor()
+        health = monitor.health_check()
+
+        return JsonResponse({
+            'success': True,
+            'data': health,
+        })
+
+    except ConnectionError as e:
+        logger.error(f"API health check connection error: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': 'Redis connection unavailable',
+        }, status=503)
+
+    except Exception as e:
+        logger.error(f"API health check error: {e}", exc_info=True)
+        return JsonResponse({
+            'success': False,
+            'error': 'Internal server error',
+        }, status=500)

django_cfg/modules/django_ipc_client/exceptions.py

@@ -0,0 +1,201 @@
+"""
+Custom Exceptions for Django-CFG RPC Client.
+
+Provides specific exception types for better error handling and debugging.
+Works independently or with django-cfg-rpc models.
+"""
+
+from typing import Optional, Any
+
+# Try to import RPCError from django-cfg-rpc if available
+try:
+    from django_ipc.models.errors import RPCError
+    HAS_DJANGO_CFG_RPC = True
+except ImportError:
+    # Fallback: simple RPCError for basic error handling
+    HAS_DJANGO_CFG_RPC = False
+
+    class RPCError:  # type: ignore
+        """Minimal RPCError fallback when django-cfg-rpc not installed."""
+
+        def __init__(self, code: str, message: str, retryable: bool = False, retry_after: Optional[int] = None):
+            self.code = code
+            self.message = message
+            self.retryable = retryable
+            self.retry_after = retry_after
+
+
+class RPCBaseException(Exception):
+    """
+    Base exception for all RPC-related errors.
+
+    All custom RPC exceptions inherit from this class.
+    """
+
+    def __init__(self, message: str):
+        """
+        Initialize base RPC exception.
+
+        Args:
+            message: Error message
+        """
+        self.message = message
+        super().__init__(message)
+
+
+class RPCTimeoutError(RPCBaseException):
+    """
+    RPC call timed out waiting for response.
+
+    Raised when BLPOP timeout is exceeded.
+
+    Example:
+        >>> try:
+        ...     result = rpc.call(method="slow", params=..., timeout=5)
+        ... except RPCTimeoutError as e:
+        ...     print(f"RPC timeout: {e.message}")
+        ...     print(f"Timeout duration: {e.timeout_seconds}s")
+    """
+
+    def __init__(self, message: str, method: str, timeout_seconds: int):
+        """
+        Initialize timeout error.
+
+        Args:
+            message: Error message
+            method: RPC method that timed out
+            timeout_seconds: Timeout duration that was exceeded
+        """
+        super().__init__(message)
+        self.method = method
+        self.timeout_seconds = timeout_seconds
+
+    def __str__(self) -> str:
+        """String representation."""
+        return f"RPC timeout on method '{self.method}' after {self.timeout_seconds}s: {self.message}"
+
+
+class RPCRemoteError(RPCBaseException):
+    """
+    Remote RPC execution failed.
+
+    Raised when server returns error response.
+
+    Example:
+        >>> try:
+        ...     result = rpc.call(method="...", params=...)
+        ... except RPCRemoteError as e:
+        ...     print(f"Remote error: {e.error.code}")
+        ...     print(f"Message: {e.error.message}")
+        ...     if e.is_retryable:
+        ...         print(f"Can retry after {e.retry_after}s")
+    """
+
+    def __init__(self, error: Any):
+        """
+        Initialize remote error.
+
+        Args:
+            error: Structured RPC error from server (RPCError or dict)
+        """
+        # Handle both RPCError objects and dicts
+        if isinstance(error, dict):
+            message = error.get("message", "Unknown error")
+            self.error = RPCError(
+                code=error.get("code", "internal_error"),
+                message=message,
+                retryable=error.get("retryable", False),
+                retry_after=error.get("retry_after"),
+            )
+        else:
+            message = error.message if hasattr(error, "message") else str(error)
+            self.error = error
+
+        super().__init__(message)
+
+    def __str__(self) -> str:
+        """String representation."""
+        code = self.error.code if hasattr(self.error, "code") else "unknown"
+        return f"RPC remote error [{code}]: {self.message}"
+
+    @property
+    def is_retryable(self) -> bool:
+        """Check if error is retryable."""
+        return getattr(self.error, "retryable", False)
+
+    @property
+    def retry_after(self) -> Optional[int]:
+        """Get retry delay in seconds."""
+        return getattr(self.error, "retry_after", None)
+
+
+class RPCConnectionError(RPCBaseException):
+    """
+    Failed to connect to Redis.
+
+    Raised when Redis connection fails.
+
+    Example:
+        >>> try:
+        ...     rpc = DjangoCfgRPCClient(redis_url="redis://invalid:6379")
+        ... except RPCConnectionError as e:
+        ...     print(f"Connection failed: {e.message}")
+    """
+
+    def __init__(self, message: str, redis_url: Optional[str] = None):
+        """
+        Initialize connection error.
+
+        Args:
+            message: Error message
+            redis_url: Redis URL that failed to connect
+        """
+        super().__init__(message)
+        self.redis_url = redis_url
+
+    def __str__(self) -> str:
+        """String representation."""
+        if self.redis_url:
+            return f"RPC connection error to {self.redis_url}: {self.message}"
+        return f"RPC connection error: {self.message}"
+
+
+class RPCConfigurationError(RPCBaseException):
+    """
+    RPC configuration error.
+
+    Raised when RPC client is misconfigured.
+
+    Example:
+        >>> try:
+        ...     rpc = get_rpc_client()  # No config in settings
+        ... except RPCConfigurationError as e:
+        ...     print(f"Configuration error: {e.message}")
+    """
+
+    def __init__(self, message: str, config_key: Optional[str] = None):
+        """
+        Initialize configuration error.
+
+        Args:
+            message: Error message
+            config_key: Configuration key that is missing/invalid
+        """
+        super().__init__(message)
+        self.config_key = config_key
+
+    def __str__(self) -> str:
+        """String representation."""
+        if self.config_key:
+            return f"RPC configuration error (key: {self.config_key}): {self.message}"
+        return f"RPC configuration error: {self.message}"
+
+
+__all__ = [
+    "RPCBaseException",
+    "RPCTimeoutError",
+    "RPCRemoteError",
+    "RPCConnectionError",
+    "RPCConfigurationError",
+    "HAS_DJANGO_CFG_RPC",
+]