fujin-cli 0.3.0__tar.gz → 0.5.0__tar.gz

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fujin-cli
-Version: 0.3.0
+Version: 0.5.0
 Summary: Add your description here
 Project-URL: Documentation, https://github.com/falcopackages/fujin#readme
 Project-URL: Issues, https://github.com/falcopackages/fujin/issues

fujin_cli-0.5.0/docs/configuration.rst

@@ -0,0 +1,32 @@
+Configuration
+=============
+
+.. automodule:: fujin.config
+
+
+Example
+-------
+
+This is a minimal working example.
+
+.. tab-set::
+
+    .. tab-item:: simple python package
+
+        .. jupyter-execute::
+            :hide-code:
+
+            from fujin.commands.init import simple_config
+            from tomli_w import dumps
+
+            print(dumps(simple_config("bookstore")))
+
+    .. tab-item:: binary mode
+
+        .. jupyter-execute::
+            :hide-code:
+
+            from fujin.commands.init import binary_config
+            from tomli_w import dumps
+
+            print(dumps(binary_config("bookstore")))

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/docs/index.rst

@@ -11,6 +11,9 @@ fujin documentation
 
    This a work in progress, not ready for production use yet.
 
+.. raw:: html
+
+   <script src="https://asciinema.org/a/687274.js" id="asciicast-687274" async="true"></script>
 
 .. .. include:: ../README.md
    :parser: myst_parser.sphinx_

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/examples/django/bookstore/fujin.toml

@@ -3,8 +3,9 @@ requirements = "requirements.txt"
 python_version = "3.13"
 versions_to_keep = 2
 build_command = "uv build && uv pip compile pyproject.toml -o requirements.txt"
-release_command = "bookstore migrate && bookstore collectstatic --no-input && sudo rsync --mkpath -a --delete staticfiles/ /var/www/bookstore/static/"
+release_command = "bookstore migrate && bookstore collectstatic --no-input && sudo mkdir -p /var/www/bookstore/static/ && sudo rsync  -a --delete staticfiles/ /var/www/bookstore/static/"
 distfile = "./../../../dist/bookstore-{version}-py3-none-any.whl"
+installation_mode = "python-package"
 
 [webserver]
 upstream = "unix//run/bookstore.sock"
@@ -20,18 +21,18 @@ shell = "server exec --appenv -i bash"
 web = ".venv/bin/gunicorn bookstore.wsgi:application --access-logfile - --error-logfile -"
 worker = ".venv/bin/bookstore db_worker"
 
-#[host]
-#ip = "127.0.0.1"
-#domain_name = "bookstore.localhost.dev"
-#envfile = ".env.prod"
-#user = "vagrant"
-#key_filename = "/home/tobi/Builds/falcopackages/fujin/.vagrant/machines/default/virtualbox/private_key"
-#ssh_port = 2222
-
 [host]
-ip = "aws-ec2"
-domain_name = "test.oluwatobi.dev"
+ip = "127.0.0.1"
+domain_name = "bookstore.localhost.dev"
 envfile = ".env.prod"
-user = "ubuntu"
-key_filename = "../../../aws.pem"
+user = "vagrant"
+key_filename = "/home/tobi/Builds/falcopackages/fujin/.vagrant/machines/default/virtualbox/private_key"
+ssh_port = 2222
+
+#[host]
+#ip = "aws-ec2"
+#domain_name = "test.oluwatobi.dev"
+#envfile = ".env.prod"
+#user = "ubuntu"
+#key_filename = "../../../aws.pem"
 

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/pyproject.toml

@@ -7,7 +7,7 @@ requires = [
 
 [project]
 name = "fujin-cli"
-version = "0.3.0"
+version = "0.5.0"
 description = "Add your description here"
 readme = "README.md"
 keywords = [

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/src/fujin/commands/app.py

@@ -5,6 +5,7 @@ from typing import Annotated
 import cappa
 
 from fujin.commands import BaseCommand
+from fujin.config import InstallationMode
 
 
 @cappa.command(help="Run application-related tasks")
@@ -25,11 +26,12 @@ class App(BaseCommand):
                 "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",
             }
+            if self.config.installation_mode == InstallationMode.PY_PACKAGE:
+                infos["python_version"] = self.config.python_version
             pm = self.create_process_manager(conn)
             services: dict[str, bool] = pm.is_active()
 

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/src/fujin/commands/config.py

@@ -16,13 +16,14 @@ class ConfigCMD(BaseCommand):
             "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,
+            "installation_mode": self.config.installation_mode,
             "distfile": self.config.distfile,
-            "requirements": self.config.requirements,
             "webserver": f"{{ upstream = '{self.config.webserver.upstream}', type = '{self.config.webserver.type}' }}",
         }
