This host no longer draws Habits' and Practices' screens, so a package of theirs built for an older host interface would leave them blank. Each app in apps/versions.json may now name the oldest host interface its packages must be built for; Habits and Practices name 30. An older installed or rolled-back package gives way to the bundled copy, and the compatibility test skips the node's older releases of those two as this build does.
277 lines
13 KiB
Python
277 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
"""Run app packages across Inner Breeze versions before they reach phones.
|
|
|
|
Forward: this build runs every package the Waozi node serves to an app with its
|
|
host interface. Phones still hold those packages when they install this app.
|
|
|
|
Reverse: the last released app runs each package built here that declares a
|
|
host interface the released app accepts, so a package update that claims to
|
|
support older apps cannot break them. Packages reach only apps that run their
|
|
format: an app released before the ZX format never asks the node for `.zx`
|
|
packages, so there is nothing to check against it.
|
|
|
|
Bundled packages are loaded with --bundle, which validates them and fails the
|
|
run when the host rejects them. The node's Arcade, and Chess while the node
|
|
still serves it on its own, are installed through More apps, played against
|
|
the computer and restarted to check the saved game.
|
|
"""
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import stat
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
import urllib.error
|
|
import urllib.parse
|
|
import urllib.request
|
|
|
|
from PIL import Image, ImageStat
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
REPOSITORY = "waozixyz/breeze"
|
|
# (ledger name, app ID, local bundle, --feature name)
|
|
PACKAGES = (
|
|
("inbe", "inbe", "build/inbe.zx", None),
|
|
("lists", "inbe.lists", "build/apps/lists.zx", "lists"),
|
|
("habits", "inbe.habits", "build/apps/habits.zx", "habits"),
|
|
("practices", "inbe.practices", "build/apps/practices.zx", "practices"),
|
|
("diary", "inbe.diary", "build/apps/diary.zx", "diary"),
|
|
("lumi", "inbe.lumi", "build/apps/lumi.zx", "lumi"),
|
|
("leaderboard", "inbe.leaderboard", "build/apps/leaderboard.zx", None),
|
|
)
|
|
SCRUBBED = ("DISPLAY", "WAYLAND_DISPLAY", "XAUTHORITY", "DBUS_SESSION_BUS_ADDRESS",
|
|
"SESSION_MANAGER", "GDK_DISPLAY")
|
|
|
|
|
|
def fetch(url, limit):
|
|
headers = {"User-Agent": "Inbe-Compatibility-Test/1.0"}
|
|
# Anonymous GitHub API calls share 60 an hour per address, which CI
|
|
# runners exhaust; Actions passes its token as GITHUB_TOKEN. Release
|
|
# downloads redirect to signed storage URLs that must not carry it.
|
|
token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
|
|
if token and urllib.parse.urlsplit(url).hostname == "api.github.com":
|
|
headers["Authorization"] = f"Bearer {token}"
|
|
headers["Accept"] = "application/vnd.github+json"
|
|
request = urllib.request.Request(url, headers=headers)
|
|
with urllib.request.urlopen(request, timeout=60) as response:
|
|
data = response.read(limit + 1)
|
|
if len(data) > limit:
|
|
raise ValueError(f"{url} exceeds {limit} bytes")
|
|
return data
|
|
|
|
|
|
def host_range(ledger):
|
|
"""Apps released before version ranges accept only their own interface."""
|
|
return ledger.get("oldest_host_api", ledger["host_api"]), ledger["host_api"]
|
|
|
|
|
|
def latest_release_tag():
|
|
"""GitHub's public latest link avoids shared anonymous API rate limits."""
|
|
request = urllib.request.Request(f"https://github.com/{REPOSITORY}/releases/latest",
|
|
headers={"User-Agent": "Inbe-Compatibility-Test/1.0"}, method="HEAD")
|
|
with urllib.request.urlopen(request, timeout=60) as response:
|
|
target = urllib.parse.urlsplit(response.geturl())
|
|
prefix = f"/{REPOSITORY}/releases/tag/"
|
|
if target.scheme != "https" or target.hostname != "github.com" or not target.path.startswith(prefix):
|
|
raise ValueError("GitHub's latest release link did not resolve to this repository's release")
|
|
tag = urllib.parse.unquote(target.path[len(prefix):])
|
|
if not tag or "/" in tag:
|
|
raise ValueError("GitHub's latest release link returned no release tag")
|
|
return tag
|
|
|
|
|
|
def declared_host(ledger, name):
|
|
return ledger["apps"][name].get("host_api", ledger["host_api"])
|
|
|
|
|
|
def run_app(binary, bundle, feature, output, label):
|
|
"""Open one package and render its app once on a private display."""
|
|
environment = {key: value for key, value in os.environ.items() if key not in SCRUBBED}
|
|
environment.update(YUE_DESKTOP_RECOVERY="0", SDL_AUDIODRIVER="dummy", APP_NO_TRAY="1")
|
|
image = output / (label + ".png")
|
|
log = output / (label + ".log")
|
|
image.unlink(missing_ok=True)
|
|
command = ["xvfb-run", "-a", "-n", "361", "-s", "-noreset -screen 0 1280x900x24", str(binary),
|
|
"--bundle", str(bundle), *(["--feature", feature] if feature else []),
|
|
"--screenshot", str(image), "--screenshot-width", "540", "--screenshot-height", "960"]
|
|
with tempfile.TemporaryDirectory(prefix=label + '-profile-', dir=output) as profile, log.open("w") as stream:
|
|
environment['APP_DATA_ROOT'] = profile
|
|
result = subprocess.run(command, env=environment, stdout=stream, stderr=subprocess.STDOUT,
|
|
timeout=180)
|
|
text = log.read_text(errors="replace")
|
|
if result.returncode != 0 or not image.exists():
|
|
raise AssertionError(f"{label}: the app rejected the package (exit {result.returncode})\n{text[-2000:]}")
|
|
if any(message in text for message in ("app launch rejected", "cell launch rejected")):
|
|
raise AssertionError(f"{label}: the package loaded but its app did not open\n{text[-2000:]}")
|
|
# A host call whose records do not fit fails inside the package and the
|
|
# screen silently loses that part, so any failed call fails the check.
|
|
failures = sorted({line for line in text.splitlines() if "portable execution failed" in line})
|
|
if failures:
|
|
raise AssertionError(f"{label}: package calls failed: " + "; ".join(failures))
|
|
with Image.open(image) as picture:
|
|
if max(ImageStat.Stat(picture.convert("RGB")).stddev) < 2:
|
|
raise AssertionError(f"{label}: the app rendered a blank screen")
|
|
|
|
|
|
def forward(binary, origin, ledger, output):
|
|
oldest, current = host_range(ledger)
|
|
checked = 0
|
|
for name, app_id, _, feature in PACKAGES:
|
|
route = f"{origin}/api/v2/packages/{app_id}"
|
|
try:
|
|
metadata = json.loads(fetch(f"{route}/latest?host_api={current}&module_api={ledger['module_api']}&format=zx", 65536))
|
|
except urllib.error.HTTPError as error:
|
|
if error.code == 404:
|
|
print(f"forward {app_id}: the node has no release this build can run")
|
|
continue
|
|
raise
|
|
floor = ledger["apps"][name].get("oldest_host_api", oldest)
|
|
if not floor <= metadata["host_api"] <= current or metadata["module_api"] != ledger["module_api"]:
|
|
print(f"forward {app_id}: skipped {metadata['version']}, built for host "
|
|
f"{metadata['host_api']} outside {floor}..{current}")
|
|
continue
|
|
artifact = metadata["artifacts"][0]
|
|
data = fetch(f"{route}/{artifact['sha256']}.zx", artifact["size"])
|
|
if len(data) != artifact["size"] or hashlib.sha256(data).hexdigest() != artifact["sha256"]:
|
|
raise AssertionError(f"forward {app_id}: the node served bytes that differ from its release")
|
|
bundle = output / f"published-{name}.zx"
|
|
bundle.write_bytes(data)
|
|
run_app(binary, bundle, feature, output, f"forward-{name}")
|
|
print(f"forward {app_id} {metadata['version']} (host {metadata['host_api']}): runs in this build")
|
|
checked += 1
|
|
return checked
|
|
|
|
|
|
def published_release(origin, ledger, app_id, output):
|
|
"""Download the node's release of app_id for this build, or None if it serves none."""
|
|
oldest, current = host_range(ledger)
|
|
route = f"{origin}/api/v2/packages/{app_id}"
|
|
try:
|
|
metadata = json.loads(fetch(
|
|
f"{route}/latest?host_api={current}&module_api={ledger['module_api']}&format=zx", 65536))
|
|
except urllib.error.HTTPError as error:
|
|
if error.code == 404:
|
|
return None
|
|
raise
|
|
if not oldest <= metadata["host_api"] <= current or metadata["module_api"] != ledger["module_api"]:
|
|
raise AssertionError(f"The published {app_id} package does not support this host")
|
|
artifact = metadata["artifacts"][0]
|
|
data = fetch(f"{route}/{artifact['sha256']}.zx", artifact["size"])
|
|
if len(data) != artifact["size"] or hashlib.sha256(data).hexdigest() != artifact["sha256"]:
|
|
raise AssertionError(f"The node's {app_id} bytes differ from its release")
|
|
directory = output / ("published-" + app_id.split(".")[-1])
|
|
directory.mkdir(parents=True, exist_ok=True)
|
|
bundle = directory / (app_id.split(".")[-1] + ".zx")
|
|
bundle.write_bytes(data)
|
|
(directory / "release.json").write_text(json.dumps(metadata, indent=2) + "\n")
|
|
return bundle, metadata
|
|
|
|
|
|
def published_release_retried(origin, ledger, app_id, output, attempts=6, delay=15):
|
|
"""The node restarts for a minute or so whenever it is deployed; ask
|
|
again for a while before deciding that it serves no release."""
|
|
for attempt in range(attempts):
|
|
try:
|
|
return published_release(origin, ledger, app_id, output)
|
|
except (OSError, ValueError) as error:
|
|
if attempt == attempts - 1:
|
|
raise
|
|
print(f"forward {app_id}: the node did not answer ({error}); asking again")
|
|
time.sleep(delay)
|
|
return None
|
|
|
|
|
|
def published_games(binary, origin, ledger, output):
|
|
"""Install and play the node's games, independently of Arcade's checkout.
|
|
|
|
Arcade carries Chess; Chess on its own is checked only while the node
|
|
still serves it. At least one of them must be served.
|
|
"""
|
|
environment = {key: value for key, value in os.environ.items() if key not in SCRUBBED}
|
|
environment["YUE_DESKTOP_RECOVERY"] = "0"
|
|
checked = 0
|
|
for app_id, test in (("inbe.arcade", "tests/arcade_ui_test.sh"), ("inbe.chess", "tests/chess_ui_test.sh")):
|
|
published = published_release_retried(origin, ledger, app_id, output)
|
|
if published is None:
|
|
print(f"forward {app_id}: the node serves no release")
|
|
continue
|
|
bundle, metadata = published
|
|
subprocess.run(["sh", str(ROOT / test), str(binary), str(bundle)],
|
|
env=environment, check=True, timeout=600)
|
|
print(f"forward {app_id} {metadata['version']}: install, play, board and saved restart passed")
|
|
checked += 1
|
|
if checked == 0:
|
|
raise AssertionError("The node serves neither Arcade nor Chess")
|
|
return checked
|
|
|
|
|
|
def released_app(tag, output):
|
|
"""Unpack the release's Linux AppImage without FUSE."""
|
|
image = output / "released.AppImage"
|
|
image.write_bytes(fetch(f"https://github.com/{REPOSITORY}/releases/download/{tag}/"
|
|
"inbe-linux-x86_64.AppImage", 256 * 1024 * 1024))
|
|
image.chmod(image.stat().st_mode | stat.S_IXUSR)
|
|
environment = {key: value for key, value in os.environ.items() if key not in SCRUBBED}
|
|
subprocess.run([str(image), "--appimage-extract"], cwd=output, env=environment, check=True,
|
|
stdout=subprocess.DEVNULL, timeout=300)
|
|
return output / "squashfs-root/AppRun"
|
|
|
|
|
|
def reverse(tag, ledger, output):
|
|
released = json.loads(fetch(f"https://raw.githubusercontent.com/{REPOSITORY}/{tag}/apps/versions.json", 65536))
|
|
if released.get("package_format", "zib") != ledger.get("package_format", "zib"):
|
|
print(f"reverse {tag}: the released app runs {released.get('package_format', 'zib')} packages and is "
|
|
f"never offered these {ledger.get('package_format', 'zib')} ones; nothing to check")
|
|
return 0
|
|
oldest, current = host_range(released)
|
|
candidates = [package for package in PACKAGES
|
|
if oldest <= declared_host(ledger, package[0]) <= current and
|
|
ledger["module_api"] == released["module_api"]]
|
|
if not candidates:
|
|
print(f"reverse {tag}: no package here declares host {oldest}..{current}; nothing to check")
|
|
return 0
|
|
binary = released_app(tag, output)
|
|
for name, app_id, path, feature in candidates:
|
|
bundle = ROOT / path
|
|
if not bundle.exists():
|
|
raise AssertionError(f"reverse {app_id}: {path} is missing; build the packages first")
|
|
run_app(binary, bundle, feature, output, f"reverse-{name}")
|
|
print(f"reverse {app_id} (declares host {declared_host(ledger, name)}): runs in {tag}")
|
|
return len(candidates)
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("binary", type=Path, nargs="?", help="this build's app; needed unless --skip-forward")
|
|
parser.add_argument("--origin", default="https://api.waozi.xyz")
|
|
parser.add_argument("--release", help="Release tag to check new packages against (default: the latest)")
|
|
parser.add_argument("--skip-forward", action="store_true")
|
|
parser.add_argument("--skip-reverse", action="store_true")
|
|
args = parser.parse_args()
|
|
ledger = json.loads((ROOT / "apps/versions.json").read_text())
|
|
output = ROOT / "build/package-compat-test"
|
|
output.mkdir(parents=True, exist_ok=True)
|
|
checked = 0
|
|
if not args.skip_forward:
|
|
if args.binary is None:
|
|
parser.error("the forward check needs this build's app binary")
|
|
binary = args.binary.resolve(strict=True)
|
|
origin = args.origin.rstrip("/")
|
|
checked += forward(binary, origin, ledger, output)
|
|
checked += published_games(binary, origin, ledger, output)
|
|
if not args.skip_reverse:
|
|
tag = args.release
|
|
if tag is None:
|
|
tag = latest_release_tag()
|
|
with tempfile.TemporaryDirectory(prefix="inbe-released-", dir=output) as directory:
|
|
checked += reverse(tag, ledger, Path(directory))
|
|
print(f"Package compatibility: {checked} package runs passed")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|