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

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

@@ -0,0 +1,192 @@
+"""
+Manager for GrpcApiKey model.
+
+Provides convenient methods for API key management.
+"""
+
+from datetime import timedelta
+from typing import Optional
+
+from django.contrib.auth import get_user_model
+from django.db import models
+from django.utils import timezone
+
+User = get_user_model()
+
+
+class GrpcApiKeyManager(models.Manager):
+    """
+    Manager for GrpcApiKey model.
+
+    Provides convenient methods for creating and validating API keys.
+    """
+
+    def create_for_user(
+        self,
+        user: User,
+        name: str,
+        description: str = "",
+        key_type: str = "service",
+        expires_in_days: Optional[int] = None,
+        created_by: Optional[User] = None,
+    ) -> "GrpcApiKey":
+        """
+        Create a new API key for a user.
+
+        Args:
+            user: User this key authenticates as
+            name: Descriptive name for this key
+            description: Additional details about this key
+            key_type: Type of key (service, cli, webhook, etc.)
+            expires_in_days: Number of days until expiration (None = never)
+            created_by: User who created this key
+
+        Returns:
+            Created GrpcApiKey instance
+
+        Example:
+            >>> key = GrpcApiKey.objects.create_for_user(
+            ...     user=admin_user,
+            ...     name="Analytics Service",
+            ...     description="Internal analytics microservice",
+            ...     expires_in_days=365,
+            ... )
+        """
+        expires_at = None
+        if expires_in_days:
+            expires_at = timezone.now() + timedelta(days=expires_in_days)
+
+        return self.create(
+            user=user,
+            name=name,
+            description=description,
+            key_type=key_type,
+            expires_at=expires_at,
+            created_by=created_by or user,
+        )
+
+    def get_by_key(self, key: str) -> Optional["GrpcApiKey"]:
+        """
+        Get API key by key string.
+
+        Args:
+            key: API key string
+
+        Returns:
+            GrpcApiKey instance or None if not found
+
+        Example:
+            >>> api_key = GrpcApiKey.objects.get_by_key("abc123...")
+            >>> if api_key and api_key.is_valid:
+            ...     user = api_key.user
+        """
+        try:
+            return self.select_related("user").get(key=key)
+        except self.model.DoesNotExist:
+            return None
+
+    def validate_key(self, key: str) -> Optional[User]:
+        """
+        Validate API key and return associated user.
+
+        Args:
+            key: API key string
+
+        Returns:
+            User instance if key is valid, None otherwise
+
+        Example:
+            >>> user = GrpcApiKey.objects.validate_key("abc123...")
+            >>> if user:
+            ...     print(f"Authenticated as {user.username}")
+        """
+        api_key = self.get_by_key(key)
+
+        if not api_key:
+            return None
+
+        if not api_key.is_valid:
+            return None
+
+        # Mark as used
+        api_key.mark_used()
+
+        return api_key.user
+
+    def active(self):
+        """
+        Get all active API keys.
+
+        Returns:
+            QuerySet of active keys
+
+        Example:
+            >>> active_keys = GrpcApiKey.objects.active()
+        """
+        return self.filter(is_active=True)
+
+    def valid(self):
+        """
+        Get all valid API keys (active and not expired).
+
+        Returns:
+            QuerySet of valid keys
+
+        Example:
+            >>> valid_keys = GrpcApiKey.objects.valid()
+        """
+        now = timezone.now()
+        return self.filter(
+            is_active=True
+        ).filter(
+            models.Q(expires_at__isnull=True) | models.Q(expires_at__gt=now)
+        )
+
+    def for_user(self, user: User):
+        """
+        Get all API keys for a user.
+
+        Args:
+            user: User instance
+
+        Returns:
+            QuerySet of keys for this user
+
+        Example:
+            >>> user_keys = GrpcApiKey.objects.for_user(request.user)
+        """
+        return self.filter(user=user)
+
+    def expired(self):
+        """
+        Get all expired API keys.
+
+        Returns:
+            QuerySet of expired keys
+
+        Example:
+            >>> expired_keys = GrpcApiKey.objects.expired()
+        """
+        return self.filter(
+            expires_at__isnull=False,
+            expires_at__lte=timezone.now()
+        )
+
+    def revoke_all_for_user(self, user: User) -> int:
+        """
+        Revoke all API keys for a user.
+
+        Args:
+            user: User instance
+
+        Returns:
+            Number of keys revoked
+
+        Example:
+            >>> count = GrpcApiKey.objects.revoke_all_for_user(user)
+            >>> print(f"Revoked {count} keys")
+        """
+        return self.filter(user=user, is_active=True).update(is_active=False)
+
+
+__all__ = ["GrpcApiKeyManager"]

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

@@ -53,6 +53,10 @@ class GRPCServerStatusManager(models.Manager):
             ... )
             >>> status.is_running
             True
