py-app-runner 0.5.49.dev0__py3-none-any.whl

py_app_runner/bridge/_service.py

@@ -0,0 +1,265 @@
+"""
+Bridge service should be treated as a transport layer for the other services.
+"""
+
+import asyncio
+import logging
+import os
+import signal
+import socket
+import threading
+from argparse import Namespace
+from collections.abc import Awaitable, Callable
+from importlib import import_module
+from typing import Any
+
+import uvloop
+from database_wrapper_pgsql import PgsqlWithPoolingAsync
+from database_wrapper_redis import RedisDbAsync, RedisDbWithPoolAsync
+from tornado import escape, httpserver, netutil, process
+from tornado.platform.asyncio import AsyncIOMainLoop
+
+from py_app_runner.bridge.web_app import WebApplication
+from py_app_runner.config import is_env_dev
+from py_app_runner.db_pools import DbPools
+from py_app_runner.pybridge import PyBridge
+from py_app_runner.registry import AppRegistry
+from py_app_runner.request_handler.handlers import WebApplicationBase
+from py_app_runner.utils import json_decode, json_encode, run_blocking, workers_auto
+from py_app_runner.wbcm.wb_connection_manager import WbConnectionManager
+
+ServerStarter = Callable[
+    [WebApplicationBase, Namespace, logging.Logger, list[socket.socket] | None],
+    Awaitable[None],
+]
+
+
+async def start_server_dev(
+    app: WebApplicationBase,
+    args: Namespace,
+    log: logging.Logger,
+    sockets: list[socket.socket] | None = None,  # unused
+) -> None:
+    # Enable autoreload
+    from tornado import autoreload
+
+    autoreload.start()
+
+    # Start the server
+    server = httpserver.HTTPServer(app, xheaders=True, max_body_size=app.settings.get("max_body_size"))
+    server.listen(args.port, address=args.address)  # no fork, no reuse_port
+
+    # Graceful shutdown on SIGINT/SIGTERM
+    shutdown = asyncio.Event()
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        loop.add_signal_handler(sig, shutdown.set)
+
+    log.info("Web server started in DEV mode (autoreload ON)")
+    try:
+        await shutdown.wait()
+
+    finally:
+        # Shutdown the server
+        server.stop()
+        await asyncio.sleep(0.1)
+        await server.close_all_connections()
+
+
+async def start_server_prod(
+    app: WebApplicationBase,
+    args: Namespace,
+    log: logging.Logger,
+    sockets: list[socket.socket] | None,
+) -> None:
+    assert sockets, "Prod starter requires pre-bound sockets"
+
+    # Set asyncio event loop for tornado
+    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+    AsyncIOMainLoop().install()
+
+    # Disable debug stuff
+    app.settings.update(autoreload=False)
+
+    # Start the server
+    server = httpserver.HTTPServer(app, xheaders=True, max_body_size=app.settings.get("max_body_size"))
+    server.add_sockets(sockets)
+
+    # Graceful shutdown on SIGINT/SIGTERM
+    shutdown = asyncio.Event()
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        loop.add_signal_handler(sig, shutdown.set)
+
+    log.info("Web server started in PROD mode")
+    try:
+        await shutdown.wait()
+    finally:
+        server.stop()
+        await asyncio.sleep(0.1)
+        await server.close_all_connections()
+        await asyncio.sleep(0)  # let callbacks run once
+
+
+async def child_process_initializer(
+    application: WebApplicationBase,
+    args: Namespace,
+    base_logger: logging.Logger,
+    sockets: list[socket.socket] | None,
+    start_server: ServerStarter,
+) -> None:
+    config = AppRegistry.config()
+
+    base_logger.info(f"Child starting, task_id={process.task_id()}")
+
+    # Init redis
+    redisPool = RedisDbWithPoolAsync(config["db"]["redis"])
+
+    # Init postgres
+    pgPool = PgsqlWithPoolingAsync(
+        db_config=config["db"]["main"],
+        instance_name=f"services_bridge_{config['environment']}",
+    )
+    await pgPool.open_pool()
+
+    # Init database pools
+    dbPools = DbPools(cache_db_pool=redisPool, main_db_pool=pgPool)
+    application.set_db_pools(dbPools)
+
+    # Init connection manager
+    wb_redis = RedisDbAsync(config["db"]["redis"])
+    cm = WbConnectionManager(cache_db=wb_redis, debug=args.debug_wbcm)
+    # Daemon: a wedged manager must not keep the process alive after the join below
+    # gives up.
+    bg_thread = threading.Thread(target=cm.start_in_new_loop, name="wbcm", daemon=True)
+    bg_thread.start()
+    application.set_wb_connection_manager(cm)
+
+    # Start the server
+    try:
+        base_logger.info(f"Web service child process started (task_id={process.task_id()})")
+        await start_server(application, args, base_logger, sockets)
+
+    finally:
+        # Stop processing messages, thus stopping the background thread
+        await cm.stop()
+
+        # join() blocks; keep it off the event loop and bounded so a stuck manager
+        # cannot hang the shutdown.
+        await run_blocking(bg_thread.join, 10.0)
+        if bg_thread.is_alive():
+            base_logger.warning("WbConnectionManager thread did not stop in time")
+
+        # Close the database pools
+        await redisPool.close()
+        await pgPool.close_pool()
+
+        # Remove references
+        application.set_db_pools(None)  # type: ignore
+        application.set_pybridge(None)  # type: ignore
+        application.set_wb_connection_manager(None)  # type: ignore
+
+        base_logger.info("Web service child process stopped")
+
+
+####################
+### Init Service ###
+####################
+async def init_service(
+    args: Namespace,
+    pybridge: PyBridge,
+    base_logger: logging.Logger,
+) -> None:
+    """Init service"""
+    config = AppRegistry.config()
+
+    # Replace tornado's default json encoder/decoder
+    escape.json_encode = json_encode
+    escape.json_decode = json_decode
+
+    # Load all the endpoint services
+    for service_name in config["services"]:
+        service = pybridge.load_service_pybridge(service_name)
+        if service:
+            base_logger.info(f"Loaded service: {service_name}")
+            if hasattr(service, "service_name"):
+                service_name = service.service_name
+            pybridge.cache_service(service_name, service)
+
+            # Load additional endpoints / services
+            number_of_routes = 0
+            if hasattr(service, "bridge_routes"):
+                routes = service.bridge_routes()
+                number_of_routes = len(routes)
+                for route_name in routes:
+                    route_handler = routes[route_name]
+                    pybridge.cache_service(route_name, route_handler)
+
+            base_logger.info(f"Loaded service: {service_name}; Additional routes: {number_of_routes}")
+        else:
+            base_logger.info(f"No endpoint for the service: {service_name}")
+
+    # Auto-discover project routes and optional app settings
+    routes = None
+    app_settings: dict[str, Any] = {}
+    try:
+        routes_module = import_module("services.bridge.routes")
+        if hasattr(routes_module, "get_routes"):
+            routes = routes_module.get_routes()
+            base_logger.info(f"Loaded {len(routes)} route(s) from services.bridge.routes")
+        else:
+            base_logger.warning("services.bridge.routes found but missing get_routes()")
+
+        # Projects can pass tornado Application settings (websocket_max_message_size, ...)
+        # plus max_body_size, which the server starters hand to HTTPServer.
+        if hasattr(routes_module, "get_app_settings"):
+            app_settings = routes_module.get_app_settings() or {}
+            base_logger.info(f"Loaded app settings from services.bridge.routes: {sorted(app_settings)}")
+    except ModuleNotFoundError as e:
+        # Only swallow "the routes module itself is absent". A missing import *inside*
+        # routes.py must not be reported as "no routes" and start a bridge that serves
+        # nothing.
+        if e.name not in ("services", "services.bridge", "services.bridge.routes"):
+            raise
+        base_logger.warning("No services.bridge.routes found — bridge has no routes")
+
+    # Initialize our application
+    app_kwargs: dict[str, Any] = {
+        "autoreload": False,
+        "xheaders": True,
+    }
+    app_kwargs.update(app_settings)
+    application = WebApplication(routes=routes, **app_kwargs)
+    application.set_pybridge(pybridge)
+
+    # Dev mode: run single process without forking
+    # This is needed to have autoreload working properly
+    if is_env_dev(config):
+        await child_process_initializer(application, args, base_logger, None, start_server_dev)
+        return
+
+    # Bind sockets and start processes
+    sockets = netutil.bind_sockets(args.port, address=args.address, reuse_port=True)
+
+    # The parent typically runs as container PID 1, which ignores signals with no
+    # handler installed - `docker stop` would hang and end in SIGKILL. Forward
+    # TERM/INT to the process group so the children shut down gracefully.
+    def _forward_to_children(signum: int, frame: Any) -> None:
+        signal.signal(signum, signal.SIG_IGN)  # killpg below also targets ourselves
+        os.killpg(0, signum)
+
+    signal.signal(signal.SIGTERM, _forward_to_children)
+    signal.signal(signal.SIGINT, _forward_to_children)
+
+    process.fork_processes(workers_auto() if not config["debug"] else 1)
+
+    # Children continue past the fork; restore default handling so the asyncio
+    # signal handlers installed by the server starter are the only ones active.
+    if process.task_id() is not None:
+        signal.signal(signal.SIGTERM, signal.SIG_DFL)
+        signal.signal(signal.SIGINT, signal.SIG_DFL)
+        asyncio.run(child_process_initializer(application, args, base_logger, sockets, start_server_prod))
+        return
+
+    # Parent: fork_processes only returns here once all children have exited.
+    base_logger.info("Web service parent exiting (all children stopped)")

