opengris-scaler 1.12.7__cp38-cp38-manylinux_2_28_x86_64.whl

scaler/cluster/combo.py

@@ -0,0 +1,148 @@
+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.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_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,
+    DEFAULT_LOGGING_LEVEL,
+    DEFAULT_LOGGING_PATHS,
+)
+from scaler.scheduler.allocate_policy.allocate_policy import AllocatePolicy
+from scaler.utility.network_util import get_available_tcp_port
+from scaler.config.types.object_storage_server import ObjectStorageConfig
+from scaler.config.types.zmq import ZMQConfig
+
+
+class SchedulerClusterCombo:
+    def __init__(
+        self,
+        n_workers: int,
+        address: Optional[str] = None,
+        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 storage_address is None:
+            self._storage_address = ObjectStorageConfig(self._address.host, get_available_tcp_port())
+        else:
+            self._storage_address = ObjectStorageConfig.from_string(storage_address)
+
+        if monitor_address is None:
+            self._monitor_address = None
+        else:
+            self._monitor_address = ZMQConfig.from_string(monitor_address)
+
+        self._object_storage = ObjectStorageServerProcess(
+            storage_address=self._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(
+            address=self._address,
+            storage_address=self._storage_address,
+            preload=None,
+            worker_io_threads=worker_io_threads,
+            worker_names=[f"{socket.gethostname().split('.')[0]}_{i}" for i in range(n_workers)],
+            per_worker_capabilities=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,
+            event_loop=event_loop,
+            logging_paths=logging_paths,
+            logging_config_file=logging_config_file,
+            logging_level=logging_level,
+        )
+
+        self._scheduler = SchedulerProcess(
+            address=self._address,
+            storage_address=self._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,
+            adapter_webhook_url=None,
+            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.object_storage.object_storage_server import ObjectStorageServer
+from scaler.utility.logging.utility import get_logger_info, setup_logger
+from scaler.config.types.object_storage_server import ObjectStorageConfig
+
+
+class ObjectStorageServerProcess(multiprocessing.get_context("fork").Process):  # type: ignore[misc]
+    def __init__(
+        self,
+        storage_address: ObjectStorageConfig,
+        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._storage_address = 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._storage_address.to_string()}")
+
+        log_format_str, log_level_str, logging_paths = get_logger_info(logging.getLogger())
+
+        self._server.run(
+            self._storage_address.host,
+            self._storage_address.port,
+            self._storage_address.identity,
+            log_level_str,
+            log_format_str,
+            logging_paths,
+        )

scaler/cluster/scheduler.py

@@ -0,0 +1,83 @@
+import asyncio
+import multiprocessing
+import signal
+from asyncio import AbstractEventLoop, Task
+from typing import Any, Optional, Tuple
+
+from scaler.scheduler.allocate_policy.allocate_policy import AllocatePolicy
+from scaler.config.section.scheduler import SchedulerConfig
+from scaler.config.types.object_storage_server import ObjectStorageConfig
+from scaler.config.types.zmq import ZMQConfig
+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,
+        storage_address: Optional[ObjectStorageConfig],
+        monitor_address: Optional[ZMQConfig],
+        adapter_webhook_url: Optional[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(
+            event_loop=event_loop,
+            scheduler_address=address,
+            object_storage_address=storage_address,
+            monitor_address=monitor_address,
+            adapter_webhook_url=adapter_webhook_url,
+            io_threads=io_threads,
+            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,
+            protected=protected,
+            allocate_policy=allocate_policy,
+        )
+
+        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/defaults.py

@@ -0,0 +1,87 @@
+import os
+
+# ==============
+# SYSTEM OPTIONS
+
+# object clean up time interval
+CLEANUP_INTERVAL_SECONDS = 1
+
+# status report interval, used by poke or scaled monitor
+STATUS_REPORT_INTERVAL_SECONDS = 1
+
+# number of seconds for profiling
+PROFILING_INTERVAL_SECONDS = 1
+
+# cap'n proto only allow Data/Text/Blob size to be as big as 500MB
+CAPNP_DATA_SIZE_LIMIT = 2**29 - 1
+
+# message size limitation, max can be 2**64
+CAPNP_MESSAGE_SIZE_LIMIT = 2**64 - 1
+
+# ==========================
+# SCHEDULER SPECIFIC OPTIONS
+
+# number of threads for zmq socket to handle
+DEFAULT_IO_THREADS = 1
+
+# if all workers are full and busy working, this option determine how many additional tasks scheduler can receive and
+# queued, if additional number of tasks received exceeded this number, scheduler will reject tasks
+DEFAULT_MAX_NUMBER_OF_TASKS_WAITING = -1
+
+# if didn't receive heartbeat for following seconds, then scheduler will treat worker as dead and reschedule unfinished
+# tasks for this worker
+DEFAULT_WORKER_TIMEOUT_SECONDS = 60
+
+# if didn't receive heartbeat for following seconds, then scheduler will treat client as dead and cancel remaining
+# tasks for this client
+DEFAULT_CLIENT_TIMEOUT_SECONDS = 60
+
+# number of seconds for load balance, if value is -1 means disable load balance
+DEFAULT_LOAD_BALANCE_SECONDS = 1
+
+# when load balance advice happened repeatedly and always be the same, we issue load balance request when exact repeated
+# times happened
+DEFAULT_LOAD_BALANCE_TRIGGER_TIMES = 2
+
+# number of tasks can be queued to each worker on scheduler side
+DEFAULT_PER_WORKER_QUEUE_SIZE = 1000
+
+# =======================
+# WORKER SPECIFIC OPTIONS
+
+# number of workers, echo worker use 1 process
+DEFAULT_NUMBER_OF_WORKER = os.cpu_count() - 1
+
+# number of seconds that worker agent send heartbeat to scheduler
+DEFAULT_HEARTBEAT_INTERVAL_SECONDS = 2
+
+# number of seconds the object cache kept in worker's memory
+DEFAULT_OBJECT_RETENTION_SECONDS = 60
+
+# number of seconds worker doing garbage collection
+DEFAULT_GARBAGE_COLLECT_INTERVAL_SECONDS = 30
+
+# number of bytes threshold for worker process that trigger deep garbage collection
+DEFAULT_TRIM_MEMORY_THRESHOLD_BYTES = 1024 * 1024 * 1024
+
+# default task timeout seconds, 0 means never timeout
+DEFAULT_TASK_TIMEOUT_SECONDS = 0
+
+# number of seconds that worker agent wait for processor to finish before killing it
+DEFAULT_PROCESSOR_KILL_DELAY_SECONDS = 3
+
+# number of seconds without scheduler contact before worker shuts down
+DEFAULT_WORKER_DEATH_TIMEOUT = 5 * 60
+
+# if true, suspended worker's processors will be actively suspended with a SIGTSTP signal, otherwise a synchronization
+# event will be used.
+DEFAULT_HARD_PROCESSOR_SUSPEND = False
+
+# =======================
+# LOGGING SPECIFIC OPTIONS
+
+# default logging level
+DEFAULT_LOGGING_LEVEL = "INFO"
+
+# default logging paths
+DEFAULT_LOGGING_PATHS = ("/dev/stdout",)

scaler/config/loader.py

@@ -0,0 +1,95 @@
+import argparse
+import dataclasses
+import enum
+from typing import Any, cast, Dict, Optional, Type, TypeVar, Union, get_args, get_origin
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
+
+from scaler.config.mixins import ConfigType
+
+T = TypeVar("T")
+
+
+def load_config(
+    config_class: Type[T], config_path: Optional[str], args: argparse.Namespace, section_name: Optional[str] = None
+) -> T:
+    """
+    Loads configuration for a given dataclass from a TOML file and overrides it with command-line arguments.
+    """
+    if not dataclasses.is_dataclass(config_class):
+        raise TypeError(f"{config_class.__name__} is not a dataclass and cannot be used with this config loader.")
+
+    config_from_file = {}
+    if config_path:
+        try:
+            with open(config_path, "rb") as f:
+                try:
+                    full_config = tomllib.load(f)
+                except tomllib.TOMLDecodeError as e:
+                    raise ValueError(f"Error parsing TOML file at {config_path}: {e}") from e
+
+                if section_name:
+                    config_from_file = full_config.get(section_name, {})
+                else:
+                    config_from_file = full_config
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Configuration file not found at: {config_path}")
+
+    config_from_args = {k: v for k, v in vars(args).items() if v is not None}
+    merged_config_data = {**config_from_file, **config_from_args}
+
+    valid_keys = {f.name for f in dataclasses.fields(config_class)}
+    unknown_keys = set(merged_config_data.keys()) - valid_keys - {"config"}
+    if unknown_keys:
+        raise ValueError(f"Unknown configuration key(s) for {config_class.__name__}: {', '.join(unknown_keys)}")
+
+    final_kwargs: Dict[str, Any] = {}
+    for field in dataclasses.fields(config_class):
+        if field.name in merged_config_data:
+            raw_value = merged_config_data[field.name]
+            field_type = field.type
+            is_optional = get_origin(field_type) is Union
+            if is_optional:
+                possible_types = [t for t in get_args(field_type) if t is not type(None)]
+                actual_type = possible_types[0] if possible_types else field_type
+            else:
+                actual_type = field_type
+
+            if (
+                isinstance(raw_value, str)
+                and isinstance(actual_type, type)
+                and issubclass(actual_type, ConfigType)
+                and not isinstance(raw_value, actual_type)
+            ):
+                final_kwargs[field.name] = actual_type.from_string(raw_value)
+            elif isinstance(raw_value, str) and isinstance(actual_type, type) and issubclass(actual_type, enum.Enum):
+                try:
+                    final_kwargs[field.name] = actual_type[raw_value]
+                except KeyError as e:
+                    raise ValueError(f"'{raw_value}' is not a valid member for {actual_type.__name__}") from e
+            elif isinstance(raw_value, list) and get_origin(field.type) is tuple:
+                final_kwargs[field.name] = tuple(raw_value)
+            else:
+                final_kwargs[field.name] = raw_value
+
+    try:
+        return cast(T, config_class(**final_kwargs))
+    except TypeError as e:
+        missing_fields = [
+            f.name
+            for f in dataclasses.fields(config_class)
+            if f.init
+            and f.name not in final_kwargs
+            and f.default is dataclasses.MISSING
+            and f.default_factory is dataclasses.MISSING
+        ]
+        if missing_fields:
+            raise ValueError(
+                f"Missing required configuration arguments: {', '.join(missing_fields)}. "
+                f"Please provide them via command line or a TOML config file."
+            ) from e
+        else:
+            raise e

scaler/config/mixins.py

@@ -0,0 +1,15 @@
+import abc
+from typing_extensions import Self
+
+
+class ConfigType(metaclass=abc.ABCMeta):
+    """A base class for composite config values that can be parsed and serialized from/to a string."""
+
+    @classmethod
+    @abc.abstractmethod
+    def from_string(cls, value: str) -> Self:
+        pass
+
+    @abc.abstractmethod
+    def __str__(self) -> str:
+        pass

scaler/config/section/cluster.py

@@ -0,0 +1,56 @@
+import dataclasses
+from typing import Optional, Tuple
+
+from scaler.config import defaults
+from scaler.utility.logging.utility import LoggingLevel
+
+from scaler.config.types.object_storage_server import ObjectStorageConfig
+from scaler.config.types.worker import WorkerCapabilities, WorkerNames
+from scaler.config.types.zmq import ZMQConfig
+
+
+@dataclasses.dataclass
+class ClusterConfig:
+    scheduler_address: ZMQConfig
+    storage_address: Optional[ObjectStorageConfig] = None
+    preload: Optional[str] = None
+    worker_io_threads: int = defaults.DEFAULT_IO_THREADS
+    worker_names: WorkerNames = dataclasses.field(default_factory=lambda: WorkerNames.from_string(""))
+    num_of_workers: int = defaults.DEFAULT_NUMBER_OF_WORKER
+    per_worker_capabilities: WorkerCapabilities = dataclasses.field(
+        default_factory=lambda: WorkerCapabilities.from_string("")
+    )
+    per_worker_task_queue_size: int = defaults.DEFAULT_PER_WORKER_QUEUE_SIZE
+    heartbeat_interval_seconds: int = defaults.DEFAULT_HEARTBEAT_INTERVAL_SECONDS
+    task_timeout_seconds: int = defaults.DEFAULT_TASK_TIMEOUT_SECONDS
+    death_timeout_seconds: int = defaults.DEFAULT_WORKER_DEATH_TIMEOUT
+    garbage_collect_interval_seconds: int = defaults.DEFAULT_GARBAGE_COLLECT_INTERVAL_SECONDS
+    trim_memory_threshold_bytes: int = defaults.DEFAULT_TRIM_MEMORY_THRESHOLD_BYTES
+    hard_processor_suspend: bool = defaults.DEFAULT_HARD_PROCESSOR_SUSPEND
+    event_loop: str = "builtin"
+    logging_paths: Tuple[str, ...] = defaults.DEFAULT_LOGGING_PATHS
+    logging_config_file: Optional[str] = None
+    logging_level: str = defaults.DEFAULT_LOGGING_LEVEL
+
+    def __post_init__(self):
+        if self.worker_io_threads <= 0:
+            raise ValueError("worker_io_threads must be a positive integer.")
+        if self.worker_names.names and len(self.worker_names.names) != self.num_of_workers:
+            raise ValueError(
+                f"The number of worker_names ({len(self.worker_names.names)}) \
+                    must match num_of_workers ({self.num_of_workers})."
+            )
+        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.")
+        valid_levels = {level.name for level in LoggingLevel}
+        if self.logging_level.upper() not in valid_levels:
+            raise ValueError(f"logging_level must be one of {valid_levels}, but got '{self.logging_level}'")

scaler/config/section/native_worker_adapter.py

@@ -0,0 +1,44 @@
+import dataclasses
+from typing import Optional, Tuple
+
+from scaler.config.types.object_storage_server import ObjectStorageConfig
+from scaler.config.types.worker import WorkerCapabilities
+from scaler.config.types.zmq import ZMQConfig
+
+from scaler.config import defaults
+
+
+@dataclasses.dataclass
+class NativeWorkerAdapterConfig:
+    scheduler_address: ZMQConfig
+    storage_address: Optional[ObjectStorageConfig] = None
+    adapter_web_host: str = "localhost"
+    adapter_web_port: int = 8080
+    per_worker_capabilities: WorkerCapabilities = dataclasses.field(
+        default_factory=lambda: WorkerCapabilities.from_string("")
+    )
+    io_threads: int = defaults.DEFAULT_IO_THREADS
+    worker_task_queue_size: int = defaults.DEFAULT_PER_WORKER_QUEUE_SIZE
+    max_workers: int = defaults.DEFAULT_NUMBER_OF_WORKER
+    heartbeat_interval_seconds: int = defaults.DEFAULT_HEARTBEAT_INTERVAL_SECONDS
+    task_timeout_seconds: int = defaults.DEFAULT_TASK_TIMEOUT_SECONDS
+    death_timeout_seconds: int = defaults.DEFAULT_WORKER_DEATH_TIMEOUT
+    garbage_collect_interval_seconds: int = defaults.DEFAULT_GARBAGE_COLLECT_INTERVAL_SECONDS
+    trim_memory_threshold_bytes: int = defaults.DEFAULT_TRIM_MEMORY_THRESHOLD_BYTES
+    hard_processor_suspend: bool = defaults.DEFAULT_HARD_PROCESSOR_SUSPEND
+    event_loop: str = "builtin"
+    logging_paths: Tuple[str, ...] = defaults.DEFAULT_LOGGING_PATHS
+    logging_level: str = defaults.DEFAULT_LOGGING_LEVEL
+    logging_config_file: Optional[str] = None
+
+    def __post_init__(self):
+        if not isinstance(self.adapter_web_host, str):
+            raise TypeError(f"adapter_web_host should be string, given {self.adapter_web_host}")
+        if not isinstance(self.adapter_web_port, int):
+            raise TypeError(f"adapter_web_port must be between 1 and 65535, but got {self.adapter_web_port}")
+        if self.io_threads <= 0:
+            raise ValueError("io_threads must be a positive integer.")
+        if self.worker_task_queue_size <= 0:
+            raise ValueError("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:
+            raise ValueError("All interval/timeout second values must be positive.")

scaler/config/section/object_storage_server.py

@@ -0,0 +1,7 @@
+import dataclasses
+from scaler.config.types.object_storage_server import ObjectStorageConfig
+
+
+@dataclasses.dataclass
+class ObjectStorageServerConfig:
+    object_storage_address: ObjectStorageConfig

scaler/config/section/scheduler.py

@@ -0,0 +1,53 @@
+import dataclasses
+from typing import Optional, Tuple
+from urllib.parse import urlparse
+
+from scaler.config import defaults
+from scaler.scheduler.allocate_policy.allocate_policy import AllocatePolicy
+from scaler.utility.logging.utility import LoggingLevel
+
+from scaler.config.types.object_storage_server import ObjectStorageConfig
+from scaler.config.types.zmq import ZMQConfig
+
+
+@dataclasses.dataclass
+class SchedulerConfig:
+    scheduler_address: ZMQConfig = dataclasses.field()
+    object_storage_address: Optional[ObjectStorageConfig] = None
+    monitor_address: Optional[ZMQConfig] = None
+    adapter_webhook_url: Optional[str] = None
+    protected: bool = True
+    allocate_policy: AllocatePolicy = AllocatePolicy.even
+    event_loop: str = "builtin"
+    io_threads: int = defaults.DEFAULT_IO_THREADS
+    max_number_of_tasks_waiting: int = defaults.DEFAULT_MAX_NUMBER_OF_TASKS_WAITING
+    client_timeout_seconds: int = defaults.DEFAULT_CLIENT_TIMEOUT_SECONDS
+    worker_timeout_seconds: int = defaults.DEFAULT_WORKER_TIMEOUT_SECONDS
+    object_retention_seconds: int = defaults.DEFAULT_OBJECT_RETENTION_SECONDS
+    load_balance_seconds: int = defaults.DEFAULT_LOAD_BALANCE_SECONDS
+    load_balance_trigger_times: int = defaults.DEFAULT_LOAD_BALANCE_TRIGGER_TIMES
+    logging_paths: Tuple[str, ...] = defaults.DEFAULT_LOGGING_PATHS
+    logging_config_file: Optional[str] = None
+    logging_level: str = defaults.DEFAULT_LOGGING_LEVEL
+
+    def __post_init__(self):
+        if self.io_threads <= 0:
+            raise ValueError("io_threads must be a positive integer.")
+        if self.max_number_of_tasks_waiting < -1:
+            raise ValueError("max_number_of_tasks_waiting must be -1 (for unlimited) or non-negative.")
+        if (
+            self.client_timeout_seconds <= 0
+            or self.worker_timeout_seconds <= 0
+            or self.object_retention_seconds <= 0
+            or self.load_balance_seconds <= 0
+        ):
+            raise ValueError("All timeout/retention/balance second values must be positive.")
+        if self.load_balance_trigger_times <= 0:
+            raise ValueError("load_balance_trigger_times must be a positive integer.")
+        if self.adapter_webhook_url:
+            parsed_url = urlparse(self.adapter_webhook_url)
+            if not all([parsed_url.scheme, parsed_url.netloc]):
+                raise ValueError(f"adapter_webhook_url '{self.adapter_webhook_url}' is not a valid URL.")
+        valid_levels = {level.name for level in LoggingLevel}
+        if self.logging_level.upper() not in valid_levels:
+            raise ValueError(f"logging_level must be one of {valid_levels}, but got '{self.logging_level}'")