runtimepy 5.5.0__tar.gz → 5.6.0__tar.gz

{runtimepy-5.5.0/runtimepy.egg-info → runtimepy-5.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: runtimepy
-Version: 5.5.0
+Version: 5.6.0
 Summary: A framework for implementing Python services.
 Home-page: https://github.com/vkottler/runtimepy
 Author: Vaughn Kottler
@@ -17,9 +17,9 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: psutil
 Requires-Dist: websockets
 Requires-Dist: svgen>=0.6.8
-Requires-Dist: psutil
 Requires-Dist: vcorelib>=3.3.1
 Provides-Extra: test
 Requires-Dist: pylint; extra == "test"
@@ -44,11 +44,11 @@ Requires-Dist: uvloop; (sys_platform != "win32" and sys_platform != "cygwin") an
     =====================================
     generator=datazen
     version=3.1.4
-    hash=5c5edaf1332d842e9ca04a018455beba
+    hash=cd04f0ce079f8c60bc93c7f1d098316b
     =====================================
 -->
 
-# runtimepy ([5.5.0](https://pypi.org/project/runtimepy/))
+# runtimepy ([5.6.0](https://pypi.org/project/runtimepy/))
 
 [![python](https://img.shields.io/pypi/pyversions/runtimepy.svg)](https://pypi.org/project/runtimepy/)
 ![Build Status](https://github.com/vkottler/runtimepy/workflows/Python%20Package/badge.svg)

{runtimepy-5.5.0 → runtimepy-5.6.0}/README.md

@@ -2,11 +2,11 @@
     =====================================
     generator=datazen
     version=3.1.4
-    hash=5c5edaf1332d842e9ca04a018455beba
+    hash=cd04f0ce079f8c60bc93c7f1d098316b
     =====================================
 -->
 
-# runtimepy ([5.5.0](https://pypi.org/project/runtimepy/))
+# runtimepy ([5.6.0](https://pypi.org/project/runtimepy/))
 
 [![python](https://img.shields.io/pypi/pyversions/runtimepy.svg)](https://pypi.org/project/runtimepy/)
 ![Build Status](https://github.com/vkottler/runtimepy/workflows/Python%20Package/badge.svg)

{runtimepy-5.5.0 → runtimepy-5.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta:__legacy__"
 
 [project]
 name = "runtimepy"
-version = "5.5.0"
+version = "5.6.0"
 description = "A framework for implementing Python services."
 readme = "README.md"
 requires-python = ">=3.11"

{runtimepy-5.5.0 → runtimepy-5.6.0}/runtimepy/__init__.py

@@ -1,7 +1,7 @@
 # =====================================
 # generator=datazen
 # version=3.1.4
-# hash=e8348ec684fac751916510d1d8c7dafb
+# hash=6c21c41096ed57b6c6469232c97787cd
 # =====================================
 
 """
@@ -10,7 +10,7 @@ Useful defaults and other package metadata.
 
 DESCRIPTION = "A framework for implementing Python services."
 PKG_NAME = "runtimepy"
-VERSION = "5.5.0"
+VERSION = "5.6.0"
 
 # runtimepy-specific content.
 METRICS_NAME = "metrics"

{runtimepy-5.5.0 → runtimepy-5.6.0}/runtimepy/commands/server.py

@@ -14,6 +14,9 @@ from vcorelib.args import CommandFunction as _CommandFunction
 from runtimepy.commands.arbiter import arbiter_cmd
 from runtimepy.commands.common import FACTORIES, arbiter_args, cmd_with_jit
 
+SSL_PASSTHROUGH = ["cafile", "capath", "cadata", "certfile"]
+PASSTHROUGH = SSL_PASSTHROUGH + ["keyfile"]
+
 
 def port_name(args: _Namespace, port: str = "port") -> str:
     """Get the name for a connection factory's port."""
@@ -25,7 +28,7 @@ def server_data(args: _Namespace) -> dict[str, Any]:
 
     return {
         "factory": args.factory,
-        "kwargs": {"port": f"${port_name(args)}", "host": args.host},
+        "kwargs": get_kwargs(args, port=f"${port_name(args)}", host=args.host),
     }
 
 
@@ -34,6 +37,26 @@ def is_websocket(args: _Namespace) -> bool:
     return "websocket" in args.factory.lower()
 
 
+def is_ssl(kwargs: dict[str, Any]) -> bool:
+    """Determine if server arugments indicate SSL use."""
+    return any(x in kwargs for x in SSL_PASSTHROUGH)
+
+
+def get_kwargs(args: _Namespace, **kwargs) -> dict[str, Any]:
+    """Get boilerplate kwargs."""
+
+    new_kwargs: dict[str, Any] = {**kwargs}
+
+    # Pass additional arguments through.
+    print(args)
+    for opt in PASSTHROUGH:
+        value = getattr(args, opt, None)
+        if value is not None:
+            new_kwargs[opt] = value
+
+    return new_kwargs
+
+
 def client_data(args: _Namespace) -> dict[str, Any]:
     """Get client data based on command-line arguments."""
 
@@ -43,7 +66,9 @@ def client_data(args: _Namespace) -> dict[str, Any]:
     kwargs: dict[str, Any] = {}
 
     if is_websocket(args):
-        arg_list.append(f"ws://localhost:{port}")
+        arg_list.append(
+            f"ws{'s' if is_ssl(get_kwargs(args)) else ''}://localhost:{port}"
+        )
     elif not args.udp:
         kwargs["host"] = "localhost"
         kwargs["port"] = port
@@ -76,7 +101,9 @@ def config_data(args: _Namespace) -> dict[str, Any]:
             {
                 "name": port_name(args, port="server"),
                 "factory": args.factory,
-                "kwargs": {"local_addr": ["0.0.0.0", f"${port_name(args)}"]},
+                "kwargs": get_kwargs(
+                    args, local_addr=["0.0.0.0", f"${port_name(args)}"]
+                ),
             }
         )
 
@@ -108,6 +135,11 @@ def add_server_cmd(parser: _ArgumentParser) -> _CommandFunction:
     """Add server-command arguments to its parser."""
 
     with arbiter_args(parser, nargs="*"):
+        for optional in PASSTHROUGH:
+            parser.add_argument(
+                f"--{optional}", help="passed directly to instantiation"
+            )
+
         parser.add_argument(
             "--host",
             default="0.0.0.0",

{runtimepy-5.5.0 → runtimepy-5.6.0}/runtimepy/data/js/util.js

@@ -1,6 +1,15 @@
 function worker_config(config) {
   let worker_cfg = {};
 
+  let port_name = "runtimepy_websocket";
+  let uri_prefix = "ws";
+
+  /* Ensured TLS is handled properly. */
+  if (location.protocol.includes("https")) {
+    port_name = "runtimepy_secure_websocket";
+    uri_prefix += "s";
+  }
+
   /* Look for connections to establish. */
   let ports = config["config"]["ports"];
   for (let port_idx in ports) {
@@ -10,11 +19,11 @@ function worker_config(config) {
     let hostname = window.location.hostname;
 
     /* This business logic could use some work. */
-    if (port["name"].includes("runtimepy_websocket")) {
+    if (port["name"].includes(port_name)) {
       if (port["name"].includes("data")) {
-        worker_cfg["data"] = "ws://" + hostname + ":" + port["port"];
+        worker_cfg["data"] = `${uri_prefix}://${hostname}:` + port["port"];
       } else {
-        worker_cfg["json"] = "ws://" + hostname + ":" + port["port"];
+        worker_cfg["json"] = `${uri_prefix}://${hostname}:` + port["port"];
       }
     }
   }

{runtimepy-5.5.0 → runtimepy-5.6.0}/runtimepy/net/arbiter/tcp/__init__.py

@@ -42,6 +42,7 @@ class TcpConnectionFactory(_ConnectionFactory, _Generic[T]):
         """Create a task that will run a connection server."""
 
         assert not [*args], "Only keyword arguments are used!"
+
         return self.kind.app(
             stop_sig,
             manager=manager,

{runtimepy-5.5.0 → runtimepy-5.6.0}/runtimepy/net/server/app/__init__.py

@@ -27,26 +27,27 @@ async def launch_browser(app: AppInfo) -> None:
     """
 
     # Launch browser based on config option.
-    if config_param(app, "xdg_open_http", False):
-
-        port: Any
-        for port in app.config["root"]["ports"]:  # type: ignore
-            if "http_server" in port["name"]:
-                # URI parameters.
-                hostname = config_param(app, "xdg_host", "localhost")
-
-                # Assemble URI.
-                uri = f"http://{hostname}:{port['port']}/"
-
-                # Add a fragment if one was specified.
-                fragment = config_param(app, "xdg_fragment", "")
-                if fragment:
-                    uri += "#" + fragment
-
-                with suppress(FileNotFoundError):
-                    await app.stack.enter_async_context(
-                        spawn_exec("xdg-open", uri)
-                    )
+    for prefix in ["http", "https"]:
+        if config_param(app, f"xdg_open_{prefix}", False):
+
+            port: Any
+            for port in app.config["root"]["ports"]:  # type: ignore
+                if f"{prefix}_server" in port["name"]:
+                    # URI parameters.
+                    hostname = config_param(app, "xdg_host", "localhost")
+
+                    # Assemble URI.
+                    uri = f"{prefix}://{hostname}:{port['port']}/"
+
+                    # Add a fragment if one was specified.
+                    fragment = config_param(app, "xdg_fragment", "")
+                    if fragment:
+                        uri += "#" + fragment
+
+                    with suppress(FileNotFoundError):
+                        await app.stack.enter_async_context(
+                            spawn_exec("xdg-open", uri)
+                        )
 
 
 # Could add an interface for adding multiple applications.

runtimepy-5.6.0/runtimepy/net/ssl.py

@@ -0,0 +1,33 @@
+"""
+A module implementing SSL-related interfaces.
+"""
+
+# built-in
+import ssl
+from typing import Any
+
+
+def handle_possible_ssl(client: bool = True, **kwargs) -> dict[str, Any]:
+    """Handle creating an SSL context based on keyword arguments."""
+
+    args = ["cafile", "capath", "cadata"]
+    if (
+        kwargs.pop("use_ssl", False)
+        or any(x in kwargs for x in args)
+        or "certfile" in kwargs
+    ):
+        context = ssl.create_default_context(
+            purpose=(
+                ssl.Purpose.SERVER_AUTH if client else ssl.Purpose.CLIENT_AUTH
+            ),
+            **{x: kwargs.pop(x, None) for x in args},
+        )
+
+        if "certfile" in kwargs:
+            context.load_cert_chain(
+                kwargs.pop("certfile"), keyfile=kwargs.pop("keyfile", None)
+            )
+
+        kwargs["ssl"] = context
+
+    return kwargs

{runtimepy-5.5.0 → runtimepy-5.6.0}/runtimepy/net/tcp/connection.py

@@ -27,6 +27,7 @@ from runtimepy.net.connection import EchoConnection as _EchoConnection
 from runtimepy.net.connection import NullConnection as _NullConnection
 from runtimepy.net.manager import ConnectionManager as _ConnectionManager
 from runtimepy.net.mixin import TransportMixin as _TransportMixin
+from runtimepy.net.ssl import handle_possible_ssl
 from runtimepy.net.tcp.create import (
     TcpTransportProtocol,
     tcp_transport_protocol_backoff,
@@ -70,6 +71,20 @@ class TcpConnection(_Connection, _TransportMixin):
         self._protocol = protocol
         self._protocol.conn = self
 
+    @classmethod
+    def get_log_prefix(cls, is_ssl: bool = False) -> str:
+        """Get a logging prefix for this instance."""
+
+        # Default implementation doesn't handle this.
+        del is_ssl
+
+        return cls.log_prefix
+
+    @property
+    def is_ssl(self) -> bool:
+        """Determine if this connection uses SSL."""
+        return self._transport.get_extra_info("sslcontext") is not None
+
     async def _await_message(self) -> _Optional[_Union[_BinaryMessage, str]]:
         """Await the next message. Return None on error or failure."""
 
@@ -142,18 +157,24 @@ class TcpConnection(_Connection, _TransportMixin):
                     callback(self.conn)
 
         eloop = _get_event_loop()
+
+        server_kwargs = handle_possible_ssl(client=False, **kwargs)
+        is_ssl = "ssl" in server_kwargs
         server = await eloop.create_server(
-            CallbackProtocol, family=_socket.AF_INET, **kwargs
+            CallbackProtocol,
+            family=_socket.AF_INET,
+            **server_kwargs,
         )
         async with server:
             for socket in server.sockets:
                 sockname = socket.getsockname()
                 LOG.info(
-                    "Started %s server listening on '%s%s' (%s%s:%d).",
+                    "Started %s%s server listening on '%s%s' (%s%s:%d).",
+                    "secure " if is_ssl else "",
                     cls.log_alias,
-                    cls.log_prefix,
+                    cls.get_log_prefix(is_ssl=is_ssl),
                     _sockname(socket),
-                    cls.log_prefix,
+                    cls.get_log_prefix(is_ssl=is_ssl),
                     sockname[0] if sockname[0] != "0.0.0.0" else "localhost",
                     sockname[1],
                 )
@@ -193,7 +214,10 @@ class TcpConnection(_Connection, _TransportMixin):
     @classmethod
     @_asynccontextmanager
     async def create_pair(
-        cls: type[T], peer: type[V] = None
+        cls: type[T],
+        peer: type[V] = None,
+        serve_kwargs: dict[str, _Any] = None,
+        connect_kwargs: dict[str, _Any] = None,
     ) -> _AsyncIterator[tuple[V, T]]:
         """Create a connection pair."""
 
@@ -212,13 +236,20 @@ class TcpConnection(_Connection, _TransportMixin):
                 peer = cls  # type: ignore
             assert peer is not None
 
+            if serve_kwargs is None:
+                serve_kwargs = {}
+
             server = await stack.enter_async_context(
-                peer.serve(callback, port=0, backlog=1)
+                peer.serve(callback, port=0, backlog=1, **serve_kwargs)
             )
 
             host = server.sockets[0].getsockname()
+
+            if connect_kwargs is None:
+                connect_kwargs = {}
+
             client = await cls.create_connection(
-                host="localhost", port=host[1]
+                host="localhost", port=host[1], **connect_kwargs
             )
             await cond.acquire()
 

{runtimepy-5.5.0 → runtimepy-5.6.0}/runtimepy/net/tcp/create.py

@@ -11,6 +11,7 @@ from typing import Callable, Optional
 
 # internal
 from runtimepy.net.backoff import ExponentialBackoff
+from runtimepy.net.ssl import handle_possible_ssl
 from runtimepy.net.tcp.protocol import QueueProtocol
 from runtimepy.net.util import try_log_connection_error
 
@@ -26,7 +27,7 @@ async def tcp_transport_protocol(**kwargs) -> TcpTransportProtocol:
 
     transport: _Transport
     transport, protocol = await _asyncio.get_event_loop().create_connection(
-        QueueProtocol, **kwargs
+        QueueProtocol, **handle_possible_ssl(**kwargs)
     )
     return transport, protocol
 

{runtimepy-5.5.0 → runtimepy-5.6.0}/runtimepy/net/tcp/http/__init__.py

@@ -58,7 +58,6 @@ class HttpConnection(_TcpConnection):
     expecting_response: bool
 
     log_alias = "HTTP"
-    log_prefix = "http://"
 
     # Handlers registered at the class level so that instances created at
     # runtime don't need additional initialization.
@@ -79,6 +78,12 @@ class HttpConnection(_TcpConnection):
         self.handlers[http.HTTPMethod.GET] = self.get_handler
         self.handlers[http.HTTPMethod.POST] = self.post_handler
 
+    @classmethod
+    def get_log_prefix(cls, is_ssl: bool = False) -> str:
+        """Get a logging prefix for this instance."""
+
+        return f"http{'s' if is_ssl else ''}://"
+
     async def get_handler(
         self,
         response: ResponseHeader,

{runtimepy-5.5.0 → runtimepy-5.6.0}/runtimepy/net/websocket/connection.py

@@ -10,6 +10,7 @@ from contextlib import AsyncExitStack as _AsyncExitStack
 from contextlib import asynccontextmanager as _asynccontextmanager
 from contextlib import suppress as _suppress
 from logging import getLogger as _getLogger
+from typing import Any as _Any
 from typing import AsyncIterator as _AsyncIterator
 from typing import Awaitable as _Awaitable
 from typing import Callable as _Callable
@@ -36,6 +37,7 @@ from runtimepy.net.connection import BinaryMessage, Connection
 from runtimepy.net.connection import EchoConnection as _EchoConnection
 from runtimepy.net.connection import NullConnection as _NullConnection
 from runtimepy.net.manager import ConnectionManager as _ConnectionManager
+from runtimepy.net.ssl import handle_possible_ssl
 
 T = _TypeVar("T", bound="WebsocketConnection")
 ConnectionInit = _Callable[[T], _Awaitable[bool]]
@@ -93,7 +95,11 @@ class WebsocketConnection(Connection):
     async def create_connection(cls: type[T], uri: str, **kwargs) -> T:
         """Connect a client to an endpoint."""
 
-        protocol = await getattr(websockets, "connect")(uri, **kwargs)
+        kwargs.setdefault("use_ssl", uri.startswith("wss"))
+
+        protocol = await getattr(websockets, "connect")(
+            uri, **handle_possible_ssl(**kwargs)
+        )
         return cls(protocol)
 
     @classmethod
@@ -101,7 +107,11 @@ class WebsocketConnection(Connection):
     async def client(cls: type[T], uri: str, **kwargs) -> _AsyncIterator[T]:
         """A wrapper for connecting a client."""
 
-        async with getattr(websockets, "connect")(uri, **kwargs) as protocol:
+        kwargs.setdefault("use_ssl", uri.startswith("wss"))
+
+        async with getattr(websockets, "connect")(
+            uri, **handle_possible_ssl(**kwargs)
+        ) as protocol:
             yield cls(protocol)
 
     @classmethod
@@ -154,7 +164,9 @@ class WebsocketConnection(Connection):
 
     @classmethod
     @_asynccontextmanager
-    async def create_pair(cls: type[T]) -> _AsyncIterator[tuple[T, T]]:
+    async def create_pair(
+        cls: type[T], serve_kwargs: dict[str, _Any] = None
+    ) -> _AsyncIterator[tuple[T, T]]:
         """Obtain a connected pair of WebsocketConnection objects."""
 
         server_conn: _Optional[T] = None
@@ -167,15 +179,21 @@ class WebsocketConnection(Connection):
             return True
 
         async with _AsyncExitStack() as stack:
+            if serve_kwargs is None:
+                serve_kwargs = {}
+
+            serve_kwargs = handle_possible_ssl(client=False, **serve_kwargs)
+            is_ssl = "ssl" in serve_kwargs
+
             # Start a server.
             server = await stack.enter_async_context(
-                _serve(server_init, host="0.0.0.0", port=0)
+                _serve(server_init, host="0.0.0.0", port=0, **serve_kwargs)
             )
 
             host = list(server.sockets)[0].getsockname()
 
             client_conn = await stack.enter_async_context(
-                cls.client(f"ws://localhost:{host[1]}")
+                cls.client(f"ws{'s' if is_ssl else ''}://localhost:{host[1]}")
             )
 
             # Connect a client and yield both sides of the connection.
@@ -193,13 +211,17 @@ class WebsocketConnection(Connection):
     ) -> _AsyncIterator[_WebSocketServer]:
         """Serve a WebSocket server."""
 
+        kwargs = handle_possible_ssl(client=False, **kwargs)
+        is_ssl = "ssl" in kwargs
+
         async with _serve(
             cls.server_handler(init=init, stop_sig=stop_sig, manager=manager),
             **kwargs,
         ) as server:
             for socket in server.sockets:
                 LOG.info(
-                    "Started WebSocket server listening on '%s'.",
+                    "Started WebSocket server listening on 'ws%s://%s'.",
+                    "s" if is_ssl else "",
                     _sockname(socket),
                 )
             yield server

{runtimepy-5.5.0 → runtimepy-5.6.0/runtimepy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: runtimepy
-Version: 5.5.0
+Version: 5.6.0
 Summary: A framework for implementing Python services.
 Home-page: https://github.com/vkottler/runtimepy
 Author: Vaughn Kottler
@@ -17,9 +17,9 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: psutil
 Requires-Dist: websockets
 Requires-Dist: svgen>=0.6.8
-Requires-Dist: psutil
 Requires-Dist: vcorelib>=3.3.1
 Provides-Extra: test
 Requires-Dist: pylint; extra == "test"
@@ -44,11 +44,11 @@ Requires-Dist: uvloop; (sys_platform != "win32" and sys_platform != "cygwin") an
     =====================================
     generator=datazen
     version=3.1.4
-    hash=5c5edaf1332d842e9ca04a018455beba
+    hash=cd04f0ce079f8c60bc93c7f1d098316b
     =====================================
 -->
 
-# runtimepy ([5.5.0](https://pypi.org/project/runtimepy/))
+# runtimepy ([5.6.0](https://pypi.org/project/runtimepy/))
 
 [![python](https://img.shields.io/pypi/pyversions/runtimepy.svg)](https://pypi.org/project/runtimepy/)
 ![Build Status](https://github.com/vkottler/runtimepy/workflows/Python%20Package/badge.svg)

{runtimepy-5.5.0 → runtimepy-5.6.0}/runtimepy.egg-info/SOURCES.txt

@@ -134,6 +134,7 @@ runtimepy/net/connection.py
 runtimepy/net/manager.py
 runtimepy/net/mixin.py
 runtimepy/net/mtu.py
+runtimepy/net/ssl.py
 runtimepy/net/util.py
 runtimepy/net/apps/__init__.py
 runtimepy/net/arbiter/__init__.py