opengris-scaler 1.12.37__cp38-cp38-musllinux_1_2_x86_64.whl

scaler/entry_points/top.py

@@ -0,0 +1,272 @@
+import curses
+import functools
+from typing import Dict, List, Literal, Union
+
+from scaler.config.section.top import TopConfig
+from scaler.io.sync_subscriber import ZMQSyncSubscriber
+from scaler.protocol.python.message import StateScheduler
+from scaler.protocol.python.mixins import Message
+from scaler.utility.formatter import (
+    format_bytes,
+    format_integer,
+    format_microseconds,
+    format_percentage,
+    format_seconds,
+)
+
+SORT_BY_OPTIONS = {
+    ord("g"): "group",
+    ord("n"): "worker",
+    ord("C"): "agt_cpu",
+    ord("M"): "agt_rss",
+    ord("c"): "cpu",
+    ord("m"): "rss",
+    ord("F"): "rss_free",
+    ord("f"): "free",
+    ord("w"): "sent",
+    ord("d"): "queued",
+    ord("s"): "suspended",
+    ord("l"): "lag",
+}
+
+SORT_BY_STATE: Dict[str, Union[str, bool]] = {"sort_by": "cpu", "sort_by_previous": "cpu", "sort_reverse": True}
+
+
+def main():
+    curses.wrapper(poke, TopConfig.parse("A Top-like Application for Scaler Monitoring", "top"))
+
+
+def poke(screen, config: TopConfig):
+    screen.nodelay(1)
+
+    try:
+        subscriber = ZMQSyncSubscriber(
+            address=config.monitor_address,
+            callback=functools.partial(show_status, screen=screen),
+            topic=b"",
+            daemonic=False,
+            timeout_seconds=config.timeout,
+        )
+        subscriber.run()
+    except KeyboardInterrupt:
+        pass
+
+
+def show_status(status: Message, screen):
+    if not isinstance(status, StateScheduler):
+        return
+
+    __change_option_state(screen.getch())
+
+    scheduler_table = __generate_keyword_data(
+        "scheduler",
+        {
+            "cpu": format_percentage(status.scheduler.cpu),
+            "rss": format_bytes(status.scheduler.rss),
+            "rss_free": format_bytes(status.rss_free),
+        },
+    )
+
+    task_manager_table = __generate_keyword_data(
+        "task_manager",
+        dict(sorted((k.name, v) for k, v in status.task_manager.state_to_count.items())),
+        format_integer_flag=True,
+    )
+    object_manager = __generate_keyword_data("object_manager", {"num_of_objs": status.object_manager.number_of_objects})
+    sent_table = __generate_keyword_data("scheduler_sent", status.binder.sent, format_integer_flag=True)
+    received_table = __generate_keyword_data("scheduler_received", status.binder.received, format_integer_flag=True)
+    client_table = __generate_keyword_data(
+        "client_manager", status.client_manager.client_to_num_of_tasks, key_col_length=18
+    )
+
+    worker_group_map = {}
+    if status.scaling_manager.worker_groups:
+        for worker_group_id, worker_ids in status.scaling_manager.worker_groups.items():
+            worker_group_id_str = worker_group_id.decode()
+            for worker_id in worker_ids:
+                worker_group_map[worker_id.decode()] = worker_group_id_str
+
+    # Include 'group' as the first column for each worker; empty if not found
+    worker_manager_table = __generate_worker_manager_table(
+        [
+            {
+                "group": worker_group_map.get(worker.worker_id.decode(), ""),
+                "worker": worker.worker_id.decode(),
+                "agt_cpu": worker.agent.cpu,
+                "agt_rss": worker.agent.rss,
+                "cpu": sum(p.resource.cpu for p in worker.processor_statuses),
+                "rss": sum(p.resource.rss for p in worker.processor_statuses),
+                "os_rss_free": worker.rss_free,
+                "free": worker.free,
+                "sent": worker.sent,
+                "queued": worker.queued,
+                "suspended": worker.suspended,
+                "lag": worker.lag_us,
+                "last": worker.last_s,
+                "ITL": worker.itl,
+            }
+            for worker in status.worker_manager.workers
+        ],
+        worker_group_length=10,
+        worker_length=20,
+    )
+
+    table1 = __merge_tables(scheduler_table, object_manager, padding="|")
+    table1 = __merge_tables(table1, task_manager_table, padding="|")
+    table1 = __merge_tables(table1, sent_table, padding="|")
+    table1 = __merge_tables(table1, received_table, padding="|")
+
+    table3 = __merge_tables(worker_manager_table, client_table, padding="|")
+
+    screen.clear()
+    try:
+        new_row, max_cols = __print_table(screen, 0, table1, padding=1)
+    except curses.error:
+        __print_too_small(screen)
+        return
+
+    try:
+        screen.addstr(new_row, 0, "-" * max_cols)
+        screen.addstr(new_row + 1, 0, "Shortcuts: " + " ".join([f"{v}[{chr(k)}]" for k, v in SORT_BY_OPTIONS.items()]))
+        screen.addstr(
+            new_row + 3,
+            0,
+            f"Total {len(status.scaling_manager.worker_groups)} worker group(s) "
+            f"with {len(status.worker_manager.workers)} worker(s)",
+        )
+        _ = __print_table(screen, new_row + 4, table3)
+    except curses.error:
+        pass
+
+    screen.refresh()
+
+
+def __generate_keyword_data(title, data, key_col_length: int = 0, format_integer_flag: bool = False):
+    table = [[title, ""]]
+
+    def format_integer_func(value):
+        if format_integer_flag:
+            return format_integer(value)
+
+        return value
+
+    table.extend([[__truncate(k, key_col_length), format_integer_func(v)] for k, v in data.items()])
+    return table
+
+
+def __generate_worker_manager_table(
+    wm_data: List[Dict], worker_group_length: int, worker_length: int
+) -> List[List[str]]:
+    if not wm_data:
+        headers = [["No workers"]]
+        return headers
+
+    wm_data = sorted(
+        wm_data, key=lambda item: item[SORT_BY_STATE["sort_by"]], reverse=bool(SORT_BY_STATE["sort_reverse"])
+    )
+
+    for row in wm_data:
+        row["group"] = __truncate(row["group"], worker_group_length, how="left")
+        row["worker"] = __truncate(row["worker"], worker_length, how="left")
+        row["agt_cpu"] = format_percentage(row["agt_cpu"])
+        row["agt_rss"] = format_bytes(row["agt_rss"])
+        row["cpu"] = format_percentage(row["cpu"])
+        row["rss"] = format_bytes(row["rss"])
+        row["os_rss_free"] = format_bytes(row["os_rss_free"])
+
+        last = row.pop("last")
+        last = f"({format_seconds(last)}) " if last > 5 else ""
+        row["lag"] = last + format_microseconds(row["lag"])
+
+    worker_manager_table = [[f"[{v}]" if v == SORT_BY_STATE["sort_by"] else v for v in wm_data[0].keys()]]
+    worker_manager_table.extend([list(worker.values()) for worker in wm_data])
+    return worker_manager_table
+
+
+def __print_table(screen, line_number, data, padding: int = 1):
+    if not data:
+        return
+
+    col_widths = [max(len(str(row[i])) for row in data) for i in range(len(data[0]))]
+
+    for i, header in enumerate(data[0]):
+        screen.addstr(line_number, sum(col_widths[:i]) + (padding * i), str(header).rjust(col_widths[i]))
+
+    for i, row in enumerate(data[1:], start=1):
+        for j, cell in enumerate(row):
+            screen.addstr(line_number + i, sum(col_widths[:j]) + (padding * j), str(cell).rjust(col_widths[j]))
+
+    return line_number + len(data), sum(col_widths) + (padding * len(col_widths))
+
+
+def __merge_tables(left: List[List], right: List[List], padding: str = "") -> List[List]:
+    if not left:
+        return right
+
+    if not right:
+        return left
+
+    result = []
+    for i in range(max(len(left), len(right))):
+        if i < len(left):
+            left_row = left[i]
+        else:
+            left_row = [""] * len(left[0])
+
+        if i < len(right):
+            right_row = right[i]
+        else:
+            right_row = [""] * len(right[0])
+
+        if padding:
+            padding_column = [padding]
+            result.append(left_row + padding_column + right_row)
+        else:
+            result.append(left_row + right_row)
+
+    return result
+
+
+def __concat_tables(up: List[List], down: List[List], padding: int = 1) -> List[List]:
+    max_cols = max([len(row) for row in up] + [len(row) for row in down])
+    for row in up:
+        row.extend([""] * (max_cols - len(row)))
+
+    padding_rows = [[""] * max_cols] * padding
+
+    for row in down:
+        row.extend([""] * (max_cols - len(row)))
+
+    return up + padding_rows + down
+
+
+def __truncate(string: str, number: int, how: Literal["left", "right"] = "left") -> str:
+    if number <= 0:
+        return string
+
+    if len(string) <= number:
+        return string
+
+    if how == "left":
+        return f"{string[:number]}+"
+    else:
+        return f"+{string[-number:]}"
+
+
+def __print_too_small(screen):
+    screen.clear()
+    screen.addstr(0, 0, "Your terminal is too small to show")
+    screen.refresh()
+
+
+def __change_option_state(option: int):
+    if option not in SORT_BY_OPTIONS.keys():
+        return
+
+    SORT_BY_STATE["sort_by_previous"] = SORT_BY_STATE["sort_by"]
+    SORT_BY_STATE["sort_by"] = SORT_BY_OPTIONS[option]
+    if SORT_BY_STATE["sort_by"] != SORT_BY_STATE["sort_by_previous"]:
+        SORT_BY_STATE["sort_reverse"] = True
+        return
+
+    SORT_BY_STATE["sort_reverse"] = not SORT_BY_STATE["sort_reverse"]

