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

django_cfg/apps/integrations/grpc/admin/grpc_server_status.py

@@ -0,0 +1,236 @@
+"""
+gRPC Server Status Admin.
+
+PydanticAdmin for GRPCServerStatus model with server monitoring and lifecycle tracking.
+"""
+
+from django.contrib import admin
+from django_cfg.modules.django_admin import Icons, computed_field
+from django_cfg.modules.django_admin.base import PydanticAdmin
+
+from ..models import GRPCServerStatus
+from .config import grpcserverstatus_config
+
+
+@admin.register(GRPCServerStatus)
+class GRPCServerStatusAdmin(PydanticAdmin):
+    """
+    Admin interface for gRPC server status monitoring.
+
+    Features:
+    - Real-time server status indicators
+    - Uptime tracking and display
+    - Process information (PID, hostname)
+    - Service registration details
+    - Error tracking and display
+    """
+
+    config = grpcserverstatus_config
+
+    @computed_field("Uptime", ordering="started_at")
+    def uptime_display(self, obj):
+        """Display server uptime with performance indicator."""
+        uptime_text = obj.uptime_display
+
+        if not obj.is_running:
+            return self.html.badge(
+                uptime_text,
+                variant="secondary",
+                icon=Icons.SCHEDULE
+            )
+
+        # Color code based on uptime
+        uptime_seconds = obj.uptime_seconds
+        if uptime_seconds > 86400:  # > 1 day
+            variant = "success"
+            icon = Icons.CHECK_CIRCLE
+        elif uptime_seconds > 3600:  # > 1 hour
+            variant = "info"
+            icon = Icons.TIMER
+        else:  # < 1 hour
+            variant = "warning"
+            icon = Icons.SCHEDULE
+
+        return self.html.badge(uptime_text, variant=variant, icon=icon)
+
+    def server_config_display(self, obj):
+        """Display server configuration details."""
+        return self.html.breakdown(
+            self.html.key_value(
+                "Address",
+                self.html.badge(obj.address, variant="info", icon=Icons.CLOUD)
+            ),
+            self.html.key_value(
+                "Host",
+                self.html.code(obj.host)
+            ),
+            self.html.key_value(
+                "Port",
+                self.html.text(str(obj.port), variant="primary")
+            ),
+            self.html.key_value(
+                "Max Workers",
+                self.html.badge(str(obj.max_workers), variant="secondary", icon=Icons.SETTINGS)
+            ),
+            self.html.key_value(
+                "Reflection",
+                self.html.badge(
+                    "Enabled" if obj.enable_reflection else "Disabled",
+                    variant="success" if obj.enable_reflection else "secondary",
+                    icon=Icons.VISIBILITY if obj.enable_reflection else Icons.VISIBILITY_OFF
+                )
+            ),
+            self.html.key_value(
+                "Health Check",
+                self.html.badge(
+                    "Enabled" if obj.enable_health_check else "Disabled",
+                    variant="success" if obj.enable_health_check else "secondary",
+                    icon=Icons.HEALTH_AND_SAFETY if obj.enable_health_check else Icons.CANCEL
+                )
+            ),
+        )
+
+    server_config_display.short_description = "Server Configuration"
+
+    def process_info_display(self, obj):
+        """Display process information."""
+        return self.html.breakdown(
+            self.html.key_value(
+                "Instance ID",
+                self.html.code(obj.instance_id)
+            ),
+            self.html.key_value(
+                "PID",
+                self.html.badge(str(obj.pid), variant="info", icon=Icons.MEMORY)
+            ),
+            self.html.key_value(
+                "Hostname",
+                self.html.text(obj.hostname, variant="secondary")
+            ),
+            self.html.key_value(
+                "Running",
+                self.html.badge(
+                    "Yes" if obj.is_running else "No",
+                    variant="success" if obj.is_running else "danger",
+                    icon=Icons.CHECK_CIRCLE if obj.is_running else Icons.CANCEL
+                )
+            ),
+        )
+
+    process_info_display.short_description = "Process Information"
+
+    def registered_services_display(self, obj):
+        """Display registered services."""
+        if not obj.registered_services:
+            return self.html.empty("No services registered")
+
+        import json
+        try:
+            formatted = json.dumps(obj.registered_services, indent=2)
+            return self.html.code_block(formatted, language="json", max_height="400px")
+        except Exception:
+            return self.html.code(str(obj.registered_services))
+
+    registered_services_display.short_description = "Registered Services"
+
+    def error_display(self, obj):
+        """Display error information if status is ERROR."""
+        if obj.status != "error" or not obj.error_message:
+            return self.html.inline(
+                self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
+                self.html.text("No errors", variant="success"),
+                separator=" "
+            )
+
+        return self.html.breakdown(
+            self.html.key_value(
+                "Error Message",
+                self.html.text(obj.error_message, variant="danger")
+            ),
+            self.html.key_value(
+                "Stopped At",
+                self.html.text(
+                    obj.stopped_at.strftime("%Y-%m-%d %H:%M:%S") if obj.stopped_at else "N/A",
+                    variant="secondary"
+                )
+            ),
+        )
+
+    error_display.short_description = "Error Details"
+
+    def lifecycle_display(self, obj):
+        """Display server lifecycle timestamps."""
+        return self.html.breakdown(
+            self.html.key_value(
+                "Started",
+                self.html.text(
+                    obj.started_at.strftime("%Y-%m-%d %H:%M:%S"),
+                    variant="success"
+                )
+            ),
+            self.html.key_value(
+                "Last Heartbeat",
+                self.html.text(
+                    obj.last_heartbeat.strftime("%Y-%m-%d %H:%M:%S"),
+                    variant="info"
+                )
+            ) if obj.last_heartbeat else None,
+            self.html.key_value(
+                "Stopped",
+                self.html.text(
+                    obj.stopped_at.strftime("%Y-%m-%d %H:%M:%S"),
+                    variant="danger"
+                )
+            ) if obj.stopped_at else None,
+            self.html.key_value(
+                "Uptime",
+                self.html.badge(obj.uptime_display, variant="primary", icon=Icons.TIMER)
+            ),
+        )
+
+    lifecycle_display.short_description = "Lifecycle"
+
+    # Fieldsets for detail view
+    def get_fieldsets(self, request, obj=None):
+        """Dynamic fieldsets based on object state."""
+        fieldsets = [
+            (
+                "Server Identity",
+                {"fields": ("id", "instance_id", "address", "status")},
+            ),
+            (
+                "Configuration",
+                {"fields": ("server_config_display", "host", "port", "max_workers", "enable_reflection", "enable_health_check")},
+            ),
+            (
+                "Process Information",
+                {"fields": ("process_info_display", "pid", "hostname", "is_running")},
+            ),
+            (
+                "Lifecycle",
+                {"fields": ("lifecycle_display", "started_at", "last_heartbeat", "stopped_at", "uptime_display")},
+            ),
+        ]
+
+        # Add registered services section if available
+        if obj and obj.registered_services:
+            fieldsets.append(
+                (
+                    "Registered Services",
+                    {"fields": ("registered_services_display",), "classes": ("collapse",)},
+                )
+            )
+
+        # Add error section only if status is ERROR
+        if obj and obj.status == "error":
+            fieldsets.append(
+                (
+                    "Error Details",
+                    {"fields": ("error_display", "error_message")},
+                )
+            )
+
+        return fieldsets
+
+
+__all__ = ["GRPCServerStatusAdmin"]

