fujin-cli 0.7.1__tar.gz → 0.9.0__tar.gz

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to this project will be documented in this file.
 
 This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.9.0] - 2024-11-23
+
+### 🚀 Features
+
+- Env content can be define directly in toml
+
+### 🚜 Refactor
+
+- Avoid running secret adapter if no secret placeholder is found
+
+## [0.8.0] - 2024-11-23
+
+### 🚀 Features
+
+- Rewrite hooks (#30)
+
 ## [0.7.1] - 2024-11-23
 
 ### 🐛 Bug Fixes

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fujin-cli
-Version: 0.7.1
+Version: 0.9.0
 Summary: Get your project up and running in a few minutes on your own vps.
 Project-URL: Documentation, https://github.com/falcopackages/fujin#readme
 Project-URL: Issues, https://github.com/falcopackages/fujin/issues

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/docs/configuration.rst

@@ -20,7 +20,7 @@ This is a minimal working example.
             from fujin.commands.init import simple_config
             from tomli_w import dumps
 
-            print(dumps(simple_config("bookstore")))
+            print(dumps(simple_config("bookstore"),  multiline_strings=True))
             #hide:toggle
 
     .. tab-item:: binary mode
@@ -32,5 +32,5 @@ This is a minimal working example.
             from fujin.commands.init import binary_config
             from tomli_w import dumps
 
-            print(dumps(binary_config("bookstore")))
+            print(dumps(binary_config("bookstore"),  multiline_strings=True))
             #hide:toggle

fujin_cli-0.9.0/docs/hooks.rst

@@ -0,0 +1,41 @@
+Hooks
+=====
+
+Hooks allow you to run scripts at specific points in the deployment process. These scripts can perform checks before deployment, run tests, or send a notification after a successful deployment.
+
+The currently available ``hooks`` are:
+
+- ``pre_build``: The first action executed when the ``deploy`` command is run, before your app is built.
+- ``pre_deploy``: Executed after app is built before the code is pushed to the remote server.
+- ``post_deploy``: Executed after a successful deployment.
+
+.. note::
+
+    Hooks are run on your local machine, not on the remote server. If they fail, the deployment process is stopped.
+
+You can specify hooks in the ``fujin.toml`` file like this:
+
+.. code-block::
+
+    [hooks]
+    pre_build = "echo 'hello'"
+
+.. tip::
+
+    Using a `justfile <https://just.systems/>`_ can be an easy way to write more complex scripts without adding new files.
+
+    .. code-block::
+
+        [hooks]
+        pre_build = "just run-some-checks"
+
+Alternatively, you can create a file with the hook's name in the ``.fujin/hooks`` folder and ensure the file is executable.
+
+.. code-block::
+    :caption: .fujin/hooks/pre_build
+
+    #!/usr/bin/env bash
+
+    echo 'hello'
+
+The ``hooks`` configuration takes precedence over files in the ``.fujin/hooks`` folder; you cannot mix and match both.

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/pyproject.toml

@@ -7,7 +7,7 @@ requires = [
 
 [project]
 name = "fujin-cli"
-version = "0.7.1"
+version = "0.9.0"
 description = "Get your project up and running in a few minutes on your own vps."
 readme = "README.md"
 keywords = [
@@ -154,7 +154,7 @@ lint.isort.required-imports = [
 lint.pyupgrade.keep-runtime-typing = true
 
 [tool.bumpversion]
-current_version = "0.7.1"
+current_version = "0.9.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = [
   "{major}.{minor}.{patch}",

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/src/fujin/commands/_base.py

@@ -33,6 +33,14 @@ class BaseCommand:
     def app_dir(self) -> str:
         return self.config.host.get_app_dir(app_name=self.config.app_name)
 
+    @cached_property
+    def hook_manager(self) -> HookManager:
+        return HookManager(
+            hooks=self.config.hooks,
+            app_name=self.config.app_name,
+            local_config_dir=self.config.local_config_dir,
+        )
+
     @contextmanager
     def connection(self):
         with host_connection(host=self.config.host) as conn:
@@ -70,8 +78,3 @@ class BaseCommand:
 
     def create_process_manager(self, conn: Connection) -> ProcessManager:
         return self.process_manager_class.create(conn=conn, config=self.config)
-
-    def create_hook_manager(self, conn: Connection) -> HookManager:
-        return HookManager(
-            conn=conn, hooks=self.config.hooks, app_name=self.config.app_name
-        )

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/src/fujin/commands/config.py

@@ -37,9 +37,17 @@ class ConfigCMD(BaseCommand):
             )
         )
 
+        host_config = {
+            f: getattr(self.config.host, f) for f in self.config.host.__struct_fields__
+        }
+        host_config.pop("_key_filename")
+        host_config.pop("_env_file")
+        host_config.pop("env_content")
+        if self.config.host.key_filename:
+            host_config["key_filename"] = self.config.host.key_filename
+        host_config["env_content"] = self.config.host.env_content
         host_config_text = "\n".join(
-            f"[dim]{key}:[/dim] {value}"
-            for key, value in self.config.host.to_dict().items()
+            f"[dim]{key}:[/dim] {value}" for key, value in host_config.items()
         )
         console.print(
             Panel(

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/src/fujin/commands/deploy.py

@@ -16,15 +16,15 @@ from fujin.secrets import resolve_secrets
 )
 class Deploy(BaseCommand):
     def __call__(self):
+        self.hook_manager.pre_build()
         parsed_env = self.parse_envfile()
         self.build_app()
-
+        self.hook_manager.pre_deploy()
         with self.connection() as conn:
             process_manager = self.create_process_manager(conn)
             conn.run(f"mkdir -p {self.app_dir}")
             conn.run(f"mkdir -p {self.versioned_assets_dir}")
             with conn.cd(self.app_dir):
-                self.create_hook_manager(conn).pre_deploy()
                 self.transfer_files(conn, env=parsed_env)
                 self.install_project(conn)
             with self.app_environment() as app_conn:
@@ -35,7 +35,7 @@ class Deploy(BaseCommand):
                 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.hook_manager.post_deploy()
         self.stdout.output("[green]Project deployment completed successfully![/green]")
         self.stdout.output(
             f"[blue]Access the deployed project at: https://{self.config.host.domain_name}[/blue]"
@@ -52,12 +52,12 @@ class Deploy(BaseCommand):
         return f"{self.app_dir}/v{self.config.version}"
 
     def parse_envfile(self) -> str:
-        if not self.config.host.envfile.exists():
-            raise cappa.Exit(f"{self.config.host.envfile} not found", code=1)
         if self.config.secret_config:
             self.stdout.output("[blue]Reading secrets....[/blue]")
-            return resolve_secrets(self.config.host.envfile, self.config.secret_config)
-        return self.config.host.envfile.read_text()
+            return resolve_secrets(
+                self.config.host.env_content, self.config.secret_config
+            )
+        return self.config.host.env_content
 
     def transfer_files(
         self, conn: Connection, env: str, skip_requirements: bool = False

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/src/fujin/commands/down.py

@@ -33,8 +33,6 @@ class Down(BaseCommand):
         if not confirm:
             return
         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()
@@ -42,7 +40,6 @@ class Down(BaseCommand):
             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_cli-0.7.1 → fujin_cli-0.9.0}/src/fujin/commands/init.py

@@ -31,7 +31,7 @@ class Init(BaseCommand):
         }
         app_name = Path().resolve().stem.replace("-", "_").replace(" ", "_").lower()
         config = profile_to_func[self.profile](app_name)
-        fujin_toml.write_text(tomli_w.dumps(config))
+        fujin_toml.write_text(tomli_w.dumps(config, multiline_strings=True))
         self.stdout.output(
             "[green]Sample configuration file generated successfully![/green]"
         )
@@ -57,7 +57,7 @@ def simple_config(app_name) -> dict:
         "host": {
             "user": "root",
             "domain_name": f"{app_name}.com",
-            "envfile": ".env.prod",
+            "env_content": f"DEBUG=False\nALLOWED_HOSTS={app_name}.com\n",
         },
     }
     if not Path(".python-version").exists():

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/src/fujin/commands/printenv.py

@@ -11,8 +11,8 @@ class Printenv(BaseCommand):
     def __call__(self):
         if self.config.secret_config:
             result = resolve_secrets(
-                self.config.host.envfile, self.config.secret_config
+                self.config.host.env_content, self.config.secret_config
             )
         else:
-            result = self.config.host.envfile.read_text()
+            result = self.config.host.env_content
         self.stdout.output(result)

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/src/fujin/commands/redeploy.py

@@ -5,22 +5,21 @@ from pathlib import Path
 
 import cappa
 
-from .deploy import Deploy
 from fujin.commands import BaseCommand
 from fujin.config import InstallationMode
 from fujin.connection import Connection
+from .deploy import Deploy
 
 
 @cappa.command(help="Redeploy the application to apply code and environment changes")
 class Redeploy(BaseCommand):
     def __call__(self):
         deploy = Deploy()
+        self.hook_manager.pre_build()
         parsed_env = deploy.parse_envfile()
         deploy.build_app()
-
+        self.hook_manager.pre_deploy()
         with self.app_environment() as conn:
-            hook_manager = self.create_hook_manager(conn)
-            hook_manager.pre_deploy()
             conn.run(f"mkdir -p {deploy.versioned_assets_dir}")
             requirements_copied = self._copy_requirements_if_needed(conn)
             deploy.transfer_files(
@@ -30,8 +29,8 @@ class Redeploy(BaseCommand):
             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]")
+        self.hook_manager.post_deploy()
+        self.stdout.output("[green]Redeployment completed successfully![/green]")
 
     def _copy_requirements_if_needed(self, conn: Connection) -> bool:
         if (

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/src/fujin/commands/server.py

@@ -23,8 +23,6 @@ class Server(BaseCommand):
     @cappa.command(help="Setup uv, web proxy, and install necessary dependencies")
     def bootstrap(self):
         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)
@@ -33,7 +31,6 @@ class Server(BaseCommand):
                 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]"
             )

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/src/fujin/config.py

