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

fujin/config.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+import msgspec
+
+from .errors import ImproperlyConfiguredError
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+try:
+    from enum import StrEnum
+except ImportError:
+    from enum import Enum
+
+    class StrEnum(str, Enum):
+        pass
+
+
+class Hook(StrEnum):
+    PRE_DEPLOY = "pre_deploy"
+
+
+class Config(msgspec.Struct, kw_only=True):
+    app: str
+    app_bin: str = ".venv/bin/{app}"
+    version: str = msgspec.field(default_factory=lambda: read_version_from_pyproject())
+    python_version: str = msgspec.field(default_factory=lambda: find_python_version())
+    build_command: str
+    _distfile: str = msgspec.field(name="distfile")
+    aliases: dict[str, str]
+    hosts: dict[str, HostConfig]
+    processes: dict[str, str]
+    process_manager: str = "fujin.process_managers.systemd"
+    webserver: Webserver
+    _requirements: str = msgspec.field(name="requirements", default="requirements.txt")
+    hooks: dict[Hook, str] = msgspec.field(default=dict)
+
+    def __post_init__(self):
+        self.app_bin = self.app_bin.format(app=self.app)
+        self._distfile = self._distfile.format(version=self.version)
+
+        if "web" not in self.processes and self.webserver.type != "fujin.proxies.dummy":
+            raise ValueError(
+                "Missing web process or set the proxy to 'fujin.proxies.dummy' to disable the use of a proxy"
+            )
+
+    @property
+    def distfile(self) -> Path:
+        return Path(self._distfile)
+
+    @property
+    def requirements(self) -> Path:
+        return Path(self._requirements)
+
+    @classmethod
+    def read(cls) -> Config:
+        fujin_toml = Path("fujin.toml")
+        if not fujin_toml.exists():
+            raise ImproperlyConfiguredError(
+                "No fujin.toml file found in the current directory"
+            )
+        try:
+            return msgspec.toml.decode(fujin_toml.read_text(), type=cls)
+        except msgspec.ValidationError as e:
+            raise ImproperlyConfiguredError(f"Improperly configured, {e}") from e
+
+
+class HostConfig(msgspec.Struct, kw_only=True):
+    ip: str
+    domain_name: str
+    user: str
+    _envfile: str = msgspec.field(name="envfile")
+    projects_dir: str = "/home/{user}/.local/share/fujin"
+    password_env: str | None = None
+    ssh_port: int = 22
+    _key_filename: str | None = msgspec.field(name="key_filename", default=None)
+    default: bool = False
+
+    def __post_init__(self):
+        self.projects_dir = self.projects_dir.format(user=self.user)
+
+    def to_dict(self):
+        return {f: getattr(self, f) for f in self.__struct_fields__}
+
+    @property
+    def envfile(self) -> Path:
+        return Path(self._envfile)
+
+    @property
+    def key_filename(self) -> Path | None:
+        if self._key_filename:
+            return Path(self._key_filename)
+
+    @property
+    def password(self) -> str | None:
+        if not self.password_env:
+            return
+        password = os.getenv(self.password_env)
+        if not password:
+            msg = f"Env {self.password_env} can not be found"
+            raise ImproperlyConfiguredError(msg)
+        return password
+
+
+class Webserver(msgspec.Struct):
+    upstream: str
+    type: str = "fujin.proxies.caddy"
+
+
+def read_version_from_pyproject():
+    try:
+        return tomllib.loads(Path("pyproject.toml").read_text())["project"]["version"]
+    except (FileNotFoundError, KeyError) as e:
+        raise msgspec.ValidationError(
+            "Project version was not found in the pyproject.toml file, define it manually"
+        ) from e
+
+
+def find_python_version():
+    py_version_file = Path(".python-version")
+    if not py_version_file.exists():
+        raise msgspec.ValidationError(
+            f"Add a python_version key or a .python-version file"
+        )
+    return py_version_file.read_text().strip()

fujin/errors.py

@@ -0,0 +1,5 @@
+import cappa
+
+
+class ImproperlyConfiguredError(cappa.Exit):
+    code = 1

fujin/hooks.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+
+from fujin.config import Config
+from fujin.host import Host
+from fujin.config import Hook
+
+
+@dataclass(frozen=True, slots=True)
+class HookManager:
+    config: Config
+    host: Host
+
+    def pre_deploy(self):
+        if pre_deploy := self.config.hooks.get(Hook.PRE_DEPLOY):
+            self.host.run(pre_deploy)

