django-cfg 1.4.116__py3-none-any.whl → 1.5.14__py3-none-any.whl

django_cfg/apps/integrations/grpc/views/services.py

@@ -0,0 +1,298 @@
+"""
+gRPC Service Registry ViewSet.
+
+Provides REST API endpoints for viewing registered gRPC services and their methods.
+"""
+
+from django.db import models
+from django.db.models import Avg, Count, Max, Min
+from django_cfg.middleware.pagination import DefaultPagination
+from django_cfg.mixins import AdminAPIMixin
+from django_cfg.modules.django_logging import get_logger
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter, extend_schema
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..models import GRPCRequestLog
+from ..serializers.service_registry import (
+    MethodDetailSerializer,
+    ServiceDetailSerializer,
+    ServiceListSerializer,
+    ServiceMethodsSerializer,
+    ServiceSummarySerializer,
+)
+from ..services import ServiceRegistryManager
+
+logger = get_logger("grpc.services")
+
+
+class GRPCServiceViewSet(AdminAPIMixin, viewsets.GenericViewSet):
+    """
+    ViewSet for gRPC service registry and management.
+
+    Provides endpoints for:
+    - List all registered services
+    - Get service details
+    - Get service methods
+    - Get method details and statistics
+
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    # Pagination for list endpoint
+    pagination_class = DefaultPagination
+
+    # Required for GenericViewSet
+    queryset = GRPCRequestLog.objects.none()  # Placeholder
+    serializer_class = ServiceSummarySerializer
+
+    # Allow dots in service names (e.g., apps.CryptoService)
+    lookup_value_regex = r'[^/]+'
+
+    @extend_schema(
+        tags=["gRPC Services"],
+        summary="List all services",
+        description="Returns paginated list of all registered gRPC services with basic statistics.",
+        parameters=[
+            OpenApiParameter(
+                name="hours",
+                type=OpenApiTypes.INT,
+                location=OpenApiParameter.QUERY,
+                description="Statistics period in hours (default: 24)",
+                required=False,
+            ),
+            # Note: page, page_size added automatically by pagination_class
+        ],
+        responses={
+            200: ServiceSummarySerializer(many=True),
+        },
+    )
+    def list(self, request):
+        """List all registered gRPC services with pagination."""
+        try:
+            hours = int(request.GET.get("hours", 24))
+            hours = min(max(hours, 1), 168)
+
+            # Use service registry manager
+            registry = ServiceRegistryManager()
+
+            # Get services with stats from service layer
+            # Note: This will return empty list if server is not running,
+            # but that's expected - services are only known when server is started
+            services_list = registry.get_all_services_with_stats(hours=hours)
+
+            # Paginate the services list (works with empty list too)
+            page = self.paginate_queryset(services_list)
+            if page is not None:
+                serializer = ServiceSummarySerializer(page, many=True)
+                return self.get_paginated_response(serializer.data)
+
+            # Fallback (no pagination)
+            serializer = ServiceSummarySerializer(services_list, many=True)
+            return Response(serializer.data)
+
+        except Exception as e:
+            logger.error(f"Service list error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Services"],
+        summary="Get service details",
+        description="Returns detailed information about a specific gRPC service.",
+        parameters=[
+            OpenApiParameter(
+                name="pk",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.PATH,
+                description="Service name (e.g., myapp.UserService)",
+                required=True,
+            ),
+        ],
+        responses={
+            200: ServiceDetailSerializer,
+            404: {"description": "Service not found"},
+        },
+    )
+    def retrieve(self, request, pk=None):
+        """Get detailed information about a service."""
+        try:
+            service_name = pk  # pk is service_name in URL
+
+            # Use service registry manager
+            registry = ServiceRegistryManager()
+
+            if not registry.is_server_running():
+                return Response(
+                    {"error": "gRPC server is not running"},
+                    status=status.HTTP_503_SERVICE_UNAVAILABLE,
+                )
+
+            service = registry.get_service_by_name(service_name)
+            if not service:
+                return Response(
+                    {"error": f"Service '{service_name}' not found"},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            # Get statistics
+            stats = GRPCRequestLog.objects.filter(service_name=service_name).aggregate(
+                total=Count("id"),
+                successful=Count("id", filter=models.Q(status="success")),
+                errors=Count("id", filter=models.Q(status="error")),
+                avg_duration=Avg("duration_ms"),
+            )
+
+            # Calculate success rate
+            total = stats["total"] or 0
+            successful = stats["successful"] or 0
+            success_rate = (successful / total * 100) if total > 0 else 0.0
+
+            # Get last 24h requests
+            from datetime import timedelta
+
+            from django.utils import timezone
+
+            last_24h = timezone.now() - timedelta(hours=24)
+            last_24h_count = GRPCRequestLog.objects.filter(
+                service_name=service_name, created_at__gte=last_24h
+            ).count()
+
+            # Get recent errors
+            recent_errors = list(
+                GRPCRequestLog.objects.filter(
+                    service_name=service_name,
+                    status="error",
+                )
+                .order_by("-created_at")[:5]
+                .values(
+                    "method_name",
+                    "error_message",
+                    "grpc_status_code",
+                    "created_at",
+                )
+            )
+
+            # Format methods
+            methods = []
+            for method_name in service.get("methods", []):
+                methods.append(
+                    {
+                        "name": method_name,
+                        "full_name": f"/{service_name}/{method_name}",
+                        "request_type": "",
+                        "response_type": "",
+                        "streaming": False,
+                        "auth_required": False,
+                    }
+                )
+
+            # Extract package
+            package = service_name.split(".")[0] if "." in service_name else ""
+
+            # Format response
+            service_detail = {
+                "name": service_name,
+                "full_name": service.get("full_name", f"/{service_name}"),
+                "package": package,
+                "description": service.get("description", ""),
+                "file_path": service.get("file_path", ""),
+                "class_name": service.get("class_name", ""),
+                "base_class": service.get("base_class", ""),
+                "methods": methods,
+                "stats": {
+                    "total_requests": total,
+                    "successful": successful,
+                    "errors": stats["errors"] or 0,
+                    "success_rate": round(success_rate, 2),
+                    "avg_duration_ms": round(stats["avg_duration"] or 0, 2),
+                    "last_24h_requests": last_24h_count,
+                },
+                "recent_errors": [
+                    {
+                        "method": err["method_name"],
+                        "error_message": err["error_message"] or "",
+                        "grpc_status_code": err["grpc_status_code"] or "",
+                        "occurred_at": err["created_at"].isoformat(),
+                    }
+                    for err in recent_errors
+                ],
+            }
+
+            serializer = ServiceDetailSerializer(data=service_detail)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except Exception as e:
+            logger.error(f"Service detail error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Services"],
+        summary="Get service methods",
+        description="Returns list of methods for a specific service with statistics.",
+        parameters=[
+            OpenApiParameter(
+                name="pk",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.PATH,
+                description="Service name",
+                required=True,
+            ),
+        ],
+        responses={
+            200: ServiceMethodsSerializer,
+            404: {"description": "Service not found"},
+        },
+    )
+    @action(detail=True, methods=["get"], url_path="methods")
+    def methods(self, request, pk=None):
+        """Get methods for a service."""
+        try:
+            service_name = pk
+
+            # Use service registry manager
+            registry = ServiceRegistryManager()
+
+            if not registry.is_server_running():
+                return Response(
+                    {"error": "gRPC server is not running"},
+                    status=status.HTTP_503_SERVICE_UNAVAILABLE,
+                )
+
+            service = registry.get_service_by_name(service_name)
+            if not service:
+                return Response(
+                    {"error": f"Service '{service_name}' not found"},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            # Get methods with stats from service layer
+            methods_list = registry.get_service_methods_with_stats(service_name)
+
+            response_data = {
+                "service_name": service_name,
+                "methods": methods_list,
+                "total_methods": len(methods_list),
+            }
+
+            serializer = ServiceMethodsSerializer(data=response_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except Exception as e:
+            logger.error(f"Service methods error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+__all__ = ["GRPCServiceViewSet"]

django_cfg/apps/integrations/grpc/views/testing.py

@@ -0,0 +1,308 @@
+"""
+gRPC Testing ViewSet.
+
+Provides REST API endpoints for interactive gRPC method testing,
+examples, and test logs.
+"""
+
+import json
+
+from django_cfg.mixins import AdminAPIMixin
+from django_cfg.modules.django_logging import get_logger
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter, extend_schema
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..models import GRPCRequestLog
+from ..serializers.testing import (
+    GRPCCallRequestSerializer,
+    GRPCCallResponseSerializer,
+    GRPCExamplesListSerializer,
+    GRPCTestLogSerializer,
+)
+from ..services import TestingService
+
+logger = get_logger("grpc.testing")
+
+
+class GRPCTestingViewSet(AdminAPIMixin, viewsets.GenericViewSet):
+    """
+    ViewSet for gRPC method testing.
+
+    Provides endpoints for:
+    - Example payloads viewing
+    - Test logs viewing
+    - Method calling (placeholder for future implementation)
+
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    # Required for GenericViewSet
+    queryset = GRPCRequestLog.objects.none()  # Placeholder, actual queries in actions
+    serializer_class = GRPCTestLogSerializer  # Default serializer for schema
+
+    @extend_schema(
+        tags=["gRPC Testing"],
+        summary="Get example payloads",
+        description="Returns example payloads for testing gRPC methods.",
+        parameters=[
+            OpenApiParameter(
+                name="service",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by service name",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="method",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by method name",
+                required=False,
+            ),
+        ],
+        responses={
+            200: GRPCExamplesListSerializer,
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="examples")
+    def examples(self, request):
+        """Get example payloads for testing."""
+        try:
+            service_filter = request.GET.get("service")
+            method_filter = request.GET.get("method")
+
+            service = TestingService()
+            examples = service.get_examples(
+                service_filter=service_filter,
+                method_filter=method_filter,
+            )
+
+            response_data = {
+                "examples": examples,
+                "total_examples": len(examples),
+            }
+
+            serializer = GRPCExamplesListSerializer(data=response_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except Exception as e:
+            logger.error(f"Examples fetch error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Testing"],
+        summary="Get test logs",
+        description="Returns logs from test gRPC calls. Uses standard DRF pagination.",
+        parameters=[
+            OpenApiParameter(
+                name="service",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by service name",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="method",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by method name",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="status",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by status (success, error, etc.)",
+                required=False,
+            ),
+        ],
+        responses={
+            200: GRPCTestLogSerializer,
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="logs")
+    def logs(self, request):
+        """Get test logs."""
+        try:
+            service_filter = request.GET.get("service")
+            method_filter = request.GET.get("method")
+            status_filter = request.GET.get("status")
+
+            service = TestingService()
+            queryset = service.get_test_logs(
+                service_filter=service_filter,
+                method_filter=method_filter,
+                status_filter=status_filter,
+            )
+
+            # Use DRF pagination
+            page = self.paginate_queryset(queryset)
+            if page is not None:
+                # Serialize paginated data
+                logs_list = []
+                for log in page:
+                    logs_list.append({
+                        "request_id": log.request_id,
+                        "service": log.service_name,
+                        "method": log.method_name,
+                        "status": log.status,
+                        "grpc_status_code": log.grpc_status_code or "",
+                        "error_message": log.error_message or "",
+                        "duration_ms": log.duration_ms or 0,
+                        "created_at": log.created_at.isoformat(),
+                        "user": log.user.username if log.user else None,
+                    })
+                return self.get_paginated_response(logs_list)
+
+            # No pagination (shouldn't happen with default pagination)
+            logs_list = []
+            for log in queryset[:100]:  # Safety limit
+                logs_list.append({
+                    "request_id": log.request_id,
+                    "service": log.service_name,
+                    "method": log.method_name,
+                    "status": log.status,
+                    "grpc_status_code": log.grpc_status_code or "",
+                    "error_message": log.error_message or "",
+                    "duration_ms": log.duration_ms or 0,
+                    "created_at": log.created_at.isoformat(),
+                    "user": log.user.username if log.user else None,
+                })
+            return Response({"logs": logs_list, "count": len(logs_list)})
+
+        except Exception as e:
+            logger.error(f"Test logs error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Testing"],
+        summary="Call gRPC method",
+        description=(
+            "Interactive gRPC method calling using dynamic invocation. "
+            "Uses gRPC Reflection API to discover and call methods without compiled stubs."
+        ),
+        request=GRPCCallRequestSerializer,
+        responses={
+            200: GRPCCallResponseSerializer,
+            400: {"description": "Invalid request"},
+            404: {"description": "Service or method not found"},
+            500: {"description": "gRPC call failed"},
+        },
+    )
+    @action(detail=False, methods=["post"], url_path="call")
+    def call_method(self, request):
+        """
+        Call a gRPC method interactively.
+
+        Request body:
+            {
+                "service": "apps.CryptoService",
+                "method": "GetCoin",
+                "request": {"symbol": "BTC"},
+                "metadata": {"authorization": "Bearer token"},
+                "timeout": 5.0
+            }
+
+        Uses gRPC Reflection API for dynamic invocation.
+        Logs all calls to GRPCRequestLog for history tracking.
+        """
+        from uuid import uuid4
+        from django.utils import timezone
+
+        try:
+            # Validate request - DRF validation
+            serializer = GRPCCallRequestSerializer(data=request.data)
+            serializer.is_valid(raise_exception=True)
+            data = serializer.validated_data
+
+            service_name = data["service"]
+            method_name = data["method"]
+            request_data = data.get("payload", {})
+            metadata = data.get("metadata", {})
+            timeout_ms = data.get("timeout_ms", 5000)
+            timeout = timeout_ms / 1000.0  # Convert to seconds
+
+            # Generate request ID
+            request_id = str(uuid4())
+
+            # Create log entry (pending)
+            log = GRPCRequestLog.objects.create(
+                request_id=request_id,
+                service_name=service_name,
+                method_name=method_name,
+                full_method=f"/{service_name}/{method_name}",
+                status="pending",
+                user=request.user if request.user.is_authenticated else None,
+                is_authenticated=request.user.is_authenticated,
+                request_data=request_data,
+            )
+
+            # Call method via service
+            start_time = timezone.now()
+
+            service = TestingService()
+            result = service.call_method(
+                service_name=service_name,
+                method_name=method_name,
+                request_data=request_data,
+                metadata=metadata,
+                timeout=timeout,
+            )
+
+            end_time = timezone.now()
+
+            # Update log
+            log.status = "success" if result["success"] else "error"
+            log.grpc_status_code = result["grpc_status_code"]
+            log.duration_ms = result["duration_ms"]
+            log.response_data = result.get("response") or {}
+            log.error_message = result.get("error_message") or ""
+            log.completed_at = end_time
+            log.save()
+
+            # Construct full response using GRPCCallResponseSerializer
+            response_data = result.get("response")
+            if response_data and isinstance(response_data, dict):
+                response_data = json.dumps(response_data)
+
+            response_data_dict = {
+                "success": result["success"],
+                "request_id": request_id,
+                "service": result["service"],
+                "method": result["method"],
+                "status": log.status,
+                "grpc_status_code": result["grpc_status_code"],
+                "duration_ms": result["duration_ms"],
+                "response": response_data,
+                "error": result.get("error_message"),
+                "metadata": {},
+                "timestamp": end_time.isoformat(),
+            }
+
+            response_serializer = GRPCCallResponseSerializer(data=response_data_dict)
+            response_serializer.is_valid(raise_exception=True)
+            return Response(response_serializer.data, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            logger.error(f"gRPC call endpoint error: {e}", exc_info=True)
+            return Response(
+                {
+                    "success": False,
+                    "error": "Internal server error",
+                    "details": str(e),
+                },
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+__all__ = ["GRPCTestingViewSet"]

django_cfg/apps/integrations/rq/__init__.py

@@ -0,0 +1,9 @@
+"""
+Django-RQ integration for django-cfg.
+
+Provides REST API endpoints for monitoring and managing RQ task queues.
+"""
+
+default_app_config = 'django_cfg.apps.integrations.rq.apps.RQAppConfig'
+
+__version__ = '1.0.0'

django_cfg/apps/integrations/rq/_cfg/__init__.py

@@ -0,0 +1,28 @@
+"""
+Django-RQ system configuration and dependency checking.
+
+This module provides internal/system utilities for RQ integration:
+- Dependency validation
+- Feature detection
+- Installation checks
+
+For public RQ utilities, use `django_cfg.apps.integrations.rq` directly.
+"""
+
+from .dependencies import (
+    DependencyChecker,
+    RQDependencyError,
+    check_rq_available,
+    check_rq_dependencies,
+    print_dependency_status,
+    require_rq_feature,
+)
+
+__all__ = [
+    "DependencyChecker",
+    "RQDependencyError",
+    "check_rq_available",
+    "check_rq_dependencies",
+    "print_dependency_status",
+    "require_rq_feature",
+]