trobz-deploy 0.9.0__py3-none-any.whl

trobz_deploy/cli.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import click
+
+from trobz_deploy.command.configure import configure
+from trobz_deploy.command.status import status
+from trobz_deploy.command.update import update
+
+
+@click.group()
+@click.option(
+    "--config",
+    default="deploy.yml",
+    show_default=True,
+    metavar="FILE",
+    help="Path to the configuration file.",
+)
+@click.option(
+    "--verbose",
+    is_flag=True,
+    default=False,
+    help="Print each remote command and its output as it runs.",
+)
+@click.pass_context
+def cli(ctx: click.Context, config: str, verbose: bool) -> None:
+    """Deploy and manage applications on remote servers over SSH."""
+    ctx.ensure_object(dict)
+    ctx.obj["config"] = config
+    ctx.obj["verbose"] = verbose
+
+
+cli.add_command(configure)
+cli.add_command(update)
+cli.add_command(status)

trobz_deploy/command/configure.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from trobz_deploy.utils.config import load_config, resolve_options
+from trobz_deploy.utils.executor import Executor, ExecutorError
+from trobz_deploy.utils.render import render_unit
+from trobz_deploy.utils.venv import setup_odoo_venv, setup_package_venv, setup_python_venv
+
+
+def _is_git_repo(executor: Executor, path: str) -> bool:
+    try:
+        executor.run(f"test -d {path}/.git")
+    except ExecutorError:
+        return False
+    else:
+        return True
+
+
+@click.command()
+@click.argument("instance_name")
+@click.argument("ssh_host", required=False)
+@click.argument("repo_url", required=False)
+@click.option(
+    "--type",
+    "deploy_type",
+    type=click.Choice(["odoo", "python", "service"]),
+    default=None,
+    help="Deployment type (auto-detected from instance name prefix if omitted).",
+)
+@click.option(
+    "-p",
+    "--port",
+    "ssh_port",
+    type=int,
+    default=None,
+    help="SSH port on the remote host.",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    default=False,
+    help="Re-run setup steps even if the instance directory already exists.",
+)
+@click.option(
+    "--repo-subdir",
+    "repo_subdir",
+    default=None,
+    help="Subdirectory within the repo to use as the service root (for monorepos).",
+)
+@click.option(
+    "--repo-branch",
+    "repo_branch",
+    default=None,
+    help="Git branch to clone and track (defaults to the repository's default branch).",
+)
+@click.pass_context
+def configure(  # noqa: C901
+    ctx: click.Context,
+    instance_name: str,
+    ssh_host: str | None,
+    repo_url: str | None,
+    deploy_type: str | None,
+    ssh_port: int | None,
+    force: bool,
+    repo_subdir: str | None,
+    repo_branch: str | None,
+) -> None:
+    """Configure a new deployment instance."""
+    cfg = load_config(ctx.obj["config"], instance_name)
+    try:
+        opts = resolve_options(
+            cfg,
+            instance_name,
+            ssh_host=ssh_host,
+            ssh_port=ssh_port,
+            repo_url=repo_url,
+            repo_branch=repo_branch,
+            deploy_type=deploy_type,
+            repo_subdir=repo_subdir,
+        )
+    except ValueError as exc:
+        raise click.ClickException(click.style(str(exc), fg="red")) from exc
+
+    eff_ssh_host: str | None = opts.get("ssh_host")
+    eff_ssh_port: int | None = opts.get("ssh_port")
+    eff_repo_url: str | None = opts.get("repo_url")
+    eff_repo_branch: str | None = opts.get("repo_branch")
+    eff_type: str = opts["type"]
+    _req = opts.get("requirements")
+    eff_requirements: list[str] = ([_req] if isinstance(_req, str) else _req) if _req else []
+
+    if eff_type == "python" and eff_requirements and eff_repo_url:
+        msg = click.style(
+            "requirements and repo_url are mutually exclusive for python type.",
+            fg="red",
+        )
+        raise click.ClickException(msg)
+
+    executor = Executor(eff_ssh_host, ctx.obj["verbose"], ssh_port=eff_ssh_port)
+    home_dir = executor.capture("echo $HOME")
+    instance_path = f"{home_dir}/{instance_name}"
+    eff_repo_subdir: str | None = opts.get("repo_subdir")
+    service_path = f"{instance_path}/{eff_repo_subdir}" if eff_repo_subdir else instance_path
+
+    # Step 2: Set up instance directory
+    if eff_type == "python" and eff_requirements:
+        # Package mode: create directory directly, no git clone
+        try:
+            executor.run(f"test -d {instance_path}")
+            if not force:
+                msg = click.style(
+                    f"Instance directory already exists: ~/{instance_name}\nUse --force to re-run setup.",
+                    fg="yellow",
+                )
+                raise click.ClickException(msg)
+            click.secho("\nDirectory exists, skipping mkdir (--force).", fg="yellow")
+        except ExecutorError:
+            click.secho(f"\nCreating instance directory ~/{instance_name}…", fg="green")
+            executor.run(f"mkdir -p {instance_path}")
+    else:
+        if not eff_repo_url:
+            msg = click.style(
+                "repo_url is required. Provide it as an argument or set it in deploy.yml.",
+                fg="red",
+            )
+            raise click.ClickException(msg)
+
+        # Repo mode: clone
+        if _is_git_repo(executor, instance_path):
+            if not force:
+                msg = click.style(
+                    f"Instance directory already exists: ~/{instance_name}\n"
+                    "Use --force to skip cloning and re-run setup.",
+                    fg="yellow",
+                )
+                raise click.ClickException(msg)
+            click.secho("\nDirectory exists, skipping clone (--force).", fg="yellow")
+        else:
+            click.secho(f"\nCloning {eff_repo_url} into ~/{instance_name}…", fg="green")
+            try:
+                clone_cmd = f"git clone {eff_repo_url} $HOME/{instance_name}"
+                if eff_repo_branch:
+                    clone_cmd += f" --branch {eff_repo_branch}"
+                executor.run(clone_cmd)
+            except ExecutorError as exc:
+                msg = click.style(f"Git clone failed: {exc}", fg="red")
+                raise click.ClickException(msg) from exc
+
+    if eff_type == "odoo":
+        executor.run(
+            "if [ -f addons/repos.yaml ]; then cd addons/ && gitaggregate -c repos.yaml; fi",
+            cwd=instance_path,
+        )
+
+    # Step 3: Set up environment
+    click.secho(f"\nSetting up {eff_type} environment…", fg="green")
+    try:
+        if eff_type == "odoo":
+            setup_odoo_venv(executor, instance_path)
+        elif eff_type == "python":
+            if eff_requirements:
+                setup_package_venv(executor, instance_path, eff_requirements, force=force)
+            else:
+                setup_python_venv(executor, service_path, force=force)
+                executor.run(
+                    "if [ -f .env.example ] && [ ! -f .env ]; then cp .env.example .env; fi",
+                    cwd=service_path,
+                )
+        else:  # service
+            build_cmd: str | None = opts.get("build")
+            if not build_cmd:
+                msg = click.style(
+                    "build command is required for service type. Set it in deploy.yml.",
+                    fg="red",
+                )
+                raise click.ClickException(msg)
+            executor.run(build_cmd, cwd=service_path)
+    except ExecutorError as exc:
+        raise click.ClickException(click.style(str(exc), fg="red")) from exc
+
+    # Step 4: Install systemd unit
+    click.secho("\nInstalling systemd unit…", fg="green")
+    unit_instance_path = instance_path if eff_requirements else service_path
+    venv_path = f"{unit_instance_path}/.venv"
+
+    template_vars: dict[str, Any] = {
+        "instance_name": instance_name,
+        "instance_path": unit_instance_path,
+    }
+    if eff_type == "odoo":
+        template_vars["venv_path"] = venv_path
+        odoo_addons_path = executor.capture("which odoo-addons-path")
+        template_vars["odoo_addons_path"] = odoo_addons_path
+    else:
+        exec_start: str = opts.get("exec_start", "")
+        if not exec_start and not eff_requirements:
+            res = executor.capture(
+                "if [ -f server.py ]; then echo server.py; fi",
+                cwd=service_path,
+            )
+            if res == "server.py":
+                exec_start = "python server.py"
+        if not exec_start:
+            msg = click.style(
+                "exec_start is required for service or python type. Set it in deploy.yml.",
+                fg="red",
+            )
+            raise click.ClickException(msg)
+        if eff_type == "python":
+            template_vars["venv_path"] = venv_path
+        template_vars["exec_start"] = exec_start
+
+    try:
+        unit_content = render_unit(eff_type, **template_vars)
+    except Exception as exc:
+        msg = click.style(f"Template rendering failed: {exc}", fg="red")
+        raise click.ClickException(msg) from exc
+
+    unit_dir = "$HOME/.config/systemd/user"
+    unit_path = f"{unit_dir}/{instance_name}.service"
+    try:
+        executor.run(f"mkdir -p {unit_dir}")
+        executor.write_file(unit_content, unit_path)
+        executor.run("loginctl enable-linger")
+        executor.run("systemctl --user daemon-reload")
+        executor.run(f"systemctl --user enable --now {instance_name}")
+    except ExecutorError as exc:
+        raise click.ClickException(click.style(str(exc), fg="red")) from exc
+
+    click.secho(f"\nInstance {instance_name!r} configured successfully.", fg="green")

