opengris-scaler 1.12.37__cp38-cp38-musllinux_1_2_x86_64.whl

scaler/config/section/scheduler.py

@@ -0,0 +1,126 @@
+import dataclasses
+from typing import Optional, Tuple
+from urllib.parse import urlparse
+
+from scaler.config import defaults
+from scaler.config.common.logging import LoggingConfig
+from scaler.config.config_class import ConfigClass
+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.utility.event_loop import EventLoopType
+
+
+@dataclasses.dataclass
+class SchedulerConfig(ConfigClass):
+    scheduler_address: ZMQConfig = dataclasses.field(
+        metadata=dict(positional=True, help="scheduler address to connect to, e.g.: `tcp://localhost:6378`")
+    )
+    object_storage_address: Optional[ObjectStorageAddressConfig] = dataclasses.field(
+        default=None,
+        metadata=dict(
+            short="-osa",
+            help="specify the object storage server address, if not specified, "
+            "the address is scheduler address with port number plus 1, "
+            "e.g.: if scheduler address is tcp://localhost:2345, "
+            "then object storage address is tcp://localhost:2346",
+        ),
+    )
+    monitor_address: Optional[ZMQConfig] = dataclasses.field(
+        default=None,
+        metadata=dict(
+            short="-ma",
+            help="specify monitoring address, if not specified, the monitoring address is scheduler address with port "
+            "number plus 2, e.g.: if scheduler address is tcp://localhost:2345, then monitoring address is "
+            "tcp://localhost:2347",
+        ),
+    )
+    scaling_controller_strategy: ScalingControllerStrategy = dataclasses.field(
+        default=ScalingControllerStrategy.NULL,
+        metadata=dict(
+            short="-scs",
+            choices=[s.name for s in ScalingControllerStrategy],
+            help="specify the scaling controller strategy, if not specified, no scaling controller will be used",
+        ),
+    )
+    adapter_webhook_urls: Tuple[str, ...] = dataclasses.field(
+        default=(),
+        metadata=dict(
+            short="-awu",
+            type=str,
+            nargs="*",
+            help="specify the adapter webhook urls for the scaling controller to send scaling events to",
+        ),
+    )
+    protected: bool = dataclasses.field(
+        default=False,
+        metadata=dict(
+            short="-p", action="store_true", help="protect scheduler and worker from being shutdown by client"
+        ),
+    )
+    allocate_policy: AllocatePolicy = dataclasses.field(
+        default=AllocatePolicy.even,
+        metadata=dict(
+            short="-ap",
+            choices=[p.name for p in AllocatePolicy],
+            help="specify allocate policy, this controls how scheduler will prioritize tasks, "
+            "including balancing tasks",
+        ),
+    )
+    max_number_of_tasks_waiting: int = dataclasses.field(
+        default=defaults.DEFAULT_MAX_NUMBER_OF_TASKS_WAITING,
+        metadata=dict(short="-mt", help="max number of tasks can wait in scheduler while all workers are full"),
+    )
+    client_timeout_seconds: int = dataclasses.field(
+        default=defaults.DEFAULT_CLIENT_TIMEOUT_SECONDS,
+        metadata=dict(short="-ct", help="discard client when timeout seconds reached"),
+    )
+    worker_timeout_seconds: int = dataclasses.field(
+        default=defaults.DEFAULT_WORKER_TIMEOUT_SECONDS,
+        metadata=dict(short="-wt", help="discard worker when timeout seconds reached"),
+    )
+    object_retention_seconds: int = dataclasses.field(
+        default=defaults.DEFAULT_OBJECT_RETENTION_SECONDS,
+        metadata=dict(short="-ot", help="discard function in scheduler when timeout seconds reached"),
+    )
+    load_balance_seconds: int = dataclasses.field(
+        default=defaults.DEFAULT_LOAD_BALANCE_SECONDS,
+        metadata=dict(short="-ls", help="number of seconds for load balance operation in scheduler"),
+    )
+    load_balance_trigger_times: int = dataclasses.field(
+        default=defaults.DEFAULT_LOAD_BALANCE_TRIGGER_TIMES,
+        metadata=dict(
+            short="-lbt",
+            help="exact number of repeated load balance advices when trigger load balance operation in scheduler",
+        ),
+    )
+    event_loop: str = dataclasses.field(
+        default="builtin",
+        metadata=dict(short="-el", choices=EventLoopType.allowed_types(), help="select the event loop type"),
+    )
+
+    worker_io_threads: int = dataclasses.field(
+        default=defaults.DEFAULT_IO_THREADS,
+        metadata=dict(short="-wit", help="set the number of io threads for io backend per worker"),
+    )
+    logging_config: LoggingConfig = dataclasses.field(default_factory=LoggingConfig)
+
+    def __post_init__(self):
+        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.")
+        for adapter_webhook_url in self.adapter_webhook_urls:
+            parsed_url = urlparse(adapter_webhook_url)
+            if not all([parsed_url.scheme, parsed_url.netloc]):
+                raise ValueError(f"adapter_webhook_urls contains url '{adapter_webhook_url}' which is not a valid URL.")
+        if self.worker_io_threads <= 0:
+            raise ValueError("worker_io_threads must be a positive integer.")

