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

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

@@ -2,10 +2,12 @@
 Models for gRPC app.
 """
 
+from .grpc_api_key import GrpcApiKey
 from .grpc_request_log import GRPCRequestLog
 from .grpc_server_status import GRPCServerStatus
 
 __all__ = [
+    "GrpcApiKey",
     "GRPCRequestLog",
     "GRPCServerStatus",
 ]

django_cfg/apps/integrations/grpc/models/grpc_api_key.py

@@ -0,0 +1,198 @@
+"""
+gRPC API Key Model.
+
+Django model for managing API keys used for gRPC authentication.
+Provides secure, revocable authentication for services and CLI tools.
+"""
+
+import secrets
+from django.conf import settings
+from django.db import models
+from django.utils import timezone
+
+
+def generate_api_key() -> str:
+    """
+    Generate a secure random API key.
+
+    Returns:
+        32-character hex string (128 bits of entropy)
+    """
+    return secrets.token_hex(32)
+
+
+class GrpcApiKey(models.Model):
+    """
+    API Key for gRPC authentication.
+
+    Provides secure, revocable authentication for:
+    - Service-to-service communication
+    - CLI tools and scripts
+    - Internal systems
+    - Development and testing
+
+    Features:
+    - Auto-generated secure keys
+    - User association for permissions
+    - Expiration support
+    - Usage tracking
+    - Easy revocation via admin
+
+    Example:
+        >>> # Create API key for a service
+        >>> key = GrpcApiKey.objects.create_for_user(
+        ...     user=admin_user,
+        ...     name="Analytics Service",
+        ...     description="Internal analytics microservice"
+        ... )
+        >>> print(key.key)  # Use this in service config
+
+        >>> # Check if key is valid
+        >>> if key.is_valid:
+        ...     user = key.user
+    """
+
+    # Custom manager
+    from ..managers.grpc_api_key import GrpcApiKeyManager
+    objects: GrpcApiKeyManager = GrpcApiKeyManager()
+
+    class KeyTypeChoices(models.TextChoices):
+        """Type of API key."""
+        SERVICE = "service", "Service-to-Service"
+        CLI = "cli", "CLI Tool"
+        WEBHOOK = "webhook", "Webhook"
+        INTERNAL = "internal", "Internal System"
+        DEVELOPMENT = "development", "Development"
+
+    # Identity
+    key = models.CharField(
+        max_length=64,
+        unique=True,
+        default=generate_api_key,
+        db_index=True,
+        help_text="API key (auto-generated)",
+    )
+
+    name = models.CharField(
+        max_length=255,
+        help_text="Descriptive name for this key (e.g., 'Analytics Service')",
+    )
+
+    description = models.TextField(
+        blank=True,
+        help_text="Additional details about this key's purpose",
+    )
+
+    key_type = models.CharField(
+        max_length=20,
+        choices=KeyTypeChoices.choices,
+        default=KeyTypeChoices.SERVICE,
+        help_text="Type of API key",
+    )
+
+    # User association
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="grpc_api_keys",
+        help_text="User this key authenticates as",
+    )
+
+    # Status
+    is_active = models.BooleanField(
+        default=True,
+        db_index=True,
+        help_text="Whether this key is currently active (can be used)",
+    )
+
+    # Expiration
+    expires_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        db_index=True,
+        help_text="When this key expires (null = never expires)",
+    )
+
+    # Usage tracking
+    last_used_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="When this key was last used",
+    )
+
+    request_count = models.IntegerField(
+        default=0,
+        help_text="Total number of requests made with this key",
+    )
+
+    # Metadata
+    created_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="created_grpc_api_keys",
+        help_text="User who created this key",
+    )
+
+    # Timestamps
+    created_at = models.DateTimeField(
+        auto_now_add=True,
+        db_index=True,
+        help_text="When this key was created",
+    )
+
+    updated_at = models.DateTimeField(
+        auto_now=True,
+        help_text="When this key was last updated",
+    )
+
+    class Meta:
+        db_table = "django_cfg_grpc_api_key"
+        ordering = ["-created_at"]
+        indexes = [
+            models.Index(fields=["user", "-created_at"]),
+            models.Index(fields=["is_active", "-created_at"]),
+            models.Index(fields=["expires_at"]),
+            models.Index(fields=["key_type", "-created_at"]),
+        ]
+        verbose_name = "gRPC API Key"
+        verbose_name_plural = "gRPC API Keys"
+
+    def __str__(self) -> str:
+        """String representation."""
+        status = "✓" if self.is_valid else "✗"
+        return f"{status} {self.name} ({self.user.username})"
+
+    @property
+    def is_expired(self) -> bool:
+        """Check if key has expired."""
+        if not self.expires_at:
+            return False
+        return timezone.now() > self.expires_at
+
+    @property
+    def is_valid(self) -> bool:
+        """Check if key is valid (active and not expired)."""
+        return self.is_active and not self.is_expired
+
+    @property
+    def masked_key(self) -> str:
+        """Return masked version of key for display."""
+        if len(self.key) <= 8:
+            return self.key
+        return f"{self.key[:4]}...{self.key[-4:]}"
+
+    def mark_used(self) -> None:
+        """Mark this key as used (update last_used_at and increment counter)."""
+        self.last_used_at = timezone.now()
+        self.request_count += 1
+        self.save(update_fields=["last_used_at", "request_count"])
+
+    def revoke(self) -> None:
+        """Revoke this key (set is_active=False)."""
+        self.is_active = False
+        self.save(update_fields=["is_active"])
+
+
+__all__ = ["GrpcApiKey", "generate_api_key"]

django_cfg/apps/integrations/grpc/models/grpc_request_log.py

@@ -9,6 +9,7 @@ from django.conf import settings
 from django.db import models
 from django.utils import timezone
 
+from .grpc_api_key import GrpcApiKey
 
 class GRPCRequestLog(models.Model):
     """
