django-cfg 1.5.1__py3-none-any.whl → 1.5.2__py3-none-any.whl

django_cfg/apps/rq/serializers/testing.py

@@ -0,0 +1,139 @@
+"""
+DRF serializers for RQ testing and simulation endpoints.
+"""
+
+from rest_framework import serializers
+
+
+class TestScenarioSerializer(serializers.Serializer):
+    """Serializer for available test scenarios."""
+
+    id = serializers.CharField(help_text="Scenario ID")
+    name = serializers.CharField(help_text="Scenario name")
+    description = serializers.CharField(help_text="Scenario description")
+    task_func = serializers.CharField(help_text="Task function path")
+    default_args = serializers.ListField(
+        child=serializers.JSONField(),
+        required=False,
+        default=list,
+        help_text="Default arguments"
+    )
+    default_kwargs = serializers.DictField(
+        required=False,
+        default=dict,
+        help_text="Default keyword arguments"
+    )
+    estimated_duration = serializers.IntegerField(
+        required=False,
+        allow_null=True,
+        help_text="Estimated duration in seconds"
+    )
+
+
+class RunDemoRequestSerializer(serializers.Serializer):
+    """Serializer for running demo tasks."""
+
+    scenario = serializers.ChoiceField(
+        choices=[
+            'success',
+            'failure',
+            'slow',
+            'progress',
+            'retry',
+            'random',
+            'memory',
+            'cpu',
+        ],
+        help_text="Demo scenario to run"
+    )
+    queue = serializers.CharField(
+        default='default',
+        help_text="Queue name"
+    )
+    args = serializers.ListField(
+        child=serializers.JSONField(),
+        required=False,
+        default=list,
+        help_text="Task arguments"
+    )
+    kwargs = serializers.DictField(
+        required=False,
+        default=dict,
+        help_text="Task keyword arguments"
+    )
+    timeout = serializers.IntegerField(
+        required=False,
+        allow_null=True,
+        help_text="Job timeout in seconds"
+    )
+
+
+class StressTestRequestSerializer(serializers.Serializer):
+    """Serializer for stress testing."""
+
+    num_jobs = serializers.IntegerField(
+        min_value=1,
+        max_value=1000,
+        default=10,
+        help_text="Number of jobs to create"
+    )
+    queue = serializers.CharField(
+        default='default',
+        help_text="Queue name"
+    )
+    scenario = serializers.ChoiceField(
+        choices=['success', 'failure', 'slow', 'random'],
+        default='success',
+        help_text="Task scenario"
+    )
+    duration = serializers.IntegerField(
+        min_value=1,
+        max_value=60,
+        default=2,
+        help_text="Task duration in seconds"
+    )
+
+
+class TestingActionResponseSerializer(serializers.Serializer):
+    """Serializer for testing action responses."""
+
+    success = serializers.BooleanField(help_text="Action success status")
+    message = serializers.CharField(help_text="Action message")
+    job_ids = serializers.ListField(
+        child=serializers.CharField(),
+        required=False,
+        default=list,
+        help_text="Created job IDs"
+    )
+    count = serializers.IntegerField(
+        required=False,
+        allow_null=True,
+        help_text="Number of items affected"
+    )
+    metadata = serializers.DictField(
+        required=False,
+        default=dict,
+        help_text="Additional metadata"
+    )
+
+
+class CleanupRequestSerializer(serializers.Serializer):
+    """Serializer for cleanup operations."""
+
+    queue = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        help_text="Queue name (empty for all queues)"
+    )
+    registries = serializers.ListField(
+        child=serializers.ChoiceField(
+            choices=['failed', 'finished', 'deferred', 'scheduled']
+        ),
+        required=False,
+        default=list,
+        help_text="Registries to clean"
+    )
+    delete_demo_jobs_only = serializers.BooleanField(
+        default=True,
+        help_text="Only delete demo jobs (func starts with 'demo_')"
+    )

django_cfg/apps/rq/serializers/worker.py

