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

django_cfg/apps/integrations/centrifugo/views/wrapper.py

@@ -0,0 +1,259 @@
+"""
+Centrifugo Wrapper API.
+
+Provides /api/publish endpoint that acts as a proxy to Centrifugo
+with ACK tracking and database logging.
+"""
+
+import time
+import uuid
+from typing import Any, Dict
+
+import httpx
+from django.db import transaction
+from django.http import JsonResponse
+from django.utils.decorators import method_decorator
+from django.views import View
+from django.views.decorators.csrf import csrf_exempt
+from django_cfg.modules.django_logging import get_logger
+from pydantic import BaseModel, Field
+
+from ..services import get_centrifugo_config
+from ..services.logging import CentrifugoLogger
+
+logger = get_logger("centrifugo.wrapper")
+
+
+# ========================================================================
+# Request/Response Models
+# ========================================================================
+
+
+class PublishRequest(BaseModel):
+    """Request model for publish endpoint."""
+
+    channel: str = Field(..., description="Target channel name")
+    data: Dict[str, Any] = Field(..., description="Message data")
+    wait_for_ack: bool = Field(default=False, description="Wait for client ACK")
+    ack_timeout: int = Field(default=10, description="ACK timeout in seconds")
+    message_id: str | None = Field(default=None, description="Optional message ID")
+
+
+class PublishResponse(BaseModel):
+    """Response model for publish endpoint."""
+
+    published: bool = Field(..., description="Whether message was published")
+    message_id: str = Field(..., description="Unique message ID")
+    channel: str = Field(..., description="Target channel")
+    delivered: bool = Field(default=False, description="Whether message was delivered")
+    acks_received: int = Field(default=0, description="Number of ACKs received")
+
+
+# ========================================================================
+# Wrapper View
+# ========================================================================
+
+
+@method_decorator(csrf_exempt, name='dispatch')
+@method_decorator(transaction.non_atomic_requests, name='dispatch')
+class PublishWrapperView(View):
+    """
+    Centrifugo publish wrapper endpoint (ASYNC).
+
+    Provides /api/publish endpoint that:
+    - Accepts publish requests from CentrifugoClient
+    - Logs to database (CentrifugoLog)
+    - Proxies to Centrifugo HTTP API
+    - Returns publish result with ACK tracking
+
+    NOTE: This is an async view for proper async/await handling.
+    Using asyncio.run() in sync views causes event loop conflicts.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._http_client = None
+
+    @property
+    def http_client(self) -> httpx.AsyncClient:
+        """Get or create HTTP client for Centrifugo API calls."""
+        if self._http_client is None:
+            config = get_centrifugo_config()
+            if not config:
+                raise ValueError("Centrifugo not configured")
+
+            headers = {"Content-Type": "application/json"}
+
+            # Add Centrifugo API key for server-to-server auth
+            if config.centrifugo_api_key:
+                headers["Authorization"] = f"apikey {config.centrifugo_api_key}"
+
+            # Use Centrifugo API URL (not wrapper URL)
+            base_url = config.centrifugo_api_url.rstrip("/api").rstrip("/")
+
+            self._http_client = httpx.AsyncClient(
+                base_url=base_url,
+                headers=headers,
+                timeout=httpx.Timeout(config.http_timeout),
+                verify=config.verify_ssl,
+            )
+
+        return self._http_client
+
+    async def _publish_to_centrifugo(
+        self, channel: str, data: Dict[str, Any], wait_for_ack: bool, ack_timeout: int, message_id: str
+    ) -> Dict[str, Any]:
+        """
+        Publish message to Centrifugo API.
+
+        Args:
+            channel: Target channel
+            data: Message data
+            wait_for_ack: Whether to wait for ACK
+            ack_timeout: ACK timeout in seconds
+            message_id: Message ID
+
+        Returns:
+            Publish result dict
+        """
+        start_time = time.time()
+
+        # Create log entry
+        log_entry = await CentrifugoLogger.create_log_async(
+            message_id=message_id,
+            channel=channel,
+            data=data,
+            wait_for_ack=wait_for_ack,
+            ack_timeout=ack_timeout if wait_for_ack else None,
+            is_notification=True,
+            user=None,  # Can extract from request if needed
+        )
+
+        try:
+            # Centrifugo API format: POST /api with method in body
+            payload = {
+                "method": "publish",
+                "params": {
+                    "channel": channel,
+                    "data": data,
+                },
+            }
+
+            response = await self.http_client.post("/api", json=payload)
+            response.raise_for_status()
+            result = response.json()
+
+            # Check for Centrifugo error
+            if "error" in result and result["error"]:
+                raise Exception(f"Centrifugo error: {result['error']}")
+
+            # Calculate duration
+            duration_ms = int((time.time() - start_time) * 1000)
+
+            # Mark as success
+            if log_entry:
+                await CentrifugoLogger.mark_success_async(
+                    log_entry,
+                    acks_received=0,  # ACK tracking would be implemented separately
+                    duration_ms=duration_ms,
+                )
+
+            # Return wrapper-compatible response
+            return {
+                "published": True,
+                "message_id": message_id,
+                "channel": channel,
+                "acks_received": 0,
+                "delivered": True,  # Centrifugo confirms publish, not delivery
+            }
+
+        except Exception as e:
+            # Calculate duration
+            duration_ms = int((time.time() - start_time) * 1000)
+
+            # Mark as failed
+            if log_entry:
+                from asgiref.sync import sync_to_async
+                from ..models import CentrifugoLog
+
+                await sync_to_async(CentrifugoLog.objects.mark_failed)(
+                    log_instance=log_entry,
+                    error_code=type(e).__name__,
+                    error_message=str(e),
+                    duration_ms=duration_ms,
+                )
+
+            raise
+
+    async def post(self, request):
+        """
+        Handle POST /api/publish request (ASYNC).
+
+        Request body:
+            {
+                "channel": "test#demo",
+                "data": {"key": "value"},
+                "wait_for_ack": false,
+                "ack_timeout": 10,
+                "message_id": "optional-uuid"
+            }
+
+        Response:
+            {
+                "published": true,
+                "message_id": "uuid",
+                "channel": "test#demo",
+                "delivered": true,
+                "acks_received": 0
+            }
+        """
+        try:
+            import json
+
+            # Parse request body
+            body = json.loads(request.body)
+            req_data = PublishRequest(**body)
+
+            # Generate message ID if not provided
+            message_id = req_data.message_id or str(uuid.uuid4())
+
+            # Publish to Centrifugo (ASYNC - no asyncio.run()!)
+            result = await self._publish_to_centrifugo(
+                channel=req_data.channel,
+                data=req_data.data,
+                wait_for_ack=req_data.wait_for_ack,
+                ack_timeout=req_data.ack_timeout,
+                message_id=message_id,
+            )
+
+            response = PublishResponse(**result)
+            return JsonResponse(response.model_dump(), status=200)
+
+        except Exception as e:
+            logger.error(f"Failed to publish via wrapper: {e}", exc_info=True)
+            return JsonResponse(
+                {
+                    "published": False,
+                    "message_id": "",
+                    "channel": body.get("channel", "") if "body" in locals() else "",
+                    "delivered": False,
+                    "acks_received": 0,
+                    "error": str(e),
+                },
+                status=500,
+            )
+
+    async def cleanup(self):
+        """
+        Explicit async cleanup method for HTTP client.
+
+        Note: Django handles View lifecycle automatically.
+        This method is provided for explicit cleanup if needed,
+        but httpx.AsyncClient will be garbage collected normally.
+        """
+        if self._http_client:
+            await self._http_client.aclose()
+            self._http_client = None
+
+
+__all__ = ["PublishWrapperView"]

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

@@ -170,10 +170,11 @@ class ApiKeyAuthInterceptor(grpc.aio.ServerInterceptor):
             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()
-                )
+                # Django 5.2: Native async ORM
+                superuser = await User.objects.filter(
+                    is_superuser=True, is_active=True
+                ).afirst()
+
                 if superuser:
                     return superuser, None
                 else:
@@ -187,14 +188,14 @@ class ApiKeyAuthInterceptor(grpc.aio.ServerInterceptor):
         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()
-            )
+            # Django 5.2: Native async ORM
+            api_key_obj = await GrpcApiKey.objects.filter(
+                key=api_key, is_active=True
+            ).afirst()
 
             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)
+                # Update usage tracking (async method call)
+                await api_key_obj.amark_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:

django_cfg/apps/integrations/grpc/management/commands/compile_proto.py

@@ -0,0 +1,105 @@
+"""
+Django management command to compile .proto files to Python.
+
+Usage:
+    # Compile single proto file
+    python manage.py compile_proto path/to/file.proto
+
+    # Compile with custom output directory
+    python manage.py compile_proto path/to/file.proto --output-dir generated/
+
+    # Auto-fix imports (change 'import X' to 'from . import X')
+    python manage.py compile_proto path/to/file.proto --fix-imports
+
+    # Compile all proto files in a directory
+    python manage.py compile_proto path/to/protos/ --recursive
+"""
+
+import logging
+from pathlib import Path
+
+from django.core.management.base import BaseCommand, CommandError
+
+from django_cfg.apps.integrations.grpc.management.proto.compiler import ProtoCompiler
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Compile .proto files to Python using grpc_tools.protoc"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "proto_path",
+            type=str,
+            help="Path to .proto file or directory containing .proto files",
+        )
+        parser.add_argument(
+            "--output-dir",
+            type=str,
+            default=None,
+            help="Output directory for generated files (default: same as proto file)",
+        )
+        parser.add_argument(
+            "--proto-path",
+            type=str,
+            default=None,
+            help="Additional proto import path (passed to protoc -I flag)",
+        )
+        parser.add_argument(
+            "--fix-imports",
+            action="store_true",
+            default=True,
+            help="Fix imports in generated _grpc.py files (default: True)",
+        )
+        parser.add_argument(
+            "--no-fix-imports",
+            action="store_false",
+            dest="fix_imports",
+            help="Disable import fixing",
+        )
+        parser.add_argument(
+            "--recursive",
+            action="store_true",
+            help="Recursively compile all .proto files in directory",
+        )
+
+    def handle(self, *args, **options):
+        proto_path = Path(options["proto_path"])
+        output_dir = Path(options["output_dir"]) if options["output_dir"] else None
+        proto_import_path = Path(options["proto_path"]) if options.get("proto_path") else None
+        fix_imports = options["fix_imports"]
+        recursive = options["recursive"]
+
+        if not proto_path.exists():
+            raise CommandError(f"Path does not exist: {proto_path}")
+
+        # Create compiler
+        compiler = ProtoCompiler(
+            output_dir=output_dir,
+            proto_import_path=proto_import_path,
+            fix_imports=fix_imports,
+            verbose=True,
+        )
+
+        self.stdout.write("")
+
+        # Compile proto file(s)
+        if proto_path.is_file():
+            success = compiler.compile_file(proto_path)
+            if not success:
+                raise CommandError(f"Failed to compile {proto_path}")
+        else:
+            success_count, failure_count = compiler.compile_directory(
+                proto_path,
+                recursive=recursive,
+            )
+
+            if failure_count > 0:
+                raise CommandError(
+                    f"Failed to compile {failure_count} proto file(s) "
+                    f"({success_count} succeeded)"
+                )
+
+        self.stdout.write("")
+        self.stdout.write(self.style.SUCCESS("🎉 Done! All proto files compiled successfully."))

django_cfg/apps/integrations/grpc/management/commands/generate_protos.py

@@ -36,10 +36,21 @@ class Command(AdminCommand):
             default=None,
             help="Custom output directory (overrides config)",
         )
+        parser.add_argument(
+            "--compile",
+            action="store_true",
+            help="Automatically compile generated .proto files to Python",
+        )
+        parser.add_argument(
+            "--no-fix-imports",
+            action="store_false",
+            dest="fix_imports",
+            help="Disable import fixing when compiling (only with --compile)",
+        )
 
     def handle(self, *args, **options):
         from django_cfg.apps.integrations.grpc.utils.proto_gen import generate_proto_for_app
-        from django_cfg.apps.integrations.grpc.services.config_helper import get_grpc_config
+        from django_cfg.apps.integrations.grpc.services.management.config_helper import get_grpc_config
 
         # Get gRPC config
         grpc_config = get_grpc_config()
@@ -123,8 +134,52 @@ class Command(AdminCommand):
                     f"📂 Output directory: {output_location}"
                 )
             )
+
+            # Compile proto files if requested
+            if options["compile"]:
+                self.stdout.write("\n" + "=" * 70)
+                self.stdout.write(self.style.SUCCESS("🔧 Compiling generated proto files..."))
+                self._compile_protos(output_location, options.get("fix_imports", True))
         else:
             self.stdout.write(
                 self.style.WARNING("⚠️  No proto files generated")
             )
         self.stdout.write("=" * 70)
+
+    def _compile_protos(self, output_dir, fix_imports: bool):
+        """Compile all .proto files in output directory."""
+        from pathlib import Path
+        from django_cfg.apps.integrations.grpc.management.proto.compiler import ProtoCompiler
+
+        output_path = Path(output_dir)
+        if not output_path.exists():
+            self.stdout.write(self.style.ERROR(f"   ❌ Output directory not found: {output_dir}"))
+            return
+
+        # Create compiler
+        compiler = ProtoCompiler(
+            output_dir=output_path / "generated",  # Compile to generated/ subdirectory
+            proto_import_path=output_path,
+            fix_imports=fix_imports,
+            verbose=True,
+        )
+
+        # Compile all proto files
+        success_count, failure_count = compiler.compile_directory(
+            output_path,
+            recursive=False,
+        )
+
+        if failure_count > 0:
+            self.stdout.write(
+                self.style.ERROR(
+                    f"   ❌ Failed to compile {failure_count} proto file(s) "
+                    f"({success_count} succeeded)"
+                )
+            )
+        else:
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"   ✅ Compiled {success_count} proto file(s) successfully"
+                )
+            )