py_app_runner/bridge/_service_args.py

@@ -0,0 +1,24 @@
+import logging
+from argparse import ArgumentParser, _SubParsersAction  # type: ignore
+
+from py_app_runner.pybridge import PyBridge
+
+
+###########################
+### Register Subparsers ###
+###########################
+def reg_subparsers(
+    subparsers: "_SubParsersAction[ArgumentParser]",
+    pybridge: PyBridge,
+    baseLogger: logging.Logger,
+) -> None:
+    """Command line subparsers"""
+
+    bridge_parser = subparsers.add_parser(
+        "bridge",
+        description="Bridge api handler service",
+        help="Bridge api handler service",
+    )
+    bridge_parser.add_argument("--address", type=str, default="0.0.0.0", help="Address to bind to")
+    bridge_parser.add_argument("--port", type=int, default=4100, help="Port")
+    bridge_parser.add_argument("--debug-wbcm", action="store_true", help="Enable debug for WBCM")

py_app_runner/bridge/api.py

@@ -0,0 +1,138 @@
+import logging
+
+from py_app_runner.http_exception import HTTPException
+
+# from memory_profiler import profile
+from py_app_runner.request_handler.handlers import WebHandlerBase
+
+
+# * ApiHandler
+class ApiHandler(WebHandlerBase):
+    """Http request handler"""
+
+    def initialize(self) -> None:  # type: ignore
+        # Override default logger
+        loggerName = f"{__name__}.{self.__class__.__name__}"
+        self.logger = logging.getLogger(loggerName)
+
+    ########################
+    ### Request Handling ###
+    ########################
+    # def set_default_headers(self):
+    #     # self.set_header("Access-Control-Allow-Origin", "*")
+    #     origin = self.request.headers.get(  # type: ignore
+    #         "Origin", "*"
+    #     )  # use current requesting origin
+    #     self.set_header("Access-Control-Allow-Origin", origin)  # type: ignore
+    #     self.set_header(
+    #         "Access-Control-Allow-Headers",
+    #         "X-API-Key,Authorization,Accept,Origin,DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,
+    #           If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range",
+    #     )
+    #     self.set_header("Access-Control-Allow-Methods", "POST,GET,OPTIONS")
+    #     self.set_header("Access-Control-Max-Age", 10800)
+    #     self.set_header("Access-Control-Request-Headers", "*")
+    #     self.set_header("Access-Control-Allow-Credentials", "true")
+
+    async def options(self, service: str | None = None, action: str | None = None) -> None:  # type: ignore
+        self.set_header("Content-Type", "text/plain charset=UTF-8")
+        self.set_header("Content-Length", 0)
+        self.set_status(204)
+        await self.finish()  # type: ignore
+
+    # @profile
+    async def get(self, service: str | None = None, action: str | None = None) -> None:  # type: ignore
+        """Get request"""
+        try:
+            async with self.timer.aenter("bridge.get"):
+                await self.get_v1(service=service, action=action)
+
+        except HTTPException as e:
+            self.log_request(error=e)
+            self.error(e)
+
+        except Exception as e:
+            self.log_request(error=e)
+            self.logger.exception(f"Error processing request with exception: {e}")
+            # Anything reaching here is a server-side fault, not a bad request - a 4xx
+            # would tell the client to stop retrying and hide the failure from monitoring.
+            self.error(
+                "Found an error while processing your request. Please try again later."
+                " Send us a message if the problem persists.",
+                http_status=500,
+            )
+
+        finally:
+            self.auth_token = None
+
+            # Print debug and free resources
+            self.timer.print_timer_stats()
+            self.timer.reset_timers()
+
+    async def post(self, service: str | None = None, action: str | None = None) -> None:  # type: ignore[override]
+        """Post request is just a forward to get request"""
+        await self.get(service, action)
+
+    ##########
+    ### V1 ###
+    ##########
+    async def get_v1(self, service: str | None = None, action: str | None = None) -> None:
+        """
+        Requests always have to be in this format:
+        {
+            "action": "action_name",
+            "data": {
+                "input1": "value1",
+                "input2": "value2",
+                ...
+            }
+        }
+        """
+
+        async with self.timer.aenter("bridge.get_v1.findService"):
+            # Move to finding a service
+            res = self.find_service(service_name=service)
+            if not res.result:
+                raise HTTPException(
+                    f"Could not find service by provided name: {service}",
+                    code=1002,
+                    http_status=400,
+                )
+
+            # Bridge request handler
+            bridge_request, requires_api_key = res.result
+            if not bridge_request:
+                raise HTTPException(f"Service not found: {service}", code=1003, http_status=400)
+
+        # Timer
+        async with self.timer.aenter("bridge.get_v1.withPools"):
+            # Check for valid api key
+            if requires_api_key is not False:
+                status = await self.has_valid_api_key()
+                if isinstance(status, str):
+                    raise HTTPException(
+                        f"Application is not authenticated: {status}",
+                        code=1401,
+                        http_status=401,
+                    )
+
+        # Timer
+        async with self.timer.aenter("bridge.get_v1.run_request_handler"):
+            # Find request data
+            request_data = self.get_request_data(action)
+            action = request_data.get("action", None)
+            input_data = request_data.get("data", {})
+
+            if not action:
+                raise HTTPException("Missing action", code=1005, http_status=400)
+
+            return_data = await bridge_request(action, input_data, self)
+            if return_data is not None:
+                self.write(return_data)
+                self.log_request(response=return_data, level="debug")
+            else:
+                # A service that returns nothing produced no payload, which is not an
+                # error - the WebSocket path stays silent in the same case. 204 has no
+                # body, so nothing must be written here.
+                self.set_status(204)
+                self.log_request(level="debug")