trobz_deploy/command/status.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import click
+
+from trobz_deploy.utils.config import load_config
+from trobz_deploy.utils.executor import Executor, ExecutorError
+
+
+@click.command()
+@click.argument("instance_name")
+@click.argument("ssh_host", required=False)
+@click.option(
+    "-p",
+    "--port",
+    "ssh_port",
+    type=int,
+    default=None,
+    help="SSH port on the remote host.",
+)
+@click.pass_context
+def status(
+    ctx: click.Context,
+    instance_name: str,
+    ssh_host: str | None,
+    ssh_port: int | None,
+) -> None:
+    """Show status of a deployment instance."""
+    cfg = load_config(ctx.obj["config"], instance_name)
+
+    # Resolve ssh_host/ssh_port: CLI arg > config value
+    eff_ssh_host: str | None = ssh_host if ssh_host is not None else cfg.get("ssh_host")
+    eff_ssh_port: int | None = ssh_port if ssh_port is not None else cfg.get("ssh_port")
+
+    executor = Executor(eff_ssh_host, ctx.obj["verbose"], ssh_port=eff_ssh_port)
+    instance_path = f"$HOME/{instance_name}"
+
+    # Step 2: Verify instance directory exists
+    try:
+        executor.run(f"test -d {instance_path}")
+    except ExecutorError:
+        msg = f"Instance directory not found: ~/{instance_name}"
+        raise click.ClickException(msg) from None
+
+    # Step 3: Git info
+    try:
+        remote_url = executor.capture("git remote get-url origin", cwd=instance_path)
+        branch = executor.capture("git rev-parse --abbrev-ref HEAD", cwd=instance_path)
+        commit = executor.capture("git rev-parse --short HEAD", cwd=instance_path)
+    except ExecutorError as exc:
+        msg = f"Failed to get git info: {exc}"
+        raise click.ClickException(msg) from exc
+
+    # Step 4: systemd unit status
+    unit_line = "unknown"
+    try:
+        raw = executor.capture(
+            f"systemctl --user show {instance_name} --property=ActiveState,SubState,ActiveEnterTimestamp"
+        )
+        props: dict[str, str] = {}
+        for line in raw.splitlines():
+            if "=" in line:
+                key, _, val = line.partition("=")
+                props[key.strip()] = val.strip()
+
+        active = props.get("ActiveState", "unknown")
+        sub = props.get("SubState", "unknown")
+        ts = props.get("ActiveEnterTimestamp", "")
+        # Timestamp format: "Mon 2026-03-09 08:12:03 UTC"
+        since = " ".join(ts.split()[1:3]) if ts else ""
+        unit_line = f"{active} ({sub})"
+        if since:
+            unit_line += f" since {since}"
+    except ExecutorError:
+        pass
+
+    click.echo(f"Instance:  {instance_name}")
+    click.echo(f"Remote:    {remote_url}")
+    click.echo(f"Branch:    {branch} ({commit})")
+    click.echo(f"Unit:      {unit_line}")

