fujin-cli 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

fujin/__init__.py

@@ -1,2 +0,0 @@
-def main() -> None:
-    print("Hello from fujin!")

fujin/__main__.py

@@ -0,0 +1,71 @@
+import shlex
+import sys
+from pathlib import Path
+
+import cappa
+
+from fujin.commands.app import App
+from fujin.commands.config import ConfigCMD
+from fujin.commands.deploy import Deploy
+from fujin.commands.docs import Docs
+from fujin.commands.down import Down
+from fujin.commands.init import Init
+from fujin.commands.proxy import Proxy
+from fujin.commands.prune import Prune
+from fujin.commands.redeploy import Redeploy
+from fujin.commands.rollback import Rollback
+from fujin.commands.server import Server
+from fujin.commands.up import Up
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+
+@cappa.command(help="Deployment of python web apps in a breeze :)")
+class Fujin:
+    subcommands: cappa.Subcommands[
+        Init
+        | Up
+        | Deploy
+        | Redeploy
+        | App
+        | Server
+        | Proxy
+        | ConfigCMD
+        | Docs
+        | Down
+        | Rollback
+        | Prune
+    ]
+
+
+def main():
+    alias_cmd = _parse_aliases()
+    if alias_cmd:
+        cappa.invoke(Fujin, argv=alias_cmd)
+    else:
+        cappa.invoke(Fujin)
+
+
+def _parse_aliases() -> list[str] | None:
+    fujin_toml = Path("fujin.toml")
+    if not fujin_toml.exists():
+        return
+    data = tomllib.loads(fujin_toml.read_text())
+    aliases: dict[str, str] = data.get("aliases")
+    if not aliases:
+        return
+    if len(sys.argv) == 1:
+        return
+    if sys.argv[1] not in aliases:
+        return
+    extra_args = sys.argv[2:] if len(sys.argv) > 2 else []
+    aliased_cmd = aliases.get(sys.argv[1])
+    subcommand, args = aliased_cmd.split(" ", 1)
+    return [subcommand, *extra_args, *shlex.split(args, posix=True)]
+
+
+if __name__ == "__main__":
+    main()

fujin/commands/__init__.py

@@ -0,0 +1,2 @@
+from ._base import BaseCommand  # noqa
+from ._base import BaseCommand  # noqa

fujin/commands/_base.py

@@ -0,0 +1,76 @@
+import importlib
+from contextlib import contextmanager
+from dataclasses import dataclass
+from functools import cached_property
+
+import cappa
+
+from fujin.config import Config
+from fujin.connection import host_connection, Connection
+from fujin.errors import ImproperlyConfiguredError
+from fujin.hooks import HookManager
+from fujin.process_managers import ProcessManager
+from fujin.proxies import WebProxy
+
+
+@dataclass
+class BaseCommand:
+    """
+    A command that provides access to the host config and provide a connection to interact with it,
+    including configuring the web proxy and managing systemd services.
+    """
+
+    @cached_property
+    def config(self) -> Config:
+        return Config.read()
+
+    @cached_property
+    def stdout(self) -> cappa.Output:
+        return cappa.Output()
+
+    @cached_property
+    def app_dir(self) -> str:
+        return self.config.host.get_app_dir(app_name=self.config.app_name)
+
+    @contextmanager
+    def connection(self):
+        with host_connection(host=self.config.host) as conn:
+            yield conn
+
+    @contextmanager
+    def app_environment(self) -> Connection:
+        with self.connection() as conn:
+            with conn.cd(self.app_dir):
+                with conn.prefix("source .appenv"):
+                    yield conn
+
+    @cached_property
+    def web_proxy_class(self) -> type[WebProxy]:
+        module = importlib.import_module(self.config.webserver.type)
+        try:
+            return getattr(module, "WebProxy")
+        except KeyError as e:
+            raise ImproperlyConfiguredError(
+                f"Missing WebProxy class in {self.config.webserver.type}"
+            ) from e
+
+    def create_web_proxy(self, conn: Connection) -> WebProxy:
+        return self.web_proxy_class.create(conn=conn, config=self.config)
+
+    @cached_property
+    def process_manager_class(self) -> type[ProcessManager]:
+        module = importlib.import_module(self.config.process_manager)
+        try:
+            return getattr(module, "ProcessManager")
+        except KeyError as e:
+            raise ImproperlyConfiguredError(
+                f"Missing ProcessManager class in {self.config.process_manager}"
+            ) from e
+
+    def create_process_manager(self, conn: Connection) -> ProcessManager:
+        return self.process_manager_class.create(conn=conn, config=self.config)
+
+    def create_hook_manager(self, conn: Connection) -> HookManager:
+        return HookManager(
+            conn=conn, hooks=self.config.hooks, app_name=self.config.app_name
+        )

