quoll-cli 0.2.0__py3-none-any.whl

quoll/commands/docker.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Optional
+
+import questionary
+import typer
+from rich.table import Table
+
+from quoll import languages
+from quoll.ci.config import ConfigError as CIConfigError
+from quoll.ci.config import load_config as load_ci_config
+from quoll.ci.detect import Detection, detect
+from quoll.commands._common import (
+    DirOption,
+    ask,
+    check_files,
+    confirm_overwrite,
+    resolve_dir,
+    supported_hint,
+    update_files,
+)
+from quoll.config import quoll_toml
+from quoll.console import console
+from quoll.docker import render
+from quoll.docker.config import CONFIG_FILE, ConfigError, DockerConfig, load_config, save_config
+from quoll.docker.detect import default_config, image_defaults
+from quoll.files import write
+from quoll.languages.base import DockerDefaults
+from quoll.workspace import find_root, load_workspace, member_name
+
+app = typer.Typer(help="Generate and maintain the Dockerfile of a project.", no_args_is_help=True)
+
+
+@app.command()
+def init(
+    project_dir: Path = DirOption,
+    yes: bool = typer.Option(False, "--yes", "-y", help="Accept detected defaults without asking."),
+    force: bool = typer.Option(False, "--force", help="Overwrite a Dockerfile that was not generated by quoll."),
+    command: str = typer.Option("", "--command", help="What the container runs, when quoll can't infer it."),
+) -> None:
+    """Detect the project, write quoll.toml and generate a Dockerfile, .dockerignore and compose.yaml.
+
+    At the root of a workspace: for each of its projects."""
+    project_dir = resolve_dir(project_dir)
+    members = _members(project_dir)
+    if members is None:
+        _init(project_dir, yes=yes, force=force, command=command)
+        return
+    for member in members:
+        if force or "docker" not in _read(project_dir / member):
+            _init(project_dir / member, yes=yes, force=force, command=command, label=member)
+    files = _workspace_files(project_dir)
+    if files and confirm_overwrite(files, yes=yes, force=force):
+        write(project_dir, files)
+        console.print(f"\n[green]✓[/green] {files[0].path} (the whole workspace)")
+        console.print("\n[bold green]Done![/bold green] Run every project and its services:")
+        console.print("  docker compose up --build")
+
+
+def _init(project_dir: Path, *, yes: bool, force: bool, command: str, label: str = "") -> None:
+    console.print(f"\n[bold]quoll docker[/bold] — {label or project_dir.name}\n")
+
+    if "docker" in _read(project_dir) and not force:
+        if yes or not ask(questionary.confirm(
+            f"{CONFIG_FILE} already configures Docker. Detect again and replace it?", default=False
+        )):
+            console.print("Nothing changed. Use [bold]quoll docker update[/bold] to regenerate from quoll.toml.")
+            raise typer.Exit(0)
+
+    det = detect(project_dir)
+    if det.stack is None:
+        console.print(f"[red]Error:[/red] no supported project found.\n{supported_hint()}")
+        raise typer.Exit(1)
+    try:
+        defaults = image_defaults(project_dir, det)
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    if command:
+        defaults.command = command
+    _print_defaults(det, defaults)
+
+    if not yes:
+        _customize(defaults, det)
+    elif _needs_command(det, defaults) and not defaults.command:
+        console.print("[red]Error:[/red] quoll couldn't infer what the container runs. Pass [bold]--command[/bold].")
+        raise typer.Exit(1)
+
+    cfg = default_config(det, defaults)[0]
+    files = render.plan(project_dir, cfg)
+    if not confirm_overwrite(files, yes=yes, force=force):
+        raise typer.Exit(1)
+
+    save_config(project_dir, cfg)
+    write(project_dir, files)
+    console.print()
+    console.print(f"[green]✓[/green] {CONFIG_FILE}")
+    for f in files:
+        console.print(f"[green]✓[/green] {f.path}")
+
+    console.print("\n[bold green]Done![/bold green] Run the app" + (" and its services:" if cfg.services else ":"))
+    console.print("  docker compose up --build")
+    _suggest_ci_build(project_dir)
+
+
+@app.command()
+def update(
+    project_dir: Path = DirOption,
+    yes: bool = typer.Option(False, "--yes", "-y", help="Write changes without asking."),
+    force: bool = typer.Option(False, "--force", help="Overwrite a Dockerfile that was not generated by quoll."),
+) -> None:
+    """Regenerate the Dockerfile, .dockerignore and compose.yaml from quoll.toml (each project's, in a
+    workspace)."""
+    project_dir = resolve_dir(project_dir)
+    for directory in _targets(project_dir):
+        files = render.plan(directory, _load(directory))
+        update_files(directory, files, yes=yes, force=force, what=f"Docker files of {directory.name} are")
+    root = find_root(project_dir)
+    files = _workspace_files(root)
+    if files:
+        update_files(root, files, yes=yes, force=force, what="The workspace's compose.yaml is")
+
+
+@app.command()
+def check(project_dir: Path = DirOption) -> None:
+    """Fail if the Docker files differ from what quoll.toml describes (each project's, in a workspace)."""
+    project_dir = resolve_dir(project_dir)
+    for directory in _targets(project_dir):
+        check_files(render.plan(directory, _load(directory)), "docker")
+    root = find_root(project_dir)
+    files = _workspace_files(root)
+    if files:
+        check_files(files, "docker")
+
+
+def _workspace_files(root: Path) -> list:
+    """The compose.yaml running a whole workspace (its projects with a [docker] section), if `root` is one."""
+    members = _members(root)
+    if not members:
+        return []
+    configs = [(member_name(m), m, _load(root / m)) for m in members if "docker" in _read(root / m)]
+    return render.plan_workspace(root, configs) if configs else []
+
+
+def _members(project_dir: Path) -> Optional[List[str]]:
+    """The projects of the workspace whose root is `project_dir`, or None."""
+    try:
+        workspace = load_workspace(project_dir)
+    except ConfigError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    return workspace.members if workspace else None
+
+
+def _targets(project_dir: Path) -> List[Path]:
+    """`project_dir`, or the workspace projects with a [docker] section when it is a workspace root."""
+    members = _members(project_dir)
+    if members is None:
+        return [project_dir]
+    targets = [project_dir / m for m in members if "docker" in _read(project_dir / m)]
+    if not targets:
+        console.print("[red]Error:[/red] no project of the workspace has a [docker] section. Run "
+                      "[bold]quoll docker init[/bold] first.")
+        raise typer.Exit(1)
+    return targets
+
+
+# --------------------------------------------------------------------------- interactive
+
+
+def _customize(defaults: DockerDefaults, det: Detection) -> None:
+    port = ask(questionary.text(
+        "Port the app listens on",
+        default=str(defaults.port),
+        validate=lambda v: v.isdigit() and 0 < int(v) < 65536 or "Enter a port number",
+    ))
+    defaults.port = int(port)
+    if _needs_command(det, defaults):
+        defaults.command = ask(questionary.text(
+            "Command the container runs",
+            default=defaults.command,
+            validate=lambda v: bool(v.strip()) or "The container needs a command",
+        )).strip()
+
+
+def _needs_command(det: Detection, defaults: DockerDefaults) -> bool:
+    if defaults.static:
+        return False
+    image = languages.docker_image(det.stack, det.framework)
+    return image is not None and image.requires_command
+
+
+# --------------------------------------------------------------------------- output
+
+
+def _print_defaults(det: Detection, defaults: DockerDefaults) -> None:
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column(style="dim")
+    table.add_column(style="bold")
+    table.add_row("Stack", det.stack + (f" / {det.framework}" if det.framework else ""))
+    table.add_row("Version", det.version)
+    table.add_row("Build", defaults.build_command or "-")
+    if defaults.static:
+        table.add_row("Serves", f"{defaults.output_dir}/ (static, nginx)")
+    else:
+        table.add_row("Runs", defaults.command or "[yellow]?[/yellow]")
+    table.add_row("Port", str(defaults.port))
+    table.add_row("Services", ", ".join(det.services) or "-")
+    table.add_row("Existing Dockerfile", "yes" if det.has_dockerfile else "no")
+    console.print(table)
+    for warning in [*det.warnings, *defaults.warnings]:
+        console.print(f"[yellow]![/yellow] {warning}")
+    console.print()
+
+
+def _suggest_ci_build(project_dir: Path) -> None:
+    try:
+        ci = load_ci_config(project_dir)
+    except CIConfigError:
+        return
+    if not ci.build.docker:
+        console.print(
+            "\n[dim]To build the image in CI: set [bold]build.docker = true[/bold] in [ci], "
+            "then run [bold]quoll ci update[/bold].[/dim]"
+        )
+
+
+# --------------------------------------------------------------------------- helpers
+
+
+def _read(project_dir: Path) -> dict:
+    try:
+        return quoll_toml.read(project_dir)
+    except ConfigError:
+        return {}
+
+
+def _load(project_dir: Path) -> DockerConfig:
+    try:
+        return load_config(project_dir)
+    except ConfigError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)

