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

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

@@ -0,0 +1,101 @@
+"""
+Centrifugo Token API
+
+Provides endpoint for generating Centrifugo JWT tokens with user permissions.
+"""
+
+import logging
+
+from drf_spectacular.utils import extend_schema
+from pydantic import BaseModel, Field
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+
+from ..services import generate_centrifugo_token
+
+logger = logging.getLogger(__name__)
+
+
+# ========================================================================
+# Response Models
+# ========================================================================
+
+
+class ConnectionTokenResponse(BaseModel):
+    """Response model for Centrifugo connection token."""
+
+    token: str = Field(..., description="JWT token for Centrifugo connection")
+    centrifugo_url: str = Field(..., description="Centrifugo WebSocket URL")
+    expires_at: str = Field(..., description="Token expiration time (ISO 8601)")
+    channels: list[str] = Field(..., description="List of allowed channels")
+
+
+class CentrifugoTokenViewSet(viewsets.ViewSet):
+    """
+    Centrifugo Token API ViewSet.
+
+    Provides endpoint for authenticated users to get Centrifugo JWT token
+    with their allowed channels based on permissions.
+    """
+
+    permission_classes = [IsAuthenticated]
+
+    @extend_schema(
+        tags=["Centrifugo Auth"],
+        summary="Get Centrifugo connection token",
+        description=(
+            "Generate JWT token for WebSocket connection to Centrifugo. "
+            "Token includes user's allowed channels based on their permissions. "
+            "Requires authentication."
+        ),
+        responses={
+            200: ConnectionTokenResponse,
+            401: {"description": "Unauthorized - authentication required"},
+            500: {"description": "Server error"},
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="token")
+    def get_token(self, request):
+        """
+        Get Centrifugo connection token for authenticated user.
+
+        Returns JWT token with user's allowed channels that can be used
+        to connect to Centrifugo WebSocket.
+        """
+        try:
+            user = request.user
+
+            # Generate token with user's channels
+            token_data = generate_centrifugo_token(user)
+
+            logger.debug(
+                f"Generated Centrifugo token for user {user.email} (ID: {user.id}) "
+                f"with {len(token_data['channels'])} channels: {token_data['channels']}"
+            )
+
+            # Format expires_at as ISO 8601 string
+            return Response({
+                "token": token_data["token"],
+                "centrifugo_url": token_data["centrifugo_url"],
+                "expires_at": token_data["expires_at"].isoformat() + "Z",
+                "channels": token_data["channels"],
+            })
+
+        except ValueError as e:
+            # Centrifugo not configured or disabled
+            logger.warning(f"Centrifugo token generation failed: {e}")
+            return Response(
+                {"error": str(e)},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+        except Exception as e:
+            logger.error(f"Failed to generate Centrifugo token: {e}", exc_info=True)
+            return Response(
+                {"error": "Failed to generate token"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+__all__ = ["CentrifugoTokenViewSet"]

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

@@ -0,0 +1,257 @@
+"""
+Centrifugo Wrapper API.
+
+Provides /api/publish endpoint that acts as a proxy to Centrifugo
+with ACK tracking and database logging.
+"""
+
+import asyncio
+import time
+import uuid
+from typing import Any, Dict
+
+import httpx
+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')
+class PublishWrapperView(View):
+    """
+    Centrifugo publish wrapper endpoint.
+
+    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
+    """
+
+    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
+
+    def post(self, request):
+        """
+        Handle POST /api/publish request.
+
+        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
+            result = asyncio.run(
+                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,
+            )
+
+    def __del__(self):
+        """Cleanup HTTP client on deletion."""
+        if self._http_client:
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    loop.create_task(self._http_client.aclose())
+                else:
+                    loop.run_until_complete(self._http_client.aclose())
+            except Exception:
+                pass
+
+
+__all__ = ["PublishWrapperView"]

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

@@ -0,0 +1,29 @@
+"""
+gRPC → Centrifugo Integration.
+
+Mixin and configuration for bridging gRPC streaming events to Centrifugo WebSocket.
+"""
+
+from .bridge import CentrifugoBridgeMixin
+from .config import ChannelConfig, CentrifugoChannels
+from .demo import (
+    DemoChannels,
+    DemoBridgeService,
+    test_complete_integration,
+    test_demo_service,
+    send_demo_event,
+)
+
+__all__ = [
+    # Core components
+    "CentrifugoBridgeMixin",
+    "ChannelConfig",
+    "CentrifugoChannels",
+
+    # Demo/testing
+    "DemoChannels",
+    "DemoBridgeService",
+    "test_complete_integration",
+    "test_demo_service",
+    "send_demo_event",
+]

django_cfg/apps/integrations/grpc/centrifugo/bridge.py

@@ -0,0 +1,277 @@
+"""
+Centrifugo Bridge Mixin for gRPC Services.
+
+Universal mixin that enables automatic publishing of gRPC stream events
+to Centrifugo WebSocket channels using Pydantic configuration.
+"""
+
+import logging
+import time
+from datetime import datetime, timezone as tz
+from typing import Dict, Optional, Any, TYPE_CHECKING
+
+from .config import CentrifugoChannels, ChannelConfig
+from .transformers import transform_protobuf_to_dict
+
+if TYPE_CHECKING:
+    from django_cfg.apps.integrations.centrifugo import CentrifugoClient
+
+logger = logging.getLogger(__name__)
+
+
+class CentrifugoBridgeMixin:
+    """
+    Universal mixin for publishing gRPC stream events to Centrifugo.
+
+    Uses Pydantic models for type-safe, validated configuration.
+
+    Features:
+    - Type-safe Pydantic configuration
+    - Automatic event publishing to WebSocket channels
+    - Built-in protobuf → JSON transformation
+    - Graceful degradation if Centrifugo unavailable
+    - Custom transform functions support
+    - Template-based channel naming
+    - Per-channel rate limiting
+    - Critical event bypassing
+
+    Usage:
+        ```python
+        from django_cfg.apps.integrations.grpc.mixins import (
+            CentrifugoBridgeMixin,
+            CentrifugoChannels,
+            ChannelConfig,
+        )
+
+        class BotChannels(CentrifugoChannels):
+            heartbeat: ChannelConfig = ChannelConfig(
+                template='bot#{bot_id}#heartbeat',
+                rate_limit=0.1
+            )
+            status: ChannelConfig = ChannelConfig(
+                template='bot#{bot_id}#status',
+                critical=True
+            )
+
+        class BotStreamingService(
+            bot_streaming_service_pb2_grpc.BotStreamingServiceServicer,
+            CentrifugoBridgeMixin
+        ):
+            centrifugo_channels = BotChannels()
+
+            async def ConnectBot(self, request_iterator, context):
+                async for message in request_iterator:
+                    # Your business logic
+                    await self._handle_message(bot_id, message)
+
+                    # Auto-publish to Centrifugo (1 line!)
+                    await self._notify_centrifugo(message, bot_id=bot_id)
+        ```
+    """
+
+    # Class-level Pydantic config (optional, can be set in __init__)
+    centrifugo_channels: Optional[CentrifugoChannels] = None
+
+    def __init__(self):
+        """Initialize Centrifugo bridge from Pydantic configuration."""
+        super().__init__()
+
+        # Instance attributes
+        self._centrifugo_enabled: bool = False
+        self._centrifugo_graceful: bool = True
+        self._centrifugo_client: Optional['CentrifugoClient'] = None
+        self._centrifugo_mappings: Dict[str, Dict[str, Any]] = {}
+        self._centrifugo_last_publish: Dict[str, float] = {}
+
+        # Auto-setup if config exists
+        if self.centrifugo_channels:
+            self._setup_from_pydantic_config(self.centrifugo_channels)
+
+    def _setup_from_pydantic_config(self, config: CentrifugoChannels):
+        """
+        Setup Centrifugo bridge from Pydantic configuration.
+
+        Args:
+            config: CentrifugoChannels instance with channel mappings
+        """
+        self._centrifugo_enabled = config.enabled
+        self._centrifugo_graceful = config.graceful_degradation
+
+        # Extract channel mappings
+        for field_name, channel_config in config.get_channel_mappings().items():
+            if channel_config.enabled:
+                self._centrifugo_mappings[field_name] = {
+                    'template': channel_config.template,
+                    'rate_limit': channel_config.rate_limit or config.default_rate_limit,
+                    'critical': channel_config.critical,
+                    'transform': channel_config.transform,
+                    'metadata': channel_config.metadata,
+                }
+
+        # Initialize client if enabled
+        if self._centrifugo_enabled and self._centrifugo_mappings:
+            self._initialize_centrifugo_client()
+
+    def _initialize_centrifugo_client(self):
+        """Lazy initialize Centrifugo client."""
+        try:
+            from django_cfg.apps.integrations.centrifugo import get_centrifugo_client
+            self._centrifugo_client = get_centrifugo_client()
+            logger.info(
+                f"✅ Centrifugo bridge enabled with {len(self._centrifugo_mappings)} channels"
+            )
+        except Exception as e:
+            logger.warning(f"⚠️ Centrifugo client not available: {e}")
+            if not self._centrifugo_graceful:
+                raise
+            self._centrifugo_enabled = False
+
+    async def _notify_centrifugo(
+        self,
+        message: Any,  # Protobuf message
+        **context: Any  # Template variables for channel rendering
+    ) -> bool:
+        """
+        Publish protobuf message to Centrifugo based on configured mappings.
+
+        Automatically detects which field is set in the message and publishes
+        to the corresponding channel.
+
+        Args:
+            message: Protobuf message (e.g., BotMessage with heartbeat/status/etc.)
+            **context: Template variables for channel name rendering
+                Example: bot_id='123', user_id='456'
+
+        Returns:
+            True if published successfully, False otherwise
+
+        Example:
+            ```python
+            # message = BotMessage with heartbeat field set
+            await self._notify_centrifugo(message, bot_id='bot-123')
+            # → Publishes to channel: bot#bot-123#heartbeat
+            ```
+        """
+        if not self._centrifugo_enabled or not self._centrifugo_client:
+            return False
+
+        # Check each mapped field
+        for field_name, mapping in self._centrifugo_mappings.items():
+            if message.HasField(field_name):
+                return await self._publish_field(
+                    field_name,
+                    message,
+                    mapping,
+                    context
+                )
+
+        return False
+
+    async def _publish_field(
+        self,
+        field_name: str,
+        message: Any,
+        mapping: Dict[str, Any],
+        context: dict
+    ) -> bool:
+        """
+        Publish specific message field to Centrifugo.
+
+        Args:
+            field_name: Name of the protobuf field
+            message: Full protobuf message
+            mapping: Channel mapping configuration
+            context: Template variables
+
+        Returns:
+            True if published successfully
+        """
+        try:
+            # Render channel from template
+            channel = mapping['template'].format(**context)
+
+            # Rate limiting check (unless critical)
+            if not mapping['critical'] and mapping['rate_limit']:
+                now = time.time()
+                last = self._centrifugo_last_publish.get(channel, 0)
+                if now - last < mapping['rate_limit']:
+                    logger.debug(f"⏱️ Rate limit: skipping {field_name} for {channel}")
+                    return False
+                self._centrifugo_last_publish[channel] = now
+
+            # Get field value
+            field_value = getattr(message, field_name)
+
+            # Transform to dict
+            data = self._transform_field(field_name, field_value, mapping, context)
+
+            # Publish to Centrifugo
+            await self._centrifugo_client.publish(
+                channel=channel,
+                data=data
+            )
+
+            logger.debug(f"✅ Published {field_name} to {channel}")
+            return True
+
+        except KeyError as e:
+            logger.error(
+                f"❌ Missing template variable in channel: {e}. "
+                f"Template: {mapping['template']}, Context: {context}"
+            )
+            return False
+
+        except Exception as e:
+            logger.error(
+                f"❌ Failed to publish {field_name} to Centrifugo: {e}",
+                exc_info=True
+            )
+            if not self._centrifugo_graceful:
+                raise
+            return False
+
+    def _transform_field(
+        self,
+        field_name: str,
+        field_value: Any,
+        mapping: Dict[str, Any],
+        context: dict
+    ) -> dict:
+        """
+        Transform protobuf field to JSON-serializable dict.
+
+        Args:
+            field_name: Field name
+            field_value: Protobuf message field value
+            mapping: Channel mapping with optional transform function
+            context: Template context variables
+
+        Returns:
+            JSON-serializable dictionary
+        """
+        # Use custom transform if provided
+        if mapping['transform']:
+            data = mapping['transform'](field_name, field_value)
+        else:
+            # Default protobuf → dict transform
+            data = transform_protobuf_to_dict(field_value)
+
+        # Add metadata
+        data['type'] = field_name
+        data['timestamp'] = datetime.now(tz.utc).isoformat()
+
+        # Merge channel metadata
+        if mapping['metadata']:
+            for key, value in mapping['metadata'].items():
+                if key not in data:
+                    data[key] = value
+
+        # Add context variables (bot_id, user_id, etc.)
+        for key, value in context.items():
+            if key not in data:
+                data[key] = value
+
+        return data
+
+
+__all__ = ["CentrifugoBridgeMixin"]