fujin/commands/app.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import cappa
+
+from fujin.commands import BaseCommand
+
+
+@cappa.command(help="Run application-related tasks")
+class App(BaseCommand):
+    @cappa.command(help="Display information about the application")
+    def info(self):
+        with self.app_environment() as conn:
+            remote_version = (
+                conn.run("head -n 1 .versions", warn=True, hide=True).stdout.strip()
+                or "N/A"
+            )
+            rollback_targets = conn.run(
+                "sed -n '2,$p' .versions", warn=True, hide=True
+            ).stdout.strip()
+            infos = {
+                "app_name": self.config.app_name,
+                "app_dir": self.app_dir,
+                "app_bin": self.config.app_bin,
+                "local_version": self.config.version,
+                "remote_version": remote_version,
+                "python_version": self.config.python_version,
+                "rollback_targets": ", ".join(rollback_targets.split("\n"))
+                if rollback_targets
+                else "N/A",
+            }
+            pm = self.create_process_manager(conn)
+            services: dict[str, bool] = pm.is_active()
+
+        infos_text = "\n".join(f"{key}: {value}" for key, value in infos.items())
+        from rich.table import Table
+
+        table = Table(title="", header_style="bold cyan")
+        table.add_column("Service", style="")
+        table.add_column("Running?")
+        for service, is_active in services.items():
+            table.add_row(
+                service,
+                "[bold green]Yes[/bold green]"
+                if is_active
+                else "[bold red]No[/bold red]",
+            )
+
+        self.stdout.output(infos_text)
+        self.stdout.output(table)
+
+    @cappa.command(help="Run an arbitrary command via the application binary")
+    def exec(
+        self,
+        command: str,
+        interactive: Annotated[bool, cappa.Arg(default=False, short="-i")],
+    ):
+        with self.app_environment() as conn:
+            if interactive:
+                conn.run(f"{self.config.app_bin} {command}", pty=interactive, warn=True)
+            else:
+                self.stdout.output(
+                    conn.run(f"{self.config.app_bin} {command}", hide=True).stdout
+                )
+
+    @cappa.command(
+        help="Start the specified service or all services if no name is provided"
+    )
+    def start(
+        self,
+        name: Annotated[
+            str | None, cappa.Arg(help="Service name, no value means all")
+        ] = None,
+    ):
+        with self.app_environment() as conn:
+            self.create_process_manager(conn).start_services(name)
+        msg = f"{name} Service" if name else "All Services"
+        self.stdout.output(f"[green]{msg} started successfully![/green]")
+
+    @cappa.command(
+        help="Restart the specified service or all services if no name is provided"
+    )
+    def restart(
+        self,
+        name: Annotated[
+            str | None, cappa.Arg(help="Service name, no value means all")
+        ] = None,
+    ):
+        with self.app_environment() as conn:
+            self.create_process_manager(conn).restart_services(name)
+        msg = f"{name} Service" if name else "All Services"
+        self.stdout.output(f"[green]{msg} restarted successfully![/green]")
+
+    @cappa.command(
+        help="Stop the specified service or all services if no name is provided"
+    )
+    def stop(
+        self,
+        name: Annotated[
+            str | None, cappa.Arg(help="Service name, no value means all")
+        ] = None,
+    ):
+        with self.app_environment() as conn:
+            self.create_process_manager(conn).stop_services(name)
+        msg = f"{name} Service" if name else "All Services"
+        self.stdout.output(f"[green]{msg} stopped successfully![/green]")
+
+    @cappa.command(help="Show logs for the specified service")
+    def logs(
+        self, name: Annotated[str, cappa.Arg(help="Service name")], follow: bool = False
+    ):
+        # TODO: flash out this more
+        with self.app_environment() as conn:
+            self.create_process_manager(conn).service_logs(name=name, follow=follow)
+
+    @cappa.command(
+        name="export-config",
+        help="Export the service configuration files locally to the .fujin directory",
+    )
+    def export_config(
+        self,
+        overwrite: Annotated[
+            bool, cappa.Arg(help="overwrite any existing config file")
+        ] = False,
+    ):
+        with self.connection() as conn:
+            for filename, content in self.create_process_manager(
+                conn
+            ).get_configuration_files(ignore_local=True):
+                local_config = self.config.local_config_dir / filename
+                if local_config.exists() and not overwrite:
+                    self.stdout.output(
+                        f"[blue]Skipping {filename}, file already exists. Use --overwrite to replace it.[/blue]"
+                    )
+                    continue
+                local_config.write_text(content)
+                self.stdout.output(f"[green]{filename} exported successfully![/green]")