fujin/host.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from dataclasses import dataclass
+from functools import cached_property
+
+import cappa
+from fabric import Connection
+from invoke import Responder
+from paramiko.ssh_exception import AuthenticationException
+
+from .config import HostConfig
+
+
+@dataclass(frozen=True)
+class Host:
+    config: HostConfig
+
+    def __str__(self):
+        return self.config.ip
+
+    @property
+    def watchers(self) -> list[Responder]:
+        if not self.config.password:
+            return []
+        return [
+            Responder(
+                pattern=r"\[sudo\] password:",
+                response=f"{self.config.password}\n",
+            )
+        ]
+
+    @cached_property
+    def connection(self) -> Connection:
+        connect_kwargs = None
+        if self.config.key_filename:
+            connect_kwargs = {"key_filename": str(self.config.key_filename)}
+        elif self.config.password:
+            connect_kwargs = {"password": self.config.password}
+
+        return Connection(
+            self.config.ip,
+            user=self.config.user,
+            port=self.config.ssh_port,
+            connect_kwargs=connect_kwargs,
+        )
+
+    def run(self, args: str, **kwargs):
+        try:
+            return self.connection.run(args, **kwargs, watchers=self.watchers)
+        except AuthenticationException as e:
+            msg = f"Authentication failed for {self.config.user}@{self.config.ip} -p {self.config.ssh_port}.\n"
+            if self.config.key_filename:
+                msg += f"An SSH key was provided at {self.config.key_filename.resolve()}. Please verify its validity and correctness."
+            elif self.config.password:
+                msg += f"A password was provided through the environment variable {self.config.password_env}. Please ensure it is correct for the user {self.config.user}."
+            else:
+                msg += "No password or SSH key was provided. Ensure your current host has SSH access to the target host."
+            raise cappa.Exit(msg, code=1) from e
+
+    def put(self, *args, **kwargs):
+        return self.connection.put(args, **kwargs, watchers=self.watchers)
+
+    def get(self, *args, **kwargs):
+        return self.connection.get(args, **kwargs, watchers=self.watchers)
+
+    def sudo(self, args: str, **kwargs):
+        return self.connection.sudo(args, **kwargs)
+
+    def run_uv(self, args: str, **kwargs):
+        return self.run(f"/home/{self.config.user}/.cargo/bin/uv {args}", **kwargs)
+
+    def run_caddy(self, args: str, **kwargs):
+        return self.run(f"/home/{self.config.user}/.local/bin/caddy {args}", **kwargs)
+
+    def make_project_dir(self, project_name: str):
+        self.run(f"mkdir -p {self.project_dir(project_name)}")
+
+    def project_dir(self, project_name: str) -> str:
+        return f"{self.config.projects_dir}/{project_name}"
+
+    @contextmanager
+    def cd_project_dir(self, project_name: str):
+        with self.connection.cd(self.project_dir(project_name)):
+            yield

fujin/process_managers/__init__.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    from fujin.config import Config
+    from fujin.host import Host
+
+
+class ProcessManager(Protocol):
+    host: Host
+    config: Config
+    service_names: list[str]
+
+    def get_service_name(self, name: str): ...
+
+    def install_services(self) -> None: ...
+
+    def uninstall_services(self) -> None: ...
+
+    def start_services(self, *names) -> None: ...
+
+    def restart_services(self, *names) -> None: ...
+
+    def stop_services(self, *names) -> None: ...
+
+    def service_logs(self, name: str, follow: bool = False): ...
+
+    def reload_configuration(self) -> None: ...

