offline-docker-cli 2.2.2__py3-none-any.whl

offline_docker/__init__.py

@@ -0,0 +1,3 @@
+"""Universal Docker offline cache / build CLI."""
+
+__version__ = "2.2.2"

offline_docker/__main__.py

@@ -0,0 +1,4 @@
+from offline_docker.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

offline_docker/actions.py

@@ -0,0 +1,173 @@
+"""Shared command handlers for CLI and TUI."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from offline_docker import docker_cmd
+from offline_docker.build import (
+    build_base_offline_cmd,
+    build_offline,
+    down_stack,
+    up_offline,
+    up_online,
+)
+from offline_docker.context import ProjectContext
+from offline_docker.discover import format_discovery_report
+from offline_docker.download_debs import download_debs
+from offline_docker.download_images import download_docker_images
+from offline_docker.download_npm import download_npm_cache
+from offline_docker.download_trivy import download_trivy_db
+from offline_docker.download_wheels import download_wheels
+from offline_docker.download_yarn import download_yarn_cache
+from offline_docker.hooks import run_after_cache_hooks
+from offline_docker.load_images import load_docker_images
+from offline_docker.trivy_scan import scan_trivy_offline
+from offline_docker.validate import validate_offline_cache
+
+# Canonical action names (CLI 2.x).
+PROJECT_ACTIONS = frozenset(
+    {
+        "discover",
+        "cache",
+        "cache-wheels",
+        "cache-debs",
+        "cache-npm",
+        "cache-yarn",
+        "cache-images",
+        "cache-trivy",
+        "cache-check",
+        "cache-load",
+        "build",
+        "build-base",
+        "up",
+        "up-online",
+        "down",
+        "scan",
+    }
+)
+
+DOCKER_ACTIONS = frozenset(PROJECT_ACTIONS - {"discover", "cache-check"})
+
+
+def resolve_action(name: str) -> str:
+    """Validate and return a canonical action name."""
+    if name not in PROJECT_ACTIONS:
+        raise ValueError(f"Unknown action: {name}")
+    return name
+
+
+def download_offline_cache(ctx: ProjectContext) -> None:
+    print("========================================")
+    print(" cache (полный набор)")
+    print(f" Project: {ctx.root}")
+    print("========================================")
+    print()
+    from offline_docker.sync_cache import maybe_materialize
+
+    maybe_materialize(ctx)
+    download_debs(ctx)
+    print()
+    download_wheels(ctx)
+    print()
+    download_npm_cache(ctx)
+    print()
+    download_yarn_cache(ctx)
+    print()
+    download_docker_images(ctx)
+    print()
+    download_trivy_db(ctx)
+    print()
+    run_after_cache_hooks(ctx)
+    print("=== offline-cache готов ===")
+    print(docker_cmd.dir_size_human(ctx.offline_cache))
+
+
+def run_action(name: str, ctx: ProjectContext, **opts: Any) -> None:
+    """Run a project-scoped action by name.
+
+    Supported opts (by action):
+      build / build-base / up-online: no_cache
+      build: targets (list[str] | None)
+      up: lab, no_build, no_deps, services, no_cache, online
+      down: lab, online, services
+      scan: target, image (scanner defaults to trivy)
+    """
+    canon = resolve_action(name)
+
+    if canon == "discover":
+        print(format_discovery_report(ctx.config))
+        return
+    if canon == "cache-wheels":
+        download_wheels(ctx)
+        return
+    if canon == "cache-debs":
+        download_debs(ctx)
+        return
+    if canon == "cache-npm":
+        download_npm_cache(ctx)
+        return
+    if canon == "cache-yarn":
+        download_yarn_cache(ctx)
+        return
+    if canon == "cache-images":
+        download_docker_images(ctx)
+        return
+    if canon == "cache-trivy":
+        download_trivy_db(ctx)
+        return
+    if canon == "cache":
+        download_offline_cache(ctx)
+        return
+    if canon == "cache-check":
+        validate_offline_cache(ctx)
+        return
+    if canon == "cache-load":
+        load_docker_images(ctx)
+        return
+    if canon == "build-base":
+        build_base_offline_cmd(ctx, no_cache=bool(opts.get("no_cache")))
+        return
+    if canon == "build":
+        targets = opts.get("targets")
+        build_offline(
+            ctx,
+            list(targets) if targets else None,
+            no_cache=bool(opts.get("no_cache")),
+        )
+        return
+    if canon == "up-online":
+        up_online(ctx, no_cache=bool(opts.get("no_cache")))
+        return
+    if canon == "up":
+        if opts.get("online"):
+            up_online(ctx, no_cache=bool(opts.get("no_cache")))
+            return
+        services = opts.get("services")
+        up_offline(
+            ctx,
+            lab=bool(opts.get("lab")),
+            no_build=bool(opts.get("no_build")),
+            no_deps=bool(opts.get("no_deps")),
+            no_cache=bool(opts.get("no_cache")),
+            services=list(services) if services else None,
+        )
+        return
+    if canon == "down":
+        services = opts.get("services")
+        down_stack(
+            ctx,
+            lab=bool(opts.get("lab")),
+            online=bool(opts.get("online")),
+            services=list(services) if services else None,
+        )
+        return
+    if canon == "scan":
+        target = opts.get("target")
+        if target not in ("backend", "frontend"):
+            raise ValueError("scan requires target=backend|frontend")
+        # Future: opts.get("scanner", "trivy")
+        scan_trivy_offline(ctx, target, opts.get("image"))
+        return
+
+    raise ValueError(f"Unhandled action: {canon}")

offline_docker/build.py

@@ -0,0 +1,245 @@
+"""Offline build orchestration."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+from offline_docker import docker_cmd
+from offline_docker.context import ProjectContext
+from offline_docker.download_npm import download_npm_cache
+from offline_docker.download_wheels import download_wheels
+from offline_docker.download_yarn import download_yarn_cache
+from offline_docker.ensure_base import build_base_offline, require_base_offline
+from offline_docker.hooks import run_after_cache_hooks
+from offline_docker.load_images import load_docker_images
+from offline_docker.validate import validate_offline_cache
+
+
+def _stamp_ui_project_label(image: str, project: str) -> None:
+    print(f">>> stamp UI label {image} -> com.docker.compose.project={project}")
+    with tempfile.TemporaryDirectory(prefix="od-stamp-") as tmp:
+        df = Path(tmp) / "Dockerfile"
+        df.write_text(
+            f"FROM {image}\nLABEL com.docker.compose.project={project}\n",
+            encoding="utf-8",
+        )
+        subprocess.run(
+            ["docker", "build", "-t", image, "-f", str(df), tmp],
+            check=True,
+        )
+
+
+def build_base_offline_cmd(ctx: ProjectContext, *, no_cache: bool = False) -> None:
+    image = os.environ.get("IMAGE", ctx.config.images.base)
+    ctx.set_offline_cache_env()
+
+    print("=== build base ===")
+    print(f"Project:       {ctx.root}")
+    print(f"Offline cache: {ctx.offline_cache}")
+    print(f"Image:         {image}")
+    print()
+
+    from offline_docker.sync_cache import maybe_materialize
+
+    maybe_materialize(ctx)
+    download_wheels(ctx)
+    validate_offline_cache(ctx)
+    load_docker_images(ctx)
+    build_base_offline(ctx, image, no_cache=no_cache)
+
+    print()
+    print(f"=== Готово: {image} ===")
+
+
+def build_offline(
+    ctx: ProjectContext, targets: list[str] | None = None, *, no_cache: bool = False
+) -> None:
+    if not targets:
+        targets = list(ctx.config.build_services)
+
+    ctx.set_offline_cache_env()
+    compose_args = ctx.config.compose_build_file_args()
+    env_file_args = ctx.config.compose_env_file_args()
+
+    print("=== build ===")
+    print(f"Project:       {ctx.root}")
+    print(f"Offline cache: {ctx.offline_cache}")
+    print(f"Compose:       {' '.join(compose_args)}")
+    print(f"Логи:          {ctx.log_dir}")
+    print(f"Сервисы:       {' '.join(targets)}")
+    if no_cache:
+        print("No-cache:      да")
+    print()
+
+    from offline_docker.sync_cache import maybe_materialize
+
+    maybe_materialize(ctx)
+    download_wheels(ctx)
+    download_npm_cache(ctx)
+    download_yarn_cache(ctx)
+    run_after_cache_hooks(ctx)
+    validate_offline_cache(ctx)
+    load_docker_images(ctx)
+
+    compose_targets: list[str] = []
+    for svc in targets:
+        if svc == "base":
+            build_base_offline(ctx, no_cache=no_cache)
+        else:
+            compose_targets.append(svc)
+
+    uses_shared_base = "base" in ctx.config.build_services
+    for svc in compose_targets:
+        if svc == "backend" and uses_shared_base:
+            require_base_offline(ctx)
+        log_file = ctx.offline_build_log(svc)
+        print(f">>> compose build {svc} -> {log_file}")
+        build_cmd = ["docker", "compose", *env_file_args, *compose_args, "build"]
+        if no_cache:
+            build_cmd.append("--no-cache")
+        build_cmd.append(svc)
+        docker_cmd.run_tee(
+            build_cmd,
+            log_file,
+            cwd=ctx.root,
+            env={"DOCKER_BUILDKIT": "1"},
+        )
+
+    image_map = {
+        "backend": os.environ.get("BACKEND_IMAGE", ctx.config.images.backend),
+        "frontend": os.environ.get("FRONTEND_IMAGE", ctx.config.images.frontend),
+    }
+    for svc in compose_targets:
+        image = image_map.get(svc)
+        if image:
+            _stamp_ui_project_label(image, ctx.config.app_name)
+
+    print()
+    print(f"=== Готово. Логи: {ctx.log_dir}/offline-build-*.log ===")
+
+
+def up_online(ctx: ProjectContext, *, no_cache: bool = False) -> None:
+    """Online compose up (compose_online only). Formerly ``dev-up``."""
+    from offline_docker.ensure_base import ensure_base_online
+
+    compose = ctx.config.compose_online
+    print("=== up --online ===")
+    print(f"Project: {ctx.root}")
+    print(f"Compose: {compose}")
+    print()
+
+    ensure_base_online(ctx, no_cache=no_cache)
+    build_cmd = ["docker", "compose", "-f", compose, "build"]
+    if no_cache:
+        build_cmd.append("--no-cache")
+    docker_cmd.run(build_cmd, cwd=ctx.root, env={"DOCKER_BUILDKIT": "1"})
+    docker_cmd.run(
+        ["docker", "compose", "-f", compose, "up", "-d"],
+        cwd=ctx.root,
+        env={"DOCKER_BUILDKIT": "1"},
+    )
+    print()
+    print("=== up --online: контейнеры подняты ===")
+
+
+# Back-compat alias
+dev_up = up_online
+
+
+def _ensure_traefik_network() -> None:
+    subprocess.run(
+        ["docker", "network", "create", "traefik_proxy"],
+        check=False,
+        capture_output=True,
+    )
+
+
+def up_offline(
+    ctx: ProjectContext,
+    *,
+    lab: bool = False,
+    no_build: bool = False,
+    no_deps: bool = False,
+    no_cache: bool = False,
+    services: list[str] | None = None,
+) -> None:
+    ctx.set_offline_cache_env()
+    compose_args = ctx.config.compose_up_file_args(lab=lab)
+    env_file_args = ctx.config.compose_env_file_args()
+
+    print("=== up ===" if not lab else "=== up --lab ===")
+    print(f"Project: {ctx.root}")
+    print(f"Offline cache: {ctx.offline_cache}")
+    print(f"Compose:       {' '.join(compose_args)}")
+    if lab:
+        print("Lab:           docker-compose.lab.yml")
+    if no_cache:
+        print("No-cache:      да")
+    print()
+
+    _ensure_traefik_network()
+
+    if not no_build:
+        from offline_docker.sync_cache import maybe_materialize
+
+        maybe_materialize(ctx)
+        run_after_cache_hooks(ctx)
+        validate_offline_cache(ctx)
+        load_docker_images(ctx)
+
+    if no_cache and not no_build:
+        build_cmd = ["docker", "compose", *env_file_args, *compose_args, "build", "--no-cache"]
+        if services:
+            build_cmd.extend(services)
+        docker_cmd.run(build_cmd, cwd=ctx.root, env={"DOCKER_BUILDKIT": "1"})
+        no_build = True
+
+    cmd = ["docker", "compose", *env_file_args, *compose_args, "up", "-d"]
+    if no_build:
+        cmd.append("--no-build")
+    if no_deps:
+        cmd.append("--no-deps")
+    if services:
+        cmd.extend(services)
+
+    docker_cmd.run(cmd, cwd=ctx.root, env={"DOCKER_BUILDKIT": "1"})
+    print()
+    print("=== up: контейнеры подняты ===")
+
+
+def down_stack(
+    ctx: ProjectContext,
+    *,
+    lab: bool = False,
+    online: bool = False,
+    services: list[str] | None = None,
+) -> None:
+    """Compose down for the same stack selection as ``up`` / ``up --lab`` / ``up --online``."""
+    if lab and online:
+        raise ValueError("--lab and --online are mutually exclusive")
+
+    env_file_args = ctx.config.compose_env_file_args()
+    if online:
+        compose = ctx.config.compose_online
+        compose_args = ["-f", compose]
+        label = "down --online"
+    else:
+        compose_args = ctx.config.compose_up_file_args(lab=lab)
+        label = "down --lab" if lab else "down"
+
+    print(f"=== {label} ===")
+    print(f"Project: {ctx.root}")
+    print(f"Compose: {' '.join(compose_args)}")
+    if services:
+        print(f"Services: {' '.join(services)}")
+    print()
+
+    cmd = ["docker", "compose", *env_file_args, *compose_args, "down"]
+    if services:
+        cmd.extend(services)
+    docker_cmd.run(cmd, cwd=ctx.root, env={"DOCKER_BUILDKIT": "1"})
+    print()
+    print(f"=== {label}: готово ===")