plain 0.66.0__py3-none-any.whl → 0.101.2__py3-none-any.whl

plain/server/workers/base.py

@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+#
+#
+# This file is part of gunicorn released under the MIT license.
+# See the LICENSE for more information.
+#
+# Vendored and modified for Plain.
+import io
+import os
+import signal
+import sys
+import time
+import traceback
+from abc import ABC, abstractmethod
+from datetime import datetime
+from random import randint
+from ssl import SSLError
+from typing import TYPE_CHECKING, Any
+
+from plain.internal.reloader import Reloader
+
+from .. import sock, util
+from ..http.errors import (
+    ConfigurationProblem,
+    InvalidHeader,
+    InvalidHeaderName,
+    InvalidHTTPVersion,
+    InvalidRequestLine,
+    InvalidRequestMethod,
+    InvalidSchemeHeaders,
+    LimitRequestHeaders,
+    LimitRequestLine,
+    ObsoleteFolding,
+    UnsupportedTransferCoding,
+)
+from ..http.wsgi import Response, default_environ
+from .workertmp import WorkerTmp
+
+if TYPE_CHECKING:
+    import socket
+
+    from ..app import ServerApplication
+    from ..config import Config
+    from ..glogging import Logger
+    from ..http.message import Request
+
+# Maximum jitter to add to max_requests to stagger worker restarts
+MAX_REQUESTS_JITTER = 50
+
+
+class Worker(ABC):
+    SIGNALS = [
+        getattr(signal, f"SIG{x}")
+        for x in ("ABRT HUP QUIT INT TERM USR1 USR2 WINCH CHLD".split())
+    ]
+
+    PIPE = []
+
+    def __init__(
+        self,
+        age: int,
+        ppid: int,
+        sockets: list[sock.BaseSocket],
+        app: ServerApplication,
+        timeout: int | float,
+        cfg: Config,
+        log: Logger,
+    ):
+        """\
+        This is called pre-fork so it shouldn't do anything to the
+        current process. If there's a need to make process wide
+        changes you'll want to do that in ``self.init_process()``.
+        """
+        self.age = age
+        self.pid: str | int = "[booting]"
+        self.ppid = ppid
+        self.sockets = sockets
+        self.app = app
+        self.timeout = timeout
+        self.cfg = cfg
+        self.booted = False
+        self.aborted = False
+        self.reloader: Any = None
+
+        self.nr = 0
+
+        if cfg.max_requests > 0:
+            jitter = randint(0, MAX_REQUESTS_JITTER)
+            self.max_requests = cfg.max_requests + jitter
+        else:
+            self.max_requests = sys.maxsize
+
+        self.alive = True
+        self.log = log
+        self.tmp = WorkerTmp(cfg)
+
+    def __str__(self) -> str:
+        return f"<Worker {self.pid}>"
+
+    def notify(self) -> None:
+        """\
+        Your worker subclass must arrange to have this method called
+        once every ``self.timeout`` seconds. If you fail in accomplishing
+        this task, the master process will murder your workers.
+        """
+        self.tmp.notify()
+
+    @abstractmethod
+    def run(self) -> None:
+        """\
+        This is the mainloop of a worker process. You should override
+        this method in a subclass to provide the intended behaviour
+        for your particular evil schemes.
+        """
+        ...
+
+    def init_process(self) -> None:
+        """\
+        If you override this method in a subclass, the last statement
+        in the function should be to call this method with
+        super().init_process() so that the ``run()`` loop is initiated.
+        """
+
+        # Reseed the random number generator
+        util.seed()
+
+        # For waking ourselves up
+        self.PIPE = os.pipe()
+        for p in self.PIPE:
+            util.set_non_blocking(p)
+            util.close_on_exec(p)
+
+        # Prevent fd inheritance
+        for s in self.sockets:
+            util.close_on_exec(s.fileno())
+        util.close_on_exec(self.tmp.fileno())
+
+        self.wait_fds: list[sock.BaseSocket | int] = self.sockets + [self.PIPE[0]]
+
+        self.log.close_on_exec()
+
+        self.init_signals()
+
+        # start the reloader
+        if self.cfg.reload:
+
+            def changed(fname: str) -> None:
+                self.log.debug("Server worker reloading: %s modified", fname)
+                self.alive = False
+                os.write(self.PIPE[1], b"1")
+                time.sleep(0.1)
+                sys.exit(0)
+
+            self.reloader = Reloader(callback=changed, watch_html=True)
+
+        self.load_wsgi()
+        if self.reloader:
+            self.reloader.start()
+
+        # Enter main run loop
+        self.booted = True
+        self.run()
+
+    def load_wsgi(self) -> None:
+        try:
+            self.wsgi = self.app.wsgi()
+        except SyntaxError:
+            if not self.cfg.reload:
+                raise
+
+            self.log.exception("Error loading WSGI application")
+
+            # fix from PR #1228
+            # storing the traceback into exc_tb will create a circular reference.
+            # per https://docs.python.org/2/library/sys.html#sys.exc_info warning,
+            # delete the traceback after use.
+            try:
+                _, exc_val, exc_tb = sys.exc_info()
+
+                tb_string = io.StringIO()
+                traceback.print_tb(exc_tb, file=tb_string)
+                self.wsgi = util.make_fail_app(tb_string.getvalue())
+            finally:
+                del exc_tb
+
+    def init_signals(self) -> None:
+        # reset signaling
+        for s in self.SIGNALS:
+            signal.signal(s, signal.SIG_DFL)
+        # init new signaling
+        signal.signal(signal.SIGQUIT, self.handle_quit)
+        signal.signal(signal.SIGTERM, self.handle_exit)
+        signal.signal(signal.SIGINT, self.handle_quit)
+        signal.signal(signal.SIGWINCH, self.handle_winch)
+        signal.signal(signal.SIGUSR1, self.handle_usr1)
+        signal.signal(signal.SIGABRT, self.handle_abort)
+
+        # Don't let SIGTERM and SIGUSR1 disturb active requests
+        # by interrupting system calls
+        signal.siginterrupt(signal.SIGTERM, False)
+        signal.siginterrupt(signal.SIGUSR1, False)
+
+        if hasattr(signal, "set_wakeup_fd"):
+            signal.set_wakeup_fd(self.PIPE[1])
+
+    def handle_usr1(self, sig: int, frame: Any) -> None:
+        self.log.reopen_files()
+
+    def handle_exit(self, sig: int, frame: Any) -> None:
+        self.alive = False
+
+    def handle_quit(self, sig: int, frame: Any) -> None:
+        self.alive = False
+        time.sleep(0.1)
+        sys.exit(0)
+
+    def handle_abort(self, sig: int, frame: Any) -> None:
+        self.alive = False
+        sys.exit(1)
+
+    def handle_error(
+        self, req: Request | None, client: socket.socket, addr: Any, exc: BaseException
+    ) -> None:
+        request_start = datetime.now()
+        addr = addr or ("", -1)  # unix socket case
+        if isinstance(
+            exc,
+            InvalidRequestLine
+            | InvalidRequestMethod
+            | InvalidHTTPVersion
+            | InvalidHeader
+            | InvalidHeaderName
+            | LimitRequestLine
+            | LimitRequestHeaders
+            | InvalidSchemeHeaders
+            | UnsupportedTransferCoding
+            | ConfigurationProblem
+            | ObsoleteFolding
+            | SSLError,
+        ):
+            status_int = 400
+            reason = "Bad Request"
+
+            if isinstance(exc, InvalidRequestLine):
+                mesg = f"Invalid Request Line '{str(exc)}'"
+            elif isinstance(exc, InvalidRequestMethod):
+                mesg = f"Invalid Method '{str(exc)}'"
+            elif isinstance(exc, InvalidHTTPVersion):
+                mesg = f"Invalid HTTP Version '{str(exc)}'"
+            elif isinstance(exc, UnsupportedTransferCoding):
+                mesg = f"{str(exc)}"
+                status_int = 501
+            elif isinstance(exc, ConfigurationProblem):
+                mesg = f"{str(exc)}"
+                status_int = 500
+            elif isinstance(exc, ObsoleteFolding):
+                mesg = f"{str(exc)}"
+            elif isinstance(exc, InvalidHeaderName | InvalidHeader):
+                mesg = f"{str(exc)}"
+                if not req and hasattr(exc, "req"):
+                    req = exc.req  # type: ignore[assignment]  # for access log
+            elif isinstance(exc, LimitRequestLine):
+                mesg = f"{str(exc)}"
+            elif isinstance(exc, LimitRequestHeaders):
+                reason = "Request Header Fields Too Large"
+                mesg = f"Error parsing headers: '{str(exc)}'"
+                status_int = 431
+            elif isinstance(exc, InvalidSchemeHeaders):
+                mesg = f"{str(exc)}"
+            elif isinstance(exc, SSLError):
+                reason = "Forbidden"
+                mesg = f"'{str(exc)}'"
+                status_int = 403
+
+            msg = "Invalid request from ip={ip}: {error}"
+            self.log.warning(msg.format(ip=addr[0], error=str(exc)))
+        else:
+            if hasattr(req, "uri"):
+                self.log.exception("Error handling request %s", req.uri)
+            else:
+                self.log.exception("Error handling request (no URI read)")
+            status_int = 500
+            reason = "Internal Server Error"
+            mesg = ""
+
+        if req is not None:
+            request_time = datetime.now() - request_start
+            environ = default_environ(req, client, self.cfg)
+            environ["REMOTE_ADDR"] = addr[0]
+            environ["REMOTE_PORT"] = str(addr[1])
+            resp = Response(req, client, self.cfg)
+            resp.status = f"{status_int} {reason}"
+            resp.response_length = len(mesg)
+            self.log.access(resp, req, environ, request_time)
+
+        try:
+            util.write_error(client, status_int, reason, mesg)
+        except Exception:
+            self.log.debug("Failed to send error message.")
+
+    def handle_winch(self, sig: int, fname: Any) -> None:
+        # Ignore SIGWINCH in worker. Fixes a crash on OpenBSD.
+        self.log.debug("worker: SIGWINCH ignored.")