trobz_deploy/command/update.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import click
+
+from trobz_deploy.utils.addons import get_addons_path
+from trobz_deploy.utils.config import load_config, resolve_options
+from trobz_deploy.utils.executor import Executor, ExecutorError
+from trobz_deploy.utils.venv import setup_python_deps, upgrade_package
+
+
+@click.command()
+@click.argument("instance_name")
+@click.argument("ssh_host", required=False)
+@click.option(
+    "--type",
+    "deploy_type",
+    type=click.Choice(["odoo", "python", "service"]),
+    default=None,
+    help="Deployment type (auto-detected from instance name prefix if omitted).",
+)
+@click.option(
+    "--db",
+    default=None,
+    help="Override the target database name (Odoo only).",
+)
+@click.option(
+    "-p",
+    "--port",
+    "ssh_port",
+    type=int,
+    default=None,
+    help="SSH port on the remote host.",
+)
+@click.option(
+    "--ignore-hooks",
+    "ignore_hooks",
+    is_flag=True,
+    default=False,
+    help="Skip all hook execution.",
+)
+@click.option(
+    "--repo-subdir",
+    "repo_subdir",
+    default=None,
+    help="Subdirectory within the repo to use as the service root (for monorepos).",
+)
+@click.option(
+    "--repo-branch",
+    "repo_branch",
+    default=None,
+    help="Git branch to pull (defaults to the currently checked-out branch).",
+)
+@click.option(
+    "--watch",
+    "watch",
+    is_flag=True,
+    default=False,
+    help="Stream service logs with journalctl after a successful update.",
+)
+@click.pass_context
+def update(  # noqa: C901
+    ctx: click.Context,
+    instance_name: str,
+    ssh_host: str | None,
+    deploy_type: str | None,
+    db: str | None,
+    ssh_port: int | None,
+    ignore_hooks: bool,
+    repo_subdir: str | None,
+    repo_branch: str | None,
+    watch: bool,
+) -> None:
+    """Update an existing deployment instance."""
+    cfg = load_config(ctx.obj["config"], instance_name)
+    try:
+        opts = resolve_options(
+            cfg,
+            instance_name,
+            ssh_host=ssh_host,
+            ssh_port=ssh_port,
+            deploy_type=deploy_type,
+            db=db,
+            repo_subdir=repo_subdir,
+            repo_branch=repo_branch,
+        )
+    except ValueError as exc:
+        raise click.ClickException(click.style(str(exc), fg="red")) from exc
+
+    eff_ssh_host: str | None = opts.get("ssh_host")
+    eff_ssh_port: int | None = opts.get("ssh_port")
+    eff_type: str = opts["type"]
+    eff_db: str = opts.get("db", instance_name)
+    eff_repo_branch: str | None = opts.get("repo_branch")
+    _req = opts.get("requirements")
+    eff_requirements: list[str] = ([_req] if isinstance(_req, str) else _req) if _req else []
+    hooks: dict = opts.get("hooks", {})
+
+    executor = Executor(eff_ssh_host, ctx.obj["verbose"], ssh_port=eff_ssh_port)
+    home_dir = executor.capture("echo $HOME")
+    instance_path = f"{home_dir}/{instance_name}"
+    eff_repo_subdir: str | None = opts.get("repo_subdir")
+    service_path = f"{instance_path}/{eff_repo_subdir}" if eff_repo_subdir else instance_path
+
+    def run_hooks(hook_name: str) -> bool:
+        """Execute all commands for *hook_name*. Returns True if all succeeded."""
+        if ignore_hooks:
+            return True
+        for cmd in hooks.get(hook_name, []):
+            try:
+                executor.run(cmd, cwd=instance_path)
+            except ExecutorError as exc:
+                click.secho(
+                    f"Hook {hook_name!r} failed: {exc}",
+                    fg="red",
+                    err=True,
+                )
+                return False
+        return True
+
+    # Step 2: pre-update hooks (non-blocking)
+    click.secho("\nRunning pre-update hooks…", fg="green")
+    run_hooks("pre-update")
+
+    # Step 3: pre-update-required hooks (blocking on failure)
+    click.secho("\nRunning pre-update-required hooks…", fg="green")
+    if not run_hooks("pre-update-required"):
+        run_hooks("pre-update-fail")
+        msg = click.style(
+            "pre-update-required hook failed. Update aborted.",
+            fg="red",
+        )
+        raise click.ClickException(msg)
+
+    # Step 4: pre-update-success
+    run_hooks("pre-update-success")
+
+    # Step 5+6: Pull/upgrade code and update dependencies
+    if eff_type == "python" and eff_requirements:
+        # Package mode: upgrade pip package directly, no git pull
+        click.secho("\nUpgrading package…", fg="green")
+        try:
+            upgrade_package(executor, instance_path, eff_requirements)
+        except ExecutorError as exc:
+            run_hooks("post-update")
+            run_hooks("post-update-fail")
+            msg = click.style(f"Package upgrade failed: {exc}", fg="red")
+            raise click.ClickException(msg) from exc
+    else:
+        # Repo mode: git pull then update deps
+        try:
+            executor.run(f"test -d {instance_path}/.git")
+        except ExecutorError:
+            msg = click.style(
+                f"Instance directory not found or not a git repo: ~/{instance_name}",
+                fg="red",
+            )
+            raise click.ClickException(msg) from None
+
+        click.secho("\nPulling latest code…", fg="green")
+        try:
+            if eff_repo_branch:
+                executor.run(
+                    f"git fetch origin && git checkout {eff_repo_branch} && git pull",
+                    cwd=instance_path,
+                )
+            else:
+                executor.run("git pull", cwd=instance_path)
+        except ExecutorError as exc:
+            run_hooks("post-update")
+            run_hooks("post-update-fail")
+            msg = click.style(f"git pull failed: {exc}", fg="red")
+            raise click.ClickException(msg) from exc
+
+        click.secho("\nUpdating dependencies…", fg="green")
+        try:
+            if eff_type == "odoo":
+                executor.run(
+                    "if [ -f addons/repos.yaml ]; then cd addons/ && gitaggregate -c repos.yaml; fi",
+                    cwd=instance_path,
+                )
+                executor.run("odoo-venv update .venv --backup --yes", cwd=instance_path)
+            elif eff_type == "python":
+                setup_python_deps(executor, service_path)
+            else:  # service
+                build_cmd: str | None = opts.get("build")
+                if build_cmd:
+                    executor.run(build_cmd, cwd=service_path)
+        except ExecutorError as exc:
+            run_hooks("post-update")
+            run_hooks("post-update-fail")
+            msg = click.style(f"Dependency update failed: {exc}", fg="red")
+            raise click.ClickException(msg) from exc
+
+    # Step 7: Apply changes
+    click.secho("\nApplying changes…", fg="green")
+    try:
+        if eff_type == "odoo":
+            addons_path = get_addons_path(executor, instance_path)
+            executor.run(
+                f".venv/bin/click-odoo-update -d {eff_db} --addons-path={addons_path}",
+                cwd=instance_path,
+            )
+        executor.run(f"systemctl --user restart {instance_name}")
+    except ExecutorError as exc:
+        run_hooks("post-update")
+        run_hooks("post-update-fail")
+        msg = click.style(f"Restart/upgrade failed: {exc}", fg="red")
+        raise click.ClickException(msg) from exc
+
+    # Step 8: post-update hooks
+    run_hooks("post-update")
+    run_hooks("post-update-success")
+
+    click.secho(f"\nInstance {instance_name!r} updated successfully.", fg="green")
+
+    if watch:
+        click.secho("\nWatching service logs (Ctrl+C to stop)…", fg="cyan")
+        try:
+            executor.stream(f"journalctl --user -u {instance_name} -f")
+        except KeyboardInterrupt:
+            click.echo()