py_app_runner/bridge/encoders/__init__.py

@@ -0,0 +1,5 @@
+from .base import MessageEncoder
+from .json_encoder import JsonEncoder
+from .msgpack_encoder import MsgpackEncoder
+
+__all__ = ["MessageEncoder", "JsonEncoder", "MsgpackEncoder"]

py_app_runner/bridge/encoders/base.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class MessageEncoder(ABC):
+    """Abstract base for WebSocket message encoding/decoding."""
+
+    @abstractmethod
+    def encode(self, data: dict[str, Any]) -> str | bytes:
+        """Encode a dict into a wire format (str for text frames, bytes for binary)."""
+
+    @abstractmethod
+    def decode(self, raw: str | bytes) -> dict[str, Any]:
+        """Decode a raw WebSocket message into a dict."""
+
+    @property
+    @abstractmethod
+    def is_binary(self) -> bool:
+        """Whether this encoder produces binary frames (True) or text frames (False)."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Human-readable name for logging."""

py_app_runner/bridge/encoders/json_encoder.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+from py_app_runner.utils import json_decode, json_encode
+
+from .base import MessageEncoder
+
+
+class JsonEncoder(MessageEncoder):
+    """JSON message encoder for WebSocket frames."""
+
+    def encode(self, data: dict[str, Any]) -> str:
+        return json_encode(data)
+
+    def decode(self, raw: str | bytes) -> dict[str, Any]:
+        try:
+            return json_decode(raw)
+        except Exception as exc:
+            raise ValueError(str(exc)) from exc
+
+    @property
+    def is_binary(self) -> bool:
+        return False
+
+    @property
+    def name(self) -> str:
+        return "json"

