plain 0.74.0__py3-none-any.whl → 0.76.0__py3-none-any.whl

plain/server/http/wsgi.py

@@ -0,0 +1,421 @@
+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 logging
+import os
+import re
+import socket
+import sys
+from collections.abc import Callable, Iterator
+from typing import TYPE_CHECKING, Any, cast
+
+import plain.runtime
+
+from .. import util
+from .errors import ConfigurationProblem, InvalidHeader, InvalidHeaderName
+from .message import TOKEN_RE
+
+if TYPE_CHECKING:
+    from ..config import Config
+    from .message import Request
+
+# Send files in at most 1GB blocks as some operating systems can have problems
+# with sending files in blocks over 2GB.
+BLKSIZE = 0x3FFFFFFF
+
+# RFC9110 5.5: field-vchar = VCHAR / obs-text
+# RFC4234 B.1: VCHAR = 0x21-x07E = printable ASCII
+HEADER_VALUE_RE = re.compile(r"[ \t\x21-\x7e\x80-\xff]*")
+
+log = logging.getLogger(__name__)
+
+
+class FileWrapper:
+    def __init__(self, filelike: Any, blksize: int = 8192) -> None:
+        self.filelike = filelike
+        self.blksize = blksize
+        if hasattr(filelike, "close"):
+            self.close = filelike.close
+
+    def __getitem__(self, key: int) -> bytes:
+        data = self.filelike.read(self.blksize)
+        if data:
+            return data
+        raise IndexError
+
+
+class WSGIErrorsWrapper(io.RawIOBase):
+    def __init__(self, cfg: Config) -> None:
+        # There is no public __init__ method for RawIOBase so
+        # we don't need to call super() in the __init__ method.
+        # pylint: disable=super-init-not-called
+        errorlog = logging.getLogger("plain.server.error")
+        handlers = errorlog.handlers
+        self.streams: list[Any] = []
+
+        if cfg.errorlog == "-":
+            self.streams.append(sys.stderr)
+            handlers = handlers[1:]
+
+        for h in handlers:
+            if hasattr(h, "stream"):
+                self.streams.append(h.stream)
+
+    def write(self, data: str | bytes) -> None:
+        for stream in self.streams:
+            try:
+                stream.write(data)
+            except UnicodeError:
+                if isinstance(data, str):
+                    stream.write(data.encode("UTF-8"))
+                else:
+                    stream.write(data)
+            stream.flush()
+
+
+def base_environ(cfg: Config) -> dict[str, Any]:
+    return {
+        "wsgi.errors": WSGIErrorsWrapper(cfg),
+        "wsgi.version": (1, 0),
+        "wsgi.multithread": False,
+        "wsgi.multiprocess": (cfg.workers > 1),
+        "wsgi.run_once": False,
+        "wsgi.file_wrapper": FileWrapper,
+        "wsgi.input_terminated": True,
+        "SERVER_SOFTWARE": f"plain/{plain.runtime.__version__}",
+    }
+
+
+def default_environ(req: Request, sock: socket.socket, cfg: Config) -> dict[str, Any]:
+    env = base_environ(cfg)
+    env.update(
+        {
+            "wsgi.input": req.body,
+            "plain.server.socket": sock,
+            "REQUEST_METHOD": req.method,
+            "QUERY_STRING": req.query,
+            "RAW_URI": req.uri,
+            "SERVER_PROTOCOL": "HTTP/{}".format(
+                ".".join([str(v) for v in req.version])
+            ),
+        }
+    )
+    return env
+
+
+def create(
+    req: Request,
+    sock: socket.socket,
+    client: str | bytes | tuple[str, int],
+    server: str | tuple[str, int],
+    cfg: Config,
+) -> tuple[Response, dict[str, Any]]:
+    resp = Response(req, sock, cfg)
+
+    # set initial environ
+    environ = default_environ(req, sock, cfg)
+
+    # default variables
+    host = None
+    script_name = os.environ.get("SCRIPT_NAME", "")
+
+    # add the headers to the environ
+    for hdr_name, hdr_value in req.headers:
+        if hdr_name == "EXPECT":
+            # handle expect
+            if hdr_value.lower() == "100-continue":
+                sock.send(b"HTTP/1.1 100 Continue\r\n\r\n")
+        elif hdr_name == "HOST":
+            host = hdr_value
+        elif hdr_name == "SCRIPT_NAME":
+            script_name = hdr_value
+        elif hdr_name == "CONTENT-TYPE":
+            environ["CONTENT_TYPE"] = hdr_value
+            continue
+        elif hdr_name == "CONTENT-LENGTH":
+            environ["CONTENT_LENGTH"] = hdr_value
+            continue
+
+        # do not change lightly, this is a common source of security problems
+        # RFC9110 Section 17.10 discourages ambiguous or incomplete mappings
+        key = "HTTP_" + hdr_name.replace("-", "_")
+        if key in environ:
+            hdr_value = f"{environ[key]},{hdr_value}"
+        environ[key] = hdr_value
+
+    # set the url scheme
+    environ["wsgi.url_scheme"] = req.scheme
+
+    # set the REMOTE_* keys in environ
+    # authors should be aware that REMOTE_HOST and REMOTE_ADDR
+    # may not qualify the remote addr:
+    # http://www.ietf.org/rfc/rfc3875
+    if isinstance(client, str):
+        environ["REMOTE_ADDR"] = client
+    elif isinstance(client, bytes):
+        environ["REMOTE_ADDR"] = client.decode()
+    else:
+        environ["REMOTE_ADDR"] = client[0]
+        environ["REMOTE_PORT"] = str(client[1])
+
+    # handle the SERVER_*
+    # Normally only the application should use the Host header but since the
+    # WSGI spec doesn't support unix sockets, we are using it to create
+    # viable SERVER_* if possible.
+    server_parts: list[str | int]
+    if isinstance(server, str):
+        server_parts = cast(list[str | int], server.split(":"))
+        if len(server_parts) == 1:
+            # unix socket
+            if host:
+                server_parts = cast(list[str | int], host.split(":"))
+                if len(server_parts) == 1:
+                    if req.scheme == "http":
+                        server_parts.append(80)
+                    elif req.scheme == "https":
+                        server_parts.append(443)
+                    else:
+                        server_parts.append("")
+            else:
+                # no host header given which means that we are not behind a
+                # proxy, so append an empty port.
+                server_parts.append("")
+    else:
+        server_parts = list(server)
+    environ["SERVER_NAME"] = str(server_parts[0])
+    environ["SERVER_PORT"] = str(server_parts[1])
+
+    # set the path and script name
+    path_info: str = req.path or ""
+    if script_name:
+        if not path_info.startswith(script_name):
+            raise ConfigurationProblem(
+                f"Request path {path_info!r} does not start with SCRIPT_NAME {script_name!r}"
+            )
+        path_info = path_info[len(script_name) :]
+    environ["PATH_INFO"] = util.unquote_to_wsgi_str(path_info)
+    environ["SCRIPT_NAME"] = script_name
+
+    return resp, environ
+
+
+class Response:
+    def __init__(self, req: Request, sock: socket.socket, cfg: Config) -> None:
+        self.req = req
+        self.sock = sock
+        self.version = "plain"
+        self.status: str | None = None
+        self.chunked = False
+        self.must_close = False
+        self.headers: list[tuple[str, str]] = []
+        self.headers_sent = False
+        self.response_length: int | None = None
+        self.sent = 0
+        self.upgrade = False
+        self.cfg = cfg
+        self.status_code: int | None = None
+
+    def force_close(self) -> None:
+        self.must_close = True
+
+    def should_close(self) -> bool:
+        if self.must_close or self.req.should_close():
+            return True
+        if self.response_length is not None or self.chunked:
+            return False
+        if self.req.method == "HEAD":
+            return False
+        if self.status_code is not None and (
+            self.status_code < 200 or self.status_code in (204, 304)
+        ):
+            return False
+        return True
+
+    def start_response(
+        self,
+        status: str,
+        headers: list[tuple[str, str]],
+        exc_info: tuple[type[BaseException], BaseException, Any] | None = None,
+    ) -> Callable[[bytes], None]:
+        if exc_info:
+            try:
+                if self.status and self.headers_sent:
+                    util.reraise(exc_info[0], exc_info[1], exc_info[2])
+            finally:
+                exc_info = None
+        elif self.status is not None:
+            raise AssertionError("Response headers already set!")
+
+        self.status = status
+
+        # get the status code from the response here so we can use it to check
+        # the need for the connection header later without parsing the string
+        # each time.
+        try:
+            self.status_code = int(self.status.split()[0])
+        except ValueError:
+            self.status_code = None
+
+        self.process_headers(headers)
+        self.chunked = self.is_chunked()
+        return self.write
+
+    def process_headers(self, headers: list[tuple[str, str]]) -> None:
+        for name, value in headers:
+            if not isinstance(name, str):
+                raise TypeError(f"{name!r} is not a string")
+
+            if not TOKEN_RE.fullmatch(name):
+                raise InvalidHeaderName(f"{name!r}")
+
+            if not isinstance(value, str):
+                raise TypeError(f"{value!r} is not a string")
+
+            if not HEADER_VALUE_RE.fullmatch(value):
+                raise InvalidHeader(f"{value!r}")
+
+            # RFC9110 5.5
+            value = value.strip(" \t")
+            lname = name.lower()
+            if lname == "content-length":
+                self.response_length = int(value)
+            elif util.is_hoppish(name):
+                if lname == "connection":
+                    # handle websocket
+                    if value.lower() == "upgrade":
+                        self.upgrade = True
+                elif lname == "upgrade":
+                    if value.lower() == "websocket":
+                        self.headers.append((name, value))
+
+                # ignore hopbyhop headers
+                continue
+            self.headers.append((name, value))
+
+    def is_chunked(self) -> bool:
+        # Only use chunked responses when the client is
+        # speaking HTTP/1.1 or newer and there was
+        # no Content-Length header set.
+        if self.response_length is not None:
+            return False
+        elif self.req.version <= (1, 0):
+            return False
+        elif self.req.method == "HEAD":
+            # Responses to a HEAD request MUST NOT contain a response body.
+            return False
+        elif self.status_code is not None and self.status_code in (204, 304):
+            # Do not use chunked responses when the response is guaranteed to
+            # not have a response body.
+            return False
+        return True
+
+    def default_headers(self) -> list[str]:
+        # set the connection header
+        if self.upgrade:
+            connection = "upgrade"
+        elif self.should_close():
+            connection = "close"
+        else:
+            connection = "keep-alive"
+
+        headers = [
+            f"HTTP/{self.req.version[0]}.{self.req.version[1]} {self.status}\r\n",
+            f"Server: {self.version}\r\n",
+            f"Date: {util.http_date()}\r\n",
+            f"Connection: {connection}\r\n",
+        ]
+        if self.chunked:
+            headers.append("Transfer-Encoding: chunked\r\n")
+        return headers
+
+    def send_headers(self) -> None:
+        if self.headers_sent:
+            return None
+        tosend = self.default_headers()
+        tosend.extend([f"{k}: {v}\r\n" for k, v in self.headers])
+
+        header_str = "{}\r\n".format("".join(tosend))
+        util.write(self.sock, util.to_bytestring(header_str, "latin-1"))
+        self.headers_sent = True
+        return None
+
+    def write(self, arg: bytes) -> None:
+        self.send_headers()
+        if not isinstance(arg, bytes):
+            raise TypeError(f"{arg!r} is not a byte")
+        arglen = len(arg)
+        tosend = arglen
+        if self.response_length is not None:
+            if self.sent >= self.response_length:
+                # Never write more than self.response_length bytes
+                return None
+
+            tosend = min(self.response_length - self.sent, tosend)
+            if tosend < arglen:
+                arg = arg[:tosend]
+
+        # Sending an empty chunk signals the end of the
+        # response and prematurely closes the response
+        if self.chunked and tosend == 0:
+            return None
+
+        self.sent += tosend
+        util.write(self.sock, arg, self.chunked)
+        return None
+
+    def can_sendfile(self) -> bool:
+        return self.cfg.sendfile is not False
+
+    def sendfile(self, respiter: FileWrapper) -> bool:
+        if self.cfg.is_ssl or not self.can_sendfile():
+            return False
+
+        if not util.has_fileno(respiter.filelike):
+            return False
+
+        fileno = respiter.filelike.fileno()
+        try:
+            offset = os.lseek(fileno, 0, os.SEEK_CUR)
+            if self.response_length is None:
+                filesize = os.fstat(fileno).st_size
+                nbytes = filesize - offset
+            else:
+                nbytes = self.response_length
+        except (OSError, io.UnsupportedOperation):
+            return False
+
+        self.send_headers()
+
+        if self.is_chunked():
+            chunk_size = f"{nbytes:X}\r\n"
+            self.sock.sendall(chunk_size.encode("utf-8"))
+        if nbytes > 0:
+            self.sock.sendfile(respiter.filelike, offset=offset, count=nbytes)
+
+        if self.is_chunked():
+            self.sock.sendall(b"\r\n")
+
+        os.lseek(fileno, offset, os.SEEK_SET)
+
+        return True
+
+    def write_file(self, respiter: FileWrapper | Iterator[bytes]) -> None:
+        if isinstance(respiter, FileWrapper):
+            if not self.sendfile(respiter):
+                for item in respiter:
+                    self.write(item)
+        else:
+            for item in respiter:
+                self.write(item)
+
+    def close(self) -> None:
+        if not self.headers_sent:
+            self.send_headers()
+        if self.chunked:
+            util.write_chunk(self.sock, b"")