scaler/config/section/symphony_worker_adapter.py

@@ -0,0 +1,35 @@
+import dataclasses
+
+from scaler.config import defaults
+from scaler.config.common.logging import LoggingConfig
+from scaler.config.common.web import WebConfig
+from scaler.config.common.worker import WorkerConfig
+from scaler.config.common.worker_adapter import WorkerAdapterConfig
+from scaler.config.config_class import ConfigClass
+from scaler.utility.event_loop import EventLoopType
+
+
+@dataclasses.dataclass
+class SymphonyWorkerConfig(ConfigClass):
+    service_name: str = dataclasses.field(metadata=dict(short="-sn", help="symphony service name"))
+
+    web_config: WebConfig
+    worker_adapter_config: WorkerAdapterConfig
+    worker_config: WorkerConfig = dataclasses.field(default_factory=WorkerConfig)
+    logging_config: LoggingConfig = dataclasses.field(default_factory=LoggingConfig)
+    event_loop: str = dataclasses.field(
+        default="builtin",
+        metadata=dict(short="-el", choices=EventLoopType.allowed_types(), help="select the event loop type"),
+    )
+
+    worker_io_threads: int = dataclasses.field(
+        default=defaults.DEFAULT_IO_THREADS,
+        metadata=dict(short="-wit", help="set the number of io threads for io backend per worker"),
+    )
+
+    def __post_init__(self):
+        """Validates configuration values after initialization."""
+        if not self.service_name:
+            raise ValueError("service_name cannot be an empty string.")
+        if self.worker_io_threads <= 0:
+            raise ValueError("worker_io_threads must be a positive integer.")

scaler/config/section/top.py

@@ -0,0 +1,16 @@
+import dataclasses
+
+from scaler.config.config_class import ConfigClass
+from scaler.config.types.zmq import ZMQConfig
+
+
+@dataclasses.dataclass
+class TopConfig(ConfigClass):
+    monitor_address: ZMQConfig = dataclasses.field(
+        metadata=dict(positional=True, help="scheduler monitor address to connect to")
+    )
+    timeout: int = dataclasses.field(default=5, metadata=dict(short="-t", help="timeout seconds"))
+
+    def __post_init__(self):
+        if self.timeout <= 0:
+            raise ValueError("timeout must be a positive integer.")

scaler/config/section/webui.py

@@ -0,0 +1,16 @@
+import dataclasses
+
+from scaler.config.common.logging import LoggingConfig
+from scaler.config.config_class import ConfigClass
+from scaler.config.types.zmq import ZMQConfig
+
+
+@dataclasses.dataclass
+class WebUIConfig(ConfigClass):
+    monitor_address: ZMQConfig = dataclasses.field(
+        metadata=dict(positional=True, help="scheduler monitor address to connect to")
+    )
+    web_host: str = dataclasses.field(default="0.0.0.0", metadata=dict(help="host for webserver to connect to"))
+    web_port: int = dataclasses.field(default=50001, metadata=dict(help="host for webserver to connect to"))
+
+    logging_config: LoggingConfig = dataclasses.field(default_factory=LoggingConfig)

scaler/config/types/network_backend.py

@@ -0,0 +1,12 @@
+import enum
+
+
+class NetworkBackend(enum.Enum):
+    """
+    Network backend to select when running scaler
+    - tcp_zmq means for oss it use raw tcp, for client/scheduler/worker communication it use zmq
+    - ymq means all components will use ymq for communication
+    """
+
+    tcp_zmq = enum.auto()
+    ymq = enum.auto()

scaler/config/types/object_storage_server.py

