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

plain/server/glogging.py

@@ -0,0 +1,292 @@
+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 base64
+import binascii
+import datetime
+import logging
+import time
+from typing import TYPE_CHECKING, Any
+
+logging.Logger.manager.emittedNoHandlerWarning = True  # type: ignore[attr-defined]
+import os  # noqa: E402
+import sys  # noqa: E402
+import threading  # noqa: E402
+import traceback  # noqa: E402
+
+from . import util  # noqa: E402
+
+if TYPE_CHECKING:
+    from io import TextIOWrapper
+
+    from .config import Config
+
+
+def loggers() -> list[logging.Logger]:
+    """get list of all loggers"""
+    root = logging.root
+    existing = list(root.manager.loggerDict.keys())
+    return [logging.getLogger(name) for name in existing]
+
+
+class SafeAtoms(dict[str, Any]):
+    def __init__(self, atoms: dict[str, Any]) -> None:
+        dict.__init__(self)
+        for key, value in atoms.items():
+            if isinstance(value, str):
+                self[key] = value.replace('"', '\\"')
+            else:
+                self[key] = value
+
+    def __getitem__(self, k: str) -> Any:
+        if k.startswith("{"):
+            kl = k.lower()
+            if kl in self:
+                return super().__getitem__(kl)
+            else:
+                return "-"
+        if k in self:
+            return super().__getitem__(k)
+        else:
+            return "-"
+
+
+class Logger:
+    LOG_LEVELS = {
+        "critical": logging.CRITICAL,
+        "error": logging.ERROR,
+        "warning": logging.WARNING,
+        "info": logging.INFO,
+        "debug": logging.DEBUG,
+    }
+    loglevel = logging.INFO
+
+    error_fmt = r"%(asctime)s [%(process)d] [%(levelname)s] %(message)s"
+    datefmt = r"[%Y-%m-%d %H:%M:%S %z]"
+
+    access_fmt = "%(message)s"
+    syslog_fmt = "[%(process)d] %(message)s"
+
+    atoms_wrapper_class = SafeAtoms
+
+    def __init__(self, cfg: Config) -> None:
+        self.error_log = logging.getLogger("plain.server.error")
+        self.error_log.propagate = False
+        self.access_log = logging.getLogger("plain.server.access")
+        self.access_log.propagate = False
+        self.error_handlers: list[logging.Handler] = []
+        self.access_handlers: list[logging.Handler] = []
+        self.logfile: TextIOWrapper | None = None
+        self.lock = threading.Lock()
+        self.cfg = cfg
+        self.setup(cfg)
+
+    def setup(self, cfg: Config) -> None:
+        self.loglevel = self.LOG_LEVELS.get(cfg.loglevel.lower(), logging.INFO)
+        self.error_log.setLevel(self.loglevel)
+        self.access_log.setLevel(logging.INFO)
+
+        # set plain.server.error handler
+        self._set_handler(
+            self.error_log,
+            cfg.errorlog,
+            logging.Formatter(cfg.log_format, self.datefmt),
+        )
+
+        # set plain.server.access handler
+        if cfg.accesslog is not None:
+            self._set_handler(
+                self.access_log,
+                cfg.accesslog,
+                fmt=logging.Formatter(cfg.log_format, self.datefmt),
+                stream=sys.stdout,
+            )
+
+    def critical(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self.error_log.critical(msg, *args, **kwargs)
+
+    def error(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self.error_log.error(msg, *args, **kwargs)
+
+    def warning(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self.error_log.warning(msg, *args, **kwargs)
+
+    def info(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self.error_log.info(msg, *args, **kwargs)
+
+    def debug(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self.error_log.debug(msg, *args, **kwargs)
+
+    def exception(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self.error_log.exception(msg, *args, **kwargs)
+
+    def log(self, lvl: int | str, msg: str, *args: Any, **kwargs: Any) -> None:
+        if isinstance(lvl, str):
+            lvl = self.LOG_LEVELS.get(lvl.lower(), logging.INFO)
+        self.error_log.log(lvl, msg, *args, **kwargs)
+
+    def atoms(
+        self,
+        resp: Any,
+        req: Any,
+        environ: dict[str, Any],
+        request_time: datetime.timedelta,
+    ) -> dict[str, Any]:
+        """Gets atoms for log formatting."""
+        status = resp.status
+        if isinstance(status, str):
+            status = status.split(None, 1)[0]
+        atoms = {
+            "h": environ.get("REMOTE_ADDR", "-"),
+            "l": "-",
+            "u": self._get_user(environ) or "-",
+            "t": self.now(),
+            "r": "{} {} {}".format(
+                environ["REQUEST_METHOD"],
+                environ["RAW_URI"],
+                environ["SERVER_PROTOCOL"],
+            ),
+            "s": status,
+            "m": environ.get("REQUEST_METHOD"),
+            "U": environ.get("PATH_INFO"),
+            "q": environ.get("QUERY_STRING"),
+            "H": environ.get("SERVER_PROTOCOL"),
+            "b": getattr(resp, "sent", None) is not None and str(resp.sent) or "-",
+            "B": getattr(resp, "sent", None),
+            "f": environ.get("HTTP_REFERER", "-"),
+            "a": environ.get("HTTP_USER_AGENT", "-"),
+            "T": request_time.seconds,
+            "D": (request_time.seconds * 1000000) + request_time.microseconds,
+            "M": (request_time.seconds * 1000) + int(request_time.microseconds / 1000),
+            "L": f"{request_time.seconds}.{request_time.microseconds:06d}",
+            "p": f"<{os.getpid()}>",
+        }
+
+        # add request headers
+        if hasattr(req, "headers"):
+            req_headers = req.headers
+        else:
+            req_headers = req
+
+        if hasattr(req_headers, "items"):
+            req_headers = req_headers.items()
+
+        atoms.update({f"{{{k.lower()}}}i": v for k, v in req_headers})
+
+        resp_headers = resp.headers
+        if hasattr(resp_headers, "items"):
+            resp_headers = resp_headers.items()
+
+        # add response headers
+        atoms.update({f"{{{k.lower()}}}o": v for k, v in resp_headers})
+
+        # add environ variables
+        environ_variables = environ.items()
+        atoms.update({f"{{{k.lower()}}}e": v for k, v in environ_variables})
+
+        return atoms
+
+    def access(
+        self,
+        resp: Any,
+        req: Any,
+        environ: dict[str, Any],
+        request_time: datetime.timedelta,
+    ) -> None:
+        """See http://httpd.apache.org/docs/2.0/logs.html#combined
+        for format details
+        """
+
+        if not self.cfg.accesslog:
+            return None
+
+        # wrap atoms:
+        # - make sure atoms will be test case insensitively
+        # - if atom doesn't exist replace it by '-'
+        safe_atoms = self.atoms_wrapper_class(
+            self.atoms(resp, req, environ, request_time)
+        )
+
+        try:
+            self.access_log.info(self.cfg.access_log_format, safe_atoms)
+        except Exception:
+            self.error(traceback.format_exc())
+
+        return None
+
+    def now(self) -> str:
+        """return date in Apache Common Log Format"""
+        return time.strftime("[%d/%b/%Y:%H:%M:%S %z]")
+
+    def reopen_files(self) -> None:
+        for log in loggers():
+            for handler in log.handlers:
+                if isinstance(handler, logging.FileHandler):
+                    handler.acquire()
+                    try:
+                        if handler.stream:
+                            handler.close()
+                            handler.stream = handler._open()
+                    finally:
+                        handler.release()
+
+    def close_on_exec(self) -> None:
+        for log in loggers():
+            for handler in log.handlers:
+                if isinstance(handler, logging.FileHandler):
+                    handler.acquire()
+                    try:
+                        if handler.stream:
+                            util.close_on_exec(handler.stream.fileno())
+                    finally:
+                        handler.release()
+
+    def _get_plain_server_handler(self, log: logging.Logger) -> logging.Handler | None:
+        for h in log.handlers:
+            if getattr(h, "_plain_server", False):
+                return h
+        return None
+
+    def _set_handler(
+        self,
+        log: logging.Logger,
+        output: str | None,
+        fmt: logging.Formatter,
+        stream: Any = None,
+    ) -> None:
+        # remove previous plain server log handler
+        h = self._get_plain_server_handler(log)
+        if h:
+            log.handlers.remove(h)
+
+        if output is not None:
+            if output == "-":
+                h = logging.StreamHandler(stream)
+            else:
+                util.check_is_writable(output)
+                h = logging.FileHandler(output)
+
+            h.setFormatter(fmt)
+            h._plain_server = True  # type: ignore[attr-defined]  # custom attribute
+            log.addHandler(h)
+
+    def _get_user(self, environ: dict[str, Any]) -> str | None:
+        user = None
+        http_auth = environ.get("HTTP_AUTHORIZATION")
+        if http_auth and http_auth.lower().startswith("basic"):
+            auth = http_auth.split(" ", 1)
+            if len(auth) == 2:
+                try:
+                    # b64decode doesn't accept unicode in Python < 3.3
+                    # so we need to convert it to a byte string
+                    auth = base64.b64decode(auth[1].strip().encode("utf-8"))
+                    # b64decode returns a byte string
+                    user = auth.split(b":", 1)[0].decode("UTF-8")
+                except (TypeError, binascii.Error, UnicodeDecodeError) as exc:
+                    self.debug("Couldn't get username: %s", exc)
+        return user

plain/server/http/__init__.py

@@ -0,0 +1,12 @@
+#
+#
+# This file is part of gunicorn released under the MIT license.
+# See the LICENSE for more information.
+#
+# Vendored and modified for Plain.
+
+from . import errors
+from .message import Message, Request
+from .parser import RequestParser
+
+__all__ = ["Message", "Request", "RequestParser", "errors"]

plain/server/http/body.py

@@ -0,0 +1,283 @@
+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 sys
+from collections.abc import Generator, Iterator
+from typing import TYPE_CHECKING
+
+from .errors import ChunkMissingTerminator, InvalidChunkSize, NoMoreData
+
+if TYPE_CHECKING:
+    from .message import Request
+    from .unreader import Unreader
+
+
+class ChunkedReader:
+    def __init__(self, req: Request, unreader: Unreader) -> None:
+        self.req = req
+        self.parser: Generator[bytes, None, None] | None = self.parse_chunked(unreader)
+        self.buf = io.BytesIO()
+
+    def read(self, size: int) -> bytes:
+        if not isinstance(size, int):
+            raise TypeError("size must be an integer type")
+        if size < 0:
+            raise ValueError("Size must be positive.")
+        if size == 0:
+            return b""
+
+        if self.parser:
+            while self.buf.tell() < size:
+                try:
+                    self.buf.write(next(self.parser))
+                except StopIteration:
+                    self.parser = None
+                    break
+
+        data = self.buf.getvalue()
+        ret, rest = data[:size], data[size:]
+        self.buf = io.BytesIO()
+        self.buf.write(rest)
+        return ret
+
+    def parse_trailers(self, unreader: Unreader, data: bytes) -> None:
+        buf = io.BytesIO()
+        buf.write(data)
+
+        idx = buf.getvalue().find(b"\r\n\r\n")
+        done = buf.getvalue()[:2] == b"\r\n"
+        while idx < 0 and not done:
+            self.get_data(unreader, buf)
+            idx = buf.getvalue().find(b"\r\n\r\n")
+            done = buf.getvalue()[:2] == b"\r\n"
+        if done:
+            unreader.unread(buf.getvalue()[2:])
+            return None
+        self.req.trailers = self.req.parse_headers(
+            buf.getvalue()[:idx], from_trailer=True
+        )
+        unreader.unread(buf.getvalue()[idx + 4 :])
+        return None
+
+    def parse_chunked(self, unreader: Unreader) -> Generator[bytes, None, None]:
+        (size, rest) = self.parse_chunk_size(unreader)
+        while size > 0:
+            while size > len(rest):
+                size -= len(rest)
+                yield rest
+                rest = unreader.read()
+                if not rest:
+                    raise NoMoreData()
+            yield rest[:size]
+            # Remove \r\n after chunk
+            rest = rest[size:]
+            while len(rest) < 2:
+                new_data = unreader.read()
+                if not new_data:
+                    break
+                rest += new_data
+            if rest[:2] != b"\r\n":
+                raise ChunkMissingTerminator(rest[:2])
+            (size, rest) = self.parse_chunk_size(unreader, data=rest[2:])
+
+    def parse_chunk_size(
+        self, unreader: Unreader, data: bytes | None = None
+    ) -> tuple[int, bytes]:
+        buf = io.BytesIO()
+        if data is not None:
+            buf.write(data)
+
+        idx = buf.getvalue().find(b"\r\n")
+        while idx < 0:
+            self.get_data(unreader, buf)
+            idx = buf.getvalue().find(b"\r\n")
+
+        data = buf.getvalue()
+        line, rest_chunk = data[:idx], data[idx + 2 :]
+
+        # RFC9112 7.1.1: BWS before chunk-ext - but ONLY then
+        chunk_size, *chunk_ext = line.split(b";", 1)
+        if chunk_ext:
+            chunk_size = chunk_size.rstrip(b" \t")
+        if any(n not in b"0123456789abcdefABCDEF" for n in chunk_size):
+            raise InvalidChunkSize(chunk_size)
+        if len(chunk_size) == 0:
+            raise InvalidChunkSize(chunk_size)
+        chunk_size = int(chunk_size, 16)
+
+        if chunk_size == 0:
+            try:
+                self.parse_trailers(unreader, rest_chunk)
+            except NoMoreData:
+                pass
+            return (0, b"")
+        return (chunk_size, rest_chunk)
+
+    def get_data(self, unreader: Unreader, buf: io.BytesIO) -> None:
+        data = unreader.read()
+        if not data:
+            raise NoMoreData()
+        buf.write(data)
+        return None
+
+
+class LengthReader:
+    def __init__(self, unreader: Unreader, length: int) -> None:
+        self.unreader = unreader
+        self.length = length
+
+    def read(self, size: int) -> bytes:
+        if not isinstance(size, int):
+            raise TypeError("size must be an integral type")
+
+        size = min(self.length, size)
+        if size < 0:
+            raise ValueError("Size must be positive.")
+        if size == 0:
+            return b""
+
+        buf = io.BytesIO()
+        data = self.unreader.read()
+        while data:
+            buf.write(data)
+            if buf.tell() >= size:
+                break
+            data = self.unreader.read()
+
+        buf_data = buf.getvalue()
+        ret, rest = buf_data[:size], buf_data[size:]
+        self.unreader.unread(rest)
+        self.length -= size
+        return ret
+
+
+class EOFReader:
+    def __init__(self, unreader: Unreader) -> None:
+        self.unreader = unreader
+        self.buf = io.BytesIO()
+        self.finished = False
+
+    def read(self, size: int) -> bytes:
+        if not isinstance(size, int):
+            raise TypeError("size must be an integral type")
+        if size < 0:
+            raise ValueError("Size must be positive.")
+        if size == 0:
+            return b""
+
+        if self.finished:
+            data = self.buf.getvalue()
+            ret, rest = data[:size], data[size:]
+            self.buf = io.BytesIO()
+            self.buf.write(rest)
+            return ret
+
+        data = self.unreader.read()
+        while data:
+            self.buf.write(data)
+            if self.buf.tell() > size:
+                break
+            data = self.unreader.read()
+
+        if not data:
+            self.finished = True
+
+        data = self.buf.getvalue()
+        ret, rest = data[:size], data[size:]
+        self.buf = io.BytesIO()
+        self.buf.write(rest)
+        return ret
+
+
+class Body:
+    def __init__(self, reader: ChunkedReader | LengthReader | EOFReader) -> None:
+        self.reader = reader
+        self.buf = io.BytesIO()
+
+    def __iter__(self) -> Iterator[bytes]:
+        return self
+
+    def __next__(self) -> bytes:
+        ret = self.readline()
+        if not ret:
+            raise StopIteration()
+        return ret
+
+    next = __next__
+
+    def getsize(self, size: int | None) -> int:
+        if size is None:
+            return sys.maxsize
+        elif not isinstance(size, int):
+            raise TypeError("size must be an integral type")
+        elif size < 0:
+            return sys.maxsize
+        return size
+
+    def read(self, size: int | None = None) -> bytes:
+        size = self.getsize(size)
+        if size == 0:
+            return b""
+
+        if size < self.buf.tell():
+            data = self.buf.getvalue()
+            ret, rest = data[:size], data[size:]
+            self.buf = io.BytesIO()
+            self.buf.write(rest)
+            return ret
+
+        while size > self.buf.tell():
+            data = self.reader.read(1024)
+            if not data:
+                break
+            self.buf.write(data)
+
+        data = self.buf.getvalue()
+        ret, rest = data[:size], data[size:]
+        self.buf = io.BytesIO()
+        self.buf.write(rest)
+        return ret
+
+    def readline(self, size: int | None = None) -> bytes:
+        size = self.getsize(size)
+        if size == 0:
+            return b""
+
+        data = self.buf.getvalue()
+        self.buf = io.BytesIO()
+
+        ret = []
+        while 1:
+            idx = data.find(b"\n", 0, size)
+            idx = idx + 1 if idx >= 0 else size if len(data) >= size else 0
+            if idx:
+                ret.append(data[:idx])
+                self.buf.write(data[idx:])
+                break
+
+            ret.append(data)
+            size -= len(data)
+            data = self.reader.read(min(1024, size))
+            if not data:
+                break
+
+        return b"".join(ret)
+
+    def readlines(self, size: int | None = None) -> list[bytes]:
+        ret = []
+        data = self.read()
+        while data:
+            pos = data.find(b"\n")
+            if pos < 0:
+                ret.append(data)
+                data = b""
+            else:
+                line, data = data[: pos + 1], data[pos + 1 :]
+                ret.append(line)
+        return ret