plain.dev 0.32.0__py3-none-any.whl → 0.33.0__py3-none-any.whl

plain/dev/core.py

@@ -0,0 +1,346 @@
+import json
+import os
+import platform
+import socket
+import subprocess
+import sys
+import tomllib
+from importlib.metadata import entry_points
+from importlib.util import find_spec
+from pathlib import Path
+
+import click
+from rich.columns import Columns
+from rich.console import Console
+from rich.text import Text
+
+from plain.runtime import APP_PATH, PLAIN_TEMP_PATH
+
+from .mkcert import MkcertManager
+from .process import ProcessManager
+from .utils import has_pyproject_toml
+
+ENTRYPOINT_GROUP = "plain.dev"
+
+
+class DevProcess(ProcessManager):
+    pidfile = PLAIN_TEMP_PATH / "dev" / "dev.pid"
+    log_dir = PLAIN_TEMP_PATH / "dev" / "logs" / "run"
+
+    def setup(self, *, port, hostname, log_level):
+        if not hostname:
+            project_name = os.path.basename(
+                os.getcwd()
+            )  # Use directory name by default
+
+            if has_pyproject_toml(APP_PATH.parent):
+                with open(Path(APP_PATH.parent, "pyproject.toml"), "rb") as f:
+                    pyproject = tomllib.load(f)
+                    project_name = pyproject.get("project", {}).get(
+                        "name", project_name
+                    )
+
+            hostname = f"{project_name}.localhost"
+
+        self.hostname = hostname
+        self.log_level = log_level
+
+        self.pid_value = self.pid
+        self.prepare_log()
+
+        if port:
+            self.port = int(port)
+            if not self._port_available(self.port):
+                click.secho(f"Port {self.port} in use", fg="red")
+                raise SystemExit(1)
+        else:
+            self.port = self._find_open_port(8443)
+            if self.port != 8443:
+                click.secho(f"Port 8443 in use, using {self.port}", fg="yellow")
+
+        self.ssl_key_path = None
+        self.ssl_cert_path = None
+
+        self.url = f"https://{self.hostname}:{self.port}"
+        self.tunnel_url = os.environ.get("PLAIN_DEV_TUNNEL_URL", "")
+
+        self.plain_env = {
+            "PYTHONUNBUFFERED": "true",
+            "PLAIN_DEV": "true",
+            **os.environ,
+        }
+
+        if log_level:
+            self.plain_env["PLAIN_LOG_LEVEL"] = log_level.upper()
+            self.plain_env["APP_LOG_LEVEL"] = log_level.upper()
+
+        self.custom_process_env = {
+            **self.plain_env,
+            "PORT": str(self.port),
+            "PLAIN_DEV_URL": self.url,
+        }
+
+        if self.tunnel_url:
+            status_bar = Columns(
+                [
+                    Text.from_markup(
+                        f"[bold]Tunnel[/bold] [underline][link={self.tunnel_url}]{self.tunnel_url}[/link][/underline]"
+                    ),
+                    Text.from_markup(
+                        f"[dim][bold]Server[/bold] [link={self.url}]{self.url}[/link][/dim]"
+                    ),
+                    Text.from_markup(
+                        "[dim][bold]Ctrl+C[/bold] to stop[/dim]",
+                        justify="right",
+                    ),
+                ],
+                expand=True,
+            )
+        else:
+            status_bar = Columns(
+                [
+                    Text.from_markup(
+                        f"[bold]Server[/bold] [underline][link={self.url}]{self.url}[/link][/underline]"
+                    ),
+                    Text.from_markup(
+                        "[dim][bold]Ctrl+C[/bold] to stop[/dim]", justify="right"
+                    ),
+                ],
+                expand=True,
+            )
+        self.console = Console(markup=False, highlight=False)
+        self.console_status = self.console.status(status_bar)
+
+        self.init_poncho(self.console.out)
+
+    def _find_open_port(self, start_port):
+        port = start_port
+        while not self._port_available(port):
+            port += 1
+        return port
+
+    def _port_available(self, port):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.settimeout(0.5)
+            result = sock.connect_ex(("127.0.0.1", port))
+        return result != 0
+
+    def run(self):
+        self.write_pidfile()
+        mkcert_manager = MkcertManager()
+        mkcert_manager.setup_mkcert(install_path=Path.home() / ".plain" / "dev")
+        self.ssl_cert_path, self.ssl_key_path = mkcert_manager.generate_certs(
+            domain=self.hostname,
+            storage_path=Path(PLAIN_TEMP_PATH) / "dev" / "certs",
+        )
+
+        self.symlink_plain_src()
+        self.modify_hosts_file()
+        self.set_allowed_hosts()
+
+        click.secho("→ Running preflight checks... ", dim=True, nl=False)
+        self.run_preflight()
+
+        # if ServicesProcess.running_pid():
+        #     self.poncho.add_process(
+        #         "services",
+        #         f"{sys.executable} -m plain dev logs --services --follow",
+        #     )
+
+        if find_spec("plain.models"):
+            click.secho("→ Waiting for database... ", dim=True, nl=False)
+            subprocess.run(
+                [sys.executable, "-m", "plain", "models", "db-wait"],
+                env=self.plain_env,
+                check=True,
+            )
+            click.secho("→ Running migrations...", dim=True)
+            subprocess.run(
+                [sys.executable, "-m", "plain", "migrate", "--backup"],
+                env=self.plain_env,
+                check=True,
+            )
+
+        click.secho("\n→ Starting app...", dim=True)
+
+        # Manually start the status bar now so it isn't bungled by
+        # another thread checking db stuff...
+        self.console_status.start()
+
+        self.add_gunicorn()
+        self.add_entrypoints()
+        self.add_pyproject_run()
+
+        try:
+            # Start processes we know about and block the main thread
+            self.poncho.loop()
+
+            # Remove the status bar
+            self.console_status.stop()
+        finally:
+            self.rm_pidfile()
+            self.close()
+
+        return self.poncho.returncode
+
+    def symlink_plain_src(self):
+        """Symlink the plain package into .plain so we can look at it easily"""
+        plain_path = Path(find_spec("plain.runtime").origin).parent.parent
+        if not PLAIN_TEMP_PATH.exists():
+            PLAIN_TEMP_PATH.mkdir()
+
+        symlink_path = PLAIN_TEMP_PATH / "src"
+
+        # The symlink is broken
+        if symlink_path.is_symlink() and not symlink_path.exists():
+            symlink_path.unlink()
+
+        # The symlink exists but points to the wrong place
+        if (
+            symlink_path.is_symlink()
+            and symlink_path.exists()
+            and symlink_path.resolve() != plain_path
+        ):
+            symlink_path.unlink()
+
+        if plain_path.exists() and not symlink_path.exists():
+            symlink_path.symlink_to(plain_path)
+
+    def modify_hosts_file(self):
+        """Modify the hosts file to map the custom domain to 127.0.0.1."""
+        entry_identifier = "# Added by plain"
+        hosts_entry = f"127.0.0.1 {self.hostname}  {entry_identifier}"
+
+        if platform.system() == "Windows":
+            hosts_path = Path(r"C:\Windows\System32\drivers\etc\hosts")
+            try:
+                with hosts_path.open("r") as f:
+                    content = f.read()
+
+                if hosts_entry in content:
+                    return  # Entry already exists; no action needed
+
+                # Entry does not exist; add it
+                with hosts_path.open("a") as f:
+                    f.write(f"{hosts_entry}\n")
+                click.secho(f"Added {self.hostname} to {hosts_path}", bold=True)
+            except PermissionError:
+                click.secho(
+                    "Permission denied while modifying hosts file. Please run the script as an administrator.",
+                    fg="red",
+                )
+                sys.exit(1)
+        else:
+            # For macOS and Linux
+            hosts_path = Path("/etc/hosts")
+            try:
+                with hosts_path.open("r") as f:
+                    content = f.read()
+
+                if hosts_entry in content:
+                    return  # Entry already exists; no action needed
+
+                # Entry does not exist; append it using sudo
+                click.secho(
+                    f"Adding {self.hostname} to /etc/hosts file. You may be prompted for your password.\n",
+                    bold=True,
+                )
+                cmd = f"echo '{hosts_entry}' | sudo tee -a {hosts_path} >/dev/null"
+                subprocess.run(cmd, shell=True, check=True)
+                click.secho(f"Added {self.hostname} to {hosts_path}\n", bold=True)
+            except PermissionError:
+                click.secho(
+                    "Permission denied while accessing hosts file.",
+                    fg="red",
+                )
+                sys.exit(1)
+            except subprocess.CalledProcessError:
+                click.secho(
+                    "Failed to modify hosts file. Please ensure you have sudo privileges.",
+                    fg="red",
+                )
+                sys.exit(1)
+
+    def set_allowed_hosts(self):
+        if "PLAIN_ALLOWED_HOSTS" not in os.environ:
+            hostnames = [self.hostname]
+            if self.tunnel_url:
+                # Add the tunnel URL to the allowed hosts
+                hostnames.append(self.tunnel_url.split("://")[1])
+            allowed_hosts = json.dumps(hostnames)
+            self.plain_env["PLAIN_ALLOWED_HOSTS"] = allowed_hosts
+            self.custom_process_env["PLAIN_ALLOWED_HOSTS"] = allowed_hosts
+            click.secho(
+                f"Automatically set PLAIN_ALLOWED_HOSTS={allowed_hosts}", dim=True
+            )
+
+    def run_preflight(self):
+        if subprocess.run(["plain", "preflight"], env=self.plain_env).returncode:
+            click.secho("Preflight check failed!", fg="red")
+            sys.exit(1)
+
+    def add_gunicorn(self):
+        # Watch .env files for reload
+        extra_watch_files = []
+        for f in os.listdir(APP_PATH.parent):
+            if f.startswith(".env"):
+                # Needs to be absolute or "./" for inotify to work on Linux...
+                # https://github.com/dropseed/plain/issues/26
+                extra_watch_files.append(str(Path(APP_PATH.parent) / f))
+
+        reload_extra = " ".join(f"--reload-extra-file {f}" for f in extra_watch_files)
+        gunicorn_cmd = [
+            "gunicorn",
+            "--bind",
+            f"{self.hostname}:{self.port}",
+            "--certfile",
+            str(self.ssl_cert_path),
+            "--keyfile",
+            str(self.ssl_key_path),
+            "--threads",
+            "4",
+            "--reload",
+            "plain.wsgi:app",
+            "--timeout",
+            "60",
+            "--log-level",
+            self.log_level or "info",
+            "--access-logfile",
+            "-",
+            "--error-logfile",
+            "-",
+            *reload_extra.split(),
+            "--access-logformat",
+            "'\"%(r)s\" status=%(s)s length=%(b)s time=%(M)sms'",
+            "--log-config-json",
+            str(Path(__file__).parent / "gunicorn_logging.json"),
+        ]
+        gunicorn = " ".join(gunicorn_cmd)
+
+        self.poncho.add_process("plain", gunicorn, env=self.plain_env)
+
+    def add_entrypoints(self):
+        for entry_point in entry_points().select(group=ENTRYPOINT_GROUP):
+            self.poncho.add_process(
+                entry_point.name,
+                f"plain dev entrypoint {entry_point.name}",
+                env=self.plain_env,
+            )
+
+    def add_pyproject_run(self):
+        """Additional processes that only run during `plain dev`."""
+        if not has_pyproject_toml(APP_PATH.parent):
+            return
+
+        with open(Path(APP_PATH.parent, "pyproject.toml"), "rb") as f:
+            pyproject = tomllib.load(f)
+
+        run_commands = (
+            pyproject.get("tool", {}).get("plain", {}).get("dev", {}).get("run", {})
+        )
+        for name, data in run_commands.items():
+            env = {
+                **self.custom_process_env,
+                **data.get("env", {}),
+            }
+            self.poncho.add_process(name, data["cmd"], env=env)

