ccproxy-api 0.1.7__py3-none-any.whl → 0.2.0__py3-none-any.whl

ccproxy/scheduler/core.py

@@ -11,7 +11,7 @@ from .errors import (
     TaskNotFoundError,
     TaskRegistrationError,
 )
-from .registry import TaskRegistry, get_task_registry
+from .registry import TaskRegistry
 from .tasks import BaseScheduledTask
 
 
@@ -31,9 +31,9 @@ class Scheduler:
 
     def __init__(
         self,
+        task_registry: TaskRegistry,
         max_concurrent_tasks: int = 10,
         graceful_shutdown_timeout: float = 30.0,
-        task_registry: TaskRegistry | None = None,
     ):
         """
         Initialize the scheduler.
@@ -41,11 +41,11 @@ class Scheduler:
         Args:
             max_concurrent_tasks: Maximum number of tasks to run concurrently
             graceful_shutdown_timeout: Timeout for graceful shutdown in seconds
-            task_registry: Task registry instance (uses global if None)
+            task_registry: Task registry instance (required)
         """
         self.max_concurrent_tasks = max_concurrent_tasks
         self.graceful_shutdown_timeout = graceful_shutdown_timeout
-        self.task_registry = task_registry or get_task_registry()
+        self.task_registry = task_registry
 
         self._running = False
         self._tasks: dict[str, BaseScheduledTask] = {}
@@ -63,7 +63,7 @@ class Scheduler:
         logger.debug(
             "scheduler_starting",
             max_concurrent_tasks=self.max_concurrent_tasks,
-            registered_tasks=self.task_registry.list_tasks(),
+            registered_tasks=self.task_registry.list(),
         )
 
         try:
@@ -81,6 +81,7 @@ class Scheduler:
                 "scheduler_start_failed",
                 error=str(e),
                 error_type=type(e).__name__,
+                exc_info=e,
             )
             raise SchedulerError(f"Failed to start scheduler: {e}") from e
 
@@ -90,7 +91,7 @@ class Scheduler:
             return
 
         self._running = False
-        logger.info("scheduler_stopping", active_tasks=len(self._tasks))
+        logger.debug("scheduler_stopping", active_tasks=len(self._tasks))
 
         # Stop all tasks
         stop_tasks = []
@@ -106,7 +107,7 @@ class Scheduler:
                     asyncio.gather(*stop_tasks, return_exceptions=True),
                     timeout=self.graceful_shutdown_timeout,
                 )
-                logger.info("scheduler_stopped_gracefully")
+                logger.debug("scheduler_stopped_gracefully")
             except TimeoutError:
                 logger.warning(
                     "scheduler_shutdown_timeout",
@@ -123,6 +124,7 @@ class Scheduler:
                     "scheduler_shutdown_error",
                     error=str(e),
                     error_type=type(e).__name__,
+                    exc_info=e,
                 )
                 raise SchedulerShutdownError(
                     f"Error during scheduler shutdown: {e}"
@@ -152,7 +154,7 @@ class Scheduler:
         if task_name in self._tasks:
             raise SchedulerError(f"Task '{task_name}' already exists")
 
-        if not self.task_registry.is_registered(task_type):
+        if not self.task_registry.has(task_type):
             raise TaskRegistrationError(f"Task type '{task_type}' is not registered")
 
         try:
@@ -160,6 +162,18 @@ class Scheduler:
             task_class = self.task_registry.get(task_type)
             task_instance = task_class(name=task_name, **task_kwargs)
 
+            interval_value = task_kwargs.get("interval_seconds")
+            if interval_value is not None:
+                try:
+                    task_instance.interval_seconds = max(1.0, float(interval_value))
+                except (TypeError, ValueError):
+                    logger.warning(
+                        "task_interval_invalid",
+                        task_name=task_name,
+                        task_type=task_type,
+                        interval_value=interval_value,
+                    )
+
             # Add to our tasks dict
             self._tasks[task_name] = task_instance
 
@@ -191,6 +205,7 @@ class Scheduler:
                 task_type=task_type,
                 error=str(e),
                 error_type=type(e).__name__,
+                exc_info=e,
             )
             raise SchedulerError(f"Failed to add task '{task_name}': {e}") from e
 
