opengris-scaler 1.12.37__cp38-cp38-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,265 @@
+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.defaults import PROFILING_INTERVAL_SECONDS
+from scaler.config.types.object_storage_server import ObjectStorageAddressConfig
+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.mixins import AsyncBinder, AsyncConnector, AsyncObjectStorageConnector
+from scaler.io.utility import create_async_object_storage_connector
+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,
+        object_storage_address: Optional[ObjectStorageAddressConfig],
+        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._object_storage_address = object_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 = create_async_object_storage_connector()
+
+        self._heartbeat_manager = VanillaHeartbeatManager(
+            object_storage_address=self._object_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,
+            scheduler_address=self._address,
+            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._object_storage_address is not None:
+            # With a manually set storage address, immediately connect to the object storage server.
+            await self._connector_storage.connect(self._object_storage_address.host, self._object_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/common.py

@@ -0,0 +1,26 @@
+from typing import Dict
+
+WorkerGroupID = bytes
+
+
+class CapacityExceededError(Exception):
+    pass
+
+
+class WorkerGroupNotFoundError(Exception):
+    pass
+
+
+def format_capabilities(capabilities: Dict[str, int]) -> str:
+    """
+    Reverse of `parse_capabilities`: convert a capabilities dict into a
+    comma-separated capability string (e.g. "linux,cpu=4").
+    Values equal to -1 are emitted as flag-style entries (no `=value`).
+    """
+    parts = []
+    for name, value in capabilities.items():
+        if value == -1:
+            parts.append(name)
+        else:
+            parts.append(f"{name}={value}")
+    return ",".join(parts)

scaler/worker_adapter/ecs.py

@@ -0,0 +1,241 @@
+import logging
+import uuid
+from dataclasses import dataclass
+from typing import Dict, Set
+
+import boto3
+from aiohttp import web
+from aiohttp.web_request import Request
+
+from scaler.config.section.ecs_worker_adapter import ECSWorkerAdapterConfig
+from scaler.utility.identifiers import WorkerID
+from scaler.worker_adapter.common import (
+    CapacityExceededError,
+    WorkerGroupID,
+    WorkerGroupNotFoundError,
+    format_capabilities,
+)
+
+
+@dataclass
+class WorkerGroupInfo:
+    worker_ids: Set[WorkerID]
+    task_arn: str
+
+
+class ECSWorkerAdapter:
+    def __init__(self, config: ECSWorkerAdapterConfig):
+        self._address = config.worker_adapter_config.scheduler_address
+        self._object_storage_address = config.worker_adapter_config.object_storage_address
+        self._capabilities = config.worker_config.per_worker_capabilities.capabilities
+        self._io_threads = config.worker_io_threads
+        self._per_worker_task_queue_size = config.worker_config.per_worker_task_queue_size
+        self._max_instances = config.worker_adapter_config.max_workers
+        self._heartbeat_interval_seconds = config.worker_config.heartbeat_interval_seconds
+        self._task_timeout_seconds = config.worker_config.task_timeout_seconds
+        self._death_timeout_seconds = config.worker_config.death_timeout_seconds
+        self._garbage_collect_interval_seconds = config.worker_config.garbage_collect_interval_seconds
+        self._trim_memory_threshold_bytes = config.worker_config.trim_memory_threshold_bytes
+        self._hard_processor_suspend = config.worker_config.hard_processor_suspend
+        self._event_loop = config.event_loop
+
+        self._aws_access_key_id = config.aws_access_key_id
+        self._aws_secret_access_key = config.aws_secret_access_key
+        self._aws_region = config.aws_region
+
+        self._ecs_cluster = config.ecs_cluster
+        self._ecs_task_image = config.ecs_task_image
+        self._ecs_python_requirements = config.ecs_python_requirements
+        self._ecs_python_version = config.ecs_python_version
+        self._ecs_task_definition = config.ecs_task_definition
+        self._ecs_task_cpu = config.ecs_task_cpu
+        self._ecs_task_memory = config.ecs_task_memory
+        self._ecs_subnets = config.ecs_subnets
+
+        aws_session = boto3.Session(
+            aws_access_key_id=self._aws_access_key_id,
+            aws_secret_access_key=self._aws_secret_access_key,
+            region_name=self._aws_region,
+        )
+        self._ecs_client = aws_session.client("ecs")
+
+        resp = self._ecs_client.describe_clusters(clusters=[self._ecs_cluster])
+        clusters = resp.get("clusters") or []
+        if not clusters or clusters[0]["status"] != "ACTIVE":
+            logging.info(f"ECS cluster '{self._ecs_cluster}' missing, creating it.")
+            self._ecs_client.create_cluster(clusterName=self._ecs_cluster)
+
+        self._worker_groups: Dict[WorkerGroupID, WorkerGroupInfo] = {}
+
+        try:
+            resp = self._ecs_client.describe_task_definition(taskDefinition=self._ecs_task_definition)
+        except self._ecs_client.exceptions.ClientException:
+            logging.info(f"ECS task definition '{self._ecs_task_definition}' missing, creating it.")
+            iam_client = aws_session.client("iam")
+            try:
+                resp = iam_client.get_role(RoleName="ecsTaskExecutionRole")
+                execution_role_arn = resp["Role"]["Arn"]
+            except iam_client.exceptions.NoSuchEntityException:
+                resp = iam_client.create_role(
+                    RoleName="ecsTaskExecutionRole",
+                    AssumeRolePolicyDocument=(
+                        '{"Version": "2012-10-17", '
+                        '"Statement": [{"Effect": "Allow", '
+                        '"Principal": {"Service": "ecs-tasks.amazonaws.com"}, "Action": "sts:AssumeRole"}]}'
+                    ),
+                )
+                execution_role_arn = resp["Role"]["Arn"]
+                iam_client.attach_role_policy(
+                    RoleName="ecsTaskExecutionRole",
+                    PolicyArn="arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy",
+                )
+
+            resp = self._ecs_client.register_task_definition(
+                family=self._ecs_task_definition,
+                cpu=str(self._ecs_task_cpu * 1024),
+                memory=str(self._ecs_task_memory * 1024),
+                runtimePlatform={"cpuArchitecture": "X86_64", "operatingSystemFamily": "LINUX"},
+                networkMode="awsvpc",
+                containerDefinitions=[{"name": "scaler-container", "image": self._ecs_task_image, "essential": True}],
+                requiresCompatibilities=["FARGATE"],
+                executionRoleArn=execution_role_arn,
+            )
+        self._ecs_task_definition = resp["taskDefinition"]["taskDefinitionArn"]
+
+    async def start_worker_group(self) -> WorkerGroupID:
+        if len(self._worker_groups) >= self._max_instances != -1:
+            raise CapacityExceededError(f"Maximum number of instances ({self._max_instances}) reached.")
+
+        worker_names = [f"ECS|{uuid.uuid4().hex}" for _ in range(self._ecs_task_cpu)]
+        command = (
+            f"scaler_cluster {self._address.to_address()} "
+            f"--num-of-workers {self._ecs_task_cpu} "
+            f"--worker-names \"{','.join(worker_names)}\" "
+            f"--per-worker-task-queue-size {self._per_worker_task_queue_size} "
+            f"--heartbeat-interval-seconds {self._heartbeat_interval_seconds} "
+            f"--task-timeout-seconds {self._task_timeout_seconds} "
+            f"--garbage-collect-interval-seconds {self._garbage_collect_interval_seconds} "
+            f"--death-timeout-seconds {self._death_timeout_seconds} "
+            f"--trim-memory-threshold-bytes {self._trim_memory_threshold_bytes} "
+            f"--event-loop {self._event_loop} "
+            f"--worker-io-threads {self._io_threads}"
+        )
+
+        if self._hard_processor_suspend:
+            command += " --hard-processor-suspend"
+
+        if self._object_storage_address:
+            command += f" --object-storage-address {self._object_storage_address.to_string()}"
+
+        if format_capabilities(self._capabilities).strip():
+            command += f" --per-worker-capabilities {format_capabilities(self._capabilities)}"
+
+        resp = self._ecs_client.run_task(
+            cluster=self._ecs_cluster,
+            taskDefinition=self._ecs_task_definition,
+            launchType="FARGATE",
+            overrides={
+                "containerOverrides": [
+                    {
+                        "name": "scaler-container",
+                        "environment": [
+                            {"name": "COMMAND", "value": command},
+                            {"name": "PYTHON_REQUIREMENTS", "value": self._ecs_python_requirements},
+                            {"name": "PYTHON_VERSION", "value": self._ecs_python_version},
+                        ],
+                    }
+                ]
+            },
+            networkConfiguration={"awsvpcConfiguration": {"subnets": self._ecs_subnets, "assignPublicIp": "ENABLED"}},
+        )
+
+        failures = resp.get("failures") or []
+        if failures:
+            raise RuntimeError(f"ECS run task failed: {failures}")
+
+        tasks = resp.get("tasks") or []
+        if not tasks:
+            raise RuntimeError("ECS run task returned no tasks")
+        if len(tasks) > 1:
+            raise RuntimeError("ECS run task returned multiple tasks, expected only one")
+
+        task_arn = tasks[0]["taskArn"]
+        worker_group_id = f"ecs-{uuid.uuid4().hex}".encode()
+        self._worker_groups[worker_group_id] = WorkerGroupInfo(
+            worker_ids={WorkerID.generate_worker_id(worker_name) for worker_name in worker_names}, task_arn=task_arn
+        )
+        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.")
+
+        resp = self._ecs_client.stop_task(
+            cluster=self._ecs_cluster,
+            task=self._worker_groups[worker_group_id].task_arn,
+            reason="Shutdown requested by ecs adapter",
+        )
+        failures = resp.get("failures") or []
+        if failures:
+            raise RuntimeError(f"ECS stop task failed: {failures}")
+
+        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 == "get_worker_adapter_info":
+            return web.json_response(
+                {
+                    "max_worker_groups": self._max_instances,
+                    "workers_per_group": self._ecs_task_cpu,
+                    "base_capabilities": self._capabilities,
+                },
+                status=web.HTTPOk.status_code,
+            )
+
+        elif 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].worker_ids],
+                },
+                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