scaler/entry_points/webui.py

@@ -0,0 +1,6 @@
+from scaler.config.section.webui import WebUIConfig
+from scaler.ui.webui import start_webui
+
+
+def main():
+    start_webui(WebUIConfig.parse("Web UI for Scaler Monitoring", "webui"))

scaler/entry_points/worker_adapter_ecs.py

@@ -0,0 +1,22 @@
+from aiohttp import web
+
+from scaler.config.section.ecs_worker_adapter import ECSWorkerAdapterConfig
+from scaler.utility.event_loop import register_event_loop
+from scaler.utility.logging.utility import setup_logger
+from scaler.worker_adapter.ecs import ECSWorkerAdapter
+
+
+def main():
+    ecs_config = ECSWorkerAdapterConfig.parse("Scaler ECS Worker Adapter", "ecs_worker_adapter")
+    register_event_loop(ecs_config.event_loop)
+    setup_logger(
+        ecs_config.logging_config.paths, ecs_config.logging_config.config_file, ecs_config.logging_config.level
+    )
+    ecs_worker_adapter = ECSWorkerAdapter(ecs_config)
+
+    app = ecs_worker_adapter.create_app()
+    web.run_app(app, host=ecs_config.web_config.adapter_web_host, port=ecs_config.web_config.adapter_web_port)
+
+
+if __name__ == "__main__":
+    main()