@@ -138,6 +139,15 @@ class GRPCRequestLog(models.Model):
         help_text="Authenticated user (if applicable)",
     )
 
+    api_key = models.ForeignKey(
+        GrpcApiKey,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="request_logs",
+        help_text="API key used for authentication (if applicable)",
+    )
+
     is_authenticated = models.BooleanField(
         default=False,
         db_index=True,
@@ -186,6 +196,7 @@ class GRPCRequestLog(models.Model):
             models.Index(fields=["method_name", "-created_at"]),
             models.Index(fields=["status", "-created_at"]),
             models.Index(fields=["user", "-created_at"]),
+            models.Index(fields=["api_key", "-created_at"]),
             models.Index(fields=["grpc_status_code", "-created_at"]),
         ]
         verbose_name = "gRPC Request Log"

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

@@ -174,11 +174,17 @@ class GRPCServerStatus(models.Model):
 
     @property
     def is_running(self) -> bool:
-        """Check if server is currently running."""
+        """
+        Check if server is currently running.
+
+        Uses environment-aware detection:
+        - Production: Assumes external server (Docker), relies on heartbeat only
+        - Development/Test: Checks local process + heartbeat
+        """
         if self.status not in [self.StatusChoices.RUNNING, self.StatusChoices.STARTING]:
             return False
 
-        # Check if process is still alive
+        # Check if process is still alive (auto-detects external servers)
         if not self._is_process_alive():
             return False
 
@@ -227,12 +233,41 @@ class GRPCServerStatus(models.Model):
         return " ".join(parts)
 
     def _is_process_alive(self) -> bool:
-        """Check if the process is still running."""
+        """
+        Check if the process is still running.
+
+        Uses environment-aware detection:
+        - Production mode: Skip PID check (assumes external server in Docker)
+        - Development/Test: Check PID with graceful fallback for containers
+        """
+        try:
+            from django_cfg.core import get_current_config
+
+            # Auto-detect based on env_mode
+            config = get_current_config()
+            if config and str(config.env_mode) == "production":
+                # Production = external server in separate container
+                # Don't check PID, rely on heartbeat only
+                return True
+
+        except Exception:
+            # Config not available, use fallback logic
+            pass
+
+        # Development/Test or fallback: check PID with graceful handling
         try:
             # Send signal 0 to check if process exists
             os.kill(self.pid, 0)
             return True
-        except (OSError, ProcessLookupError):
+        except ProcessLookupError:
+            # PID not found - could be different namespace (Docker)
+            # Don't mark as dead immediately, rely on heartbeat
+            return True
+        except PermissionError:
+            # Process exists but no permission to signal
+            return True
+        except OSError:
+            # Other OS error (e.g., process died)
             return False
 
     def mark_running(self):

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