plain/dev/poncho/printer.py

@@ -1,4 +1,6 @@
+import re
 from collections import namedtuple
+from pathlib import Path
 
 Message = namedtuple("Message", "type data time name color")
 
@@ -17,12 +19,19 @@ class Printer:
         width=0,
         color=True,
         prefix=True,
+        log_file=None,
     ):
         self.print_func = print_func
         self.time_format = time_format
         self.width = width
         self.color = color
         self.prefix = prefix
+        if log_file is not None:
+            log_path = Path(log_file)
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            self.log_file = log_path.open("w", encoding="utf-8")
+        else:
+            self.log_file = None
 
     def write(self, message):
         if message.type != "line":
@@ -49,7 +58,23 @@ class Printer:
                 if self.color and message.color:
                     prefix = _color_string(message.color, prefix)
 
-            self.print_func(prefix + line)
+            formatted = prefix + line
+
+            # Send original (possibly ANSI-coloured) string to stdout.
+            self.print_func(formatted)
+
+            # Strip ANSI escape sequences before persisting to disk so the log
+            # file contains plain text only.  This avoids leftover control
+            # codes (e.g. hidden-cursor) that can confuse terminals when the
+            # log is displayed later via `plain dev logs`.
+            if self.log_file is not None:
+                plain = _ANSI_RE.sub("", formatted)
+                self.log_file.write(plain + "\n")
+                self.log_file.flush()
+
+    def close(self):
+        if self.log_file and hasattr(self.log_file, "close"):
+            self.log_file.close()
 
 
 def _color_string(color, s):
