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

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

@@ -0,0 +1,330 @@
+"""
+Service Registry Manager.
+
+Provides business logic for accessing and managing registered gRPC services.
+Acts as a bridge between the running gRPC server and the REST API.
+"""
+
+from typing import Dict, List, Optional
+
+from django.db import models
+from django.db.models import Avg, Count
+
+from ..models import GRPCRequestLog, GRPCServerStatus
+from django_cfg.modules.django_logging import get_logger
+
+logger = get_logger("grpc.service_registry")
+
+
+class ServiceRegistryManager:
+    """
+    Manager for accessing registered gRPC services.
+
+    This class provides methods to retrieve service metadata from the running
+    gRPC server instance stored in the database.
+
+    Example:
+        >>> manager = ServiceRegistryManager()
+        >>> services = manager.get_all_services()
+        >>> service = manager.get_service_by_name("apps.CryptoService")
+    """
+
+    def get_current_server(self) -> Optional[GRPCServerStatus]:
+        """
+        Get the currently running gRPC server instance.
+
+        Returns:
+            GRPCServerStatus instance if server is running, None otherwise
+        """
+        try:
+            current_server = GRPCServerStatus.objects.get_current_server()
+            if current_server and current_server.is_running:
+                return current_server
+            return None
+        except Exception as e:
+            logger.error(f"Error getting current server: {e}", exc_info=True)
+            return None
+
+    def get_all_services(self) -> List[Dict]:
+        """
+        Get all registered services.
+
+        Returns services from running server if available,
+        otherwise discovers services from filesystem.
+
+        Returns:
+            List of service metadata dictionaries
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> services = manager.get_all_services()
+            >>> len(services)
+            1
+            >>> services[0]['name']
+            'apps.CryptoService'
+        """
+        current_server = self.get_current_server()
+
+        # If server is running, use its registered services
+        if current_server and current_server.registered_services:
+            return current_server.registered_services
+
+        # Otherwise, discover services from filesystem
+        logger.debug("Server not running - discovering services from filesystem")
+        from .discovery import ServiceDiscovery
+        discovery = ServiceDiscovery()
+        return discovery.get_registered_services()
+
+    def get_service_by_name(self, service_name: str) -> Optional[Dict]:
+        """
+        Get service metadata by service name.
+
+        Args:
+            service_name: Full service name (e.g., "apps.CryptoService")
+
+        Returns:
+            Service metadata dictionary or None if not found
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> service = manager.get_service_by_name("apps.CryptoService")
+            >>> service['name']
+            'apps.CryptoService'
+            >>> service['methods']
+            ['GetCoin', 'ListCoins', ...]
+        """
+        services = self.get_all_services()
+        return next((s for s in services if s.get("name") == service_name), None)
+
+    def get_service_statistics(
+        self, service_name: str, hours: int = 24
+    ) -> Dict:
+        """
+        Get statistics for a specific service.
+
+        Args:
+            service_name: Service name
+            hours: Statistics period in hours (default: 24)
+
+        Returns:
+            Dictionary with service statistics
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> stats = manager.get_service_statistics("apps.CryptoService", hours=24)
+            >>> stats['total']
+            150
+            >>> stats['successful']
+            145
+            >>> stats['success_rate']
+            96.67
+        """
+        stats = (
+            GRPCRequestLog.objects.filter(service_name=service_name)
+            .recent(hours)
+            .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"),
+            )
+        )
+
+        total = stats["total"] or 0
+        successful = stats["successful"] or 0
+        success_rate = (successful / total * 100) if total > 0 else 0.0
+
+        return {
+            "total": total,
+            "successful": successful,
+            "errors": stats["errors"] or 0,
+            "success_rate": round(success_rate, 2),
+            "avg_duration_ms": round(stats["avg_duration"] or 0, 2),
+        }
+
+    def get_all_services_with_stats(self, hours: int = 24) -> List[Dict]:
+        """
+        Get all services with their statistics.
+
+        Args:
+            hours: Statistics period in hours (default: 24)
+
+        Returns:
+            List of services with statistics
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> services = manager.get_all_services_with_stats(hours=24)
+            >>> services[0]['name']
+            'apps.CryptoService'
+            >>> services[0]['total_requests']
+            150
+        """
+        services = self.get_all_services()
+        services_with_stats = []
+
+        for service in services:
+            service_name = service.get("name")
+
+            # Get stats from GRPCRequestLog
+            stats = (
+                GRPCRequestLog.objects.filter(service_name=service_name)
+                .recent(hours)
+                .aggregate(
+                    total=Count("id"),
+                    successful=Count("id", filter=models.Q(status="success")),
+                    avg_duration=Avg("duration_ms"),
+                    last_activity=models.Max("created_at"),
+                )
+            )
+
+            # Calculate success rate
+            total = stats["total"] or 0
+            successful = stats["successful"] or 0
+            success_rate = (successful / total * 100) if total > 0 else 0.0
+
+            # Extract package name
+            package = service_name.split(".")[0] if "." in service_name else ""
+
+            # Build dict directly
+            service_summary = {
+                "name": service_name,
+                "full_name": service.get("full_name", f"/{service_name}"),
+                "package": package,
+                "methods_count": len(service.get("methods", [])),
+                "total_requests": total,
+                "success_rate": round(success_rate, 2),
+                "avg_duration_ms": round(stats["avg_duration"] or 0, 2),
+                "last_activity_at": (
+                    stats["last_activity"].isoformat()
+                    if stats["last_activity"]
+                    else None
+                ),
+            }
+
+            services_with_stats.append(service_summary)
+
+        return services_with_stats
+
+    def get_service_methods_with_stats(
+        self, service_name: str
+    ) -> List[Dict]:
+        """
+        Get all methods for a service with statistics.
+
+        Args:
+            service_name: Service name
+
+        Returns:
+            List of methods with statistics
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> methods = manager.get_service_methods_with_stats("apps.CryptoService")
+            >>> methods[0]['name']
+            'GetCoin'
+            >>> methods[0]['stats']['total_requests']
+            50
+        """
+        service = self.get_service_by_name(service_name)
+        if not service:
+            return []
+
+        methods_list = []
+        for method_name in service.get("methods", []):
+            # Get durations for percentile calculation
+            durations = list(
+                GRPCRequestLog.objects.filter(
+                    service_name=service_name,
+                    method_name=method_name,
+                    duration_ms__isnull=False,
+                ).values_list("duration_ms", flat=True)
+            )
+
+            # Get aggregate stats
+            stats = GRPCRequestLog.objects.filter(
+                service_name=service_name,
+                method_name=method_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 percentiles
+            p50, p95, p99 = self._calculate_percentiles(durations)
+
+            # Calculate success rate
+            total = stats["total"] or 0
+            successful = stats["successful"] or 0
+            success_rate = (successful / total * 100) if total > 0 else 0.0
+
+            # Build method stats dict
+            method_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),
+                "p50_duration_ms": p50,
+                "p95_duration_ms": p95,
+                "p99_duration_ms": p99,
+            }
+
+            # Build method summary dict
+            method_summary = {
+                "name": method_name,
+                "full_name": f"/{service_name}/{method_name}",
+                "service_name": service_name,
+                "request_type": "",
+                "response_type": "",
+                "stats": method_stats,
+            }
+
+            methods_list.append(method_summary)
+
+        return methods_list
+
+    def _calculate_percentiles(self, values):
+        """
+        Calculate p50, p95, p99 percentiles.
+
+        Args:
+            values: List of numeric values
+
+        Returns:
+            Tuple of (p50, p95, p99)
+        """
+        if not values:
+            return 0.0, 0.0, 0.0
+
+        sorted_values = sorted(values)
+        n = len(sorted_values)
+
+        p50_idx = int(n * 0.50)
+        p95_idx = int(n * 0.95)
+        p99_idx = int(n * 0.99)
+
+        return (
+            float(sorted_values[p50_idx] if p50_idx < n else 0),
+            float(sorted_values[p95_idx] if p95_idx < n else 0),
+            float(sorted_values[p99_idx] if p99_idx < n else 0),
+        )
+
+    def is_server_running(self) -> bool:
+        """
+        Check if gRPC server is currently running.
+
+        Returns:
+            True if server is running, False otherwise
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> manager.is_server_running()
+            True
+        """
+        return self.get_current_server() is not None
+
+
+__all__ = ["ServiceRegistryManager"]

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

