opengris-scaler 1.12.37__cp38-cp38-musllinux_1_2_x86_64.whl

scaler/cluster/combo.py

@@ -0,0 +1,157 @@
+import logging
+import socket
+from typing import Dict, Optional, Tuple
+
+from scaler.cluster.cluster import Cluster
+from scaler.cluster.object_storage_server import ObjectStorageServerProcess
+from scaler.cluster.scheduler import SchedulerProcess
+from scaler.config.common.logging import LoggingConfig
+from scaler.config.common.worker import WorkerConfig
+from scaler.config.defaults import (
+    DEFAULT_CLIENT_TIMEOUT_SECONDS,
+    DEFAULT_GARBAGE_COLLECT_INTERVAL_SECONDS,
+    DEFAULT_HARD_PROCESSOR_SUSPEND,
+    DEFAULT_HEARTBEAT_INTERVAL_SECONDS,
+    DEFAULT_IO_THREADS,
+    DEFAULT_LOAD_BALANCE_SECONDS,
+    DEFAULT_LOAD_BALANCE_TRIGGER_TIMES,
+    DEFAULT_LOGGING_LEVEL,
+    DEFAULT_LOGGING_PATHS,
+    DEFAULT_MAX_NUMBER_OF_TASKS_WAITING,
+    DEFAULT_OBJECT_RETENTION_SECONDS,
+    DEFAULT_PER_WORKER_QUEUE_SIZE,
+    DEFAULT_TASK_TIMEOUT_SECONDS,
+    DEFAULT_TRIM_MEMORY_THRESHOLD_BYTES,
+    DEFAULT_WORKER_DEATH_TIMEOUT,
+    DEFAULT_WORKER_TIMEOUT_SECONDS,
+)
+from scaler.config.section.cluster import ClusterConfig
+from scaler.config.types.object_storage_server import ObjectStorageAddressConfig
+from scaler.config.types.worker import WorkerCapabilities, WorkerNames
+from scaler.config.types.zmq import ZMQConfig
+from scaler.scheduler.allocate_policy.allocate_policy import AllocatePolicy
+from scaler.scheduler.controllers.scaling_policies.types import ScalingControllerStrategy
+from scaler.utility.network_util import get_available_tcp_port
+
+
+class SchedulerClusterCombo:
+    def __init__(
+        self,
+        n_workers: int,
+        address: Optional[str] = None,
+        object_storage_address: Optional[str] = None,
+        monitor_address: Optional[str] = None,
+        per_worker_capabilities: Optional[Dict[str, int]] = None,
+        worker_io_threads: int = DEFAULT_IO_THREADS,
+        scheduler_io_threads: int = DEFAULT_IO_THREADS,
+        max_number_of_tasks_waiting: int = DEFAULT_MAX_NUMBER_OF_TASKS_WAITING,
+        heartbeat_interval_seconds: int = DEFAULT_HEARTBEAT_INTERVAL_SECONDS,
+        client_timeout_seconds: int = DEFAULT_CLIENT_TIMEOUT_SECONDS,
+        worker_timeout_seconds: int = DEFAULT_WORKER_TIMEOUT_SECONDS,
+        object_retention_seconds: int = DEFAULT_OBJECT_RETENTION_SECONDS,
+        task_timeout_seconds: int = DEFAULT_TASK_TIMEOUT_SECONDS,
+        death_timeout_seconds: int = DEFAULT_WORKER_DEATH_TIMEOUT,
+        load_balance_seconds: int = DEFAULT_LOAD_BALANCE_SECONDS,
+        load_balance_trigger_times: int = DEFAULT_LOAD_BALANCE_TRIGGER_TIMES,
+        garbage_collect_interval_seconds: int = DEFAULT_GARBAGE_COLLECT_INTERVAL_SECONDS,
+        trim_memory_threshold_bytes: int = DEFAULT_TRIM_MEMORY_THRESHOLD_BYTES,
+        per_worker_task_queue_size: int = DEFAULT_PER_WORKER_QUEUE_SIZE,
+        hard_processor_suspend: bool = DEFAULT_HARD_PROCESSOR_SUSPEND,
+        protected: bool = True,
+        allocate_policy: AllocatePolicy = AllocatePolicy.even,
+        event_loop: str = "builtin",
+        logging_paths: Tuple[str, ...] = DEFAULT_LOGGING_PATHS,
+        logging_level: str = DEFAULT_LOGGING_LEVEL,
+        logging_config_file: Optional[str] = None,
+    ):
+        if address is None:
+            self._address = ZMQConfig.from_string(f"tcp://127.0.0.1:{get_available_tcp_port()}")
+        else:
+            self._address = ZMQConfig.from_string(address)
+
+        if object_storage_address is None:
+            self._object_storage_address = ObjectStorageAddressConfig(self._address.host, get_available_tcp_port())
+        else:
+            self._object_storage_address = ObjectStorageAddressConfig.from_string(object_storage_address)
+
+        if monitor_address is None:
+            self._monitor_address = None
+        else:
+            self._monitor_address = ZMQConfig.from_string(monitor_address)
+
+        self._object_storage = ObjectStorageServerProcess(
+            object_storage_address=self._object_storage_address,
+            logging_paths=logging_paths,
+            logging_level=logging_level,
+            logging_config_file=logging_config_file,
+        )
+        self._object_storage.start()
+        self._object_storage.wait_until_ready()  # object storage should be ready before starting the cluster
+
+        self._cluster = Cluster(
+            config=ClusterConfig(
+                scheduler_address=self._address,
+                object_storage_address=self._object_storage_address,
+                preload=None,
+                worker_names=WorkerNames([f"{socket.gethostname().split('.')[0]}" for _ in range(n_workers)]),
+                num_of_workers=n_workers,
+                event_loop=event_loop,
+                worker_io_threads=worker_io_threads,
+                worker_config=WorkerConfig(
+                    per_worker_capabilities=WorkerCapabilities(per_worker_capabilities or {}),
+                    per_worker_task_queue_size=per_worker_task_queue_size,
+                    heartbeat_interval_seconds=heartbeat_interval_seconds,
+                    task_timeout_seconds=task_timeout_seconds,
+                    death_timeout_seconds=death_timeout_seconds,
+                    garbage_collect_interval_seconds=garbage_collect_interval_seconds,
+                    trim_memory_threshold_bytes=trim_memory_threshold_bytes,
+                    hard_processor_suspend=hard_processor_suspend,
+                ),
+                logging_config=LoggingConfig(paths=logging_paths, config_file=logging_config_file, level=logging_level),
+            )
+        )
+
+        self._scheduler = SchedulerProcess(
+            address=self._address,
+            object_storage_address=self._object_storage_address,
+            monitor_address=self._monitor_address,
+            io_threads=scheduler_io_threads,
+            max_number_of_tasks_waiting=max_number_of_tasks_waiting,
+            client_timeout_seconds=client_timeout_seconds,
+            scaling_controller_strategy=ScalingControllerStrategy.NULL,
+            adapter_webhook_urls=(),
+            worker_timeout_seconds=worker_timeout_seconds,
+            object_retention_seconds=object_retention_seconds,
+            load_balance_seconds=load_balance_seconds,
+            load_balance_trigger_times=load_balance_trigger_times,
+            protected=protected,
+            allocate_policy=allocate_policy,
+            event_loop=event_loop,
+            logging_paths=logging_paths,
+            logging_config_file=logging_config_file,
+            logging_level=logging_level,
+        )
+
+        self._cluster.start()
+        self._scheduler.start()
+        logging.info(f"{self.__get_prefix()} started")
+
+    def __del__(self):
+        self.shutdown()
+
+    def shutdown(self):
+        logging.info(f"{self.__get_prefix()} shutdown")
+        self._cluster.terminate()
+        self._scheduler.terminate()
+        self._cluster.join()
+        self._scheduler.join()
+
+        # object storage should terminate after the cluster and scheduler.
+        self._object_storage.terminate()
+        self._object_storage.join()
+
+    def get_address(self) -> str:
+        return self._address.to_address()
+
+    def __get_prefix(self):
+        return f"{self.__class__.__name__}:"