@@ -57,3 +82,8 @@ def _color_string(color, s):
         return f"\033[{code}m"
 
     return f"{_ansi(0)}{_ansi(color)}{s}{_ansi(0)}"
+
+
+# Regex that matches ANSI escape sequences (e.g. colour codes, cursor control
+# sequences, etc.).  Adapted from ECMA-48 / VT100 patterns.
+_ANSI_RE = re.compile(r"\x1B\[[0-?]*[ -/]*[@-~]")

plain/dev/precommit/cli.py

@@ -10,8 +10,6 @@ import click
 from plain.cli import register_cli
 from plain.cli.print import print_event
 
-from ..services import Services
-
 
 def install_git_hook():
     hook_path = os.path.join(".git", "hooks", "pre-commit")
@@ -38,60 +36,58 @@ def cli(install):
 
     pyproject = Path("pyproject.toml")
 
-    with Services():
-        if pyproject.exists():
-            with open(pyproject, "rb") as f:
-                pyproject = tomllib.load(f)
-            for name, data in (
-                pyproject.get("tool", {})
-                .get("plain", {})
-                .get("pre-commit", {})
-                .get("run", {})
-            ).items():
-                cmd = data["cmd"]
-                print_event(f"Custom: {name} -> {cmd}")
-                result = subprocess.run(cmd, shell=True)
-                if result.returncode != 0:
-                    sys.exit(result.returncode)
-
-        # Run this first since it's probably the most likely to fail
-        if find_spec("plain.code"):
-            check_short("Running plain code checks", "plain", "code", "check")
-
-        if Path("uv.lock").exists():
-            check_short("Checking uv.lock", "uv", "lock", "--check")
-
-        if plain_db_connected():
-            check_short(
-                "Running preflight checks",
-                "plain",
-                "preflight",
-                "--database",
-                "default",
-            )
-            check_short("Checking Plain migrations", "plain", "migrate", "--check")
-            check_short(
-                "Checking for Plain models missing migrations",
-                "plain",
-                "makemigrations",
-                "--dry-run",
-                "--check",
-            )
-        else:
-            check_short("Running Plain checks (without database)", "plain", "preflight")
-            click.secho("--> Skipping migration checks", bold=True, fg="yellow")
+    if pyproject.exists():
+        with open(pyproject, "rb") as f:
+            pyproject = tomllib.load(f)
+        for name, data in (
+            pyproject.get("tool", {})
+            .get("plain", {})
+            .get("pre-commit", {})
+            .get("run", {})
+        ).items():
+            cmd = data["cmd"]
+            print_event(f"Custom: {name} -> {cmd}")
+            result = subprocess.run(cmd, shell=True)
+            if result.returncode != 0:
+                sys.exit(result.returncode)
+
+    # Run this first since it's probably the most likely to fail
+    if find_spec("plain.code"):
+        check_short("Running plain code checks", "plain", "code", "check")
+
+    if Path("uv.lock").exists():
+        check_short("Checking uv.lock", "uv", "lock", "--check")
+
+    if plain_db_connected():
+        check_short(
+            "Running preflight checks",
+            "plain",
+            "preflight",
+            "--database",
+        )
+        check_short("Checking Plain migrations", "plain", "migrate", "--check")
+        check_short(
+            "Checking for Plain models missing migrations",
+            "plain",
+            "makemigrations",
+            "--dry-run",
+            "--check",
+        )
+    else:
+        check_short("Running Plain checks (without database)", "plain", "preflight")
+        click.secho("--> Skipping migration checks", bold=True, fg="yellow")
+
+    print_event("Running plain build")
+    result = subprocess.run(["plain", "build"])
+    if result.returncode != 0:
+        sys.exit(result.returncode)
 