scaler/entry_points/worker_adapter_native.py

@@ -0,0 +1,31 @@
+from aiohttp import web
+
+from scaler.config.section.native_worker_adapter import NativeWorkerAdapterConfig
+from scaler.utility.event_loop import register_event_loop
+from scaler.utility.logging.utility import setup_logger
+from scaler.worker_adapter.native import NativeWorkerAdapter
+
+
+def main():
+    native_adapter_config = NativeWorkerAdapterConfig.parse("Scaler Native Worker Adapter", "native_worker_adapter")
+
+    register_event_loop(native_adapter_config.event_loop)
+
+    setup_logger(
+        native_adapter_config.logging_config.paths,
+        native_adapter_config.logging_config.config_file,
+        native_adapter_config.logging_config.level,
+    )
+
+    native_worker_adapter = NativeWorkerAdapter(native_adapter_config)
+
+    app = native_worker_adapter.create_app()
+    web.run_app(
+        app,
+        host=native_adapter_config.web_config.adapter_web_host,
+        port=native_adapter_config.web_config.adapter_web_port,
+    )
+
+
+if __name__ == "__main__":
+    main()

scaler/entry_points/worker_adapter_symphony.py

@@ -0,0 +1,26 @@
+from aiohttp import web
+
+from scaler.config.section.symphony_worker_adapter import SymphonyWorkerConfig
+from scaler.utility.event_loop import register_event_loop
+from scaler.utility.logging.utility import setup_logger
+from scaler.worker_adapter.symphony.worker_adapter import SymphonyWorkerAdapter
+
+
+def main():
+    symphony_config = SymphonyWorkerConfig.parse("Scaler Symphony Worker Adapter", "symphony_worker_adapter")
+    register_event_loop(symphony_config.event_loop)
+
+    setup_logger(
+        symphony_config.logging_config.paths,
+        symphony_config.logging_config.config_file,
+        symphony_config.logging_config.level,
+    )
+
+    symphony_worker_adapter = SymphonyWorkerAdapter(symphony_config)
+
+    app = symphony_worker_adapter.create_app()
+    web.run_app(app, host=symphony_config.web_config.adapter_web_host, port=symphony_config.web_config.adapter_web_port)
+
+
+if __name__ == "__main__":
+    main()

