opengris-scaler 1.12.7__cp311-cp311-musllinux_1_2_x86_64.whl

scaler/worker/preload.py

@@ -0,0 +1,84 @@
+import ast
+import importlib
+import logging
+import os
+import traceback
+from typing import Any, Dict, List, Optional, Tuple
+
+
+class PreloadSpecError(Exception):
+    pass
+
+
+def execute_preload(spec: str) -> None:
+    """
+    Import and execute the given preload spec in current interpreter.
+
+    Example: 'foo.bar:preload_function("a", 2)'
+    """
+    module_path, func_name, args, kwargs = _parse_preload_spec(spec)
+    logging.info("preloading: %s:%s with args=%s kwargs=%s", module_path, func_name, args, kwargs)
+
+    try:
+        module = importlib.import_module(module_path)
+    except ImportError:
+        if module_path.endswith(".py") and os.path.exists(module_path):
+            raise PreloadSpecError(
+                f"Failed to find module. Did you mean '{module_path.rsplit('.', 1)[0]}:{func_name}'?"
+            )
+        raise
+
+    try:
+        target = getattr(module, func_name)
+    except AttributeError:
+        logging.exception(f"Failed to find attribute {func_name!r} in {module_path!r}.")
+        raise PreloadSpecError(f"Failed to find attribute {func_name!r} in {module_path!r}.")
+
+    if not callable(target):
+        raise PreloadSpecError("Preload target must be callable.")
+
+    try:
+        if args is None:
+            # Simple name: call with no args
+            target()
+        else:
+            target(*args, **(kwargs or {}))
+    except TypeError as e:
+        raise PreloadSpecError("".join(traceback.format_exception_only(TypeError, e)).strip())
+
+
+def _parse_preload_spec(spec: str) -> Tuple[str, str, Optional[List[Any]], Optional[Dict[str, Any]]]:
+    """
+    Parse 'pkg.mod:func(arg1, kw=val)' using AST.
+    Returns (module_path, func_name, args_or_None, kwargs_or_None).
+    If expression is a simple name (no args), returns args=None, kwargs=None.
+    """
+    if ":" not in spec:
+        raise PreloadSpecError("preload must be in 'module.sub:func(...)' format")
+
+    module_part, obj_expr = spec.split(":", 1)
+
+    # Parse the right-hand side as a single expression
+    try:
+        expression = ast.parse(obj_expr, mode="eval").body
+    except SyntaxError:
+        raise PreloadSpecError(f"Failed to parse {obj_expr!r} as an attribute name or function call.")
+
+    if isinstance(expression, ast.Name):
+        func_name = expression.id
+        args = None
+        kwargs = None
+    elif isinstance(expression, ast.Call):
+        # Ensure the function name is an attribute name only (no dotted path)
+        if not isinstance(expression.func, ast.Name):
+            raise PreloadSpecError(f"Function reference must be a simple name: {obj_expr!r}")
+        func_name = expression.func.id
+        try:
+            args = [ast.literal_eval(arg) for arg in expression.args]
+            kwargs = {kw.arg: ast.literal_eval(kw.value) for kw in expression.keywords}
+        except ValueError:
+            raise PreloadSpecError(f"Failed to parse arguments as literal values: {obj_expr!r}")
+    else:
+        raise PreloadSpecError(f"Failed to parse {obj_expr!r} as an attribute name or function call.")
+
+    return module_part, func_name, args, kwargs

scaler/worker/worker.py