@@ -136,10 +136,18 @@ The login user for running remote tasks. Should have passwordless sudo access fo
 
     You can create a user with these requirements using the ``fujin server create-user`` command.
 
-envfile
-~~~~~~~
+env_file
+~~~~~~~~
 Path to the production environment file that will be copied to the host.
 
+env_content
+~~~~~~~~~~~
+A string containing the production environment variables, ideal for scenarios where most variables are retrieved from secrets and you prefer not to use a separate file.
+
+.. important::
+
+    ``env_file`` and ``env_content`` are mutually exclusive—you can define only one.
+
 apps_dir
 ~~~~~~~~
 
@@ -176,6 +184,9 @@ Example:
     dbconsole = "app exec -i dbshell" # open an interactive django database shell
     shell = "server exec --appenv -i bash" # SSH into the project directory with environment variables loaded
 
+hooks
+-----
+Run custom scripts at specific points with hooks. Check out the `hooks </hooks.html>`_ page for more information.
 
 """
 
@@ -268,28 +279,27 @@ class HostConfig(msgspec.Struct, kw_only=True):
     ip: str | None = None
     domain_name: str
     user: str
-    _envfile: str = msgspec.field(name="envfile")
+    _env_file: str = msgspec.field(name="envfile", default="")
+    env_content: str = ""
     apps_dir: str = ".local/share/fujin"
     password_env: str | None = None
     ssh_port: int = 22
     _key_filename: str | None = msgspec.field(name="key_filename", default=None)
 
     def __post_init__(self):
+        if self._env_file and self.env_content:
+            raise ImproperlyConfiguredError(
+                "Cannot set both 'env_content' and 'env_file' properties."
+            )
+        if not self.env_content:
+            envfile = Path(self._env_file)
+            if not envfile.exists():
+                raise ImproperlyConfiguredError(f"{self._env_file} not found")
+            self.env_content = envfile.read_text()
+        self.env_content = self.env_content.strip()
         self.apps_dir = f"/home/{self.user}/{self.apps_dir}"
         self.ip = self.ip or self.domain_name
 
-    def to_dict(self):
-        d = {f: getattr(self, f) for f in self.__struct_fields__}
-        d.pop("_key_filename")
-        d.pop("_envfile")
-        d["key_filename"] = self.key_filename
-        d["envfile"] = self.envfile
-        return d
-
-    @property
-    def envfile(self) -> Path:
-        return Path(self._envfile)
-
     @property
     def key_filename(self) -> Path | None:
         if self._key_filename:

fujin_cli-0.9.0/src/fujin/hooks.py

@@ -0,0 +1,59 @@
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+import cappa
+from rich import print as rich_print
+
+try:
+    from enum import StrEnum
+except ImportError:
+    from enum import Enum
+
+    class StrEnum(str, Enum):
+        pass
+
+
+class Hook(StrEnum):
+    PRE_BUILD = "pre_build"
+    PRE_DEPLOY = "pre_deploy"
+    POST_DEPLOY = "post_deploy"
+
+
+HooksDict = dict[Hook, str]
+
+
+@dataclass(slots=True)
+class HookManager:
+    app_name: str
+    hooks: HooksDict
+    local_config_dir: Path
+
+    def __post_init__(self):
+        if self.hooks:
+            return
+        hooks_folder = self.local_config_dir / "hooks"
+        if not hooks_folder.exists():
+            return
+        self.hooks = {
+            h.value: f"./{hooks_folder / h.value}"  # noqa
+            for h in Hook
+            if (hooks_folder / h.value).exists()  # noqa
+        }
+
+    def _run_hook(self, type_: Hook) -> None:
+        if cmd := self.hooks.get(type_):
+            rich_print(f"[blue]Running {type_} hook[/blue]")
+            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+            if result.returncode != 0:
+                raise cappa.Exit(result.stderr)
+            rich_print(result.stdout)
+
+    def pre_build(self) -> None:
+        self._run_hook(Hook.PRE_BUILD)
+
+    def pre_deploy(self) -> None:
+        self._run_hook(Hook.PRE_DEPLOY)
+
+    def post_deploy(self) -> None:
+        self._run_hook(Hook.POST_DEPLOY)

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/src/fujin/secrets/__init__.py

@@ -1,19 +1,19 @@
 from __future__ import annotations
 
-from pathlib import Path
-from typing import Callable
+from contextlib import closing
+from io import StringIO
+from typing import Callable, ContextManager
 
 import gevent
 from dotenv import dotenv_values
 
-from .bitwarden import bitwarden
-from .onepassword import one_password
 from fujin.config import SecretAdapter
 from fujin.config import SecretConfig
-
+from .bitwarden import bitwarden
+from .onepassword import one_password
 
 secret_reader = Callable[[str], str]
-secret_adapter_context = Callable[[SecretConfig], secret_reader]
+secret_adapter_context = Callable[[SecretConfig], ContextManager[secret_reader]]
 
 adapter_to_context: dict[SecretAdapter, secret_adapter_context] = {
     SecretAdapter.BITWARDEN: bitwarden,
@@ -21,14 +21,17 @@ adapter_to_context: dict[SecretAdapter, secret_adapter_context] = {
 }
 
 
-def resolve_secrets(envfile: Path, secret_config: SecretConfig) -> str:
-    env_dict = dotenv_values(envfile)
+def resolve_secrets(env_content: str, secret_config: SecretConfig) -> str:
+    with closing(StringIO(env_content)) as buffer:
+        env_dict = dotenv_values(stream=buffer)
     secrets = {key: value for key, value in env_dict.items() if value.startswith("$")}
+    if not secrets:
+        return env_content
     adapter_context = adapter_to_context[secret_config.adapter]
     parsed_secrets = {}
-    with adapter_context(secret_config) as secret_reader:
+    with adapter_context(secret_config) as reader:
         for key, secret in secrets.items():
-            parsed_secrets[key] = gevent.spawn(secret_reader, secret[1:])
+            parsed_secrets[key] = gevent.spawn(reader, secret[1:])
         gevent.joinall(parsed_secrets.values())
     env_dict.update({key: thread.value for key, thread in parsed_secrets.items()})
     return "\n".join(f'{key}="{value}"' for key, value in env_dict.items())

{fujin_cli-0.7.1 → fujin_cli-0.9.0}/uv.lock

@@ -477,7 +477,7 @@ wheels = [
 
 [[package]]
 name = "fujin-cli"
-version = "0.7.1"
+version = "0.9.0"
 source = { editable = "." }
 dependencies = [
     { name = "cappa" },

fujin_cli-0.7.1/docs/hooks.rst

@@ -1,2 +0,0 @@
-Hooks
-=====

fujin_cli-0.7.1/src/fujin/hooks.py

@@ -1,56 +0,0 @@
-from dataclasses import dataclass
-
-from rich import print as rich_print
-
-from fujin.connection import Connection
-
-try:
-    from enum import StrEnum
-except ImportError:
-    from enum import Enum
-
-    class StrEnum(str, Enum):
-        pass
-
-
-class Hook(StrEnum):
-    PRE_DEPLOY = "pre_deploy"
-    POST_DEPLOY = "post_deploy"
-    PRE_BOOTSTRAP = "pre_bootstrap"
-    POST_BOOTSTRAP = "post_bootstrap"
-    PRE_TEARDOWN = "pre_teardown"
-    POST_TEARDOWN = "post_teardown"
-
-
-HooksDict = dict[Hook, dict]
-
-
-@dataclass(frozen=True, slots=True)
-class HookManager:
-    app_name: str
-    hooks: HooksDict
-    conn: Connection
-
-    def _run_hook(self, type_: Hook) -> None:
-        if hooks := self.hooks.get(type_):
-            for name, command in hooks.items():
-                rich_print(f"[blue]Running {type_} hook {name} [/blue]")
-                self.conn.run(command, pty=True)
-
-    def pre_deploy(self) -> None:
-        self._run_hook(Hook.PRE_DEPLOY)
-
-    def post_deploy(self) -> None:
-        self._run_hook(Hook.POST_DEPLOY)
-
-    def pre_bootstrap(self) -> None:
-        self._run_hook(Hook.PRE_BOOTSTRAP)
-
-    def post_bootstrap(self) -> None:
-        self._run_hook(Hook.POST_BOOTSTRAP)
-
-    def pre_teardown(self) -> None:
-        self._run_hook(Hook.PRE_TEARDOWN)
-
-    def post_teardown(self) -> None:
-        self._run_hook(Hook.POST_TEARDOWN)