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

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

@@ -0,0 +1,296 @@
+"""
+Manager for GRPCServerStatus model.
+
+Provides convenient methods for server lifecycle management.
+"""
+
+import os
+import socket
+from typing import Optional
+
+from django.db import models
+from django.utils import timezone
+
+
+class GRPCServerStatusManager(models.Manager):
+    """
+    Manager for GRPCServerStatus model.
+
+    Provides methods for:
+    - Starting/stopping server tracking
+    - Getting current server status
+    - Cleaning up stale records
+    """
+
+    def start_server(
+        self,
+        host: str,
+        port: int,
+        pid: int = None,
+        max_workers: int = 10,
+        enable_reflection: bool = False,
+        enable_health_check: bool = True,
+    ):
+        """
+        Start tracking a new server instance.
+
+        Args:
+            host: Server host address
+            port: Server port
+            pid: Process ID (defaults to current process)
+            max_workers: Maximum worker threads
+            enable_reflection: Whether reflection is enabled
+            enable_health_check: Whether health check is enabled
+
+        Returns:
+            GRPCServerStatus instance
+
+        Example:
+            >>> status = GRPCServerStatus.objects.start_server(
+            ...     host="[::]",
+            ...     port=50051,
+            ...     pid=12345
+            ... )
+            >>> 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()
+
+        hostname = socket.gethostname()
+        address = f"{host}:{port}"
+        instance_id = f"{hostname}:{port}:{pid}"
+
+        # Mark any existing server at this address as stopped
+        self.stop_servers_at_address(address)
+
+        # Create or update server status (handles restart with same instance_id)
+        status, created = self.update_or_create(
+            instance_id=instance_id,
+            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
+
+    def get_current_server(self, address: str = None) -> Optional["GRPCServerStatus"]:
+        """
+        Get the currently running server.
+
+        Args:
+            address: Optional address filter (host:port)
+
+        Returns:
+            GRPCServerStatus instance or None
+
+        Example:
+            >>> server = GRPCServerStatus.objects.get_current_server()
+            >>> if server and server.is_running:
+            ...     print(f"Server running for {server.uptime_display}")
+        """
+        queryset = self.filter(
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ]
+        )
+
+        if address:
+            queryset = queryset.filter(address=address)
+
+        # Get most recent
+        server = queryset.order_by("-started_at").first()
+
+        # Verify it's actually running
+        if server and server.is_running:
+            return server
+
+        return None
+
+    def get_running_servers(self):
+        """
+        Get all currently running servers.
+
+        Returns:
+            QuerySet of running servers
+
+        Example:
+            >>> servers = GRPCServerStatus.objects.get_running_servers()
+            >>> for server in servers:
+            ...     print(f"{server.address}: {server.uptime_display}")
+        """
+        running_servers = []
+
+        # Get servers marked as running
+        candidates = self.filter(
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ]
+        ).order_by("-started_at")
+
+        # Verify each one is actually running
+        for server in candidates:
+            if server.is_running:
+                running_servers.append(server.id)
+
+        return self.filter(id__in=running_servers)
+
+    def stop_server(self, pid: int = None, address: str = None):
+        """
+        Stop tracking a server instance.
+
+        Args:
+            pid: Process ID to stop
+            address: Address to stop (alternative to pid)
+
+        Example:
+            >>> GRPCServerStatus.objects.stop_server(pid=12345)
+        """
+        if pid:
+            servers = self.filter(pid=pid)
+        elif address:
+            servers = self.filter(address=address)
+        else:
+            # Stop current process
+            pid = os.getpid()
+            servers = self.filter(pid=pid)
+
+        servers = servers.filter(
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ]
+        )
+
+        for server in servers:
+            server.mark_stopped()
+
+    def stop_servers_at_address(self, address: str):
+        """
+        Stop all servers at a specific address.
+
+        Args:
+            address: Server address (host:port)
+
+        Example:
+            >>> GRPCServerStatus.objects.stop_servers_at_address("[::]:50051")
+        """
+        servers = self.filter(
+            address=address,
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ],
+        )
+
+        for server in servers:
+            server.mark_stopped("Replaced by new server instance")
+
+    def cleanup_stale_servers(self, hours: int = 24):
+        """
+        Mark stale servers as stopped.
+
+        A server is considered stale if:
+        - Status is STARTING or RUNNING
+        - Last heartbeat is older than threshold
+        - Process is not alive
+
+        Args:
+            hours: Hours without heartbeat to consider stale
+
+        Returns:
+            Number of servers cleaned up
+
+        Example:
+            >>> count = GRPCServerStatus.objects.cleanup_stale_servers()
+            >>> print(f"Cleaned up {count} stale servers")
+        """
+        from django.utils import timezone
+        from datetime import timedelta
+
+        threshold = timezone.now() - timedelta(hours=hours)
+
+        stale_servers = self.filter(
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ],
+            last_heartbeat__lt=threshold,
+        )
+
+        count = 0
+        for server in stale_servers:
+            if not server.is_running:
+                server.mark_stopped("Stale server (no heartbeat)")
+                count += 1
+
+        return count
+
+    def get_server_by_pid(self, pid: int) -> Optional["GRPCServerStatus"]:
+        """
+        Get server by process ID.
+
+        Args:
+            pid: Process ID
+
+        Returns:
+            GRPCServerStatus instance or None
+        """
+        return (
+            self.filter(pid=pid)
+            .order_by("-started_at")
+            .first()
+        )
+
+    def get_statistics(self):
+        """
+        Get statistics about server instances.
+
+        Returns:
+            Dictionary with statistics
+
+        Example:
+            >>> stats = GRPCServerStatus.objects.get_statistics()
+            >>> print(f"Total servers: {stats['total_servers']}")
+            >>> print(f"Currently running: {stats['running_servers']}")
+        """
+        running_servers = self.get_running_servers()
+
+        return {
+            "total_servers": self.count(),
+            "running_servers": running_servers.count(),
+            "stopped_servers": self.filter(
+                status=self.model.StatusChoices.STOPPED
+            ).count(),
+            "error_servers": self.filter(
+                status=self.model.StatusChoices.ERROR
+            ).count(),
+            "running_list": [
+                {
+                    "address": server.address,
+                    "pid": server.pid,
+                    "uptime_seconds": server.uptime_seconds,
+                    "started_at": server.started_at.isoformat(),
+                }
+                for server in running_servers
+            ],
+        }
+
+
+__all__ = ["GRPCServerStatusManager"]

django_cfg/apps/integrations/grpc/migrations/0001_initial.py

@@ -0,0 +1,69 @@
+# Generated manually for django_cfg.apps.integrations.grpc
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='GRPCRequestLog',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('request_id', models.CharField(db_index=True, help_text='Unique request identifier (UUID)', max_length=100, unique=True)),
+                ('service_name', models.CharField(db_index=True, help_text='gRPC service name (e.g., myapp.UserService)', max_length=200)),
+                ('method_name', models.CharField(db_index=True, help_text='gRPC method name (e.g., GetUser)', max_length=200)),
+                ('full_method', models.CharField(db_index=True, help_text='Full method path (e.g., /myapp.UserService/GetUser)', max_length=400)),
+                ('request_size', models.IntegerField(blank=True, help_text='Request size in bytes', null=True)),
+                ('response_size', models.IntegerField(blank=True, help_text='Response size in bytes', null=True)),
+                ('request_data', models.JSONField(blank=True, help_text='Request data (if logged)', null=True)),
+                ('response_data', models.JSONField(blank=True, help_text='Response data (if logged)', null=True)),
+                ('status', models.CharField(choices=[('pending', 'Pending'), ('success', 'Success'), ('error', 'Error'), ('cancelled', 'Cancelled'), ('timeout', 'Timeout')], db_index=True, default='pending', help_text='Current status of request', max_length=20)),
+                ('grpc_status_code', models.CharField(blank=True, db_index=True, help_text='gRPC status code (OK, CANCELLED, INVALID_ARGUMENT, etc.)', max_length=50, null=True)),
+                ('error_message', models.TextField(blank=True, help_text='Error message if failed', null=True)),
+                ('error_details', models.JSONField(blank=True, help_text='Additional error details', null=True)),
+                ('duration_ms', models.IntegerField(blank=True, help_text='Total duration in milliseconds', null=True)),
+                ('is_authenticated', models.BooleanField(db_index=True, default=False, help_text='Whether request was authenticated')),
+                ('client_ip', models.GenericIPAddressField(blank=True, help_text='Client IP address', null=True)),
+                ('user_agent', models.TextField(blank=True, help_text='User agent from metadata', null=True)),
+                ('peer', models.CharField(blank=True, help_text='gRPC peer information', max_length=200, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True, db_index=True, help_text='When request was received')),
+                ('completed_at', models.DateTimeField(blank=True, db_index=True, help_text='When request completed (success/error)', null=True)),
+                ('user', models.ForeignKey(blank=True, help_text='Authenticated user (if applicable)', null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='grpc_request_logs', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'gRPC Request Log',
+                'verbose_name_plural': 'gRPC Request Logs',
+                'db_table': 'django_cfg_grpc_request_log',
+                'ordering': ['-created_at'],
+            },
+        ),
+        migrations.AddIndex(
+            model_name='grpcrequestlog',
+            index=models.Index(fields=['service_name', '-created_at'], name='django_cfg__service_4c4a8e_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='grpcrequestlog',
+            index=models.Index(fields=['method_name', '-created_at'], name='django_cfg__method__8e1a7c_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='grpcrequestlog',
+            index=models.Index(fields=['status', '-created_at'], name='django_cfg__status_f3d9a1_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='grpcrequestlog',
+            index=models.Index(fields=['user', '-created_at'], name='django_cfg__user_id_9c2b4f_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='grpcrequestlog',
+            index=models.Index(fields=['grpc_status_code', '-created_at'], name='django_cfg__grpc_st_a7e5c2_idx'),
+        ),
+    ]

django_cfg/apps/integrations/grpc/migrations/0002_rename_django_cfg__service_4c4a8e_idx_django_cfg__service_584308_idx_and_more.py

@@ -0,0 +1,38 @@
+# Generated by Django 5.2.7 on 2025-11-01 13:48
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("grpc", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.RenameIndex(
+            model_name="grpcrequestlog",
+            new_name="django_cfg__service_584308_idx",
+            old_name="django_cfg__service_4c4a8e_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="grpcrequestlog",
+            new_name="django_cfg__method__5e704d_idx",
+            old_name="django_cfg__method__8e1a7c_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="grpcrequestlog",
+            new_name="django_cfg__status_a564a8_idx",
+            old_name="django_cfg__status_f3d9a1_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="grpcrequestlog",
+            new_name="django_cfg__user_id_f2ada7_idx",
+            old_name="django_cfg__user_id_9c2b4f_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="grpcrequestlog",
+            new_name="django_cfg__grpc_st_fea09f_idx",
+            old_name="django_cfg__grpc_st_a7e5c2_idx",
+        ),
+    ]

django_cfg/apps/integrations/grpc/migrations/0003_grpcserverstatus.py

@@ -0,0 +1,119 @@
+# Generated by Django 5.2.7 on 2025-11-03 08:28
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        (
+            "grpc",
+            "0002_rename_django_cfg__service_4c4a8e_idx_django_cfg__service_584308_idx_and_more",
+        ),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="GRPCServerStatus",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
+                    ),
+                ),
+                (
+                    "instance_id",
+                    models.CharField(
+                        db_index=True,
+                        help_text="Unique instance identifier (hostname:port:pid)",
+                        max_length=100,
+                        unique=True,
+                    ),
+                ),
+                ("host", models.CharField(help_text="Server host address", max_length=200)),
+                ("port", models.IntegerField(help_text="Server port")),
+                (
+                    "address",
+                    models.CharField(
+                        db_index=True, help_text="Full server address (host:port)", max_length=200
+                    ),
+                ),
+                ("pid", models.IntegerField(help_text="Process ID of gRPC server")),
+                ("hostname", models.CharField(help_text="Server hostname", max_length=255)),
+                (
+                    "status",
+                    models.CharField(
+                        choices=[
+                            ("starting", "Starting"),
+                            ("running", "Running"),
+                            ("stopping", "Stopping"),
+                            ("stopped", "Stopped"),
+                            ("error", "Error"),
+                        ],
+                        db_index=True,
+                        default="starting",
+                        help_text="Current server status",
+                        max_length=20,
+                    ),
+                ),
+                (
+                    "started_at",
+                    models.DateTimeField(
+                        auto_now_add=True, db_index=True, help_text="When server started"
+                    ),
+                ),
+                (
+                    "last_heartbeat",
+                    models.DateTimeField(
+                        auto_now=True, db_index=True, help_text="Last heartbeat timestamp"
+                    ),
+                ),
+                (
+                    "stopped_at",
+                    models.DateTimeField(blank=True, help_text="When server stopped", null=True),
+                ),
+                (
+                    "max_workers",
+                    models.IntegerField(default=10, help_text="Maximum worker threads"),
+                ),
+                (
+                    "enable_reflection",
+                    models.BooleanField(default=False, help_text="Whether reflection is enabled"),
+                ),
+                (
+                    "enable_health_check",
+                    models.BooleanField(default=True, help_text="Whether health check is enabled"),
+                ),
+                (
+                    "error_message",
+                    models.TextField(
+                        blank=True, help_text="Error message if status is ERROR", null=True
+                    ),
+                ),
+                (
+                    "created_at",
+                    models.DateTimeField(auto_now_add=True, help_text="Record creation time"),
+                ),
+                (
+                    "updated_at",
+                    models.DateTimeField(auto_now=True, help_text="Record last update time"),
+                ),
+            ],
+            options={
+                "verbose_name": "gRPC Server Status",
+                "verbose_name_plural": "gRPC Server Statuses",
+                "db_table": "django_cfg_grpc_server_status",
+                "ordering": ["-started_at"],
+                "indexes": [
+                    models.Index(
+                        fields=["status", "-started_at"], name="django_cfg__status_b0ce6c_idx"
+                    ),
+                    models.Index(
+                        fields=["address", "-started_at"], name="django_cfg__address_4966eb_idx"
+                    ),
+                    models.Index(fields=["pid", "-started_at"], name="django_cfg__pid_bab561_idx"),
+                ],
+            },
+        ),
+    ]

django_cfg/apps/integrations/grpc/migrations/0004_grpcserverstatus_registered_services.py

@@ -0,0 +1,22 @@
+# Generated by Django 5.2.7 on 2025-11-03 09:25
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("grpc", "0003_grpcserverstatus"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="grpcserverstatus",
+            name="registered_services",
+            field=models.JSONField(
+                blank=True,
+                default=list,
+                help_text="List of registered service metadata (name, methods, etc.)",
+            ),
+        ),
+    ]

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