@@ -0,0 +1,264 @@
+import asyncio
+import logging
+import multiprocessing
+import os
+import signal
+import tempfile
+import uuid
+from typing import Dict, Optional, Tuple
+
+import zmq.asyncio
+
+from scaler.config.types.object_storage_server import ObjectStorageConfig
+from scaler.config.types.zmq import ZMQConfig, ZMQType
+from scaler.io.async_binder import ZMQAsyncBinder
+from scaler.io.async_connector import ZMQAsyncConnector
+from scaler.io.async_object_storage_connector import PyAsyncObjectStorageConnector
+from scaler.config.defaults import PROFILING_INTERVAL_SECONDS
+from scaler.io.mixins import AsyncBinder, AsyncConnector, AsyncObjectStorageConnector
+from scaler.io.ymq import ymq
+from scaler.protocol.python.message import (
+    ClientDisconnect,
+    DisconnectRequest,
+    ObjectInstruction,
+    ProcessorInitialized,
+    Task,
+    TaskCancel,
+    TaskLog,
+    TaskResult,
+    WorkerHeartbeatEcho,
+)
+from scaler.protocol.python.mixins import Message
+from scaler.utility.event_loop import create_async_loop_routine, register_event_loop
+from scaler.utility.exceptions import ClientShutdownException
+from scaler.utility.identifiers import ProcessorID, WorkerID
+from scaler.utility.logging.utility import setup_logger
+from scaler.worker.agent.heartbeat_manager import VanillaHeartbeatManager
+from scaler.worker.agent.processor_manager import VanillaProcessorManager
+from scaler.worker.agent.profiling_manager import VanillaProfilingManager
+from scaler.worker.agent.task_manager import VanillaTaskManager
+from scaler.worker.agent.timeout_manager import VanillaTimeoutManager
+
+
+class Worker(multiprocessing.get_context("spawn").Process):  # type: ignore
+    def __init__(
+        self,
+        event_loop: str,
+        name: str,
+        address: ZMQConfig,
+        storage_address: Optional[ObjectStorageConfig],
+        preload: Optional[str],
+        capabilities: Dict[str, int],
+        io_threads: int,
+        task_queue_size: int,
+        heartbeat_interval_seconds: int,
+        garbage_collect_interval_seconds: int,
+        trim_memory_threshold_bytes: int,
+        task_timeout_seconds: int,
+        death_timeout_seconds: int,
+        hard_processor_suspend: bool,
+        logging_paths: Tuple[str, ...],
+        logging_level: str,
+    ):
+        multiprocessing.Process.__init__(self, name="Agent")
+
+        self._event_loop = event_loop
+        self._name = name
+        self._address = address
+        self._storage_address = storage_address
+        self._preload = preload
+        self._capabilities = capabilities
+        self._io_threads = io_threads
+        self._task_queue_size = task_queue_size
+
+        self._ident = WorkerID.generate_worker_id(name)  # _identity is internal to multiprocessing.Process
+
+        self._address_path_internal = os.path.join(tempfile.gettempdir(), f"scaler_worker_{uuid.uuid4().hex}")
+        self._address_internal = ZMQConfig(ZMQType.ipc, host=self._address_path_internal)
+
+        self._task_queue_size = task_queue_size
+        self._heartbeat_interval_seconds = heartbeat_interval_seconds
+        self._garbage_collect_interval_seconds = garbage_collect_interval_seconds
+        self._trim_memory_threshold_bytes = trim_memory_threshold_bytes
+        self._task_timeout_seconds = task_timeout_seconds
+        self._death_timeout_seconds = death_timeout_seconds
+        self._hard_processor_suspend = hard_processor_suspend
+
+        self._logging_paths = logging_paths
+        self._logging_level = logging_level
+
+        self._context: Optional[zmq.asyncio.Context] = None
+        self._connector_external: Optional[AsyncConnector] = None
+        self._binder_internal: Optional[AsyncBinder] = None
+        self._connector_storage: Optional[AsyncObjectStorageConnector] = None
+        self._task_manager: Optional[VanillaTaskManager] = None
+        self._heartbeat_manager: Optional[VanillaHeartbeatManager] = None
+        self._profiling_manager: Optional[VanillaProfilingManager] = None
+        self._processor_manager: Optional[VanillaProcessorManager] = None
+
+    @property
+    def identity(self) -> WorkerID:
+        return self._ident
+
+    def run(self) -> None:
+        self.__initialize()
+        self.__run_forever()
+
+    def __initialize(self):
+        setup_logger()
+        register_event_loop(self._event_loop)
+
+        self._context = zmq.asyncio.Context()
+        self._connector_external = ZMQAsyncConnector(
+            context=self._context,
+            name=self.name,
+            socket_type=zmq.DEALER,
+            address=self._address,
+            bind_or_connect="connect",
+            callback=self.__on_receive_external,
+            identity=self._ident,
+        )
+
+        self._binder_internal = ZMQAsyncBinder(
+            context=self._context, name=self.name, address=self._address_internal, identity=self._ident
+        )
+        self._binder_internal.register(self.__on_receive_internal)
+
+        self._connector_storage = PyAsyncObjectStorageConnector()
+
+        self._heartbeat_manager = VanillaHeartbeatManager(
+            storage_address=self._storage_address,
+            capabilities=self._capabilities,
+            task_queue_size=self._task_queue_size,
+        )
+
+        self._profiling_manager = VanillaProfilingManager()
+        self._task_manager = VanillaTaskManager(task_timeout_seconds=self._task_timeout_seconds)
+        self._timeout_manager = VanillaTimeoutManager(death_timeout_seconds=self._death_timeout_seconds)
+        self._processor_manager = VanillaProcessorManager(
+            identity=self._ident,
+            event_loop=self._event_loop,
+            address_internal=self._address_internal,
+            preload=self._preload,
+            garbage_collect_interval_seconds=self._garbage_collect_interval_seconds,
+            trim_memory_threshold_bytes=self._trim_memory_threshold_bytes,
+            hard_processor_suspend=self._hard_processor_suspend,
+            logging_paths=self._logging_paths,
+            logging_level=self._logging_level,
+        )
+
+        # register
+        self._task_manager.register(connector=self._connector_external, processor_manager=self._processor_manager)
+        self._heartbeat_manager.register(
+            connector_external=self._connector_external,
+            connector_storage=self._connector_storage,
+            worker_task_manager=self._task_manager,
+            timeout_manager=self._timeout_manager,
+            processor_manager=self._processor_manager,
+        )
+        self._processor_manager.register(
+            heartbeat_manager=self._heartbeat_manager,
+            task_manager=self._task_manager,
+            profiling_manager=self._profiling_manager,
+            connector_external=self._connector_external,
+            binder_internal=self._binder_internal,
+            connector_storage=self._connector_storage,
+        )
+
+        self._loop = asyncio.get_event_loop()
+        self.__register_signal()
+        self._task = self._loop.create_task(self.__get_loops())
+
+    async def __on_receive_external(self, message: Message):
+        if isinstance(message, WorkerHeartbeatEcho):
+            await self._heartbeat_manager.on_heartbeat_echo(message)
+            return
+
+        if isinstance(message, Task):
+            await self._task_manager.on_task_new(message)
+            return
+
+        if isinstance(message, TaskCancel):
+            await self._task_manager.on_cancel_task(message)
+            return
+
+        if isinstance(message, ObjectInstruction):
+            await self._processor_manager.on_external_object_instruction(message)
+            return
+
+        if isinstance(message, ClientDisconnect):
+            if message.disconnect_type == ClientDisconnect.DisconnectType.Shutdown:
+                raise ClientShutdownException("received client shutdown, quitting")
+            logging.error(f"Worker received invalid ClientDisconnect type, ignoring {message=}")
+            return
+
+        raise TypeError(f"Unknown {message=}")
+
+    async def __on_receive_internal(self, processor_id_bytes: bytes, message: Message):
+        processor_id = ProcessorID(processor_id_bytes)
+
+        if isinstance(message, ProcessorInitialized):
+            await self._processor_manager.on_processor_initialized(processor_id, message)
+            return
+
+        if isinstance(message, ObjectInstruction):
+            await self._processor_manager.on_internal_object_instruction(processor_id, message)
+            return
+
+        if isinstance(message, TaskLog):
+            await self._connector_external.send(message)
+            return
+
+        if isinstance(message, TaskResult):
+            await self._processor_manager.on_task_result(processor_id, message)
+            return
+
+        raise TypeError(f"Unknown message from {processor_id!r}: {message}")
+
+    async def __get_loops(self):
+        if self._storage_address is not None:
+            # With a manually set storage address, immediately connect to the object storage server.
+            await self._connector_storage.connect(self._storage_address.host, self._storage_address.port)
+
+        try:
+            await asyncio.gather(
+                self._processor_manager.initialize(),
+                create_async_loop_routine(self._connector_external.routine, 0),
+                create_async_loop_routine(self._connector_storage.routine, 0),
+                create_async_loop_routine(self._binder_internal.routine, 0),
+                create_async_loop_routine(self._heartbeat_manager.routine, self._heartbeat_interval_seconds),
+                create_async_loop_routine(self._timeout_manager.routine, 1),
+                create_async_loop_routine(self._task_manager.routine, 0),
+                create_async_loop_routine(self._profiling_manager.routine, PROFILING_INTERVAL_SECONDS),
+            )
+        except asyncio.CancelledError:
+            pass
+
+        # TODO: Should the object storage connector catch this error?
+        except ymq.YMQException as e:
+            if e.code == ymq.ErrorCode.ConnectorSocketClosedByRemoteEnd:
+                pass
+            else:
+                logging.exception(f"{self.identity!r}: failed with unhandled exception:\n{e}")
+        except (ClientShutdownException, TimeoutError) as e:
+            logging.info(f"{self.identity!r}: {str(e)}")
+        except Exception as e:
+            logging.exception(f"{self.identity!r}: failed with unhandled exception:\n{e}")
+
+        await self._connector_external.send(DisconnectRequest.new_msg(self.identity))
+
+        self._connector_external.destroy()
+        self._processor_manager.destroy("quit")
+        self._binder_internal.destroy()
+        os.remove(self._address_path_internal)
+
+        logging.info(f"{self.identity!r}: quit")
+
+    def __run_forever(self):
+        self._loop.run_until_complete(self._task)
+
+    def __register_signal(self):
+        self._loop.add_signal_handler(signal.SIGINT, self.__destroy)
+
+    def __destroy(self):
+        self._task.cancel()