@@ -0,0 +1,58 @@
+"""
+Worker information serializers for Django-RQ.
+"""
+
+from rest_framework import serializers
+
+
+class WorkerSerializer(serializers.Serializer):
+    """
+    Worker information serializer.
+
+    Provides detailed information about an RQ worker.
+    """
+
+    name = serializers.CharField(help_text="Worker name/ID")
+    queues = serializers.ListField(
+        child=serializers.CharField(), default=list, help_text="List of queue names"
+    )
+    state = serializers.CharField(help_text="Worker state (idle/busy/suspended)")
+    current_job = serializers.CharField(
+        allow_null=True, required=False, help_text="Current job ID if busy"
+    )
+    birth = serializers.DateTimeField(help_text="Worker start time")
+    last_heartbeat = serializers.DateTimeField(help_text="Last heartbeat timestamp")
+    successful_job_count = serializers.IntegerField(
+        default=0, help_text="Total successful jobs"
+    )
+    failed_job_count = serializers.IntegerField(default=0, help_text="Total failed jobs")
+    total_working_time = serializers.FloatField(
+        default=0.0, help_text="Total working time in seconds"
+    )
+
+
+class WorkerStatsSerializer(serializers.Serializer):
+    """
+    Aggregated worker statistics serializer.
+
+    Provides overview of all workers across all queues.
+    """
+
+    total_workers = serializers.IntegerField(help_text="Total number of workers")
+    busy_workers = serializers.IntegerField(default=0, help_text="Number of busy workers")
+    idle_workers = serializers.IntegerField(default=0, help_text="Number of idle workers")
+    suspended_workers = serializers.IntegerField(
+        default=0, help_text="Number of suspended workers"
+    )
+    total_successful_jobs = serializers.IntegerField(
+        default=0, help_text="Total successful jobs (all workers)"
+    )
+    total_failed_jobs = serializers.IntegerField(
+        default=0, help_text="Total failed jobs (all workers)"
+    )
+    total_working_time = serializers.FloatField(
+        default=0.0, help_text="Total working time across all workers (seconds)"
+    )
+    workers = serializers.ListField(
+        child=WorkerSerializer(), default=list, help_text="List of individual workers"
+    )

django_cfg/apps/rq/services/__init__.py

@@ -0,0 +1,25 @@
+"""
+Services for Django-RQ monitoring.
+"""
+
+from .config_helper import (
+    get_redis_url,
+    get_rq_config,
+    is_prometheus_enabled,
+    is_rq_enabled,
+    register_schedules_from_config,
+)
+from .rq_converters import job_to_model, queue_to_model, worker_to_model
+
+__all__ = [
+    # Converters
+    'job_to_model',
+    'queue_to_model',
+    'worker_to_model',
+    # Config helpers
+    'get_redis_url',
+    'get_rq_config',
+    'is_rq_enabled',
+    'is_prometheus_enabled',
+    'register_schedules_from_config',
+]

django_cfg/apps/rq/services/config_helper.py