fujin/commands/config.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import cappa
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from fujin.commands import BaseCommand
+
+
+@cappa.command(name="config", help="Display your current configuration")
+class ConfigCMD(BaseCommand):
+    def __call__(self):
+        console = Console()
+        general_config = {
+            "app": self.config.app_name,
+            "app_bin": self.config.app_bin,
+            "version": self.config.version,
+            "python_version": self.config.python_version,
+            "build_command": self.config.build_command,
+            "release_command": self.config.release_command,
+            "distfile": self.config.distfile,
+            "requirements": self.config.requirements,
+            "webserver": f"{{ upstream = '{self.config.webserver.upstream}', type = '{self.config.webserver.type}' }}",
+        }
+        general_config_text = "\n".join(
+            f"[bold green]{key}:[/bold green] {value}"
+            for key, value in general_config.items()
+        )
+        console.print(
+            Panel(
+                general_config_text,
+                title="General Configuration",
+                border_style="green",
+                width=100,
+            )
+        )
+
+        host_config_text = "\n".join(
+            f"[dim]{key}:[/dim] {value}"
+            for key, value in self.config.host.to_dict().items()
+        )
+        console.print(
+            Panel(
+                host_config_text,
+                title="Host Configuration",
+                width=100,
+            )
+        )
+
+        # Processes Table with headers and each dictionary on its own line
+        processes_table = Table(title="Processes", header_style="bold cyan")
+        processes_table.add_column("Name", style="dim")
+        processes_table.add_column("Command")
+        for name, command in self.config.processes.items():
+            processes_table.add_row(name, command)
+        console.print(processes_table)
+
+        aliases_table = Table(title="Aliases", header_style="bold cyan")
+        aliases_table.add_column("Alias", style="dim")
+        aliases_table.add_column("Command")
+        for alias, command in self.config.aliases.items():
+            aliases_table.add_row(alias, command)
+
+        console.print(aliases_table)