scaler/cluster/object_storage_server.py

@@ -0,0 +1,45 @@
+import logging
+import multiprocessing
+from typing import Optional, Tuple
+
+from scaler.config.types.object_storage_server import ObjectStorageAddressConfig
+from scaler.object_storage.object_storage_server import ObjectStorageServer
+from scaler.utility.logging.utility import get_logger_info, setup_logger
+
+
+class ObjectStorageServerProcess(multiprocessing.get_context("fork").Process):  # type: ignore[misc]
+    def __init__(
+        self,
+        object_storage_address: ObjectStorageAddressConfig,
+        logging_paths: Tuple[str, ...],
+        logging_level: str,
+        logging_config_file: Optional[str],
+    ):
+        multiprocessing.Process.__init__(self, name="ObjectStorageServer")
+
+        self._logging_paths = logging_paths
+        self._logging_level = logging_level
+        self._logging_config_file = logging_config_file
+
+        self._object_storage_address = object_storage_address
+
+        self._server = ObjectStorageServer()
+
+    def wait_until_ready(self) -> None:
+        """Blocks until the object storage server is available to server requests."""
+        self._server.wait_until_ready()
+
+    def run(self) -> None:
+        setup_logger(self._logging_paths, self._logging_config_file, self._logging_level)
+        logging.info(f"ObjectStorageServer: start and listen to {self._object_storage_address.to_string()}")
+
+        log_format_str, log_level_str, logging_paths = get_logger_info(logging.getLogger())
+
+        self._server.run(
+            self._object_storage_address.host,
+            self._object_storage_address.port,
+            self._object_storage_address.identity,
+            log_level_str,
+            log_format_str,
+            logging_paths,
+        )