-        print_event("Running plain build")
-        result = subprocess.run(["plain", "build"])
+    if find_spec("plain.pytest"):
+        print_event("Running tests")
+        result = subprocess.run(["plain", "test"])
         if result.returncode != 0:
             sys.exit(result.returncode)
 
-        if find_spec("plain.pytest"):
-            print_event("Running tests")
-            result = subprocess.run(["plain", "test"])
-            if result.returncode != 0:
-                sys.exit(result.returncode)
-
 
 def plain_db_connected():
     result = subprocess.run(

plain/dev/process.py

@@ -0,0 +1,127 @@
+import os
+import time
+from pathlib import Path
+
+from .poncho.manager import Manager as PonchoManager
+from .poncho.printer import Printer
+
+
+class ProcessManager:
+    pidfile: Path
+    log_dir: Path
+
+    def __init__(self):
+        self.pid = os.getpid()
+        self.log_path: Path | None = None
+        self.printer: Printer | None = None
+        self.poncho: PonchoManager | None = None
+
+    # ------------------------------------------------------------------
+    # Class-level pidfile helpers (usable without instantiation)
+    # ------------------------------------------------------------------
+    @classmethod
+    def read_pidfile(cls) -> int | None:
+        """Return the PID recorded in *cls.pidfile* (or ``None``)."""
+        if not cls.pidfile.exists():
+            return None
+
+        try:
+            return int(cls.pidfile.read_text())
+        except (ValueError, OSError):
+            # Corrupted pidfile – remove it so we don't keep trying.
+            cls.rm_pidfile()
+            return None
+
+    @classmethod
+    def rm_pidfile(cls) -> None:
+        if cls.pidfile and cls.pidfile.exists():
+            cls.pidfile.unlink(missing_ok=True)  # Python 3.8+
+
+    @classmethod
+    def running_pid(cls) -> int | None:
+        """Return a *running* PID or ``None`` if the process is not alive."""
+        pid = cls.read_pidfile()
+        if pid is None:
+            return None
+
+        try:
+            os.kill(pid, 0)  # Does not kill – merely checks for existence.
+        except OSError:
+            cls.rm_pidfile()
+            return None
+
+        return pid
+
+    def write_pidfile(self) -> None:
+        """Create/overwrite the pidfile for *this* process."""
+        self.pidfile.parent.mkdir(parents=True, exist_ok=True)
+        with self.pidfile.open("w+", encoding="utf-8") as f:
+            f.write(str(self.pid))
+
+    def stop_process(self) -> None:
+        """Terminate the process recorded in the pidfile, if it is running."""
+        pid = self.read_pidfile()
+        if pid is None:
+            return
+
+        # Try graceful termination first (SIGTERM)…
+        try:
+            os.kill(pid, 15)
+        except OSError:
+            # Process already gone – ensure we clean up.
+            self.rm_pidfile()
+            self.close()
+            return
+
+        timeout = 10  # seconds
+        start = time.time()
+        while time.time() - start < timeout:
+            try:
+                os.kill(pid, 0)
+            except OSError:
+                break  # Process has exited.
+            time.sleep(0.1)
+
+        else:  # Still running – force kill.
+            try:
+                os.kill(pid, 9)
+            except OSError:
+                pass
+
+        self.rm_pidfile()
+        self.close()
+
+    # ------------------------------------------------------------------
+    # Logging / Poncho helpers (unchanged)
+    # ------------------------------------------------------------------
+    def prepare_log(self) -> Path:
+        """Create the log directory and return a path for *this* run."""
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+
+        # Keep the 5 most recent log files.
+        logs = sorted(
+            self.log_dir.glob("*.log"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )
+        for old in logs[5:]:
+            old.unlink(missing_ok=True)
+
+        self.log_path = self.log_dir / f"{self.pid}.log"
+        return self.log_path
+
+    def init_poncho(self, print_func) -> PonchoManager:  # noqa: D401
+        """Return a :class:`~plain.dev.poncho.manager.Manager` instance."""
+        if self.log_path is None:
+            self.prepare_log()
+
+        self.printer = Printer(print_func, log_file=self.log_path)
+        self.poncho = PonchoManager(printer=self.printer)
+        return self.poncho
+
+    # ------------------------------------------------------------------
+    # Cleanup
+    # ------------------------------------------------------------------
+    def close(self) -> None:
+        if self.printer:
+            self.printer.close()