scaler/worker_adapter/native.py

@@ -0,0 +1,154 @@
+import os
+import signal
+import uuid
+from typing import Dict, Optional, Tuple
+
+from aiohttp import web
+from aiohttp.web_request import Request
+
+from scaler.utility.identifiers import WorkerID
+from scaler.config.types.object_storage_server import ObjectStorageConfig
+from scaler.config.types.zmq import ZMQConfig
+from scaler.worker.worker import Worker
+
+WorkerGroupID = bytes
+
+
+class CapacityExceededError(Exception):
+    pass
+
+
+class WorkerGroupNotFoundError(Exception):
+    pass
+
+
+class NativeWorkerAdapter:
+    def __init__(
+        self,
+        address: ZMQConfig,
+        storage_address: Optional[ObjectStorageConfig],
+        capabilities: Dict[str, int],
+        io_threads: int,
+        task_queue_size: int,
+        max_workers: int,
+        heartbeat_interval_seconds: int,
+        task_timeout_seconds: int,
+        death_timeout_seconds: int,
+        garbage_collect_interval_seconds: int,
+        trim_memory_threshold_bytes: int,
+        hard_processor_suspend: bool,
+        event_loop: str,
+        logging_paths: Tuple[str, ...],
+        logging_level: str,
+        logging_config_file: Optional[str],
+    ):
+        self._address = address
+        self._storage_address = storage_address
+        self._capabilities = capabilities
+        self._io_threads = io_threads
+        self._task_queue_size = task_queue_size
+        self._max_workers = max_workers
+        self._heartbeat_interval_seconds = heartbeat_interval_seconds
+        self._task_timeout_seconds = task_timeout_seconds
+        self._death_timeout_seconds = death_timeout_seconds
+        self._garbage_collect_interval_seconds = garbage_collect_interval_seconds
+        self._trim_memory_threshold_bytes = trim_memory_threshold_bytes
+        self._hard_processor_suspend = hard_processor_suspend
+        self._event_loop = event_loop
+        self._logging_paths = logging_paths
+        self._logging_level = logging_level
+        self._logging_config_file = logging_config_file
+
+        """
+        Although a worker group can contain multiple workers, in this native adapter implementation,
+        each worker group will only contain one worker.
+        """
+        self._worker_groups: Dict[WorkerGroupID, Dict[WorkerID, Worker]] = {}
+
+    async def start_worker_group(self) -> WorkerGroupID:
+        num_of_workers = sum(len(workers) for workers in self._worker_groups.values())
+        if num_of_workers >= self._max_workers != -1:
+            raise CapacityExceededError(f"Maximum number of workers ({self._max_workers}) reached.")
+
+        worker = Worker(
+            name=uuid.uuid4().hex,
+            address=self._address,
+            storage_address=self._storage_address,
+            preload=None,
+            capabilities=self._capabilities,
+            io_threads=self._io_threads,
+            task_queue_size=self._task_queue_size,
+            heartbeat_interval_seconds=self._heartbeat_interval_seconds,
+            task_timeout_seconds=self._task_timeout_seconds,
+            death_timeout_seconds=self._death_timeout_seconds,
+            garbage_collect_interval_seconds=self._garbage_collect_interval_seconds,
+            trim_memory_threshold_bytes=self._trim_memory_threshold_bytes,
+            hard_processor_suspend=self._hard_processor_suspend,
+            event_loop=self._event_loop,
+            logging_paths=self._logging_paths,
+            logging_level=self._logging_level,
+        )
+
+        worker.start()
+        worker_group_id = f"native-{uuid.uuid4().hex}".encode()
+        self._worker_groups[worker_group_id] = {worker.identity: worker}
+        return worker_group_id
+
+    async def shutdown_worker_group(self, worker_group_id: WorkerGroupID):
+        if worker_group_id not in self._worker_groups:
+            raise WorkerGroupNotFoundError(f"Worker group with ID {worker_group_id.decode()} does not exist.")
+
+        for worker in self._worker_groups[worker_group_id].values():
+            os.kill(worker.pid, signal.SIGINT)
+            worker.join()
+
+        self._worker_groups.pop(worker_group_id)
+
+    async def webhook_handler(self, request: Request):
+        request_json = await request.json()
+
+        if "action" not in request_json:
+            return web.json_response({"error": "No action specified"}, status=web.HTTPBadRequest.status_code)
+
+        action = request_json["action"]
+
+        if action == "start_worker_group":
+            try:
+                worker_group_id = await self.start_worker_group()
+            except CapacityExceededError as e:
+                return web.json_response({"error": str(e)}, status=web.HTTPTooManyRequests.status_code)
+            except Exception as e:
+                return web.json_response({"error": str(e)}, status=web.HTTPInternalServerError.status_code)
+
+            return web.json_response(
+                {
+                    "status": "Worker group started",
+                    "worker_group_id": worker_group_id.decode(),
+                    "worker_ids": [worker_id.decode() for worker_id in self._worker_groups[worker_group_id].keys()],
+                },
+                status=web.HTTPOk.status_code,
+            )
+
+        elif action == "shutdown_worker_group":
+            if "worker_group_id" not in request_json:
+                return web.json_response(
+                    {"error": "No worker_group_id specified"}, status=web.HTTPBadRequest.status_code
+                )
+
+            worker_group_id = request_json["worker_group_id"].encode()
+            try:
+                await self.shutdown_worker_group(worker_group_id)
+            except WorkerGroupNotFoundError as e:
+                return web.json_response({"error": str(e)}, status=web.HTTPNotFound.status_code)
+            except Exception as e:
+                return web.json_response({"error": str(e)}, status=web.HTTPInternalServerError.status_code)
+
+            return web.json_response({"status": "Worker group shutdown"}, status=web.HTTPOk.status_code)
+
+        else:
+            return web.json_response({"error": "Unknown action"}, status=web.HTTPBadRequest.status_code)
+
+    def create_app(self):
+        app = web.Application()
+        app.router.add_post("/", self.webhook_handler)
+        return app