@@ -2,6 +2,17 @@
 Pydantic serializers for gRPC monitoring API.
 """
 
+from .api_keys import (
+    ApiKeyListSerializer,
+    ApiKeySerializer,
+    ApiKeyStatsSerializer,
+)
+from .proto_files import (
+    ProtoFileDetailSerializer,
+    ProtoFileListSerializer,
+    ProtoGenerateRequestSerializer,
+    ProtoGenerateResponseSerializer,
+)
 from .charts import (
     DashboardChartsSerializer,
     ErrorDistributionChartSerializer,
@@ -17,14 +28,12 @@ from .requests import RecentRequestsSerializer
 from .service_registry import (
     MethodDetailSerializer,
     ServiceDetailSerializer,
-    ServiceListSerializer as ServiceRegistryListSerializer,
+    ServiceListSerializer,
     ServiceMethodsSerializer,
 )
 from .services import (
     MethodListSerializer,
     MethodStatsSerializer,
-    MonitoringServiceStatsSerializer,
-    ServiceListSerializer,
 )
 from .stats import GRPCOverviewStatsSerializer
 from .testing import (
@@ -39,15 +48,13 @@ __all__ = [
     "GRPCHealthCheckSerializer",
     "GRPCOverviewStatsSerializer",
     "RecentRequestsSerializer",
-    "MonitoringServiceStatsSerializer",
-    "ServiceListSerializer",
     "MethodStatsSerializer",
     "MethodListSerializer",
     # Config
     "GRPCConfigSerializer",
     "GRPCServerInfoSerializer",
     # Service Registry
-    "ServiceRegistryListSerializer",
+    "ServiceListSerializer",
     "ServiceDetailSerializer",
     "ServiceMethodsSerializer",
     "MethodDetailSerializer",
@@ -64,4 +71,13 @@ __all__ = [
     "ServerLifecycleChartSerializer",
     "ErrorDistributionChartSerializer",
     "DashboardChartsSerializer",
+    # API Keys
+    "ApiKeySerializer",
+    "ApiKeyListSerializer",
+    "ApiKeyStatsSerializer",
+    # Proto Files
+    "ProtoFileDetailSerializer",
+    "ProtoFileListSerializer",
+    "ProtoGenerateRequestSerializer",
+    "ProtoGenerateResponseSerializer",
 ]

django_cfg/apps/integrations/grpc/serializers/api_keys.py

@@ -0,0 +1,63 @@
+"""
+DRF serializers for gRPC API Keys.
+
+Read-only serializers for listing and viewing API keys.
+Create/Update/Delete operations handled through Django Admin.
+"""
+
+from rest_framework import serializers
+
+
+class ApiKeySerializer(serializers.Serializer):
+    """API Key information (read-only)."""
+
+    id = serializers.IntegerField(help_text="Database ID")
+    name = serializers.CharField(help_text="Key name/description")
+    key_type = serializers.CharField(help_text="Type of API key")
+    masked_key = serializers.CharField(help_text="Masked API key (first 4 and last 4 chars)")
+    is_active = serializers.BooleanField(help_text="Whether key is active")
+    is_valid = serializers.BooleanField(help_text="Whether key is valid (active and not expired)")
+    user_id = serializers.IntegerField(help_text="User ID")
+    username = serializers.CharField(help_text="Username")
+    user_email = serializers.CharField(help_text="User email", allow_blank=True)
+    request_count = serializers.IntegerField(help_text="Total requests made with this key")
+    last_used_at = serializers.DateTimeField(
+        allow_null=True,
+        help_text="When key was last used"
+    )
+    expires_at = serializers.DateTimeField(
+        allow_null=True,
+        help_text="When key expires (null = never)"
+    )
+    created_at = serializers.DateTimeField(help_text="When key was created")
+    created_by = serializers.CharField(
+        allow_null=True,
+        help_text="User who created this key"
+    )
+
+
+class ApiKeyListSerializer(serializers.Serializer):
+    """List of API keys response."""
+
+    results = ApiKeySerializer(many=True, help_text="List of API keys")
+    count = serializers.IntegerField(help_text="Total number of API keys")
+
+
+class ApiKeyStatsSerializer(serializers.Serializer):
+    """API Key usage statistics."""
+
+    total_keys = serializers.IntegerField(help_text="Total API keys")
+    active_keys = serializers.IntegerField(help_text="Active API keys")
+    expired_keys = serializers.IntegerField(help_text="Expired API keys")
+    total_requests = serializers.IntegerField(help_text="Total requests across all keys")
+    keys_by_type = serializers.DictField(
+        child=serializers.IntegerField(),
+        help_text="Count of keys by type"
+    )
+
+
+__all__ = [
+    "ApiKeySerializer",
+    "ApiKeyListSerializer",
+    "ApiKeyStatsSerializer",
+]