@@ -0,0 +1,45 @@
+import dataclasses
+import ipaddress
+
+from scaler.config.mixins import ConfigType
+
+
+@dataclasses.dataclass
+class ObjectStorageAddressConfig(ConfigType):
+    host: str
+    port: int
+    identity: str = "ObjectStorageServer"
+
+    def __post_init__(self):
+        try:
+            ipaddress.ip_address(self.host)
+        except ValueError:
+            raise TypeError(f"Host must be a valid IP address, but got '{self.host}'")
+
+        if not isinstance(self.identity, str):
+            raise TypeError(f"Identity should be a string, given {self.identity}")
+
+        if not isinstance(self.port, int):
+            raise TypeError(f"Port should be an integer, given {self.port}")
+
+    def __str__(self) -> str:
+        return self.to_string()
+
+    def to_string(self) -> str:
+        return f"tcp://{self.host}:{self.port}"
+
+    @classmethod
+    def from_string(cls, value: str) -> "ObjectStorageAddressConfig":
+        if not value.startswith("tcp://"):
+            raise ValueError("Address must start with 'tcp://'")
+
+        try:
+            host, port_str = value[6:].rsplit(":", 1)
+            port = int(port_str)
+
+            ipaddress.ip_address(host)
+
+        except (ValueError, IndexError):
+            raise ValueError(f"Invalid address format '{value}'. Expected format is tcp://<ip_address>:<port>")
+
+        return cls(host=host, port=port)

scaler/config/types/worker.py

@@ -0,0 +1,67 @@
+import dataclasses
+import sys
+from typing import Dict, List
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+from scaler.config.mixins import ConfigType
+
+
+@dataclasses.dataclass
+class WorkerNames(ConfigType):
+    """Parses a comma-separated string of worker names into a list."""
+
+    names: List[str] = dataclasses.field(default_factory=list)
+
+    @classmethod
+    def from_string(cls, value: str) -> Self:
+        if not value:
+            return cls([])
+        names = [name.strip() for name in value.split(",")]
+        return cls(names)
+
+    def __str__(self) -> str:
+        if self.names:
+            return ",".join(self.names)
+        return "<empty>"
+
+    def __len__(self) -> int:
+        return len(self.names)
+
+
+@dataclasses.dataclass
+class WorkerCapabilities(ConfigType):
+    """Parses a string of worker capabilities."""
+
+    capabilities: Dict[str, int] = dataclasses.field(default_factory=dict)
+
+    @classmethod
+    def from_string(cls, value: str) -> Self:
+        capabilities: Dict[str, int] = {}
+        if not value:
+            return cls(capabilities)
+        for item in value.split(","):
+            name, _, value = item.partition("=")
+            if value != "":
+                try:
+                    capabilities[name.strip()] = int(value)
+                except ValueError:
+                    raise ValueError(f"Invalid capability value for '{name}'. Expected an integer, but got '{value}'.")
+            else:
+                capabilities[name.strip()] = -1
+        return cls(capabilities)
+
+    def __str__(self) -> str:
+        if not self.capabilities:
+            return "<empty>"
+
+        items = []
+        for name, cap in self.capabilities.items():
+            if cap == -1:
+                items.append(name)
+            else:
+                items.append(f"{name}={cap}")
+        return ",".join(items)

scaler/config/types/zmq.py

@@ -0,0 +1,83 @@
+import dataclasses
+import enum
+import sys
+from typing import Optional
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+from scaler.config.mixins import ConfigType
+
+
+class ZMQType(enum.Enum):
+    inproc = "inproc"
+    ipc = "ipc"
+    tcp = "tcp"
+
+    @staticmethod
+    def allowed_types():
+        return {t.value for t in ZMQType}
+
+
+@dataclasses.dataclass
+class ZMQConfig(ConfigType):
+    type: ZMQType
+    host: str
+    port: Optional[int] = None
+
+    def __post_init__(self):
+        if not isinstance(self.type, ZMQType):
+            raise TypeError(f"Invalid zmq type {self.type}, available types are: {ZMQType.allowed_types()}")
+
+        if not isinstance(self.host, str):
+            raise TypeError(f"Host should be string, given {self.host}")
+
+        if self.port is None:
+            if self.type == ZMQType.tcp:
+                raise ValueError(f"type {self.type.value} should have `port`")
+        else:
+            if self.type in {ZMQType.inproc, ZMQType.ipc}:
+                raise ValueError(f"type {self.type.value} should not have `port`")
+
+            if not isinstance(self.port, int):
+                raise TypeError(f"Port should be integer, given {self.port}")
+
+    def to_address(self):
+        if self.type == ZMQType.tcp:
+            return f"tcp://{self.host}:{self.port}"
+
+        if self.type in {ZMQType.inproc, ZMQType.ipc}:
+            return f"{self.type.value}://{self.host}"
+
+        raise TypeError(f"Unsupported ZMQ type: {self.type}")
+
+    @classmethod
+    def from_string(cls, value: str) -> Self:
+        if "://" not in value:
+            raise ValueError("valid ZMQ config should be like tcp://127.0.0.1:12345")
+
+        socket_type, host_port = value.split("://", 1)
+        if socket_type not in ZMQType.allowed_types():
+            raise ValueError(f"supported ZMQ types are: {ZMQType.allowed_types()}")
+
+        socket_type_enum = ZMQType(socket_type)
+        if socket_type_enum in {ZMQType.inproc, ZMQType.ipc}:
+            host = host_port
+            port_int = None
+        elif socket_type_enum == ZMQType.tcp:
+            host, port = host_port.split(":")
+            try:
+                port_int = int(port)
+            except ValueError:
+                raise ValueError(f"cannot convert '{port}' to port number")
+        else:
+            raise ValueError(f"Unsupported ZMQ type: {socket_type}")
+
+        return cls(socket_type_enum, host, port_int)
+
+    def __str__(self) -> str:
+        return self.to_address()
+
+    def __repr__(self) -> str:
+        return self.to_address()

