firmware/bin/build-payload.py

#!/usr/bin/env python3
"""Build $MODDIR by installing the feed inside the printer replica.

    ./bin/build-payload.py <root-package> [<root-package> ...]

Writes the installed tree to $PAYLOAD_DIR, replacing whatever was there.

The printer's OWN apk installs onto the printer's own filesystem, under
qemu-mipsel, and the tree is tarred back out -- so maintainer scripts run
where they will run on a machine, and the install that ships is the install
that was tested.

WHAT IT COSTS. A privileged container and the printer image, which is why
`make build` has its own docker lane. The feed itself
(bin/build-packages.sh) still needs nothing but a checkout.
"""
import os
import subprocess
import sys
from pathlib import Path

for _p in Path(__file__).resolve().parents:
    if (_p / "bin" / "common.sh").is_file():
        ROOT = _p
        sys.path.insert(0, str(_p / "tools" / "replica"))
        break

from ffsim import cli                            # noqa: E402
from ffsim.config import Config                  # noqa: E402
from ffsim.replica import Replica                # noqa: E402

CASE = "tools/replica/printer/case-build-payload.sh"


def _sh(var, default=""):
    """One value out of bin/common.sh, asked of the shell that defines it.

    Re-deriving IPK_ARCH or PKG_FEED here would be a second place for them to
    be wrong, and the two would agree until somebody edited one.
    """
    out = subprocess.run(
        ["bash", "-c", '. "%s/bin/common.sh" >/dev/null 2>&1; printf "%%s" "${%s:-%s}"'
         % (ROOT, var, default)],
        capture_output=True, text=True, cwd=str(ROOT))
    return out.stdout.strip()


def run():
    roots = sys.argv[1:]
    if not roots:
        raise SystemExit("usage: build-payload.py <root-package> ...")

    feed = Path(_sh("PKG_FEED", str(ROOT / "work" / "packages")))
    payload_dir = Path(_sh("PAYLOAD_DIR"))
    if not payload_dir.is_absolute() and not str(payload_dir).startswith(str(ROOT)):
        payload_dir = ROOT / payload_dir

    # Asked of common.sh rather than spelled here -- the same rule the rest of
    # this file follows for PKG_FEED and IPK_ARCH.
    ext = _sh("PKG_EXT", "apk")
    pkgs = sorted(feed.glob("*." + ext))
    if not pkgs:
        raise SystemExit("no feed at %s -- run ./bin/build-packages.sh" % feed)
    index = feed / _sh("PKG_INDEX_NAME", "anvil.adb")
    if not index.is_file():
        raise SystemExit("no %s index at %s" % (index.name, feed))

    # Everything the printer's package manager needs, on the simulated stick at
    # /mnt: the archives and the index that names them. `packages` is the
    # replica's own mechanism for this and copies each to /mnt/<name>.
    packages = {p.name: str(p) for p in pkgs}
    packages[index.name] = str(index)

    # THE BOOTSTRAP BINARY. The package manager is one of the packages, and a
    # v3 .apk is an ADB stream rather than a tar -- `tar` refuses it -- so
    # there is no way to open the first package without an apk already
    # present. The cross-built binary rides along at /mnt/apk.
    #
    # It is the same build anvil-apk-tools contains, and that package installs
    # normally, so the tree that ships carries the packaged copy with a
    # database row to match. This one is scaffolding and never lands.
    boot = ROOT / "work" / "pkg" / "apk-tools" / "bin" / "apk"
    if not boot.is_file():
        raise SystemExit(
            "no bootstrap apk at %s -- run `make packages PKG=apk-tools`" % boot)
    packages["apk"] = str(boot)

    # THE PUBLIC KEY HAS TO ARRIVE BEFORE THE PACKAGES IT VERIFIES. It ships
    # in anvil-core so a printer keeps it, but anvil-core is one of the
    # packages being installed -- so at bootstrap there is nowhere for apk to
    # have read it from yet. It rides on the stick and the case copies it into
    # the trust directory before the first `apk add`.
    signkey = _sh("APK_SIGN_KEY")
    if signkey and Path(signkey + ".pub").is_file():
        packages["anvil.pub"] = signkey + ".pub"

    config = Config.load()
    replica = Replica.start(config)
    out = ROOT / "work" / ".payload-out"
    replica.run_case(
        ROOT / CASE, packages=packages, out_dir=out, on_output=_echo,
        env={
            "MOD_ROOTS": " ".join(roots),
            "IPK_ARCH": _sh("IPK_ARCH", "mipsel_xburst2"),
            "SOURCE_DATE_EPOCH": os.environ.get("SOURCE_DATE_EPOCH", "1"),
            # The case compiles the s6-rc database and stamps it db-$MOD_VER.
            # Asked of common.sh like every other value here, so the database
            # name and the package versions cannot come from two clocks.
            "MOD_VER": _sh("MOD_VER"),
        })

    tar = out / "payload.tar"
    if not tar.is_file():
        raise SystemExit("the replica produced no payload.tar")

    # Replace, never merge: a surviving file from a previous build is one no
    # package accounts for, and the manifest would ship it as though it did.
    if payload_dir.exists():
        subprocess.run(["rm", "-rf", str(payload_dir)], check=True)
    payload_dir.mkdir(parents=True)
    # --strip-components=1 drops the leading anvil/ the case tarred with.
    # No -p and no --same-owner: the archive carries the printer's root, this
    # runs as the build user, and runFirmwareExe.sh extracts as root on the
    # machine -- ownership in the payload means nothing.
    subprocess.run(["tar", "-xf", str(tar), "-C", str(payload_dir),
                    "--strip-components=1"], check=True)
    subprocess.run(["rm", "-rf", str(out)], check=True)
    _echo("payload: %s" % payload_dir)


def _echo(text):
    sys.stdout.write(str(text).rstrip("\n") + "\n")
    sys.stdout.flush()


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