Refactor server app and config

Author: davegaeddert

plain/plain/server/__init__.py

@@ -4,11 +4,6 @@
 #
 # Vendored and modified for Plain.
 
-import plain.runtime
+from .app import ServerApplication
 
-from .core import PlainServerApp, run_server
-
-SERVER = "plain"
-SERVER_SOFTWARE = f"{SERVER}/{plain.runtime.__version__}"
-
-__all__ = ["run_server", "PlainServerApp", "SERVER_SOFTWARE"]
+__all__ = ["ServerApplication"]

plain/plain/server/app.py

@@ -7,64 +7,43 @@
 
 from __future__ import annotations
 
-import argparse
 import sys
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from .arbiter import Arbiter
-from .config import Config
 
+if TYPE_CHECKING:
+    from .config import Config
 
-class BaseApplication:
+
+class ServerApplication:
     """
-    An application interface for configuring and loading
-    the various necessities for any given web framework.
+    Plain's server application.
+
+    This class provides the interface for running the WSGI server.
     """
 
-    def __init__(self, usage: str | None = None, prog: str | None = None) -> None:
-        self.usage: str | None = usage
-        self.cfg: Config | None = None
+    def __init__(self, cfg: Config) -> None:
+        self.cfg: Config = cfg
         self.callable: Any = None
-        self.prog: str | None = prog
-        self.logger: Any = None
-        self.do_load_config()
-
-    def do_load_config(self) -> None:
-        """
-        Loads the configuration
-        """
-        try:
-            self.load_config()
-        except Exception as e:
-            print(f"\nError: {str(e)}", file=sys.stderr)
-            sys.stderr.flush()
-            sys.exit(1)
-
-    def init(
-        self, parser: argparse.ArgumentParser, opts: argparse.Namespace, args: list[str]
-    ) -> None:
-        raise NotImplementedError
 
     def load(self) -> Any:
-        raise NotImplementedError
+        """Load the WSGI application."""
+        # Import locally to avoid circular dependencies and allow
+        # the WSGI module to handle Plain runtime setup
+        from plain.wsgi import app
 
-    def load_config(self) -> None:
-        """
-        This method is used to load the configuration from one or several input(s).
-        Custom Command line, configuration file.
-        You have to override this method in your class.
-        """
-        raise NotImplementedError
-
-    def reload(self) -> None:
-        self.do_load_config()
+        return app
 
     def wsgi(self) -> Any:
+        """Get the WSGI application."""
         if self.callable is None:
             self.callable = self.load()
         return self.callable
 
     def run(self) -> None:
+        """Run the server."""
+
         try:
             Arbiter(self).run()
         except RuntimeError as e:

plain/plain/server/arbiter.py

@@ -25,7 +25,7 @@
 from .pidfile import Pidfile
 
 if TYPE_CHECKING:
-    from .app import BaseApplication
+    from .app import ServerApplication
     from .config import Config
     from .glogging import Logger
     from .workers.base import Worker
@@ -64,7 +64,7 @@ class Arbiter:
         if name[:3] == "SIG" and name[3] != "_"
     }
 
-    def __init__(self, app: BaseApplication):
+    def __init__(self, app: ServerApplication):
         os.environ["SERVER_SOFTWARE"] = f"plain/{plain.runtime.__version__}"
 
         self._num_workers: int | None = None
@@ -92,8 +92,8 @@ def _set_num_workers(self, value: int) -> None:
 
     num_workers = property(_get_num_workers, _set_num_workers)
 
-    def setup(self, app: BaseApplication) -> None:
-        self.app: BaseApplication = app
+    def setup(self, app: ServerApplication) -> None:
+        self.app: ServerApplication = app
         assert app.cfg is not None, "Application config must be initialized"
         self.cfg: Config = app.cfg
 
@@ -332,8 +332,6 @@ def stop(self, graceful: bool = True) -> None:
     def reload(self) -> None:
         old_address = self.cfg.address
 
-        # reload conf
-        self.app.reload()
         self.setup(self.app)
 
         # reopen log files

plain/plain/server/config.py

@@ -7,36 +7,35 @@
 #
 # Vendored and modified for Plain.
 import os
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 
 from . import util
 
 
 @dataclass
 class Config:
-    """Plain server configuration."""
+    """Plain server configuration.
+
+    All configuration values are required and provided by the CLI.
+    Defaults are defined in the CLI layer, not here.
+    """
 
     # Core settings (from CLI)
-    bind: list[str] = field(default_factory=lambda: ["127.0.0.1:8000"])
-    workers: int = 1
-    threads: int = 1
-    timeout: int = 30
-    max_requests: int = 0
-    reload: bool = False
-    reload_extra_files: list[str] = field(default_factory=list)
-    pidfile: str | None = None
-    certfile: str | None = None
-    keyfile: str | None = None
-    loglevel: str = "info"
-    accesslog: str | None = None
-    errorlog: str = "-"
-    access_log_format: str = (
-        '%(h)s %(l)s %(u)s %(t)s "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s"'
-    )
-    logconfig_json: str | None = None
-
-    # Internal
-    env_orig: dict[str, str] = field(default_factory=lambda: os.environ.copy())
+    bind: list[str]
+    workers: int
+    threads: int
+    timeout: int
+    max_requests: int
+    reload: bool
+    reload_extra_files: list[str]
+    pidfile: str | None
+    certfile: str | None
+    keyfile: str | None
+    loglevel: str
+    accesslog: str
+    errorlog: str
+    access_log_format: str
+    logconfig_json: str | None
 
     @property
     def worker_class_str(self) -> str:

plain/plain/server/http/wsgi.py

@@ -15,7 +15,9 @@
 from collections.abc import Callable, Iterator
 from typing import TYPE_CHECKING, Any, cast
 
-from .. import SERVER_SOFTWARE, util
+import plain.runtime
+
+from .. import util
 from .errors import ConfigurationProblem, InvalidHeader, InvalidHeaderName
 from .message import TOKEN_RE
 
@@ -86,7 +88,7 @@ def base_environ(cfg: Config) -> dict[str, Any]:
         "wsgi.run_once": False,
         "wsgi.file_wrapper": FileWrapper,
         "wsgi.input_terminated": True,
-        "SERVER_SOFTWARE": SERVER_SOFTWARE,
+        "SERVER_SOFTWARE": f"plain/{plain.runtime.__version__}",
     }
 
 

plain/plain/server/util.py

@@ -6,15 +6,13 @@
 # See the LICENSE for more information.
 #
 # Vendored and modified for Plain.
-import ast
 import email.utils
 import errno
 import fcntl
 import html
 import importlib
 import inspect
 import io
-import logging
 import os
 import random
 import re
@@ -28,7 +26,6 @@
 from collections.abc import Callable
 from typing import Any
 
-from .errors import AppImportError
 from .workers import SUPPORTED_WORKERS
 
 # Server and Date aren't technically hop-by-hop
@@ -256,115 +253,6 @@ def write_error(sock: socket.socket, status_int: int, reason: str, mesg: str) ->
     write_nonblock(sock, http.encode("latin1"))
 
 
-def _called_with_wrong_args(f: Any) -> bool:
-    """Check whether calling a function raised a ``TypeError`` because
-    the call failed or because something in the function raised the
-    error.
-
-    :param f: The function that was called.
-    :return: ``True`` if the call failed.
-    """
-    tb = sys.exc_info()[2]
-
-    try:
-        while tb is not None:
-            if tb.tb_frame.f_code is f.__code__:
-                # In the function, it was called successfully.
-                return False
-
-            tb = tb.tb_next
-
-        # Didn't reach the function.
-        return True
-    finally:
-        # Delete tb to break a circular reference in Python 2.
-        # https://docs.python.org/2/library/sys.html#sys.exc_info
-        del tb
-
-
-def import_app(module: str) -> Callable[..., Any]:
-    parts = module.split(":", 1)
-    if len(parts) == 1:
-        obj = "application"
-    else:
-        module, obj = parts[0], parts[1]
-
-    try:
-        mod = importlib.import_module(module)
-    except ImportError:
-        if module.endswith(".py") and os.path.exists(module):
-            msg = "Failed to find application, did you mean '%s:%s'?"
-            raise ImportError(msg % (module.rsplit(".", 1)[0], obj))
-        raise
-
-    # Parse obj as a single expression to determine if it's a valid
-    # attribute name or function call.
-    try:
-        expression = ast.parse(obj, mode="eval").body
-    except SyntaxError:
-        raise AppImportError(
-            f"Failed to parse {obj!r} as an attribute name or function call."
-        )
-
-    if isinstance(expression, ast.Name):
-        name = expression.id
-        args = kwargs = None
-    elif isinstance(expression, ast.Call):
-        # Ensure the function name is an attribute name only.
-        if not isinstance(expression.func, ast.Name):
-            raise AppImportError(f"Function reference must be a simple name: {obj!r}")
-
-        name = expression.func.id
-
-        # Parse the positional and keyword arguments as literals.
-        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:
-            # literal_eval gives cryptic error messages, show a generic
-            # message with the full expression instead.
-            raise AppImportError(
-                f"Failed to parse arguments as literal values: {obj!r}"
-            )
-    else:
-        raise AppImportError(
-            f"Failed to parse {obj!r} as an attribute name or function call."
-        )
-
-    is_debug = logging.root.level == logging.DEBUG
-    try:
-        app = getattr(mod, name)
-    except AttributeError:
-        if is_debug:
-            traceback.print_exception(*sys.exc_info())
-        raise AppImportError(f"Failed to find attribute {name!r} in {module!r}.")
-
-    # If the expression was a function call, call the retrieved object
-    # to get the real application.
-    if args is not None:
-        try:
-            app = app(*args, **kwargs)
-        except TypeError as e:
-            # If the TypeError was due to bad arguments to the factory
-            # function, show Python's nice error message without a
-            # traceback.
-            if _called_with_wrong_args(app):
-                raise AppImportError(
-                    "".join(traceback.format_exception_only(TypeError, e)).strip()
-                )
-
-            # Otherwise it was raised from within the function, show the
-            # full traceback.
-            raise
-
-    if app is None:
-        raise AppImportError(f"Failed to find application object: {obj!r}")
-
-    if not callable(app):
-        raise AppImportError("Application object must be callable.")
-    return app
-
-
 def getcwd() -> str:
     # get current path, try to use PWD env first
     try:

plain/plain/server/workers/base.py

@@ -38,7 +38,7 @@
 if TYPE_CHECKING:
     import socket
 
-    from ..app import BaseApplication
+    from ..app import ServerApplication
     from ..config import Config
     from ..glogging import Logger
     from ..http.message import Request
@@ -60,7 +60,7 @@ def __init__(
         age: int,
         ppid: int,
         sockets: list[socket.socket],
-        app: BaseApplication,
+        app: ServerApplication,
         timeout: int,
         cfg: Config,
         log: Logger,