+        if self.config.python_version:
+            general_config["python_version"] = self.config.python_version
         general_config_text = "\n".join(
             f"[bold green]{key}:[/bold green] {value}"
             for key, value in general_config.items()

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/src/fujin/commands/deploy.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import subprocess
+from pathlib import Path
 
 import cappa
 
 from fujin.commands import BaseCommand
+from fujin.config import InstallationMode
 from fujin.connection import Connection
 
 
@@ -16,21 +18,20 @@ class Deploy(BaseCommand):
         self.build_app()
 
         with self.connection() as conn:
+            process_manager = self.create_process_manager(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.install_project(conn)
+            with self.app_environment() as app_conn:
+                self.release(app_conn)
+                process_manager.install_services()
+                process_manager.reload_configuration()
+                process_manager.restart_services()
+                self.create_web_proxy(app_conn).setup()
+                self.update_version_history(app_conn)
+                self.prune_assets(app_conn)
             self.create_hook_manager(conn).post_deploy()
         self.stdout.output("[green]Project deployment completed successfully![/green]")
         self.stdout.output(
@@ -47,24 +48,37 @@ class Deploy(BaseCommand):
     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):
+    def transfer_files(self, conn: Connection):
         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}",
         )
+
+    def install_project(
+        self, conn: Connection, version: str | None = None, *, skip_setup: bool = False
+    ):
+        version = version or self.config.version
+        if self.config.installation_mode == InstallationMode.PY_PACKAGE:
+            self._install_python_package(conn, version, skip_setup)
+        else:
+            self._install_binary(conn, version)
+
+    def _install_python_package(
+        self, conn: Connection, version: str, skip_setup: bool = False
+    ):
+        if not skip_setup and self.config.requirements:
+            requirements = Path(self.config.requirements)
+            if not requirements.exists():
+                raise cappa.Exit(f"{self.config.requirements} not found", code=1)
+            conn.put(
+                Path(self.config.requirements).resolve(),
+                f"{self.versioned_assets_dir}/requirements.txt",
+            )
         appenv = f"""
 set -a  # Automatically export all variables
 source .env
@@ -73,22 +87,30 @@ 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
+        conn.run(f"echo '{appenv.strip()}' > {self.app_dir}/.appenv")
         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")
+            if self.config.requirements:
+                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 _install_binary(self, conn: Connection, version: str):
+        appenv = f"""
+set -a  # Automatically export all variables
+source .env
+set +a  # Stop automatic export
+export PATH="{self.app_dir}:$PATH"
+"""
+        conn.run(f"echo '{appenv.strip()}' > {self.app_dir}/.appenv")
+        full_path_app_bin = f"{self.app_dir}/{self.config.app_bin}"
+        conn.run(f"rm {full_path_app_bin}", warn=True)
+        conn.run(
+            f"ln -s {self.versioned_assets_dir}/{self.config.get_distfile_path(version).name} {full_path_app_bin}"
+        )
+
     def release(self, conn: Connection):
         if self.config.release_command:
             conn.run(f"source .env && {self.config.release_command}")

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/src/fujin/commands/down.py

@@ -28,7 +28,7 @@ class Down(BaseCommand):
             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:
+        except KeyboardInterrupt:
             raise cappa.Exit("Teardown aborted", code=0)
         if not confirm:
             return

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/src/fujin/commands/init.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Annotated
 
@@ -7,31 +8,28 @@ import cappa
 import tomli_w
 
 from fujin.commands import BaseCommand
-from fujin.config import tomllib
+from fujin.config import tomllib, InstallationMode
 
 
 @cappa.command(help="Generate a sample configuration file")
+@dataclass
 class Init(BaseCommand):
     profile: Annotated[
-        str, cappa.Arg(choices=["simple", "falco"], short="-p", long="--profile")
+        str,
+        cappa.Arg(choices=["simple", "falco", "binary"], 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}
+        profile_to_func = {
+            "simple": simple_config,
+            "falco": falco_config,
+            "binary": binary_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]"
@@ -39,18 +37,20 @@ class Init(BaseCommand):
 
 
 def simple_config(app_name) -> dict:
-    return {
+    config = {
         "app": app_name,
-        "version": "0.1.0",
+        "version": "0.0.1",
         "build_command": "uv build && uv pip compile pyproject.toml -o requirements.txt",
         "distfile": f"dist/{app_name}-{{version}}-py3-none-any.whl",
+        "requirements": "requirements.txt",
         "webserver": {
-            "upstream": "localhost:8000",
+            "upstream": f"unix//run/{app_name}.sock",
             "type": "fujin.proxies.caddy",
         },
         "release_command": f"{app_name} migrate",
+        "installation_mode": InstallationMode.PY_PACKAGE,
         "processes": {
-            "web": f".venv/bin/gunicorn {app_name}.wsgi:app --bind 0.0.0.0:8000"
+            "web": f".venv/bin/gunicorn {app_name}.wsgi:application --bind unix//run/{app_name}.sock"
         },
         "aliases": {"shell": "server exec --appenv -i bash"},
         "host": {
@@ -60,6 +60,16 @@ def simple_config(app_name) -> dict:
             "envfile": ".env.prod",
         },
     }
+    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")
+    return config
 
 
 def falco_config(app_name: str) -> dict:
@@ -71,6 +81,10 @@ def falco_config(app_name: str) -> dict:
                 "web": f".venv/bin/{config['app']} prodserver",
                 "worker": f".venv/bin/{config['app']} qcluster",
             },
+            "webserver": {
+                "upstream": "localhost:8000",
+                "type": "fujin.proxies.caddy",
+            },
             "aliases": {
                 "console": "app exec -i shell_plus",
                 "dbconsole": "app exec -i dbshell",
@@ -80,3 +94,26 @@ def falco_config(app_name: str) -> dict:
         }
     )
     return config
+
+
+def binary_config(app_name: str) -> dict:
+    return {
+        "app": app_name,
+        "version": "0.0.1",
+        "build_command": "just build-bin",
+        "distfile": f"dist/bin/{app_name}-{{version}}",
+        "webserver": {
+            "upstream": "localhost:8000",
+            "type": "fujin.proxies.caddy",
+        },
+        "release_command": f"{app_name} migrate",
+        "installation_mode": InstallationMode.BINARY,
+        "processes": {"web": f"{app_name} prodserver"},
+        "aliases": {"shell": "server exec --appenv -i bash"},
+        "host": {
+            "ip": "127.0.0.1",
+            "user": "root",
+            "domain_name": f"{app_name}.com",
+            "envfile": ".env.prod",
+        },
+    }

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/src/fujin/commands/proxy.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from typing import Annotated
 
 import cappa
+from rich.prompt import Confirm
 
 from fujin.commands import BaseCommand
 
@@ -13,11 +14,21 @@ class Proxy(BaseCommand):
     def install(self):
         with self.connection() as conn:
             self.create_web_proxy(conn).install()
+        self.stdout.output("[green]Proxy installed successfully![/green]")
 
     @cappa.command(help="Uninstall the proxy from the remote host")
     def uninstall(self):
+        try:
+            confirm = Confirm.ask(
+                f"[red]Uninstalling the proxy will remove all current configurations. Are you sure you want to proceed?"
+            )
+        except KeyboardInterrupt:
+            raise cappa.Exit("Teardown aborted", code=0)
+        if not confirm:
+            return
         with self.connection() as conn:
             self.create_web_proxy(conn).uninstall()
+        self.stdout.output("[green]Proxy uninstalled successfully![/green]")
 
     @cappa.command(help="Start the proxy on the remote host")
     def start(self):

fujin_cli-0.5.0/src/fujin/commands/redeploy.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+import cappa
+
+from fujin.commands import BaseCommand
+from .deploy import Deploy
+from fujin.config import InstallationMode
+from fujin.connection import Connection
+
+
+@cappa.command(help="Redeploy the application to apply code and environment changes")
+class Redeploy(BaseCommand):
+    def __call__(self):
+        deploy = Deploy()
+        deploy.build_app()
+
+        with self.app_environment() as conn:
+            hook_manager = self.create_hook_manager(conn)
+            hook_manager.pre_deploy()
+            deploy.transfer_files(conn)
+            requirements_copied = self._copy_requirements_if_needed(conn)
+            deploy.install_project(conn, skip_setup=requirements_copied)
+            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]")
+
+    def _copy_requirements_if_needed(self, conn: Connection) -> bool:
+        if (
+            not self.config.requirements
+            or self.config.installation_mode == InstallationMode.BINARY
+        ):
+            return False
+        local_requirements = hashlib.md5(
+            Path(self.config.requirements).read_bytes()
+        ).hexdigest()
+        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:
+            return False
+        if skip_requirements and current_host_version != self.config.version:
+            conn.run(
+                f"cp v{current_host_version}/requirements.txt  {self.app_dir}/v{self.config.version}/requirements.txt "
+            )
+        return True

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/src/fujin/commands/server.py

@@ -38,11 +38,6 @@ class Server(BaseCommand):
                 "[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"
     )

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/src/fujin/config.py

@@ -5,18 +5,14 @@ app
 ---
 The name of your project or application. Must be a valid Python package name.
 
-app_bin
--------
-Path to your application's executable. Used by the **app** subcommand for remote execution.
-Default: ``.venv/bin/{app}``
-
 version
 --------
 The version of your project to build and deploy. If not specified, automatically parsed from ``pyproject.toml`` under ``project.version``.
 
 python_version
 --------------
-The Python version for your virtualenv. If not specified, automatically parsed from ``.python-version`` file.
+The Python version for your virtualenv. If not specified, automatically parsed from ``.python-version`` file. This is only
+required if the installation mode is set to ``python-package``
 
 versions_to_keep
 ----------------
@@ -32,14 +28,20 @@ distfile
 Path to your project's distribution file. This should be the main artifact containing everything needed to run your project on the server.
 Supports version placeholder, e.g., ``dist/app_name-{version}-py3-none-any.whl``
 
+installation_mode
+-----------------
+
+Indicates whether the ``distfile`` is a Python package or a self-contained executable. The possible values are ``python-package`` and ``binary``.
+The ``binary`` option disables specific Python-related features, such as virtual environment creation and requirements installation. ``fujin`` will assume the provided
+``distfile`` already contains all the necessary dependencies to run your program.
+
 release_command
 ---------------
 Optional command to run at the end of deployment (e.g., database migrations).
 
 requirements
 ------------
-Path to your requirements file.
-Default: ``requirements.txt``
+Optional path to your requirements file. This will only be used when the installation mode is set to ``python-package``
 
 Webserver
 ---------
@@ -63,7 +65,8 @@ statics
 ~~~~~~~
 
 Defines the mapping of URL paths to local directories for serving static files. The syntax and support for static
-file serving depend on the selected reverse proxy.
+file serving depend on the selected reverse proxy. The directories you map should be accessible by the web server, meaning
+with read permissions for the ``www-data`` group; a reliable choice is ``/var/www``.
 
 Example:
 
@@ -72,7 +75,7 @@ Example:
     [webserver]
     upstream = "unix//run/project.sock"
     type = "fujin.proxies.caddy"
-    statics = { "/static/*" = "/var/www/example.com/static/" }
+    statics = { "/static/*" = "/var/www/myproject/static/" }
 
 processes
 ---------
@@ -159,6 +162,7 @@ from __future__ import annotations
 
 import os
 import sys
+from functools import cached_property
 from pathlib import Path
 
 import msgspec
@@ -170,31 +174,36 @@ if sys.version_info >= (3, 11):
 else:
     import tomli as tomllib
 
-from .hooks import HooksDict
+from .hooks import HooksDict, StrEnum
+
+
+class InstallationMode(StrEnum):
+    PY_PACKAGE = "python-package"
+    BINARY = "binary"
 
 
 class Config(msgspec.Struct, kw_only=True):
     app_name: str = msgspec.field(name="app")
-    app_bin: str = ".venv/bin/{app}"
     version: str = msgspec.field(default_factory=lambda: read_version_from_pyproject())
     versions_to_keep: int | None = 5
-    python_version: str = msgspec.field(default_factory=lambda: find_python_version())
+    python_version: str | None = None
     build_command: str
     release_command: str | None = None
-    skip_project_install: bool = False
+    installation_mode: InstallationMode
     distfile: str
     aliases: dict[str, str] = msgspec.field(default_factory=dict)
     host: HostConfig
     processes: dict[str, str] = msgspec.field(default_factory=dict)
     process_manager: str = "fujin.process_managers.systemd"
     webserver: Webserver
-    _requirements: str = msgspec.field(name="requirements", default="requirements.txt")
+    requirements: str | None = None
     hooks: HooksDict = msgspec.field(default_factory=dict)
     local_config_dir: Path = Path(".fujin")
 
     def __post_init__(self):
-        self.app_bin = self.app_bin.format(app=self.app_name)
-        # self._distfile = self._distfile.format(version=self.version)
+        if self.installation_mode == InstallationMode.PY_PACKAGE:
+            if not self.python_version:
+                self.python_version = find_python_version()
 
         if "web" not in self.processes and self.webserver.type != "fujin.proxies.dummy":
             raise ValueError(
@@ -202,8 +211,10 @@ class Config(msgspec.Struct, kw_only=True):
             )
 
     @property
-    def requirements(self) -> Path:
-        return Path(self._requirements)
+    def app_bin(self) -> str:
+        if self.installation_mode == InstallationMode.PY_PACKAGE:
+            return f".venv/bin/{self.app_name}"
+        return self.app_name
 
     def get_distfile_path(self, version: str | None = None) -> Path:
         version = version or self.version

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/src/fujin/proxies/caddy.py

@@ -49,6 +49,9 @@ class WebProxy(msgspec.Struct):
         return self.conn.run(*args, **kwargs, pty=True)
 
     def install(self):
+        result = self.conn.run(f"command -v caddy", warn=True, hide=True)
+        if result.ok:
+            return
         version = get_latest_gh_tag()
         download_url = GH_DOWNL0AD_URL.format(version=version)
         filename = GH_TAR_FILENAME.format(version=version)
@@ -71,6 +74,9 @@ class WebProxy(msgspec.Struct):
         )
         self.run_pty("sudo systemctl daemon-reload")
         self.run_pty("sudo systemctl enable --now caddy-api")
+        self.conn.run(
+            """curl --silent http://localhost:2019/config/ -d '{"apps":{"http": {"servers": {"srv0":{"listen":[":443"]}}}}}' -H 'Content-Type: application/json'"""
+        )
 
     def uninstall(self):
         self.stop()