django_cfg/apps/integrations/grpc/apps.py

@@ -0,0 +1,108 @@
+"""
+Django app configuration for gRPC integration.
+"""
+
+from __future__ import annotations
+
+import os
+
+from django.apps import AppConfig
+
+
+class GRPCAppConfig(AppConfig):
+    """
+    Django app config for gRPC integration.
+
+    Provides:
+    - gRPC server with Django ORM integration
+    - JWT authentication
+    - Request logging to database
+    - Admin interface for monitoring
+    - REST API for metrics
+    """
+
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_cfg.apps.integrations.grpc'
+    verbose_name = 'gRPC Integration'
+
+    def ready(self):
+        """
+        Called when Django starts.
+
+        Validates that all required gRPC dependencies are installed.
+        """
+        # Only check dependencies if we're running a command that needs gRPC
+        # (avoid breaking migrations, shell, etc.)
+        self._check_dependencies_if_needed()
+
+        # Import signal handlers if needed
+        # from . import signals
+
+    def _check_dependencies_if_needed(self):
+        """
+        Check gRPC dependencies only when running gRPC-related commands.
+
+        Skips check for:
+        - Migrations (makemigrations, migrate)
+        - Shell commands (shell, shell_plus)
+        - Test discovery (test --help)
+        - Django checks (check)
+        - Management command listing (help)
+        """
+        import sys
+
+        # Get command name from sys.argv
+        if len(sys.argv) < 2:
+            return
+
+        command = sys.argv[1]
+
+        # Commands that don't need gRPC dependencies
+        skip_commands = [
+            'makemigrations',
+            'migrate',
+            'shell',
+            'shell_plus',
+            'check',
+            'help',
+            'test',
+            'collectstatic',
+            'createsuperuser',
+            'changepassword',
+            'showmigrations',
+            'sqlmigrate',
+            'inspectdb',
+        ]
+
+        # Skip check for these commands
+        if command in skip_commands:
+            return
+
+        # Also skip if running tests (pytest, nose, etc.)
+        if 'test' in sys.argv or 'pytest' in sys.argv[0]:
+            return
+
+        # Skip if DJANGO_SKIP_GRPC_CHECK environment variable is set
+        if os.environ.get('DJANGO_SKIP_GRPC_CHECK', '').lower() in ('1', 'true', 'yes'):
+            return
+
+        # For 'rungrpc' command, perform strict check
+        if command == 'rungrpc':
+            from ._cfg import check_grpc_dependencies
+            try:
+                check_grpc_dependencies(raise_on_missing=True)
+            except Exception as e:
+                # Print error and exit
+                print(str(e))
+                sys.exit(1)
+
+        # For other commands, perform silent check (just import validation)
+        # This ensures basic imports work but doesn't block the command
+        else:
+            from ._cfg import check_grpc_dependencies
+            try:
+                # Silent check - only validates that checker itself works
+                check_grpc_dependencies(raise_on_missing=False)
+            except Exception:
+                # Silently ignore - don't break other commands
+                pass

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