fujin/commands/deploy.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import subprocess
+
+import cappa
+
+from fujin.commands import BaseCommand
+from fujin.connection import Connection
+
+
+@cappa.command(
+    help="Deploy the project by building, transferring files, installing, and configuring services"
+)
+class Deploy(BaseCommand):
+    def __call__(self):
+        self.build_app()
+
+        with self.connection() as conn:
+            conn.run(f"mkdir -p {self.app_dir}")
+            with conn.cd(self.app_dir):
+                self.create_hook_manager(conn).pre_deploy()
+                self.transfer_files(conn)
+
+        with self.app_environment() as conn:
+            process_manager = self.create_process_manager(conn)
+            self.install_project(conn)
+            self.release(conn)
+            process_manager.install_services()
+            process_manager.reload_configuration()
+            process_manager.restart_services()
+            self.create_web_proxy(conn).setup()
+            self.update_version_history(conn)
+            self.prune_assets(conn)
+            self.create_hook_manager(conn).post_deploy()
+        self.stdout.output("[green]Project deployment completed successfully![/green]")
+        self.stdout.output(
+            f"[blue]Access the deployed project at: https://{self.config.host.domain_name}[/blue]"
+        )
+
+    def build_app(self) -> None:
+        try:
+            subprocess.run(self.config.build_command, check=True, shell=True)
+        except subprocess.CalledProcessError as e:
+            raise cappa.Exit(f"build command failed: {e}", code=1) from e
+
+    @property
+    def versioned_assets_dir(self) -> str:
+        return f"{self.app_dir}/v{self.config.version}"
+
+    def transfer_files(self, conn: Connection, skip_requirements: bool = False):
+        if not self.config.host.envfile.exists():
+            raise cappa.Exit(f"{self.config.host.envfile} not found", code=1)
+
+        if not self.config.requirements.exists():
+            raise cappa.Exit(f"{self.config.requirements} not found", code=1)
+        conn.put(str(self.config.host.envfile), f"{self.app_dir}/.env")
+        conn.run(f"mkdir -p {self.versioned_assets_dir}")
+        if not skip_requirements:
+            conn.put(
+                str(self.config.requirements),
+                f"{self.versioned_assets_dir}/requirements.txt",
+            )
+        distfile_path = self.config.get_distfile_path()
+        conn.put(
+            str(distfile_path),
+            f"{self.versioned_assets_dir}/{distfile_path.name}",
+        )
+        appenv = f"""
+set -a  # Automatically export all variables
+source .env
+set +a  # Stop automatic export
+export UV_COMPILE_BYTECODE=1
+export UV_PYTHON=python{self.config.python_version}
+export PATH=".venv/bin:$PATH"
+"""
+        conn.run(f"echo '{appenv.strip()}' > .appenv")
+
+    def install_project(
+        self, conn: Connection, version: str | None = None, *, skip_setup: bool = False
+    ):
+        if self.config.skip_project_install:
+            return
+        version = version or self.config.version
+        versioned_assets_dir = f"{self.app_dir}/v{version}"
+        if not skip_setup:
+            conn.run("uv venv")
+            conn.run(f"uv pip install -r {versioned_assets_dir}/requirements.txt")
+        conn.run(
+            f"uv pip install {versioned_assets_dir}/{self.config.get_distfile_path(version).name}"
+        )
+
+    def release(self, conn: Connection):
+        if self.config.release_command:
+            conn.run(f"source .env && {self.config.release_command}")
+
+    def update_version_history(self, conn: Connection):
+        result = conn.run("head -n 1 .versions", warn=True, hide=True).stdout.strip()
+        if result == self.config.version:
+            return
+        if result == "":
+            conn.run(f"echo '{self.config.version}' > .versions")
+        else:
+            conn.run(f"sed -i '1i {self.config.version}' .versions")
+
+    def prune_assets(self, conn: Connection):
+        if not self.config.versions_to_keep:
+            return
+        result = conn.run(
+            f"sed -n '{self.config.versions_to_keep + 1},$p' .versions", hide=True
+        ).stdout.strip()
+        result_list = result.split("\n")
+        if result == "":
+            return
+        to_prune = [f"{self.app_dir}/v{v}" for v in result_list]
+        conn.run(f"rm -r {' '.join(to_prune)}", warn=True)
+        conn.run(f"sed -i '{self.config.versions_to_keep + 1},$d' .versions", warn=True)

fujin/commands/docs.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import cappa
+
+import fujin.config
+from fujin.commands import BaseCommand
+
+
+@cappa.command(help="Configuration documentation")
+class Docs(BaseCommand):
+    def __call__(self):
+        docs = f"""
+            # Fujin Configuration
+            {fujin.config.__doc__}
+            """
+        self.stdout.output(docs)