scaler/entry_points/cluster.py

@@ -0,0 +1,10 @@
+from scaler.cluster.cluster import Cluster
+from scaler.config.section.cluster import ClusterConfig
+from scaler.utility.event_loop import register_event_loop
+
+
+def main():
+    cluster_config = ClusterConfig.parse("Scaler Standalone Compute Cluster", "cluster")
+    register_event_loop(cluster_config.event_loop)
+    cluster = Cluster(cluster_config)
+    cluster.run()

scaler/entry_points/object_storage_server.py

@@ -0,0 +1,26 @@
+import logging
+import sys
+
+from scaler.config.section.object_storage_server import ObjectStorageServerConfig
+from scaler.object_storage.object_storage_server import ObjectStorageServer
+from scaler.utility.logging.utility import get_logger_info, setup_logger
+
+
+def main():
+    oss_config = ObjectStorageServerConfig.parse("Scaler Object Storage Server", "object_storage_server")
+
+    setup_logger()
+
+    log_format_str, log_level_str, log_paths = get_logger_info(logging.getLogger())
+
+    try:
+        ObjectStorageServer().run(
+            oss_config.object_storage_address.host,
+            oss_config.object_storage_address.port,
+            oss_config.object_storage_address.identity,
+            log_level_str,
+            log_format_str,
+            log_paths,
+        )
+    except KeyboardInterrupt:
+        sys.exit(0)

scaler/entry_points/scheduler.py

@@ -0,0 +1,51 @@
+from scaler.cluster.object_storage_server import ObjectStorageServerProcess
+from scaler.cluster.scheduler import SchedulerProcess
+from scaler.config.section.scheduler import SchedulerConfig
+from scaler.config.types.object_storage_server import ObjectStorageAddressConfig
+
+
+def main():
+    scheduler_config = SchedulerConfig.parse("Scaler Scheduler", "scheduler")
+
+    object_storage_address = scheduler_config.object_storage_address
+    object_storage = None
+
+    if object_storage_address is None:
+        assert scheduler_config.scheduler_address.port is not None, "Scheduler address must have a port"
+        object_storage_address = ObjectStorageAddressConfig(
+            host=scheduler_config.scheduler_address.host, port=scheduler_config.scheduler_address.port + 1
+        )
+        object_storage = ObjectStorageServerProcess(
+            object_storage_address=object_storage_address,
+            logging_paths=scheduler_config.logging_config.paths,
+            logging_config_file=scheduler_config.logging_config.config_file,
+            logging_level=scheduler_config.logging_config.level,
+        )
+        object_storage.start()
+        object_storage.wait_until_ready()  # object storage should be ready before starting the cluster
+
+    scheduler = SchedulerProcess(
+        address=scheduler_config.scheduler_address,
+        object_storage_address=object_storage_address,
+        monitor_address=scheduler_config.monitor_address,
+        scaling_controller_strategy=scheduler_config.scaling_controller_strategy,
+        adapter_webhook_urls=scheduler_config.adapter_webhook_urls,
+        io_threads=scheduler_config.worker_io_threads,
+        max_number_of_tasks_waiting=scheduler_config.max_number_of_tasks_waiting,
+        client_timeout_seconds=scheduler_config.client_timeout_seconds,
+        worker_timeout_seconds=scheduler_config.worker_timeout_seconds,
+        object_retention_seconds=scheduler_config.object_retention_seconds,
+        load_balance_seconds=scheduler_config.load_balance_seconds,
+        load_balance_trigger_times=scheduler_config.load_balance_trigger_times,
+        protected=scheduler_config.protected,
+        allocate_policy=scheduler_config.allocate_policy,
+        event_loop=scheduler_config.event_loop,
+        logging_paths=scheduler_config.logging_config.paths,
+        logging_config_file=scheduler_config.logging_config.config_file,
+        logging_level=scheduler_config.logging_config.level,
+    )
+    scheduler.start()
+
+    scheduler.join()
+    if object_storage is not None:
+        object_storage.join()