@@ -0,0 +1,321 @@
+"""
+Testing Service.
+
+Provides business logic for gRPC testing operations.
+"""
+
+from typing import Dict, List, Optional
+
+from django.db import models
+from django.db.models import Count
+from django_cfg.modules.django_logging import get_logger
+
+from ..models import GRPCRequestLog
+from ..testing import get_example
+from .service_registry import ServiceRegistryManager
+
+logger = get_logger("grpc.testing_service")
+
+
+class TestingService:
+    """
+    Service for gRPC testing operations.
+
+    Provides methods to retrieve test examples, logs, and execute test calls.
+    """
+
+    def __init__(self):
+        """Initialize testing service with registry manager."""
+        self.registry = ServiceRegistryManager()
+
+    def get_examples(
+        self,
+        service_filter: Optional[str] = None,
+        method_filter: Optional[str] = None,
+    ) -> List[Dict]:
+        """
+        Get example payloads for testing gRPC methods.
+
+        Args:
+            service_filter: Filter by service name
+            method_filter: Filter by method name
+
+        Returns:
+            List of example dictionaries
+
+        Example:
+            >>> service = TestingService()
+            >>> examples = service.get_examples(service_filter='CryptoService')
+            >>> examples[0]['method']
+            'GetCoin'
+        """
+        # Get registered services from service registry
+        services = self.registry.get_all_services()
+
+        examples = []
+        for service in services:
+            service_name = service.get("class_name", "")
+            if not service_name:
+                continue
+
+            # Filter by service if specified
+            if service_filter and service_name != service_filter:
+                continue
+
+            for method_name in service.get("methods", []):
+                # Filter by method if specified
+                if method_filter and method_name != method_filter:
+                    continue
+
+                # Get example from registry
+                example_data = get_example(service_name, method_name)
+                if example_data:
+                    # Build dict directly
+                    example = {
+                        "service": service_name,
+                        "method": method_name,
+                        "description": example_data.get(
+                            "description", f"{method_name} method"
+                        ),
+                        "payload_example": example_data.get("request", {}),
+                        "expected_response": example_data.get("response", {}),
+                        "metadata_example": example_data.get("metadata", {}),
+                    }
+                    examples.append(example)
+
+        return examples
+
+    def get_test_logs(
+        self,
+        service_filter: Optional[str] = None,
+        method_filter: Optional[str] = None,
+        status_filter: Optional[str] = None,
+    ):
+        """
+        Get test logs queryset for gRPC calls.
+
+        Args:
+            service_filter: Filter by service name
+            method_filter: Filter by method name
+            status_filter: Filter by status (success/error)
+
+        Returns:
+            Queryset of GRPCRequestLog (pagination handled by DRF)
+
+        Example:
+            >>> service = TestingService()
+            >>> queryset = service.get_test_logs(status_filter='error')
+            >>> queryset.count()
+            25
+        """
+        # Build queryset with filters
+        queryset = GRPCRequestLog.objects.all()
+
+        if service_filter:
+            queryset = queryset.filter(service_name__icontains=service_filter)
+        if method_filter:
+            queryset = queryset.filter(method_name__icontains=method_filter)
+        if status_filter:
+            queryset = queryset.filter(status=status_filter)
+
+        return queryset.order_by("-created_at")
+
+    def get_test_statistics(self) -> Dict:
+        """
+        Get overall test statistics.
+
+        Returns:
+            Dictionary with test statistics
+
+        Example:
+            >>> service = TestingService()
+            >>> stats = service.get_test_statistics()
+            >>> stats['total_tests']
+            1000
+        """
+        # Get overall stats
+        stats = GRPCRequestLog.objects.aggregate(
+            total_tests=Count("id"),
+            successful=Count("id", filter=models.Q(status="success")),
+            errors=Count("id", filter=models.Q(status="error")),
+        )
+
+        total = stats["total_tests"] or 0
+        successful = stats["successful"] or 0
+        success_rate = (successful / total * 100) if total > 0 else 0.0
+
+        return {
+            "total_tests": total,
+            "successful": successful,
+            "errors": stats["errors"] or 0,
+            "success_rate": round(success_rate, 2),
+        }
+
+    def call_method(
+        self,
+        service_name: str,
+        method_name: str,
+        request_data: Dict,
+        metadata: Optional[Dict] = None,
+        timeout: Optional[float] = None,
+    ) -> Dict:
+        """
+        Call a gRPC method for testing using dynamic invocation.
+
+        Args:
+            service_name: Service name (e.g., 'apps.CryptoService')
+            method_name: Method name (e.g., 'GetCoin')
+            request_data: Request payload as dictionary
+            metadata: Optional metadata (headers)
+            timeout: Timeout in seconds (default: 5.0)
+
+        Returns:
+            Dictionary with call result (to be wrapped by view layer):
+            {
+                'success': bool,
+                'service': str,
+                'method': str,
+                'duration_ms': int,
+                'grpc_status_code': str,
+                'response': dict (if success) or None,
+                'error_message': str (if error) or None,
+            }
+
+        Example:
+            >>> service = TestingService()
+            >>> response = service.call_method(
+            ...     service_name='apps.CryptoService',
+            ...     method_name='GetCoin',
+            ...     request_data={'symbol': 'BTC'},
+            ...     timeout=5.0
+            ... )
+            >>> response['success']
+            True
+            >>> response['response']
+            {'coin': {'symbol': 'BTC', 'price': 50000.0}}
+        """
+        import grpc
+        from time import time
+
+        from .grpc_client import DynamicGRPCClient
+        from .config_helper import get_grpc_server_config
+
+        # Get gRPC server config
+        grpc_config = get_grpc_server_config()
+        host = getattr(grpc_config, "host", "localhost")
+        port = getattr(grpc_config, "port", 50051)
+
+        # Set default timeout
+        if timeout is None:
+            timeout = 5.0
+
+        logger.info(f"Calling gRPC method: {service_name}.{method_name}")
+
+        start_time = time()
+
+        try:
+            # Create dynamic client and make the call
+            with DynamicGRPCClient(host=host, port=port) as client:
+                response_data = client.call_method(
+                    service_name=service_name,
+                    method_name=method_name,
+                    request_data=request_data,
+                    metadata=metadata,
+                    timeout=timeout,
+                )
+
+            end_time = time()
+            duration_ms = int((end_time - start_time) * 1000)
+
+            logger.info(
+                f"gRPC call successful: {service_name}.{method_name} " f"({duration_ms}ms)"
+            )
+
+            # Return success response (view layer will add request_id, status, timestamp)
+            return {
+                "success": True,
+                "service": service_name,
+                "method": method_name,
+                "duration_ms": duration_ms,
+                "grpc_status_code": "OK",
+                "response": response_data,
+                "error_message": None,
+            }
+
+        except grpc.RpcError as e:
+            # Handle gRPC errors
+            end_time = time()
+            duration_ms = int((end_time - start_time) * 1000)
+
+            logger.error(
+                f"gRPC call failed: {service_name}.{method_name} - "
+                f"{e.code()}: {e.details()} ({duration_ms}ms)"
+            )
+
+            return {
+                "success": False,
+                "service": service_name,
+                "method": method_name,
+                "duration_ms": duration_ms,
+                "grpc_status_code": e.code().name,
+                "response": None,
+                "error_message": e.details() or f"gRPC error: {e.code()}",
+            }
+
+        except ConnectionError as e:
+            # Handle connection errors
+            end_time = time()
+            duration_ms = int((end_time - start_time) * 1000)
+
+            logger.error(
+                f"Cannot connect to gRPC server: {host}:{port} - {e} ({duration_ms}ms)"
+            )
+
+            return {
+                "success": False,
+                "service": service_name,
+                "method": method_name,
+                "duration_ms": duration_ms,
+                "grpc_status_code": "UNAVAILABLE",
+                "response": None,
+                "error_message": f"Cannot connect to gRPC server: {e}",
+            }
+
+        except ValueError as e:
+            # Handle validation errors (service/method not found, invalid request data)
+            end_time = time()
+            duration_ms = int((end_time - start_time) * 1000)
+
+            logger.error(f"Validation error: {e} ({duration_ms}ms)")
+
+            return {
+                "success": False,
+                "service": service_name,
+                "method": method_name,
+                "duration_ms": duration_ms,
+                "grpc_status_code": "INVALID_ARGUMENT",
+                "response": None,
+                "error_message": str(e),
+            }
+
+        except Exception as e:
+            # Handle unexpected errors
+            end_time = time()
+            duration_ms = int((end_time - start_time) * 1000)
+
+            logger.error(
+                f"Unexpected error calling gRPC method: {e} ({duration_ms}ms)", exc_info=True
+            )
+
+            return {
+                "success": False,
+                "service": service_name,
+                "method": method_name,
+                "duration_ms": duration_ms,
+                "grpc_status_code": "INTERNAL",
+                "response": None,
+                "error_message": f"Internal error: {str(e)}",
+            }
+
+
+__all__ = ["TestingService"]

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

@@ -0,0 +1,12 @@
+"""
+Testing utilities for gRPC services.
+
+Provides example payloads and testing helpers for gRPC methods.
+"""
+
+from .examples import EXAMPLES_REGISTRY, get_example
+
+__all__ = [
+    "EXAMPLES_REGISTRY",
+    "get_example",
+]