quoll/commands/k8s.py

@@ -0,0 +1,211 @@
+"""`quoll k8s`: a Helm chart per project, deployed by the delivery pipeline to each environment."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import questionary
+import typer
+
+from quoll.cd.config import load_config as load_cd_config
+from quoll.ci.config import load_config as load_ci_config
+from quoll.ci.config import save_config as save_ci_config
+from quoll.ci.detect import configured_platform
+from quoll.commands._common import DirOption, ask, check_files, confirm_overwrite, resolve_dir, update_files
+from quoll.commands._workspace import refresh, snapshot
+from quoll.config import quoll_toml
+from quoll.config.quoll_toml import ConfigError
+from quoll.console import console
+from quoll.docker.config import load_config as load_docker_config
+from quoll.files import PlannedFile, write
+from quoll.k8s import render
+from quoll.k8s.config import (
+    Environment,
+    K8sConfig,
+    default_environments,
+    kubernetes_name,
+    load_config,
+    save_config,
+)
+from quoll.k8s.detect import health_path
+from quoll.workspace import find_root, load_workspace, member_name
+
+app = typer.Typer(help="Generate and maintain the Helm chart deploying a project to Kubernetes.", no_args_is_help=True)
+
+
+@app.command()
+def init(
+    project_dir: Path = DirOption,
+    yes: bool = typer.Option(False, "--yes", "-y", help="Accept detected defaults without asking."),
+    force: bool = typer.Option(False, "--force", help="Overwrite a chart that was not generated by quoll."),
+) -> None:
+    """Write [k8s] in quoll.toml and generate the project's Helm chart (each project's, in a workspace)."""
+    project_dir = resolve_dir(project_dir)
+    root = find_root(project_dir)
+    targets = _targets(project_dir, configured=False)
+    platform = configured_platform(root)
+    # Without a pipeline yet, nothing else to update.
+    before = snapshot(root, platform) if platform and "ci" in _read(root) else None
+    for directory in targets:
+        _init(root, directory, yes=yes, force=force)
+    # The other projects' URLs changed with the new ones.
+    for directory in _targets(root, configured=True):
+        if directory not in targets:
+            write(directory, [f for f in _plan(root, directory) if f.changed and f.managed])
+    if before is not None:
+        # The CI checks the charts; the delivery deploys them.
+        console.print()
+        refresh(root, platform, before, "add the chart to it yourself", members_changed=False)
+    console.print("\n[bold green]Done![/bold green] Install it on a cluster:")
+    first = targets[0]
+    cfg = load_config(first)
+    console.print(f"  helm upgrade --install {cfg.name} {_relative(first, cfg.chart)} "
+                  f"-f {_relative(first, cfg.chart)}/values-staging.yaml --set image.tag=<tag>")
+
+
+def _init(root: Path, directory: Path, *, yes: bool, force: bool, like: Optional[K8sConfig] = None) -> None:
+    """[k8s] and the chart of the project in `directory`; `like`: another project of the workspace, whose
+    environments (namespaces, triggers) and Ingress settings it shares."""
+    label = directory.relative_to(root).as_posix() if directory != root else directory.name
+    console.print(f"\n[bold]quoll k8s[/bold] — {label}\n")
+    if "k8s" in _read(directory) and not force:
+        if yes or not ask(questionary.confirm("quoll.toml already has a chart. Replace its settings?", default=False)):
+            console.print("Nothing changed. Use [bold]quoll k8s update[/bold] to regenerate from quoll.toml.")
+            return
+
+    workspace = directory != root
+    name = member_name(label) if workspace else kubernetes_name(directory.name)
+    project = kubernetes_name(root.name)
+    cfg = K8sConfig(name=kubernetes_name(name), health_path=health_path(directory),
+                    environments=default_environments(project))
+    if like is not None:
+        cfg.ingress_class, cfg.tls, cfg.cluster_issuer = like.ingress_class, like.tls, like.cluster_issuer
+        cfg.environments = {
+            env_name: Environment(namespace=env.namespace, deploy_on=env.deploy_on, replicas=env.replicas)
+            for env_name, env in like.environments.items()
+        }
+    if not yes:
+        cfg.health_path = ask(questionary.text(
+            "Health check path (empty: TCP checks on the port)", default=cfg.health_path
+        )).strip()
+        for env_name, environment in cfg.environments.items():
+            environment.host = ask(questionary.text(
+                f"Public host in {env_name} (empty: no Ingress)", default=environment.host
+            )).strip()
+
+    save_config(directory, cfg)
+    if "ci" in _read(directory) and "workspace" not in _read(directory):
+        ci = load_ci_config(directory)
+        ci.build.chart = cfg.chart
+        save_ci_config(directory, ci)
+    files = _plan(root, directory)
+    if not confirm_overwrite(files, yes=yes, force=force):
+        raise typer.Exit(1)
+    write(directory, files)
+    console.print("[green]✓[/green] quoll.toml")
+    console.print(f"[green]✓[/green] {cfg.chart}/ (Helm chart: values.yaml, "
+                  + ", ".join(f"values-{e}.yaml" for e in cfg.environments) + ")")
+    docker = load_docker_config(directory)
+    if docker.services:
+        console.print(f"[yellow]![/yellow] {name} uses {', '.join(docker.services)}: put their URLs "
+                      f"(DATABASE_URL...) in the Secret {cfg.secret_name} of each namespace.")
+
+
+@app.command()
+def update(
+    project_dir: Path = DirOption,
+    yes: bool = typer.Option(False, "--yes", "-y", help="Write changes without asking."),
+    force: bool = typer.Option(False, "--force", help="Overwrite a chart that was not generated by quoll."),
+) -> None:
+    """Regenerate the Helm chart from quoll.toml (each project's, in a workspace)."""
+    project_dir = resolve_dir(project_dir)
+    root = find_root(project_dir)
+    for directory in _targets(project_dir, configured=True):
+        update_files(directory, _plan(root, directory), yes=yes, force=force, what=f"The chart of {directory.name} is")
+
+
+@app.command()
+def check(project_dir: Path = DirOption) -> None:
+    """Fail if the Helm chart differs from what quoll.toml describes (each project's, in a workspace)."""
+    project_dir = resolve_dir(project_dir)
+    root = find_root(project_dir)
+    for directory in _targets(project_dir, configured=True):
+        check_files(_plan(root, directory), "k8s")
+
+
+def chart_files(root: Path) -> List[PlannedFile]:
+    """The charts of `root` (or of its workspace's projects), paths from `root`."""
+    files = []
+    for directory in _targets(root, configured=True, required=False):
+        prefix = directory.relative_to(root)
+        for f in _plan(root, directory):
+            f.path = prefix / f.path
+            files.append(f)
+    return files
+
+
+def _plan(root: Path, directory: Path) -> List[PlannedFile]:
+    try:
+        cfg = load_config(directory)
+        docker = load_docker_config(directory)
+    except ConfigError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    image = load_cd_config(directory).image if "cd" in _read(directory) else ""
+    return render.plan(directory, cfg, docker, image, _peers(root, directory))
+
+
+def _peers(root: Path, directory: Path) -> Dict[str, str]:
+    """<NAME>_URL of the workspace's other projects, at their Service: http://<name>:<port>, as in compose.yaml."""
+    workspace = _workspace(root)
+    if workspace is None:
+        return {}
+    peers = {}
+    for member in workspace:
+        other = root / member
+        if other == directory or "docker" not in _read(other):
+            continue
+        name = load_config(other).name if "k8s" in _read(other) else member_name(member)
+        peers[f"{member_name(member).upper().replace('-', '_')}_URL"] = f"http://{name}:{load_docker_config(other).port}"
+    return peers
+
+
+def _targets(project_dir: Path, *, configured: bool, required: bool = True) -> List[Path]:
+    """`project_dir`, or the workspace's projects when it is a workspace root: with a [docker] section (init), or
+    with a [k8s] one."""
+    section = "k8s" if configured else "docker"
+    members = _workspace(project_dir)
+    candidates = [project_dir] if members is None else [project_dir / m for m in members]
+    targets = [d for d in candidates if section in _read(d)]
+    if not targets and required:
+        if configured:
+            console.print("[red]Error:[/red] no chart configured. Run [bold]quoll k8s init[/bold] first.")
+        else:
+            console.print("[red]Error:[/red] the chart deploys the project's image: run "
+                          "[bold]quoll docker init[/bold] first.")
+        raise typer.Exit(1)
+    return targets
+
+
+def _workspace(project_dir: Path) -> Optional[List[str]]:
+    try:
+        workspace = load_workspace(project_dir)
+    except ConfigError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    return workspace.members if workspace else None
+
+
+def _read(directory: Path) -> dict:
+    try:
+        return quoll_toml.read(directory)
+    except ConfigError:
+        return {}
+
+
+def _relative(directory: Path, chart: str) -> str:
+    cwd = Path.cwd()
+    try:
+        return str((directory / chart).relative_to(cwd))
+    except ValueError:
+        return str(directory / chart)