py_app_runner/bridge/encoders/msgpack_encoder.py

@@ -0,0 +1,58 @@
+import datetime as dt
+import math
+from decimal import Decimal
+from enum import Enum
+from typing import Any
+
+import msgpack
+
+from .base import MessageEncoder
+
+
+def _msgpack_default(obj: Any) -> Any:
+    """Custom packer for types msgpack doesn't handle natively."""
+    if isinstance(obj, Decimal):
+        return float(obj)
+
+    if isinstance(obj, dt.datetime):
+        # Normalize to UTC: the wire format carries no offset.
+        if obj.tzinfo is not None:
+            obj = obj.astimezone(dt.UTC).replace(tzinfo=None)
+        return obj.strftime("%Y-%m-%dT%H:%M:%S")
+
+    if isinstance(obj, dt.date):
+        return obj.strftime("%Y-%m-%d")
+
+    if isinstance(obj, Enum):
+        return obj.value
+
+    if isinstance(obj, float):
+        if not math.isfinite(obj):
+            return None
+        return obj
+
+    if isinstance(obj, (int, str)):
+        return obj
+
+    return str(obj)
+
+
+class MsgpackEncoder(MessageEncoder):
+    """MessagePack encoder for WebSocket binary frames."""
+
+    def encode(self, data: dict[str, Any]) -> bytes:
+        result: bytes = msgpack.packb(data, default=_msgpack_default, use_bin_type=True)  # type: ignore[assignment]
+        return result
+
+    def decode(self, raw: str | bytes) -> dict[str, Any]:
+        if isinstance(raw, str):
+            raw = raw.encode("utf-8")
+        return msgpack.unpackb(raw, raw=False)
+
+    @property
+    def is_binary(self) -> bool:
+        return True
+
+    @property
+    def name(self) -> str:
+        return "msgpack"