@@ -222,6 +237,7 @@ class Scheduler:
                 task_name=task_name,
                 error=str(e),
                 error_type=type(e).__name__,
+                exc_info=e,
             )
             raise SchedulerError(f"Failed to remove task '{task_name}': {e}") from e
 
@@ -287,7 +303,7 @@ class Scheduler:
             "graceful_shutdown_timeout": self.graceful_shutdown_timeout,
             "task_names": list(self._tasks.keys()),
             "running_task_names": running_tasks,
-            "registered_task_types": self.task_registry.list_tasks(),
+            "registered_task_types": self.task_registry.list(),
         }
 
     @property
@@ -301,35 +317,4 @@ class Scheduler:
         return len(self._tasks)
 
 
-# Global scheduler instance
-_global_scheduler: Scheduler | None = None
-
-
-async def get_scheduler() -> Scheduler:
-    """
-    Get or create the global scheduler instance.
-
-    Returns:
-        Global Scheduler instance
-    """
-    global _global_scheduler
-
-    if _global_scheduler is None:
-        _global_scheduler = Scheduler()
-
-    return _global_scheduler
-
-
-async def start_scheduler() -> None:
-    """Start the global scheduler."""
-    scheduler = await get_scheduler()
-    await scheduler.start()
-
-
-async def stop_scheduler() -> None:
-    """Stop the global scheduler."""
-    global _global_scheduler
-
-    if _global_scheduler:
-        await _global_scheduler.stop()
-        _global_scheduler = None
+# Global scheduler helpers omitted.

ccproxy/scheduler/manager.py

@@ -3,16 +3,12 @@
 import structlog
 
 from ccproxy.config.settings import Settings
+from ccproxy.services.container import ServiceContainer
 
 from .core import Scheduler
-from .registry import register_task
-from .tasks import (
-    PoolStatsTask,
-    PricingCacheUpdateTask,
-    PushgatewayTask,
-    StatsPrintingTask,
-    VersionUpdateCheckTask,
-)
+from .errors import SchedulerError, TaskRegistrationError
+from .registry import TaskRegistry
+from .tasks import PoolStatsTask, VersionUpdateCheckTask
 
 
 logger = structlog.get_logger(__name__)
@@ -29,11 +25,11 @@ async def setup_scheduler_tasks(scheduler: Scheduler, settings: Settings) -> Non
     scheduler_config = settings.scheduler
 
     if not scheduler_config.enabled:
-        logger.info("scheduler_disabled")
+        logger.debug("scheduler_disabled")
         return
 
     # Log network features status
-    logger.info(
+    logger.debug(
         "network_features_status",
         pricing_updates_enabled=scheduler_config.pricing_update_enabled,
         version_check_enabled=scheduler_config.version_check_enabled,
@@ -45,71 +41,21 @@ async def setup_scheduler_tasks(scheduler: Scheduler, settings: Settings) -> Non
         ),
     )
 
-    # Add pushgateway task if enabled
-    if scheduler_config.pushgateway_enabled:
-        try:
-            await scheduler.add_task(
-                task_name="pushgateway",
-                task_type="pushgateway",
-                interval_seconds=scheduler_config.pushgateway_interval_seconds,
-                enabled=True,
-                max_backoff_seconds=scheduler_config.pushgateway_max_backoff_seconds,
-            )
-            logger.info(
-                "pushgateway_task_added",
-                interval_seconds=scheduler_config.pushgateway_interval_seconds,
-            )
-        except Exception as e:
-            logger.error(
-                "pushgateway_task_add_failed",
-                error=str(e),
-                error_type=type(e).__name__,
-            )
-
-    # Add stats printing task if enabled
-    if scheduler_config.stats_printing_enabled:
-        try:
-            await scheduler.add_task(
-                task_name="stats_printing",
-                task_type="stats_printing",
-                interval_seconds=scheduler_config.stats_printing_interval_seconds,
-                enabled=True,
-            )
-            logger.info(
-                "stats_printing_task_added",
-                interval_seconds=scheduler_config.stats_printing_interval_seconds,
-            )
-        except Exception as e:
-            logger.error(
-                "stats_printing_task_add_failed",
-                error=str(e),
-                error_type=type(e).__name__,
-            )
+    if (
+        hasattr(scheduler_config, "stats_printing_enabled")
+        and scheduler_config.stats_printing_enabled
+    ):
+        logger.debug(
+            "stats_printing_task_skipped",
+            message="Stats printing is handled by plugin",
+        )
 