trobz_deploy/templates/odoo.service.j2

@@ -0,0 +1,15 @@
+[Unit]
+Description=Odoo instance {{ instance_name }}
+After=network.target postgresql.service
+
+[Service]
+Type=simple
+WorkingDirectory={{ instance_path }}
+ExecStart=bash -c "{{ venv_path }}/bin/python {{ venv_path }}/bin/odoo \
+    --config {{ instance_path }}/config/odoo.conf \
+    --addons-path $({{ odoo_addons_path }} {{ instance_path }})"
+Restart=on-failure
+RestartSec=5s
+
+[Install]
+WantedBy=default.target

trobz_deploy/templates/python.service.j2

@@ -0,0 +1,14 @@
+[Unit]
+Description=Python service {{ instance_name }}
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory={{ instance_path }}
+EnvironmentFile=-{{ instance_path }}/.env
+ExecStart={{ venv_path }}/bin/{{ exec_start }}
+Restart=on-failure
+RestartSec=5s
+
+[Install]
+WantedBy=default.target

trobz_deploy/templates/service.service.j2

@@ -0,0 +1,13 @@
+[Unit]
+Description={{ instance_name }}
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory={{ instance_path }}
+ExecStart={{ exec_start }}
+Restart=on-failure
+RestartSec=5s
+
+[Install]
+WantedBy=default.target

trobz_deploy/utils/addons.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from trobz_deploy.utils.executor import Executor
+
+
+def get_addons_path(executor: Executor, instance_path: str) -> str:
+    """Run ``odoo-addons-path`` in *instance_path* and return the result."""
+    return executor.capture("odoo-addons-path", cwd=instance_path)