scaler/worker_adapter/symphony/callback.py

@@ -0,0 +1,45 @@
+import concurrent.futures
+import threading
+from typing import Dict
+
+import cloudpickle
+
+from scaler.worker_adapter.symphony.message import SoamMessage
+
+try:
+    import soamapi
+except ImportError:
+    raise ImportError("IBM Spectrum Symphony API not found, please install it with 'pip install soamapi'.")
+
+
+class SessionCallback(soamapi.SessionCallback):
+    def __init__(self):
+        self._callback_lock = threading.Lock()
+        self._task_id_to_future: Dict[str, concurrent.futures.Future] = {}
+
+    def on_response(self, task_output_handle):
+        with self._callback_lock:
+            task_id = task_output_handle.get_id()
+
+            future = self._task_id_to_future.pop(task_id)
+
+            if task_output_handle.is_successful():
+                output_message = SoamMessage()
+                task_output_handle.populate_task_output(output_message)
+                result = cloudpickle.loads(output_message.get_payload())
+                future.set_result(result)
+            else:
+                future.set_exception(task_output_handle.get_exception().get_embedded_exception())
+
+    def on_exception(self, exception):
+        with self._callback_lock:
+            for future in self._task_id_to_future.values():
+                future.set_exception(exception)
+
+            self._task_id_to_future.clear()
+
+    def submit_task(self, task_id: str, future: concurrent.futures.Future):
+        self._task_id_to_future[task_id] = future
+
+    def get_callback_lock(self) -> threading.Lock:
+        return self._callback_lock