-    # Add pricing cache update task if enabled
     if scheduler_config.pricing_update_enabled:
-        try:
-            # Convert hours to seconds
-            interval_seconds = scheduler_config.pricing_update_interval_hours * 3600
-
-            await scheduler.add_task(
-                task_name="pricing_cache_update",
-                task_type="pricing_cache_update",
-                interval_seconds=interval_seconds,
-                enabled=True,
-                force_refresh_on_startup=scheduler_config.pricing_force_refresh_on_startup,
-            )
-            logger.debug(
-                "pricing_update_task_added",
-                interval_hours=scheduler_config.pricing_update_interval_hours,
-                force_refresh_on_startup=scheduler_config.pricing_force_refresh_on_startup,
-            )
-        except Exception as e:
-            logger.error(
-                "pricing_update_task_add_failed",
-                error=str(e),
-                error_type=type(e).__name__,
-            )
+        logger.debug(
+            "pricing_update_task_handled_by_plugin",
+            message="Pricing updates managed by plugin",
+            interval_hours=scheduler_config.pricing_update_interval_hours,
+        )
 
     # Add version update check task if enabled
     if scheduler_config.version_check_enabled:
@@ -129,43 +75,36 @@ async def setup_scheduler_tasks(scheduler: Scheduler, settings: Settings) -> Non
                 interval_hours=scheduler_config.version_check_interval_hours,
                 version_check_cache_ttl_hours=scheduler_config.version_check_cache_ttl_hours,
             )
+        except TaskRegistrationError as e:
+            logger.error(
+                "version_check_task_registration_failed",
+                error=str(e),
+                error_type=type(e).__name__,
+                exc_info=e,
+            )
         except Exception as e:
             logger.error(
                 "version_check_task_add_failed",
                 error=str(e),
                 error_type=type(e).__name__,
+                exc_info=e,
             )
 
 
-def _register_default_tasks(settings: Settings) -> None:
+def _register_default_tasks(registry: TaskRegistry, settings: Settings) -> None:
     """Register default task types in the global registry based on configuration."""
-    from .registry import get_task_registry
-
-    registry = get_task_registry()
-    scheduler_config = settings.scheduler
-
-    # Only register pushgateway task if enabled
-    if scheduler_config.pushgateway_enabled and not registry.is_registered(
-        "pushgateway"
-    ):
-        register_task("pushgateway", PushgatewayTask)
-
-    # Only register stats printing task if enabled
-    if scheduler_config.stats_printing_enabled and not registry.is_registered(
-        "stats_printing"
-    ):
-        register_task("stats_printing", StatsPrintingTask)
+    # Registry is provided by DI
 
     # Always register core tasks (not metrics-related)
