fujin-cli 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

fujin/__main__.py

@@ -1,3 +1,4 @@
+import shlex
 import sys
 from pathlib import Path
 
@@ -6,8 +7,13 @@ 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
 
@@ -20,12 +26,22 @@ else:
 @cappa.command(help="Deployment of python web apps in a breeze :)")
 class Fujin:
     subcommands: cappa.Subcommands[
-        Up | Deploy | Redeploy | App | Server | ConfigCMD | Down
+        Init
+        | Up
+        | Deploy
+        | Redeploy
+        | App
+        | Server
+        | Proxy
+        | ConfigCMD
+        | Docs
+        | Down
+        | Rollback
+        | Prune
     ]
 
 
 def main():
-    # install(show_locals=True)
     alias_cmd = _parse_aliases()
     if alias_cmd:
         cappa.invoke(Fujin, argv=alias_cmd)
@@ -38,7 +54,7 @@ def _parse_aliases() -> list[str] | None:
     if not fujin_toml.exists():
         return
     data = tomllib.loads(fujin_toml.read_text())
-    aliases = data.get("aliases")
+    aliases: dict[str, str] = data.get("aliases")
     if not aliases:
         return
     if len(sys.argv) == 1:
@@ -46,7 +62,9 @@ def _parse_aliases() -> list[str] | None:
     if sys.argv[1] not in aliases:
         return
     extra_args = sys.argv[2:] if len(sys.argv) > 2 else []
-    return [*aliases.get(sys.argv[1]).split(), *extra_args]
+    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__":

fujin/commands/__init__.py

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

fujin/commands/_base.py

@@ -1,20 +1,25 @@
 import importlib
+from contextlib import contextmanager
 from dataclasses import dataclass
 from functools import cached_property
-from typing import Annotated
 
 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.host import Host
 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()
@@ -23,61 +28,49 @@ class BaseCommand:
     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)
 
-@dataclass
-class AppCommand(BaseCommand):
-    """
-    A command that provides access to the current host and allows interaction with it,
-    including configuring the web proxy and managing systemd services.
-    """
-
-    _host: Annotated[str | None, cappa.Arg(long="--host", value_name="HOST")]
-
-    # TODO: add info / details command that will list all services with their current status, if they are installed or running or stopped
+    @contextmanager
+    def connection(self):
+        with host_connection(host=self.config.host) as conn:
+            yield conn
 
-    @cached_property
-    def host(self) -> Host:
-        if not self._host:
-            host_config = next(
-                (hc for hc in self.config.hosts.values() if hc.default), None
-            )
-            if not host_config:
-                raise ImproperlyConfiguredError(
-                    "No default host has been configured, either pass --host or set the default in your fujin.toml file"
-                )
-        else:
-            host_config = next(
-                (
-                    hc
-                    for name, hc in self.config.hosts.items()
-                    if self._host in [name, hc.ip]
-                ),
-                None,
-            )
-        if not host_config:
-            raise cappa.Exit(f"Host {self._host} does not exist", code=1)
-        return Host(config=host_config)
+    @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(self) -> WebProxy:
+    def web_proxy_class(self) -> type[WebProxy]:
         module = importlib.import_module(self.config.webserver.type)
         try:
-            return getattr(module, "WebProxy")(host=self.host, config=self.config)
+            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(self) -> ProcessManager:
+    def process_manager_class(self) -> type[ProcessManager]:
         module = importlib.import_module(self.config.process_manager)
         try:
-            return getattr(module, "ProcessManager")(host=self.host, config=self.config)
+            return getattr(module, "ProcessManager")
         except KeyError as e:
             raise ImproperlyConfiguredError(
                 f"Missing ProcessManager class in {self.config.process_manager}"
             ) from e
 
-    @cached_property
-    def hook_manager(self) -> HookManager:
-        return HookManager(host=self.host, config=self.config)
+    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

@@ -4,11 +4,51 @@ from typing import Annotated
 
 import cappa
 