plain/server/pidfile.py

@@ -0,0 +1,91 @@
+#
+#
+# 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 tempfile
+
+
+class Pidfile:
+    """\
+    Manage a PID file. If a specific name is provided
+    it and '"%s.oldpid" % name' will be used. Otherwise
+    we create a temp file using os.mkstemp.
+    """
+
+    def __init__(self, fname: str) -> None:
+        self.fname = fname
+        self.pid: int | None = None
+
+    def create(self, pid: int) -> None:
+        oldpid = self.validate()
+        if oldpid:
+            if oldpid == os.getpid():
+                return None
+            msg = "Already running on PID %s (or pid file '%s' is stale)"
+            raise RuntimeError(msg % (oldpid, self.fname))
+
+        self.pid = pid
+
+        # Write pidfile
+        fdir = os.path.dirname(self.fname)
+        if fdir and not os.path.isdir(fdir):
+            raise RuntimeError(f"{fdir} doesn't exist. Can't create pidfile.")
+        fd, fname = tempfile.mkstemp(dir=fdir)
+        os.write(fd, (f"{self.pid}\n").encode())
+        if self.fname:
+            os.rename(fname, self.fname)
+        else:
+            self.fname = fname
+        os.close(fd)
+
+        # set permissions to -rw-r--r--
+        os.chmod(self.fname, 420)
+        return None
+
+    def rename(self, path: str) -> None:
+        self.unlink()
+        self.fname = path
+        self.create(self.pid)  # type: ignore[arg-type]
+        return None
+
+    def unlink(self) -> None:
+        """delete pidfile"""
+        try:
+            with open(self.fname) as f:
+                pid1 = int(f.read() or 0)
+
+            if pid1 == self.pid:
+                os.unlink(self.fname)
+        except Exception:
+            pass
+        return None
+
+    def validate(self) -> int | None:
+        """Validate pidfile and make it stale if needed"""
+        if not self.fname:
+            return None
+        try:
+            with open(self.fname) as f:
+                try:
+                    wpid = int(f.read())
+                except ValueError:
+                    return None
+
+                try:
+                    os.kill(wpid, 0)
+                    return wpid
+                except OSError as e:
+                    if e.args[0] == errno.EPERM:
+                        return wpid
+                    if e.args[0] == errno.ESRCH:
+                        return None
+                    raise
+        except OSError as e:
+            if e.args[0] == errno.ENOENT:
+                return None
+            raise

