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

fujin/commands/down.py

@@ -1,30 +1,48 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import Annotated
 
 import cappa
-from rich.prompt import Prompt
+from rich.prompt import Confirm
 
-from fujin.commands import AppCommand
+from fujin.commands import BaseCommand
 
 
 @cappa.command(
     help="Tear down the project by stopping services and cleaning up resources"
 )
 @dataclass
-class Down(AppCommand):
+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):
-        confirm = Prompt.ask(
-            f"""[red]You are about to delete all project files, stop all services, and remove all configurations on the host {self.host} for the project {self.config.app}. 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]""",
-            choices=["no", "yes"],
-            default="no",
-        )
-        if confirm == "no":
+        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
-        project_dir = self.host.project_dir(self.config.app)
-        self.host.run(f"rm -rf {project_dir}")
-        self.web_proxy.teardown()
-        self.process_manager.uninstall_services()
-        self.process_manager.reload_configuration()
-        self.stdout.output("[green]Project teardown completed successfully![/green]")
+        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

fujin/commands/proxy.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass
+from typing import Annotated
+
+import cappa
+
+from fujin.commands import BaseCommand
+
+
+@cappa.command(help="Manage web proxy.")
+@dataclass
+class Proxy(BaseCommand):
+    @cappa.command(help="Install the proxy on the remote host")
+    def install(self):
+        with self.connection() as conn:
+            self.create_web_proxy(conn).install()
+
+    @cappa.command(help="Uninstall the proxy from the remote host")
+    def uninstall(self):
+        with self.connection() as conn:
+            self.create_web_proxy(conn).uninstall()
+
+    @cappa.command(help="Start the proxy on the remote host")
+    def start(self):
+        with self.connection() as conn:
+            self.create_web_proxy(conn).start()
+        self.stdout.output("[green]Proxy started successfully![/green]")
+
+    @cappa.command(help="Stop the proxy on the remote host")
+    def stop(self):
+        with self.connection() as conn:
+            self.create_web_proxy(conn).stop()
+        self.stdout.output("[green]Proxy stopped successfully![/green]")
+
+    @cappa.command(help="Restart the proxy on the remote host")
+    def restart(self):
+        with self.connection() as conn:
+            self.create_web_proxy(conn).restart()
+        self.stdout.output("[green]Proxy restarted successfully![/green]")
+
+    @cappa.command(help="Check the status of the proxy on the remote host")
+    def status(self):
+        with self.connection() as conn:
+            self.create_web_proxy(conn).status()
+
+    @cappa.command(help="View the logs of the proxy on the remote host")
+    def logs(self):
+        with self.connection() as conn:
+            self.create_web_proxy(conn).logs()
+
+    @cappa.command(
+        name="export-config",
+        help="Export the proxy configuration file 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:
+            proxy = self.create_web_proxy(conn)
+            if proxy.config_file.exists() and not overwrite:
+                self.stdout.output(
+                    f"[blue]{proxy.config_file} already exists, use --overwrite to overwrite it content.[/blue]"
+                )
+            else:
+                self.config.local_config_dir.mkdir(exist_ok=True)
+                proxy.export_config()
+                self.stdout.output(
+                    f"[green]Config file successfully to {proxy.config_file}[/green]"
+                )

fujin/commands/prune.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+from typing import Annotated
+
+import cappa
+from rich.prompt import Confirm
+
+from fujin.commands import BaseCommand
+
+
+@cappa.command(
+    help="Prune old version artifacts, keeping only the specified number of recent versions"
+)
+@dataclass
+class Prune(BaseCommand):
+    keep: Annotated[
+        int,
+        cappa.Arg(
+            short="-k",
+            long="--keep",
+            help="Number of version artifacts to retain (minimum 1)",
+        ),
+    ] = 2
+
+    def __call__(self):
+        if self.keep < 1:
+            raise cappa.Exit("The minimum value for the --keep option is 1", code=1)
+        with self.connection() as conn, conn.cd(self.app_dir):
+            result = conn.run(
+                f"sed -n '{self.keep + 1},$p' .versions", hide=True
+            ).stdout.strip()
+            result_list = result.split("\n")
+            if result == "":
+                self.stdout.output("[blue]No versions to prune[/blue]")
+                return
+            if not Confirm.ask(
+                f"[red]The following versions will be permanently deleted: {', '.join(result_list)}. This action is irreversible. Are you sure you want to proceed?[/red]"
+            ):
+                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.keep + 1},$d' .versions", warn=True)
+            self.stdout.output("[green]Pruning completed successfully[/green]")

fujin/commands/redeploy.py

@@ -1,19 +1,48 @@
 from __future__ import annotations
 
-import cappa
+import hashlib
 
-from fujin.commands import AppCommand
+import cappa
 
+from fujin.commands import BaseCommand
 from .deploy import Deploy
 
 
 @cappa.command(help="Redeploy the application to apply code and environment changes")