py_app_runner/bridge/web_app.py

@@ -0,0 +1,31 @@
+from typing import Any
+
+from tornado.web import url as TornadoUrl
+
+from py_app_runner.config import is_env_dev
+from py_app_runner.registry import AppRegistry
+from py_app_runner.request_handler.handlers import WebApplicationBase
+
+RouteDefinition = tuple[str, type, str]
+
+
+class WebApplication(WebApplicationBase):
+    """Tornado web application that builds its handler list from a project-defined routes list."""
+
+    def __init__(self, routes: list[RouteDefinition] | None = None, **kwargs: Any):
+        handlers = []
+        if routes:
+            for pattern, handler_class, name in routes:
+                handlers.append(TornadoUrl(pattern, handler_class, name=name))
+
+        kwargs["handlers"] = handlers
+        # setdefault, so a project can override it through get_app_settings().
+        kwargs.setdefault("debug", is_env_dev(AppRegistry.config()))
+        # Without server pings, dead peers are never detected and writes to them
+        # buffer in memory unboundedly.
+        # Tornado clamps the timeout to the interval, so a larger value here would be
+        # discarded and logged as a warning.
+        kwargs.setdefault("websocket_ping_interval", 30)
+        kwargs.setdefault("websocket_ping_timeout", 30)
+
+        super().__init__(**kwargs)