django-cfg 1.5.8__py3-none-any.whl → 1.5.20__py3-none-any.whl

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

@@ -0,0 +1,268 @@
+"""
+Proto Files Manager Service.
+
+Handles proto file operations: scanning, reading, generating, archiving.
+"""
+
+import io
+import zipfile
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from django.conf import settings
+from django_cfg.modules.django_logging import get_logger
+
+from .config_helper import get_grpc_config
+
+logger = get_logger("grpc.proto_files_manager")
+
+
+class ProtoFilesManager:
+    """
+    Service for managing proto files.
+
+    Handles:
+    - Scanning proto directory
+    - Reading proto files
+    - Generating proto files from Django models
+    - Creating zip archives
+    """
+
+    def __init__(self):
+        """Initialize proto files manager."""
+        self.grpc_config = get_grpc_config()
+
+    def get_proto_dir(self) -> Path:
+        """
+        Get proto files directory path.
+
+        Returns:
+            Path to proto files directory
+        """
+        if self.grpc_config and self.grpc_config.proto and self.grpc_config.proto.output_dir:
+            proto_dir = Path(settings.BASE_DIR) / self.grpc_config.proto.output_dir
+        else:
+            proto_dir = Path(settings.MEDIA_ROOT) / "protos"
+
+        return proto_dir
+
+    def scan_proto_files(self, request=None) -> List[Dict]:
+        """
+        Scan proto directory and return list of proto files with metadata.
+
+        Args:
+            request: Optional Django request object for building download URLs
+
+        Returns:
+            List of dicts with proto file metadata:
+            {
+                "app_label": str,
+                "filename": str,
+                "size_bytes": int,
+                "package": str,
+                "messages_count": int,
+                "services_count": int,
+                "created_at": float,
+                "modified_at": float,
+                "download_url": str (if request provided),
+            }
+        """
+        proto_dir = self.get_proto_dir()
+
+        if not proto_dir.exists():
+            logger.warning(f"Proto directory does not exist: {proto_dir}")
+            return []
+
+        proto_files = []
+        for proto_file in proto_dir.glob("*.proto"):
+            try:
+                metadata = self._parse_proto_file(proto_file)
+                if metadata:
+                    # Add download URL if request provided
+                    if request:
+                        from django.urls import reverse
+                        from django_cfg.core.state import get_current_config
+
+                        app_label = metadata['app_label']
+                        config = get_current_config()
+
+                        # Use api_url from config (respects HTTPS behind reverse proxy)
+                        # Falls back to request.build_absolute_uri if config not available
+                        if config and hasattr(config, 'api_url'):
+                            path = reverse('django_cfg_grpc:proto-files-detail', kwargs={'pk': app_label})
+                            download_url = f"{config.api_url}{path}"
+                        else:
+                            download_url = request.build_absolute_uri(
+                                reverse('django_cfg_grpc:proto-files-detail', kwargs={'pk': app_label})
+                            )
+
+                        metadata['download_url'] = download_url
+
+                    proto_files.append(metadata)
+            except Exception as e:
+                logger.error(f"Error reading proto file {proto_file}: {e}")
+                continue
+
+        return proto_files
+
+    def _parse_proto_file(self, proto_file: Path) -> Optional[Dict]:
+        """
+        Parse proto file and extract metadata.
+
+        Args:
+            proto_file: Path to proto file
+
+        Returns:
+            Dict with proto file metadata or None if failed
+        """
+        try:
+            stat = proto_file.stat()
+            content = proto_file.read_text()
+
+            # Parse proto file for metadata
+            package = ""
+            messages_count = 0
+            services_count = 0
+
+            for line in content.split("\n"):
+                line = line.strip()
+                if line.startswith("package "):
+                    package = line.replace("package ", "").replace(";", "").strip()
+                elif line.startswith("message "):
+                    messages_count += 1
+                elif line.startswith("service "):
+                    services_count += 1
+
+            # Extract app_label from filename (crypto.proto -> crypto)
+            app_label = proto_file.stem
+
+            return {
+                "app_label": app_label,
+                "filename": proto_file.name,
+                "size_bytes": stat.st_size,
+                "package": package,
+                "messages_count": messages_count,
+                "services_count": services_count,
+                "created_at": stat.st_ctime,
+                "modified_at": stat.st_mtime,
+            }
+
+        except Exception as e:
+            logger.error(f"Error parsing proto file {proto_file}: {e}")
+            return None
+
+    def get_proto_file(self, app_label: str) -> Optional[Path]:
+        """
+        Get path to proto file for specific app.
+
+        Args:
+            app_label: App label (e.g., 'crypto')
+
+        Returns:
+            Path to proto file or None if not found
+        """
+        proto_dir = self.get_proto_dir()
+        proto_file = proto_dir / f"{app_label}.proto"
+
+        if proto_file.exists():
+            return proto_file
+
+        logger.warning(f"Proto file not found for app '{app_label}'")
+        return None
+
+    def create_zip_archive(self) -> Optional[bytes]:
+        """
+        Create zip archive with all proto files.
+
+        Returns:
+            Zip archive bytes or None if failed
+        """
+        proto_dir = self.get_proto_dir()
+
+        if not proto_dir.exists():
+            logger.error(f"Proto directory does not exist: {proto_dir}")
+            return None
+
+        try:
+            # Create zip in memory
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+                proto_files = list(proto_dir.glob("*.proto"))
+
+                if not proto_files:
+                    logger.warning("No proto files found to archive")
+                    return None
+
+                for proto_file in proto_files:
+                    zip_file.write(proto_file, arcname=proto_file.name)
+                    logger.debug(f"Added to archive: {proto_file.name}")
+
+            zip_buffer.seek(0)
+            return zip_buffer.read()
+
+        except Exception as e:
+            logger.error(f"Error creating zip archive: {e}", exc_info=True)
+            return None
+
+    def generate_protos(self, apps: Optional[List[str]] = None, force: bool = False) -> Dict:
+        """
+        Generate proto files for specified apps.
+
+        Args:
+            apps: List of app labels (uses enabled_apps from config if None)
+            force: Force regeneration even if proto file exists
+
+        Returns:
+            Dict with generation results:
+            {
+                "status": "success" | "failed",
+                "generated": List[str],  # Successfully generated app labels
+                "generated_count": int,
+                "errors": List[Dict],  # Errors for failed apps
+            }
+        """
+        from ..utils.proto_gen import generate_proto_for_app
+
+        # Determine which apps to generate for
+        if not apps:
+            if self.grpc_config and self.grpc_config.enabled_apps:
+                apps = self.grpc_config.enabled_apps
+            else:
+                logger.error("No apps specified and no enabled_apps in config")
+                return {
+                    "status": "failed",
+                    "generated": [],
+                    "generated_count": 0,
+                    "errors": [{"app": "N/A", "error": "No apps specified"}],
+                }
+
+        generated = []
+        errors = []
+
+        for app_label in apps:
+            try:
+                logger.info(f"Generating proto for app: {app_label}")
+                count = generate_proto_for_app(app_label)
+
+                if count > 0:
+                    generated.append(app_label)
+                    logger.info(f"Successfully generated proto for {app_label}")
+                else:
+                    error_msg = "No models found"
+                    logger.warning(f"No models found in app {app_label}")
+                    errors.append({"app": app_label, "error": error_msg})
+
+            except Exception as e:
+                error_msg = str(e)
+                logger.error(f"Proto generation error for {app_label}: {error_msg}", exc_info=True)
+                errors.append({"app": app_label, "error": error_msg})
+
+        return {
+            "status": "success" if generated else "failed",
+            "generated": generated,
+            "generated_count": len(generated),
+            "errors": errors,
+        }
+
+
+__all__ = ["ProtoFilesManager"]

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