fujin/process_managers/systemd.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import importlib.util
+from dataclasses import dataclass
+from pathlib import Path
+
+from fujin.config import Config
+from fujin.host import Host
+
+
+@dataclass(frozen=True, slots=True)
+class SystemdFile:
+    name: str
+    body: str
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessManager:
+    config: Config
+    host: Host
+
+    @property
+    def service_names(self) -> list[str]:
+        return [self.get_service_name(name) for name in self.config.processes]
+
+    def get_service_name(self, name: str):
+        if name == "web":
+            return self.config.app
+        return f"{self.config.app}-{name}.service"
+
+    def install_services(self) -> None:
+        conf_files = self.get_configuration_files()
+        for conf_file in conf_files:
+            self.host.sudo(
+                f"echo '{conf_file.body}' | sudo tee /etc/systemd/system/{conf_file.name}",
+                hide="out",
+            )
+
+        self.host.sudo(f"systemctl enable --now {self.config.app}.socket")
+        for name in self.service_names:
+            # the main web service is launched by the socket service
+            if name != f"{self.config.app}.service":
+                self.host.sudo(f"systemctl enable {name}")
+
+    def get_configuration_files(self) -> list[SystemdFile]:
+        templates_folder = (
+            Path(importlib.util.find_spec("fujin").origin).parent / "templates"
+        )
+        web_service_content = (templates_folder / "web.service").read_text()
+        web_socket_content = (templates_folder / "web.socket").read_text()
+        other_service_content = (templates_folder / "other.service").read_text()
+        context = {
+            "app": self.config.app,
+            "user": self.host.config.user,
+            "project_dir": self.host.project_dir(self.config.app),
+        }
+
+        files = []
+        for name, command in self.config.processes.items():
+            name = self.get_service_name(name)
+            if name == "web":
+                body = web_service_content.format(**context, command=command)
+                files.append(
+                    SystemdFile(
+                        name=f"{self.config.app}.socket",
+                        body=web_socket_content.format(**context),
+                    )
+                )
+            else:
+                body = other_service_content.format(**context, command=command)
+            files.append(SystemdFile(name=name, body=body))
+        return files
+
+    def uninstall_services(self) -> None:
+        self.stop_services()
+        self.host.sudo(f"systemctl disable {self.config.app}.socket")
+        for name in self.service_names:
+            # was never enabled in the first place, look at the code above
+            if name != f"{self.config.app}.service":
+                self.host.sudo(f"systemctl disable {name}")
+
+    def start_services(self, *names) -> None:
+        names = names or self.service_names
+        for name in names:
+            if name in self.service_names:
+                self.host.sudo(f"systemctl start {name}")
+
+    def restart_services(self, *names) -> None:
+        names = names or self.service_names
+        for name in names:
+            if name in self.service_names:
+                self.host.sudo(f"systemctl restart {name}")
+
+    def stop_services(self, *names) -> None:
+        names = names or self.service_names
+        for name in names:
+            if name in self.service_names:
+                self.host.sudo(f"systemctl stop {name}")
+
+    def service_logs(self, name: str, follow: bool = False):
+        # TODO: add more options here
+        self.host.sudo(f"journalctl -u {name} -r {'-f' if follow else ''}")
+
+    def reload_configuration(self) -> None:
+        self.host.sudo(f"systemctl daemon-reload")

fujin/proxies/__init__.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    from fujin.config import Config
+    from fujin.host import Host
+
+
+class WebProxy(Protocol):
+    host: Host
+    config: Config
+
+    def install(self) -> None: ...
+
+    def setup(self) -> None: ...
+
+    def teardown(self) -> None: ...

fujin/proxies/caddy.py

@@ -0,0 +1,52 @@
+import json
+
+import msgspec
+
+from fujin.config import Config
+from fujin.host import Host
+
+
+class WebProxy(msgspec.Struct):
+    host: Host
+    config: Config
+
+    def install(self):
+        self.host.run_uv("tool install caddy-bin")
+        self.host.run_caddy("start", pty=True)
+
+    def setup(self):
+        with self.host.cd_project_dir(self.config.app):
+            self.host.run(f"echo '{json.dumps(self._generate_config())}' > caddy.json")
+            self.host.run(
+                f"curl localhost:2019/load -H 'Content-Type: application/json' -d @caddy.json"
+            )
+
+    def teardown(self):
+        # TODO
+        pass
+
+    def _generate_config(self) -> dict:
+        return {
+            "apps": {
+                "http": {
+                    "servers": {
+                        self.config.app: {
+                            "listen": [":443"],
+                            "routes": [
+                                {
+                                    "match": [{"host": [self.host.config.domain_name]}],
+                                    "handle": [
+                                        {
+                                            "handler": "reverse_proxy",
+                                            "upstreams": [
+                                                {"dial": self.config.webserver.upstream}
+                                            ],
+                                        }
+                                    ],
+                                }
+                            ],
+                        }
+                    }
+                }
+            }
+        }

fujin/proxies/dummy.py

@@ -0,0 +1,16 @@
+from fujin.config import Config
+from fujin.host import Host
+
+
+class WebProxy:
+    host: Host
+    config: Config
+
+    def install(self):
+        pass
+
+    def setup(self):
+        pass
+
+    def teardown(self):
+        pass

fujin/proxies/nginx.py