@@ -0,0 +1,17 @@
+"""
+gRPC authentication components.
+
+Provides API key authentication for gRPC services.
+"""
+
+from .api_key_auth import (
+    ApiKeyAuthInterceptor,
+    get_current_grpc_user,
+    get_current_grpc_api_key,
+)
+
+__all__ = [
+    "ApiKeyAuthInterceptor",
+    "get_current_grpc_user",
+    "get_current_grpc_api_key",
+]

django_cfg/apps/integrations/grpc/auth/api_key_auth.py

@@ -0,0 +1,320 @@
+"""
+API Key Authentication Interceptor for gRPC.
+
+Handles API key verification and Django user authentication for gRPC requests.
+Simple, secure, and manageable through Django admin.
+"""
+
+import asyncio
+import contextvars
+import logging
+from typing import Callable, Optional
+
+import grpc
+import grpc.aio
+from django.conf import settings
+from django.contrib.auth import get_user_model
+
+logger = logging.getLogger(__name__)
+
+User = get_user_model()
+
+# Context variables for passing user/api_key between async interceptors
+_grpc_user_var: contextvars.ContextVar = contextvars.ContextVar('grpc_user', default=None)
+_grpc_api_key_var: contextvars.ContextVar = contextvars.ContextVar('grpc_api_key', default=None)
+
+
+class ApiKeyAuthInterceptor(grpc.aio.ServerInterceptor):
+    """
+    gRPC interceptor for API key authentication.
+
+    Features:
+    - Validates API keys from database (GrpcApiKey model)
+    - Accepts Django SECRET_KEY for development/internal use
+    - Loads Django user from API key
+    - Sets user on request context
+    - Supports public methods whitelist
+    - Tracks API key usage
+    - Handles authentication errors gracefully
+
+    Example:
+        ```python
+        # In Django settings (auto-configured by django-cfg)
+        GRPC_FRAMEWORK = {
+            "SERVER_INTERCEPTORS": [
+                "django_cfg.apps.integrations.grpc.auth.ApiKeyAuthInterceptor",
+            ]
+        }
+        ```
+
+    API Key Format:
+        x-api-key: <api_key_string>
+
+    Or for SECRET_KEY:
+        x-api-key: <Django SECRET_KEY>
+    """
+
+    def __init__(self):
+        """Initialize API key authentication interceptor."""
+        self.grpc_auth_config = getattr(settings, "GRPC_AUTH", {})
+        self.enabled = self.grpc_auth_config.get("enabled", True)
+        self.require_auth = self.grpc_auth_config.get("require_auth", False)
+
+        # API Key settings
+        self.api_key_header = self.grpc_auth_config.get("api_key_header", "x-api-key")
+        self.accept_django_secret_key = self.grpc_auth_config.get(
+            "accept_django_secret_key", True
+        )
+
+        # Public methods (don't require auth)
+        self.public_methods = self.grpc_auth_config.get("public_methods", [
+            "/grpc.health.v1.Health/Check",
+            "/grpc.health.v1.Health/Watch",
+            "/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
+        ])
+
+    async def intercept_service(
+        self,
+        continuation: Callable,
+        handler_call_details: grpc.HandlerCallDetails
+    ) -> grpc.RpcMethodHandler:
+        """
+        Intercept gRPC service call for authentication (async).
+
+        Args:
+            continuation: Function to invoke the next interceptor or handler
+            handler_call_details: Details about the RPC call
+
+        Returns:
+            RPC method handler (possibly wrapped with auth)
+        """
+        # Skip if auth is disabled
+        if not self.enabled:
+            return await continuation(handler_call_details)
+
+        # Check if method is public
+        method_name = handler_call_details.method
+        if method_name in self.public_methods:
+            logger.debug(f"Public method accessed: {method_name}")
+            return await continuation(handler_call_details)
+
+        # Extract API key from metadata
+        api_key = self._extract_api_key(handler_call_details.invocation_metadata)
+
+        # If no API key provided
+        if not api_key:
+            if self.require_auth:
+                logger.warning(f"Missing API key for {method_name}")
+                return self._abort_unauthenticated("API key is required")
+            else:
+                # Allow anonymous access (no user/api_key in context)
+                logger.debug(f"No API key provided for {method_name}, allowing anonymous access")
+                return await continuation(handler_call_details)
+
+        # Verify API key and get user + api_key instance (async)
+        user, api_key_instance = await self._verify_api_key(api_key)
+
+        # If API key is valid, ALWAYS set user and api_key in context (even if require_auth=False)
+        if user:
+            logger.debug(f"Authenticated user {user.id} ({user.username}) for {method_name}")
+            return await self._continue_with_user(continuation, handler_call_details, user, api_key_instance)
+
+        # API key provided but invalid
+        if self.require_auth:
+            logger.warning(f"Invalid API key for {method_name}")
+            return self._abort_unauthenticated("Invalid or expired API key")
+        else:
+            # Allow anonymous access even with invalid key
+            logger.debug(f"Invalid API key for {method_name}, allowing anonymous access")
+            return await continuation(handler_call_details)
+
+    def _extract_api_key(self, metadata: tuple) -> Optional[str]:
+        """
+        Extract API key from gRPC metadata.
+
+        Args:
+            metadata: gRPC invocation metadata
+
+        Returns:
+            API key string or None
+        """
+        if not metadata:
+            return None
+
+        # Convert metadata to dict (case-insensitive lookup)
+        metadata_dict = dict(metadata)
+
+        # Get API key header (case-insensitive)
+        for key, value in metadata_dict.items():
+            if key.lower() == self.api_key_header.lower():
+                return value
+
+        return None
+
+    async def _verify_api_key(self, api_key: str) -> tuple[Optional[User], Optional["GrpcApiKey"]]:
+        """
+        Verify API key and return user and api_key instance (async).
+
+        Checks:
+        1. Django SECRET_KEY (if enabled)
+        2. GrpcApiKey model in database
+
+        Args:
+            api_key: API key string
+
+        Returns:
+            Tuple of (Django User instance or None, GrpcApiKey instance or None)
+        """
+        # Check if it's Django SECRET_KEY
+        if self.accept_django_secret_key and api_key == settings.SECRET_KEY:
+            logger.debug("API key matches Django SECRET_KEY")
+            # For SECRET_KEY, return first superuser or None (no api_key instance)
+            try:
+                # Wrap Django ORM in asyncio.to_thread()
+                superuser = await asyncio.to_thread(
+                    lambda: User.objects.filter(is_superuser=True, is_active=True).first()
+                )
+                if superuser:
+                    return superuser, None
+                else:
+                    logger.warning("No active superuser found for SECRET_KEY authentication")
+                    return None, None
+            except Exception as e:
+                logger.error(f"Error loading superuser for SECRET_KEY: {e}")
+                return None, None
+
+        # Check API key in database
+        try:
+            from django_cfg.apps.integrations.grpc.models import GrpcApiKey
+
+            # Wrap Django ORM in asyncio.to_thread()
+            api_key_obj = await asyncio.to_thread(
+                lambda: GrpcApiKey.objects.filter(key=api_key, is_active=True).first()
+            )
+
+            if api_key_obj and api_key_obj.is_valid:
+                # Update usage tracking (also wrapped in to_thread)
+                await asyncio.to_thread(api_key_obj.mark_used)
+                logger.debug(f"Valid API key for user {api_key_obj.user.id} ({api_key_obj.user.username})")
+                return api_key_obj.user, api_key_obj
+            else:
+                logger.debug("API key not found or invalid in database")
+                return None, None
+
+        except Exception as e:
+            logger.error(f"Error validating API key: {e}")
+            return None, None
+
+    async def _continue_with_user(
+        self,
+        continuation: Callable,
+        handler_call_details: grpc.HandlerCallDetails,
+        user: User,
+        api_key_instance: Optional["GrpcApiKey"] = None,
+    ) -> grpc.RpcMethodHandler:
+        """
+        Continue RPC with authenticated user and api_key in context (async).
+
+        Args:
+            continuation: Function to invoke next interceptor or handler
+            handler_call_details: Details about the RPC call
+            user: Authenticated Django user
+            api_key_instance: GrpcApiKey instance used for authentication (if applicable)
+
+        Returns:
+            RPC method handler with user and api_key context
+        """
+        # Get the handler (await because continuation is async)
+        handler = await continuation(handler_call_details)
+
+        if handler is None:
+            return None
+
+        # Wrap the handler to inject user and api_key into contextvars (not context directly)
+        # All wrappers must be async for grpc.aio
+        async def wrapped_unary_unary(request, context):
+            # Set context variables for async context
+            _grpc_user_var.set(user)
+            _grpc_api_key_var.set(api_key_instance)
+            logger.info(f"[Auth] Set contextvar api_key = {api_key_instance} (user={user})")
+            return await handler.unary_unary(request, context)
+
+        async def wrapped_unary_stream(request, context):
+            # Set context variables for async context
+            _grpc_user_var.set(user)
+            _grpc_api_key_var.set(api_key_instance)
+            logger.info(f"[Auth] Set contextvar api_key = {api_key_instance} (user={user})")
+            async for response in handler.unary_stream(request, context):
+                yield response
+
+        async def wrapped_stream_unary(request_iterator, context):
+            # Set context variables for async context
+            _grpc_user_var.set(user)
+            _grpc_api_key_var.set(api_key_instance)
+            return await handler.stream_unary(request_iterator, context)
+
+        async def wrapped_stream_stream(request_iterator, context):
+            # Set context variables for async context
+            _grpc_user_var.set(user)
+            _grpc_api_key_var.set(api_key_instance)
+            async for response in handler.stream_stream(request_iterator, context):
+                yield response
+
+        # Return wrapped handler based on type
+        return grpc.unary_unary_rpc_method_handler(
+            wrapped_unary_unary,
+            request_deserializer=handler.request_deserializer,
+            response_serializer=handler.response_serializer,
+        ) if handler.unary_unary else (
+            grpc.unary_stream_rpc_method_handler(
+                wrapped_unary_stream,
+                request_deserializer=handler.request_deserializer,
+                response_serializer=handler.response_serializer,
+            ) if handler.unary_stream else (
+                grpc.stream_unary_rpc_method_handler(
+                    wrapped_stream_unary,
+                    request_deserializer=handler.request_deserializer,
+                    response_serializer=handler.response_serializer,
+                ) if handler.stream_unary else (
+                    grpc.stream_stream_rpc_method_handler(
+                        wrapped_stream_stream,
+                        request_deserializer=handler.request_deserializer,
+                        response_serializer=handler.response_serializer,
+                    ) if handler.stream_stream else None
+                )
+            )
+        )
+
+    def _abort_unauthenticated(self, message: str) -> grpc.RpcMethodHandler:
+        """
+        Return handler that aborts with UNAUTHENTICATED status.
+
+        Args:
+            message: Error message
+
+        Returns:
+            RPC method handler that aborts
+        """
+        def abort(*args, **kwargs):
+            context = args[1] if len(args) > 1 else None
+            if context:
+                context.abort(grpc.StatusCode.UNAUTHENTICATED, message)
+
+        return grpc.unary_unary_rpc_method_handler(
+            abort,
+            request_deserializer=lambda x: x,
+            response_serializer=lambda x: x,
+        )
+
+
+__all__ = ["ApiKeyAuthInterceptor", "get_current_grpc_user", "get_current_grpc_api_key"]
+
+
+def get_current_grpc_user():
+    """Get current gRPC user from context variables (async-safe)."""
+    return _grpc_user_var.get()
+
+
+def get_current_grpc_api_key():
+    """Get current gRPC API key from context variables (async-safe)."""
+    return _grpc_api_key_var.get()

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

@@ -0,0 +1,19 @@
+"""
+gRPC interceptors for logging, metrics, and error handling.
+
+Provides production-ready interceptors for gRPC services.
+"""
+
+from .errors import ErrorHandlingInterceptor
+from .logging import LoggingInterceptor
+from .metrics import MetricsInterceptor, get_metrics, reset_metrics
+from .request_logger import RequestLoggerInterceptor
+
+__all__ = [
+    "LoggingInterceptor",
+    "MetricsInterceptor",
+    "ErrorHandlingInterceptor",
+    "RequestLoggerInterceptor",
+    "get_metrics",
+    "reset_metrics",
+]