fujin/commands/down.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Annotated
+
+import cappa
+from rich.prompt import Confirm
+
+from fujin.commands import BaseCommand
+
+
+@cappa.command(
+    help="Tear down the project by stopping services and cleaning up resources"
+)
+@dataclass
+class Down(BaseCommand):
+    full: Annotated[
+        bool,
+        cappa.Arg(
+            short="-f",
+            long="--full",
+            help="Stop and uninstall proxy as part of teardown",
+        ),
+    ] = False
+
+    def __call__(self):
+        try:
+            confirm = Confirm.ask(
+                f"""[red]You are about to delete all project files, stop all services, and remove all configurations on the host {self.config.host.ip} for the project {self.config.app_name}. Any assets in your project folder will be lost (sqlite not in there ?). Are you sure you want to proceed? This action is irreversible.[/red]""",
+            )
+        except KeyboardInterrupt as e:
+            raise cappa.Exit("Teardown aborted", code=0)
+        if not confirm:
+            return
+        with self.connection() as conn:
+            hook_manager = self.create_hook_manager(conn)
+            hook_manager.pre_teardown()
+            process_manager = self.create_process_manager(conn)
+            conn.run(f"rm -rf {self.app_dir}")
+            self.create_web_proxy(conn).teardown()
+            process_manager.uninstall_services()
+            process_manager.reload_configuration()
+            if self.full:
+                self.create_web_proxy(conn).uninstall()
+            hook_manager.post_teardown()
+            self.stdout.output(
+                "[green]Project teardown completed successfully![/green]"
+            )

fujin/commands/init.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import cappa
+import tomli_w
+
+from fujin.commands import BaseCommand
+from fujin.config import tomllib
+
+
+@cappa.command(help="Generate a sample configuration file")
+class Init(BaseCommand):
+    profile: Annotated[
+        str, cappa.Arg(choices=["simple", "falco"], short="-p", long="--profile")
+    ] = "simple"
+
+    def __call__(self):
+        fujin_toml = Path("fujin.toml")
+        if fujin_toml.exists():
+            raise cappa.Exit("fujin.toml file already exists", code=1)
+        profile_to_func = {"simple": simple_config, "falco": falco_config}
+        app_name = Path().resolve().stem.replace("-", "_").replace(" ", "_").lower()
+        config = profile_to_func[self.profile](app_name)
+        if not Path(".python-version").exists():
+            config["python_version"] = "3.12"
+        pyproject_toml = Path("pyproject.toml")
+        if pyproject_toml.exists():
+            pyproject = tomllib.loads(pyproject_toml.read_text())
+            config["app"] = pyproject.get("project", {}).get("name", app_name)
+            if pyproject.get("project", {}).get("version"):
+                # fujin will read the version itself from the pyproject
+                config.pop("version")
+        fujin_toml.write_text(tomli_w.dumps(config))
+        self.stdout.output(
+            "[green]Sample configuration file generated successfully![/green]"
+        )
+
+
+def simple_config(app_name) -> dict:
+    return {
+        "app": app_name,
+        "version": "0.1.0",
+        "build_command": "uv build && uv pip compile pyproject.toml -o requirements.txt",
+        "distfile": f"dist/{app_name}-{{version}}-py3-none-any.whl",
+        "webserver": {
+            "upstream": "localhost:8000",
+            "type": "fujin.proxies.caddy",
+        },
+        "release_command": f"{app_name} migrate",
+        "processes": {
+            "web": f".venv/bin/gunicorn {app_name}.wsgi:app --bind 0.0.0.0:8000"
+        },
+        "aliases": {"shell": "server exec --appenv -i bash"},
+        "host": {
+            "ip": "127.0.0.1",
+            "user": "root",
+            "domain_name": f"{app_name}.com",
+            "envfile": ".env.prod",
+        },
+    }
+
+
+def falco_config(app_name: str) -> dict:
+    config = simple_config(app_name)
+    config.update(
+        {
+            "release_command": f"{config['app']} setup",
+            "processes": {
+                "web": f".venv/bin/{config['app']} prodserver",
+                "worker": f".venv/bin/{config['app']} qcluster",
+            },
+            "aliases": {
+                "console": "app exec -i shell_plus",
+                "dbconsole": "app exec -i dbshell",
+                "print_settings": "app exec print_settings --format=pprint",
+                "shell": "server exec --appenv -i bash",
+            },
+        }
+    )
+    return config