@@ -11,11 +11,6 @@ from django.db import models
 from django.db.models import Avg, Count
 
 from ..models import GRPCRequestLog, GRPCServerStatus
-from ..serializers.service_registry import (
-    MethodStatsSerializer,
-    MethodSummarySerializer,
-    ServiceSummarySerializer,
-)
 from django_cfg.modules.django_logging import get_logger
 
 logger = get_logger("grpc.service_registry")
@@ -52,7 +47,10 @@ class ServiceRegistryManager:
 
     def get_all_services(self) -> List[Dict]:
         """
-        Get all registered services from the running gRPC server.
+        Get all registered services.
+
+        Returns services from running server if available,
+        otherwise discovers services from filesystem.
 
         Returns:
             List of service metadata dictionaries
@@ -66,11 +64,16 @@ class ServiceRegistryManager:
             'apps.CryptoService'
         """
         current_server = self.get_current_server()
-        if not current_server:
-            logger.debug("No running gRPC server found")
-            return []
 
-        return current_server.registered_services or []
+        # 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]:
         """
@@ -183,23 +186,23 @@ class ServiceRegistryManager:
             # Extract package name
             package = service_name.split(".")[0] if "." in service_name else ""
 
-            # Validate and serialize data
-            service_summary = ServiceSummarySerializer(
-                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=(
+            # 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.model_dump())
+            services_with_stats.append(service_summary)
 
         return services_with_stats
 
@@ -257,30 +260,29 @@ class ServiceRegistryManager:
             successful = stats["successful"] or 0
             success_rate = (successful / total * 100) if total > 0 else 0.0
 
-            # Create stats object first
-            method_stats = MethodStatsSerializer(
-                service_name=service_name,
-                method_name=method_name,
-                total=total,
-                successful=successful,
-                errors=stats["errors"] or 0,
-                avg_duration_ms=round(stats["avg_duration"] or 0, 2),
-                p50_duration_ms=p50,
-                p95_duration_ms=p95,
-                p99_duration_ms=p99,
-            )
-
-            # Validate and serialize method with stats
-            method_summary = MethodSummarySerializer(
-                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.model_dump())
+            # 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
 

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

@@ -11,11 +11,6 @@ from django.db.models import Count
 from django_cfg.modules.django_logging import get_logger
 
 from ..models import GRPCRequestLog
-from ..serializers.testing import (
-    GRPCCallResponseSerializer,
-    GRPCExampleSerializer,
-    GRPCTestLogSerializer,
-)
 from ..testing import get_example
 from .service_registry import ServiceRegistryManager
 
@@ -75,18 +70,18 @@ class TestingService:
                 # Get example from registry
                 example_data = get_example(service_name, method_name)
                 if example_data:
-                    # Validate and serialize
-                    example = GRPCExampleSerializer(
-                        service=service_name,
-                        method=method_name,
-                        description=example_data.get(
+                    # Build dict directly
+                    example = {
+                        "service": service_name,
+                        "method": method_name,
+                        "description": example_data.get(
                             "description", f"{method_name} method"
                         ),
-                        request_example=example_data.get("request", {}),
-                        response_example=example_data.get("response", {}),
-                        notes=example_data.get("notes", ""),
-                    )
-                    examples.append(example.model_dump())
+                        "payload_example": example_data.get("request", {}),
+                        "expected_response": example_data.get("response", {}),
+                        "metadata_example": example_data.get("metadata", {}),
+                    }
+                    examples.append(example)
 
         return examples
 

django_cfg/apps/integrations/grpc/urls.py

@@ -7,9 +7,11 @@ Public API endpoints for gRPC monitoring.
 from django.urls import include, path
 from rest_framework import routers
 
+from .views.api_keys import GRPCApiKeyViewSet
 from .views.charts import GRPCChartsViewSet
 from .views.config import GRPCConfigViewSet
 from .views.monitoring import GRPCMonitorViewSet
+from .views.proto_files import GRPCProtoFilesViewSet
 from .views.services import GRPCServiceViewSet
 from .views.testing import GRPCTestingViewSet
 
@@ -33,6 +35,12 @@ router.register(r'test', GRPCTestingViewSet, basename='test')
 # Charts endpoints (statistics visualization)
 router.register(r'charts', GRPCChartsViewSet, basename='charts')
 
+# API Keys endpoints (read-only)
+router.register(r'api-keys', GRPCApiKeyViewSet, basename='api-keys')
+
+# Proto Files endpoints (download proto files)
+router.register(r'proto-files', GRPCProtoFilesViewSet, basename='proto-files')
+
 urlpatterns = [
     # Include router URLs
     path('', include(router.urls)),

django_cfg/apps/integrations/grpc/utils/SERVER_LOGGING.md

@@ -0,0 +1,164 @@
+# Server Lifecycle Logging Utilities
+
+Reusable functions for logging server startup and shutdown with timestamps and uptime tracking.
+
+**Uses Rich** for beautiful output with panels, tables, and colors! 🎨
+
+## 📦 Functions
+
+### `log_server_start()`
+
+Logs server startup with timestamp and configuration.
+
+```python
+from django_cfg.apps.integrations.grpc.utils import log_server_start
+
+start_time = log_server_start(
+    logger,
+    server_type="gRPC Server",       # Server type
+    mode="Development",               # Production/Development
+    hotreload_enabled=True,           # Is hotreload enabled?
+    host="0.0.0.0",                   # Additional parameters
+    port=50051
+)
+```
+
+**Output (Rich Panel):**
+```
+╭────────────── 🚀 gRPC Server Starting ───────────────╮
+│                                                      │
+│  ⏰ Started at    2025-11-05 14:30:15               │
+│  Mode            Development                        │
+│  Hotreload       Enabled ⚡                          │
+│  Host            0.0.0.0                            │
+│  Port            50051                              │
+│                                                      │
+╰──────────────────────────────────────────────────────╯
+⚠️  Hotreload active - connections may be dropped on code changes
+```
+(with green border and colors!)
+
+**Returns:** `datetime` object of start time (for use in `log_server_shutdown`)
+
+---
+
+### `log_server_shutdown()`
+
+Logs server shutdown with uptime calculation.
+
+```python
+from django_cfg.apps.integrations.grpc.utils import log_server_shutdown
+
+log_server_shutdown(
+    logger,
+    start_time,                       # datetime from log_server_start()
+    server_type="gRPC Server",
+    reason="Hotreload triggered",     # Shutdown reason
+    active_connections=5              # Additional parameters
+)
+```
+
+**Output (Rich Panel):**
+```
+╭───────────── 🧹 Shutting down gRPC Server ──────────────╮
+│                                                          │
+│  📋 Reason            Hotreload triggered               │
+│  ⏱️  Uptime            0h 2m 35s                         │
+│  🕐 Stopped at        2025-11-05 14:32:50               │
+│  Active Connections  5                                  │
+│                                                          │
+╰──────────────────────────────────────────────────────────╯
+✅ Server shutdown complete
+```
+(with red border and colors!)
+
+---
+
+## 🎯 Complete Usage Example
+
+```python
+from django_cfg.apps.integrations.grpc.utils import (
+    setup_streaming_logger,
+    log_server_start,
+    log_server_shutdown,
+)
+
+# Create logger
+logger = setup_streaming_logger('my_server')
+
+# Log server start
+start_time = log_server_start(
+    logger,
+    server_type="WebSocket Server",
+    mode="Production",
+    hotreload_enabled=False,
+    host="0.0.0.0",
+    port=8000
+)
+
+try:
+    # Server work...
+    await server.serve_forever()
+    shutdown_reason = "Normal termination"
+except KeyboardInterrupt:
+    shutdown_reason = "Keyboard interrupt"
+finally:
+    # Log server shutdown
+    log_server_shutdown(
+        logger,
+        start_time,
+        server_type="WebSocket Server",
+        reason=shutdown_reason,
+        total_connections=1250
+    )
+```
+
+---
+
+## 📊 Used in:
+
+- ✅ `rungrpc` - gRPC server command
+- ✅ Can be used for any servers (WebSocket, HTTP, etc.)
+
+---
+
+## 🔧 Parameters
+
+### `log_server_start()`
+
+| Parameter | Type | Required | Description |
+|----------|-----|----------|-------------|
+| `logger` | `logging.Logger` | ✅ Yes | Logger instance |
+| `server_type` | `str` | ❌ No | Server type (default: "Server") |
+| `mode` | `str` | ❌ No | Running mode (default: "Development") |
+| `hotreload_enabled` | `bool` | ❌ No | Is hotreload enabled (default: False) |
+| `use_rich` | `bool` | ❌ No | Use Rich for output (default: True) |
+| `**extra_info` | `dict` | ❌ No | Additional key-value pairs to log |
+
+### `log_server_shutdown()`
+
+| Parameter | Type | Required | Description |
+|----------|-----|----------|-------------|
+| `logger` | `logging.Logger` | ✅ Yes | Logger instance |
+| `start_time` | `datetime` | ✅ Yes | Start time from `log_server_start()` |
+| `server_type` | `str` | ❌ No | Server type (default: "Server") |
+| `reason` | `str` | ❌ No | Shutdown reason |
+| `use_rich` | `bool` | ❌ No | Use Rich for output (default: True) |
+| `**extra_info` | `dict` | ❌ No | Additional key-value pairs to log |
+
+---
+
+## 💡 Benefits
+
+1. ✅ **DRY** - single code for all servers
+2. ✅ **Consistency** - uniform log format
+3. ✅ **Rich UI** - beautiful panels, tables, colors 🎨
+4. ✅ **Uptime tracking** - automatic time calculation
+5. ✅ **Flexible** - can add arbitrary parameters via `**extra_info`
+6. ✅ **Hotreload aware** - special warning for hotreload mode
+7. ✅ **Fallback** - works without Rich (if `use_rich=False`)
+
+---
+
+**Author:** django-cfg team
+**Date:** 2025-11-05

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

@@ -1,18 +1,9 @@
 """
-gRPC utilities.
+Utilities for gRPC Integration.
 
-Provides proto generation and other helper utilities for gRPC integration.
-
-Note:
-    For dependency checking, use `django_cfg.apps.integrations.grpc._cfg` instead.
-    This module focuses on user-facing utilities like proto generation.
+Reusable utilities for gRPC services in django-cfg.
 """
 
-from .proto_gen import ProtoFieldMapper, ProtoGenerator, generate_proto_for_app
+from .streaming_logger import setup_streaming_logger, get_streaming_logger
 
-__all__ = [
-    # Proto generation
-    "ProtoFieldMapper",
-    "ProtoGenerator",
-    "generate_proto_for_app",
-]
+__all__ = ["setup_streaming_logger", "get_streaming_logger"]