+
+        Note:
+            External/internal server detection is automatic based on env_mode.
+            Production mode assumes external server (Docker), dev/test assumes local.
         """
         if pid is None:
             pid = os.getpid()
@@ -64,18 +68,22 @@ class GRPCServerStatusManager(models.Manager):
         # Mark any existing server at this address as stopped
         self.stop_servers_at_address(address)
 
-        # Create new server status
-        status = self.create(
+        # Create or update server status (handles restart with same instance_id)
+        status, created = self.update_or_create(
             instance_id=instance_id,
-            host=host,
-            port=port,
-            address=address,
-            pid=pid,
-            hostname=hostname,
-            status=self.model.StatusChoices.STARTING,
-            max_workers=max_workers,
-            enable_reflection=enable_reflection,
-            enable_health_check=enable_health_check,
+            defaults={
+                "host": host,
+                "port": port,
+                "address": address,
+                "pid": pid,
+                "hostname": hostname,
+                "status": self.model.StatusChoices.STARTING,
+                "max_workers": max_workers,
+                "enable_reflection": enable_reflection,
+                "enable_health_check": enable_health_check,
+                "started_at": timezone.now(),
+                "last_heartbeat": timezone.now(),
+            },
         )
 
         return status

django_cfg/apps/integrations/grpc/migrations/0005_grpcapikey.py

@@ -0,0 +1,143 @@
+# Generated by Django 5.2.7 on 2025-11-04 05:14
+
+import django.db.models.deletion
+import django_cfg.apps.integrations.grpc.models.grpc_api_key
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("grpc", "0004_grpcserverstatus_registered_services"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="GrpcApiKey",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
+                    ),
+                ),
+                (
+                    "key",
+                    models.CharField(
+                        db_index=True,
+                        default=django_cfg.apps.integrations.grpc.models.grpc_api_key.generate_api_key,
+                        help_text="API key (auto-generated)",
+                        max_length=64,
+                        unique=True,
+                    ),
+                ),
+                (
+                    "name",
+                    models.CharField(
+                        help_text="Descriptive name for this key (e.g., 'Analytics Service')",
+                        max_length=255,
+                    ),
+                ),
+                (
+                    "description",
+                    models.TextField(
+                        blank=True, help_text="Additional details about this key's purpose"
+                    ),
+                ),
+                (
+                    "key_type",
+                    models.CharField(
+                        choices=[
+                            ("service", "Service-to-Service"),
+                            ("cli", "CLI Tool"),
+                            ("webhook", "Webhook"),
+                            ("internal", "Internal System"),
+                            ("development", "Development"),
+                        ],
+                        default="service",
+                        help_text="Type of API key",
+                        max_length=20,
+                    ),
+                ),
+                (
+                    "is_active",
+                    models.BooleanField(
+                        db_index=True,
+                        default=True,
+                        help_text="Whether this key is currently active (can be used)",
+                    ),
+                ),
+                (
+                    "expires_at",
+                    models.DateTimeField(
+                        blank=True,
+                        db_index=True,
+                        help_text="When this key expires (null = never expires)",
+                        null=True,
+                    ),
+                ),
+                (
+                    "last_used_at",
+                    models.DateTimeField(
+                        blank=True, help_text="When this key was last used", null=True
+                    ),
+                ),
+                (
+                    "request_count",
+                    models.IntegerField(
+                        default=0, help_text="Total number of requests made with this key"
+                    ),
+                ),
+                (
+                    "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"),
+                ),
+                (
+                    "created_by",
+                    models.ForeignKey(
+                        blank=True,
+                        help_text="User who created this key",
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="created_grpc_api_keys",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        help_text="User this key authenticates as",
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="grpc_api_keys",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "gRPC API Key",
+                "verbose_name_plural": "gRPC API Keys",
+                "db_table": "django_cfg_grpc_api_key",
+                "ordering": ["-created_at"],
+                "indexes": [
+                    models.Index(
+                        fields=["user", "-created_at"], name="django_cfg__user_id_9c5276_idx"
+                    ),
+                    models.Index(
+                        fields=["is_active", "-created_at"], name="django_cfg__is_acti_26421c_idx"
+                    ),
+                    models.Index(fields=["expires_at"], name="django_cfg__expires_8f83cf_idx"),
+                    models.Index(
+                        fields=["key_type", "-created_at"], name="django_cfg__key_typ_6ad1cb_idx"
+                    ),
+                ],
+            },
+        ),
+    ]

django_cfg/apps/integrations/grpc/migrations/0006_grpcrequestlog_api_key_and_more.py

@@ -0,0 +1,34 @@
+# Generated by Django 5.2.7 on 2025-11-04 05:30
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("grpc", "0005_grpcapikey"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="grpcrequestlog",
+            name="api_key",
+            field=models.ForeignKey(
+                blank=True,
+                help_text="API key used for authentication (if applicable)",
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="request_logs",
+                to="grpc.grpcapikey",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="grpcrequestlog",
+            index=models.Index(
+                fields=["api_key", "-created_at"], name="django_cfg__api_key_218ecc_idx"
+            ),
+        ),
+    ]

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"