-from fujin.commands import AppCommand
+from fujin.commands import BaseCommand
 
 
 @cappa.command(help="Run application-related tasks")
-class App(AppCommand):
+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(
@@ -16,12 +56,13 @@ class App(AppCommand):
         command: str,
         interactive: Annotated[bool, cappa.Arg(default=False, short="-i")],
     ):
-        with self.host.cd_project_dir(self.config.app):
+        with self.app_environment() as conn:
             if interactive:
-                self.host.run(f"{self.config.app_bin} {command}", pty=interactive)
+                conn.run(f"{self.config.app_bin} {command}", pty=interactive, warn=True)
             else:
-                result = self.host.run(f"{self.config.app_bin} {command}", hide=True)
-                self.stdout.output(result)
+                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"
@@ -32,7 +73,8 @@ class App(AppCommand):
             str | None, cappa.Arg(help="Service name, no value means all")
         ] = None,
     ):
-        self.process_manager.start_services(name)
+        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]")
 
@@ -45,7 +87,8 @@ class App(AppCommand):
             str | None, cappa.Arg(help="Service name, no value means all")
         ] = None,
     ):
-        self.process_manager.restart_services(name)
+        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]")
 
@@ -58,7 +101,8 @@ class App(AppCommand):
             str | None, cappa.Arg(help="Service name, no value means all")
         ] = None,
     ):
-        self.process_manager.stop_services(name)
+        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]")
 
@@ -67,4 +111,28 @@ class App(AppCommand):
         self, name: Annotated[str, cappa.Arg(help="Service name")], follow: bool = False
     ):
         # TODO: flash out this more
-        self.process_manager.service_logs(name=name, follow=follow)
+        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

@@ -1,78 +1,52 @@
 from __future__ import annotations
 
-from pathlib import Path
-from typing import Annotated
-
 import cappa
-import tomli_w
 from rich.console import Console
-from rich.markdown import Markdown
 from rich.panel import Panel
 from rich.table import Table
 
 from fujin.commands import BaseCommand
-from fujin.config import tomllib
 
 
-@cappa.command(name="config", help="Manage application configuration")
+@cappa.command(name="config", help="Display your current configuration")
 class ConfigCMD(BaseCommand):
-
-    @cappa.command(help="Display the parsed configuration")
-    def show(self):
+    def __call__(self):
         console = Console()
-
         general_config = {
-            "app": self.config.app,
+            "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}' }}",
         }
-        formatted_text = "\n".join(
+        general_config_text = "\n".join(
             f"[bold green]{key}:[/bold green] {value}"
             for key, value in general_config.items()
         )
         console.print(
             Panel(
-                formatted_text,
+                general_config_text,
                 title="General Configuration",
                 border_style="green",
                 width=100,
             )
         )
 
-        # Hosts Table with headers and each dictionary on its own line
-        hosts_table = Table(title="Hosts", header_style="bold cyan")
-        hosts_table.add_column("Host", style="dim")
-        hosts_table.add_column("ip")
-        hosts_table.add_column("domain_name")
-        hosts_table.add_column("user")
-        hosts_table.add_column("password_env")
-        hosts_table.add_column("projects_dr")
-        hosts_table.add_column("ssh_port")
-        hosts_table.add_column("key_filename")
-        hosts_table.add_column("envfile")
-        hosts_table.add_column("primary", justify="center")
-
-        for host_name, host in self.config.hosts.items():
-            host_dict = host.to_dict()
-            hosts_table.add_row(
-                host_name,
-                host_dict["ip"],
-                host_dict["domain_name"],
-                host_dict["user"],
-                str(host_dict["password_env"] or "N/A"),
-                host_dict["projects_dir"],
-                str(host_dict["ssh_port"]),
-                str(host_dict["_key_filename"] or "N/A"),
-                host_dict["_envfile"],
-                "[green]Yes[/green]" if host_dict["default"] else "[red]No[/red]",
+        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,
             )
-
-        console.print(hosts_table)
+        )
 
         # Processes Table with headers and each dictionary on its own line
         processes_table = Table(title="Processes", header_style="bold cyan")