plain/server/workers/sync.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+#
+#
+# This file is part of gunicorn released under the MIT license.
+# See the LICENSE for more information.
+#
+# Vendored and modified for Plain.
+import errno
+import os
+import select
+import socket
+import ssl
+import sys
+from datetime import datetime
+from typing import Any
+
+from .. import http, sock, util
+from ..http import wsgi
+from . import base
+
+
+class StopWaiting(Exception):
+    """exception raised to stop waiting for a connection"""
+
+
+class SyncWorker(base.Worker):
+    def accept(self, listener: sock.BaseSocket) -> None:
+        client, addr = listener.accept()
+        client.setblocking(True)
+        util.close_on_exec(client.fileno())
+        self.handle(listener, client, addr)
+
+    def wait(self, timeout: float) -> list[Any] | None:
+        try:
+            self.notify()
+            ret = select.select(self.wait_fds, [], [], timeout)
+            if ret[0]:
+                if self.PIPE[0] in ret[0]:
+                    os.read(self.PIPE[0], 1)
+                return ret[0]
+            return None
+
+        except OSError as e:
+            if e.args[0] == errno.EINTR:
+                return self.sockets
+            if e.args[0] == errno.EBADF:
+                if self.nr < 0:
+                    return self.sockets
+                else:
+                    raise StopWaiting
+            raise
+
+    def is_parent_alive(self) -> bool:
+        # If our parent changed then we shut down.
+        if self.ppid != os.getppid():
+            self.log.info("Parent changed, shutting down: %s", self)
+            return False
+        return True
+
+    def run_for_one(self, timeout: float) -> None:
+        listener = self.sockets[0]
+        while self.alive:
+            self.notify()
+
+            # Accept a connection. If we get an error telling us
+            # that no connection is waiting we fall down to the
+            # select which is where we'll wait for a bit for new
+            # workers to come give us some love.
+            try:
+                self.accept(listener)
+                # Keep processing clients until no one is waiting. This
+                # prevents the need to select() for every client that we
+                # process.
+                continue
+
+            except OSError as e:
+                if e.errno not in (errno.EAGAIN, errno.ECONNABORTED, errno.EWOULDBLOCK):
+                    raise
+
+            if not self.is_parent_alive():
+                return None
+
+            try:
+                self.wait(timeout)
+            except StopWaiting:
+                return None
+
+    def run_for_multiple(self, timeout: float) -> None:
+        while self.alive:
+            self.notify()
+
+            try:
+                ready = self.wait(timeout)
+            except StopWaiting:
+                return None
+
+            if ready is not None:
+                for listener in ready:
+                    if listener == self.PIPE[0]:
+                        continue
+
+                    try:
+                        self.accept(listener)
+                    except OSError as e:
+                        if e.errno not in (
+                            errno.EAGAIN,
+                            errno.ECONNABORTED,
+                            errno.EWOULDBLOCK,
+                        ):
+                            raise
+
+            if not self.is_parent_alive():
+                return None
+
+    def run(self) -> None:
+        # if no timeout is given the worker will never wait and will
+        # use the CPU for nothing. This minimal timeout prevent it.
+        timeout = self.timeout or 0.5
+
+        # self.socket appears to lose its blocking status after
+        # we fork in the arbiter. Reset it here.
+        for s in self.sockets:
+            s.setblocking(False)
+
+        if len(self.sockets) > 1:
+            self.run_for_multiple(timeout)
+        else:
+            self.run_for_one(timeout)
+
+    def handle(
+        self, listener: sock.BaseSocket, client: socket.socket, addr: Any
+    ) -> None:
+        req = None
+        try:
+            if self.cfg.is_ssl:
+                client = sock.ssl_wrap_socket(client, self.cfg)
+            parser = http.RequestParser(self.cfg, client, addr)
+            req = next(parser)
+            self.handle_request(listener, req, client, addr)
+        except http.errors.NoMoreData as e:
+            self.log.debug("Ignored premature client disconnection. %s", e)
+        except StopIteration as e:
+            self.log.debug("Closing connection. %s", e)
+        except ssl.SSLError as e:
+            if e.args[0] == ssl.SSL_ERROR_EOF:
+                self.log.debug("ssl connection closed")
+                client.close()
+            else:
+                self.log.debug("Error processing SSL request.")
+                self.handle_error(req, client, addr, e)
+        except OSError as e:
+            if e.errno not in (errno.EPIPE, errno.ECONNRESET, errno.ENOTCONN):
+                self.log.exception("Socket error processing request.")
+            else:
+                if e.errno == errno.ECONNRESET:
+                    self.log.debug("Ignoring connection reset")
+                elif e.errno == errno.ENOTCONN:
+                    self.log.debug("Ignoring socket not connected")
+                else:
+                    self.log.debug("Ignoring EPIPE")
+        except BaseException as e:
+            self.handle_error(req, client, addr, e)
+        finally:
+            util.close(client)
+
+    def handle_request(
+        self, listener: sock.BaseSocket, req: Any, client: socket.socket, addr: Any
+    ) -> None:
+        environ = {}
+        resp = None
+        try:
+            request_start = datetime.now()
+            resp, environ = wsgi.create(
+                req, client, addr, listener.getsockname(), self.cfg
+            )
+            # Force the connection closed until someone shows
+            # a buffering proxy that supports Keep-Alive to
+            # the backend.
+            resp.force_close()
+            self.nr += 1
+            if self.nr >= self.max_requests:
+                self.log.info("Autorestarting worker after current request.")
+                self.alive = False
+            respiter = self.wsgi(environ, resp.start_response)
+            try:
+                if isinstance(respiter, environ["wsgi.file_wrapper"]):
+                    resp.write_file(respiter)
+                else:
+                    for item in respiter:
+                        resp.write(item)
+                resp.close()
+            finally:
+                request_time = datetime.now() - request_start
+                self.log.access(resp, req, environ, request_time)
+                if hasattr(respiter, "close"):
+                    respiter.close()
+        except OSError:
+            # pass to next try-except level
+            util.reraise(*sys.exc_info())
+        except Exception:
+            if resp and resp.headers_sent:
+                # If the requests have already been sent, we should close the
+                # connection to indicate the error.
+                self.log.exception("Error handling request")
+                try:
+                    client.shutdown(socket.SHUT_RDWR)
+                    client.close()
+                except OSError:
+                    pass
+                raise StopIteration()
+            raise