-class Redeploy(AppCommand):
-
+class Redeploy(BaseCommand):
     def __call__(self):
-        deploy = Deploy(_host=self._host)
-        deploy.transfer_files()
-        deploy.install_project()
-        self.hook_manager.pre_deploy()
-        self.process_manager.restart_services()
-        self.stdout.output("[green]Redeployment completed successfully![/green]")
+        deploy = Deploy()
+        deploy.build_app()
+        local_requirements = hashlib.md5(
+            self.config.requirements.read_bytes()
+        ).hexdigest()
+        with self.app_environment() as conn:
+            hook_manager = self.create_hook_manager(conn)
+            hook_manager.pre_deploy()
+            current_host_version = conn.run(
+                "head -n 1 .versions", warn=True, hide=True
+            ).stdout.strip()
+            try:
+                host_requirements = (
+                    conn.run(
+                        f"md5sum v{current_host_version}/requirements.txt",
+                        warn=True,
+                        hide=True,
+                    )
+                    .stdout.strip()
+                    .split()[0]
+                )
+                skip_requirements = host_requirements == local_requirements
+            except IndexError:
+                skip_requirements = False
+            deploy.transfer_files(conn, skip_requirements=skip_requirements)
+            if skip_requirements and current_host_version != self.config.version:
+                conn.run(
+                    f"cp v{current_host_version}/requirements.txt  {deploy.versioned_assets_dir}/requirements.txt "
+                )
+            deploy.install_project(conn, skip_setup=skip_requirements)
+            deploy.release(conn)
+            self.create_process_manager(conn).restart_services()
+            deploy.update_version_history(conn)
+            hook_manager.post_deploy()
+            self.stdout.output("[green]Redeployment completed successfully![/green]")

fujin/commands/rollback.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+
+import cappa
+from rich.prompt import Prompt, Confirm
+
+from fujin.commands import BaseCommand
+from fujin.commands.deploy import Deploy
+
+
+@cappa.command(help="Rollback application to a previous version")
+@dataclass
+class Rollback(BaseCommand):
+    def __call__(self):
+        with self.app_environment() as conn:
+            result = conn.run(
+                "sed -n '2,$p' .versions", warn=True, hide=True
+            ).stdout.strip()
+            if not result:
+                self.stdout.output("[blue]No rollback targets available")
+                return
+            versions: list[str] = result.split("\n")
+            try:
+                version = Prompt.ask(
+                    "Enter the version you want to rollback to:",
+                    choices=versions,
+                    default=versions[0],
+                )
+            except KeyboardInterrupt as e:
+                raise cappa.Exit("Rollback aborted by user.", code=0) from e
+
+            current_app_version = conn.run(
+                "head -n 1 .versions", warn=True, hide=True
+            ).stdout.strip()
+            versions_to_clean = [current_app_version] + versions[
+                : versions.index(version)
+            ]
+            confirm = Confirm.ask(
+                f"[blue]Rolling back to v{version} will permanently delete versions {', '.join(versions_to_clean)}. This action is irreversible. Are you sure you want to proceed?[/blue]"
+            )
+            if not confirm:
+                return
+            deploy = Deploy()
+            deploy.install_project(conn, version)
+            self.create_process_manager(conn).restart_services()
+            conn.run(f"rm -r {' '.join(f'v{v}' for v in versions_to_clean)}", warn=True)
+            conn.run(f"sed -i '1,/{version}/{{/{version}/!d}}' .versions", warn=True)
+            self.stdout.output(
+                f"[green]Rollback to version {version} from {current_app_version} completed successfully![/green]"
+            )

fujin/commands/secrets.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+import cappa
+
+from fujin.commands import BaseCommand
+
+
+@cappa.command(help="")
+@dataclass
+class Secrets(BaseCommand):
+    pass

fujin/commands/server.py

@@ -1,30 +1,47 @@
 from __future__ import annotations
 
+import secrets
+from functools import partial
 from typing import Annotated
 
 import cappa
 
-from fujin.commands import AppCommand
+from fujin.commands import BaseCommand
 
 
 @cappa.command(help="Manage server operations")
-class Server(AppCommand):
-
+class Server(BaseCommand):
     @cappa.command(help="Display information about the host system")
     def info(self):
-        self.stdout.output(self.host.sudo("cat /etc/os-release", hide="out"))
+        with self.connection() as conn:
+            result = conn.run(f"command -v fastfetch", warn=True, hide=True)
+            if result.ok:
+                conn.run("fastfetch", pty=True)
+            else:
+                self.stdout.output(conn.run("cat /etc/os-release", hide=True).stdout)
 
     @cappa.command(help="Setup uv, web proxy, and install necessary dependencies")
     def bootstrap(self):