@@ -89,86 +63,3 @@ class ConfigCMD(BaseCommand):
             aliases_table.add_row(alias, command)
 
         console.print(aliases_table)
-
-    @cappa.command(help="Generate a sample configuration file")
-    def init(
-        self,
-        profile: Annotated[
-            str, cappa.Arg(choices=["simple", "falco"], short="-p", long="--profile")
-        ] = "simple",
-    ):
-        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}
-        config = profile_to_func[profile]()
-        fujin_toml.write_text(tomli_w.dumps(config))
-        self.stdout.output(
-            "[green]Sample configuration file generated successfully![/green]"
-        )
-
-    @cappa.command(help="Config documentation")
-    def docs(self):
-        self.stdout.output(Markdown(docs))
-
-
-def simple_config() -> dict:
-    app = Path().resolve().stem.replace("-", "_").replace(" ", "_").lower()
-
-    config = {
-        "app": app,
-        "version": "0.1.0",
-        "build_command": "uv build",
-        "distfile": f"dist/{app}-{{version}}-py3-none-any.whl",
-        "webserver": {
-            "upstream": "localhost:8000",
-            "type": "fujin.proxies.caddy",
-        },
-        "hooks": {"pre_deploy": f".venv/bin/{app} migrate"},
-        "processes": {"web": f".venv/bin/gunicorn {app}.wsgi:app --bind 0.0.0.0:8000"},
-        "aliases": {"shell": "server exec -i bash"},
-        "hosts": {
-            "primary": {
-                "ip": "127.0.0.1",
-                "user": "root",
-                "domain_name": f"{app}.com",
-                "envfile": ".env.prod",
-                "default": True,
-            }
-        },
-    }
-    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)
-        if pyproject.get("project", {}).get("version"):
-            # fujin will read the version itself from the pyproject
-            config.pop("version")
-    return config
-
-
-def falco_config() -> dict:
-    config = simple_config()
-    config.update(
-        {
-            "hooks": {"pre_deploy": f".venv/bin/{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 -i bash",
-            },
-        }
-    )
-    return config
-
-
-docs = """
-# Fujin Configuration
-"""

fujin/commands/deploy.py

@@ -4,51 +4,113 @@ import subprocess
 
 import cappa
 
-from fujin.commands import AppCommand
+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(AppCommand):
-
+class Deploy(BaseCommand):
     def __call__(self):
-        try:
-            subprocess.run(self.config.build_command.split(), check=True)
-        except subprocess.CalledProcessError as e:
-            raise cappa.Exit(f"build command failed: {e}", code=1) from e
+        self.build_app()
 
-        self.host.make_project_dir(project_name=self.config.app)
-        self.transfer_files()
-        self.install_project()
-        self.hook_manager.pre_deploy()
+        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)
 
-        self.process_manager.install_services()
-        self.process_manager.reload_configuration()
-        self.process_manager.restart_services()
-
-        self.web_proxy.setup()
+        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.host.config.domain_name}[/blue]"
+            f"[blue]Access the deployed project at: https://{self.config.host.domain_name}[/blue]"
         )
 
-    def transfer_files(self):
-        if not self.host.config.envfile.exists():
-            raise cappa.Exit(f"{self.host.config.envfile} not found", code=1)
+    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)
-        project_dir = self.host.project_dir(self.config.app)
-        self.host.put(str(self.config.requirements), f"{project_dir}/requirements.txt")
-        self.host.put(str(self.host.config.envfile), f"{project_dir}/.env")
-        self.host.put(
-            str(self.config.distfile), f"{project_dir}/{self.config.distfile.name}"
+        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}",
         )
-        self.host.run(f"echo {self.config.python_version} > .python-version")
+        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 install_project(self):
-        with self.host.cd_project_dir(self.config.app):
-            self.host.run_uv("venv")
-            self.host.run_uv("pip install -r requirements.txt")
-            self.host.run_uv(f"pip install {self.config.distfile.name}")
+    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)