@@ -0,0 +1,59 @@
+import msgspec
+
+from fujin.config import Config
+from fujin.host import Host
+
+CERTBOT_EMAIL = ""
+
+# TODO: this is a wip
+
+
+class WebProxy(msgspec.Struct):
+    host: Host
+    config: Config
+
+    def install(self):
+        # TODO: won"t always install the latest version, install certbot with uv ?
+        self.host.sudo(
+            "apt install -y nginx libpq-dev python3-dev python3-certbot-nginx sqlite3"
+        )
+
+    def setup(self):
+        self.host.sudo(
+            f"echo '{self._get_config()}' | sudo tee /etc/nginx/sites-available/{self.config.app}",
+            hide="out",
+        )
+        self.host.sudo(
+            f"ln -sf /etc/nginx/sites-available/{self.config.app} /etc/nginx/sites-enabled/{self.config.app}"
+        )
+        self.host.sudo(
+            f"certbot --nginx -d {self.host.config.domain_name} --non-interactive --agree-tos --email {CERTBOT_EMAIL} --redirect"
+        )
+        # Updating local Nginx configuration
+        self.host.get(
+            f"/etc/nginx/sites-available/{self.config.app}",
+            f".fujin/{self.config.app}",
+        )
+        # Enabling certificate auto-renewal
+        self.host.sudo("systemctl enable certbot.timer")
+        self.host.sudo("systemctl start certbot.timer")
+
+    def teardown(self):
+        pass
+
+    def _get_config(self) -> str:
+        return f"""
+server {{
+   listen 80;
+   server_name {self.host.config.domain_name};
+
+   location / {{
+      proxy_pass {self.config.webserver.upstream};
+      proxy_set_header Host $host;
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_set_header X-Forwarded-Proto $scheme;
+   }}
+}}
+
+"""

fujin/templates/other.service

@@ -0,0 +1,15 @@
+[Unit]
+Description={app} Worker
+
+[Service]
+User={user}
+Group=www-data
+WorkingDirectory={project_dir}
+ExecStart={command}
+EnvironmentFile={project_dir}/.env
+Restart=always
+#StandardOutput=append:/var/log/your_project/qcluster.out.log
+#StandardError=append:/var/log/your_project/qcluster.err.log
+
+[Install]
+WantedBy=multi-user.target

fujin/templates/web.service

@@ -0,0 +1,24 @@
+# TODO: add tons of comments in this file
+[Unit]
+Description={app} daemon
+Requires={app}.socket
+After=network.target
+
+[Service]
+Type=notify
+NotifyAccess=main
+User={user}
+Group=www-data
+RuntimeDirectory={app}
+WorkingDirectory={project_dir}
+ExecStart={project_dir}/{command}
+EnvironmentFile={project_dir}/.env
+ExecReload=/bin/kill -s HUP $MAINPID
+KillMode=mixed
+TimeoutStopSec=5
+PrivateTmp=true
+# if your app does not need administrative capabilities, let systemd know
+# ProtectSystem=strict
+
+[Install]
+WantedBy=multi-user.target

fujin/templates/web.socket

@@ -0,0 +1,11 @@
+[Unit]
+Description={app} socket
+
+[Socket]
+ListenStream=/run/{app}.sock
+SocketUser=www-data
+SocketGroup=www-data
+SocketMode=0660
+
+[Install]
+WantedBy=sockets.target