plain/server/reloader.py

@@ -0,0 +1,158 @@
+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 os
+import os.path
+import re
+import sys
+import threading
+import time
+from collections.abc import Callable, Iterable
+
+COMPILED_EXT_RE = re.compile(r"py[co]$")
+
+
+class Reloader(threading.Thread):
+    def __init__(
+        self,
+        extra_files: Iterable[str] | None = None,
+        interval: int = 1,
+        callback: Callable[[str], None] | None = None,
+    ) -> None:
+        super().__init__()
+        self.daemon = True
+        self._extra_files: set[str] = set(extra_files or ())
+        self._interval = interval
+        self._callback = callback
+
+    def add_extra_file(self, filename: str) -> None:
+        self._extra_files.add(filename)
+
+    def get_files(self) -> list[str]:
+        fnames = [
+            COMPILED_EXT_RE.sub("py", module.__file__)  # type: ignore[arg-type]
+            for module in tuple(sys.modules.values())
+            if getattr(module, "__file__", None)
+        ]
+
+        fnames.extend(self._extra_files)
+
+        return fnames
+
+    def run(self) -> None:
+        mtimes: dict[str, float] = {}
+        while True:
+            for filename in self.get_files():
+                try:
+                    mtime = os.stat(filename).st_mtime
+                except OSError:
+                    continue
+                old_time = mtimes.get(filename)
+                if old_time is None:
+                    mtimes[filename] = mtime
+                    continue
+                elif mtime > old_time:
+                    if self._callback:
+                        self._callback(filename)
+            time.sleep(self._interval)
+
+
+has_inotify = False
+if sys.platform.startswith("linux"):
+    try:
+        import inotify.constants
+        from inotify.adapters import Inotify
+
+        has_inotify = True
+    except ImportError:
+        pass
+
+
+if has_inotify:
+
+    class InotifyReloader(threading.Thread):
+        event_mask = (
+            inotify.constants.IN_CREATE
+            | inotify.constants.IN_DELETE
+            | inotify.constants.IN_DELETE_SELF
+            | inotify.constants.IN_MODIFY
+            | inotify.constants.IN_MOVE_SELF
+            | inotify.constants.IN_MOVED_FROM
+            | inotify.constants.IN_MOVED_TO
+        )
+
+        def __init__(
+            self,
+            extra_files: Iterable[str] | None = None,
+            callback: Callable[[str], None] | None = None,
+        ) -> None:
+            super().__init__()
+            self.daemon = True
+            self._callback = callback
+            self._dirs: set[str] = set()
+            self._watcher = Inotify()
+
+            if extra_files:
+                for extra_file in extra_files:
+                    self.add_extra_file(extra_file)
+
+        def add_extra_file(self, filename: str) -> None:
+            dirname = os.path.dirname(filename)
+
+            if dirname in self._dirs:
+                return None
+
+            self._watcher.add_watch(dirname, mask=self.event_mask)
+            self._dirs.add(dirname)
+
+        def get_dirs(self) -> set[str]:
+            fnames = [
+                os.path.dirname(
+                    os.path.abspath(COMPILED_EXT_RE.sub("py", module.__file__))  # type: ignore[arg-type]
+                )
+                for module in tuple(sys.modules.values())
+                if getattr(module, "__file__", None)
+            ]
+
+            return set(fnames)
+
+        def run(self) -> None:
+            self._dirs = self.get_dirs()
+
+            for dirname in self._dirs:
+                if os.path.isdir(dirname):
+                    self._watcher.add_watch(dirname, mask=self.event_mask)
+
+            for event in self._watcher.event_gen():  # type: ignore[attr-defined]
+                if event is None:
+                    continue
+
+                filename = event[3]  # type: ignore[index]
+
+                self._callback(filename)  # type: ignore[misc]
+
+else:
+
+    class InotifyReloader:
+        def __init__(
+            self,
+            extra_files: Iterable[str] | None = None,
+            callback: Callable[[str], None] | None = None,
+        ) -> None:
+            raise ImportError(
+                "You must have the inotify module installed to use the inotify reloader"
+            )
+
+
+preferred_reloader = InotifyReloader if has_inotify else Reloader
+
+reloader_engines = {
+    "auto": preferred_reloader,
+    "poll": Reloader,
+    "inotify": InotifyReloader,
+}