@@ -0,0 +1,233 @@
+"""
+Helper functions for accessing Django-RQ configuration from django-cfg.
+
+Provides utilities to get RQ config and check if RQ is enabled.
+"""
+
+from typing import Optional
+
+from django_cfg.modules.django_logging import get_logger
+
+logger = get_logger("rq.config")
+
+
+def get_rq_config() -> Optional["DjangoRQConfig"]:
+    """
+    Get Django-RQ configuration from django-cfg.
+
+    Returns:
+        DjangoRQConfig instance or None if not configured
+
+    Example:
+        >>> config = get_rq_config()
+        >>> if config and config.enabled:
+        >>>     print(config.queues)
+    """
+    try:
+        from django_cfg.core.config import get_current_config
+        from django_cfg.models.django.django_rq import DjangoRQConfig
+
+        config = get_current_config()
+        if not config:
+            return None
+
+        django_rq = getattr(config, 'django_rq', None)
+
+        # Type validation
+        if django_rq and isinstance(django_rq, DjangoRQConfig):
+            return django_rq
+
+        return None
+
+    except Exception as e:
+        logger.debug(f"Failed to get RQ config: {e}")
+        return None
+
+
+def is_rq_enabled() -> bool:
+    """
+    Check if Django-RQ is enabled in django-cfg.
+
+    Returns:
+        True if RQ is enabled, False otherwise
+
+    Example:
+        >>> if is_rq_enabled():
+        >>>     from django_rq import enqueue
+        >>>     enqueue(my_task)
+    """
+    config = get_rq_config()
+    if not config:
+        return False
+
+    return getattr(config, 'enabled', False)
+
+
+def get_queue_names() -> list:
+    """
+    Get list of configured queue names.
+
+    Returns:
+        List of queue names from config
+
+    Example:
+        >>> queues = get_queue_names()
+        >>> print(queues)  # ['default', 'high', 'low']
+    """
+    config = get_rq_config()
+    if not config:
+        return []
+
+    queues = getattr(config, 'queues', {})
+    if isinstance(queues, dict):
+        return list(queues.keys())
+
+    return []
+
+
+def is_prometheus_enabled() -> bool:
+    """
+    Check if Prometheus metrics export is enabled.
+
+    Returns:
+        True if Prometheus is enabled, False otherwise
+    """
+    config = get_rq_config()
+    if not config:
+        return False
+
+    return getattr(config, 'prometheus_enabled', True)
+
+
+def get_redis_url() -> Optional[str]:
+    """
+    Get Redis URL from django-cfg DjangoConfig.
+
+    This is the global Redis URL that is automatically used for:
+    - RQ queues (if queue.url is not set)
+    - RQ scheduler
+    - Cache backend
+    - Session backend
+
+    Returns:
+        Redis URL string (e.g., "redis://localhost:6379/0") or None
+
+    Example:
+        >>> redis_url = get_redis_url()
+        >>> print(redis_url)  # redis://localhost:6379/0
+    """
+    try:
+        from django_cfg.core.config import get_current_config
+
+        config = get_current_config()
+        if not config:
+            return None
+
+        return getattr(config, 'redis_url', None)
+
+    except Exception as e:
+        logger.debug(f"Failed to get redis_url: {e}")
+        return None
+
+
+def register_schedules_from_config():
+    """
+    Register scheduled jobs from django-cfg config in rq-scheduler.
+
+    This function should be called on Django startup (from AppConfig.ready()).
+    It reads schedules from config.django_rq.schedules and registers them
+    in rq-scheduler.
+
+    Example:
+        >>> from django_cfg.apps.rq.services import register_schedules_from_config
+        >>> register_schedules_from_config()
+    """
+    try:
+        import django_rq
+        from rq_scheduler import Scheduler
+
+        config = get_rq_config()
+        if not config or not config.enabled:
+            logger.debug("RQ not enabled, skipping schedule registration")
+            return
+
+        schedules = getattr(config, 'schedules', [])
+        if not schedules:
+            logger.debug("No schedules configured")
+            return
+
+        # Get scheduler for default queue
+        queue = django_rq.get_queue('default')
+        scheduler = Scheduler(queue=queue, connection=queue.connection)
+
+        logger.info(f"Registering {len(schedules)} scheduled jobs from config...")
+
+        for schedule_config in schedules:
+            try:
+                # Import function
+                func_path = schedule_config.func
+                module_path, func_name = func_path.rsplit('.', 1)
+
+                try:
+                    import importlib
+                    module = importlib.import_module(module_path)
+                    func = getattr(module, func_name)
+                except (ImportError, AttributeError) as e:
+                    logger.warning(f"Failed to import function {func_path}: {e}")
+                    continue
+
+                # Get schedule type and register
+                if schedule_config.cron:
+                    scheduler.cron(
+                        schedule_config.cron,
+                        func=func,
+                        args=schedule_config.args,
+                        kwargs=schedule_config.kwargs,
+                        queue_name=schedule_config.queue,
+                        timeout=schedule_config.timeout,
+                        result_ttl=schedule_config.result_ttl,
+                        id=schedule_config.job_id,
+                        repeat=schedule_config.repeat,
+                    )
+                    logger.info(f"✓ Registered cron schedule: {func_path} ({schedule_config.cron})")
+
+                elif schedule_config.interval:
+                    from datetime import datetime
+                    scheduler.schedule(
+                        scheduled_time=datetime.utcnow(),  # Start immediately
+                        func=func,
+                        args=schedule_config.args,
+                        kwargs=schedule_config.kwargs,
+                        interval=schedule_config.interval,
+                        queue_name=schedule_config.queue,
+                        timeout=schedule_config.timeout,
+                        result_ttl=schedule_config.result_ttl,
+                        id=schedule_config.job_id,
+                        repeat=schedule_config.repeat,
+                    )
+                    logger.info(f"✓ Registered interval schedule: {func_path} (every {schedule_config.interval}s)")
+
+                elif schedule_config.scheduled_time:
+                    from datetime import datetime
+                    scheduled_dt = datetime.fromisoformat(schedule_config.scheduled_time)
+
+                    scheduler.schedule(
+                        scheduled_time=scheduled_dt,
+                        func=func,
+                        args=schedule_config.args,
+                        kwargs=schedule_config.kwargs,
+                        queue_name=schedule_config.queue,
+                        timeout=schedule_config.timeout,
+                        result_ttl=schedule_config.result_ttl,
+                        id=schedule_config.job_id,
+                    )
+                    logger.info(f"✓ Registered one-time schedule: {func_path} (at {schedule_config.scheduled_time})")
+
+            except Exception as e:
+                logger.error(f"Failed to register schedule {schedule_config.func}: {e}")
+                continue
+
+        logger.info("Schedule registration completed")
+
+    except Exception as e:
+        logger.error(f"Failed to register schedules: {e}", exc_info=True)