-    if not registry.is_registered("pricing_cache_update"):
-        register_task("pricing_cache_update", PricingCacheUpdateTask)
-    if not registry.is_registered("version_update_check"):
-        register_task("version_update_check", VersionUpdateCheckTask)
-    if not registry.is_registered("pool_stats"):
-        register_task("pool_stats", PoolStatsTask)
+    if not registry.has("version_update_check"):
+        registry.register("version_update_check", VersionUpdateCheckTask)
+    if not registry.has("pool_stats"):
+        registry.register("pool_stats", PoolStatsTask)
 
 
-async def start_scheduler(settings: Settings) -> Scheduler | None:
+async def start_scheduler(
+    settings: Settings, container: ServiceContainer
+) -> Scheduler | None:
     """
     Start the scheduler with configured tasks.
 
@@ -180,13 +119,15 @@ async def start_scheduler(settings: Settings) -> Scheduler | None:
             logger.info("scheduler_disabled")
             return None
 
-        # Register task types (only when actually starting scheduler)
-        _register_default_tasks(settings)
+        # Resolve registry from DI and register task types
+        registry = container.get_task_registry()
+        _register_default_tasks(registry, settings)
 
         # Create scheduler with settings
         scheduler = Scheduler(
             max_concurrent_tasks=settings.scheduler.max_concurrent_tasks,
             graceful_shutdown_timeout=settings.scheduler.graceful_shutdown_timeout,
+            task_registry=registry,
         )
 
         # Start the scheduler
@@ -195,26 +136,33 @@ async def start_scheduler(settings: Settings) -> Scheduler | None:
         # Setup tasks based on configuration
         await setup_scheduler_tasks(scheduler, settings)
 
-        logger.info(
+        task_names = scheduler.list_tasks()
+        logger.debug(
             "scheduler_started",
             max_concurrent_tasks=settings.scheduler.max_concurrent_tasks,
             active_tasks=scheduler.task_count,
             running_tasks=len(
-                [
-                    name
-                    for name in scheduler.list_tasks()
-                    if scheduler.get_task(name).is_running
-                ]
+                [name for name in task_names if scheduler.get_task(name).is_running]
             ),
+            names=task_names,
         )
 
         return scheduler
 
+    except SchedulerError as e:
+        logger.error(
+            "scheduler_start_scheduler_error",
+            error=str(e),
+            error_type=type(e).__name__,
+            exc_info=e,
+        )
+        return None
     except Exception as e:
         logger.error(
             "scheduler_start_failed",
             error=str(e),
             error_type=type(e).__name__,
+            exc_info=e,
         )
         return None
 
@@ -231,9 +179,17 @@ async def stop_scheduler(scheduler: Scheduler | None) -> None:
 
     try:
         await scheduler.stop()
+    except SchedulerError as e:
+        logger.error(
+            "scheduler_stop_scheduler_error",
+            error=str(e),
+            error_type=type(e).__name__,
+            exc_info=e,
+        )
     except Exception as e:
         logger.error(
             "scheduler_stop_failed",
             error=str(e),
             error_type=type(e).__name__,
+            exc_info=e,
         )

ccproxy/scheduler/registry.py

@@ -1,5 +1,7 @@
 """Task registry for dynamic task registration and discovery."""
 
+from __future__ import annotations
+
 from typing import Any
 
 import structlog
@@ -79,7 +81,7 @@ class TaskRegistry:
 
         return self._tasks[name]
 
-    def list_tasks(self) -> list[str]:
+    def list(self) -> list[str]:
         """
         Get list of all registered task names.
 
@@ -88,7 +90,7 @@ class TaskRegistry:
         """
         return list(self._tasks.keys())
 
-    def is_registered(self, name: str) -> bool:
+    def has(self, name: str) -> bool:
         """
         Check if a task is registered.
 
@@ -105,7 +107,7 @@ class TaskRegistry:
         self._tasks.clear()
         logger.debug("task_registry_cleared")
 
-    def get_registry_info(self) -> dict[str, Any]:
+    def info(self) -> dict[str, Any]:
         """
         Get information about the current registry state.
 
@@ -119,32 +121,4 @@ class TaskRegistry:
         }
 
 
-# Global task registry instance
-_global_registry: TaskRegistry | None = None
-
-
-def get_task_registry() -> TaskRegistry:
-    """
-    Get the global task registry instance.
-
-    Returns:
-        Global TaskRegistry instance
-    """
-    global _global_registry
-
-    if _global_registry is None:
-        _global_registry = TaskRegistry()
-
-    return _global_registry
-
-
-def register_task(name: str, task_class: type[BaseScheduledTask]) -> None:
-    """
-    Register a task in the global registry.
-
-    Args:
-        name: Unique name for the task
-        task_class: Task class that inherits from BaseScheduledTask
-    """
-    registry = get_task_registry()
-    registry.register(name, task_class)
+# Module-level accessors intentionally omitted.