fujin-cli 0.1.0__py3-none-any.whl → 0.2.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,53 @@
+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.down import Down
+from fujin.commands.redeploy import Redeploy
+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[
+        Up | Deploy | Redeploy | App | Server | ConfigCMD | Down
+    ]
+
+
+def main():
+    # install(show_locals=True)
+    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 = 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 []
+    return [*aliases.get(sys.argv[1]).split(), *extra_args]
+
+
+if __name__ == "__main__":
+    main()

fujin/commands/__init__.py

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

fujin/commands/_base.py

@@ -0,0 +1,83 @@
+import importlib
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Annotated
+
+import cappa
+
+from fujin.config import Config
+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:
+    @cached_property
+    def config(self) -> Config:
+        return Config.read()
+
+    @cached_property
+    def stdout(self) -> cappa.Output:
+        return cappa.Output()
+
+
+@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
+
+    @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)
+
+    @cached_property
+    def web_proxy(self) -> WebProxy:
+        module = importlib.import_module(self.config.webserver.type)
+        try:
+            return getattr(module, "WebProxy")(host=self.host, config=self.config)
+        except KeyError as e:
+            raise ImproperlyConfiguredError(
+                f"Missing WebProxy class in {self.config.webserver.type}"
+            ) from e
+
+    @cached_property
+    def process_manager(self) -> ProcessManager:
+        module = importlib.import_module(self.config.process_manager)
+        try:
+            return getattr(module, "ProcessManager")(host=self.host, config=self.config)
+        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)

fujin/commands/app.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import cappa
+
+from fujin.commands import AppCommand
+
+
+@cappa.command(help="Run application-related tasks")
+class App(AppCommand):
+
+    @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.host.cd_project_dir(self.config.app):
+            if interactive:
+                self.host.run(f"{self.config.app_bin} {command}", pty=interactive)
+            else:
+                result = self.host.run(f"{self.config.app_bin} {command}", hide=True)
+                self.stdout.output(result)
+
+    @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,
+    ):
+        self.process_manager.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,
+    ):
+        self.process_manager.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,
+    ):
+        self.process_manager.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
+        self.process_manager.service_logs(name=name, follow=follow)

fujin/commands/config.py

@@ -0,0 +1,174 @@
+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")
+class ConfigCMD(BaseCommand):
+
+    @cappa.command(help="Display the parsed configuration")
+    def show(self):
+        console = Console()
+
+        general_config = {
+            "app": self.config.app,
+            "app_bin": self.config.app_bin,
+            "version": self.config.version,
+            "python_version": self.config.python_version,
+            "build_command": self.config.build_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(
+            f"[bold green]{key}:[/bold green] {value}"
+            for key, value in general_config.items()
+        )
+        console.print(
+            Panel(
+                formatted_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]",
+            )
+
+        console.print(hosts_table)
+
+        # 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)
+
+    @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

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import subprocess
+
+import cappa
+
+from fujin.commands import AppCommand
+
+
+@cappa.command(
+    help="Deploy the project by building, transferring files, installing, and configuring services"
+)
+class Deploy(AppCommand):
+
+    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.host.make_project_dir(project_name=self.config.app)
+        self.transfer_files()
+        self.install_project()
+        self.hook_manager.pre_deploy()
+
+        self.process_manager.install_services()
+        self.process_manager.reload_configuration()
+        self.process_manager.restart_services()
+
+        self.web_proxy.setup()
+        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]"
+        )
+
+    def transfer_files(self):
+        if not self.host.config.envfile.exists():
+            raise cappa.Exit(f"{self.host.config.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}"
+        )
+        self.host.run(f"echo {self.config.python_version} > .python-version")
+
+    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}")

fujin/commands/down.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import cappa
+from rich.prompt import Prompt
+
+from fujin.commands import AppCommand
+
+
+@cappa.command(
+    help="Tear down the project by stopping services and cleaning up resources"
+)
+@dataclass
+class Down(AppCommand):
+
+    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":
+            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]")

fujin/commands/redeploy.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import cappa
+
+from fujin.commands import AppCommand
+
+from .deploy import Deploy
+
+
+@cappa.command(help="Redeploy the application to apply code and environment changes")
+class Redeploy(AppCommand):
+
+    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]")

fujin/commands/server.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import cappa
+
+from fujin.commands import AppCommand
+
+
+@cappa.command(help="Manage server operations")
+class Server(AppCommand):
+
+    @cappa.command(help="Display information about the host system")
+    def info(self):
+        self.stdout.output(self.host.sudo("cat /etc/os-release", hide="out"))
+
+    @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]")
+
+    @cappa.command(
+        help="Execute an arbitrary command on the server, optionally in interactive mode"
+    )
+    def exec(
+        self,
+        command: str,
+        interactive: Annotated[bool, cappa.Arg(default=False, short="-i")],
+    ):
+        if interactive:
+            self.host.run(command, pty=interactive)
+        else:
+            result = self.host.run(command, hide=True)
+            self.stdout.output(result)
+
+    @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]")

fujin/commands/up.py

@@ -0,0 +1,16 @@
+import cappa
+
+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):
+
+    def __call__(self):
+        Server(_host=self._host).bootstrap()
+        Deploy(_host=self._host)()
+        self.stdout.output(
+            "[green]Server bootstrapped and application deployed successfully![/green]"
+        )