zenops 0.18.0

Declarative system configuration management for shell config and dotfiles.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

#!/usr/bin/env python3
"""Host driver for the cross-platform integration test harness.

Builds a Docker image per distro (cached across runs) and runs the
in-container scenario for each filtered matrix entry. Stdlib only — no pip
install needed on the host.

Examples:
    python tests/cross-platform/run.py
    python tests/cross-platform/run.py --only ubuntu
    python tests/cross-platform/run.py --only ubuntu --shell bash
    python tests/cross-platform/run.py --install registry
    python tests/cross-platform/run.py --scenario basic
"""
import argparse
import shlex
import shutil
import subprocess
import sys
from pathlib import Path

HERE = Path(__file__).resolve().parent
REPO_ROOT = HERE.parent.parent
DOCKER_DIR = HERE / "docker"
CONTAINER_DIR = HERE / "container"

sys.path.insert(0, str(HERE))
from matrix import DISTROS, MATRIX, SHELLS  # noqa: E402


def build_image(distro: str, *, pull: bool) -> str:
    tag = f"zenops-test:{distro}"
    dockerfile = DOCKER_DIR / f"{distro}.Dockerfile"
    if not dockerfile.exists():
        sys.exit(f"no Dockerfile for distro={distro}: {dockerfile}")
    cmd = ["docker", "build", "-f", str(dockerfile), "-t", tag]
    if pull:
        cmd.append("--pull")
    cmd.append(str(DOCKER_DIR))
    print(f"\n>>> building {tag}")
    print(f"    $ {' '.join(shlex.quote(c) for c in cmd)}")
    subprocess.run(cmd, check=True)
    return tag


def run_combo(
    tag: str,
    distro: str,
    shell: str,
    *,
    install: str,
    scenario: str,
    keep: bool,
) -> bool:
    prefix = f"[{distro}/{shell}]"
    print(f"\n>>> {prefix} scenario={scenario} install={install}")

    docker_args = ["docker", "run"]
    if keep:
        docker_args += ["--name", f"zenops-test-{distro}-{shell}"]
    else:
        docker_args.append("--rm")
    docker_args += [
        # cargo install needs to fetch crates.io regardless of mode; bridge
        # is required for both local (deps) and registry (zenops itself).
        "--network", "bridge",
        "-v", f"{REPO_ROOT}:/src:ro",
        "-v", f"{CONTAINER_DIR}:/test:ro",
        tag,
        "python3", "/test/runner.py",
        "--scenario", scenario,
        "--shell", shell,
        "--install", install,
        "--source-path", "/src",
    ]

    print(f"    $ {' '.join(shlex.quote(c) for c in docker_args)}")
    proc = subprocess.Popen(
        docker_args,
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        text=True,
    )
    assert proc.stdout is not None
    for line in proc.stdout:
        print(f"{prefix} {line.rstrip()}")
    proc.wait()
    ok = proc.returncode == 0
    print(f"{prefix} {'PASS' if ok else 'FAIL'} (exit {proc.returncode})")
    return ok


def main() -> int:
    p = argparse.ArgumentParser()
    p.add_argument("--only", choices=DISTROS, help="limit to one distro")
    p.add_argument("--shell", choices=SHELLS, help="limit to one shell")
    p.add_argument("--install", choices=["local", "registry"], default="local")
    p.add_argument("--scenario", default="basic")
    p.add_argument("--keep", action="store_true",
                   help="don't `docker rm` (use `docker exec` to inspect)")
    p.add_argument("--pull", action="store_true",
                   help="docker build --pull (refresh base images)")
    p.add_argument("--no-build", action="store_true",
                   help="skip docker build (assume images already exist)")
    args = p.parse_args()

    if not shutil.which("docker"):
        sys.exit("docker not on PATH")

    selected = [
        entry for entry in MATRIX
        if (args.only is None or entry[0] == args.only)
        and (args.shell is None or entry[1] == args.shell)
    ]
    if not selected:
        sys.exit("no matrix entries selected; check --only/--shell")

    print(f"matrix: {len(selected)} combination(s)")
    for d, s, pm in selected:
        print(f"  - {d} / {s} / {pm}")

    distros_needed = sorted({d for d, _, _ in selected})
    images = {}
    for distro in distros_needed:
        if args.no_build:
            images[distro] = f"zenops-test:{distro}"
        else:
            images[distro] = build_image(distro, pull=args.pull)

    results = []
    for distro, shell, _ in selected:
        ok = run_combo(
            images[distro], distro, shell,
            install=args.install,
            scenario=args.scenario,
            keep=args.keep,
        )
        results.append((distro, shell, ok))

    print("\n=== summary ===")
    for distro, shell, ok in results:
        print(f"  {distro}/{shell}: {'PASS' if ok else 'FAIL'}")
    failures = [r for r in results if not r[2]]
    return 1 if failures else 0


if __name__ == "__main__":
    sys.exit(main())