scaler/io/async_binder.py

@@ -0,0 +1,89 @@
+import logging
+import os
+import uuid
+from collections import defaultdict
+from typing import Awaitable, Callable, Dict, List, Optional
+
+import zmq.asyncio
+from zmq import Frame
+
+from scaler.config.types.zmq import ZMQConfig
+from scaler.io.mixins import AsyncBinder
+from scaler.io.utility import deserialize, serialize
+from scaler.protocol.python.mixins import Message
+from scaler.protocol.python.status import BinderStatus
+
+
+class ZMQAsyncBinder(AsyncBinder):
+    def __init__(self, context: zmq.asyncio.Context, name: str, address: ZMQConfig, identity: Optional[bytes] = None):
+        self._address = address
+
+        if identity is None:
+            identity = f"{os.getpid()}|{name}|{uuid.uuid4()}".encode()
+        self._identity = identity
+
+        self._context = context
+        self._socket = self._context.socket(zmq.ROUTER)
+        self.__set_socket_options()
+        self._socket.bind(self._address.to_address())
+
+        self._callback: Optional[Callable[[bytes, Message], Awaitable[None]]] = None
+
+        self._received: Dict[str, int] = defaultdict(lambda: 0)
+        self._sent: Dict[str, int] = defaultdict(lambda: 0)
+
+    @property
+    def identity(self):
+        return self._identity
+
+    def destroy(self):
+        self._context.destroy(linger=0)
+
+    def register(self, callback: Callable[[bytes, Message], Awaitable[None]]):
+        self._callback = callback
+
+    async def routine(self):
+        frames: List[Frame] = await self._socket.recv_multipart(copy=False)
+        if not self.__is_valid_message(frames):
+            return
+
+        source, payload = frames
+        try:
+            message: Optional[Message] = deserialize(payload.bytes)
+            if message is None:
+                logging.error(f"received unknown message from {source.bytes!r}: {payload!r}")
+                return
+        except Exception as e:
+            logging.error(f"{self.__get_prefix()} failed to deserialize message from {source.bytes!r}: {e}")
+            return
+
+        self.__count_received(message.__class__.__name__)
+        await self._callback(source.bytes, message)
+
+    async def send(self, to: bytes, message: Message):
+        self.__count_sent(message.__class__.__name__)
+        await self._socket.send_multipart([to, serialize(message)], copy=False)
+
+    def get_status(self) -> BinderStatus:
+        return BinderStatus.new_msg(received=self._received, sent=self._sent)
+
+    def __set_socket_options(self):
+        self._socket.setsockopt(zmq.IDENTITY, self._identity)
+        self._socket.setsockopt(zmq.SNDHWM, 0)
+        self._socket.setsockopt(zmq.RCVHWM, 0)
+
+    def __is_valid_message(self, frames: List[Frame]) -> bool:
+        if len(frames) != 2:
+            logging.error(f"{self.__get_prefix()} received unexpected frames {frames}")
+            return False
+
+        return True
+
+    def __count_received(self, message_type: str):
+        self._received[message_type] += 1
+
+    def __count_sent(self, message_type: str):
+        self._sent[message_type] += 1
+
+    def __get_prefix(self):
+        return f"{self.__class__.__name__}[{self._identity.decode()}]:"