scaler/cluster/scheduler.py

@@ -0,0 +1,86 @@
+import asyncio
+import multiprocessing
+import signal
+from asyncio import AbstractEventLoop, Task
+from typing import Any, Optional, Tuple
+
+from scaler.config.section.scheduler import SchedulerConfig
+from scaler.config.types.object_storage_server import ObjectStorageAddressConfig
+from scaler.config.types.zmq import ZMQConfig
+from scaler.scheduler.allocate_policy.allocate_policy import AllocatePolicy
+from scaler.scheduler.controllers.scaling_policies.types import ScalingControllerStrategy
+from scaler.scheduler.scheduler import Scheduler, scheduler_main
+from scaler.utility.event_loop import register_event_loop
+from scaler.utility.logging.utility import setup_logger
+
+
+class SchedulerProcess(multiprocessing.get_context("spawn").Process):  # type: ignore[misc]
+    def __init__(
+        self,
+        address: ZMQConfig,
+        object_storage_address: Optional[ObjectStorageAddressConfig],
+        monitor_address: Optional[ZMQConfig],
+        scaling_controller_strategy: ScalingControllerStrategy,
+        adapter_webhook_urls: Tuple[str, ...],
+        io_threads: int,
+        max_number_of_tasks_waiting: int,
+        client_timeout_seconds: int,
+        worker_timeout_seconds: int,
+        object_retention_seconds: int,
+        load_balance_seconds: int,
+        load_balance_trigger_times: int,
+        protected: bool,
+        allocate_policy: AllocatePolicy,
+        event_loop: str,
+        logging_paths: Tuple[str, ...],
+        logging_config_file: Optional[str],
+        logging_level: str,
+    ):
+        multiprocessing.Process.__init__(self, name="Scheduler")
+        self._scheduler_config = SchedulerConfig(
+            scheduler_address=address,
+            object_storage_address=object_storage_address,
+            monitor_address=monitor_address,
+            scaling_controller_strategy=scaling_controller_strategy,
+            adapter_webhook_urls=adapter_webhook_urls,
+            protected=protected,
+            allocate_policy=allocate_policy,
+            max_number_of_tasks_waiting=max_number_of_tasks_waiting,
+            client_timeout_seconds=client_timeout_seconds,
+            worker_timeout_seconds=worker_timeout_seconds,
+            object_retention_seconds=object_retention_seconds,
+            load_balance_seconds=load_balance_seconds,
+            load_balance_trigger_times=load_balance_trigger_times,
+            event_loop=event_loop,
+            worker_io_threads=io_threads,
+        )
+
+        self._logging_paths = logging_paths
+        self._logging_config_file = logging_config_file
+        self._logging_level = logging_level
+
+        self._scheduler: Optional[Scheduler] = None
+        self._loop: Optional[AbstractEventLoop] = None
+        self._task: Optional[Task[Any]] = None
+
+    def run(self) -> None:
+        # scheduler have its own single process
+        setup_logger(self._logging_paths, self._logging_config_file, self._logging_level)
+        register_event_loop(self._scheduler_config.event_loop)
+
+        self._loop = asyncio.get_event_loop()
+        SchedulerProcess.__register_signal(self._loop)
+
+        self._task = self._loop.create_task(scheduler_main(self._scheduler_config))
+
+        self._loop.run_until_complete(self._task)
+
+    @staticmethod
+    def __register_signal(loop):
+        loop.add_signal_handler(signal.SIGINT, SchedulerProcess.__handle_signal)
+        loop.add_signal_handler(signal.SIGTERM, SchedulerProcess.__handle_signal)
+
+    @staticmethod
+    def __handle_signal():
+        for task in asyncio.all_tasks():
+            task.cancel()