scaler/worker_adapter/symphony/heartbeat_manager.py

@@ -0,0 +1,79 @@
+import time
+from typing import Dict, Optional
+
+import psutil
+
+from scaler.config.types.object_storage_server import ObjectStorageConfig
+from scaler.io.mixins import AsyncConnector, AsyncObjectStorageConnector
+from scaler.protocol.python.message import WorkerHeartbeat, WorkerHeartbeatEcho
+from scaler.protocol.python.status import Resource
+from scaler.utility.mixins import Looper
+from scaler.worker.agent.mixins import HeartbeatManager, TimeoutManager
+from scaler.worker_adapter.symphony.task_manager import SymphonyTaskManager
+
+
+class SymphonyHeartbeatManager(Looper, HeartbeatManager):
+    def __init__(
+        self, storage_address: Optional[ObjectStorageConfig], capabilities: Dict[str, int], task_queue_size: int
+    ):
+        self._capabilities = capabilities
+        self._task_queue_size = task_queue_size
+
+        self._agent_process = psutil.Process()
+
+        self._connector_external: Optional[AsyncConnector] = None
+        self._connector_storage: Optional[AsyncObjectStorageConnector] = None
+        self._worker_task_manager: Optional[SymphonyTaskManager] = None
+        self._timeout_manager: Optional[TimeoutManager] = None
+
+        self._start_timestamp_ns = 0
+        self._latency_us = 0
+
+        self._storage_address: Optional[ObjectStorageConfig] = storage_address
+
+    def register(
+        self,
+        connector_external: AsyncConnector,
+        connector_storage: AsyncObjectStorageConnector,
+        worker_task_manager: SymphonyTaskManager,
+        timeout_manager: TimeoutManager,
+    ):
+        self._connector_external = connector_external
+        self._connector_storage = connector_storage
+        self._worker_task_manager = worker_task_manager
+        self._timeout_manager = timeout_manager
+
+    async def on_heartbeat_echo(self, heartbeat: WorkerHeartbeatEcho):
+        if self._start_timestamp_ns == 0:
+            # not handling echo if we didn't send out heartbeat
+            return
+
+        self._latency_us = int(((time.time_ns() - self._start_timestamp_ns) / 2) // 1_000)
+        self._start_timestamp_ns = 0
+        self._timeout_manager.update_last_seen_time()
+
+        if self._storage_address is None:
+            address_message = heartbeat.object_storage_address()
+            self._storage_address = ObjectStorageConfig(address_message.host, address_message.port)
+            await self._connector_storage.connect(self._storage_address.host, self._storage_address.port)
+
+    def get_storage_address(self) -> Optional[ObjectStorageConfig]:
+        return self._storage_address
+
+    async def routine(self):
+        if self._start_timestamp_ns != 0:
+            return
+
+        await self._connector_external.send(
+            WorkerHeartbeat.new_msg(
+                Resource.new_msg(int(self._agent_process.cpu_percent() * 10), self._agent_process.memory_info().rss),
+                psutil.virtual_memory().available,
+                self._task_queue_size,
+                self._worker_task_manager.get_queued_size(),
+                self._latency_us,
+                self._worker_task_manager.can_accept_task(),
+                [],
+                self._capabilities,
+            )
+        )
+        self._start_timestamp_ns = time.time_ns()

scaler/worker_adapter/symphony/message.py

@@ -0,0 +1,24 @@
+import array
+
+try:
+    import soamapi
+except ImportError:
+    raise ImportError("IBM Spectrum Symphony API not found, please install it with 'pip install soamapi'.")
+
+
+class SoamMessage(soamapi.Message):
+    def __init__(self, payload: bytes = b""):
+        self.__payload = payload
+
+    def set_payload(self, payload: bytes):
+        self.__payload = payload
+
+    def get_payload(self) -> bytes:
+        return self.__payload
+
+    def on_serialize(self, stream):
+        payload_array = array.array("b", self.get_payload())
+        stream.write_byte_array(payload_array, 0, len(payload_array))
+
+    def on_deserialize(self, stream):
+        self.set_payload(stream.read_byte_array("b"))