fujin_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.3
+Name: fujin-cli
+Version: 0.2.0
+Summary: Add your description here
+Project-URL: Documentation, https://github.com/falcopackages/fujin#readme
+Project-URL: Issues, https://github.com/falcopackages/fujin/issues
+Project-URL: Source, https://github.com/falcopackages/fujin
+Author-email: Tobi DEGNON <tobidegnon@proton.me>
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Requires-Dist: cappa>=0.24.0
+Requires-Dist: fabric>=3.2.2
+Requires-Dist: msgspec[toml]>=0.18.6
+Requires-Dist: rich>=13.9.2
+Description-Content-Type: text/markdown
+
+# fujin
+
+[![PyPI - Version](https://img.shields.io/pypi/v/fujin-cli.svg)](https://pypi.org/project/fujin-cli)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/fujin-cli.svg)](https://pypi.org/project/fujin-cli)
+
+-----
+
+> [!IMPORTANT]
+> This package currently contains no features and is a work-in-progress
+
+
+**Table of Contents**
+
+- [fujin](#fujin)
+  - [Installation](#installation)
+  - [License](#license)
+
+## Installation
+
+```console
+pip install fujin-cli
+```
+
+## License
+
+`fujin` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

fujin_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+fujin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fujin/__main__.py,sha256=cmbkKqDbGyc_himfDstDjC5SRi07-rU3oxWgoL_v_6c,1278
+fujin/config.py,sha256=5g_KYGc3IDdHLZRLYiw55hGob85Yxovm-47JHiEXcYE,3896
+fujin/errors.py,sha256=74Rh-Sgql1YspPdR_akQ2G3xZ48zecyafYCptpaFo1A,73
+fujin/hooks.py,sha256=Nmi0psj0cwomSaJM6l0r2V5iVn1x0xdrazW1CRQ2wyw,346
+fujin/host.py,sha256=uNYeYO2J5PQ7U3W8Olng7MuRK6uzIoom2yDNX914F14,3023
+fujin/commands/__init__.py,sha256=-9mrBJHtwQELh58HlMEjCE60nowtGzySy4-inph3YY0,78
+fujin/commands/_base.py,sha256=IYK7rXB5QW2Ac4pcgafQTjB1SPPht1ERWE_5WFzdSfo,2765
+fujin/commands/app.py,sha256=Cu3EW1FbOqR40ArsbBpwA3nLCX41leys398obc5lRbM,2347
+fujin/commands/config.py,sha256=bfWCyGYz-n-VNtcs-HiKXB7eP-K_YQkBGTPAqetVYYU,6136
+fujin/commands/deploy.py,sha256=gHrqPdZ8btB9CcwjVv1BDwbeD0RIoMALIeh7cNzUsm8,2032
+fujin/commands/down.py,sha256=iUneVfELnWmh-9NqVGCAwhF1nGSp4mZQAmW6_ER_DTg,1109
+fujin/commands/redeploy.py,sha256=3xtExNvNHDoXgWsY3-evZnBHAEaGKRVyAB4h-9YiVpM,533
+fujin/commands/server.py,sha256=UOl4pQWfj_sCc5l5EBx2PQ8UqIrMuEBJyuT-DvXFK1E,2186
+fujin/commands/up.py,sha256=kkHbNSzTogA_vGqPwzK8a85Hey3rPHSmz2YRqWeQ100,450
+fujin/process_managers/__init__.py,sha256=izJCtaGO-Fwptx4NHHjp8eOFuWfgjRMjt6YiQ0ZkXbA,672
+fujin/process_managers/systemd.py,sha256=Ltt9i1EaY2Ip4WdbcSmuRVvv-Z04lm5izuOT3hxJB1M,3770
+fujin/proxies/__init__.py,sha256=j3YdWdDBAfJ0-EL4APR0gkwTFkZ0BcUJQ_wg8bWVsGE,335
+fujin/proxies/caddy.py,sha256=ehngeBOpUWqR7bJLjdVtoMhEqwStS3FZrZBzzhdA0-g,1620
+fujin/proxies/dummy.py,sha256=Ur1mNxQGBmVLNJ0PV2ODR0fDw8VDItJ6-P1GOUc6o1o,222
+fujin/proxies/nginx.py,sha256=1vNzxtulx6tWe-lW5JV9fK7XrZWdf9_v-VjyHdgHEXQ,1686
+fujin/templates/other.service,sha256=XJUaQ0MxRuqT6KNkcn5ZPrjVtWh1zY9qbOzIhxGYOms,331
+fujin/templates/web.service,sha256=TVMELmlOVo_SZxUqkpyizvZeX0T4b1sL1WVpbJ0D-DE,528
+fujin/templates/web.socket,sha256=W5EtR-J1GNMaMqZDQduSjG2JY7gFFPKEDpPolFus9c0,163
+fujin_cli-0.2.0.dist-info/METADATA,sha256=ahTCcNWwl7V9Zs0RWVH1UJ_L0EURdJliSr7d-wuK1Js,1660
+fujin_cli-0.2.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+fujin_cli-0.2.0.dist-info/entry_points.txt,sha256=Y_TBtKt3j11qhwquMexZR5yqnDEqOBDACtresqQFE-s,46
+fujin_cli-0.2.0.dist-info/licenses/LICENSE.txt,sha256=0QF8XfuH0zkIHhSet6teXfiCze6JSdr8inRkmLLTDyo,1099
+fujin_cli-0.2.0.dist-info/RECORD,,

fujin_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fujin = fujin.__main__:main