plain.dev 0.0.0__py3-none-any.whl

plain/dev/db/container.py

@@ -0,0 +1,151 @@
+import os
+import shlex
+import subprocess
+
+from plain.runtime import APP_PATH, settings
+
+SNAPSHOT_DB_PREFIX = "plaindb_snapshot_"
+
+
+class DBContainer:
+    def __init__(self):
+        project_root = APP_PATH.parent
+        tmp_dir = settings.PLAIN_TEMP_PATH
+
+        name = os.path.basename(project_root) + "-postgres-1"
+
+        if "DATABASE_URL" in os.environ:
+            from plain.models import database_url
+
+            postgres_version = os.environ.get("POSTGRES_VERSION")
+            parsed_db_url = database_url.parse(os.environ.get("DATABASE_URL"))
+
+        self.name = name
+        self.tmp_dir = os.path.abspath(tmp_dir)
+        self.postgres_version = postgres_version or "13"
+        self.postgres_port = parsed_db_url.get("PORT", "5432")
+        self.postgres_db = parsed_db_url.get("NAME", "postgres")
+        self.postgres_user = parsed_db_url.get("USER", "postgres")
+        self.postgres_password = parsed_db_url.get("PASSWORD", "postgres")
+
+    def execute(self, command, *args, **kwargs):
+        docker_flags = kwargs.pop("docker_flags", "-it")
+        return subprocess.run(
+            [
+                "docker",
+                "exec",
+                docker_flags,
+                self.name,
+                *shlex.split(command),
+            ]
+            + list(args),
+            check=True,
+            **kwargs,
+        )
+
+    def reset(self, create=False):
+        try:
+            self.execute(
+                f"dropdb {self.postgres_db} --force -U {self.postgres_user}",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+        except subprocess.CalledProcessError as e:
+            if "does not exist" not in e.stdout.decode():
+                print(e.stderr.decode())
+                raise
+
+        if create:
+            self.execute(
+                f"createdb {self.postgres_db} -U {self.postgres_user}",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+
+    def terminate_connections(self):
+        self.execute(
+            f"psql -U {self.postgres_user} {self.postgres_db} -c",
+            f"SELECT pg_terminate_backend(pg_stat_activity.pid) FROM pg_stat_activity WHERE pg_stat_activity.datname = '{self.postgres_db}' AND pid <> pg_backend_pid();",
+            stdout=subprocess.DEVNULL,
+        )
+
+    def create_snapshot(self, name):
+        snapshot_name = f"{SNAPSHOT_DB_PREFIX}{name}"
+        current_git_branch = (
+            subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+            .decode()
+            .strip()
+        )
+        description = f"branch={current_git_branch}"
+
+        self.terminate_connections()
+        try:
+            self.execute(
+                f"createdb {snapshot_name} '{description}' -U {self.postgres_user} -T {self.postgres_db}",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+        except subprocess.CalledProcessError as e:
+            if "already exists" in e.stdout.decode():
+                return False
+            else:
+                raise
+
+        return True
+
+    def list_snapshots(self):
+        self.execute(
+            f"psql -U {self.postgres_user} {self.postgres_db} -c",
+            f"SELECT REPLACE(datname, '{SNAPSHOT_DB_PREFIX}', '') as name, pg_size_pretty(pg_database_size(datname)) as size, pg_catalog.shobj_description(oid, 'pg_database') AS description, (pg_stat_file('base/'||oid ||'/PG_VERSION')).modification as created FROM pg_catalog.pg_database WHERE datname LIKE '{SNAPSHOT_DB_PREFIX}%' ORDER BY created;",
+        )
+
+    def delete_snapshot(self, name):
+        snapshot_name = f"{SNAPSHOT_DB_PREFIX}{name}"
+        try:
+            self.execute(
+                f"dropdb {snapshot_name} -U {self.postgres_user}",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+        except subprocess.CalledProcessError as e:
+            if "does not exist" in e.stdout.decode():
+                return False
+            else:
+                raise
+
+        return True
+
+    def restore_snapshot(self, name):
+        snapshot_name = f"{SNAPSHOT_DB_PREFIX}{name}"
+        self.reset(create=False)
+        self.execute(
+            f"createdb {self.postgres_db} -U {self.postgres_user} -T {snapshot_name}",
+        )
+
+    def export(self, export_path):
+        successful = (
+            subprocess.run(
+                [
+                    "docker",
+                    "exec",
+                    self.name,
+                    "/bin/bash",
+                    "-c",
+                    f"pg_dump -U {self.postgres_user} {self.postgres_db}",
+                ],
+                stdout=open(export_path, "w+"),
+            ).returncode
+            == 0
+        )
+        return successful
+
+    def import_sql(self, sql_file):
+        self.reset(create=True)
+        successful = (
+            subprocess.run(
+                f"docker exec -i {self.name} psql -U {self.postgres_user} {self.postgres_db} < {shlex.quote(sql_file)}",
+                shell=True,
+            ).returncode
+            == 0
+        )
+        return successful

plain/dev/debug.py

@@ -0,0 +1,12 @@
+import debugpy
+
+
+def attach(endpoint=("localhost", 5678)):
+    if debugpy.is_client_connected():
+        print("Debugger already attached")
+        return
+
+    debugpy.listen(endpoint)
+    print("Waiting for debugger to attach...")
+    debugpy.wait_for_client()
+    print("Debugger attached!")

plain/dev/default_settings.py

@@ -0,0 +1,5 @@
+DEV_REQUESTS_IGNORE_PATHS = [
+    "/favicon.ico",
+]
+
+DEV_REQUESTS_MAX = 50

plain/dev/pid.py

@@ -0,0 +1,20 @@
+import os
+
+from plain.runtime import settings
+
+
+class Pid:
+    def __init__(self):
+        self.pidfile = settings.PLAIN_TEMP_PATH / "dev.pid"
+
+    def write(self):
+        pid = os.getpid()
+        self.pidfile.parent.mkdir(parents=True, exist_ok=True)
+        with self.pidfile.open("w+") as f:
+            f.write(str(pid))
+
+    def rm(self):
+        self.pidfile.unlink()
+
+    def exists(self):
+        return self.pidfile.exists()

plain/dev/precommit/__init__.py

@@ -0,0 +1,3 @@
+from .cli import cli
+
+__all__ = ["cli"]

plain/dev/precommit/cli.py

@@ -0,0 +1,123 @@
+import os
+import subprocess
+import sys
+from importlib.util import find_spec
+from pathlib import Path
+
+from plain.cli.print import print_event
+
+from ..services import Services
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+import click
+
+
+def install_git_hook():
+    hook_path = os.path.join(".git", "hooks", "pre-commit")
+    if os.path.exists(hook_path):
+        print("pre-commit hook already exists")
+    else:
+        with open(hook_path, "w") as f:
+            f.write(
+                """#!/bin/sh
+plain pre-commit"""
+            )
+        os.chmod(hook_path, 0o755)
+        print("pre-commit hook installed")
+
+
+@click.command()
+@click.option("--install", is_flag=True)
+def cli(install):
+    """Git pre-commit checks"""
+    if install:
+        install_git_hook()
+        return
+
+    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("poetry.lock").exists():
+            check_short("Checking poetry.lock", "poetry", "lock", "--check")
+
+        if plain_db_connected():
+            check_short(
+                "Running preflight checks",
+                "plain",
+                "preflight",
+                "--database",
+                "default",
+            )
+            check_short(
+                "Checking Plain migrations", "plain", "legacy", "migrate", "--check"
+            )
+            check_short(
+                "Checking for Plain models missing migrations",
+                "plain",
+                "legacy",
+                "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 compile")
+        result = subprocess.run(["plain", "compile"])
+        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",
+            "legacy",
+            "showmigrations",
+            "--skip-checks",
+        ],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    return result.returncode == 0
+
+
+def check_short(message, *args):
+    print_event(message, newline=False)
+    result = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    if result.returncode != 0:
+        click.secho("✘", fg="red")
+        click.secho(result.stdout.decode("utf-8"))
+        sys.exit(1)
+    else:
+        click.secho("✔", fg="green")

plain/dev/requests.py

@@ -0,0 +1,224 @@
+import datetime
+import json
+import os
+import sys
+import traceback
+
+import requests
+
+from plain.runtime import settings
+from plain.signals import got_request_exception
+
+
+class RequestLog:
+    def __init__(self, *, request, response, exception=None):
+        self.request = request
+        self.response = response
+        self.exception = exception
+
+    @staticmethod
+    def storage_path():
+        return str(settings.PLAIN_TEMP_PATH / "requestlog")
+
+    @classmethod
+    def replay_request(cls, name):
+        path = os.path.join(cls.storage_path(), f"{name}.json")
+        with open(path) as f:
+            data = json.load(f)
+
+        method = data["request"]["method"]
+
+        if method == "GET":
+            # Params are in absolute uri
+            request_data = data["request"]["body"].encode("utf-8")
+        elif method in ("POST", "PUT", "PATCH"):
+            if data["request"]["querydict"]:
+                request_data = data["request"]["querydict"]
+            else:
+                request_data = data["request"]["body"].encode("utf-8")
+
+        # Cookies need to be passed as a dict, so that
+        # they are passed through redirects
+        data["request"]["headers"].pop("Cookie", None)
+
+        # TODO???
+        if data["request"]["headers"].get("X-Forwarded-Proto", "") == "https,https":
+            data["request"]["headers"]["X-Forwarded-Proto"] = "https"
+
+        response = requests.request(
+            method,
+            data["request"]["absolute_uri"],
+            headers=data["request"]["headers"],
+            cookies=data["request"]["cookies"],
+            data=request_data,
+            timeout=5,
+        )
+        print("Replayed request", response)
+
+    @staticmethod
+    def load_json_logs():
+        storage_path = RequestLog.storage_path()
+        if not os.path.exists(storage_path):
+            return []
+
+        logs = []
+        filenames = os.listdir(storage_path)
+        sorted_filenames = sorted(filenames, reverse=True)
+        for filename in sorted_filenames:
+            path = os.path.join(storage_path, filename)
+            with open(path) as f:
+                log = json.load(f)
+                log["name"] = os.path.splitext(filename)[0]
+                # Convert timestamp back to datetime
+                log["timestamp"] = datetime.datetime.fromtimestamp(log["timestamp"])
+                try:
+                    log["request"]["body_json"] = json.dumps(
+                        json.loads(log["request"]["body"]), indent=2
+                    )
+                except json.JSONDecodeError:
+                    pass
+                logs.append(log)
+
+        return logs
+
+    @staticmethod
+    def delete_old_logs():
+        storage_path = RequestLog.storage_path()
+        if not os.path.exists(storage_path):
+            return
+
+        filenames = os.listdir(storage_path)
+        sorted_filenames = sorted(filenames, reverse=True)
+        for filename in sorted_filenames[settings.DEV_REQUESTS_MAX :]:
+            path = os.path.join(storage_path, filename)
+            try:
+                os.remove(path)
+            except FileNotFoundError:
+                pass
+
+    @staticmethod
+    def clear():
+        storage_path = RequestLog.storage_path()
+        if not os.path.exists(storage_path):
+            return
+
+        filenames = os.listdir(storage_path)
+        for filename in filenames:
+            path = os.path.join(storage_path, filename)
+            try:
+                os.remove(path)
+            except FileNotFoundError:
+                pass
+
+    def save(self):
+        storage_path = self.storage_path()
+        if not os.path.exists(storage_path):
+            os.makedirs(storage_path)
+
+        timestamp = datetime.datetime.now().timestamp()
+        filename = f"{timestamp}.json"
+        path = os.path.join(storage_path, filename)
+        with open(path, "w+") as f:
+            json.dump(self.as_dict(), f, indent=2)
+
+        self.delete_old_logs()
+
+    def as_dict(self):
+        return {
+            "timestamp": datetime.datetime.now().timestamp(),
+            "request": self.request_as_dict(self.request),
+            "response": self.response_as_dict(self.response),
+            "exception": self.exception_as_dict(self.exception),
+        }
+
+    @staticmethod
+    def request_as_dict(request):
+        return {
+            "method": request.method,
+            "path": request.path,
+            "full_path": request.get_full_path(),
+            "querydict": request.POST.dict()
+            if request.method == "POST"
+            else request.GET.dict(),
+            "cookies": request.COOKIES,
+            # files?
+            "absolute_uri": request.build_absolute_uri(),
+            "body": request.body.decode("utf-8"),
+            "headers": dict(request.headers),
+        }
+
+    @staticmethod
+    def response_as_dict(response):
+        try:
+            content = response.content.decode("utf-8")
+        except AttributeError:
+            content = "<streaming_content>"
+
+        return {
+            "status_code": response.status_code,
+            "headers": dict(response.headers),
+            "content": content,
+        }
+
+    @staticmethod
+    def exception_as_dict(exception):
+        if not exception:
+            return None
+
+        tb_string = "".join(traceback.format_tb(exception.__traceback__))
+
+        try:
+            args = json.dumps(exception.args)
+        except TypeError:
+            args = str(exception.args)
+
+        return {
+            "type": type(exception).__name__,
+            "str": str(exception),
+            "args": args,
+            "traceback": tb_string,
+        }
+
+
+def should_capture_request(request):
+    if not settings.DEBUG:
+        return False
+
+    if request.resolver_match and request.resolver_match.default_namespace == "dev":
+        return False
+
+    if request.path in settings.DEV_REQUESTS_IGNORE_PATHS:
+        return False
+
+    # This could be an attribute set on request or response
+    # or something more dynamic
+    if "querystats" in request.GET:
+        return False
+
+    return True
+
+
+class RequestsMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+        self.exception = None  # If an exception occurs, we want to remember it
+
+        got_request_exception.connect(self.store_exception)
+
+    def __call__(self, request):
+        # Process it first, so we know the resolver_match
+        response = self.get_response(request)
+
+        if should_capture_request(request):
+            RequestLog(
+                request=request, response=response, exception=self.exception
+            ).save()
+
+        return response
+
+    def store_exception(self, **kwargs):
+        """
+        The signal calls this at the right time,
+        so we can use sys.exxception to capture.
+        """
+        self.exception = sys.exception()

plain/dev/services.py

@@ -0,0 +1,80 @@
+import os
+import subprocess
+import time
+from importlib.util import find_spec
+from pathlib import Path
+
+import click
+from honcho.manager import Manager as HonchoManager
+
+from plain.runtime import APP_PATH
+
+from .pid import Pid
+from .utils import has_pyproject_toml
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+
+class Services:
+    @staticmethod
+    def get_services(root):
+        if not has_pyproject_toml(root):
+            return {}
+
+        with open(Path(root, "pyproject.toml"), "rb") as f:
+            pyproject = tomllib.load(f)
+
+        return (
+            pyproject.get("tool", {})
+            .get("plain", {})
+            .get("dev", {})
+            .get("services", {})
+        )
+
+    def __init__(self):
+        self.manager = HonchoManager()
+
+    def run(self):
+        services = self.get_services(APP_PATH.parent)
+        for name, data in services.items():
+            env = {
+                **os.environ,
+                "PYTHONUNBUFFERED": "true",
+                **data.get("env", {}),
+            }
+            self.manager.add_process(name, data["cmd"], env=env)
+
+        self.manager.loop()
+
+    def __enter__(self):
+        if not self.get_services(APP_PATH.parent):
+            # No-op if no services are defined
+            return
+
+        if Pid().exists():
+            click.secho("Services already running in `plain dev` command", fg="yellow")
+            return
+
+        print("Starting `plain dev services`")
+        self._subprocess = subprocess.Popen(
+            ["plain", "dev", "services"], cwd=APP_PATH.parent
+        )
+
+        if find_spec("plain.models"):
+            time.sleep(0.5)  # Give it a chance to hit on the first try
+            subprocess.check_call(["plain", "db", "wait"], env=os.environ)
+        else:
+            # A bit of a hack to wait for the services to start
+            time.sleep(3)
+
+    def __exit__(self, *args):
+        if not hasattr(self, "_subprocess"):
+            return
+
+        self._subprocess.terminate()
+
+        # Flush the buffer so the output doesn't spill over
+        self._subprocess.communicate()