-        self.host.sudo("apt update")
-        self.host.sudo("apt upgrade -y")
-        self.host.sudo("apt install -y sqlite3 curl")
-        result = self.host.run("source $HOME/.cargo/env && command -v uv", warn=True)
-        if not result.ok:
-            self.host.run("curl -LsSf https://astral.sh/uv/install.sh | sh")
-            self.host.run_uv("tool update-shell")
-        self.web_proxy.install()
-        self.stdout.output("[green]Server bootstrap completed successfully![/green]")
+        with self.connection() as conn:
+            hook_manager = self.create_hook_manager(conn)
+            hook_manager.pre_bootstrap()
+            conn.run("sudo apt update && sudo apt upgrade -y", pty=True)
+            conn.run("sudo apt install -y sqlite3 curl rsync", pty=True)
+            result = conn.run("command -v uv", warn=True)
+            if not result.ok:
+                conn.run("curl -LsSf https://astral.sh/uv/install.sh | sh")
+                conn.run("uv tool update-shell")
+            conn.run("uv tool install fastfetch-bin-edge")
+            self.create_web_proxy(conn).install()
+            hook_manager.post_bootstrap()
+            self.stdout.output(
+                "[green]Server bootstrap completed successfully![/green]"
+            )
+
+    @cappa.command(help="Stop and uninstall the web proxy")
+    def uninstall_proxy(self):
+        with self.connection() as conn:
+            self.create_web_proxy(conn).uninstall()
 
     @cappa.command(
         help="Execute an arbitrary command on the server, optionally in interactive mode"
@@ -33,25 +50,43 @@ class Server(AppCommand):
         self,
         command: str,
         interactive: Annotated[bool, cappa.Arg(default=False, short="-i")],
+        appenv: Annotated[
+            bool,
+            cappa.Arg(
+                default=False,
+                long="--appenv",
+                help="Change to app directory and enable app environment",
+            ),
+        ],
     ):
-        if interactive:
-            self.host.run(command, pty=interactive)
-        else:
-            result = self.host.run(command, hide=True)
-            self.stdout.output(result)
+        context = self.app_environment() if appenv else self.connection()
+        with context as conn:
+            if interactive:
+                conn.run(command, pty=interactive, warn=True)
+            else:
+                self.stdout.output(conn.run(command, hide=True).stdout)
 
     @cappa.command(
         name="create-user", help="Create a new user with sudo and ssh access"
     )
-    def create_user(self, name: str):
-        # TODO not working right now, ssh key not working
-        self.host.sudo(f"adduser --disabled-password --gecos '' {name}")
-        self.host.sudo(f"mkdir -p /home/{name}/.ssh")
-        self.host.sudo(f"cp ~/.ssh/authorized_keys /home/{name}/.ssh/")
-        self.host.sudo(f"chown -R {name}:{name} /home/{name}/.ssh")
-        self.host.sudo(f"chmod 700 /home/{name}/.ssh")
-        self.host.sudo(f"chmod 600 /home/{name}/.ssh/authorized_keys")
-        self.host.sudo(
-            f"echo '{name} ALL=(ALL) NOPASSWD:ALL' | sudo tee -a /etc/sudoers"
-        )
-        self.stdout.output(f"[green]New user {name} created successfully![/green]")
+    def create_user(
+        self,
+        name: str,
+        with_password: Annotated[bool, cappa.Arg(long="--with-password")] = False,
+    ):
+        with self.connection() as conn:
+            run_pty = partial(conn.run, pty=True)
+            run_pty(
+                f"sudo adduser --disabled-password --gecos '' {name}",
+            )
+            run_pty(f"sudo mkdir -p /home/{name}/.ssh")
+            run_pty(f"sudo cp ~/.ssh/authorized_keys /home/{name}/.ssh/")
+            run_pty(f"sudo chown -R {name}:{name} /home/{name}/.ssh")
+            if with_password:
+                password = secrets.token_hex(8)
+                run_pty(f"echo '{name}:{password}' | sudo chpasswd")
+                self.stdout.output(f"[green]Generated password: [/green]{password}")
+            run_pty(f"sudo chmod 700 /home/{name}/.ssh")
+            run_pty(f"sudo chmod 600 /home/{name}/.ssh/authorized_keys")
+            run_pty(f"echo '{name} ALL=(ALL) NOPASSWD:ALL' | sudo tee -a /etc/sudoers")
+            self.stdout.output(f"[green]New user {name} created successfully![/green]")

fujin/commands/up.py

@@ -1,16 +1,15 @@
 import cappa
+from fujin.commands import BaseCommand
 
-from fujin.commands import AppCommand
 from .deploy import Deploy
 from .server import Server
 
 
 @cappa.command(help="Run everything required to deploy an application to a fresh host.")
-class Up(AppCommand):
-
+class Up(BaseCommand):
     def __call__(self):
-        Server(_host=self._host).bootstrap()
-        Deploy(_host=self._host)()
+        Server().bootstrap()
+        Deploy()()
         self.stdout.output(
             "[green]Server bootstrapped and application deployed successfully![/green]"
         )