Validate every writable drive (qcow2, inside PHOEBUS_VM_DISKS, no /dev/*, block/char devices, raw images, escaping symlinks or outside backing chains), give each run its own OVMF variable file, QMP socket and state directory, and use QMP plus argument arrays instead of shell interpolation. Return nonzero on any failed assertion, timeout, EOF or missing result and record PASS/FAIL/BLOCKED/SKIPPED/NOT RUN. Add 16 unit tests, a report generator and a findings register; make test runs the harness suite.
193 lines
7.4 KiB
Bash
193 lines
7.4 KiB
Bash
#!/usr/bin/env python3
|
|
"""Headless serial driver for the disposable UEFI VM.
|
|
|
|
Two modes:
|
|
|
|
install : boot the live ISO kernel/initrd, run a guest script that installs
|
|
Phoebus non-interactively, then power off.
|
|
boot : boot the installed disk alone (no ISO, no -kernel), unlock LUKS,
|
|
log in and run verification commands.
|
|
|
|
Everything is parameterised through environment variables so the script is not
|
|
tied to one host. See tests/vm/README.md for the variables.
|
|
|
|
Safety: `DISK`/`DISKS` must be qcow2 files inside the disposable directory named
|
|
by `PHOEBUS_VM_DISKS` (default `$PHOEBUS_VM_STATE/disks`); block devices,
|
|
`/dev/*`, escaping symlinks, raw images and outside backing chains are refused.
|
|
Results are structured and the exit status is nonzero on failure.
|
|
"""
|
|
import os
|
|
import sys
|
|
|
|
import pexpect
|
|
|
|
import vmsafety
|
|
from vmsafety import Results
|
|
|
|
QEMU = os.environ.get("QEMU_BIN", "qemu-system-x86_64")
|
|
LIBDIR = os.environ.get("QEMU_LIBDIR", "")
|
|
DATADIR = os.environ.get("QEMU_DATADIR", "")
|
|
OVMF_CODE = os.environ["OVMF_CODE"]
|
|
OVMF_VARS_TEMPLATE = os.environ["OVMF_VARS"]
|
|
DISKS = os.environ.get("DISKS") or os.environ.get("DISK", "")
|
|
ISO = os.environ.get("ISO", "")
|
|
KERNEL = os.environ.get("KERNEL", "")
|
|
INITRD = os.environ.get("INITRD", "")
|
|
LUKS_PW = os.environ.get("LUKS_PASSPHRASE", "phoebus-luks-test")
|
|
USER_PW = os.environ.get("USER_PASSWORD", "phoebus-user-test")
|
|
USER = os.environ.get("USERNAME", "phoebus")
|
|
MEM = os.environ.get("VM_MEM", "8192")
|
|
SMP = os.environ.get("VM_SMP", "8")
|
|
|
|
BLS_APPEND = (
|
|
"root=live:CDLABEL=gentoo-amd64-livegui rd.live.dir=/ "
|
|
"rd.live.squashimg=image.squashfs cdroot console=ttyS0,115200"
|
|
)
|
|
|
|
|
|
def disposable_dir():
|
|
import pathlib
|
|
|
|
base = os.environ.get("PHOEBUS_VM_STATE", "/var/tmp/phoebus-vm")
|
|
return pathlib.Path(os.environ.get("PHOEBUS_VM_DISKS", base + "/disks"))
|
|
|
|
|
|
def base_args(ovmf_vars):
|
|
env = dict(os.environ)
|
|
if LIBDIR:
|
|
env["LD_LIBRARY_PATH"] = LIBDIR
|
|
args = ["-machine", "q35,accel=kvm"]
|
|
if DATADIR:
|
|
args += ["-L", DATADIR]
|
|
args += [
|
|
"-cpu", "host", "-smp", SMP, "-m", MEM,
|
|
"-drive", f"if=pflash,format=raw,readonly=on,file={OVMF_CODE}",
|
|
"-drive", f"if=pflash,format=raw,file={ovmf_vars}",
|
|
"-netdev", "user,id=n0", "-device", "virtio-net-pci,netdev=n0,romfile=",
|
|
"-device", "virtio-rng-pci", "-vga", "std", "-display", "none",
|
|
"-serial", "stdio", "-monitor", "none", "-no-reboot",
|
|
]
|
|
return env, args
|
|
|
|
|
|
def spawn(args, env, log):
|
|
child = pexpect.spawn(QEMU, args, env=env, timeout=600,
|
|
encoding="utf-8", codec_errors="replace",
|
|
maxread=65536)
|
|
child.delaybeforesend = 0.3
|
|
child.logfile = log
|
|
return child
|
|
|
|
|
|
def do_install(results, paths, disks):
|
|
env, args = base_args(str(paths.ovmf_vars))
|
|
for disk in disks:
|
|
args += ["-drive", f"file={disk},if=virtio,format=qcow2"]
|
|
args += ["-drive", f"file={ISO},media=cdrom,readonly=on",
|
|
"-kernel", KERNEL, "-initrd", INITRD, "-append", BLS_APPEND]
|
|
log = open(paths.serial_log, "w")
|
|
child = spawn(args, env, log)
|
|
try:
|
|
child.expect(r"root@livecd[^\n]*# ", timeout=600)
|
|
results.pass_("live-shell")
|
|
url = os.environ.get("INSTALL_URL", "http://10.0.2.2:8000/install.sh")
|
|
child.sendline(f"curl -fsSL {url} -o /tmp/run.sh && bash /tmp/run.sh")
|
|
child.expect([r"===INSTALL-RC=([0-9]+)===", "===FETCH-FAIL===",
|
|
"Kernel panic", pexpect.EOF, pexpect.TIMEOUT], timeout=9000)
|
|
if "INSTALL-RC" in (child.after or ""):
|
|
rc = child.match.group(1)
|
|
results.assert_true("install-rc-zero", rc == "0", f"INSTALL-RC={rc}")
|
|
else:
|
|
results.fail("install-rc-zero", "install did not report a status")
|
|
serial = paths.serial_log.read_text(errors="replace")
|
|
results.assert_true("no-secret-leak", "SECRET_LEAK_FOUND" not in serial,
|
|
"the guest reported a secret leak")
|
|
child.expect(["===POWEROFF===", pexpect.EOF, pexpect.TIMEOUT], timeout=600)
|
|
except pexpect.TIMEOUT as exc:
|
|
results.fail("install", f"timeout: {exc}")
|
|
except pexpect.EOF:
|
|
results.fail("install", "unexpected EOF")
|
|
finally:
|
|
child.close(force=True)
|
|
log.close()
|
|
|
|
|
|
def do_boot(results, paths, disks):
|
|
env, args = base_args(str(paths.ovmf_vars))
|
|
for disk in disks:
|
|
args += ["-drive", f"file={disk},if=virtio,format=qcow2"]
|
|
args += ["-boot", "order=c"]
|
|
# The end marker is built with a command substitution so the shell's echo of
|
|
# the typed line does not itself contain it; otherwise `expect` would match
|
|
# the echo and close the console before the checks ran.
|
|
checks = os.environ.get(
|
|
"BOOT_CHECKS",
|
|
"echo ===CHECKS-$(printf START)===; "
|
|
"cat /proc/1/comm; systemctl is-system-running; "
|
|
"systemctl --failed --no-pager; ip -brief addr; "
|
|
"lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINTS; echo ===CHECKS-$(printf END)===",
|
|
)
|
|
log = open(paths.serial_log, "w")
|
|
child = spawn(args, env, log)
|
|
try:
|
|
child.expect([r"[Pp]assphrase", r"login:"], timeout=300)
|
|
if "assphrase" in (child.after or ""):
|
|
child.sendline(LUKS_PW)
|
|
logged_in = False
|
|
for _ in range(5):
|
|
child.expect(r"phoebus login:", timeout=180)
|
|
child.sendline(USER)
|
|
idx = child.expect([r"[Pp]assword:", r"phoebus login:",
|
|
r"Login incorrect"], timeout=30)
|
|
if idx == 0:
|
|
child.sendline(USER_PW)
|
|
if child.expect([r"[$#] $", r"Login incorrect",
|
|
r"phoebus login:"], timeout=60) == 0:
|
|
logged_in = True
|
|
break
|
|
results.assert_true("detached-boot-login", logged_in, "could not log in")
|
|
child.sendline(checks)
|
|
child.expect("===CHECKS-END===", timeout=int(os.environ.get("CHECKS_TIMEOUT", "180")))
|
|
serial = paths.serial_log.read_text(errors="replace")
|
|
results.assert_true("boot-systemd-running", "running" in serial,
|
|
"systemd did not report running")
|
|
except pexpect.TIMEOUT as exc:
|
|
results.fail("boot", f"timeout: {exc}")
|
|
except pexpect.EOF:
|
|
results.fail("boot", "unexpected EOF")
|
|
finally:
|
|
child.close(force=True)
|
|
log.close()
|
|
|
|
|
|
def main() -> int:
|
|
mode = sys.argv[1] if len(sys.argv) > 1 else ""
|
|
if mode not in ("install", "boot"):
|
|
print(__doc__)
|
|
return 2
|
|
results = Results(f"serial-{mode}")
|
|
paths = vmsafety.make_run_paths(
|
|
f"serial-{mode}", base=os.environ.get("PHOEBUS_VM_STATE", "/var/tmp/phoebus-vm"),
|
|
ovmf_vars_template=OVMF_VARS_TEMPLATE,
|
|
)
|
|
try:
|
|
disks = vmsafety.validate_writable_drives(DISKS.split(","), disposable_dir())
|
|
except vmsafety.UnsafeDiskError as exc:
|
|
results.blocked("disposable-disk", str(exc))
|
|
results.write(paths.results_json)
|
|
print(f"harness error: {exc}", file=sys.stderr)
|
|
return 2
|
|
results.pass_("disposable-disk", ", ".join(str(d) for d in disks))
|
|
try:
|
|
if mode == "install":
|
|
do_install(results, paths, disks)
|
|
else:
|
|
do_boot(results, paths, disks)
|
|
finally:
|
|
results.write(paths.results_json)
|
|
print(results.summary(), flush=True)
|
|
return results.exit_code()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|