scaler/config/common/logging.py

@@ -0,0 +1,41 @@
+import dataclasses
+from typing import Optional, Tuple
+
+from scaler.config import defaults
+from scaler.config.config_class import ConfigClass
+from scaler.utility.logging.utility import LoggingLevel
+
+
+@dataclasses.dataclass
+class LoggingConfig(ConfigClass):
+    paths: Tuple[str, ...] = dataclasses.field(
+        default=defaults.DEFAULT_LOGGING_PATHS,
+        metadata=dict(
+            type=str,
+            long="--logging-paths",
+            short="-lp",
+            nargs="*",
+            help="specify where the cluster's log should logged to, there can be multiple paths."
+            '"/dev/stdout" means output to stdout, and is the default. '
+            "each worker has its own log file with process id appended to the path",
+        ),
+    )
+    config_file: Optional[str] = dataclasses.field(
+        default=None,
+        metadata=dict(
+            long="--logging-config-file",
+            short="-lcf",
+            help="provide a separate config file for logging, in python's standard .conf format. "
+            "this will supercede configuration passed to other --logging-* parameters, "
+            "and also does not support per-worker logging",
+        ),
+    )
+    level: str = dataclasses.field(
+        default=defaults.DEFAULT_LOGGING_LEVEL,
+        metadata=dict(
+            long="--logging-level",
+            short="-ll",
+            choices=[member.name for member in LoggingLevel if member is not LoggingLevel.NOTSET],
+            help="set the logging level",
+        ),
+    )

scaler/config/common/web.py

@@ -0,0 +1,18 @@
+import dataclasses
+from typing import Optional
+
+from scaler.config.config_class import ConfigClass
+
+
+@dataclasses.dataclass
+class WebConfig(ConfigClass):
+    adapter_web_host: Optional[str] = dataclasses.field(
+        default=None, metadata=dict(required=True, help="host address for the worker adapter HTTP server")
+    )
+    adapter_web_port: Optional[int] = dataclasses.field(
+        default=None, metadata=dict(short="-p", required=True, help="port for the worker adapter HTTP server")
+    )
+
+    def __post_init__(self) -> None:
+        if self.adapter_web_port and not (1 <= self.adapter_web_port <= 65535):
+            raise ValueError(f"adapter_web_port must be between 1 and 65535, but got {self.adapter_web_port}")

scaler/config/common/worker.py

