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

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

@@ -0,0 +1,75 @@
+"""
+Django management command for gRPC integration testing.
+
+Usage:
+    python manage.py test_grpc_integration
+    python manage.py test_grpc_integration --app crypto
+    python manage.py test_grpc_integration --quiet
+"""
+
+import sys
+
+from django_cfg.management.utils import SafeCommand
+
+from django_cfg.apps.integrations.grpc.utils import GRPCIntegrationTest
+
+
+class Command(SafeCommand):
+    command_name = 'test_grpc_integration'
+    help = "Run comprehensive gRPC integration test with API keys"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--app",
+            type=str,
+            default="crypto",
+            help="Django app label to test (default: crypto)",
+        )
+        parser.add_argument(
+            "--quiet",
+            "-q",
+            action="store_true",
+            help="Suppress verbose output",
+        )
+
+    def handle(self, *args, **options):
+        app_label = options["app"]
+        quiet = options["quiet"]
+
+        if not quiet:
+            self.stdout.write(
+                self.style.SUCCESS(f"Starting gRPC integration test for app: {app_label}")
+            )
+
+        # Создаем и запускаем тест
+        test = GRPCIntegrationTest(app_label=app_label, quiet=quiet)
+
+        try:
+            success = test.run()
+
+            if success:
+                self.stdout.write(
+                    self.style.SUCCESS("\n✅ Integration test completed successfully!")
+                )
+                sys.exit(0)
+            else:
+                self.stdout.write(
+                    self.style.ERROR("\n❌ Integration test failed!")
+                )
+                sys.exit(1)
+
+        except KeyboardInterrupt:
+            self.stdout.write(
+                self.style.WARNING("\n⚠️  Test interrupted by user")
+            )
+            test.step6_cleanup()
+            sys.exit(1)
+
+        except Exception as e:
+            self.stdout.write(
+                self.style.ERROR(f"\n❌ Critical error: {e}")
+            )
+            import traceback
+            traceback.print_exc()
+            test.step6_cleanup()
+            sys.exit(1)

django_cfg/apps/integrations/grpc/management/proto/__init__.py

@@ -0,0 +1,3 @@
+"""
+Proto utilities for django-cfg gRPC integration.
+"""

django_cfg/apps/integrations/grpc/management/proto/compiler.py

