Files
Triforce-Source/tests/test_linux_update.py
ruckus7382sfgsgdf e33a732651 Triforce v0.3.4
The slowdown in fights and the controller whose buttons stopped arriving are fixed; the checks' file names; groundwork for Linux.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 13:58:36 -06:00

850 lines
49 KiB
Python

"""Linux updates download a part only when its checksum changed, and the launcher starts the installed builder.
python -I -B tests/test_linux_update.py
"""
import io
import os
import shutil
import stat
import subprocess
import sys
import tempfile
import unittest
import zipfile
from pathlib import Path
# (Linux only)
RUN_ALL_SKIP = {"windows": "the Linux builder's update and folder launcher, POSIX files and shell scripts"}
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "builder" / "linux"))
sys.path.insert(0, str(ROOT / "nx2"))
sys.path.insert(0, str(ROOT / "scripts" / "linux"))
import linux_update # noqa: E402
import make_parts # noqa: E402
def sysroot_fixture(root):
source = root / "usr" / "lib" / "hookshot" / "sysroot"
lib = source / "usr" / "lib" / "x86_64-linux-gnu"
lib.mkdir(parents=True)
(source / "lib").symlink_to("usr/lib")
(lib / "libmvec.so").symlink_to("/lib/x86_64-linux-gnu/libmvec.so.1")
(lib / "libmvec.so.1").write_bytes(b"contents")
return source
def zip_link(zipped, name, target):
info = zipfile.ZipInfo(name)
info.create_system = 3
info.external_attr = (stat.S_IFLNK | 0o777) << 16
zipped.writestr(info, target)
def appdir(path):
"""A tiny AppDir: one file in each part, plus the launcher script an install copies to AppRun."""
tools = path / "usr" / "share" / "hookshot"
(tools / "builder" / "linux").mkdir(parents=True)
shutil.copyfile(ROOT / "builder" / "linux" / "AppRun", tools / "builder" / "linux" / "AppRun")
(tools / "VERSION").write_text("v1\n", encoding="utf-8")
(tools / "nx2").mkdir()
(tools / "nx2" / "marker.py").write_text("print('one')\n", encoding="utf-8")
for dest in ("usr/python", "usr/lib/hookshot/emsdk", "usr/lib/hookshot/ffmpeg", "usr/lib/hookshot/sysroot"):
folder = path / dest
folder.mkdir(parents=True)
(folder / "kept").write_text(dest + "\n", encoding="utf-8")
lib = path / "usr" / "lib" / "hookshot"
(lib / "hookshot_vk.so").write_bytes(b"vk")
(lib / "libSDL2-2.0.so.0").write_bytes(b"sdl")
(path / "AppRun").write_text("#!/bin/sh\n", encoding="utf-8")
(path / "AppRun").chmod(0o755)
class UpdateTests(unittest.TestCase):
def test_relative_links_and_final_list_stay_inside_the_staging_tree(self):
from unittest import mock
with tempfile.TemporaryDirectory(prefix="hookshot-link-bounds-") as tmp:
root = Path(tmp).resolve()
cases = (
("download-manifest-escape", False, linux_update.LIST_NAME, "../canary", False),
("reuse-manifest-escape", True, linux_update.LIST_NAME, "../canary", False),
("download-unused-escape", False, "alias", "../canary", False),
("reuse-unused-escape", True, "alias", "../canary", False),
("reuse-listed-escape", True, "alias", "../canary", False),
("reuse-absolute-escape", True, "alias", None, False),
("part-supplied-list", False, linux_update.LIST_NAME, None, False),
("internal-list-alias", False, linux_update.LIST_NAME, "inside", False),
("download-cross-part", False, "alias", "usr/lib/target", True),
("reuse-cross-part", True, "alias", "usr/lib/target", True),
("download-forward-link", False, "alias", "inside", True),
("reuse-listed-internal", True, "alias", "inside", True),
)
for label, reuse, name, link_to, succeeds in cases:
with self.subTest(case=label):
case = root / label
home = case / "home"
versions = home / "triforce" / "builder" / "versions"
previous = versions / "v1"
previous.mkdir(parents=True)
(previous / "kept").write_bytes(b"previous version")
current = versions.parent / "current"
current.write_text("v1\n", encoding="utf-8")
canary = versions / "canary"
canary.write_bytes(b"authored sibling canary")
partial = versions / "v2.part"
self.assertEqual(partial.parent, canary.parent)
self.assertIn(root, canary.resolve().parents)
before = canary.read_bytes()
files = {"usr/share/hookshot/builder/linux/AppRun": b"authored placeholder, never executed\n",
"inside": b"inside"}
if "listed" in label:
del files["usr/share/hookshot/builder/linux/AppRun"]
if link_to is None and reuse:
link_to = str(canary)
if link_to is None:
files[name] = b"part-supplied list"
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
if link_to is not None:
zip_link(zipped, name, link_to) # before its target, when it is a valid forward link
for filename, data in files.items():
zipped.writestr(filename, data)
data = archive.getvalue()
part = linux_update.Part(linux_update._sha256(data), len(data), ".", "authored-part", None)
if "listed" in label:
part.files = list(files) + [name]
parts, payloads = [part], {part.url: data}
if "listed" in label:
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
zipped.writestr("usr/share/hookshot/builder/linux/AppRun", b"authored placeholder, never executed\n")
data = archive.getvalue()
tools = linux_update.Part(linux_update._sha256(data), len(data), ".", "authored-tools", None)
parts.append(tools)
payloads[tools.url] = data
if "cross-part" in label:
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
zipped.writestr("target", b"cross-part")
data = archive.getvalue()
other = linux_update.Part(linux_update._sha256(data), len(data), "usr/lib", "authored-library", None)
parts.append(other)
payloads[other.url] = data
source_root, source = None, None
if reuse:
source_root = case / "source"
source_root.mkdir()
for filename, content in files.items():
path = source_root / filename
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(content)
(source_root / name).symlink_to(link_to)
source = linux_update.Manifest("v1", [part])
error = None
with mock.patch.dict(os.environ, {"HOOKSHOT_BUILDER_HOME": str(home)}):
try:
apprun = linux_update.install(linux_update.Manifest("v2", parts),
str(source_root) if reuse else None, source,
get=lambda url: payloads[url])
except Exception as caught:
error = caught
# Check even when install raised: an error after truncation is not safe rejection.
self.assertEqual(canary.read_bytes(), before, "the sibling canary was overwritten")
if succeeds:
self.assertIsNone(error)
installed = versions / "v2"
self.assertEqual(apprun, str(installed / "AppRun"))
self.assertEqual(current.read_text(encoding="utf-8"), "v2\n")
self.assertEqual((installed / "alias").read_bytes(),
b"cross-part" if "cross-part" in label else b"inside")
self.assertTrue((installed / "alias").is_symlink())
else:
self.assertIsInstance(error, (ValueError, FileExistsError))
self.assertEqual(current.read_text(encoding="utf-8"), "v1\n")
self.assertEqual((previous / "kept").read_bytes(), b"previous version")
self.assertFalse(partial.exists())
print("PASS link bounds:", label)
with self.subTest(case="relative-target-through-an-existing-alias"):
case = root / "resolved-escape"
dest = case / "stage"
dest.mkdir(parents=True)
canary = case / "canary"
canary.write_bytes(b"resolved sibling canary")
before = canary.read_bytes()
(dest / "redirect").symlink_to("..", target_is_directory=True)
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
zip_link(zipped, "alias", "redirect/canary")
error = None
try:
linux_update._unpack(archive.getvalue(), str(dest), None)
except Exception as caught:
error = caught
self.assertEqual(canary.read_bytes(), before)
self.assertIsInstance(error, ValueError)
self.assertFalse((dest / "alias").is_symlink())
print("PASS link bounds: relative-target-through-an-existing-alias")
with self.subTest(case="published-parts-do-not-own-the-list"):
source, out = root / "publisher", root / "parts"
appdir(source)
with mock.patch.object(sys, "argv", ["make_parts.py", str(source), "v2", str(out)]):
make_parts.main()
manifest = linux_update.parse_list((out / linux_update.LIST_NAME).read_text(encoding="utf-8"))
payloads = {}
for part in manifest.parts:
archive = out / part.url.rsplit("/", 1)[-1]
with zipfile.ZipFile(archive) as zipped:
self.assertNotIn(linux_update.LIST_NAME, zipped.namelist())
payloads[part.url] = archive.read_bytes()
home = root / "publisher-home"
versions = home / "triforce" / "builder" / "versions"
versions.mkdir(parents=True)
canary = versions / "canary"
canary.write_bytes(b"publisher sibling canary")
before = canary.read_bytes()
with mock.patch.dict(os.environ, {"HOOKSHOT_BUILDER_HOME": str(home)}):
apprun = linux_update.install(manifest, None, None, get=lambda url: payloads[url])
self.assertEqual(canary.read_bytes(), before)
self.assertTrue(Path(apprun).is_file())
installed = linux_update.read_manifest(str(versions / "v2"))
self.assertEqual(installed.tag, "v2")
self.assertEqual(len(installed.parts), len(make_parts.PARTS))
print("PASS link bounds: published-parts-do-not-own-the-list")
def test_install_rejects_a_staging_link_before_cleanup_or_placing_parts(self):
from unittest import mock
for exists in (False, True):
with self.subTest(target_exists=exists), tempfile.TemporaryDirectory(prefix="hookshot-stage-") as tmp:
root = Path(tmp).resolve()
home = root / "home"
versions = home / "triforce" / "builder" / "versions"
versions.mkdir(parents=True)
target = root / "outside-stage"
sentinel = root / "sentinel"
sentinel.write_text("unchanged", encoding="utf-8")
if exists:
target.mkdir()
(target / "kept").write_text("unchanged", encoding="utf-8")
self.assertIn(root, target.resolve().parents)
partial = versions / "v2.part"
partial.symlink_to(target, target_is_directory=True)
current = versions.parent / "current"
current.write_text("v1\n", encoding="utf-8")
manifest = linux_update.Manifest("v2", [linux_update.Part("a" * 64, 1, "usr/python", "unused", None)])
get = mock.Mock(side_effect=AssertionError("download must not start"))
with mock.patch.dict(os.environ, {"HOOKSHOT_BUILDER_HOME": str(home)}), \
mock.patch.object(linux_update, "_place", side_effect=AssertionError("placement must not start")) as place, \
mock.patch.object(linux_update.shutil, "rmtree", side_effect=AssertionError("cleanup must not start")) as cleanup:
error = None
try:
linux_update.install(manifest, None, None, get=get)
except Exception as caught:
error = caught
self.assertIsInstance(error, ValueError)
self.assertIn(str(partial), str(error))
self.assertIn("symbolic link", str(error))
cleanup.assert_not_called()
place.assert_not_called()
get.assert_not_called()
self.assertTrue(partial.is_symlink())
self.assertEqual(os.readlink(partial), str(target))
self.assertEqual(target.exists(), exists)
if exists:
self.assertEqual(sorted(p.name for p in target.iterdir()), ["kept"])
self.assertEqual((target / "kept").read_text(encoding="utf-8"), "unchanged")
self.assertEqual(sentinel.read_text(encoding="utf-8"), "unchanged")
self.assertEqual(current.read_text(encoding="utf-8"), "v1\n")
def test_install_keeps_real_staging_and_symlinked_parent_roots_working(self):
from unittest import mock
for linked_home, stale in ((False, False), (False, True), (True, False)):
with self.subTest(linked_home=linked_home, stale=stale), tempfile.TemporaryDirectory(prefix="hookshot-stage-") as tmp:
root = Path(tmp).resolve()
real_home = root / "real-home"
real_home.mkdir()
home = root / "linked-home" if linked_home else real_home
if linked_home:
home.symlink_to(real_home, target_is_directory=True)
self.assertIn(root, home.resolve().parents)
versions = home / "triforce" / "builder" / "versions"
old = versions / "v1"
old.mkdir(parents=True)
(old / "kept").write_text("old", encoding="utf-8")
partial = versions / "v2.part"
if stale:
partial.mkdir()
(partial / "stale").write_text("old", encoding="utf-8")
part = linux_update.Part("a" * 64, 1, "usr/share/hookshot", "unused", None)
manifest = linux_update.Manifest("v2", [part])
def place(part, source_root, source, dest_root, get, note):
self.assertEqual(dest_root, str(partial))
tools = Path(dest_root) / part.dest / "builder" / "linux"
tools.mkdir(parents=True)
(tools / "AppRun").write_text("authored placeholder, never executed\n", encoding="utf-8")
get = mock.Mock(side_effect=AssertionError("no download in this fixture"))
with mock.patch.dict(os.environ, {"HOOKSHOT_BUILDER_HOME": str(home)}), \
mock.patch.object(linux_update, "_place", side_effect=place) as placed:
apprun = linux_update.install(manifest, None, None, get=get)
installed = versions / "v2"
self.assertEqual(apprun, str(installed / "AppRun"))
self.assertEqual((installed / "AppRun").read_text(encoding="utf-8"), "authored placeholder, never executed\n")
self.assertEqual((versions.parent / "current").read_text(encoding="utf-8"), "v2\n")
self.assertEqual(sorted(p.name for p in versions.iterdir()), ["v2"])
self.assertFalse((installed / "stale").exists())
self.assertTrue((installed / linux_update.LIST_NAME).is_file())
placed.assert_called_once()
get.assert_not_called()
if linked_home:
self.assertTrue(home.is_symlink())
def test_a_list_whose_names_leave_the_versions_folder_is_refused(self):
sha = "a" * 64
good = "tag v2.1.0\npart %s 10 usr/share/hookshot https://example.invalid/p.zip\nfile nx2/marker.py\n" % sha
self.assertEqual(linux_update.parse_list(good).tag, "v2.1.0")
bad = [
good.replace("tag v2.1.0", "tag .."),
good.replace("tag v2.1.0", "tag /home/someone"),
good.replace("tag v2.1.0", "tag ../../x"),
good.replace("usr/share/hookshot", "../../outside"),
good.replace("usr/share/hookshot", "/abs"),
good.replace("file nx2/marker.py", "file ../../../x"),
good.replace(sha, "abc"),
good.replace("https://", "http://"),
]
for text in bad:
with self.assertRaises(ValueError, msg=text):
linux_update.parse_list(text)
# a file link is for a list from this PC only, not one downloaded (it read /dev/zero, or tested a file's hash)
local = good.replace("https://example.invalid/p.zip", "file:///dev/zero")
self.assertEqual(linux_update.parse_list(local).tag, "v2.1.0")
with self.assertRaises(ValueError):
linux_update.parse_list(local, local=False)
with self.assertRaises(ValueError):
linux_update.fetch_manifest(get=lambda url: local.encode())
def test_a_download_reads_at_most_its_limit(self):
import io
self.assertEqual(linux_update._read_at_most(io.BytesIO(b"x" * 10), 10), b"x" * 10)
with self.assertRaises(RuntimeError):
linux_update._read_at_most(io.BytesIO(b"x" * 11), 10)
def test_a_download_is_a_get(self):
# (Request's second argument is the POST body: v2.0.12's str there failed every download before it connected)
from unittest import mock
seen = []
class Answer(io.BytesIO):
def __enter__(self):
return self
def __exit__(self, *exc):
return False
def urlopen(req, timeout=None):
seen.append(req)
return Answer(b"list")
with mock.patch("urllib.request.urlopen", urlopen):
self.assertEqual(linux_update._request("https://example.invalid/list.txt", 5), b"list")
self.assertEqual(seen[0].get_method(), "GET")
self.assertIsNone(seen[0].data)
def test_a_link_chain_cannot_leave_the_staging_tree(self):
# x/../.. is inside the folder as written, but the system resolves x first: a link made after it (in the same zip
# or a later part) put the chain anywhere, and AppRun copied into a link wrote a file outside the install
from unittest import mock
deep = "a/b/c/d/e/f"
chains = (
("climb-after-a-name", [("L", "t/../canary"), ("t", ".")]),
("apprun-through-a-chain", [("AppRun", deep + "/L"), (deep + "/L", "t/../canary"), (deep + "/t", "../" * 6)]),
)
for label, links in chains:
with self.subTest(case=label), tempfile.TemporaryDirectory(prefix="hookshot-chain-") as tmp:
home = Path(tmp).resolve() / "home"
versions = home / "triforce" / "builder" / "versions"
versions.mkdir(parents=True)
canary = versions / "canary"
canary.write_bytes(b"canary")
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
for name, target in links:
zip_link(zipped, name, target)
zipped.writestr("usr/share/hookshot/builder/linux/AppRun", b"#!/bin/sh\necho changed\n")
data = archive.getvalue()
part = linux_update.Part(linux_update._sha256(data), len(data), ".", "chain-part", None)
with mock.patch.dict(os.environ, {"HOOKSHOT_BUILDER_HOME": str(home)}):
with self.assertRaises(ValueError):
linux_update.install(linux_update.Manifest("v2", [part]), None, None, get=lambda url: data)
self.assertEqual(canary.read_bytes(), b"canary")
self.assertFalse((versions / "v2").exists())
self.assertFalse((versions / "v2.part").exists())
# (leading .. stays allowed: the toolchain's links are written that way)
with tempfile.TemporaryDirectory(prefix="hookshot-chain-ok-") as tmp:
dest = Path(tmp) / "stage"
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
zipped.writestr("lib/real", b"real")
zip_link(zipped, "bin/alias", "../lib/real")
linux_update._unpack(archive.getvalue(), str(dest), None)
self.assertEqual((dest / "bin" / "alias").read_bytes(), b"real")
def test_unpacked_files_are_not_group_or_world_writable(self):
with tempfile.TemporaryDirectory(prefix="hookshot-mode-") as tmp:
dest = Path(tmp) / "stage"
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
for name, mode in (("tool", 0o777), ("data", 0o666), ("setuid", 0o4755)):
info = zipfile.ZipInfo(name)
info.create_system = 3
info.external_attr = (stat.S_IFREG | mode) << 16
zipped.writestr(info, b"x")
linux_update._unpack(archive.getvalue(), str(dest), None)
self.assertEqual((dest / "tool").stat().st_mode & 0o7777, 0o755)
self.assertEqual((dest / "data").stat().st_mode & 0o7777, 0o644)
self.assertEqual((dest / "setuid").stat().st_mode & 0o7777, 0o755)
def test_the_button_matches_the_windows_builder(self):
self.assertEqual(linux_update.choose_mode("v1", "v2", "v2", False, True), "update-game")
self.assertEqual(linux_update.choose_mode("v2", "v2", "v2", False, True), "up-to-date")
self.assertEqual(linux_update.choose_mode("v1", "v1", None, False, True), "up-to-date")
self.assertEqual(linux_update.choose_mode("v1", "v1", "v2", False, True), "update-game")
self.assertEqual(linux_update.choose_mode(None, "v1", "v2", False, False), "update-builder")
self.assertEqual(linux_update.choose_mode(None, "v2", "v2", False, False), "build")
self.assertEqual(linux_update.choose_mode("v2", "v2", "v2", True, True), "build")
def test_a_build_that_is_not_an_older_release_is_not_made_to_update(self):
# (issue 902) an AppImage from the Actions tab is git describe's version, after the latest release: it builds
ci = "v2.0.5-3-g1a2b3c4"
self.assertEqual(linux_update.choose_mode(None, ci, "v2.0.5", False, False), "build")
self.assertEqual(linux_update.choose_mode(None, "1a2b3c4", "v2.0.5", False, False), "build")
self.assertEqual(linux_update.choose_mode(None, "dev", "v2.0.5", False, False), "build")
self.assertEqual(linux_update.choose_mode(None, "v2.0.6", "v2.0.5", False, False), "build")
self.assertEqual(linux_update.choose_mode(None, "v2.1.0-rc.1", "v2.0.5", False, False), "build")
# (its game is played, not taken back to the release; an older game is built again with this builder)
self.assertEqual(linux_update.choose_mode(ci, ci, "v2.0.5", False, True), "up-to-date")
self.assertEqual(linux_update.choose_mode("v2.0.4", ci, "v2.0.5", False, True), "update-game")
self.assertEqual(linux_update.update_target("v2.0.5", ci), ci)
# (a game the release built is older than this Actions builder: its Update builds it again with the builder running,
# nothing downloaded, as for any older game)
self.assertEqual(linux_update.choose_mode("v2.0.5", ci, "v2.0.5", False, True), "update-game")
# an older release still gets the newer one
self.assertEqual(linux_update.choose_mode(None, "v2.0.4", "v2.0.5", False, False), "update-builder")
self.assertEqual(linux_update.choose_mode(None, "v2.1.0-rc.1", "v2.1.0", False, False), "update-builder")
self.assertEqual(linux_update.choose_mode(None, "v2.0.10", "v2.0.9", False, False), "build")
self.assertEqual(linux_update.choose_mode("v2.0.4", "v2.0.4", "v2.0.5", False, True), "update-game")
self.assertEqual(linux_update.update_target("v2.0.5", "v2.0.4"), "v2.0.5")
# a build from the Actions tab made after an older release is offered the newer one
self.assertEqual(linux_update.choose_mode(None, "v2.0.4-3-g1a2b3c4", "v2.0.5", False, False), "update-builder")
self.assertEqual(linux_update.choose_mode(None, "v2.0.5-3-g1a2b3c4-dirty", "v2.0.5", False, False), "build")
self.assertEqual(linux_update.choose_mode(None, "v2.1.0-rc.1-2-gabc1234", "v2.1.0", False, False), "update-builder")
def test_an_rc_build_with_its_own_list_is_not_downgraded_to_the_release(self):
# (issue 990: a -rc AppImage ships correct tools and a list naming its own parts, while releases/latest is an
# older release whose zip lacks a file these tools have: reinstalling it every launch lost that file)
from unittest import mock
with tempfile.TemporaryDirectory(prefix="hookshot-updates-") as tmp:
root = Path(tmp) / "rc"
appdir(root)
(root / "usr" / "share" / "hookshot" / "VERSION").write_text("v1.1-rc.1\n", encoding="utf-8")
(root / "triforce-linux.txt").write_text(
"tag v1.1-rc.1\npart %s 10 usr/share/hookshot file://%s/rc.zip\nfile nx2/marker.py\n" % ("a" * 64, tmp),
encoding="utf-8")
stable = "tag v1.0\npart %s 10 usr/share/hookshot https://example.invalid/old.zip\nfile nx2/marker.py\n" % ("b" * 64)
got = linux_update.startup_manifest(str(root), get=lambda url: stable.encode())
self.assertEqual((got.tag, got.parts[0].sha), ("v1.1-rc.1", "a" * 64)) # (its own: nothing reinstalled)
newer = "tag v1.2\npart %s 10 usr/share/hookshot https://example.invalid/new.zip\nfile nx2/marker.py\n" % ("c" * 64)
got = linux_update.startup_manifest(str(root), get=lambda url: newer.encode())
self.assertEqual((got.tag, got.parts[0].sha), ("v1.2", "c" * 64)) # (a newer release still wins)
# a HOOKSHOT_LINUX_LIST is taken even when the tags match (a patched part for a release, issue 990)
(root / "patched.txt").write_text(
"tag v1.1-rc.1\npart %s 10 usr/share/hookshot file://%s/patched.zip\nfile nx2/marker.py\n" % ("d" * 64, tmp),
encoding="utf-8")
with mock.patch.dict(os.environ, {"HOOKSHOT_LINUX_LIST": str(root / "patched.txt")}):
got = linux_update.startup_manifest(str(root), get=lambda url: stable.encode())
self.assertEqual(got.parts[0].sha, "d" * 64)
# an AppImage at the latest release keeps using its bundled list (nothing was ever reinstalled there)
release = Path(tmp) / "release"
appdir(release) # (VERSION v1)
(release / "triforce-linux.txt").write_text(
"tag v1\npart %s 10 usr/share/hookshot file://%s/release.zip\nfile nx2/marker.py\n" % ("e" * 64, tmp),
encoding="utf-8")
same = "tag v1\npart %s 10 usr/share/hookshot https://example.invalid/old.zip\nfile nx2/marker.py\n" % ("b" * 64)
got = linux_update.startup_manifest(str(release), get=lambda url: same.encode())
self.assertEqual(got.parts[0].sha, "e" * 64)
# and one older than the release still downloads it
(release / "usr" / "share" / "hookshot" / "VERSION").write_text("v0.9\n", encoding="utf-8")
got = linux_update.startup_manifest(str(release), get=lambda url: stable.encode())
self.assertEqual(got.parts[0].sha, "b" * 64)
def test_a_changed_part_is_downloaded_and_the_rest_are_kept(self):
with tempfile.TemporaryDirectory(prefix="hookshot-parts-") as tmp:
root = Path(tmp)
old = root / "old"
appdir(old)
first = root / "parts1"
argv = sys.argv
try:
sys.argv = ["make_parts.py", str(old), "v1", str(first)]
make_parts.main()
finally:
sys.argv = argv
manifest = linux_update.parse_list((first / "triforce-linux.txt").read_text(encoding="utf-8"))
home = root / "home"
os.environ["HOOKSHOT_BUILDER_HOME"] = str(home)
self.addCleanup(lambda: os.environ.pop("HOOKSHOT_BUILDER_HOME", None))
downloaded = []
def get(url):
downloaded.append(url)
name = url.rsplit("/", 1)[-1]
return (first / name).read_bytes()
linux_update.install(manifest, str(old), manifest, get=get)
self.assertEqual(downloaded, [])
installed = home / "triforce" / "builder" / "versions" / "v1"
self.assertTrue((installed / "AppRun").stat().st_mode & stat.S_IXUSR)
self.assertEqual((installed / "usr" / "share" / "hookshot" / "nx2" / "marker.py").read_text(encoding="utf-8"), "print('one')\n")
new = root / "new"
shutil.copytree(old, new)
(new / "usr" / "share" / "hookshot" / "nx2" / "marker.py").write_text("print('two')\n", encoding="utf-8")
second = root / "parts2"
try:
sys.argv = ["make_parts.py", str(new), "v2", str(second)]
make_parts.main()
finally:
sys.argv = argv
nxt = linux_update.parse_list((second / "triforce-linux.txt").read_text(encoding="utf-8"))
downloaded.clear()
def get2(url):
downloaded.append(url)
name = url.rsplit("/", 1)[-1]
return (second / name).read_bytes()
linux_update.install(nxt, str(installed), manifest, get=get2)
self.assertEqual(len(downloaded), 1)
self.assertIn("usr-share-hookshot", downloaded[0])
built = home / "triforce" / "builder" / "versions" / "v2"
self.assertEqual((built / "usr" / "share" / "hookshot" / "nx2" / "marker.py").read_text(encoding="utf-8"), "print('two')\n")
self.assertEqual((built / "usr" / "lib" / "hookshot" / "hookshot_vk.so").read_bytes(), b"vk")
self.assertFalse((home / "triforce" / "builder" / "versions" / "v1").exists())
def test_an_installed_builder_finds_its_own_root(self):
with tempfile.TemporaryDirectory(prefix="hookshot-root-") as tmp:
root = Path(tmp) / "versions" / "v1"
appdir(root)
saved = {k: os.environ.get(k) for k in ("APPDIR", "HOOKSHOT_TOOLS")}
os.environ.pop("APPDIR", None)
os.environ["HOOKSHOT_TOOLS"] = str(root / "usr" / "share" / "hookshot")
try:
found = linux_update.running_root()
finally:
for k, v in saved.items():
if v is None:
os.environ.pop(k, None)
else:
os.environ[k] = v
self.assertEqual(found, str(root))
self.assertEqual(linux_update.tools_tag(found), "v1")
@unittest.skipUnless(sys.platform.startswith("linux"), "the Linux folder layout")
def test_a_packaged_build_puts_the_launcher_in_the_folder_and_the_game_in_bin(self):
import ast
from unittest import mock
import make_game
main = next(n for n in ast.parse((ROOT / "nx2" / "make_game.py").read_text(encoding="utf-8")).body
if isinstance(n, ast.FunctionDef) and n.name == "main")
start = next(i for i, n in enumerate(main.body) if isinstance(n, ast.Assign)
and any(isinstance(t, ast.Name) and t.id == "staged" for t in n.targets))
end = next(i for i, n in enumerate(main.body[start + 1:], start + 1) if isinstance(n, ast.If)
and any(isinstance(c, ast.Call) and isinstance(c.func, ast.Name) and c.func.id == "shader_census_cmd"
for c in ast.walk(n)))
finish = compile(ast.Module(body=main.body[start:end], type_ignores=[]), "make_game.py", "exec")
with tempfile.TemporaryDirectory(prefix="hookshot-finish-") as tmp:
work, out = Path(tmp) / "work", Path(tmp) / "game"
built = work / "sa" / "build"
built.mkdir(parents=True)
(work / "sa" / "image").mkdir()
(work / "sa" / "image" / "image.bin").write_bytes(b"image")
for name in make_game.BESIDE:
(built / name).write_bytes(b"new " + name.encode())
out.mkdir()
for name in make_game.BESIDE: # (a folder from a builder before the launcher: the game and its libraries in it)
(out / name).write_bytes(b"old " + name.encode())
with mock.patch.dict(os.environ, {"HOOKSHOT_TOOLS": str(ROOT)}):
exec(finish, make_game.__dict__, {"built": str(built), "out": str(out), "work": str(work)})
self.assertEqual((out / make_game.BESIDE[0]).read_bytes(), (ROOT / "builder" / "linux" / "hookshot-folder").read_bytes())
self.assertTrue((out / make_game.BESIDE[0]).stat().st_mode & stat.S_IXUSR)
self.assertEqual(sorted(p.name for p in out.iterdir()), sorted(["bin", make_game.BESIDE[0], "image.bin"]))
self.assertEqual(sorted(p.name for p in (out / "bin").iterdir()), sorted(make_game.BESIDE))
self.assertEqual((out / "bin" / make_game.BESIDE[0]).read_bytes(), b"new " + make_game.BESIDE[0].encode())
def test_the_sysroot_path_is_not_part_of_an_object_key(self):
import build
handle, name = tempfile.mkstemp()
os.write(handle, b"int x;\n")
os.close(handle)
try:
one = build.object_key(name, ["--sysroot=/tmp/.mount_aaa/usr/lib/hookshot/sysroot", "-O2"], b"deps")
two = build.object_key(name, ["--sysroot=/tmp/.mount_bbb/usr/lib/hookshot/sysroot", "-O2"], b"deps")
finally:
os.remove(name)
self.assertEqual(one, two)
def test_the_folder_launcher_starts_the_builder(self):
with tempfile.TemporaryDirectory(prefix="hookshot-folder-") as tmp:
root = Path(tmp)
game = root / "game"
(game / "bin").mkdir(parents=True)
(game / "image.bin").write_bytes(b"image")
started = root / "started"
builder = root / "builder"
builder.write_text("#!/bin/sh\nprintf '%%s\\n' \"$0\" \"$@\" > '%s'\n" % started, encoding="utf-8")
builder.chmod(0o755)
(game / "hookshot_version.txt").write_text("version=v1\nbuilder=%s\n" % builder, encoding="utf-8")
script = game / "hookshot"
shutil.copyfile(ROOT / "builder" / "linux" / "hookshot-folder", script)
script.chmod(0o755)
env = os.environ.copy()
env["HOOKSHOT_BUILDER_HOME"] = str(root / "none")
ran = subprocess.run([str(script)], env=env, check=False, text=True, capture_output=True)
self.assertEqual(ran.returncode, 0, ran.stderr)
lines = started.read_text(encoding="utf-8").splitlines()
self.assertEqual(lines[1], "--launch")
self.assertEqual(lines[2], str(game))
def test_the_folder_launcher_finds_the_builder_under_the_builder_home(self):
# HOOKSHOT_BUILDER_HOME is the data directory, as XDG_DATA_HOME is: linux_update installs to
# <home>/triforce/builder and host/hos_update.c looks there, so the launcher must too
with tempfile.TemporaryDirectory(prefix="hookshot-folder-") as tmp:
root = Path(tmp)
game = root / "game"
(game / "bin").mkdir(parents=True)
home = root / "home"
started = root / "started"
installed = home / "triforce" / "builder"
(installed / "versions" / "v9").mkdir(parents=True)
(installed / "current").write_text("v9\n", encoding="utf-8")
apprun = installed / "versions" / "v9" / "AppRun"
apprun.write_text("#!/bin/sh\nprintf '%%s\\n' \"$0\" \"$@\" > '%s'\n" % started, encoding="utf-8")
apprun.chmod(0o755)
script = game / "hookshot"
shutil.copyfile(ROOT / "builder" / "linux" / "hookshot-folder", script)
script.chmod(0o755)
env = os.environ.copy()
env["HOOKSHOT_BUILDER_HOME"] = str(home)
ran = subprocess.run([str(script)], env=env, check=False, text=True, capture_output=True)
self.assertEqual(ran.returncode, 0, ran.stderr)
lines = started.read_text(encoding="utf-8").splitlines()
self.assertEqual(lines[0], str(apprun))
self.assertEqual(lines[1:], ["--launch", str(game)])
def test_the_folder_launcher_starts_the_game_when_no_builder_is_installed(self):
with tempfile.TemporaryDirectory(prefix="hookshot-folder-") as tmp:
root = Path(tmp)
game = root / "game"
(game / "bin").mkdir(parents=True)
(game / "bin" / "hookshot").write_text("#!/bin/sh\nprintf 'game\\n'\n", encoding="utf-8")
(game / "bin" / "hookshot").chmod(0o755)
script = game / "hookshot"
shutil.copyfile(ROOT / "builder" / "linux" / "hookshot-folder", script)
script.chmod(0o755)
env = os.environ.copy()
env["HOOKSHOT_BUILDER_HOME"] = str(root / "none")
ran = subprocess.run([str(script)], env=env, check=False, text=True, capture_output=True)
self.assertEqual(ran.returncode, 0, ran.stderr)
self.assertEqual(ran.stdout.strip(), "game")
def test_a_part_cannot_write_through_a_zip_symlink(self):
with tempfile.TemporaryDirectory(prefix="hookshot-zip-") as tmp:
root = Path(tmp)
outside = root / "outside"
outside.mkdir()
marker = outside / "marker"
marker.write_bytes(b"original")
# The third shape: an absolute target needs no write through the link to escape (#1295)
for link_target, member in ((outside, "link/marker"), (marker, "./link"), ("C:/escape" if os.name == "nt" else "/tmp/escape", None)):
with self.subTest(member=member):
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
link = zipfile.ZipInfo("link")
link.create_system = 3
link.external_attr = (stat.S_IFLNK | 0o777) << 16
zipped.writestr(link, str(link_target))
if member:
zipped.writestr(member, b"changed")
dest = root / ("directory" if member == "link/marker" else "file-abs" if member is None else "file")
with self.assertRaises((ValueError, FileExistsError)):
linux_update._unpack(archive.getvalue(), str(dest), None)
self.assertEqual(marker.read_bytes(), b"original")
def test_a_part_cannot_extract_through_a_symlinked_destination(self):
with tempfile.TemporaryDirectory(prefix="hookshot-zip-") as tmp:
root = Path(tmp)
outside = root / "outside"
outside.mkdir()
dest = root / "stage"
dest.mkdir()
(dest / "link").symlink_to(outside, target_is_directory=True)
staging_link = root / "staging-link"
staging_link.symlink_to(outside / "missing", target_is_directory=True)
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
zipped.writestr("marker", b"changed")
data = archive.getvalue()
for stage, folder in ((dest, "link/sub"), (staging_link, "usr")):
with self.subTest(folder=folder):
part = linux_update.Part(linux_update._sha256(data), len(data), folder, "test", None)
with self.assertRaises(ValueError):
linux_update._place(part, None, None, str(stage), lambda _: data, lambda _: None)
self.assertEqual(list(outside.iterdir()), [])
def test_a_part_keeps_toolchain_links(self):
with tempfile.TemporaryDirectory(prefix="hookshot-zip-") as tmp:
root = Path(tmp)
source = root / "sysroot"
source.mkdir()
(source / "lib").symlink_to("usr/lib")
(source / "libmvec.so").symlink_to("usr/lib/libmvec.so.1")
(source / "usr" / "lib").mkdir(parents=True)
(source / "usr" / "lib" / "marker").write_bytes(b"contents")
(source / "usr" / "lib" / "libmvec.so.1").write_bytes(b"library")
archive = root / "part.zip"
make_parts.write_zip(str(archive), str(root), "sysroot", None)
dest = root / "unpacked"
linux_update._unpack(archive.read_bytes(), str(dest), None)
self.assertEqual(os.readlink(dest / "libmvec.so"), "usr/lib/libmvec.so.1")
self.assertEqual((dest / "libmvec.so").read_bytes(), b"library")
self.assertEqual(os.readlink(dest / "lib"), "usr/lib")
self.assertEqual((dest / "lib" / "marker").read_bytes(), b"contents")
def test_a_new_sysroot_part_rebases_rooted_links(self):
with tempfile.TemporaryDirectory(prefix="hookshot-zip-") as tmp:
root = Path(tmp)
sysroot_fixture(root)
archive = root / "part.zip"
make_parts.write_zip(str(archive), str(root), linux_update.SYSROOT_PART, None)
dest = root / "unpacked"
linux_update._unpack(archive.read_bytes(), str(dest), None)
link = dest / "usr" / "lib" / "x86_64-linux-gnu" / "libmvec.so"
self.assertFalse(os.path.isabs(os.readlink(link)))
self.assertEqual(link.read_bytes(), b"contents")
self.assertEqual(os.readlink(dest / "lib"), "usr/lib")
def test_a_downloaded_legacy_sysroot_rebases_rooted_links(self):
with tempfile.TemporaryDirectory(prefix="hookshot-zip-") as tmp:
root = Path(tmp)
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
zip_link(zipped, "lib", "usr/lib")
zip_link(zipped, "usr/lib/x86_64-linux-gnu/libmvec.so", "/lib/x86_64-linux-gnu/libmvec.so.1")
zipped.writestr("usr/lib/x86_64-linux-gnu/libmvec.so.1", b"contents")
data = archive.getvalue()
with self.assertRaises(ValueError):
linux_update._unpack(data, str(root / "ordinary"), None)
part = linux_update.Part(linux_update._sha256(data), len(data), linux_update.SYSROOT_PART, "legacy", None)
dest = root / "installed"
linux_update._place(part, None, None, str(dest), lambda _: data, lambda _: None)
link = dest / linux_update.SYSROOT_PART / "usr" / "lib" / "x86_64-linux-gnu" / "libmvec.so"
self.assertFalse(os.path.isabs(os.readlink(link)))
self.assertEqual(link.read_bytes(), b"contents")
def test_a_kept_legacy_sysroot_rebases_rooted_links(self):
with tempfile.TemporaryDirectory(prefix="hookshot-sysroot-") as tmp:
root = Path(tmp)
source = root / "source"
sysroot_fixture(source)
part = linux_update.Part("a" * 64, 1, linux_update.SYSROOT_PART, "unused", None)
previous = linux_update.Manifest("old", [part])
dest = root / "installed"
def no_download(_):
self.fail("an unchanged sysroot must not be downloaded")
linux_update._place(part, str(source), previous, str(dest), no_download, lambda _: None)
link = dest / linux_update.SYSROOT_PART / "usr" / "lib" / "x86_64-linux-gnu" / "libmvec.so"
self.assertFalse(os.path.isabs(os.readlink(link)))
self.assertEqual(link.read_bytes(), b"contents")
def test_a_rooted_sysroot_link_cannot_escape_or_be_dangling(self):
with tempfile.TemporaryDirectory(prefix="hookshot-sysroot-") as tmp:
root = Path(tmp)
outside = root / "outside"
outside.mkdir()
marker = outside / "marker"
marker.write_bytes(b"original")
for name, link_to, indirect in (("lexical", "/../outside/marker", False),
("indirect", "/lib/marker", True),
("missing", "/missing", False)):
with self.subTest(name=name):
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
if indirect:
zip_link(zipped, "lib", "../outside")
zip_link(zipped, "link", link_to)
with self.assertRaises(ValueError):
linux_update._unpack(archive.getvalue(), str(root / name), None, rebase_sysroot=True)
self.assertEqual(marker.read_bytes(), b"original")
self.assertFalse((root / name / "link").is_symlink())
def test_rooted_sysroot_links_resolve_chains_but_not_cycles(self):
with tempfile.TemporaryDirectory(prefix="hookshot-sysroot-") as tmp:
root = Path(tmp)
for name, third in (("chain", True), ("cycle", False)):
with self.subTest(name=name):
archive = io.BytesIO()
with zipfile.ZipFile(archive, "w") as zipped:
zip_link(zipped, "first", "/second")
zip_link(zipped, "second", "/third" if third else "/first")
if third:
zipped.writestr("third", b"contents")
dest = root / name
if third:
linux_update._unpack(archive.getvalue(), str(dest), None, rebase_sysroot=True)
self.assertEqual((dest / "first").read_bytes(), b"contents")
self.assertFalse(os.path.isabs(os.readlink(dest / "first")))
else:
with self.assertRaises(ValueError):
linux_update._unpack(archive.getvalue(), str(dest), None, rebase_sysroot=True)
def test_packaging_refuses_a_sysroot_link_outside_its_root(self):
with tempfile.TemporaryDirectory(prefix="hookshot-sysroot-") as tmp:
root = Path(tmp)
source = root / linux_update.SYSROOT_PART
source.mkdir(parents=True)
(source / "bad").symlink_to("/../outside")
with self.assertRaises(ValueError):
make_parts.write_zip(str(root / "part.zip"), str(root), linux_update.SYSROOT_PART, None)
@unittest.skipUnless(sys.platform.startswith("linux"), "the Linux sysroot copy loop")
def test_sysroot_system_aliases_round_trip_as_library_bytes(self):
script = (ROOT / "scripts" / "linux" / "appimage.sh").read_text(encoding="utf-8")
start = script.index("for f in crt1.o ")
loop = script[start:script.index("\ndone", start) + len("\ndone")]
with tempfile.TemporaryDirectory(prefix="hookshot-sysroot-") as tmp:
root = Path(tmp)
system = root / "system"
system.mkdir()
real = system / "libmvec.so.1"
real.write_bytes(b"private library bytes")
alias = system / "libmvec.so"
alias.symlink_to(real)
source = root / "sysroot"
(source / "usr" / "lib" / "x86_64-linux-gnu").mkdir(parents=True)
(source / "lib").symlink_to("usr/lib")
env = dict(os.environ, M=str(system), S=str(source))
subprocess.run(["bash", "-euo", "pipefail", "-c", loop], env=env, check=True)
copied = source / "usr" / "lib" / "x86_64-linux-gnu" / alias.name
self.assertFalse(copied.is_symlink(), "the sysroot must carry the alias's bytes, not an absolute target")
archive = root / "part.zip"
make_parts.write_zip(str(archive), str(root), "sysroot", None)
dest = root / "unpacked"
linux_update._unpack(archive.read_bytes(), str(dest), None)
self.assertEqual((dest / "lib" / "x86_64-linux-gnu" / alias.name).read_bytes(), real.read_bytes())
self.assertEqual(os.readlink(alias), str(real))
self.assertEqual(real.read_bytes(), b"private library bytes")
if __name__ == "__main__":
unittest.main()