@@ -0,0 +1,65 @@
+import dataclasses
+
+from scaler.config import defaults
+from scaler.config.config_class import ConfigClass
+from scaler.config.types.worker import WorkerCapabilities
+
+
+@dataclasses.dataclass
+class WorkerConfig(ConfigClass):
+    per_worker_capabilities: WorkerCapabilities = dataclasses.field(
+        default_factory=WorkerCapabilities,
+        metadata=dict(
+            short="-pwc", help='a comma-separated list of capabilities provided by the workers (e.g. "linux,cpu=4")'
+        ),
+    )
+    per_worker_task_queue_size: int = dataclasses.field(
+        default=defaults.DEFAULT_PER_WORKER_QUEUE_SIZE,
+        metadata=dict(short="-wtqs", help="set the per worker queue size"),
+    )
+    heartbeat_interval_seconds: int = dataclasses.field(
+        default=defaults.DEFAULT_HEARTBEAT_INTERVAL_SECONDS,
+        metadata=dict(short="-his", help="the interval at which to send heartbeats in seconds"),
+    )
+    task_timeout_seconds: int = dataclasses.field(
+        default=defaults.DEFAULT_TASK_TIMEOUT_SECONDS,
+        metadata=dict(
+            short="-tts", help="the number of seconds before a task is considered timed out and an error is raised"
+        ),
+    )
+    death_timeout_seconds: int = dataclasses.field(
+        default=defaults.DEFAULT_WORKER_DEATH_TIMEOUT, metadata=dict(short="-dts", help="death timeout seconds")
+    )
+    garbage_collect_interval_seconds: int = dataclasses.field(
+        default=defaults.DEFAULT_GARBAGE_COLLECT_INTERVAL_SECONDS,
+        metadata=dict(short="-gc", help="the interval at which the garbage collector is run in seconds"),
+    )
+    trim_memory_threshold_bytes: int = dataclasses.field(
+        default=defaults.DEFAULT_TRIM_MEMORY_THRESHOLD_BYTES,
+        metadata=dict(short="-tm", help="set the threshold for trimming libc's memory"),
+    )
+    hard_processor_suspend: bool = dataclasses.field(
+        default=defaults.DEFAULT_HARD_PROCESSOR_SUSPEND,
+        metadata=dict(
+            short="-hps",
+            action="store_true",
+            help=(
+                "when set, suspends worker processors using the SIGTSTP signal instead of a synchronization event, "
+                "fully halting computation on suspended tasks. this may cause some tasks to fail if they "
+                "do not support being paused at the OS level (e.g. tasks requiring active network connections)"
+            ),
+        ),
+    )
+
+    def __post_init__(self) -> None:
+        if self.per_worker_task_queue_size <= 0:
+            raise ValueError("per_worker_task_queue_size must be positive.")
+        if (
+            self.heartbeat_interval_seconds <= 0
+            or self.task_timeout_seconds < 0
+            or self.death_timeout_seconds <= 0
+            or self.garbage_collect_interval_seconds <= 0
+        ):
+            raise ValueError("All interval/timeout second values must be positive.")
+        if self.trim_memory_threshold_bytes < 0:
+            raise ValueError("trim_memory_threshold_bytes cannot be negative.")

scaler/config/common/worker_adapter.py

@@ -0,0 +1,28 @@
+import dataclasses
+from typing import Optional
+
+from scaler.config import defaults
+from scaler.config.config_class import ConfigClass
+from scaler.config.types.object_storage_server import ObjectStorageAddressConfig
+from scaler.config.types.zmq import ZMQConfig
+
+
+@dataclasses.dataclass
+class WorkerAdapterConfig(ConfigClass):
+    scheduler_address: ZMQConfig = dataclasses.field(
+        metadata=dict(positional=True, help="scheduler address to connect workers to")
+    )
+
+    object_storage_address: Optional[ObjectStorageAddressConfig] = dataclasses.field(
+        default=None,
+        metadata=dict(short="-osa", help="specify the object storage server address, e.g.: tcp://localhost:2346"),
+    )
+
+    max_workers: int = dataclasses.field(
+        default=defaults.DEFAULT_NUMBER_OF_WORKER,
+        metadata=dict(short="-mw", help="maximum number of workers that can be started, -1 means no limit"),
+    )
+
+    def __post_init__(self) -> None:
+        if self.max_workers != -1 and self.max_workers <= 0:
+            raise ValueError("max_workers must be -1 (no limit) or a positive integer.")