*: Switch to python

src/container.py

@@ -0,0 +1,200 @@
+import atexit
+import hashlib
+import os
+import signal
+import subprocess
+import threading
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from src import log
+
+
+@dataclass
+class Mount:
+    src: Path
+    dst: str
+    readonly: bool = False
+
+    def as_arg(self) -> str:
+        flag = ":ro" if self.readonly else ""
+        return f"{self.src}:{self.dst}{flag}"
+
+
+_active: set["Container"] = set()
+_lock = threading.Lock()
+_handlers_installed = False
+
+
+def _install_handlers() -> None:
+    global _handlers_installed
+    if _handlers_installed:
+        return
+    _handlers_installed = True
+
+    def cleanup(*_):
+        _shutdown_all()
+
+    atexit.register(_shutdown_all)
+    for s in (signal.SIGINT, signal.SIGTERM):
+        try:
+            signal.signal(s, lambda *_: (_shutdown_all(), os._exit(130)))
+        except (ValueError, OSError):
+            pass
+
+
+def _shutdown_all() -> None:
+    with _lock:
+        cs = list(_active)
+        _active.clear()
+    for c in cs:
+        try:
+            subprocess.run(
+                ["podman", "rm", "-f", c.name],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                check=False,
+            )
+        except Exception:
+            pass
+
+
+@dataclass
+class Container:
+    name: str
+    image: str
+    mounts: list[Mount] = field(default_factory=list)
+    tmpfs: list[str] = field(default_factory=list)
+    network: bool = False
+    extra_env: dict[str, str] = field(default_factory=dict)
+    started: bool = False
+
+    def __hash__(self) -> int:
+        return id(self)
+
+    def __eq__(self, other) -> bool:
+        return self is other
+
+    def start(self) -> None:
+        if self.started:
+            return
+        _install_handlers()
+        # Ensure no stale container.
+        subprocess.run(
+            ["podman", "rm", "-f", self.name],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+        argv = [
+            "podman",
+            "run",
+            "-d",
+            "--rm",
+            "--name",
+            self.name,
+        ]
+        for t in ("/tmp", "/dest", "/var/cache", *self.tmpfs):
+            argv += ["--tmpfs", t]
+        argv += ["--network=none"] if not self.network else []
+        for m in self.mounts:
+            m.src.mkdir(parents=True, exist_ok=True) if not m.src.exists() else None
+            argv += ["-v", m.as_arg()]
+        argv += [self.image, "sleep", "infinity"]
+        log.debug(f"container start: {' '.join(argv)}")
+        r = subprocess.run(argv, capture_output=True, text=True)
+        if r.returncode != 0:
+            raise RuntimeError(f"podman run failed: {r.stderr.strip()}")
+        with _lock:
+            _active.add(self)
+        self.started = True
+
+    def stop(self) -> None:
+        if not self.started:
+            return
+        subprocess.run(
+            ["podman", "rm", "-f", self.name],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+        with _lock:
+            _active.discard(self)
+        self.started = False
+
+    def exec(
+        self,
+        argv: list[str],
+        *,
+        env: dict[str, str] | None = None,
+        cwd: str | None = None,
+        check: bool = True,
+        user: str | None = None,
+    ) -> int:
+        if not self.started:
+            raise RuntimeError("container not started")
+        cmd = ["podman", "exec"]
+        if cwd:
+            cmd += ["-w", cwd]
+        if user:
+            cmd += ["-u", user]
+        merged: dict[str, str] = {}
+        merged.update(self.extra_env)
+        if env:
+            merged.update(env)
+        for k, v in merged.items():
+            cmd += ["-e", f"{k}={v}"]
+        cmd += [self.name, *argv]
+        log.debug(f"exec: {' '.join(argv)}")
+        rc = subprocess.call(cmd)
+        if check and rc != 0:
+            raise RuntimeError(f"command failed (exit {rc}): {' '.join(argv)}")
+        return rc
+
+    def exec_shell(
+        self,
+        script: str,
+        *,
+        env: dict[str, str] | None = None,
+        cwd: str | None = None,
+        check: bool = True,
+    ) -> int:
+        return self.exec(["sh", "-ec", script], env=env, cwd=cwd, check=check)
+
+    def cp_out(self, src_in: str, dst_host: Path) -> None:
+        dst_host.parent.mkdir(parents=True, exist_ok=True)
+        r = subprocess.run(
+            ["podman", "cp", f"{self.name}:{src_in}", str(dst_host)],
+            capture_output=True,
+            text=True,
+        )
+        if r.returncode != 0:
+            raise RuntimeError(f"podman cp failed: {r.stderr.strip()}")
+
+
+def hash_dockerfile(p: Path) -> str:
+    return hashlib.sha256(p.read_bytes()).hexdigest()
+
+
+def image_exists(tag: str) -> bool:
+    r = subprocess.run(["podman", "image", "exists", tag])
+    return r.returncode == 0
+
+
+def build_image(dockerfile: Path, tag: str) -> None:
+    log.info(f"building container image {tag}")
+    r = subprocess.run(
+        ["podman", "build", "-t", tag, "-f", str(dockerfile), str(dockerfile.parent)]
+    )
+    if r.returncode != 0:
+        raise RuntimeError("podman build failed")
+
+
+def ensure_image(dockerfile: Path, tag: str, hash_file: Path) -> None:
+    cur = hash_dockerfile(dockerfile) + "\n" + tag
+    if hash_file.exists() and hash_file.read_text() == cur and image_exists(tag):
+        log.debug(f"image {tag} up-to-date")
+        return
+    build_image(dockerfile, tag)
+    hash_file.parent.mkdir(parents=True, exist_ok=True)
+    hash_file.write_text(cur)