@@ -0,0 +1,194 @@
+"""
+Proto compiler utilities.
+Shared functionality for compiling .proto files to Python.
+"""
+
+import logging
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ProtoCompiler:
+    """Compiles .proto files to Python using grpc_tools.protoc."""
+
+    def __init__(
+        self,
+        output_dir: Optional[Path] = None,
+        proto_import_path: Optional[Path] = None,
+        fix_imports: bool = True,
+        verbose: bool = True,
+    ):
+        """
+        Initialize proto compiler.
+
+        Args:
+            output_dir: Output directory for generated files (default: same as proto file)
+            proto_import_path: Additional proto import path (passed to protoc -I flag)
+            fix_imports: Fix imports in generated _grpc.py files (default: True)
+            verbose: Print compilation progress (default: True)
+        """
+        self.output_dir = output_dir
+        self.proto_import_path = proto_import_path
+        self.fix_imports = fix_imports
+        self.verbose = verbose
+
+    def compile_file(self, proto_file: Path) -> bool:
+        """
+        Compile a single .proto file.
+
+        Args:
+            proto_file: Path to .proto file
+
+        Returns:
+            True if compilation succeeded, False otherwise
+        """
+        if self.verbose:
+            logger.info(f"📦 Compiling: {proto_file}")
+
+        # Determine output directory
+        output_dir = self.output_dir or proto_file.parent
+
+        # Determine proto import path
+        proto_import_path = self.proto_import_path or proto_file.parent
+
+        # Ensure output directory exists
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Build protoc command
+        cmd = [
+            sys.executable,
+            "-m",
+            "grpc_tools.protoc",
+            f"-I{proto_import_path}",
+            f"--python_out={output_dir}",
+            f"--grpc_python_out={output_dir}",
+            str(proto_file),
+        ]
+
+        # Run protoc
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            if result.stdout and self.verbose:
+                logger.info(f"   {result.stdout}")
+
+            if self.verbose:
+                logger.info(f"   ✅ Compiled successfully")
+
+            # Fix imports if requested
+            if self.fix_imports:
+                self._fix_imports(proto_file, output_dir)
+
+            return True
+
+        except subprocess.CalledProcessError as e:
+            logger.error(f"   ❌ Compilation failed")
+            logger.error(f"   Error: {e.stderr}")
+            return False
+
+    def compile_directory(
+        self,
+        proto_path: Path,
+        recursive: bool = False,
+    ) -> tuple[int, int]:
+        """
+        Compile all .proto files in a directory.
+
+        Args:
+            proto_path: Directory containing .proto files
+            recursive: Recursively compile all .proto files
+
+        Returns:
+            Tuple of (success_count, failure_count)
+        """
+        # Collect proto files
+        proto_files = self._collect_proto_files(proto_path, recursive)
+
+        if not proto_files:
+            logger.warning(f"No .proto files found in: {proto_path}")
+            return 0, 0
+
+        if self.verbose:
+            logger.info(f"🔧 Compiling {len(proto_files)} proto file(s)...")
+
+        # Compile each proto file
+        success_count = 0
+        failure_count = 0
+
+        for proto_file in proto_files:
+            if self.compile_file(proto_file):
+                success_count += 1
+            else:
+                failure_count += 1
+
+        return success_count, failure_count
+
+    def _collect_proto_files(self, path: Path, recursive: bool) -> List[Path]:
+        """Collect all .proto files from path."""
+        if path.is_file():
+            if path.suffix == ".proto":
+                return [path]
+            else:
+                raise ValueError(f"File is not a .proto file: {path}")
+
+        # Directory
+        if recursive:
+            return list(path.rglob("*.proto"))
+        else:
+            return list(path.glob("*.proto"))
+
+    def _fix_imports(self, proto_file: Path, output_dir: Path):
+        """
+        Fix imports in generated _grpc.py files.
+
+        Changes: import foo_pb2 as foo__pb2
+        To:      from . import foo_pb2 as foo__pb2
+        """
+        # Find generated _grpc.py file
+        grpc_file = output_dir / f"{proto_file.stem}_pb2_grpc.py"
+
+        if not grpc_file.exists():
+            if self.verbose:
+                logger.warning(f"   ⚠️  Skipping import fix: {grpc_file.name} not found")
+            return
+
+        if self.verbose:
+            logger.info(f"   🔧 Fixing imports in {grpc_file.name}...")
+
+        # Read file
+        content = grpc_file.read_text()
+
+        # Pattern to match: import xxx_pb2 as yyy
+        # But NOT: from xxx import ...
+        pattern = r"^import (\w+_pb2) as (\w+)$"
+
+        # Replace with: from . import xxx_pb2 as yyy
+        def replace_func(match):
+            module = match.group(1)
+            alias = match.group(2)
+            return f"from . import {module} as {alias}"
+
+        # Apply replacement
+        new_content = re.sub(pattern, replace_func, content, flags=re.MULTILINE)
+
+        # Count changes
+        changes = content.count("\nimport ") - new_content.count("\nimport ")
+
+        if changes > 0:
+            # Write back
+            grpc_file.write_text(new_content)
+            if self.verbose:
+                logger.info(f"   ✅ Fixed {changes} import(s) in {grpc_file.name}")
+        else:
+            if self.verbose:
+                logger.info(f"   ℹ️  No imports to fix in {grpc_file.name}")

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

@@ -2,10 +2,12 @@
 Managers for gRPC app models.
 """
 
+from .grpc_api_key import GrpcApiKeyManager
 from .grpc_request_log import GRPCRequestLogManager, GRPCRequestLogQuerySet
 from .grpc_server_status import GRPCServerStatusManager
 
 __all__ = [
+    "GrpcApiKeyManager",
     "GRPCRequestLogManager",
     "GRPCRequestLogQuerySet",
     "GRPCServerStatusManager",

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"
+            ),
+        ),
+    ]