scaler/io/async_connector.py

@@ -0,0 +1,95 @@
+import logging
+import os
+import uuid
+from typing import Awaitable, Callable, Literal, Optional
+
+import zmq.asyncio
+
+from scaler.config.types.zmq import ZMQConfig
+from scaler.io.mixins import AsyncConnector
+from scaler.io.utility import deserialize, serialize
+from scaler.protocol.python.mixins import Message
+
+
+class ZMQAsyncConnector(AsyncConnector):
+    def __init__(
+        self,
+        context: zmq.asyncio.Context,
+        name: str,
+        socket_type: int,
+        address: ZMQConfig,
+        bind_or_connect: Literal["bind", "connect"],
+        callback: Optional[Callable[[Message], Awaitable[None]]],
+        identity: Optional[bytes],
+    ):
+        self._address = address
+
+        self._context = context
+        self._socket = self._context.socket(socket_type)
+
+        if identity is None:
+            identity = f"{os.getpid()}|{name}|{uuid.uuid4().bytes.hex()}".encode()
+        self._identity = identity
+
+        # set socket option
+        self._socket.setsockopt(zmq.IDENTITY, self._identity)
+        self._socket.setsockopt(zmq.SNDHWM, 0)
+        self._socket.setsockopt(zmq.RCVHWM, 0)
+
+        if bind_or_connect == "bind":
+            self._socket.bind(self.address)
+        elif bind_or_connect == "connect":
+            self._socket.connect(self.address)
+        else:
+            raise TypeError("bind_or_connect has to be 'bind' or 'connect'")
+
+        self._callback: Optional[Callable[[Message], Awaitable[None]]] = callback
+
+    def __del__(self):
+        self.destroy()
+
+    def destroy(self):
+        if self._socket.closed:
+            return
+
+        self._socket.close(linger=1)
+
+    @property
+    def identity(self) -> bytes:
+        return self._identity
+
+    @property
+    def socket(self) -> zmq.asyncio.Socket:
+        return self._socket
+
+    @property
+    def address(self) -> str:
+        return self._address.to_address()
+
+    async def routine(self):
+        if self._callback is None:
+            return
+
+        message: Optional[Message] = await self.receive()
+        if message is None:
+            return
+
+        await self._callback(message)
+
+    async def receive(self) -> Optional[Message]:
+        if self._context.closed:
+            return None
+
+        if self._socket.closed:
+            return None
+
+        payload = await self._socket.recv(copy=False)
+        result: Optional[Message] = deserialize(payload.bytes)
+        if result is None:
+            logging.error(f"received unknown message: {payload.bytes!r}")
+            return None
+
+        return result
+
+    async def send(self, message: Message):
+        await self._socket.send(serialize(message), copy=False)