@@ -80,51 +86,31 @@ class WebProxy(msgspec.Struct):
         self.run_pty("sudo userdel caddy")
 
     def setup(self):
-        config = (
+        current_config = json.loads(
+            self.conn.run(
+                "curl http://localhost:2019/config/apps/http/servers/srv0", hide=True
+            ).stdout.strip()
+        )
+        existing_routes: list[dict] = current_config.get("routes", [])
+        new_routes = [r for r in existing_routes if r.get("group") != self.app_name]
+        routes = (
             json.loads(self.config_file.read_text())
             if self.config_file.exists()
-            else self._get_config()
+            else self._get_routes()
         )
-        self.conn.run(f"echo '{json.dumps(config)}' > caddy.json")
-        self.conn.run(
-            f"curl localhost:2019/config/apps/http/servers/{self.app_name} -H 'Content-Type: application/json' -d @caddy.json"
-        )
-        # TODO: stop when received an {"error":"loading config: loading new config: http app module: start: listening on :443: listen tcp :443: bind: permission denied"}, not a 200 ok
-
-    def teardown(self):
-        self.conn.run(f"echo '{json.dumps({})}' > caddy.json")
+        new_routes.append(routes)
+        current_config["routes"] = new_routes
         self.conn.run(
-            f"curl localhost:2019/config/apps/http/servers/{self.app_name} -H 'Content-Type: application/json' -d @caddy.json"
+            f"curl localhost:2019/config/apps/http/servers/srv0 -H 'Content-Type: application/json' -d '{json.dumps(current_config)}'"
         )
 
-    def start(self) -> None:
-        self.run_pty("sudo systemctl start caddy-api")
-
-    def stop(self) -> None:
-        self.run_pty("sudo systemctl stop caddy-api")
-
-    def status(self) -> None:
-        self.run_pty("sudo systemctl status caddy-api", warn=True)
-
-    def restart(self) -> None:
-        self.run_pty("sudo systemctl restart caddy-api")
-
-    def logs(self) -> None:
-        self.run_pty(f"sudo journalctl -u caddy-api -f", warn=True)
-
-    def export_config(self) -> None:
-        self.config_file.write_text(json.dumps(self._get_config()))
-
-    def _get_config(self) -> dict:
+    def _get_routes(self) -> dict:
         handle = []
-        config = {
-            "listen": [":443"],
-            "routes": [
-                {
-                    "match": [{"host": [self.domain_name]}],
-                    "handle": handle,
-                }
-            ],
+        routes = {
+            "group": self.app_name,
+            "match": [{"host": [self.domain_name]}],
+            "terminal": True,
+            "handle": handle,
         }
         reverse_proxy = {
             "handler": "reverse_proxy",
@@ -132,14 +118,14 @@ class WebProxy(msgspec.Struct):
         }
         if not self.statics:
             handle.append(reverse_proxy)
-            return config
-        routes = []
-        handle.append({"handler": "subroute", "routes": routes})
+            return routes
+        sub_routes = []
+        handle.append({"handler": "subroute", "routes": sub_routes})
         for path, directory in self.statics.items():
             strip_path_prefix = path.replace("/*", "")
             if strip_path_prefix.endswith("/"):
                 strip_path_prefix = strip_path_prefix[:-1]
-            routes.append(
+            sub_routes.append(
                 {
                     "handle": [
                         {
@@ -167,8 +153,39 @@ class WebProxy(msgspec.Struct):
                     "match": [{"path": [path]}],
                 }
             )
-        routes.append({"handle": [reverse_proxy]})
-        return config
+        sub_routes.append({"handle": [reverse_proxy]})
+        return routes
+
+    def teardown(self):
+        current_config = json.loads(
+            self.conn.run(
+                "curl http://localhost:2019/config/apps/http/servers/srv0"
+            ).stdout.strip()
+        )
+        existing_routes: list[dict] = current_config.get("routes", [])
+        new_routes = [r for r in existing_routes if r.get("group") != self.app_name]
+        current_config["routes"] = new_routes
+        self.conn.run(
+            f"curl localhost:2019/config/apps/http/servers/srv0 -H 'Content-Type: application/json' -d '{json.dumps(current_config)}'"
+        )
+
+    def start(self) -> None:
+        self.run_pty("sudo systemctl start caddy-api")
+
+    def stop(self) -> None:
+        self.run_pty("sudo systemctl stop caddy-api")
+
+    def status(self) -> None:
+        self.run_pty("sudo systemctl status caddy-api", warn=True)
+
+    def restart(self) -> None:
+        self.run_pty("sudo systemctl restart caddy-api")
+
+    def logs(self) -> None:
+        self.run_pty(f"sudo journalctl -u caddy-api -f", warn=True)
+
+    def export_config(self) -> None:
+        self.config_file.write_text(json.dumps(self._get_routes()))
 
 
 def get_latest_gh_tag() -> str:

{fujin_cli-0.3.0 → fujin_cli-0.5.0}/uv.lock

@@ -599,7 +599,7 @@ wheels = [
 
 [[package]]
 name = "fujin-cli"
-version = "0.2.0"
+version = "0.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "cappa" },

fujin_cli-0.3.0/docs/configuration.rst

@@ -1,18 +0,0 @@
-Configuration
-=============
-
-.. automodule:: fujin.config
-
-
-Example
--------
-
-This is a minimal working example.
-
-.. jupyter-execute::
-    :hide-code:
-
-    from fujin.commands.init import simple_config
-    from tomli_w import dumps
-
-    print(dumps(simple_config("bookstore")))

fujin_cli-0.3.0/src/fujin/commands/redeploy.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-
-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(BaseCommand):
-    def __call__(self):
-        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]")