Merge remote-tracking branch 'droiddeck/main' into maint/appimage-x64-wayland-runtime

This commit is contained in:
maxjivi05 committed 2026-11-14 18:22:26 -05:00
commit 0d6c18b300
562 files changed
+71029 -1963

No files matched your search

+317 -1
View File
@@ -198,6 +198,155 @@ class ConfigAndMenuTest(Temp):
self.assertEqual(path.stat().st_mtime_ns, mtime)
class DriveTest(Temp):
def setUp(self):
super().setUp()
self.root = str(self.tmp / "Steam")
self.devices = Path(BNET["dosdevices"](self.root))
self.card = self.tmp / "card"
self.library = self.card / "Games/Battle.net"
self.library.mkdir(parents=True)
self.running = []
patcher = mock.patch.dict(BNET, {"say": lambda message: None, "wine_processes": lambda pfx, proc="/proc": list(self.running),
"volume_root": lambda path: str(self.card) if BNET["inside"](path, str(self.card)) else "/"})
patcher.start()
self.addCleanup(patcher.stop)
def test_a_volume_ends_where_the_device_changes(self):
devices = {"/": 1, "/mnt": 1, "/mnt/card": 7, "/mnt/card/Games": 7, "/mnt/card/Games/Battle.net": 7, "/root": 1, "/root/Games": 1}
with mock.patch.object(os, "stat", lambda path: mock.Mock(st_dev=devices[path])):
volume_root = runpy.run_path(str(BIN / "droiddeck-battlenet"))["volume_root"]
self.assertEqual(volume_root("/mnt/card/Games/Battle.net"), "/mnt/card")
self.assertEqual(volume_root("/mnt/card"), "/mnt/card")
self.assertEqual(volume_root("/root/Games"), "/")
self.assertEqual(volume_root("/"), "/")
def test_a_library_on_the_root_volume_keeps_its_path_and_gets_no_drive(self):
library = self.tmp / "root/Games/Battle.net"
library.mkdir(parents=True)
self.assertEqual(BNET["install_path"](self.root, str(library) + "/"), "Z:" + str(library))
self.assertFalse(self.devices.exists())
def test_a_library_on_another_volume_gets_a_drive_at_the_volume_root(self):
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "D:\\Games\\Battle.net")
self.assertEqual(os.readlink(self.devices / "d:"), str(self.card))
self.assertEqual(BNET["install_path"](self.root, str(self.library / "World of Warcraft")), "D:\\Games\\Battle.net\\World of Warcraft")
self.assertEqual(BNET["install_path"](self.root, str(self.card)), "D:\\")
self.assertEqual(sorted(os.listdir(self.devices)), ["d:"])
def test_drives_in_use_and_the_ones_proton_owns_are_left_alone(self):
self.devices.mkdir(parents=True)
os.symlink("/somewhere/else", self.devices / "d:")
os.symlink(str(self.card), self.devices / "s:")
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "E:\\Games\\Battle.net")
self.assertEqual(os.readlink(self.devices / "d:"), "/somewhere/else")
for letter in BNET["DRIVES"]:
if not os.path.lexists(self.devices / (letter + ":")):
os.symlink("/somewhere/else", self.devices / (letter + ":"))
os.unlink(self.devices / "e:")
os.symlink("/somewhere/else", self.devices / "e:")
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "Z:" + str(self.library))
self.assertNotIn("s", BNET["DRIVES"])
self.assertNotIn("t", BNET["DRIVES"])
def test_a_running_prefix_gets_no_new_drive_but_uses_the_ones_it_started_with(self):
self.running = [(5, ["C:\\Program Files (x86)\\Battle.net\\Battle.net.exe"])]
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "Z:" + str(self.library))
self.assertFalse(self.devices.exists())
self.running = []
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "D:\\Games\\Battle.net")
self.running = [(5, ["C:\\Program Files (x86)\\Battle.net\\Battle.net.exe"])]
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "D:\\Games\\Battle.net")
def test_a_drive_mapped_inside_the_volume_is_reused(self):
self.devices.mkdir(parents=True)
os.symlink(str(self.card / "Games"), self.devices / "g:")
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "G:\\Battle.net")
self.assertEqual(sorted(os.listdir(self.devices)), ["g:"])
def test_the_config_stores_the_drive_path_once(self):
path = self.tmp / ("Steam/steamapps/compatdata/%s/pfx/drive_c/users/steamuser/AppData/Roaming/Battle.net/Battle.net.config"
% BNET["APP_ID"])
BNET["write_config"](self.root)
self.assertEqual(BNET["write_config"](self.root, str(self.library)), "library")
self.assertEqual(json.loads(path.read_text())["Client"]["Install"]["DefaultInstallPath"], "D:\\Games\\Battle.net")
self.assertIsNone(BNET["write_config"](self.root, str(self.library)))
def test_registered_paths_resolve_through_their_drive(self):
BNET["install_path"](self.root, str(self.library))
self.assertEqual(BNET["windows_path"](self.root, "D:/Games/Battle.net/World of Warcraft"),
str(self.library / "World of Warcraft"))
self.assertEqual(BNET["windows_path"](self.root, "Z:\\mnt\\card\\World of Warcraft"), "/mnt/card/World of Warcraft")
self.assertEqual(BNET["windows_path"](self.root, "C:/Program Files (x86)/World of Warcraft"),
os.path.join(BNET["drive_c"](self.root), "Program Files (x86)/World of Warcraft"))
self.assertIsNone(BNET["windows_path"](self.root, "E:/Games/X"))
self.assertIsNone(BNET["windows_path"](self.root, "D:/../etc"))
self.assertEqual(BNET["windows_path"](self.root, "D:\\"), str(self.library.parent.parent))
def field(self, number, value):
varint = BNET["encode_varint"]
return varint(number << 3 | 2) + varint(len(value)) + value
def product(self, uid, folder, filler=b""):
settings = self.field(1, folder.encode()) + self.field(2, b"us") + b"\x18\x02" + filler
return self.field(1, self.field(1, uid.encode()) + self.field(2, uid.encode()) + self.field(3, settings)
+ b"\x21" + bytes(8) + b"\x2d" + bytes(4))
def database(self, *products):
path = Path(BNET["drive_c"](self.root)) / "ProgramData/Battle.net/Agent/product.db"
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(b"".join(products) + self.field(7, b"tail"))
path.chmod(0o600)
return path
def test_games_registered_through_the_root_drive_move_to_their_volume_drive(self):
game = self.library / "World of Warcraft"
game.mkdir()
other = self.tmp / "root/Games/Other"
other.mkdir(parents=True)
client = self.product("battle.net", "C:/Program Files (x86)/Battle.net")
local = self.product("other", "Z:" + str(other))
gone = self.product("gone", "Z:" + str(self.card / "Missing"))
path = self.database(client, self.product("wow", "Z:" + str(game), bytes(200)), local, gone)
self.assertTrue(BNET["move_installs"](self.root))
self.assertEqual(path.read_bytes(), client + self.product("wow", "D:/Games/Battle.net/World of Warcraft", bytes(200))
+ local + gone + self.field(7, b"tail"))
self.assertEqual(path.stat().st_mode & 0o777, 0o600)
self.assertEqual(os.readlink(self.devices / "d:"), str(self.card))
self.assertFalse(BNET["move_installs"](self.root))
def test_registrations_stay_while_the_prefix_runs_or_the_database_is_unreadable(self):
game = self.library / "World of Warcraft"
game.mkdir()
path = self.database(self.product("wow", "Z:" + str(game)))
before = path.read_bytes()
self.running = [(5, ["C:\\ProgramData\\Battle.net\\Agent\\Agent.exe"])]
self.assertFalse(BNET["move_installs"](self.root))
self.assertEqual(path.read_bytes(), before)
self.running = []
for broken in (before[:-3], b"\x0a\xff", b"\x0b\x01"):
path.write_bytes(broken)
self.assertFalse(BNET["move_installs"](self.root))
self.assertEqual(path.read_bytes(), broken)
os.unlink(path)
self.assertFalse(BNET["move_installs"](self.root))
def test_a_database_written_while_it_was_being_read_is_left_as_written(self):
game = self.library / "World of Warcraft"
game.mkdir()
path = self.database(self.product("wow", "Z:" + str(game)))
newer = path.read_bytes() + self.field(7, b"newer")
def processes(pfx, proc="/proc"):
path.write_bytes(newer)
return []
with mock.patch.dict(BNET, {"wine_processes": processes}):
self.assertFalse(BNET["move_installs"](self.root))
self.assertEqual(path.read_bytes(), newer)
self.assertTrue(BNET["move_installs"](self.root))
class GamepadTest(Temp):
def registry(self, *entries):
rows = ["WINE REGISTRY Version 2"]
@@ -772,7 +921,7 @@ class Harness(Temp):
"stop": lambda processes, wait=0: self.calls.append(("stop", sorted(pid for pid, _ in processes))),
"start": lambda exe, verb=None: self.calls.append(("start", os.path.basename(exe), verb)) or self.Proton(),
"spawn": lambda program, verb, args=(): self.calls.append(("spawn", os.path.basename(program), verb, list(args))),
"acquire": lambda folder=None: self.lock,
"acquire": lambda folder=None: self.lock, "volume_root": lambda path: "/",
"POLL": 0, "READY_SETTLE": 0, "GAME_GRACE": 0, "CLIENT_WAIT": 0,
})
patcher.start()
@@ -1170,6 +1319,7 @@ class AgentTest(Temp):
script = BNET["AGENT_SCRIPT"]
self.assertIn("port = a(0), action = a(1), uid = a(2), product = a(3), dir = a(4)", script)
self.assertIn("lang = a(5), country = a(6), region = a(7), out = a(8)", script)
self.assertIn(r'''"game_dir":"' + dir.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '","geo''', script)
self.assertIn('"--internalclienttools"', (BIN / "droiddeck-battlenet").read_text())
def test_the_driver_asks_blizzards_chinese_repository_for_chinese_installs(self):
@@ -1230,6 +1380,40 @@ class AgentJobTest(Harness):
self.assertEqual([kind for kind, _ in self.lines], ["STATE", "PROGRESS", "DONE"])
self.assertEqual(json.loads(self.lines[-1][1]), {"install_dir": "Z:" + folder, "exe": "WarcraftRumble.exe", "version": "16.1.2.119725"})
def test_an_install_on_another_volume_is_handed_over_by_its_drive_once_the_prefix_is_stopped(self):
self.install()
card = self.tmp / "card"
folder = str(card / "Games/Battle.net/Warcraft Rumble")
self.files = {".json": json.dumps({"progress": 1.0, "download_complete": True, "state": 1004}),
".game": json.dumps({"installed": True, "install_dir": "D:/Games/Battle.net/Warcraft Rumble", "local_version": "1",
"binaries": {"game": {"relative_path": "WarcraftRumble.exe"}}})}
self.states = [[(7, self.AGENT)]]
events = []
real_map = BNET["map_drive"]
def acquire(folder=None):
events.append("lock")
return self.lock
def stop(pfx):
events.append(("stop", not self.lock.closed))
self.states = [[]]
return True
def map_drive(root, volume):
events.append(("map", not self.lock.closed))
return real_map(root, volume)
with mock.patch.dict(BNET, {"volume_root": lambda path: str(card), "stop_leftovers": stop, "map_drive": map_drive,
"acquire": acquire}):
code = BNET["agent_job"](self.root, "install", "gryphon", "gryphon", folder, "enUS", "USA", "US", poll=0)
self.assertEqual(code, 0)
self.assertEqual(events, ["lock", ("stop", True), ("map", True)])
self.assertTrue(self.lock.closed)
cmd = self.started[0]
self.assertEqual(cmd[cmd.index("--") + 6], "D:\\Games\\Battle.net\\Warcraft Rumble")
self.assertEqual(os.readlink(os.path.join(BNET["dosdevices"](self.root), "d:")), str(card))
def test_an_agent_error_is_reported_with_its_code(self):
self.install()
self.files = {".json": json.dumps({"error": 2421, "progress": 0.0})}
@@ -1257,6 +1441,138 @@ class AgentJobTest(Harness):
self.assertEqual(BNET["agent_job"](self.root, "update", "gryphon", poll=0), 1)
self.assertEqual(self.lines[-1][0], "ERROR")
def test_a_job_that_stops_moving_is_ended_as_stalled_and_its_agent_stopped(self):
self.install()
self.files = {".json": json.dumps({"state": 1003, "paused": True, "download_current": [10, 0, 0], "download_total": [99, 0, 0]})}
killed = []
stopped = []
class Hung:
returncode = None
def __init__(self, cmd, **kwargs):
base = cmd[-1][2:].replace("\\", "/")
with open(base + ".json", "wb") as f:
f.write(self_files[".json"].encode("utf-16"))
def poll(self):
return None
def kill(self):
killed.append(True)
def wait(self):
return -9
self_files = self.files
with mock.patch.object(BNET["subprocess"], "Popen", Hung), \
mock.patch.dict(BNET, {"wine_processes": lambda pfx: [(5, ["agent.exe"])], "stop": lambda p: stopped.append(p)}):
code = BNET["agent_job"](self.root, "install", "s1", "s1", str(self.tmp / "S1"), "enUS", "USA", "US", poll=0, stall=0.05)
self.assertEqual(code, 6)
self.assertEqual(killed, [True])
self.assertEqual(stopped, [[(5, ["agent.exe"])]])
self.assertEqual(self.lines[-1], ("ERROR", "stalled"))
def test_a_stalled_job_leaves_a_game_or_client_in_the_prefix_running(self):
self.install()
self.files = {".json": json.dumps({"state": 1003, "download_current": [10, 0, 0], "download_total": [99, 0, 0]})}
stopped = []
calls = []
class Hung:
returncode = None
def __init__(self, cmd, **kwargs):
calls.append(True)
def poll(self):
return None
def kill(self):
pass
def wait(self):
return -9
def processes(pfx):
if not calls:
return [(3, ["agent.exe"])]
return [(3, ["agent.exe"]), (5, ["Agent.exe"]), (6, ["wineserver"]), (7, ["Wow.exe"])]
with mock.patch.object(BNET["subprocess"], "Popen", Hung), \
mock.patch.dict(BNET, {"wine_processes": processes, "stop": lambda p: stopped.append(p)}):
code = BNET["agent_job"](self.root, "install", "s1", "s1", str(self.tmp / "S1"), "enUS", "USA", "US", poll=0, stall=0.05)
self.assertEqual(code, 6)
self.assertEqual(stopped, [[(5, ["Agent.exe"])]])
def test_only_a_changing_rate_or_estimate_does_not_hold_off_the_stall(self):
self.install()
clock = [0.0]
class Spinning:
returncode = None
def __init__(self, cmd, **kwargs):
self.base = cmd[-1][2:].replace("\\", "/")
self.polls = 0
def poll(self):
self.polls += 1
if self.polls > 10:
raise AssertionError("the stall timeout never ended the job")
clock[0] += 10
with open(self.base + ".json", "wb") as f:
f.write(json.dumps({"state": 1003, "download_current": [4, 0, 0], "download_total": [9, 0, 0],
"download_rate": self.polls, "estimated_time_in_sec": self.polls}).encode("utf-16"))
return None
def kill(self):
pass
def wait(self):
return -9
fake = mock.Mock(monotonic=lambda: clock[0], sleep=lambda s: None)
with mock.patch.object(BNET["subprocess"], "Popen", Spinning), mock.patch.dict(BNET, {"time": fake, "stop": lambda p: None}):
code = BNET["agent_job"](self.root, "update", "gryphon", poll=0, stall=25)
self.assertEqual(code, 6)
self.assertEqual(self.lines[-1], ("ERROR", "stalled"))
def test_a_moving_job_is_not_ended_as_stalled(self):
self.install()
done = json.dumps({"installed": True, "playable": True, "install_dir": "Z:/g", "local_version": "2"})
clock = [0.0]
class Moving:
returncode = 0
def __init__(self, cmd, **kwargs):
self.base = cmd[-1][2:].replace("\\", "/")
self.polls = 0
def poll(self):
self.polls += 1
clock[0] += 10
with open(self.base + ".json", "wb") as f:
f.write(json.dumps({"state": 1003, "download_current": [self.polls, 0, 0], "download_total": [9, 0, 0]}).encode("utf-16"))
if self.polls < 6:
return None
with open(self.base + ".game", "wb") as f:
f.write(done.encode("utf-16"))
return 0
fake = mock.Mock(monotonic=lambda: clock[0], sleep=lambda s: None)
with mock.patch.object(BNET["subprocess"], "Popen", Moving), mock.patch.dict(BNET, {"time": fake}):
code = BNET["agent_job"](self.root, "update", "gryphon", poll=0, stall=15)
self.assertEqual(code, 0)
self.assertNotIn(("ERROR", "stalled"), self.lines)
def test_only_a_real_job_reply_counts_as_started(self):
script = BNET["AGENT_SCRIPT"]
self.assertIn("if (state == 1000 || state == 1003 || job(s) && !complete) started = true;", script)
self.assertIn('return /"state"\\s*:\\s*\\d+/.test(bare) || /"download_current"\\s*:/.test(bare);', script)
self.assertIn('if (/"error"\\s*:\\s*[1-9]/.test(text)) return false;', script)
def test_the_driver_only_stops_once_the_agent_has_really_run(self):
script = BNET["AGENT_SCRIPT"]
self.assertIn("if (started && (state == 1004 || complete && /\"playable\"\\s*:\\s*true/.test(s))) break;", script)
+30 -3
View File
@@ -22,22 +22,29 @@ extern char **environ;
int main(int argc, char **argv) {
if (argc < 3) return 2;
const char *how = argv[1], *file = argv[2];
char *node_env[] = {"ELECTRON_RUN_AS_NODE=1", NULL};
char *const *child_env = !strcmp(how, "execve-node") || !strcmp(how, "execvpe-node") ||
!strcmp(how, "spawn-node") || !strcmp(how, "spawnp-node") ? node_env : environ;
char **args = argv + 2;
if (!strcmp(how, "access")) {
int result = access(file, X_OK);
printf("access %d %d\n", result, result ? errno : 0);
return 0;
}
if (!strcmp(how, "spawn") || !strcmp(how, "spawnp")) {
if (!strcmp(how, "spawn") || !strcmp(how, "spawnp") || !strcmp(how, "spawn-node") ||
!strcmp(how, "spawnp-node")) {
pid_t pid;
int error = how[5] ? posix_spawnp(&pid, file, NULL, NULL, args, environ) : posix_spawn(&pid, file, NULL, NULL, args, environ);
int spawnp = !strcmp(how, "spawnp") || !strcmp(how, "spawnp-node");
int error = spawnp ? posix_spawnp(&pid, file, NULL, NULL, args, child_env)
: posix_spawn(&pid, file, NULL, NULL, args, child_env);
if (error) { printf("errno %d\n", error); return 3; }
int status;
waitpid(pid, &status, 0);
printf("exit %d\n", WEXITSTATUS(status));
return 0;
}
if (!strcmp(how, "execve")) execve(file, args, environ);
if (!strcmp(how, "execve") || !strcmp(how, "execve-node")) execve(file, args, (char *const *)child_env);
else if (!strcmp(how, "execvpe-node")) execvpe(file, args, (char *const *)child_env);
else if (!strcmp(how, "execv")) execv(file, args);
else if (!strcmp(how, "execvp")) execvp(file, args);
else if (!strcmp(how, "execvpe")) execvpe(file, args, environ);
@@ -88,6 +95,15 @@ class BinfmtPreloadTest(unittest.TestCase):
path.chmod(mode)
return path
def chromium_script(self):
folder = self.dir / "vscode"
folder.mkdir()
executable = folder / "code"
executable.write_text("#!/bin/sh\nprintf '%s\\n' \"$@\"\n")
executable.chmod(0o755)
(folder / "chrome-sandbox").touch()
return executable
def environment(self, desktop=True, **extra):
env = {"PATH": "%s:/usr/bin:/bin" % self.dir, "LD_PRELOAD": str(self.library), "HANDLER_LOG": str(self.log)}
if desktop:
@@ -161,6 +177,17 @@ class BinfmtPreloadTest(unittest.TestCase):
self.file("script.sh", b"#!/bin/sh\nexit 5\n")
self.assertEqual(self.run_program("spawnp", "script.sh"), (0, "exit 5", None))
def test_explicit_node_child_environment_skips_injection_for_execve_and_spawn(self):
code = self.chromium_script()
self.assertEqual(self.run_program("execve-node", code, "--version"), (0, "--version", None))
self.assertEqual(self.run_program("execvpe-node", code, "--version"), (0, "--version", None))
self.assertEqual(self.run_program("spawn-node", code, "--version"), (0, "--version\nexit 0", None))
self.assertEqual(self.run_program("spawnp-node", code, "--version"), (0, "--version\nexit 0", None))
def test_chromium_gui_launch_without_node_mode_still_receives_no_sandbox(self):
code = self.chromium_script()
self.assertEqual(self.run_program("execve", code, "--version"), (0, "--no-sandbox\n--version", None))
def test_the_hand_off_switch_works_without_the_desktop(self):
tool = self.x86()
for how in ("execve", "execvp"):
+23 -2
View File
@@ -58,11 +58,17 @@ class CiChecksTest(unittest.TestCase):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
sudo = root / 'sudo'
sudo.write_text('#!/bin/bash\nprintf "%s\\n" "$*" >> "$APT_LOG"\nexit "${APT_RESULT:-0}"\n')
sudo.write_text('#!/bin/bash\nprintf "%s\\n" "$*" >> "$APT_LOG"\n'
'for arg; do case "$arg" in Dir::Etc::sourcelist=*) '
'grep -h "^URIs:" "${arg#*=}" >> "$APT_LOG.mirrors";; esac; done\n'
'exit "${APT_RESULT:-0}"\n')
sudo.chmod(0o755)
query = root / 'dpkg-query'
query.write_text('#!/bin/sh\nexit 1\n')
query.chmod(0o755)
dpkg = root / 'dpkg'
dpkg.write_text('#!/bin/sh\necho "${DPKG_ARCH:-amd64}"\n')
dpkg.chmod(0o755)
log = root / 'apt.log'
sources = root / 'ubuntu.sources'
sources.write_text('URIs: http://mirror.invalid/ubuntu\n')
@@ -71,8 +77,23 @@ class CiChecksTest(unittest.TestCase):
installer = ROOT / 'tools/ci/install-ubuntu-packages.sh'
result = subprocess.run(['bash', str(installer), 'qemu-user'], env=dict(env, APT_RESULT='17'))
self.assertEqual(result.returncode, 17)
self.assertEqual(len(log.read_text().splitlines()), 2)
self.assertEqual(len(log.read_text().splitlines()), 3)
mirrors = Path(str(log) + '.mirrors')
self.assertEqual(mirrors.read_text().splitlines(), [
'URIs: http://mirror.invalid/ubuntu',
'URIs: https://archive.ubuntu.com/ubuntu',
'URIs: https://mirrors.edge.kernel.org/ubuntu',
])
log.unlink()
mirrors.unlink()
result = subprocess.run(['bash', str(installer), 'qemu-user'], env=dict(env, APT_RESULT='17', DPKG_ARCH='arm64'))
self.assertEqual(result.returncode, 17)
self.assertEqual(mirrors.read_text().splitlines()[1:], [
'URIs: https://ports.ubuntu.com/ubuntu-ports',
'URIs: https://mirrors.ocf.berkeley.edu/ubuntu-ports',
])
log.unlink()
mirrors.unlink()
subprocess.run(['bash', str(installer), 'qemu-user'], env=env, check=True)
update, install = log.read_text().splitlines()
for command in (update, install):
+1
View File
@@ -121,6 +121,7 @@ step() { :; }
bl_zram_scan() { :; }
bl_memory_read() { :; }
bl_client_pressure() { :; }
bl_client_pressure_finish() { :; }
bl_session_pressure() { :; }
bl_client_can_pageout() { return 0; }
bl_client_can_readback() { [ "${readback:-1}" = 1 ]; }
+141 -2
View File
@@ -1,19 +1,34 @@
import os
from pathlib import Path
import queue
import re
import shlex
import shutil
import struct
import subprocess
import tempfile
import threading
import unittest
PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
def clock_reset_command(control):
script = (PRELOAD.parent / "overlay/usr/local/bin/droiddeck-session").read_text()
start = script.index('if [ -z "${BL_INSIDE:-}" ]; then\n if [ "${BL_ZRAM:-0}"')
end = script.index("\nfi", start) + len("\nfi")
paths = {"/tmp/.bl-clock": shlex.quote(str(control)),
"/tmp/.bl-zram": shlex.quote(str(control.parent / "zram"))}
pattern = "|".join(re.escape(token) for token in paths)
return 'BL_INSIDE=; BL_ZRAM=0; ' + re.sub(pattern, lambda match: paths[match.group(0)], script[start:end])
PROGRAM = r"""
#define _GNU_SOURCE
#include <linux/futex.h>
#include <pthread.h>
#include <semaphore.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/syscall.h>
#include <sys/timerfd.h>
@@ -36,12 +51,26 @@ static int64_t start;
static void begin(void) { start = ns(CLOCK_BOOTTIME); }
static void end(const char *name) { printf("%s %lld\n", name, (long long)((ns(CLOCK_BOOTTIME) - start) / 1000000LL)); }
static unsigned long long memory_probe(void) {
static volatile unsigned char memory[4 * 1024 * 1024];
unsigned long long checksum = 0;
for (size_t i = 0; i < sizeof(memory); i += 4096) memory[i] = (unsigned char)(i / 4096 + 1);
for (size_t i = 0; i < sizeof(memory); i += 4096) checksum += memory[i];
return checksum;
}
int main(void) {
const int64_t wait = 60000000LL;
printf("gap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ns(CLOCK_MONOTONIC)) / 1000000LL));
struct timespec raw;
syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &raw);
printf("rawgap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ((int64_t)raw.tv_sec * 1000000000LL + raw.tv_nsec)) / 1000000LL));
printf("memory %llu\n", memory_probe());
if (getenv("CLOCK_PAUSE_WAIT")) { puts("ready"); fflush(stdout); getchar(); }
if (getenv("CLOCK_PAUSE_WAIT")) {
printf("livegap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ns(CLOCK_MONOTONIC)) / 1000000LL));
printf("livememory %llu\n", memory_probe());
}
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_condattr_t attr;
@@ -124,14 +153,124 @@ class ClockPausePreloadTest(unittest.TestCase):
self.assertGreaterEqual(paused[name], 50, name)
self.assertLess(paused[name], 1000, name)
def test_other_programs_keep_the_real_clock(self):
def test_program_without_preload_keeps_the_real_clock(self):
plain = self.run_program(self.other, 0, preload=False)
paused = self.run_program(self.other, SHIFT_MS)
paused = self.run_program(self.other, SHIFT_MS, preload=False)
self.assertAlmostEqual(paused["gap"], plain["gap"], delta=50)
for name in ("cond_mono", "clockwait", "sem", "nanosleep", "timerfd", "futex"):
self.assertGreaterEqual(paused[name], 50, name)
self.assertLess(paused[name], 1000, name)
def test_every_session_program_stops_monotonic_clock_and_keeps_memory_access(self):
plain = self.run_program(self.other, 0)
paused = self.run_program(self.other, SHIFT_MS)
self.assertAlmostEqual(paused["gap"] - plain["gap"], SHIFT_MS, delta=50)
self.assertAlmostEqual(paused["rawgap"] - plain["rawgap"], SHIFT_MS, delta=50)
self.assertEqual(plain["memory"], 130560)
self.assertEqual(paused["memory"], 130560)
def test_running_session_program_observes_pause_offset_update(self):
self.check_running_offset_update(False)
def test_session_reset_preserves_live_guest_mapping(self):
self.check_running_offset_update(True)
def check_running_offset_update(self, reset):
self.control.write_bytes(struct.pack("<q", 0))
env = dict(os.environ)
env["LD_PRELOAD"] = str(self.preload)
env["CLOCK_PAUSE_WAIT"] = "1"
with tempfile.TemporaryFile(mode="w+") as errors:
process = subprocess.Popen([str(self.other)], env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=errors, text=True)
lines = queue.Queue()
def read_handshake():
for _ in range(4):
line = process.stdout.readline()
lines.put(line)
if not line:
break
threading.Thread(target=read_handshake, daemon=True).start()
try:
handshake = []
for _ in range(4):
try:
line = lines.get(timeout=5)
except queue.Empty:
line = ""
if not line:
if process.poll() is None:
process.kill()
process.wait(timeout=5)
errors.seek(0)
self.fail(f"child handshake timed out or ended early (exit {process.returncode}): {errors.read()}")
handshake.append(line.strip())
self.assertEqual(handshake[3], "ready")
self.assertTrue(handshake[0].startswith("gap "))
initial_gap = int(handshake[0].split()[1])
rawgap = handshake[1]
memory = handshake[2]
self.assertTrue(rawgap.startswith("rawgap "))
self.assertEqual(memory, "memory 130560")
if reset:
inode = self.control.stat().st_ino
subprocess.run(["bash", "-c", clock_reset_command(self.control)],
check=True, timeout=5)
self.assertEqual(self.control.stat().st_ino, inode)
self.assertEqual(self.control.read_bytes(), struct.pack("<q", 0))
with self.control.open("r+b") as control:
control.write(struct.pack("<q", SHIFT_MS * 1000000))
control.flush()
process.stdin.write("\n")
process.stdin.flush()
output, _ = process.communicate(timeout=5)
errors.seek(0)
self.assertEqual(process.returncode, 0, errors.read())
values = dict(line.split() for line in output.splitlines())
self.assertAlmostEqual(int(values["livegap"]) - initial_gap, SHIFT_MS, delta=50)
self.assertEqual(int(values["livememory"]), 130560)
finally:
if process.poll() is None:
process.kill()
process.communicate()
class ClockResetCommandTest(unittest.TestCase):
def test_reset_keeps_paths_with_spaces_and_shell_syntax_as_single_arguments(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
folder = root / "session dir; touch injected $(touch substituted) 'quoted'"
folder.mkdir()
control = folder / "clock"
control.write_bytes(struct.pack("<q", 10_000_000_000) + b"tail")
(folder / "zram").write_text("1")
bystander = root / "session"
bystander.write_text("keep")
inode = control.stat().st_ino
subprocess.run(["bash", "-c", clock_reset_command(control)], cwd=root, check=True, timeout=5)
self.assertEqual(control.stat().st_ino, inode)
self.assertEqual(control.read_bytes(), struct.pack("<q", 0) + b"tail")
self.assertFalse((folder / "zram").exists())
self.assertEqual(bystander.read_text(), "keep")
self.assertEqual(sorted(path.name for path in root.iterdir()), sorted([folder.name, bystander.name]))
def test_reset_does_not_rewrite_placeholders_inside_substituted_paths(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
folder = root / "tmp/.bl-zram/$(touch injected)"
folder.mkdir(parents=True)
control = folder / "clock"
control.write_bytes(struct.pack("<q", 10_000_000_000))
(folder / "zram").write_text("1")
inode = control.stat().st_ino
subprocess.run(["bash", "-c", clock_reset_command(control)], cwd=root, check=True, timeout=5)
self.assertEqual(control.stat().st_ino, inode)
self.assertEqual(control.read_bytes(), struct.pack("<q", 0))
self.assertFalse((folder / "zram").exists())
self.assertEqual([path.name for path in root.iterdir()], ["tmp"])
if __name__ == "__main__":
unittest.main()
+69
View File
@@ -0,0 +1,69 @@
import json
import os
from pathlib import Path
import subprocess
import tempfile
import time
import unittest
SCRIPT = Path(__file__).resolve().parents[1] / 'agent/dd-lab-build'
class LabBuildPackageTest(unittest.TestCase):
def test_package_override_survives_app_handoff_without_its_environment(self):
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
inbox = root / 'agent'
inbox.mkdir()
cache = root / '.cache'
env = {**os.environ, 'HOME': tmp, 'DD_AGENT': '1',
'DD_AGENT_INBOX': str(inbox), 'DROIDDECK_PACKAGE': 'com.example.target'}
env.pop('DD_LAB_DETACHED', None)
child = subprocess.Popen(['bash', str(SCRIPT), '--prepare'], env=env,
stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
try:
request = inbox / 'lab-request'
deadline = time.monotonic() + 10
while not request.exists() and child.poll() is None and time.monotonic() < deadline:
time.sleep(0.01)
self.assertTrue(request.exists())
payload = json.loads(request.read_text())
self.assertEqual(['--prepare', '--package=com.example.target'], payload['args'])
progress = cache / 'dd-lab-build.json'
progress.write_text('{"stage":"prepared"}')
stdout, stderr = child.communicate(timeout=10)
self.assertEqual(0, child.returncode, stdout + stderr)
finally:
if child.poll() is None:
child.kill()
child.communicate()
bin_dir = root / 'bin'
bin_dir.mkdir()
(bin_dir / 'adb').write_text('#!/bin/sh\nexit 0\n')
(bin_dir / 'python3').write_text(
'#!/bin/sh\nprintf "%s" "$DROIDDECK_PACKAGE" > "$HOME/selected-package"\nexit 1\n')
for tool in bin_dir.iterdir():
tool.chmod(0o755)
env.pop('DROIDDECK_PACKAGE')
env['DD_LAB_DETACHED'] = '1'
env['PATH'] = str(bin_dir) + os.pathsep + env['PATH']
result = subprocess.run(['bash', str(SCRIPT), *payload['args']], env=env,
capture_output=True, text=True, timeout=10, cwd=SCRIPT.parents[2])
self.assertNotEqual(0, result.returncode)
self.assertIn('could not read DroidDeck', result.stderr)
self.assertEqual('com.example.target', (root / 'selected-package').read_text())
def test_invalid_packages_are_rejected_before_handoff(self):
with tempfile.TemporaryDirectory() as tmp:
inbox = Path(tmp) / 'agent'
inbox.mkdir()
for package in ('bad;touch injected', '../other', '', 'com.example/other'):
with self.subTest(package=package):
env = {**os.environ, 'HOME': tmp, 'DD_AGENT': '1', 'DD_AGENT_INBOX': str(inbox)}
result = subprocess.run(['bash', str(SCRIPT), '--package=' + package], env=env,
capture_output=True, text=True, timeout=10)
self.assertNotEqual(0, result.returncode)
self.assertIn('invalid Android package', result.stderr)
self.assertFalse((inbox / 'lab-request').exists())
+245
View File
@@ -0,0 +1,245 @@
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
FAKE = r"""
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
static int answer(int fd) {
char link[32], path[4096];
snprintf(link, sizeof(link), "/proc/self/fd/%d", fd);
long n = syscall(SYS_readlinkat, AT_FDCWD, link, path, sizeof(path) - 1);
path[n > 0 ? n : 0] = '\0';
if (strstr(path, "/card/")) return ENOTSUP;
if (strstr(path, "/denied/")) return EACCES;
return ENODATA;
}
ssize_t fgetxattr(int fd, const char *name, void *value, size_t size) {
(void)name; (void)value; (void)size;
errno = answer(fd);
return -1;
}
int fsetxattr(int fd, const char *name, const void *value, size_t size, int flags) {
(void)name; (void)value; (void)size; (void)flags;
int error = answer(fd);
if (error == ENODATA) return 0;
errno = error;
return -1;
}
int fremovexattr(int fd, const char *name) {
(void)name;
errno = answer(fd);
return -1;
}
"""
PROGRAM = r"""
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/xattr.h>
#include <unistd.h>
static const char *error(void) {
return errno == ENOTSUP ? "unsupported" : errno == ENODATA ? "none" : errno == ERANGE ? "range" :
errno == EACCES ? "denied" : "other";
}
int main(int argc, char **argv) {
for (int i = 1; i < argc; i++) {
const char *op = argv[i];
if (!strcmp(op, "unlink") || !strcmp(op, "rmdir")) {
const char *path = argv[++i];
printf("%s\n", (op[0] == 'u' ? unlink(path) : rmdir(path)) == 0 ? "ok" : "failed");
continue;
}
if (!strcmp(op, "remove-path")) {
printf("%s\n", remove(argv[++i]) == 0 ? "ok" : "failed");
continue;
}
if (!strcmp(op, "rename")) {
const char *from = argv[++i], *to = argv[++i];
printf("%s\n", rename(from, to) == 0 ? "ok" : "failed");
continue;
}
int fd = open(argv[++i], O_RDONLY);
char value[64];
if (!strcmp(op, "set")) {
const char *text = argv[++i];
errno = 1234;
int result = fsetxattr(fd, "user.wine.sd", text, strlen(text), 0);
printf("%s\n", result == 0 ? errno == 1234 ? "ok" : "errno" : error());
} else if (!strcmp(op, "get")) {
ssize_t n = fgetxattr(fd, "user.wine.sd", value, sizeof(value));
if (n < 0) printf("%s\n", error());
else printf("=%.*s\n", (int)n, value);
} else if (!strcmp(op, "size")) {
ssize_t n = fgetxattr(fd, "user.wine.sd", NULL, 0);
if (n < 0) printf("%s\n", error());
else printf("%d\n", (int)n);
} else if (!strcmp(op, "short")) {
ssize_t n = fgetxattr(fd, "user.wine.sd", value, 2);
printf("%s\n", n < 0 ? error() : "read");
} else if (!strcmp(op, "remove")) {
errno = 1234;
int result = fremovexattr(fd, "user.wine.sd");
printf("%s\n", result == 0 ? errno == 1234 ? "ok" : "errno" : error());
} else if (!strcmp(op, "other")) {
ssize_t n = fgetxattr(fd, "user.other", value, sizeof(value));
printf("%s\n", n < 0 ? error() : "read");
}
close(fd);
}
return 0;
}
"""
@unittest.skipUnless(shutil.which("cc"), "needs a C compiler")
class DescriptorPreloadTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.build_dir = tempfile.TemporaryDirectory()
build = Path(cls.build_dir.name)
(build / "fake.c").write_text(FAKE)
(build / "program.c").write_text(PROGRAM)
cls.preload = build / "libblsession.so"
cls.fake = build / "fake.so"
subprocess.run(["cc", "-shared", "-fPIC", "-O2", "-Wall", "-pthread", "-o", str(cls.preload),
*map(str, sorted(PRELOAD.glob("*.c"))), "-ldl"], check=True)
subprocess.run(["cc", "-shared", "-fPIC", "-O2", "-o", str(cls.fake), str(build / "fake.c")], check=True)
cls.wineserver = build / "wineserver"
subprocess.run(["cc", "-O2", "-o", str(cls.wineserver), str(build / "program.c")], check=True)
cls.other = build / "wine64-preloader"
shutil.copy(cls.wineserver, cls.other)
@classmethod
def tearDownClass(cls):
cls.build_dir.cleanup()
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.dir = Path(os.path.realpath(self.temp.name))
self.prefix = self.dir / "prefix"
self.prefix.mkdir()
self.store = self.prefix / ".droiddeck-descriptors"
for kind in ("card", "disk", "denied"):
(self.dir / kind / "game").mkdir(parents=True)
(self.dir / kind / "game" / "file").write_text("x")
def tearDown(self):
self.temp.cleanup()
def path(self, *parts):
return str(self.dir.joinpath(*parts))
def run_as(self, program, *args, prefix=True):
env = dict(os.environ, LD_PRELOAD="%s:%s" % (self.preload, self.fake))
env.pop("WINEPREFIX", None)
if prefix:
env["WINEPREFIX"] = str(self.prefix)
result = subprocess.run([str(program), *args], env=env, capture_output=True, text=True, check=True)
return result.stdout.split()
def server(self, *args, **kwargs):
return self.run_as(self.wineserver, *args, **kwargs)
def test_a_descriptor_is_kept_where_the_volume_cannot_store_it(self):
file, folder = self.path("card", "game", "file"), self.path("card", "game")
self.assertEqual(["none", "ok", "ok"], self.server("get", file, "set", file, "one", "set", folder, "two"))
self.assertEqual(["=one", "3", "=two"], self.server("get", file, "size", file, "get", folder))
def test_a_descriptor_is_replaced_and_removed(self):
file = self.path("card", "game", "file")
self.assertEqual(["ok", "ok", "=longer"], self.server("set", file, "one", "set", file, "longer", "get", file))
self.assertEqual(["range", "ok", "none", "none"], self.server("short", file, "remove", file, "get", file, "remove", file))
def test_a_volume_that_stores_descriptors_is_left_alone(self):
file = self.path("disk", "game", "file")
self.assertEqual(["ok", "none", "none"], self.server("set", file, "one", "get", file, "remove", file))
self.assertFalse(self.store.exists())
def test_other_failures_keep_their_error(self):
file = self.path("denied", "game", "file")
self.assertEqual(["denied", "denied", "denied"], self.server("set", file, "one", "get", file, "remove", file))
self.assertFalse(self.store.exists())
def test_other_programs_and_other_attributes_are_unchanged(self):
file = self.path("card", "game", "file")
self.assertEqual(["unsupported", "unsupported", "unsupported"],
self.run_as(self.other, "set", file, "one", "get", file, "remove", file))
self.assertEqual(["ok", "unsupported"], self.server("set", file, "one", "other", file))
self.assertEqual(["unsupported"], self.run_as(self.other, "get", file))
def test_nothing_is_kept_without_a_prefix(self):
file = self.path("card", "game", "file")
self.assertEqual(["unsupported", "unsupported", "unsupported"],
self.server("set", file, "one", "get", file, "remove", file, prefix=False))
def test_a_deleted_file_loses_its_descriptor(self):
file, folder = self.path("card", "game", "file"), self.path("card", "game")
self.assertEqual(["ok", "ok", "ok"], self.server("set", file, "one", "set", folder, "two", "unlink", file))
Path(file).write_text("x")
self.assertEqual(["none", "ok", "ok"], self.server("get", file, "unlink", file, "rmdir", folder))
Path(folder).mkdir()
self.assertEqual(["none"], self.server("get", folder))
def test_a_removed_file_or_folder_loses_its_descriptor(self):
file, folder = self.path("card", "game", "file"), self.path("card", "game")
self.assertEqual(["ok", "ok", "ok", "ok"],
self.server("set", file, "one", "set", folder, "two", "remove-path", file, "remove-path", folder))
Path(folder).mkdir()
Path(file).write_text("x")
self.assertEqual(["none", "none"], self.server("get", folder, "get", file))
def test_a_file_deleted_through_a_link_loses_its_descriptor(self):
file = self.path("card", "game", "file")
os.symlink(self.path("card"), self.path("drive"))
self.assertEqual(["ok", "ok"], self.server("set", file, "one", "unlink", self.path("drive", "game", "file")))
Path(file).write_text("x")
self.assertEqual(["none"], self.server("get", file))
def test_a_descriptor_follows_a_rename(self):
file, moved = self.path("card", "game", "file"), self.path("card", "game", "moved")
self.assertEqual(["ok", "ok", "=one"], self.server("set", file, "one", "rename", file, moved, "get", moved))
Path(file).write_text("x")
self.assertEqual(["none", "ok", "none"], self.server("get", file, "rename", file, moved, "get", moved))
def test_descriptors_follow_a_renamed_folder(self):
file, folder, moved = self.path("card", "game", "file"), self.path("card", "game"), self.path("card", "moved")
self.assertEqual(["ok", "ok", "ok"], self.server("set", file, "one", "set", folder, "two", "rename", folder, moved))
self.assertEqual(["=two", "=one"], self.server("get", moved, "get", self.path("card", "moved", "file")))
Path(folder).mkdir()
(Path(folder) / "file").write_text("x")
self.assertEqual(["none", "none"], self.server("get", folder, "get", file))
def test_deletes_outside_the_store_cost_nothing_before_it_exists(self):
file = self.path("disk", "game", "file")
self.assertEqual(["ok"], self.server("unlink", file))
self.assertFalse(self.store.exists())
def test_a_name_too_long_to_keep_reports_no_support(self):
long_file = self.path("card", "game", "n" * 254)
Path(long_file).write_text("x")
self.assertEqual(["unsupported", "unsupported"], self.server("set", long_file, "one", "get", long_file))
if __name__ == "__main__":
unittest.main()
+38
View File
@@ -136,6 +136,30 @@ class CommandTest(Temp):
self.assertEqual(OPEN["command"](script, [], "x86 script")[0],
[OPEN["FEX"], "run", "--mode", "on", "--for", str(self.tmp), "--", "/bin/sh", script])
def test_a_store_games_exe_runs_through_its_launcher(self):
exe, launcher = str(self.tmp / "game.exe"), str(self.tmp / "launch.bat")
with mock.patch.dict(OPEN, {"store_launcher": lambda path: launcher if path == exe else None,
"exe_prefix": lambda path: ["--prefix", "4242", "--compatdata", "/c/4242"]}):
keep = ["--prefix", "4242", "--compatdata", "/c/4242"]
self.assertEqual(OPEN["command"](exe, [], "windows")[0], [OPEN["PROTON_RUN"]] + keep + [launcher])
self.assertEqual(OPEN["command"](exe, [], "windows", True)[0],
[OPEN["PROTON_RUN"], "--window"] + keep + [launcher])
self.assertEqual(OPEN["command"](exe, ["-x"], "windows")[0], [OPEN["PROTON_RUN"], exe, "-x"])
other = str(self.tmp / "other.exe")
self.assertEqual(OPEN["command"](other, [], "windows")[0], [OPEN["PROTON_RUN"], other])
def test_a_store_games_launcher_keeps_the_exes_prefix(self):
exe = self.tmp / "game.exe"
exe.write_text("x")
root = str(self.tmp / "steam")
with mock.patch.dict(os.environ, {"STEAM_COMPAT_CLIENT_INSTALL_PATH": root}), \
mock.patch.dict(OPEN, {"PROTON_RUN": str(BIN / "droiddeck-proton-run"),
"store_launcher": lambda path: str(self.tmp / "launch.bat")}):
command = OPEN["command"](str(exe), [], "windows")[0]
located = RUN["locate"](str(exe), root)
self.assertEqual(command[1:5], ["--prefix", located.appid, "--compatdata", located.compatdata])
self.assertEqual(str(RUN["own_id"](str(exe))), str(RUN["locate"](str(exe), root).appid))
def test_a_native_program_on_noexec_storage_runs_from_a_copy(self):
program = self.write("storage/tool", elf(183))
x86 = self.write("storage/game.x86_64", elf(62))
@@ -737,6 +761,20 @@ class ProtonRunTest(Temp):
self.assertEqual(env["STEAM_COMPAT_DATA_PATH"], str(signed))
self.assertFalse((self.root / "steamapps/compatdata/2733369024").exists())
def test_a_launcher_run_keeps_the_resolved_compatdata_folder(self):
bat = self.write("Games/Epic/Game/.droiddeck-launch.bat", b"@echo off")
signed = self.root / "steamapps/compatdata/-1561598272"
signed.mkdir(parents=True)
other = self.tmp / "Library2/steamapps/compatdata/555"
other.mkdir(parents=True)
for compatdata, appid in ((signed, "2733369024"), (other, "555")):
with self.subTest(compatdata=str(compatdata)):
code, calls, dirs = self.run_main(["--prefix", appid, "--compatdata", str(compatdata), str(bat)])
self.assertIsNone(code)
self.assertEqual(calls[0][2]["STEAM_COMPAT_DATA_PATH"], str(compatdata))
code, calls, dirs = self.run_main(["--prefix", "555", str(bat)])
self.assertEqual(calls[0][2]["STEAM_COMPAT_DATA_PATH"], str(self.root / "steamapps/compatdata/555"))
def test_prefix_folder_prefers_initialized_unsigned_over_empty_signed(self):
signed = self.root / "steamapps/compatdata/-1561598272"
signed.mkdir(parents=True)
+32 -2
View File
@@ -83,9 +83,25 @@ int inotify_add_watch(int fd, const char *path, uint32_t mask) {
errno = ENOSPC;
return -1;
}
if (getenv("NESTED") && (mask & IN_ONLYDIR)) {
static DIR *(*uncounted)(const char *);
if (!uncounted) uncounted = dlsym(RTLD_NEXT, "opendir");
mkdir(path, 0755);
DIR *d = uncounted("/proc/self/fd");
while (d && readdir(d)) {}
if (d) closedir(d);
}
return next(fd, path, mask);
}
int remove(const char *path) {
static int (*next)(const char *);
if (!next) next = dlsym(RTLD_NEXT, "remove");
if (!getenv("NESTED")) return next(path);
if (unlink(path) == 0) return 0;
return errno == EISDIR ? rmdir(path) : -1;
}
int statfs(const char *path, struct statfs *out) {
static int (*next)(const char *, struct statfs *);
if (!next) next = dlsym(RTLD_NEXT, "statfs");
@@ -337,9 +353,9 @@ class DirCachePreloadTest(unittest.TestCase):
environment.update(env or {})
return environment
def run_program(self, *args, program=None, env=None):
def run_program(self, *args, program=None, env=None, timeout=60):
result = subprocess.run([str(program or self.steam), *map(str, args)], env=self.environment(env),
capture_output=True, text=True, check=True, timeout=60)
capture_output=True, text=True, check=True, timeout=timeout)
return result.stdout.splitlines()
def run_paused(self, *args, between, env=None):
@@ -675,6 +691,20 @@ class DirCachePreloadTest(unittest.TestCase):
env={"BL_NO_DIR_CACHE": "1"})
self.assertEqual(["-1 2", "-1 2", "2"], out[1:])
def test_a_preload_below_calling_back_while_a_folder_is_watched_does_not_hang(self):
common = self.lib / "common/Game"
common.mkdir(parents=True)
(common / "game.exe").touch()
out = self.run_program("list", self.staging, "list", common, "list", common, "opens",
env={"NESTED": "1"}, timeout=20)
self.assertEqual(["a.bundle,b.bundle", "game.exe", "game.exe", "2"], out)
def test_a_preload_below_removing_through_unlink_does_not_hang(self):
s = self.staging
out = self.run_program("list", s, "remove", s / "a.bundle", "list", s, "raw", s, "opens",
env={"NESTED": "1"}, timeout=20)
self.assertEqual(["a.bundle,b.bundle", "b.bundle", "b.bundle", "1"], out)
def test_can_be_turned_off(self):
out = self.run_program("list", self.staging, "list", self.staging, "opens", env={"BL_NO_DIR_CACHE": "1"})
self.assertEqual("2", out[-1])
+156 -5
View File
@@ -175,17 +175,27 @@ class RuntimeExtractTest(EpicTestCase):
old = self.state / "app/0.1"
old.mkdir(parents=True)
def extract_app(image, dest):
os.makedirs(os.path.join(dest, "usr/bin"))
Path(dest, "AppRun").write_text("run")
Path(dest, "usr/bin/EpicGamesLauncher").write_text("bin")
layers = []
def extract_app(image, dest, desktop=()):
layers.append(list(desktop))
os.makedirs(os.path.join(dest, "usr/bin"))
os.makedirs(os.path.join(dest, "desktop/usr/lib/x86_64-linux-gnu"))
Path(dest, "usr/bin/EpicGamesLauncher").write_text("bin")
Path(dest, "desktop/usr/lib/x86_64-linux-gnu/libwebkit2gtk-4.1.so.0").write_text("webkit")
package = self.tmp / "libwebkit.deb"
package.write_bytes(b"x")
with mock.patch.dict(G, {"extract_app": extract_app, "fex_tool": lambda request=False: {"bin": "/fex", "server": "/s"}}), \
mock.patch("sys.stdout", new_callable=io.StringIO) as out:
image = self.tmp / "image"
image.write_bytes(b"x")
with self.assertRaises(G["Failure"]):
G["install"]({"app": str(image), "app-version": "0.95.2+g1", "runtime": str(tarball),
"runtime-version": "4.0.1", "gles": str(deb), "desktop": [str(self.tmp / "missing.deb")]})
code = G["install"]({"app": str(image), "app-version": "0.95.2+g1", "runtime": str(tarball),
"runtime-version": "4.0.1", "gles": str(deb)})
"runtime-version": "4.0.1", "gles": str(deb), "desktop": [str(package)]})
self.assertEqual([[str(package)]], layers)
self.assertEqual(0, code)
report = json.loads(out.getvalue())
self.assertTrue(report["installed"])
@@ -197,6 +207,147 @@ class RuntimeExtractTest(EpicTestCase):
self.assertTrue((self.state / "app/0.95.2+g1/.droiddeck-ready").is_file())
def deb(path, entries, compression="gz"):
data = io.BytesIO()
with tarfile.open(fileobj=data, mode="w:" + compression) as archive:
for entry in entries:
tar_add(archive, *entry[:1], **entry[1])
path.write_bytes(ar([("debian-binary", b"2.0\n"), ("control.tar.xz", b"c"), ("data.tar." + compression, data.getvalue())]))
return path
class LauncherDebTest(EpicTestCase):
def launcher(self, extra=()):
return deb(self.tmp / "EpicGamesLauncher-x86_64.deb", [
("./usr", {"kind": "dir"}),
("./usr/bin/EpicGamesLauncher", {"data": b"egl", "mode": 0o755}),
("./usr/lib/epic-games-launcher/libEOSSDK-Linux-Shipping.so", {"data": b"eos"}),
("./usr/share/icons/hicolor/256x256@2/apps/EpicGamesLauncher.png", {"data": b"png"}),
("./usr/share/applications/epic-games-launcher.desktop", {"data": b"[Desktop Entry]\n"}),
("./usr/bin/egl", {"link": "/usr/bin/EpicGamesLauncher"}),
("../escape", {"data": b"x"}),
*extra,
])
def webkit(self):
return deb(self.tmp / "libwebkit2gtk-4.1-0_amd64.deb", [
("./usr/lib/x86_64-linux-gnu/libwebkit2gtk-4.1.so.0.19.1", {"data": b"webkit"}),
("./usr/lib/x86_64-linux-gnu/libwebkit2gtk-4.1.so.0", {"link": "libwebkit2gtk-4.1.so.0.19.1"}),
("./usr/lib/x86_64-linux-gnu/webkit2gtk-4.1/WebKitNetworkProcess", {"data": b"net", "mode": 0o755}),
("./usr/lib/x86_64-linux-gnu/webkit2gtk-4.1/injected-bundle/libwebkit2gtkinjectedbundle.so", {"data": b"bundle"}),
("./usr/share/glib-2.0/schemas/org.gnome.GWeather4.gschema.xml", {"data": b"schema"}),
("./usr/share/doc/libwebkit2gtk-4.1-0/copyright", {"data": b"c"}),
("./usr/share/locale/fr/LC_MESSAGES/WebKitGTK-4.1.mo", {"data": b"fr"}),
], "xz")
def test_the_launcher_and_its_desktop_layer_come_out_of_debs(self):
dest = self.state / "app/0.113.0+g1"
G["extract_app"](str(self.launcher()), str(dest), [str(self.webkit())])
self.assertEqual(b"egl", (dest / "usr/bin/EpicGamesLauncher").read_bytes())
self.assertTrue(os.access(dest / "usr/bin/EpicGamesLauncher", os.X_OK))
self.assertEqual(b"eos", (dest / "usr/lib/epic-games-launcher/libEOSSDK-Linux-Shipping.so").read_bytes())
self.assertEqual("EpicGamesLauncher", os.readlink(dest / "usr/bin/egl"))
self.assertEqual(b"png", (dest / "epic-games-launcher.png").read_bytes())
libs = dest / "desktop/usr/lib/x86_64-linux-gnu"
self.assertEqual(b"webkit", (libs / "libwebkit2gtk-4.1.so.0").read_bytes())
self.assertEqual(b"net", (libs / "webkit2gtk-4.1/WebKitNetworkProcess").read_bytes())
self.assertEqual(b"schema", (dest / "desktop/usr/share/glib-2.0/schemas/org.gnome.GWeather4.gschema.xml").read_bytes())
self.assertFalse((dest / "desktop/usr/share/doc").exists())
self.assertFalse((self.state / "app/escape").exists())
self.assertFalse((self.state / "app/0.113.0+g1.staging").exists())
self.assertTrue(G["app_complete"](str(dest)))
self.assertEqual(str(dest / "usr/bin/EpicGamesLauncher"), G["app_command"](str(dest)))
self.assertEqual(str(libs), G["desktop_libs"](str(dest)))
def test_archive_symlinks_cannot_redirect_the_desktop_layer_or_icon(self):
outside = self.tmp / "outside"
outside.mkdir()
dest = self.state / "app/0.113.0+g1"
escape = os.path.relpath(outside, Path(str(dest) + ".staging"))
launcher = self.launcher([("./desktop", {"link": escape}),
("./epic-games-launcher.png", {"link": escape + "/target"})])
with self.assertRaises(G["Failure"]) as caught:
G["extract_app"](str(launcher), str(dest), [str(self.webkit())])
self.assertEqual("app-extract", str(caught.exception))
self.assertFalse((outside / "usr").exists())
self.assertFalse((outside / "target").exists())
icon_dest = self.state / "app/0.113.0+g2"
icon_escape = os.path.relpath(outside / "target", Path(str(icon_dest) + ".staging"))
G["extract_app"](str(self.launcher([("./epic-games-launcher.png", {"link": icon_escape})])),
str(icon_dest), [str(self.webkit())])
self.assertEqual(b"png", (icon_dest / "epic-games-launcher.png").read_bytes())
self.assertFalse((outside / "target").exists())
def test_a_launcher_without_its_desktop_layer_is_refused(self):
dest = self.state / "app/0.113.0+g1"
with self.assertRaises(G["Failure"]) as caught:
G["extract_app"](str(self.launcher()), str(dest))
self.assertEqual("app-extract", str(caught.exception))
self.assertFalse(dest.exists())
self.assertFalse(Path(str(dest) + ".staging").exists())
def test_anything_but_a_deb_is_refused_and_leaves_nothing_behind(self):
image = self.tmp / "EpicGamesLauncher-x86_64.AppImage"
image.write_bytes(b"\x7fELF\x02\x01\x01\x00AI\x02" + bytes(64))
dest = self.state / "app/0.95.2+g1"
with self.assertRaises(G["Failure"]) as caught:
G["extract_app"](str(image), str(dest), [str(self.webkit())])
self.assertEqual("app-format", str(caught.exception))
plain = self.tmp / "plain.deb"
plain.write_bytes(ar([("data.tar.gz", b"x")]))
with self.assertRaises(G["Failure"]) as caught:
G["extract_app"](str(self.launcher()), str(dest), [str(plain)])
self.assertEqual("desktop-format", str(caught.exception))
self.assertFalse(dest.exists())
self.assertFalse(Path(str(dest) + ".staging").exists())
def test_an_installed_appimage_launcher_still_runs_through_apprun(self):
app = self.state / "app/0.95.2+g1"
(app / "usr/bin").mkdir(parents=True)
(app / "AppRun").write_text("run")
(app / "usr/bin/EpicGamesLauncher").write_text("bin")
self.assertTrue(G["app_complete"](str(app)))
self.assertEqual(str(app / "AppRun"), G["app_command"](str(app)))
self.assertIsNone(G["desktop_libs"](str(app)))
(app / "usr/bin/EpicGamesLauncher").unlink()
self.assertFalse(G["app_complete"](str(app)))
def test_the_webkit_helpers_are_linked_into_the_runtime(self):
dest = self.state / "app/0.113.0+g1"
G["extract_app"](str(self.launcher()), str(dest), [str(self.webkit())])
files = self.state / "runtime/4.0.1/files"
(files / "lib/x86_64-linux-gnu").mkdir(parents=True)
link = files / "lib/x86_64-linux-gnu/webkit2gtk-4.1"
G["link_webkit"](str(files), G["desktop_libs"](str(dest)))
self.assertFalse(os.path.isabs(os.readlink(link)))
self.assertEqual(b"net", (link / "WebKitNetworkProcess").read_bytes())
G["link_webkit"](str(files), G["desktop_libs"](str(dest)))
self.assertEqual(b"net", (link / "WebKitNetworkProcess").read_bytes())
G["link_webkit"](str(files), None)
self.assertFalse(os.path.lexists(link))
link.mkdir()
(link / "own").write_text("x")
G["link_webkit"](str(files), G["desktop_libs"](str(dest)))
self.assertTrue((link / "own").is_file())
self.assertTrue((dest / "desktop/usr/lib/x86_64-linux-gnu/webkit2gtk-4.1/WebKitNetworkProcess").is_file())
def test_only_the_deb_launcher_gets_the_desktop_libraries(self):
with mock.patch.dict(G, {"fex_environment": lambda fex, files, base: {}}):
plain = G["client_environment"]({"LD_LIBRARY_PATH": "/host"}, None, None, ":0", "bus", "broker")
layered = G["client_environment"]({}, None, None, ":0", "bus", "broker", libs="/app/desktop/usr/lib/x86_64-linux-gnu")
self.assertNotIn("LD_LIBRARY_PATH", plain)
self.assertEqual("/app/desktop/usr/lib/x86_64-linux-gnu", layered["LD_LIBRARY_PATH"])
self.assertEqual("/app/desktop/usr/share:/usr/local/share:/usr/share", layered["XDG_DATA_DIRS"])
self.assertEqual("/app/desktop/usr/share/glib-2.0/schemas", layered["GSETTINGS_SCHEMA_DIR"])
def test_every_desktop_package_reaches_the_install(self):
options, rest = G["parse_options"](["--app", "a.deb", "--desktop", "one.deb", "--desktop", "two.deb", "x"], lists=("desktop",))
self.assertEqual({"app": "a.deb", "desktop": ["one.deb", "two.deb"]}, options)
self.assertEqual(["x"], rest)
self.assertEqual({"desktop": "two.deb"}, G["parse_options"](["--desktop", "one.deb", "--desktop", "two.deb"])[0])
class ArgumentsTest(EpicTestCase):
def test_client_arguments_win_and_paths_become_windows_paths(self):
ovt = self.tmp / "ovt"
+59 -2
View File
@@ -213,6 +213,18 @@ class DroiddeckctlTest(FakeAdbTest):
started = [e["args"] for e in self.calls() if e["args"][:3] == ["shell", "am", "start"]]
self.assertIn("com.antutu.benchmark.full/com.droiddeck.launcher.agent.AgentStartActivity", started[0])
def test_a_start_delivered_to_an_existing_task_is_a_failure(self):
output = (b"Starting: Intent { cmp=com.droiddeck.launcher/.agent.AgentStartActivity (has extras) }\n"
b"Warning: Activity not started, intent has been delivered to currently running top-most instance.\n"
b"Status: ok\nActivity: com.droiddeck.launcher/.FrontEndActivity\nComplete\n")
def adb(_adb, _serial, *args, timeout=30):
return ctl.subprocess.CompletedProcess(args, 0, output, b"")
with unittest.mock.patch.object(ctl, "run_adb", adb), self.assertRaises(ctl.ControlError) as caught:
ctl.start_agent_activity("adb", "fake-1", {"mode": "steam"})
self.assertEqual("ACTIVITY_START_FAILED", caught.exception.code)
def test_a_malformed_package_is_refused_before_adb(self):
with unittest.mock.patch.dict(os.environ, {"DROIDDECK_PACKAGE": "com.example;reboot"}):
variant = load("droiddeckctl")
@@ -291,7 +303,7 @@ class DroiddeckctlTest(FakeAdbTest):
code, out = self.run_ctl("run", "/usr/bin/sh", "--", "-c", "true")
self.assertEqual(7, code)
self.assertEqual("AGENT_COMMANDS_DISABLED", out["error"]["code"])
self.assertIn("Setup > Diagnostics > Debugging tools", out["error"]["message"])
self.assertIn("Setup > Developer > Debugging tools", out["error"]["message"])
self.assertEqual(["access"], [c.get("method") for c in self.calls()])
def test_override_checks_names_before_pushing_any_file(self):
@@ -417,12 +429,14 @@ class DroiddeckctlTest(FakeAdbTest):
return ctl.subprocess.CompletedProcess(args, 127, b"", b"/system/bin/sh: content: inaccessible or not found")
if args[:2] == ("shell", "am"):
return ctl.subprocess.CompletedProcess(args, 0, b"Broadcast completed: result=0", b"")
if args[:2] == ("shell", "pidof " + ctl.PACKAGE):
return ctl.subprocess.CompletedProcess(args, 0, b"4940\n", b"")
return ctl.subprocess.CompletedProcess(args, 0, next(answers), b"")
with unittest.mock.patch.object(ctl, "run_adb", adb), unittest.mock.patch.object(ctl.time, "sleep"):
answer = ctl.provider_call("adb", "fake-1", "state", arg="a b", request={"x": 1})
self.assertEqual({"ok": True, "command": "state"}, answer)
broadcast = calls[1]
broadcast = next(c for c in calls if c[:2] == ("shell", "am"))
self.assertEqual(("shell", "am", "broadcast", "-a", ctl.PACKAGE + ".AGENT_CALL", "-p", ctl.PACKAGE), broadcast[:7])
self.assertIn("'a b'", broadcast)
self.assertEqual(ctl.encode_request({"x": 1}), broadcast[broadcast.index("request") + 1])
@@ -823,5 +837,48 @@ class ScenarioTest(FakeAdbTest):
self.assertEqual([{"appId": 7, "timeout": 15.0}] * 2, [c["request"] for c in self.calls("quit")])
class ProviderFallbackTest(unittest.TestCase):
MISSING = "/system/bin/sh: content: inaccessible or not found\n"
def adb(self, answers):
calls = []
def run(adb, serial, *args, timeout=None):
calls.append(args)
for prefix, (code, out, err) in answers:
if " ".join(args).startswith(" ".join(prefix)):
return unittest.mock.Mock(returncode=code, stdout=out.encode(), stderr=err.encode())
raise AssertionError(f"unexpected adb call {args}")
return calls, unittest.mock.patch.object(ctl, "run_adb", run)
def test_a_command_that_prints_the_shell_error_is_not_run_again(self):
result = 'Result: Bundle[{json={"ok":true,"stdout":{"text":"' + self.MISSING.strip() + '"}}}]'
calls, patch = self.adb([(["shell", "content"], (0, result, ""))])
with patch:
self.assertTrue(ctl.provider_call("adb", "s", "native", request={"argv": ["x"]})["ok"])
self.assertEqual(1, len(calls))
def test_a_shell_without_content_uses_the_broadcast(self):
calls, patch = self.adb([
(["shell", "content"], (127, "", self.MISSING)),
(["shell", "pidof"], (0, "4940\n", "")),
(["shell", "am", "broadcast"], (0, "Broadcast completed", "")),
(["shell"], (0, '{"ok": true}', "")),
])
with patch:
self.assertTrue(ctl.provider_call("adb", "s", "state")["ok"])
self.assertEqual(["shell", "am", "broadcast"], list(calls[2][:3]))
def test_the_broadcast_needs_the_app_running(self):
calls, patch = self.adb([
(["shell", "content"], (127, "", self.MISSING)),
(["shell", "pidof"], (1, "", "")),
])
with patch, self.assertRaises(ctl.ControlError) as raised:
ctl.provider_call("adb", "s", "state")
self.assertEqual("APP_NOT_RUNNING", raised.exception.code)
self.assertFalse(any(c[:3] == ("shell", "am", "broadcast") for c in calls))
if __name__ == "__main__":
unittest.main()
+314
View File
@@ -0,0 +1,314 @@
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
USERNS = shutil.which("unshare") is not None and subprocess.run(["unshare", "-Urm", "true"], capture_output=True).returncode == 0
FASTPATH = Path(__file__).resolve().parents[1] / "proot/fastpath/fastpath.c"
PROGRAM = r"""
#include "FASTPATH"
#include <sys/mount.h>
static const char *race_from, *race_to;
static dev_t race_dev;
static ino_t race_ino;
static long trapped_nr = -1, unsupported_nr = -1;
static long host_sys(long nr, long a, long b, long c, long d, long e, long f) {
if (nr == trapped_nr || (nr == unsupported_nr && a != -1)) return -ENOSYS;
long r = syscall(nr, a, b, c, d, e, f);
struct stat fs;
if (r >= 0 && nr == SYS_fcntl && b == F_DUPFD_CLOEXEC && c == DIR_FD_FLOOR && race_from
&& syscall(SYS_fstat, a, &fs) == 0 && fs.st_dev == race_dev && fs.st_ino == race_ino) {
syscall(SYS_renameat, AT_FDCWD, race_from, AT_FDCWD, race_to);
race_from = NULL;
}
return r < 0 ? -errno : r;
}
static void show(long r) {
if (r == FP_SLOW) puts("SLOW");
else if (r < 0) printf("E%ld\n", -r);
else puts("ok");
}
static int high_fds(void) {
int n = 0;
for (int fd = DIR_FD_FLOOR; fd < DIR_FD_FLOOR + 4 * DIRS; fd++)
if (fcntl(fd, F_GETFD) >= 0) n++;
return n;
}
int main(int argc, char **argv) {
static char hosts[MAX_BINDS][PATH_MAX], guests[MAX_BINDS][512];
static int taken[DIRS];
int ntaken = 0;
fp_sys = host_sys;
snprintf(root, sizeof root, "%s", argv[1]);
rootlen = strlen(root);
int i = 2;
for (; i + 1 < argc && strcmp(argv[i], "--"); i += 2) {
struct bind *bd = &binds[nbinds];
bd->host = hosts[nbinds];
bd->guest = guests[nbinds];
snprintf(bd->host, PATH_MAX, "%s", argv[i]);
snprintf(bd->guest, sizeof guests[0], "%s", argv[i + 1]);
bd->hlen = strlen(bd->host);
bd->glen = strlen(bd->guest);
nbinds++;
}
pthread_once(&init_once, fp_init);
fp_on = 1;
for (i++; i < argc; i++) {
const char *op = argv[i];
if (!strcmp(op, "fuse")) {
for (int b = 0; b < nbinds; b++) binds[b].fuse = 1;
} else if (!strcmp(op, "touch")) {
long fd = fp_open(AT_FDCWD, argv[++i], O_CREAT | O_WRONLY | O_CLOEXEC, 0644);
if (fd >= 0) close((int)fd);
show(fd);
} else if (!strcmp(op, "stat")) {
struct stat st;
show(fp_stat(AT_FDCWD, argv[++i], AT_SYMLINK_NOFOLLOW, &st));
} else if (!strcmp(op, "symlink")) {
long r = fp_symlink("target", AT_FDCWD, argv[++i]);
if (refused()) puts("REFUSED");
else show(r);
} else if (!strcmp(op, "trap-symlink")) {
trapped_nr = SYS_symlinkat;
} else if (!strcmp(op, "no-symlinks")) {
unsupported_nr = SYS_symlinkat;
} else if (!strcmp(op, "on")) {
printf("%d\n", fp_ready());
} else if (!strcmp(op, "no-folders")) {
unsupported_nr = SYS_mkdirat;
} else if (!strcmp(op, "busy-cache")) {
pthread_mutex_lock(&dir_lock);
} else if (!strcmp(op, "mkdir")) {
long r = fp_mkdir(AT_FDCWD, argv[++i], 0755);
if (refused()) puts("REFUSED");
else show(r);
} else if (!strcmp(op, "mv")) {
show(fp_rename(AT_FDCWD, argv[i + 1], AT_FDCWD, argv[i + 2], 0));
i += 2;
} else if (!strcmp(op, "rm")) {
show(fp_unlink(AT_FDCWD, argv[++i], 0));
} else if (!strcmp(op, "host-mv")) {
show(host_sys(SYS_renameat, AT_FDCWD, (long)argv[i + 1], AT_FDCWD, (long)argv[i + 2], 0, 0));
i += 2;
} else if (!strcmp(op, "race-mv")) {
struct stat rs;
race_from = argv[i + 1];
race_to = argv[i + 2];
i += 2;
show(host_sys(SYS_newfstatat, AT_FDCWD, (long)race_from, (long)&rs, 0, 0, 0));
race_dev = rs.st_dev;
race_ino = rs.st_ino;
} else if (!strcmp(op, "host-rmdir")) {
show(host_sys(SYS_unlinkat, AT_FDCWD, (long)argv[++i], AT_REMOVEDIR, 0, 0, 0));
} else if (!strcmp(op, "host-mkdir")) {
show(host_sys(SYS_mkdirat, AT_FDCWD, (long)argv[++i], 0755, 0, 0, 0));
} else if (!strcmp(op, "clobber")) {
long null = host_sys(SYS_openat, AT_FDCWD, (long)"/dev/null", O_RDONLY, 0, 0, 0);
for (int fd = DIR_FD_FLOOR; fd < DIR_FD_FLOOR + DIRS; fd++) host_sys(SYS_dup3, null, fd, 0, 0, 0, 0);
host_sys(SYS_close, null, 0, 0, 0, 0, 0);
puts("ok");
} else if (!strcmp(op, "first-fd")) {
char link[40], out[PATH_MAX];
snprintf(link, sizeof link, "/proc/self/fd/%d", DIR_FD_FLOOR);
long n = host_sys(SYS_readlinkat, AT_FDCWD, (long)link, (long)out, sizeof out - 1, 0, 0);
out[n > 0 ? n : 0] = 0;
puts(out);
} else if (!strcmp(op, "fds")) {
printf("%d\n", high_fds());
} else if (!strcmp(op, "ttl")) {
ttl_ns = atoll(argv[++i]) * 1000000LL;
} else if (!strcmp(op, "sleep")) {
usleep(atoi(argv[++i]) * 1000);
} else if (!strcmp(op, "chmod")) {
show(fp_chmod(AT_FDCWD, argv[i + 1], strtol(argv[i + 2], NULL, 8), 0));
i += 2;
} else if (!strcmp(op, "host-mount")) {
show(mount("tmpfs", argv[++i], "tmpfs", 0, NULL) == 0 ? 0 : -errno);
} else if (!strcmp(op, "take-over")) {
for (int fd = DIR_FD_FLOOR; fd < DIR_FD_FLOOR + DIRS; fd++) {
char link[40], out[PATH_MAX];
snprintf(link, sizeof link, "/proc/self/fd/%d", fd);
long n = host_sys(SYS_readlinkat, AT_FDCWD, (long)link, (long)out, sizeof out - 1, 0, 0);
if (n <= 0) continue;
out[n] = 0;
long mine = host_sys(SYS_openat, AT_FDCWD, (long)out, O_RDONLY | O_DIRECTORY, 0, 0, 0);
host_sys(SYS_dup3, mine, fd, 0, 0, 0, 0);
host_sys(SYS_close, mine, 0, 0, 0, 0, 0);
taken[ntaken++] = fd;
}
puts("ok");
} else if (!strcmp(op, "taken")) {
int open_fds = 0;
for (int t = 0; t < ntaken; t++)
if (lseek(taken[t], 0, SEEK_CUR) == 0) open_fds++;
printf("%d/%d\n", open_fds, ntaken);
}
}
return 0;
}
"""
class FastPathFuseDirsTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
if shutil.which("gcc") is None:
raise unittest.SkipTest("gcc is not available")
cls.build = tempfile.TemporaryDirectory()
source = Path(cls.build.name) / "fuse_dirs.c"
source.write_text(PROGRAM.replace("FASTPATH", str(FASTPATH)))
cls.program = Path(cls.build.name) / "fuse_dirs"
subprocess.run(["gcc", "-O1", "-Wall", "-Wextra", "-Werror", "-Wno-format-truncation", "-pthread", "-o", str(cls.program), str(source), "-ldl"], check=True)
@classmethod
def tearDownClass(cls):
cls.build.cleanup()
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
base = Path(self.temp.name)
self.root = base / "root"
(self.root / "mnt").mkdir(parents=True)
self.card = base / "card"
(self.card / "Games/steamapps/common/Game/Data").mkdir(parents=True)
def ask(self, *ops, wrap=()):
argv = [*wrap, str(self.program), str(self.root), str(self.card), "/mnt/card", "--", *ops]
return subprocess.run(argv, capture_output=True, text=True, timeout=20, check=True).stdout.split()
def test_files_deep_in_a_fuse_library_are_created_renamed_and_removed(self):
data = "/mnt/card/Games/steamapps/common/Game/Data"
out = self.ask("fuse", "touch", f"{data}/a.tmp", "mv", f"{data}/a.tmp", f"{data}/a.idx",
"stat", f"{data}/a.idx", "stat", f"{data}/a.tmp", "rm", f"{data}/a.idx",
"stat", f"{data}/a.idx", "fds")
self.assertEqual(["ok", "ok", "ok", "E2", "ok", "E2"], out[:-1])
self.assertGreater(int(out[-1]), 0)
self.assertEqual([], list((self.card / "Games/steamapps/common/Game/Data").iterdir()))
def test_a_folder_renamed_behind_the_cache_is_not_reused(self):
game = self.card / "Games/steamapps/common/Game"
(game / "Data/keep").write_text("x")
out = self.ask("fuse", "stat", "/mnt/card/Games/steamapps/common/Game/Data/keep",
"host-mv", str(game), str(game.parent / "Moved"),
"stat", "/mnt/card/Games/steamapps/common/Game/Data/keep",
"stat", "/mnt/card/Games/steamapps/common/Moved/Data/keep")
self.assertEqual(["ok", "ok", "E2", "ok"], out)
def test_a_folder_renamed_while_it_is_opened_is_not_used_under_its_old_name(self):
game = self.card / "Games/steamapps/common/Game"
(game / "Data/keep").write_text("x")
out = self.ask("fuse", "race-mv", str(game / "Data"), str(game / "Moved"),
"stat", "/mnt/card/Games/steamapps/common/Game/Data/keep",
"touch", "/mnt/card/Games/steamapps/common/Game/Data/new", "fds")
self.assertEqual(["ok", "E2", "E2"], out[:3])
self.assertEqual(["keep"], [p.name for p in (game / "Moved").iterdir()])
self.assertLessEqual(int(out[-1]), 64)
def test_a_folder_deleted_and_made_again_is_looked_up_fresh(self):
data = self.card / "Games/steamapps/common/Game/Data"
out = self.ask("fuse", "touch", "/mnt/card/Games/steamapps/common/Game/Data/old",
"rm", "/mnt/card/Games/steamapps/common/Game/Data/old",
"host-rmdir", str(data), "host-mkdir", str(data),
"touch", "/mnt/card/Games/steamapps/common/Game/Data/new")
self.assertEqual(["ok"] * 5, out)
self.assertEqual(["new"], [p.name for p in data.iterdir()])
def test_folders_deleted_and_made_again_many_times_keep_descriptors_bounded(self):
data = self.card / "Games/steamapps/common/Game/Data"
ops = ["fuse"]
for _ in range(200):
ops += ["touch", "/mnt/card/Games/steamapps/common/Game/Data/x",
"rm", "/mnt/card/Games/steamapps/common/Game/Data/x",
"host-rmdir", str(data), "host-mkdir", str(data)]
out = self.ask(*ops, "fds")
self.assertEqual(["ok"] * 800, out[:-1])
self.assertLessEqual(int(out[-1]), 64)
def test_descriptors_the_program_takes_over_are_left_alone(self):
data = "/mnt/card/Games/steamapps/common/Game/Data"
out = self.ask("fuse", "touch", f"{data}/a", "clobber", "touch", f"{data}/b",
"stat", f"{data}/a", "first-fd")
self.assertEqual(["ok", "ok", "ok", "ok", "/dev/null"], out)
self.assertEqual({"a", "b"}, {p.name for p in (self.card / "Games/steamapps/common/Game/Data").iterdir()})
def test_a_folder_the_program_opened_itself_stays_open_when_the_cache_moves_on(self):
data = self.card / "Games/steamapps/common/Game/Data"
ops = ["fuse", "touch", "/mnt/card/Games/steamapps/common/Game/Data/a", "take-over"]
for n in range(200):
(data / f"d{n}").mkdir()
ops += ["touch", f"/mnt/card/Games/steamapps/common/Game/Data/d{n}/x"]
out = self.ask(*ops, "taken")
self.assertEqual(["ok"] * 202, out[:-1])
opened, total = map(int, out[-1].split("/"))
self.assertGreater(total, 0)
self.assertEqual(total, opened)
self.assertEqual(200, len(list(data.glob("d*/x"))))
@unittest.skipIf(os.geteuid() == 0, "root passes folder permissions")
def test_a_parent_folder_closed_by_the_program_stops_cached_access_at_once(self):
game = self.card / "Games/steamapps/common/Game"
(game / "Data/keep").write_text("x")
self.addCleanup(os.chmod, game, 0o755)
out = self.ask("fuse", "stat", "/mnt/card/Games/steamapps/common/Game/Data/keep",
"chmod", "/mnt/card/Games/steamapps/common/Game", "000",
"stat", "/mnt/card/Games/steamapps/common/Game/Data/keep",
"touch", "/mnt/card/Games/steamapps/common/Game/Data/new")
self.assertEqual(["ok", "ok"], out[:2])
self.assertNotIn("ok", out[2:])
os.chmod(game, 0o755)
self.assertEqual(["keep"], [p.name for p in (game / "Data").iterdir()])
@unittest.skipUnless(USERNS, "mount namespaces are not available")
def test_a_mount_placed_over_a_cached_folder_receives_later_writes(self):
data = self.card / "Games/steamapps/common/Game/Data"
out = self.ask("fuse", "ttl", "1", "touch", "/mnt/card/Games/steamapps/common/Game/Data/under",
"host-mount", str(data), "sleep", "20",
"touch", "/mnt/card/Games/steamapps/common/Game/Data/over",
"stat", "/mnt/card/Games/steamapps/common/Game/Data/under", wrap=("unshare", "-Urm"))
self.assertEqual(["ok", "ok", "ok", "E2"], out)
self.assertEqual(["under"], [p.name for p in data.iterdir()])
def test_a_call_the_filesystem_does_not_implement_leaves_the_fast_path_on(self):
data = "/mnt/card/Games/steamapps/common/Game/Data"
out = self.ask("fuse", "no-symlinks", "touch", f"{data}/a", "symlink", f"{data}/link", "on",
"stat", f"{data}/a", "symlink", f"{data}/link", "on", "touch", f"{data}/b")
self.assertEqual(["ok", "REFUSED", "1", "ok", "REFUSED", "1", "ok"], out)
self.assertEqual(["a", "b"], sorted(p.name for p in (self.card / "Games/steamapps/common/Game/Data").iterdir()))
def test_repeated_unsupported_calls_close_the_folders_they_opened(self):
data = "/mnt/card/Games/steamapps/common/Game/Data"
ops = [op for n in range(40) for op in ("mkdir", f"{data}/new{n}")]
out = self.ask("fuse", "no-folders", "busy-cache", *ops, "on", "fds")
self.assertEqual(["REFUSED"] * 40 + ["1", "0"], out)
def test_a_trapped_call_still_stops_the_fast_path_for_the_process(self):
data = "/mnt/card/Games/steamapps/common/Game/Data"
out = self.ask("fuse", "trap-symlink", "symlink", f"{data}/link", "on")
self.assertEqual(["REFUSED", "0"], out)
def test_a_symlink_is_made_where_the_filesystem_allows_it(self):
data = "/mnt/card/Games/steamapps/common/Game/Data"
out = self.ask("fuse", "symlink", f"{data}/link", "on")
self.assertEqual(["ok", "1"], out)
self.assertEqual("target", os.readlink(self.card / "Games/steamapps/common/Game/Data/link"))
def test_other_filesystems_keep_absolute_paths_and_open_no_folders(self):
data = "/mnt/card/Games/steamapps/common/Game/Data"
out = self.ask("touch", f"{data}/a", "mv", f"{data}/a", f"{data}/b", "rm", f"{data}/b", "fds")
self.assertEqual(["ok", "ok", "ok", "0"], out)
if __name__ == "__main__":
unittest.main()
+65 -2
View File
@@ -950,6 +950,22 @@ class GameEnvironmentTest(unittest.TestCase):
self.assertEqual(MODULE["apply_config"](env, config, "42")["TU_DEBUG"], "sysmem")
self.assertNotIn("TU_DEBUG", MODULE["apply_config"](env, config, "43"))
def test_games_run_with_gl_error_checks_unless_the_user_turns_them_off(self):
gpu = MODULE["game_gpu"]
session = {"MESA_NO_ERROR": "1", "DROIDDECK_GAME_MESA_NO_ERROR": "", "KEEP": "1"}
self.assertEqual(gpu(session), {"KEEP": "1"})
self.assertEqual(gpu(session, True), {"MESA_NO_ERROR": "1", "KEEP": "1"})
self.assertEqual(gpu({"MESA_NO_ERROR": "1"}), {"MESA_NO_ERROR": "1"})
self.assertEqual(gpu({"MESA_NO_ERROR": "1", "DROIDDECK_GAME_MESA_NO_ERROR": "1"}), {"MESA_NO_ERROR": "1"})
both = gpu({"MESA_NO_ERROR": "1", "DROIDDECK_GAME_MESA_NO_ERROR": "", "TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "nolrz"})
self.assertEqual(both, {"TU_DEBUG": "nolrz"})
self.assertEqual(gpu({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "", "MESA_NO_ERROR": "1"}),
{"MESA_NO_ERROR": "1"})
config = {"version": 1, "games": {"42": {"MESA_NO_ERROR": "1"}}}
env = gpu(session)
self.assertEqual(MODULE["apply_config"](env, config, "42")["MESA_NO_ERROR"], "1")
self.assertNotIn("MESA_NO_ERROR", MODULE["apply_config"](env, config, "43"))
def test_a_chromium_app_keeps_the_sessions_turnip_debug(self):
gpu = MODULE["game_gpu"]
self.assertEqual(gpu({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "", "KEEP": "1"}, True),
@@ -992,9 +1008,11 @@ class GameEnvironmentTest(unittest.TestCase):
def test_the_vram_cap_comes_before_the_games_own_dxvk_settings(self):
cap = MODULE["vram_cap"]
self.assertEqual(cap({"BL_VRAM_MB": "4096"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4096")
self.assertEqual(cap({"BL_VRAM_MB": "4096"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4096; dxgi.maxSharedMemory = 4096")
self.assertEqual(cap({"BL_VRAM_MB": "8192"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 8192; dxgi.maxSharedMemory = 8192")
self.assertEqual(cap({"BL_VRAM_MB": "4095"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4095; dxgi.maxSharedMemory = 4095; d3d9.maxAvailableMemory = 4095")
self.assertEqual(cap({"BL_VRAM_MB": "2048", "DXVK_CONFIG": "dxvk.maxFrameRate = 60;"})["DXVK_CONFIG"],
"dxgi.maxDeviceMemory = 2048; dxvk.maxFrameRate = 60")
"dxgi.maxDeviceMemory = 2048; dxgi.maxSharedMemory = 2048; d3d9.maxAvailableMemory = 2048; dxvk.maxFrameRate = 60")
for off in ({}, {"BL_VRAM_MB": "0"}, {"BL_VRAM_MB": "lots"}, {"BL_VRAM_MB": "²"}, {"BL_VRAM_MB": "-1"}):
self.assertNotIn("DXVK_CONFIG", cap(off))
self.assertNotIn("DROIDDECK_VRAM_CAP", cap(off))
@@ -1124,6 +1142,23 @@ class GameEnvironmentTest(unittest.TestCase):
scope = MODULE["game_id"](env)
expected = "untouched" if scope is None else scope if scope in {"42", "4294967295", "2147483648"} else "*"
self.assertEqual(target.read_text(), expected)
for app, expected in (("42", "42"), ("4294967295", "4294967295"), ("43", "*"), ("", "*"), ("x", "*")):
with self.subTest(shared=app):
env = dict(os.environ, HOME=str(root), STEAM_COMPAT_DATA_PATH="/steam/compatdata/2929927072", SteamAppId=app)
target.write_text("untouched")
subprocess.run(["bash", "-c", script, "test", str(base)], env=env, check=True, capture_output=True)
self.assertEqual(MODULE["game_id"](env), app if app in {"42", "4294967295", "43"} else "2929927072")
self.assertEqual(target.read_text(), expected)
for game, expected in (
(str(42 << 32 | 0x02000000), "42"), (str(4294967295 << 32 | 0x02000000), "4294967295"),
(str(42 << 32 | 0x02000001), "*"), (str(42 << 32 | 0x02000000 | 1 << 64), "*"), ("33554432", "*"), ("x", "*"),
):
with self.subTest(direct=game):
env = dict(os.environ, HOME=str(root), STEAM_COMPAT_DATA_PATH="/steam/compatdata/2929927072", SteamAppId="0", SteamGameId=game)
target.write_text("untouched")
subprocess.run(["bash", "-c", script, "test", str(base)], env=env, check=True, capture_output=True)
self.assertEqual(MODULE["game_id"](env), expected if expected != "*" else "2929927072")
self.assertEqual(target.read_text(), expected)
def test_engine_fixes_follow_the_games_files(self):
with tempfile.TemporaryDirectory() as tmp:
@@ -1503,6 +1538,19 @@ class GameEnvironmentTest(unittest.TestCase):
config = {"version": 1, "shared": {}, "games": {"42": values}}
self.assertEqual(MODULE["apply_config"]({}, config, "42", env), values, name)
def test_ff7_rebirth_runs_at_feature_level_12_2_unless_the_game_overrides_it(self):
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp) / "FINAL FANTASY VII REBIRTH"
game = root / "End/Binaries/Win64/ff7rebirth_.exe"
game.parent.mkdir(parents=True)
for exe in (root / "ff7rebirth.exe", game):
exe.touch()
env, extra, notes = MODULE["engine_fixes"](str(exe), [])
self.assertEqual(env, {"VKD3D_FEATURE_LEVEL": "12_2"}, exe.name)
self.assertTrue(notes)
config = {"version": 1, "shared": {}, "games": {"42": {"VKD3D_FEATURE_LEVEL": "12_1"}}}
self.assertEqual(MODULE["apply_config"]({}, config, "42", env), {"VKD3D_FEATURE_LEVEL": "12_1"})
def test_unity_players_keep_tso_over_the_preset(self):
with tempfile.TemporaryDirectory() as tmp:
def game(*names):
@@ -1628,6 +1676,10 @@ class GameEnvironmentTest(unittest.TestCase):
self.assertIsNone(MODULE["game_id"]({"STEAM_COMPAT_DATA_PATH": prefix}))
self.assertEqual(MODULE["game_id"]({"STEAM_COMPAT_DATA_PATH": "/a/compatdata/42/"}), "42")
self.assertEqual(MODULE["game_id"]({"STEAM_COMPAT_DATA_PATH": "/a/compatdata/-1"}), "4294967295")
shared = {"STEAM_COMPAT_DATA_PATH": "/a/compatdata/2929927072", "SteamAppId": "2424921676"}
self.assertEqual(MODULE["game_id"](shared), "2424921676")
self.assertEqual(MODULE["game_id"]({"STEAM_COMPAT_DATA_PATH": "/a/compatdata/2929927072"}), "2929927072")
self.assertEqual(MODULE["game_id"]({"STEAM_COMPAT_DATA_PATH": "/a/compatdata/42", "SteamAppId": "7"}), "42")
def test_launch_reads_updates_preserves_argv_and_does_not_execute_values(self):
with tempfile.TemporaryDirectory() as tmp:
@@ -2717,6 +2769,17 @@ class ForeignSystemDllTest(unittest.TestCase):
self.assertFalse((system32 / "ucrtbase.dll").is_symlink())
self.assertEqual(0x8664, MODULE["pe_machine"](system32 / "userlib.dll"))
def test_x64_visual_cpp_runtime_in_arm64_system32_is_kept(self):
with tempfile.TemporaryDirectory() as tmp:
proton, compat, windows = self.prefix(tmp)
builtins = proton.parent / "files/lib/wine/aarch64-windows"
for name in ("msvcp140.dll", "VCRUNTIME140.dll", "msvcp_win.dll"):
(builtins / name.lower()).write_bytes(pe_image(0xAA64))
(windows / "system32" / name).write_bytes(pe_image(0x8664))
self.assertEqual(["system32/msvcp_win.dll (machine 0x8664)"], self.run_repair(compat, proton))
self.assertFalse((windows / "system32/msvcp140.dll").is_symlink())
self.assertFalse((windows / "system32/VCRUNTIME140.dll").is_symlink())
def test_final_arm64ec_image_is_not_repaired_as_a_foreign_x64_dll(self):
with tempfile.TemporaryDirectory() as tmp:
proton, compat, windows = self.prefix(tmp)
+10 -1
View File
@@ -9,7 +9,7 @@ from pathlib import Path
BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin"
KEYS = ("TU_DEBUG", "DROIDDECK_GAME_TU_DEBUG", "MESA_LOADER_DRIVER_OVERRIDE", "GALLIUM_DRIVER",
"LIBGL_KOPPER_DRI2", "VK_ICD_FILENAMES", "VK_DRIVER_FILES")
"LIBGL_KOPPER_DRI2", "VK_ICD_FILENAMES", "VK_DRIVER_FILES", "MESA_NO_ERROR", "DROIDDECK_GAME_MESA_NO_ERROR")
SESSION = {"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": ""}
GPU_SESSION = {"MESA_LOADER_DRIVER_OVERRIDE": "zink", "GALLIUM_DRIVER": "zink",
"LIBGL_KOPPER_DRI2": "true", "VK_ICD_FILENAMES": "/runtime/turnip.json",
@@ -68,6 +68,15 @@ class GameGpuLaunchersTest(unittest.TestCase):
self.chromium()
self.assertEqual("sysmem", self.wrapper("--for", str(self.app / "files"))["TU_DEBUG"])
def test_programs_get_gl_error_checks_back_while_chromium_keeps_the_client_setting(self):
session = dict(GPU_SESSION, MESA_NO_ERROR="1", DROIDDECK_GAME_MESA_NO_ERROR="")
values = self.wrapper(session=session)
self.assertEqual(("unset", "unset"), (values["MESA_NO_ERROR"], values["DROIDDECK_GAME_MESA_NO_ERROR"]))
self.assertEqual(GPU_SESSION, {key: values[key] for key in GPU_SESSION})
self.assertEqual("1", self.wrapper("--chromium", session=session)["MESA_NO_ERROR"])
self.assertEqual("unset", self.flatpak(session)["MESA_NO_ERROR"])
self.assertEqual("1", self.wrapper(session={"MESA_NO_ERROR": "1"})["MESA_NO_ERROR"])
def test_without_the_game_setting_the_wrapper_changes_nothing(self):
self.assertEqual("sysmem", self.wrapper(session={"TU_DEBUG": "sysmem"})["TU_DEBUG"])
self.assertEqual("unset", self.wrapper(session={})["TU_DEBUG"])
+53
View File
@@ -0,0 +1,53 @@
import os
from pathlib import Path
import subprocess
import tempfile
import unittest
SESSION = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/droiddeck-session'
class GameResolutionTest(unittest.TestCase):
def launch(self, mode, **overrides):
source = SESSION.read_text()
start = source.index(' width=${BL_WIDTH:-1280}')
end = source.index('\nfi\n\nbl_displays()', start)
block = source[start:end].replace('/usr/local/bin/droiddeck-pipewire', 'pipewire_stub')
with tempfile.TemporaryDirectory() as directory:
env = dict(os.environ, XDG_RUNTIME_DIR=directory, BL_REFRESH='60', BL_MANGOAPP='0',
BL_WIDTH='2560', BL_HEIGHT='1600')
for name in ('BL_GAME_WIDTH', 'BL_GAME_HEIGHT', 'BL_FOLLOW_OUTPUT', 'BL_GAMESCOPE_STRETCH_16X9'):
env.pop(name, None)
env.update(overrides)
fake = Path(directory) / 'gamescope'
fake.write_text('#!/bin/bash\nprintf "ARG:%s\\n" "$@"\n')
fake.chmod(0o755)
env['PATH'] = directory + os.pathsep + env['PATH']
script = f'''
set -u
mode={mode}
pipewire_stub() {{ return 1; }}
run_gamescope() {{ printf 'ARG:%s\n' "$@"; }}
''' + block
result = subprocess.run(['bash', '-c', script], env=env, capture_output=True, text=True, timeout=5)
self.assertEqual(0, result.returncode, result.stderr)
return [line.removeprefix('ARG:') for line in result.stdout.splitlines() if line.startswith('ARG:')]
def test_a_game_started_without_steam_runs_at_its_resolution_with_proportions_kept(self):
args = self.launch('run', BL_GAME_WIDTH='1280', BL_GAME_HEIGHT='720')
self.assertEqual(['2560', '1600'], [args[args.index('-W') + 1], args[args.index('-H') + 1]])
self.assertEqual(['1280', '720'], [args[args.index('-w') + 1], args[args.index('-h') + 1]])
self.assertNotIn('-S', args)
def test_without_a_game_resolution_the_game_matches_the_output(self):
args = self.launch('run')
self.assertEqual(['2560', '1600'], [args[args.index('-w') + 1], args[args.index('-h') + 1]])
def test_steam_ignores_the_game_resolution(self):
args = self.launch('steam', BL_GAME_WIDTH='1280', BL_GAME_HEIGHT='720')
self.assertEqual(['2560', '1600'], [args[args.index('-w') + 1], args[args.index('-h') + 1]])
if __name__ == '__main__':
unittest.main()
+177 -26
View File
@@ -2,7 +2,7 @@ from pathlib import Path
import tempfile
import unittest
from tools.tests.test_client_zram_focus import function_source, run_bash
from tools.tests.test_client_zram_focus import SCRIPT, function_source, run_bash
class MemoryPressureTest(unittest.TestCase):
@@ -20,8 +20,8 @@ class MemoryPressureTest(unittest.TestCase):
def run_policy(self, body):
functions = '\n'.join(function_source(name) for name in (
'bl_memory_read', 'bl_memory_tight', 'bl_client_can_pageout',
'bl_client_can_readback', 'bl_client_pressure'))
'bl_memory_read', 'bl_memory_tight', 'bl_memory_critical', 'bl_client_can_pageout',
'bl_client_can_readback', 'bl_client_pressure', 'bl_client_pressure_result', 'bl_zram_has_room'))
functions = functions.replace('/proc/meminfo', str(self.root / 'meminfo'))
functions = functions.replace('/proc/pressure/memory', str(self.root / 'pressure'))
harness = '''
@@ -29,7 +29,7 @@ set -u
_bl_pids=(123) _bl_game=1 _bl_packed=-1 _bl_pressure_at=-1 _bl_pressure_backoff=30
rss=$((384 * 1024)) client_swap=$((512 * 1024)) reclaimed=$((128 * 1024))
step() { :; }
bl_zram_usage() { _bl_rss=$rss _bl_swap=$client_swap; }
bl_zram_usage() { _bl_rss=$rss _bl_anon=${anon:-$rss} _bl_swap=$client_swap; }
bl_zram_send() { echo "send:$1:$3"; rss=$((rss - reclaimed)); _bl_pageout_complete=${pageout_complete:-1}; }
''' + functions + '\nbl_memory_read\n' + body
result = run_bash('NOW=0\n' + harness.replace('SECONDS', 'NOW'))
@@ -80,6 +80,13 @@ if bl_client_can_readback; then echo yes; else echo no; fi
self.assertEqual(['no'], self.run_policy('''
bl_client_pressure
if bl_client_can_pageout; then echo yes; else echo no; fi
'''))
def test_client_swap_budget_excludes_file_backed_memory(self):
self.memory(swap_free=1536)
self.assertEqual(['send:1:client'], self.run_policy('''
rss=$((2048 * 1024)) anon=$((256 * 1024))
bl_client_pressure
'''))
def test_without_swap_automatic_pageout_is_disabled(self):
@@ -152,20 +159,20 @@ class SessionPressureTest(unittest.TestCase):
def run_policy(self, body):
functions = '\n'.join(function_source(name) for name in (
'bl_memory_read', 'bl_memory_tight', 'bl_memory_critical', 'bl_low_ram',
'bl_session_pressure', 'bl_watch_nap', 'bl_zram_pick', 'bl_tier_note', 'bl_tier_readback'))
'bl_memory_read', 'bl_memory_tight', 'bl_memory_critical',
'bl_session_pressure', 'bl_zram_has_room', 'bl_watch_nap', 'bl_zram_pick', 'bl_tier_note', 'bl_tier_readback'))
functions = functions.replace('/proc/meminfo', str(self.root / 'meminfo'))
functions = functions.replace('/proc/pressure/memory', str(self.root / 'pressure'))
harness = '''
set -u
_bl_game=1 _bl_tier_at=-1 _bl_tier_backoff=30 _bl_tier_pushed=0 _bl_tier_back=0 _bl_tier_targets=() _bl_tier_swaps=() _bl_tier_starts=() _bl_pids=(999)
_bl_pressure_at=-1 _bl_packed=-1
rss=$((1536 * 1024)) swap=0 pushed=$((1024 * 1024)) alive=999 started=100 complete=1
rss=$((1536 * 1024)) swap=0 pushed=$((1024 * 1024)) alive="999 321 654" started=100 complete=1
step() { :; }
bl_proc_start() { _bl_start=; case " $alive " in *" $1 "*) _bl_start=$started; return 0 ;; esac; return 1; }
nap() { echo "nap:$1"; }
bl_session_others() { _bl_session=(321 654); }
bl_zram_usage() { _bl_rss=$rss _bl_swap=$swap; }
bl_zram_usage() { _bl_rss=$rss _bl_anon=${anon:-$rss} _bl_swap=$swap; }
bl_zram_send() { echo "send:$1:$3"; rss=$((rss - pushed)); swap=$((swap + pushed)); _bl_pageout_complete=$complete; }
''' + functions + '\nbl_memory_read\n' + body
result = run_bash('NOW=0\n' + harness.replace('SECONDS', 'NOW'))
@@ -174,19 +181,27 @@ bl_zram_send() { echo "send:$1:$3"; rss=$((rss - pushed)); swap=$((swap + pushed
return result.stdout.splitlines()
def test_low_headroom_compresses_the_game_session_at_most_every_30_seconds(self):
self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy('''
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
SECONDS=0; bl_session_pressure
SECONDS=10; bl_session_pressure
SECONDS=29; bl_session_pressure
SECONDS=30; bl_session_pressure
'''))
def test_twelve_gigabyte_devices_are_included_and_larger_ones_are_not(self):
for total, expected in ((11264, ['send:1:game']), (12288, ['send:1:game']), (15360, [])):
def test_pressure_policy_is_independent_of_ram_size(self):
for total, expected in ((11264, ['send:1:session']), (12288, ['send:1:session']), (16384, ['send:1:session'])):
with self.subTest(total=total):
self.memory(total=total)
self.assertEqual(expected, self.run_policy('bl_session_pressure'))
def test_large_device_with_real_headroom_does_not_reclaim(self):
self.memory(total=16384, available=5120, psi='12.34')
self.assertEqual([], self.run_policy('bl_session_pressure'))
def test_large_device_with_psi_and_moderate_headroom_reclaims(self):
self.memory(total=16384, available=3072, psi='1.23')
self.assertEqual(['send:1:session'], self.run_policy('bl_session_pressure'))
def test_no_game_does_not_compress_the_session(self):
self.assertEqual([], self.run_policy('_bl_game=0; bl_session_pressure'))
@@ -196,15 +211,26 @@ SECONDS=30; bl_session_pressure
def test_stalls_with_moderate_headroom_compress_before_the_hard_limit(self):
self.memory(available=2048, psi='1.50')
self.assertEqual(['send:1:game'], self.run_policy('bl_session_pressure'))
self.assertEqual(['send:1:session'], self.run_policy('bl_session_pressure'))
def test_moderate_headroom_without_stalls_waits(self):
self.memory(available=2048)
self.assertEqual([], self.run_policy('bl_session_pressure'))
def test_same_second_memory_read_preserves_the_pressure_baseline(self):
self.memory(available=2048)
meminfo = self.root / 'meminfo'
self.assertEqual(['1048576:524288:2097152'], self.run_policy(f'''
SECONDS=100
_bl_sample_at=100 _bl_sample_available=2097152 _bl_growth=0 _bl_fall=524288
sed -i 's/MemAvailable: 2097152 kB/MemAvailable: 1048576 kB/' {meminfo}
bl_memory_read
echo "$_bl_available:$_bl_fall:$_bl_sample_available"
'''))
def test_game_reading_back_most_of_a_pageout_skips_and_doubles_the_wait(self):
self.assertEqual(['send:1:game', 'backoff:60', 'send:1:game', 'backoff:60',
'send:1:game', 'backoff:30'], self.run_policy('''
self.assertEqual(['send:1:session', 'backoff:60', 'send:1:session', 'backoff:60',
'send:1:session', 'backoff:30'], self.run_policy('''
pushed=$((512 * 1024))
SECONDS=0; bl_session_pressure
swap=$((swap / 4))
@@ -226,7 +252,7 @@ echo "backoff:$_bl_tier_backoff"
def test_nearly_out_of_memory_ignores_the_backoff_but_keeps_30_seconds(self):
self.memory(available=512)
self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy('''
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
_bl_tier_backoff=300
SECONDS=0; bl_session_pressure
SECONDS=20; bl_session_pressure
@@ -235,7 +261,7 @@ SECONDS=30; bl_session_pressure
def test_nearly_out_of_memory_still_backs_off_when_the_game_reads_its_pageout_back(self):
self.memory(available=512)
self.assertEqual(['send:1:game', 'backoff:60', 'send:1:game'], self.run_policy('''
self.assertEqual(['send:1:session', 'backoff:60', 'send:1:session'], self.run_policy('''
SECONDS=0; bl_session_pressure
swap=0
SECONDS=30; bl_session_pressure
@@ -247,7 +273,7 @@ SECONDS=90; bl_session_pressure
def test_nearly_out_of_memory_retries_a_skipped_pageout_after_30_seconds(self):
self.memory(available=512)
self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy('''
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
SECONDS=0; bl_session_pressure
swap=0
SECONDS=30; bl_session_pressure
@@ -263,6 +289,24 @@ SECONDS=360; bl_session_pressure
self.memory(swap_free=1536, swap_total=2048)
self.assertEqual([], self.run_policy('bl_session_pressure'))
def test_file_backed_resident_memory_does_not_consume_the_swap_budget(self):
self.memory(swap_free=3088, swap_total=6144)
self.assertEqual(['send:1:session'], self.run_policy('''
rss=$((4096 * 1024)) anon=$((1024 * 1024))
bl_session_pressure
'''))
def test_anonymous_memory_and_pending_client_still_need_the_full_swap_reserve(self):
self.memory(swap_free=3088, swap_total=6144)
self.assertEqual([], self.run_policy('''
rss=$((4096 * 1024)) anon=$((2048 * 1024))
bl_session_pressure
'''))
self.assertEqual([], self.run_policy('''
rss=$((4096 * 1024)) anon=$((1536 * 1024)) _bl_client_reserve=$((512 * 1024))
bl_session_pressure
'''))
def test_small_session_is_left_alone(self):
self.assertEqual([], self.run_policy('rss=$((128 * 1024)); bl_session_pressure'))
@@ -275,10 +319,10 @@ SECONDS=360; bl_session_pressure
self.assertEqual(['nap:5'], self.run_policy('bl_watch_nap'))
self.assertEqual(['nap:5'], self.run_policy('_bl_game=0; bl_watch_nap'))
def test_one_push_compresses_the_game_and_the_launcher_and_restarts_the_launcher_wait(self):
self.assertEqual(['send:1:game', 'pids:321 654 999', 'client:0:0'], self.run_policy('''
def test_session_push_preserves_client_timestamps(self):
self.assertEqual(['send:1:session', 'pids:321 654', 'client:-1:-1'], self.run_policy('''
SECONDS=0; bl_session_pressure
bl_zram_pick game; echo "pids:${_pids[*]}"
bl_zram_pick session; echo "pids:${_pids[*]}"
echo "client:$_bl_pressure_at:$_bl_packed"
'''))
@@ -286,19 +330,19 @@ echo "client:$_bl_pressure_at:$_bl_packed"
self.assertEqual(['pids:321 654', 'client:-1:-1'], self.run_policy('''
BL_ZRAM_CLIENT=0
SECONDS=0; bl_session_pressure
bl_zram_pick game; echo "pids:${_pids[*]}"
bl_zram_pick session; echo "pids:${_pids[*]}"
echo "client:$_bl_pressure_at:$_bl_packed"
''')[1:])
def test_low_ram_devices_compress_with_a_quarter_of_memory_left(self):
self.memory(available=1700)
self.assertEqual(['send:1:game'], self.run_policy('bl_session_pressure'))
self.assertEqual(['send:1:session'], self.run_policy('bl_session_pressure'))
self.memory(available=1900)
self.assertEqual([], self.run_policy('bl_session_pressure'))
def test_a_compressed_process_that_exits_is_not_counted_as_read_back(self):
self.assertEqual(['send:1:game', 'send:1:game', 'backoff:30'], self.run_policy('''
self.assertEqual(['send:1:session', 'send:1:session', 'backoff:30'], self.run_policy('''
SECONDS=0; bl_session_pressure
alive=""; swap=0
SECONDS=30; bl_session_pressure
@@ -306,7 +350,7 @@ echo "backoff:$_bl_tier_backoff"
'''))
def test_a_process_that_starts_after_a_pageout_is_not_in_its_read_back(self):
self.assertEqual(['send:1:game', 'targets:999', 'send:1:game', 'backoff:30'], self.run_policy('''
self.assertEqual(['send:1:session', 'targets:321 654', 'send:1:session', 'backoff:30'], self.run_policy('''
SECONDS=0; bl_session_pressure
echo "targets:${_bl_tier_targets[*]}"
alive="999 1234"
@@ -315,7 +359,7 @@ echo "backoff:$_bl_tier_backoff"
'''))
def test_an_incomplete_pageout_does_not_restart_the_launcher_wait(self):
self.assertEqual(['send:1:game', 'client:-1:-1'], self.run_policy('''
self.assertEqual(['send:1:session', 'client:-1:-1'], self.run_policy('''
complete=0
SECONDS=0; bl_session_pressure
echo "client:$_bl_pressure_at:$_bl_packed"
@@ -323,7 +367,7 @@ echo "client:$_bl_pressure_at:$_bl_packed"
def test_a_reused_process_id_is_not_counted_as_read_back(self):
self.assertEqual(['send:1:game', 'send:1:game', 'backoff:30'], self.run_policy('''
self.assertEqual(['send:1:session', 'send:1:session', 'backoff:30'], self.run_policy('''
SECONDS=0; bl_session_pressure
started=200; swap=0
SECONDS=30; bl_session_pressure
@@ -344,5 +388,112 @@ echo "backoff:$_bl_tier_backoff"
self.assertEqual(['gone'], result.stdout.split())
class ReclaimDispatchTest(unittest.TestCase):
def run_cycle(self, client=1, game=1, anonymous=384, complete=1, reclaimed=128, body=None, available=1024, fall=0, tick=0):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
(root / 'meminfo').write_text(
f'MemTotal: 7340032 kB\nMemAvailable: {available * 1024} kB\n'
'SwapTotal: 6291456 kB\nSwapFree: 4194304 kB\n')
(root / 'pressure').write_text('some avg10=0.00 avg60=0.00 avg300=0.00 total=0\n')
names = ('bl_memory_read', 'bl_memory_tight', 'bl_memory_critical',
'bl_zram_has_room', 'bl_client_can_pageout', 'bl_client_pressure',
'bl_client_pressure_result', 'bl_client_pressure_finish',
'bl_session_pressure', 'bl_zram_send', 'bl_zram_finish', 'bl_zram_pick')
source = '\n'.join(function_source(name) for name in names)
source = source.replace('/proc/meminfo', str(root / 'meminfo'))
source = source.replace('/proc/pressure/memory', str(root / 'pressure'))
source = source.replace('/tmp/.bl-zram', str(root / 'ctl'))
monitor = SCRIPT.read_text()
start = monitor.index(' _bl_preserved_growth=$_bl_growth', monitor.index('while kill -0 $$'))
stop = monitor.index(' if [ "$_bl_game" = 1 ] && bl_game_focused', start)
cycle = monitor[start:stop] if body is None else body
script = f'''
set -u
BL_ZRAM_CLIENT={client} _bl_game={game} _bl_pids=(123) _bl_others=(321)
_bl_pressure_at=-1 _bl_pressure_backoff=30 _bl_packed=-1
_bl_tier_at=-1 _bl_tier_backoff=30 _bl_tier_pushed=0
_bl_client_reserve=0 client_rss=393216 client_anon={anonymous * 1024}
step() {{ :; }}
bl_session_others() {{ _bl_session=(321); }}
bl_zram_scan() {{ _bl_pids=(456); }}
nap() {{ echo "nap:$*:at:$NOW"; }}
bl_zram_usage() {{
if [ "$1" = 123 ]; then
_bl_rss=$client_rss _bl_anon=$client_anon _bl_swap=0
else
_bl_rss=3145728 _bl_anon=1572864 _bl_swap=0
fi
}}
kill() {{ echo "signal:$*:at:$NOW"; NOW=$((NOW + {tick})); }}
bl_zram_wait() {{
echo "wait:$*:at:$NOW"
NOW=$((NOW + 12))
_bl_pageout_complete={complete}
[ "$1" != 123 ] || client_rss=$((client_rss - {reclaimed * 1024}))
}}
bl_tier_note() {{ :; }}
''' + source + f'''
bl_memory_read
_bl_fall={fall * 1024}
''' + cycle + '''
echo "client:$_bl_pressure_backoff:${_bl_client_reserve:-0}:${_bl_client_pending:-0}"
'''
result = run_bash('NOW=0\n' + script.replace('SECONDS', 'NOW'))
self.assertEqual(0, result.returncode, result.stderr)
self.assertEqual('', result.stderr)
return result.stdout.splitlines()
def test_both_requests_are_sent_before_either_wait(self):
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:0',
'wait:321:at:0', 'wait:123:at:12', 'client:30:0:0'], self.run_cycle())
def test_disabled_client_is_never_signalled_or_waited_for(self):
self.assertEqual(['signal:-URG 321:at:0', 'wait:321:at:0', 'client:30:0:0'],
self.run_cycle(client=0))
def test_no_game_requests_nothing(self):
self.assertEqual(['client:30:0:0'], self.run_cycle(game=0))
def test_a_client_with_no_anonymous_pages_still_finishes_its_request(self):
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:0',
'wait:321:at:0', 'wait:123:at:12', 'client:30:0:0'],
self.run_cycle(anonymous=0))
def test_falling_headroom_survives_a_tick_between_requests(self):
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:1',
'wait:321:at:2', 'wait:123:at:14', 'client:30:0:0'],
self.run_cycle(available=2304, fall=512, tick=1))
def test_deferred_ineffective_reclaim_still_doubles_the_backoff(self):
self.assertEqual('client:60:0:0', self.run_cycle(reclaimed=0)[-1])
def test_deferred_incomplete_reclaim_does_not_double_the_backoff(self):
self.assertEqual('client:30:0:0', self.run_cycle(reclaimed=0, complete=0)[-1])
def test_explicit_combined_send_keeps_its_synchronous_wait(self):
self.assertEqual(['signal:-URG 321 123:at:0', 'wait:321 123:at:0', 'client:30:0:0'],
self.run_cycle(body='bl_zram_send 1 cap game\n'))
self.assertEqual(['signal:-URG 321:at:0', 'wait:321:at:0', 'client:30:0:0'],
self.run_cycle(client=0, body='bl_zram_send 1 cap game\n'))
def test_readback_keeps_its_synchronous_delay(self):
self.assertEqual(['signal:-URG 123:at:0', 'nap:5:at:0', 'client:30:0:0'],
self.run_cycle(body='bl_zram_send 0 readback client\n'))
def test_usage_sums_anonymous_rss_and_falls_back_per_process(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
for pid, contents in ((123, 'VmRSS: 2000 kB\nRssAnon: 300 kB\nVmSwap: 100 kB\n'),
(321, 'VmRSS: 4000 kB\nVmSwap: 200 kB\n'),
(654, 'VmRSS: 1000 kB\nRssAnon: 0 kB\n')):
(root / str(pid)).mkdir()
(root / str(pid) / 'status').write_text(contents)
source = function_source('bl_zram_usage').replace('/proc/', str(root) + '/')
result = run_bash(source + '\nbl_zram_usage 123 321 654 > /dev/null; echo "$_bl_rss:$_bl_anon:$_bl_swap"')
self.assertEqual(0, result.returncode, result.stderr)
self.assertEqual('7000:4300:300', result.stdout.strip())
if __name__ == '__main__':
unittest.main()
+224
View File
@@ -0,0 +1,224 @@
import os
from pathlib import Path
import subprocess
import tempfile
import unittest
from tools.tests.test_usr2_preload import runner
HOOK_BUILD = Path(__file__).resolve().parents[1] / "nativeguest/build.sh"
PROBE = r"""
#include <dirent.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
int main(int argc, char **argv) {
char cwd[4096];
for (int i = 1; i < argc; i++) {
struct stat st;
if (strncmp(argv[i], "cd:", 3) == 0) {
int ok = chdir(argv[i] + 3) == 0 && getcwd(cwd, sizeof(cwd)) != NULL;
printf("%s\t%s\n", argv[i], ok ? cwd : "-");
continue;
}
if (strncmp(argv[i], "at:", 3) == 0) {
int dfd = open(argv[i] + 3, O_RDONLY | O_DIRECTORY);
printf("%s\t%d\t%d\n", argv[i], fstatat(AT_FDCWD, argv[i] + 3, &st, 0) == 0, dfd >= 0);
if (dfd >= 0) close(dfd);
continue;
}
if (strncmp(argv[i], "ls:", 3) == 0) {
DIR *dir = opendir(argv[i] + 3);
char names[1024] = "";
struct dirent *de;
while (dir && (de = readdir(dir)) != NULL) {
if (de->d_name[0] == '.') continue;
if (names[0]) strncat(names, ",", sizeof(names) - strlen(names) - 1);
strncat(names, de->d_name, sizeof(names) - strlen(names) - 1);
}
if (dir) closedir(dir);
printf("%s\t%s\n", argv[i], dir ? names : "-");
continue;
}
int fd = open(argv[i], O_RDONLY);
char data[64] = "-";
if (fd >= 0) {
ssize_t n = read(fd, data, sizeof(data) - 1);
data[n > 0 ? n : 0] = 0;
close(fd);
}
printf("%s\t%d\t%s\n", argv[i], stat(argv[i], &st) == 0, data);
}
return 0;
}
"""
GAME = "/mnt/library/Some Game"
class NativeHookMountTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.cc, cls.prefix = runner()
if cls.cc is None:
raise unittest.SkipTest("no aarch64 compiler and runner")
cls.tmp = tempfile.TemporaryDirectory()
tmp = Path(cls.tmp.name)
cls.hook = tmp / "hook.so"
subprocess.run(["bash", str(HOOK_BUILD), str(cls.hook), cls.cc], check=True, capture_output=True)
(tmp / "probe.c").write_text(PROBE)
subprocess.run([cls.cc, "-O1", "-o", str(tmp / "probe"), str(tmp / "probe.c")], check=True)
cls.probe = tmp / "probe"
cls.root = tmp / "root"
cls.library = tmp / "storage/PC GAMES"
(cls.root / "etc").mkdir(parents=True)
(cls.root / "etc/hostname").write_text("rootfs")
(cls.root / "mnt/library/Some Game").mkdir(parents=True)
(cls.root / "mnt/library/Some Game/game.txt").write_text("mount point")
(cls.library / "Some Game").mkdir(parents=True)
(cls.library / "Some Game/game.txt").write_text("library")
for name, target in (("native", str(cls.root)), ("guest", "/")):
devices = cls.root / "pfx" / name / "dosdevices"
devices.mkdir(parents=True)
os.symlink(target, devices / "z:")
relinked = cls.root / "pfx/relinked"
(relinked / "dosdevices").mkdir(parents=True)
(relinked / "drive_c").mkdir()
(relinked / "drive_c/c.txt").write_text("drive c")
os.symlink(os.path.relpath(cls.root, relinked / "dosdevices"), relinked / "dosdevices/z:")
os.symlink("../drive_c", relinked / "dosdevices/c:")
copied = cls.root / "pfx/copied/dosdevices"
copied.mkdir(parents=True)
os.symlink("../" * 12 + "..", copied / "z:")
elsewhere = tmp / "elsewhere"
(elsewhere / "outside/pfx/dosdevices").mkdir(parents=True)
(elsewhere / "mnt/library/Some Game").mkdir(parents=True)
(elsewhere / "mnt/library/Some Game/game.txt").write_text("elsewhere")
os.symlink("../../..", elsewhere / "outside/pfx/dosdevices/z:")
os.symlink(str(elsewhere / "outside/pfx"), cls.root / "pfx/outside")
cls.private = tmp / "private"
private_pfx = cls.private / "123/pfx/dosdevices"
private_pfx.mkdir(parents=True)
os.symlink(os.path.relpath("/", "/mnt/private/123/pfx/dosdevices"), private_pfx / "z:")
private_copy = cls.private / "456/pfx/dosdevices"
private_copy.mkdir(parents=True)
os.symlink("../" * 12 + "..", private_copy / "z:")
cls.eqlen_src = tmp / "eqsrcdir"
cls.eqlen_dst = "/" + "d" * (len(str(cls.eqlen_src)) - 1)
eqlen_pfx = cls.eqlen_src / "123/pfx/dosdevices"
eqlen_pfx.mkdir(parents=True)
os.symlink(os.path.relpath("/", f"{cls.eqlen_dst}/123/pfx/dosdevices"), eqlen_pfx / "z:")
@classmethod
def tearDownClass(cls):
cls.tmp.cleanup()
def run_probe(self, *args):
binds = f"{self.library}:/mnt/library|{self.private}:/mnt/private|{self.eqlen_src}:{self.eqlen_dst}"
hook_env = {"DDNATV_ROOT": str(self.root), "DDNATV_BINDS": binds, "LD_PRELOAD": str(self.hook)}
env = {k: v for k, v in os.environ.items() if k != "LD_PRELOAD"}
if self.prefix:
cmd = list(self.prefix) + [arg for key, value in hook_env.items() for arg in ("-E", f"{key}={value}")]
else:
cmd = []
env.update(hook_env)
out = subprocess.run(cmd + [str(self.probe), *args], env=env, capture_output=True, text=True, timeout=120,
cwd=self.tmp.name)
self.assertEqual(out.returncode, 0, out.stderr)
return {line.split("\t")[0]: line.split("\t")[1:] for line in out.stdout.splitlines()}
def test_drive_link_stored_as_rootfs_path_reaches_the_mount(self):
path = f"/pfx/native/dosdevices/z:{GAME}/game.txt"
self.assertEqual(self.run_probe(path)[path], ["1", "library"])
def test_working_directory_through_a_drive_link_is_the_mount(self):
arg = f"cd:/pfx/native/dosdevices/z:{GAME}/"
self.assertEqual(self.run_probe(arg)[arg], [GAME])
def test_rootfs_path_under_a_mount_point_reaches_the_mount(self):
path = f"{self.root}{GAME}/game.txt"
self.assertEqual(self.run_probe(path)[path], ["1", "library"])
def test_guest_drive_link_is_unchanged(self):
path = f"/pfx/guest/dosdevices/z:{GAME}/game.txt"
self.assertEqual(self.run_probe(path)[path], ["1", "library"])
def test_rootfs_paths_outside_mounts_are_unchanged(self):
paths = ["/pfx/native/dosdevices/z:/etc/hostname", f"{self.root}/etc/hostname", "/etc/hostname"]
result = self.run_probe(*paths)
for path in paths:
self.assertEqual(result[path], ["1", "rootfs"], path)
def test_wine_lookup_steps_reach_the_mount(self):
for pfx in ("/pfx/native", "/pfx/guest", "/pfx/relinked", f"{self.root}/pfx/native", f"{self.root}/pfx/guest",
f"{self.root}/pfx/relinked"):
drive = f"{pfx}/dosdevices/z:"
args = [f"at:{drive}{GAME}/", f"at:{drive}{GAME}", f"ls:{drive}/mnt/library", f"ls:{drive}{GAME}"]
result = self.run_probe(*args)
self.assertEqual(result[args[0]], ["1", "1"], pfx)
self.assertEqual(result[args[1]], ["1", "1"], pfx)
self.assertEqual(result[args[2]], ["Some Game"], pfx)
self.assertEqual(result[args[3]], ["game.txt"], pfx)
def test_relative_drive_link_reaches_the_mount(self):
path = f"/pfx/relinked/dosdevices/z:{GAME}/game.txt"
cd = f"cd:/pfx/relinked/dosdevices/z:{GAME}/"
result = self.run_probe(path, cd)
self.assertEqual(result[path], ["1", "library"])
self.assertEqual(result[cd], [GAME])
def test_relative_links_outside_mounts_are_unchanged(self):
paths = ["/pfx/relinked/dosdevices/z:/etc/hostname", "/pfx/relinked/dosdevices/c:/c.txt",
f"{self.root}/pfx/relinked/dosdevices/c:/c.txt"]
result = self.run_probe(*paths)
self.assertEqual(result[paths[0]], ["1", "rootfs"])
self.assertEqual(result[paths[1]], ["1", "drive c"])
self.assertEqual(result[paths[2]], ["1", "drive c"])
def test_suffix_after_a_relative_link_is_not_collapsed(self):
path = "/pfx/relinked/dosdevices/z:/mnt/library/missing/../Some Game/game.txt"
self.assertEqual(self.run_probe(path)[path], ["0", "-"])
def test_relative_drive_link_climbing_past_the_root_reaches_the_mount(self):
path = f"/pfx/copied/dosdevices/z:{GAME}/game.txt"
cd = f"cd:/pfx/copied/dosdevices/z:{GAME}/"
result = self.run_probe(path, cd)
self.assertEqual(result[path], ["1", "library"])
self.assertEqual(result[cd], [GAME])
def test_relative_link_climbing_past_the_root_stays_in_the_rootfs(self):
path = "/pfx/copied/dosdevices/z:/etc/hostname"
self.assertEqual(self.run_probe(path)[path], ["1", "rootfs"])
def test_relative_link_is_resolved_from_its_real_directory(self):
path = f"/pfx/outside/dosdevices/z:{GAME}/game.txt"
self.assertEqual(self.run_probe(path)[path], ["1", "elsewhere"])
def test_drive_link_in_a_bound_prefix_reaches_the_mount(self):
path = f"/mnt/private/123/pfx/dosdevices/z:{GAME}/game.txt"
cd = f"cd:/mnt/private/123/pfx/dosdevices/z:{GAME}/"
result = self.run_probe(path, cd)
self.assertEqual(result[path], ["1", "library"])
self.assertEqual(result[cd], [GAME])
def test_drive_link_copied_into_a_bound_prefix_reaches_the_mount(self):
path = f"/mnt/private/456/pfx/dosdevices/z:{GAME}/game.txt"
cd = f"cd:/mnt/private/456/pfx/dosdevices/z:{GAME}/"
result = self.run_probe(path, cd)
self.assertEqual(result[path], ["1", "library"])
self.assertEqual(result[cd], [GAME])
def test_drive_link_in_equal_length_bound_prefix_reaches_the_mount(self):
path = f"{self.eqlen_dst}/123/pfx/dosdevices/z:{GAME}/game.txt"
cd = f"cd:{self.eqlen_dst}/123/pfx/dosdevices/z:{GAME}/"
result = self.run_probe(path, cd)
self.assertEqual(result[path], ["1", "library"])
self.assertEqual(result[cd], [GAME])
if __name__ == "__main__":
unittest.main()
+241
View File
@@ -0,0 +1,241 @@
from pathlib import Path
import runpy
import struct
import tempfile
import unittest
BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin'
MODULE = runpy.run_path(str(BIN / 'droiddeck-pace-cores'))
Frames = MODULE['Frames']
Parker = MODULE['Parker']
Governor = MODULE['Governor']
efficient_cores = MODULE['efficient_cores']
paced_interval = MODULE['paced_interval']
ALL = set(range(8))
EFFICIENT = set(range(6))
VBLANK = 1e9 / 60
CAPACITY = 1024
class FakeCores:
def __init__(self, tids):
self.state = {tid: set(ALL) for tid in tids}
def get(self, tid):
if tid not in self.state:
raise ProcessLookupError(tid)
return set(self.state[tid])
def set(self, tid, cpus):
if tid not in self.state:
raise ProcessLookupError(tid)
self.state[tid] = set(cpus)
class FeedWriter:
def __init__(self, path):
self.path = path
self.count = 0
self.data = bytearray(128 + CAPACITY * 16)
struct.pack_into('<IIII', self.data, 0, 0x46484444, 1, CAPACITY, 0)
def focus(self, pid, steam=False):
struct.pack_into('<I', self.data, 12, pid)
struct.pack_into('<IIII', self.data, 28, 1920, 1080, 60000, 1 if steam else 0)
self.flush()
def frames(self, *intervals):
for value in intervals:
struct.pack_into('<QQ', self.data, 128 + (self.count % CAPACITY) * 16, int(value), 0)
self.count += 1
struct.pack_into('<Q', self.data, 16, self.count)
self.flush()
def flush(self):
self.path.write_bytes(bytes(self.data))
class PacedIntervalTest(unittest.TestCase):
def test_a_steady_cap_at_30_fps_or_more_is_paced(self):
self.assertAlmostEqual(paced_interval([VBLANK] * 60), VBLANK)
self.assertAlmostEqual(paced_interval([1e9 / 30] * 30), 1e9 / 30)
jitter = [1e9 / 60 * (1 + 0.03 * (-1) ** i) for i in range(60)]
self.assertIsNotNone(paced_interval(jitter))
def test_under_30_fps_is_not(self):
self.assertIsNone(paced_interval([1e9 / 24] * 24))
self.assertIsNone(paced_interval([1e9 / 15] * 15))
def test_a_spread_or_missed_frames_are_not(self):
self.assertIsNone(paced_interval([VBLANK] * 50 + [2 * VBLANK] * 10))
self.assertIsNone(paced_interval([VBLANK * (0.8 + 0.4 * (i % 5) / 4) for i in range(60)]))
self.assertIsNone(paced_interval([]))
class EfficientCoresTest(unittest.TestCase):
def test_everything_below_the_top_capacity(self):
with tempfile.TemporaryDirectory() as temp:
cpu = Path(temp)
(cpu / 'online').write_text('0-7\n')
for core in ALL:
(cpu / f'cpu{core}').mkdir()
(cpu / f'cpu{core}/cpu_capacity').write_text('1024\n' if core >= 6 else '792\n')
self.assertEqual(efficient_cores(cpu, set(ALL)), EFFICIENT)
self.assertEqual(efficient_cores(cpu, {6, 7}), set())
def test_one_tier_has_none(self):
with tempfile.TemporaryDirectory() as temp:
cpu = Path(temp)
(cpu / 'online').write_text('0-3\n')
for core in range(4):
(cpu / f'cpu{core}').mkdir()
(cpu / f'cpu{core}/cpu_capacity').write_text('1024\n')
self.assertEqual(efficient_cores(cpu, set(range(4))), set())
class GovernorTest(unittest.TestCase):
PID = 400
TIDS = (400, 401, 402)
def setUp(self):
temp = tempfile.TemporaryDirectory()
self.addCleanup(temp.cleanup)
root = Path(temp.name)
for tid in self.TIDS:
(root / f'proc/{self.PID}/task/{tid}').mkdir(parents=True)
self.cores = FakeCores(self.TIDS)
self.feed = FeedWriter(root / 'frames')
self.feed.focus(self.PID)
self.now = 0.0
self.governor = Governor(Frames(root / 'frames'), Parker(EFFICIENT, root / 'proc', self.cores),
clock=lambda: self.now)
self.governor.tick()
def run_for(self, seconds, interval):
for _ in range(int(seconds / 0.5)):
self.now += 0.5
self.feed.frames(*([interval] * int(0.5e9 / interval)))
self.governor.tick()
def test_parks_a_game_that_holds_its_pace(self):
self.run_for(4, VBLANK)
self.assertEqual(self.governor.parker.pid, self.PID)
self.assertTrue(all(cpus == EFFICIENT for cpus in self.cores.state.values()))
def test_releases_when_frames_fall_behind_and_backs_off(self):
self.run_for(4, VBLANK)
self.run_for(2, 2 * VBLANK)
self.assertIsNone(self.governor.parker.pid)
self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values()))
self.run_for(10, VBLANK)
self.assertIsNone(self.governor.parker.pid)
self.run_for(30, VBLANK)
self.assertEqual(self.governor.parker.pid, self.PID)
def test_struggling_game_stays_on_every_core(self):
for step in range(20):
self.now += 0.5
self.feed.frames(*([VBLANK, 2 * VBLANK] * 10))
self.governor.tick()
self.assertIsNone(self.governor.parker.pid)
self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values()))
def test_steam_in_front_releases_without_backoff(self):
self.run_for(4, VBLANK)
self.feed.focus(self.PID, steam=True)
self.now += 0.5
self.governor.tick()
self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values()))
self.feed.focus(self.PID)
self.run_for(4, VBLANK)
self.assertEqual(self.governor.parker.pid, self.PID)
def test_a_mask_the_game_set_itself_is_kept(self):
self.run_for(4, VBLANK)
self.cores.state[401] = {7}
self.run_for(2, 2 * VBLANK)
self.assertEqual(self.cores.state[401], {7})
self.assertEqual(self.cores.state[400], ALL)
def idle_for(self, seconds):
for _ in range(int(seconds / 0.5)):
self.now += 0.5
self.governor.tick()
def test_thread_born_parked_is_restored(self):
self.run_for(4, VBLANK)
(self.governor.parker.proc / f'{self.PID}/task/403').mkdir()
self.cores.state[403] = set(EFFICIENT)
self.run_for(1, VBLANK)
self.run_for(2, 2 * VBLANK)
self.assertEqual(self.cores.state[403], ALL)
def test_a_thread_already_on_efficient_cores_keeps_its_mask(self):
self.cores.state[402] = set(EFFICIENT)
self.run_for(4, VBLANK)
self.run_for(1, VBLANK)
self.run_for(2, 2 * VBLANK)
self.assertEqual(self.cores.state[402], EFFICIENT)
self.assertEqual(self.cores.state[400], ALL)
def test_a_child_of_a_game_pinned_thread_keeps_its_mask(self):
self.cores.state[402] = set(EFFICIENT)
self.run_for(4, VBLANK)
(self.governor.parker.proc / f'{self.PID}/task/404').mkdir()
self.cores.state[404] = set(EFFICIENT)
self.run_for(1, VBLANK)
self.run_for(2, 2 * VBLANK)
self.assertEqual(self.cores.state[404], EFFICIENT)
self.assertEqual(self.cores.state[400], ALL)
def test_a_child_of_a_game_pinned_thread_that_exited_keeps_its_mask(self):
self.cores.state[402] = set(EFFICIENT)
self.run_for(4, VBLANK)
(self.governor.parker.proc / f'{self.PID}/task/402').rmdir()
del self.cores.state[402]
(self.governor.parker.proc / f'{self.PID}/task/404').mkdir()
self.cores.state[404] = set(EFFICIENT)
self.run_for(1, VBLANK)
self.run_for(2, 2 * VBLANK)
self.assertEqual(self.cores.state[404], EFFICIENT)
self.assertEqual(self.cores.state[400], ALL)
def test_born_parked_thread_gets_every_original_it_could_have_had(self):
for tid in self.TIDS:
self.cores.state[tid] = EFFICIENT | {6}
self.cores.state[402] = EFFICIENT | {7}
self.run_for(4, VBLANK)
(self.governor.parker.proc / f'{self.PID}/task/404').mkdir()
self.cores.state[404] = set(EFFICIENT)
self.run_for(1, VBLANK)
self.run_for(2, 2 * VBLANK)
self.assertEqual(self.cores.state[404], ALL)
self.assertEqual(self.cores.state[402], EFFICIENT | {7})
def test_a_stalled_game_is_not_parked_on_old_frames(self):
self.run_for(0.5, VBLANK)
self.idle_for(3)
self.assertIsNone(self.governor.parker.pid)
self.run_for(2, VBLANK)
self.assertIsNone(self.governor.parker.pid)
def test_a_parked_game_that_stops_presenting_is_released(self):
self.run_for(4, VBLANK)
self.run_for(1, 1e9)
self.idle_for(1)
self.assertIsNone(self.governor.parker.pid)
self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values()))
def test_threads_pinned_to_fast_cores_are_left_alone(self):
self.cores.state[402] = {6, 7}
self.run_for(4, VBLANK)
self.assertEqual(self.cores.state[402], {6, 7})
self.assertEqual(self.cores.state[400], EFFICIENT)
if __name__ == '__main__':
unittest.main()
+24
View File
@@ -150,6 +150,30 @@ class PreloadSnapshotTest(unittest.TestCase):
with self.assertRaisesRegex(ValueError, 'successful main'):
snapshots.artifact_bytes(self.data['origin'], self.root / 'cache')
def test_origin_apk_without_a_newer_output_reads_the_rest(self):
from zipfile import ZipFile
newest = 'libddnatv-hook.so'
apk = io.BytesIO()
with ZipFile(apk, 'w') as z:
for name, value in self.binaries.items():
if name != newest:
z.writestr('assets/linuxfs/' + name, value)
outer = io.BytesIO()
with ZipFile(outer, 'w') as z:
z.writestr('app-release.apk', apk.getvalue())
digest = snapshots.sha(outer.getvalue())
origin = dict(self.data['origin'], artifact_sha256=digest)
build = dict(event='push', head_branch='main', conclusion='success', head_sha=origin['commit'],
path='.github/workflows/build.yml', repository=dict(full_name=snapshots.REPO))
artifact = dict(name='droiddeck-apk', workflow_run=dict(id=origin['run']), digest='sha256:' + digest)
cache = self.root / 'cache'
cache.mkdir()
(cache / (digest + '.zip')).write_bytes(outer.getvalue())
with patch.object(snapshots, 'api', side_effect=[build, artifact]):
content = snapshots.artifact_bytes(origin, cache)
self.assertNotIn(newest, content)
self.assertEqual(set(content), snapshots.FILES - {newest})
def test_corrupt_archive_is_rejected(self):
with self.assertRaisesRegex(ValueError, 'checksum'):
snapshots.unpack(self.content + b'tampered', self.data)
+10
View File
@@ -33,6 +33,9 @@ class RuntimeInputsTest(unittest.TestCase):
self.source = self.root / 'tools/linuxfs/preload/test.c'
self.source.parent.mkdir(parents=True)
self.source.write_text('current source')
service = self.root / 'app/src/main/assets/linuxfs/usr/local/lib/droiddeck-ubisoft/droiddeck-upc.exe'
service.parent.mkdir(parents=True)
service.write_bytes(b'MZ service')
self.audio(['pactl', 'modules/arm64/module-aaudio-sink.so', 'modules/arm64/module-directaudio-native-sink.so'])
self.packs()
@@ -179,6 +182,13 @@ class RuntimeInputsTest(unittest.TestCase):
with self.assertRaisesRegex(ValueError, 'xbox pack provides'):
runtime.check_apk(apk, self.root)
def test_an_apk_still_carrying_the_ubisoft_service_is_rejected(self):
name = 'assets/linuxfs/usr/local/lib/droiddeck-ubisoft/droiddeck-upc.exe'
self.assertIn(name, runtime.outputs(self.root))
apk = self.current_apk(self.root / 'bundled.apk', {name: b'MZ service'})
with self.assertRaisesRegex(ValueError, 'ubisoft pack provides'):
runtime.check_apk(apk, self.root)
def test_an_apk_still_carrying_the_powervr_runtime_is_rejected(self):
apk = self.current_apk(self.root / 'bundled.apk', {'assets/hybris/runtime.tzst': b'runtime'})
with self.assertRaisesRegex(ValueError, 'powervr pack provides'):
+118
View File
@@ -2,6 +2,7 @@ import os
import shutil
import subprocess
import tempfile
import time
import unittest
from pathlib import Path
@@ -128,6 +129,67 @@ class SeedRedistsTest(unittest.TestCase):
self.run_seed(str(sd))
self.assertIn('"VCRedist2022"=dword:00000001', self.reg.read_text())
def manifest(self, name, build):
path = self.steam / "steamapps/appmanifest_77.acf"
path.write_text('"AppState"\n{\n\t"installdir"\t\t"%s"\n\t"buildid"\t\t"%s"\n}\n' % (name, build))
return path
def test_a_game_is_searched_again_only_when_its_build_changes(self):
late = self.steam / "steamapps/common/Late Game/installscript.vdf"
late.parent.mkdir(parents=True)
manifest = self.manifest("Late Game", "1")
self.run_seed()
late.write_text(GAME_SCRIPT)
manifest.write_text(manifest.read_text() + "\n")
self.run_seed()
self.assertNotIn("VCRedist2022", self.reg.read_text())
self.manifest("Late Game", "2")
self.run_seed()
self.assertIn('"VCRedist2022"=dword:00000001', self.reg.read_text())
def test_one_changed_game_leaves_the_other_games_unsearched(self):
other = self.game("Other Game").parent / "installscript_extra.vdf"
self.manifest("Late Game", "1")
self.run_seed()
other.write_text(GAME_SCRIPT.replace("VCRedist2022", "Unsearched"))
self.manifest("Late Game", "2")
self.run_seed()
self.assertNotIn("Unsearched", self.reg.read_text())
def test_a_call_that_names_its_scripts_does_not_search_the_libraries(self):
script = self.game()
named = self.tmp / "legacycompat/evaluatorscript_1.vdf"
named.parent.mkdir(parents=True)
named.write_text(GAME_SCRIPT.replace("VCRedist2022", "Named"))
env = dict(os.environ, DROIDDECK_LIBRARIES="", DROIDDECK_SEED_SCRIPTS=str(named))
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, capture_output=True, text=True, check=True)
reg = self.reg.read_text()
self.assertIn('"Named"=dword:00000001', reg)
self.assertNotIn("VCRedist2022", reg)
self.run_seed()
self.assertIn('"VCRedist2022"=dword:00000001', self.reg.read_text())
self.assertIn(str(script), (self.steam / ".droiddeck-game-scripts").read_text())
def test_a_removed_game_leaves_the_list(self):
script = self.game()
self.run_seed()
cache = self.steam / ".droiddeck-game-scripts"
self.assertIn(str(script), cache.read_text())
for manifest in (self.steam / "steamapps").glob("appmanifest_*.acf"):
manifest.unlink()
self.run_seed()
self.assertEqual("", cache.read_text())
def test_a_list_from_an_earlier_version_is_taken_over_without_a_search(self):
script = self.steam / "steamapps/common/Old Game/a/b/c/d/e/installscript.vdf"
script.parent.mkdir(parents=True)
script.write_text(GAME_SCRIPT)
self.manifest("Old Game", "1")
(self.steam / ".droiddeck-game-scripts").write_text("123 456\n%s\n" % script)
self.run_seed()
self.assertIn('"VCRedist2022"=dword:00000001', self.reg.read_text())
self.assertIn("\t%s\n" % script, (self.steam / ".droiddeck-game-scripts").read_text())
def test_current_user_and_machine_markers_go_to_their_own_registries(self):
self.game(script=GAME_SCRIPT + GAME_SCRIPT.replace("HKEY_LOCAL_MACHINE", "HKEY_CURRENT_USER").replace("VCRedist2022", "UserRedist"))
with self.reg.open("a") as out:
@@ -398,6 +460,62 @@ class SeedRedistsTest(unittest.TestCase):
self.assertEqual(self.reg.read_text().count('"Vulkan111080"'), 2)
def test_a_session_start_leaves_the_library_search_to_a_later_run(self):
self.game(script=GAME_SCRIPT.replace("Software\\\\Valve\\\\Steam\\\\Apps\\\\CommonRedist\\\\vcredist\\\\2022", "SOFTWARE\\\\AGEIA Technologies").replace("VCRedist2022", "PhysX Version"))
shim = self.tmp / "bin"
shim.mkdir()
go = self.tmp / "go"
(shim / "find").write_text('#!/bin/sh\ncase "$*" in *"installscript*"*) n=0; while [ ! -e "%s" ] && [ $n -lt 600 ]; do sleep 0.1; n=$((n + 1)); done;; esac\nexec %s "$@"\n' % (go, shutil.which("find")))
(shim / "find").chmod(0o755)
env = dict(os.environ, DROIDDECK_LIBRARIES="", DROIDDECK_SEED_LATER="1", PATH="%s:%s" % (shim, os.environ["PATH"]))
marker = '"PhysX Version"=dword:00000001'
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
self.assertNotIn(marker, self.reg.read_text())
go.touch()
deadline = time.monotonic() + 30
while marker not in self.reg.read_text() and time.monotonic() < deadline:
time.sleep(0.2)
self.assertIn(marker, self.reg.read_text())
before = self.reg.read_text()
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
time.sleep(0.5)
self.assertEqual(before, self.reg.read_text())
def test_a_game_whose_search_failed_is_searched_again(self):
self.game()
broken = self.tmp / "broken"
broken.touch()
shim = self.tmp / "bin"
shim.mkdir()
(shim / "find").write_text('#!/bin/sh\n%s "$@"\n[ ! -e "%s" ]\n' % (shutil.which("find"), broken))
(shim / "find").chmod(0o755)
env = dict(os.environ, DROIDDECK_LIBRARIES="", PATH="%s:%s" % (shim, os.environ["PATH"]))
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, capture_output=True, check=True)
self.assertNotIn("VCRedist2022", self.reg.read_text())
broken.unlink()
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, capture_output=True, check=True)
self.assertIn('"VCRedist2022"=dword:00000001', self.reg.read_text())
def test_a_later_run_leaves_the_registry_alone_while_a_wine_server_runs(self):
self.game(script=GAME_SCRIPT.replace("Software\\\\Valve\\\\Steam\\\\Apps\\\\CommonRedist\\\\vcredist\\\\2022", "SOFTWARE\\\\AGEIA Technologies").replace("VCRedist2022", "PhysX Version"))
shim = self.tmp / "bin"
shim.mkdir()
(shim / "pgrep").write_text("#!/bin/sh\nexit 0\n")
(shim / "pgrep").chmod(0o755)
env = dict(os.environ, DROIDDECK_LIBRARIES="", DROIDDECK_SEED_LATER="1", PATH="%s:%s" % (shim, os.environ["PATH"]))
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
cache = self.steam / ".droiddeck-game-scripts"
deadline = time.monotonic() + 30
while not (cache.exists() and "installscript" in cache.read_text().lower()) and time.monotonic() < deadline:
time.sleep(0.2)
self.assertIn("installscript", cache.read_text().lower())
time.sleep(1)
self.assertNotIn("PhysX Version", self.reg.read_text())
env.pop("DROIDDECK_SEED_LATER")
env["PATH"] = os.environ["PATH"]
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
self.assertIn('"PhysX Version"=dword:00000001', self.reg.read_text())
def evaluator(self, appid, install_script):
script = self.tmp / ("legacycompat/evaluatorscript_%s.vdf" % appid)
script.parent.mkdir(parents=True)
@@ -43,6 +43,34 @@ class WebhelperLayoutTest(unittest.TestCase):
def test_the_steam_block_uses_it(self):
self.assertIn("BL_WEBHELPER_ARGS=$(bl_webhelper_layout)", SESSION.read_text())
def test_the_gpu_ui_on_the_bridge_defaults_to_angle_on_vulkan_without_vulkan_compositing(self):
text = SESSION.read_text()
gpu = text.index('elif [ "${_bl_cef[0]}" = -cef-force-gpu ]; then')
software = text.rindex('_bl_cef=(-cef-disable-gpu -cef-disable-gpu-compositing)', 0, gpu)
defaults = text.index(': "${BL_VKBRIDGE_CEF_ANGLE=vulkan}" "${BL_VKBRIDGE_CEF_VULKAN=0}"', gpu)
self.assertLess(software, gpu)
self.assertLess(defaults, text.index("BL_WEBHELPER_ARGS=$(bl_webhelper_layout)", gpu))
self.assertLess(defaults, text.index("\n fi\n", gpu))
def test_the_defaults_give_way_to_settings(self):
script = ': "${BL_VKBRIDGE_CEF_ANGLE=vulkan}" "${BL_VKBRIDGE_CEF_VULKAN=0}"\n' + layout_function() + "bl_webhelper_layout\n"
env = {k: v for k, v in os.environ.items() if k not in KEYS}
run = lambda **s: subprocess.run(["bash", "-c", "set -u\n" + script], env={**env, **s},
capture_output=True, text=True, check=True).stdout.strip()
self.assertEqual(run(), "--use-gl=angle --use-angle=vulkan")
self.assertEqual(run(BL_VKBRIDGE_CEF_VULKAN="1"),
"--use-gl=angle --use-angle=vulkan +Vulkan +VulkanFromANGLE +DefaultANGLEVulkan")
self.assertEqual(run(BL_VKBRIDGE_CEF_ANGLE="gl"), "--use-gl=angle --use-angle=gl")
def test_empty_settings_are_kept_as_set(self):
script = ': "${BL_VKBRIDGE_CEF_ANGLE=vulkan}" "${BL_VKBRIDGE_CEF_VULKAN=0}"\n' + layout_function() + "bl_webhelper_layout\n"
env = {k: v for k, v in os.environ.items() if k not in KEYS}
run = lambda **s: subprocess.run(["bash", "-c", "set -u\n" + script], env={**env, **s},
capture_output=True, text=True, check=True).stdout.strip()
self.assertEqual(run(BL_VKBRIDGE_CEF_ANGLE=""), "stock")
self.assertEqual(run(BL_VKBRIDGE_CEF_VULKAN=""),
"--use-gl=angle --use-angle=vulkan +Vulkan +VulkanFromANGLE +DefaultANGLEVulkan")
if __name__ == "__main__":
unittest.main()
+25
View File
@@ -99,6 +99,31 @@ class X64RepointTest(unittest.TestCase):
self.assertEqual(COMPAT["x64_repoint"](str(self.root), None), [])
self.assertEqual((self.root / "config" / "config.vdf").read_text(), before)
def test_new_owned_shortcut_gets_the_x64_default_and_explicit_choice_stays(self):
app = "2350879490"
chosen = "proton-cachyos-a64"
config = self.root / "config" / "config.vdf"
state = self.root / "droiddeck-compat"
self.assertEqual(COMPAT["register_default"](
str(config), apps=[app], protect={chosen: "proton-cachyos-a64"},
default="GE-Proton11-7-a64", directory=str(state),
linux_tool="droiddeck-direct", owned=[app]), "GE-Proton11-7-a64")
self.assertEqual(self.mapping()[app], "GE-Proton11-7-a64")
self.assertEqual(COMPAT["register_default"](
str(config), apps=[app], protect={chosen: "proton-cachyos-a64"},
default="GE-Proton11-7-a64", directory=str(state),
linux_tool="droiddeck-direct", owned=[app]), "GE-Proton11-7-a64")
self.assertEqual(self.mapping()[app], "GE-Proton11-7-a64")
tokens = COMPAT["tokenize"](config.read_text())
mapping = COMPAT["mapping_block"](tokens)
COMPAT["set_mapping"](tokens, mapping, app, chosen)
config.write_text(COMPAT["serialize"](tokens))
COMPAT["register_default"](
str(config), apps=[app], protect={chosen: "proton-cachyos-a64"},
default="GE-Proton11-7-a64", directory=str(state),
linux_tool="droiddeck-direct", owned=[app])
self.assertEqual(self.mapping()[app], chosen)
if __name__ == "__main__":
unittest.main()
+166
View File
@@ -3,6 +3,7 @@ import importlib.util
import json
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
@@ -56,6 +57,171 @@ class ImportsTest(unittest.TestCase):
self.assertEqual(self.folder, (self.steam / 'steamapps/common/DroidDeck-42').resolve())
self.assertEqual(b'game', self.exe.read_bytes())
def steam_install(self, appid=42):
library = self.root / 'Library'
folder = library / 'steamapps/common/Example'
folder.mkdir(parents=True)
(folder / 'Example.exe').write_bytes(b'game')
(library / f'steamapps/appmanifest_{appid}.acf').write_text(f'"AppState"\n{{\n"appid" "{appid}"\n"installdir" "Example"\n}}\n')
saves = library / f'steamapps/compatdata/{appid}/pfx/drive_c/users/steamuser'
saves.mkdir(parents=True)
(saves / 'save.dat').write_bytes(b'cloud')
return dict(self.game, folder=str(folder), exe=str(folder / 'Example.exe'), dir=str(folder)), library
def shortcut_prefix(self):
return self.steam / 'steamapps/compatdata' / str(self.game['appid'] & 0xFFFFFFFF)
def link_shortcut_prefix(self, target, owned=True):
(self.steam / 'steamapps/compatdata').mkdir(parents=True, exist_ok=True)
self.shortcut_prefix().symlink_to(target)
if owned:
imports.save_json(self.steam / 'steamapps' / imports.PREFIX_LINKS,
{str(self.shortcut_prefix()): str(target)})
def test_shortcut_of_a_steam_install_shares_the_steam_apps_prefix(self):
game, library = self.steam_install()
(self.steam / 'steamapps').mkdir(parents=True)
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
games, routes = imports.route(self.steam, self.acct, [game])
self.assertEqual(([game], {}), (games, routes))
self.assertEqual(library / 'steamapps/compatdata/42', self.shortcut_prefix().resolve())
self.assertEqual(b'cloud', (self.shortcut_prefix() / 'pfx/drive_c/users/steamuser/save.dat').read_bytes())
def test_matching_install_prefix_precedes_an_older_prefix_in_another_library(self):
game, library = self.steam_install()
(self.steam / 'steamapps').mkdir(parents=True)
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
older = self.steam / 'steamapps/compatdata/42/pfx/drive_c/users/steamuser'
older.mkdir(parents=True)
(older / 'save.dat').write_bytes(b'old')
imports.route(self.steam, self.acct, [game])
self.assertEqual(library / 'steamapps/compatdata/42', self.shortcut_prefix().resolve())
self.assertEqual(b'cloud', (self.shortcut_prefix() / 'pfx/drive_c/users/steamuser/save.dat').read_bytes())
self.assertEqual(b'old', (older / 'save.dat').read_bytes())
def test_an_existing_shortcut_prefix_is_never_replaced(self):
game, library = self.steam_install()
(self.steam / 'steamapps').mkdir(parents=True, exist_ok=True)
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
local = self.shortcut_prefix() / 'pfx/drive_c'
local.mkdir(parents=True)
(local / 'local.dat').write_bytes(b'local')
imports.route(self.steam, self.acct, [game])
self.assertFalse(self.shortcut_prefix().is_symlink())
self.assertEqual(b'local', (local / 'local.dat').read_bytes())
self.assertEqual(b'cloud', (library / 'steamapps/compatdata/42/pfx/drive_c/users/steamuser/save.dat').read_bytes())
def test_shortcuts_without_a_manifest_identity_keep_their_own_prefix(self):
game, library = self.steam_install()
(self.steam / 'steamapps').mkdir(parents=True, exist_ok=True)
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
imports.route(self.steam, self.acct, [self.game, dict(game, folder=str(self.folder.parent / 'Other'))])
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
def test_a_manifest_without_a_steam_prefix_links_nothing(self):
game, library = self.steam_install()
shutil.rmtree(library / 'steamapps/compatdata/42')
(self.steam / 'steamapps').mkdir(parents=True, exist_ok=True)
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
imports.route(self.steam, self.acct, [game])
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
def test_an_older_prefix_in_another_library_is_not_linked_for_a_steam_install(self):
game, library = self.steam_install()
shutil.rmtree(library / 'steamapps/compatdata/42')
(self.steam / 'steamapps').mkdir(parents=True, exist_ok=True)
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
(self.steam / 'steamapps/compatdata/42/pfx/drive_c').mkdir(parents=True)
imports.route(self.steam, self.acct, [game])
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
def test_a_dangling_shortcut_prefix_link_is_replaced(self):
game, library = self.steam_install()
self.link_shortcut_prefix(self.root / 'moved')
imports.route(self.steam, self.acct, [game])
self.assertEqual(library / 'steamapps/compatdata/42', self.shortcut_prefix().resolve())
def test_a_dangling_shortcut_prefix_link_is_removed_without_a_replacement(self):
game, library = self.steam_install()
shutil.rmtree(library / 'steamapps/compatdata/42')
self.link_shortcut_prefix(self.root / 'moved')
imports.route(self.steam, self.acct, [game])
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
def test_a_link_the_user_made_is_never_changed(self):
game, library = self.steam_install()
for target in (self.root / 'moved', library / 'steamapps/compatdata/42', self.folder):
if os.path.lexists(self.shortcut_prefix()):
self.shortcut_prefix().unlink()
self.link_shortcut_prefix(target, owned=False)
imports.route(self.steam, self.acct, [game])
self.assertEqual(str(target), os.readlink(self.shortcut_prefix()))
def test_a_user_link_to_the_matching_prefix_is_never_recorded_or_removed(self):
game, library = self.steam_install()
target = library / 'steamapps/compatdata/42'
self.link_shortcut_prefix(target, owned=False)
imports.route(self.steam, self.acct, [game])
self.assertEqual(str(target), os.readlink(self.shortcut_prefix()))
self.assertNotIn(str(self.shortcut_prefix()), imports.read_json(self.steam / 'steamapps' / imports.PREFIX_LINKS, {}))
shutil.rmtree(target)
imports.route(self.steam, self.acct, [game])
self.assertTrue(os.path.islink(self.shortcut_prefix()))
self.assertEqual(str(target), os.readlink(self.shortcut_prefix()))
def test_our_link_survives_a_library_that_is_temporarily_missing(self):
game, library = self.steam_install()
imports.route(self.steam, self.acct, [game])
hidden = self.root / 'Hidden'
library.rename(hidden)
imports.route(self.steam, self.acct, [game])
self.assertTrue(os.path.islink(self.shortcut_prefix()))
hidden.rename(library)
imports.route(self.steam, self.acct, [game])
self.assertEqual(library / 'steamapps/compatdata/42', self.shortcut_prefix().resolve())
self.assertEqual(b'cloud', (self.shortcut_prefix() / 'pfx/drive_c/users/steamuser/save.dat').read_bytes())
def test_our_link_is_dropped_once_its_prefix_is_deleted(self):
game, library = self.steam_install()
imports.route(self.steam, self.acct, [game])
shutil.rmtree(library / 'steamapps/compatdata/42')
imports.route(self.steam, self.acct, [game])
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
self.assertEqual({}, imports.read_json(self.steam / 'steamapps' / imports.PREFIX_LINKS, None))
def test_a_replaced_link_record_is_forgotten_when_the_user_makes_a_real_prefix(self):
game, library = self.steam_install()
imports.route(self.steam, self.acct, [game])
self.shortcut_prefix().unlink()
(self.shortcut_prefix() / 'pfx/drive_c').mkdir(parents=True)
imports.route(self.steam, self.acct, [game])
self.assertFalse(self.shortcut_prefix().is_symlink())
self.assertEqual({}, imports.read_json(self.steam / 'steamapps' / imports.PREFIX_LINKS, None))
def test_a_shortcut_prefix_with_its_own_saves_is_reported_and_kept(self):
game, library = self.steam_install()
local = self.shortcut_prefix() / 'pfx/drive_c'
local.mkdir(parents=True)
with patch('builtins.print') as printed:
imports.route(self.steam, self.acct, [game])
self.assertTrue(local.is_dir())
self.assertIn('keeps its own prefix', printed.call_args_list[-1][0][0])
def test_a_winnative_game_shares_the_prefix_the_steam_client_uses(self):
self.winnative_manifest()
(self.steam / 'steamapps/libraryfolders.vdf').parent.mkdir(parents=True, exist_ok=True)
saves = self.steam / 'steamapps/compatdata/42/pfx/drive_c/users/steamuser'
saves.mkdir(parents=True)
(saves / 'save.dat').write_bytes(b'cloud')
imports.share_prefix(self.steam, self.game)
self.assertEqual(self.steam / 'steamapps/compatdata/42', self.shortcut_prefix().resolve())
def test_an_unreadable_library_does_not_stop_the_routing(self):
with patch.object(Path, 'glob', side_effect=PermissionError):
games, routes = imports.route(self.steam, self.acct, [self.game])
self.assertEqual([self.game], games)
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
def test_store_installs_stay_shortcuts_even_when_owned_on_steam(self):
self.snapshot()
game = dict(self.game, store='amazon')
@@ -0,0 +1,67 @@
import os
from pathlib import Path
import re
import subprocess
import tempfile
import unittest
SCRIPT = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/droiddeck-steam-x64'
SOURCE = SCRIPT.read_text()
LIBRARY_LOOP = re.search(r'^for d in "\$STEAM_X64"/steamrt64/.*?^done\nFEX_ROOTFS=', SOURCE, re.M | re.S).group()
LIBRARY_LOOP = LIBRARY_LOOP[:LIBRARY_LOOP.rfind('\nFEX_ROOTFS=')]
class SteamX64RuntimeLibsTest(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
self.steam = self.root / 'Steam'
self.runtime = self.steam / 'steamrt64/pv-runtime/steam-runtime-steamrt'
self.lib = self.runtime / 'steamrt3c_platform_a/files/lib/x86_64-linux-gnu'
self.usr_lib = self.runtime / 'steamrt3c_platform_a/files/usr/lib/x86_64-linux-gnu'
self.lib.mkdir(parents=True)
self.usr_lib.mkdir(parents=True)
self.dest = self.root / 'steamrt-libs'
self.dest.mkdir()
def run_loop(self):
shell = 'srt_libs="$DEST"\n' + LIBRARY_LOOP
env = dict(os.environ, STEAM_X64=str(self.steam), DEST=str(self.dest))
return subprocess.run(['bash', '-eu', '-c', shell], env=env, capture_output=True, text=True, timeout=10)
def test_empty_library_directory_is_skipped(self):
(self.usr_lib / 'libexample.so.1').touch()
result = self.run_loop()
self.assertEqual(0, result.returncode, result.stderr)
self.assertTrue((self.dest / 'libexample.so.1').is_symlink())
def test_two_platform_versions_with_empty_lib_dirs_use_usr_lib(self):
platform_b = self.runtime / 'steamrt3c_platform_b'
(platform_b / 'files/lib/x86_64-linux-gnu').mkdir(parents=True)
usr_lib_b = platform_b / 'files/usr/lib/x86_64-linux-gnu'
usr_lib_b.mkdir(parents=True)
(self.usr_lib / 'libexample.so.1').touch()
(usr_lib_b / 'libother.so.1').touch()
result = self.run_loop()
self.assertEqual(0, result.returncode, result.stderr)
self.assertTrue((self.dest / 'libexample.so.1').is_symlink())
self.assertTrue((self.dest / 'libother.so.1').is_symlink())
def test_stale_literal_glob_link_does_not_abort(self):
(self.dest / '*.so*').symlink_to('/missing/*.so*')
result = self.run_loop()
self.assertEqual(0, result.returncode, result.stderr)
self.assertTrue((self.dest / '*.so*').is_symlink())
def test_existing_dangling_library_link_is_not_recreated(self):
(self.lib / 'libexample.so.1').touch()
(self.dest / 'libexample.so.1').symlink_to('/missing/libexample.so.1')
result = self.run_loop()
self.assertEqual(0, result.returncode, result.stderr)
self.assertEqual('/missing/libexample.so.1', os.readlink(self.dest / 'libexample.so.1'))
if __name__ == '__main__':
unittest.main()
+99
View File
@@ -797,3 +797,102 @@ class GogRegistry(unittest.TestCase):
store.main([str(folder / store.LAUNCHER)])
apply.assert_called_once_with(folder, root + '/compat', '/chosen/proton')
support.assert_called_once_with(folder, root + '/compat', '/chosen/proton')
class Ubisoft(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.compat_data = self.root / 'compatdata/2929927072'
(self.compat_data / 'pfx').mkdir(parents=True)
(self.compat_data / 'pfx/system.reg').write_text('WINE REGISTRY Version 2\n')
(self.compat_data / 'pfx/user.reg').write_text('WINE REGISTRY Version 2\n')
self.folder = self.root / 'Games/Stores/Ubisoft/Splinter Cell'
(self.folder / 'system').mkdir(parents=True)
self.sidecar = {'store': 'ubisoft', 'id': 'space-1', 'exe': 'system/SplinterCell.exe', 'extra': {'productId': '109'}}
service = self.root / 'droiddeck-upc.exe'
service.write_bytes(b'MZ')
for patcher in (patch.object(store, 'UBISOFT_SERVICE', service), patch.object(store, 'UBISOFT_CACHE', self.root / 'cache'),
patch.object(store, 'wait_for_server', return_value=True)):
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
self.tmp.cleanup()
def runtime(self):
folder = store.ubisoft_runtime_dir(self.compat_data)
folder.mkdir(parents=True, exist_ok=True)
for name in store.UBISOFT_RUNTIME:
(folder / name).write_bytes(b'MZ')
def answer(self, *_args, **_kwargs):
return {'ok': True, 'ticket': 'PC', 'owned': [82, 109], 'appId': 'app',
'account': {'userId': 'u1', 'username': 'name', 'nameOnPlatform': 'name', 'email': 'e@x', 'country': 'US'}}
def prepare(self, ask_app):
return store.prepare_ubisoft(self.folder, self.sidecar, str(self.compat_data), str(self.root / 'launch'), '/proton', ask_app=ask_app)
def test_an_extracted_runtime_is_not_extracted_again(self):
self.runtime()
with patch.object(store.subprocess, 'run') as run:
self.assertEqual('present', store.install_runtime(str(self.compat_data)))
run.assert_not_called()
def test_the_runtime_comes_from_the_installer_through_7z(self):
installer = self.root / 'UbisoftConnectInstaller.exe'
def run(command, **_kwargs):
self.assertEqual(['7z', 'e', '-y'], command[:3])
self.assertEqual(str(installer), command[4])
out = Path(command[3][2:])
for name in command[5:]:
(out / name).write_bytes(b'MZ')
(self.root / 'cache').mkdir()
with patch.object(store, 'fetch_installer', return_value=installer), patch.object(store.subprocess, 'run', side_effect=run):
self.assertEqual('installed', store.install_runtime(str(self.compat_data)))
self.assertTrue(store.ubisoft_runtime_ready(str(self.compat_data)))
def test_a_launch_registers_the_game_and_writes_the_session_for_the_service(self):
self.runtime()
result = self.prepare(self.answer)
self.assertEqual('runtime present, registered 109, 0 manifest value(s), session ready', result)
reg = (self.compat_data / 'pfx/system.reg').read_text()
for view in ('[Software\\\\Ubisoft\\\\Launcher]', '[Software\\\\Wow6432Node\\\\Ubisoft\\\\Launcher]'):
self.assertIn(view, reg)
self.assertIn('[Software\\\\Wow6432Node\\\\Ubisoft\\\\Launcher\\\\Installs\\\\109]', reg)
self.assertIn('"InstallDir"="C:\\\\Program Files (x86)\\\\Ubisoft\\\\Ubisoft Game Launcher\\\\"', reg)
launch = json.loads((self.folder / store.UBISOFT_LAUNCH).read_text())
self.assertEqual(109, launch['productId'])
self.assertEqual('PC', launch['ticket'])
self.assertEqual([82, 109], launch['owned'])
self.assertEqual(store.windows_path(str(self.folder / 'system/SplinterCell.exe')), launch['exe'])
self.assertEqual('C:/users/steamuser/Saved Games/Ubisoft/u1/109/', launch['saves'])
self.assertTrue((self.compat_data / 'pfx/drive_c/users/steamuser/Saved Games/Ubisoft/u1/109').is_dir())
def test_without_a_session_the_launch_file_is_removed_and_the_game_starts_as_is(self):
self.runtime()
(self.folder / store.UBISOFT_LAUNCH).write_text('{}')
result = self.prepare(lambda *_a, **_k: {'ok': False, 'reason': 'signed-out'})
self.assertEqual('runtime present, registered 109, session signed-out', result)
self.assertFalse((self.folder / store.UBISOFT_LAUNCH).exists())
def test_a_game_without_a_product_is_left_alone(self):
self.sidecar['extra'] = {}
self.assertEqual('no-product', self.prepare(self.answer))
def test_the_manifest_registry_lands_in_both_views_with_the_install_folder_and_language(self):
self.runtime()
registry = [{'key': r'HKEY_LOCAL_MACHINE\SOFTWARE\Ubisoft\Launcher\Installs\109\Language',
'values': [{'name': 'French', 'value': 'fr-FR'}, {'name': 'English', 'value': 'en-US'}]},
{'key': r'HKEY_LOCAL_MACHINE\SOFTWARE\Ubisoft\Splinter Cell\GamePath', 'values': [{'name': '$INSTALL_DIR', 'value': ''}]}]
answer = dict(self.answer(), registry=registry, language='en-US')
result = self.prepare(lambda *_a, **_k: answer)
self.assertEqual('runtime present, registered 109, 4 manifest value(s), session ready', result)
reg = (self.compat_data / 'pfx/system.reg').read_text()
self.assertIn(r'[SOFTWARE\\Wow6432Node\\Ubisoft\\Launcher\\Installs\\109]', reg)
self.assertIn(r'[SOFTWARE\\Ubisoft\\Launcher\\Installs\\109]', reg)
self.assertIn('"Language"="en-US"', reg)
folder = store.windows_path(str(self.folder)).replace('\\', '\\\\')
self.assertIn('"GamePath"="%s\\\\"' % folder, reg)
+175
View File
@@ -0,0 +1,175 @@
import base64
import importlib.machinery
import importlib.util
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin'
loader = importlib.machinery.SourceFileLoader('droiddeck_store_launch_ea', str(BIN / 'droiddeck-store-launch'))
spec = importlib.util.spec_from_loader(loader.name, loader)
store = importlib.util.module_from_spec(spec)
loader.exec_module(store)
class EaHook(unittest.TestCase):
def test_wmi_output_reads_the_value_under_the_header(self):
text = 'Manufacturer \r\r\nThe Wine Project \r\r\n\r\r\n'
self.assertEqual(store.wmi_value(text), 'The Wine Project')
self.assertEqual(store.wmi_value(store.decode_output('Name\r\nFEX CPU\r\n'.encode('utf-16'))), 'FEX CPU')
self.assertEqual(store.wmi_value(''), '')
def test_registry_points_the_game_keys_at_the_install_folder(self):
sidecar = {'id': 'Origin.OFR.50.0001', 'title': 'Mass Effect 3', 'extra': {'registry': json.dumps([
[r'HKEY_LOCAL_MACHINE\SOFTWARE\EA Games\Game', 'Install Dir'],
[r'HKLM\SOFTWARE\Respawn\Titanfall2', 'Install Dir'],
[r'HKEY_CLASSES_ROOT\x', 'y'],
])}}
entries = store.ea_registry_entries(Path('/root/Games/Stores/EA/Game'), sidecar)
self.assertIn((r'HKEY_LOCAL_MACHINE\SOFTWARE\Origin', 'ClientPath', store.EA_CLIENT), entries)
game = [e for e in entries if e[1] == 'Install Dir']
self.assertEqual([e[0] for e in game], [r'HKEY_LOCAL_MACHINE\SOFTWARE\EA Games\Game', r'HKEY_LOCAL_MACHINE\SOFTWARE\Respawn\Titanfall2'])
self.assertEqual(game[0][2], 'Z:' + '\\'.join(['', 'root', 'Games', 'Stores', 'EA', 'Game', '']))
self.assertIn((r'HKEY_LOCAL_MACHINE\SOFTWARE\EA Games\Game', 'DisplayName', 'Mass Effect 3'), entries)
self.assertIn((r'HKEY_LOCAL_MACHINE\SOFTWARE\Respawn\Titanfall2', 'DisplayName', 'Mass Effect 3'), entries)
def test_the_games_exe_maps_to_its_launcher_only(self):
with tempfile.TemporaryDirectory() as tmp:
folder = Path(tmp) / 'Game'
(folder / 'bin').mkdir(parents=True)
for name in ('bin/Game.exe', 'bin/Other.exe', store.LAUNCHER):
(folder / name).write_text('x')
sidecar = {'store': 'ea', 'id': 'Origin.OFR.50.1', 'exe': 'bin/Game.exe', 'launcher': store.LAUNCHER}
(folder / store.SIDECAR).write_text(json.dumps(sidecar))
self.assertEqual(store.store_launcher(str(folder / 'bin/Game.exe')), str(folder / store.LAUNCHER))
self.assertEqual(store.store_launcher(str(folder / 'bin/game.exe')), str(folder / store.LAUNCHER))
self.assertIsNone(store.store_launcher(str(folder / 'bin/Other.exe')))
self.assertIsNone(store.store_launcher(str(Path(tmp) / 'Elsewhere.exe')))
(folder / store.SIDECAR).write_text(json.dumps(dict(sidecar, launcher='')))
self.assertIsNone(store.store_launcher(str(folder / 'bin/Game.exe')))
def test_a_symlinked_or_deep_exe_still_finds_its_launcher(self):
with tempfile.TemporaryDirectory() as tmp:
folder = Path(tmp) / 'Game'
deep = folder / 'a/b/c/d/e/f'
deep.mkdir(parents=True)
(deep / 'Game.exe').write_text('x')
(folder / store.LAUNCHER).write_text('x')
sidecar = {'store': 'ea', 'id': 'Origin.OFR.50.1', 'exe': 'a/b/c/d/e/f/Game.exe', 'launcher': store.LAUNCHER}
(folder / store.SIDECAR).write_text(json.dumps(sidecar))
link = Path(tmp) / 'x/y/z/Link.exe'
link.parent.mkdir(parents=True)
link.symlink_to(deep / 'Game.exe')
expected = str(folder.resolve() / store.LAUNCHER)
self.assertEqual(store.store_launcher(str(deep / 'Game.exe')), expected)
self.assertEqual(store.store_launcher(str(link)), expected)
self.assertIsNone(store.find_store_game([str(deep / 'Game.exe')]))
def test_a_symlinked_exe_finds_the_sidecar_beside_the_link(self):
with tempfile.TemporaryDirectory() as tmp:
outside = Path(tmp) / 'Real/Game.exe'
outside.parent.mkdir()
outside.write_text('x')
folder = Path(tmp) / 'Game'
folder.mkdir()
(folder / store.LAUNCHER).write_text('x')
(folder / 'Game.exe').symlink_to(outside)
sidecar = {'store': 'ea', 'id': 'Origin.OFR.50.1', 'exe': 'Game.exe', 'launcher': store.LAUNCHER}
(folder / store.SIDECAR).write_text(json.dumps(sidecar))
self.assertEqual(store.store_launcher(str(folder / 'Game.exe')), str(folder / store.LAUNCHER))
self.assertIsNone(store.store_launcher(str(outside)))
def test_legacy_games_are_registered_by_content_id(self):
sidecar = {'id': 'Origin.OFR.50.0005237', 'title': 'Mass Effect 3 (2012)',
'extra': {'contentIds': '71073,71183, bad id', 'displayName': 'Mass Effect 3', 'locale': 'fr_FR'}}
entries = store.ea_registry_entries(Path('/root/Games/ME3'), sidecar)
key = r'HKEY_LOCAL_MACHINE\SOFTWARE\Origin Games' + '\\'
self.assertIn((key + '71073', 'DisplayName', 'Mass Effect 3'), entries)
self.assertIn((key + '71183', 'Locale', 'fr_FR'), entries)
self.assertFalse(any('bad id' in e[0] for e in entries))
def test_cpuid_probe_is_a_32_bit_console_program(self):
import struct
exe = store.cpuid_exe()
self.assertEqual(exe[:2], b'MZ')
self.assertEqual(exe[0x40:0x44], b'PE\0\0')
self.assertEqual(struct.unpack_from('<H', exe, 0x44)[0], 0x14C)
self.assertEqual(struct.unpack_from('<H', exe, 0x58)[0], 0x10B)
self.assertEqual(struct.unpack_from('<H', exe, 0x58 + 68)[0], 3)
self.assertIn(b'KERNEL32.dll', exe)
self.assertEqual(len(exe), 0x400)
def test_origin_stub_is_a_windowless_program_installed_once(self):
import struct
exe = store.origin_stub_exe()
self.assertEqual(exe[:2], b'MZ')
self.assertEqual(struct.unpack_from('<H', exe, 0x58 + 68)[0], 2)
self.assertIn(b'Sleep', exe)
self.assertEqual(exe[0x208:0x20A], b'\xeb\xf6')
with tempfile.TemporaryDirectory() as tmp:
self.assertEqual(store.install_origin_stub(tmp), 'written')
self.assertEqual(store.install_origin_stub(tmp), 'ready')
self.assertTrue((Path(tmp) / 'pfx/drive_c/Program Files (x86)/Origin/Origin.exe').is_file())
self.assertTrue(store.EA_CLIENT.endswith('Origin.exe'))
def test_cpuid_output_is_decoded_as_the_game_sees_it(self):
raw = bytes.fromhex('1600000047656e756e74656c696e654961060a00000805000f23d882fffb8b27436f727465782d4135323000000000000000000000000000000000000000000000000000000000000000000000000000')
self.assertEqual(store.cpuid_values(raw), {'cpuVendor': 'GenuineIntel', 'cpuEax': '000A0661', 'cpuEdx': '278BFBFF',
'cpuEcx': '82d8230f', 'cpuBrand': 'Cortex-A520'})
self.assertEqual(store.cpuid_values(b''), {})
def test_touchup_arguments_fill_locale_and_folder(self):
install = r'Z:\root\My Game'
args = store.touchup_args('-locale {locale} -installPath "{installLocation}" /silent', 'fr_FR', install)
self.assertEqual(args, ['-locale', 'fr_FR', '-installPath', install, '/silent'])
def test_licences_stay_inside_the_prefix(self):
with tempfile.TemporaryDirectory() as tmp:
data = base64.b64encode(b'licence').decode()
written = store.write_licenses(tmp, [
{'path': 'ProgramData/Electronic Arts/EA Services/License/X.dlf', 'data': data},
{'path': '../escape.dlf', 'data': data},
{'path': '/abs.dlf', 'data': data},
])
self.assertEqual(written, 1)
self.assertEqual((Path(tmp) / 'pfx/drive_c/ProgramData/Electronic Arts/EA Services/License/X.dlf').read_bytes(), b'licence')
def test_prepare_asks_the_app_and_writes_the_licence(self):
with tempfile.TemporaryDirectory() as tmp:
compat = Path(tmp) / 'compat'
(compat / 'pfx').mkdir(parents=True)
(compat / 'pfx/user.reg').write_text('')
probe = {key: 'x' for key in store.EA_PROBE_FIELDS}
(compat / 'pfx' / store.EA_HARDWARE).write_text(json.dumps(probe))
folder = Path(tmp) / 'game'
folder.mkdir()
asked = {}
def fake_ask(channel, request, timeout=5.0):
asked.update(request)
return {'ok': True, 'lsx': True, 'license': 'ok v4', 'licenses': [{'path': 'ProgramData/L/x.dlf', 'data': base64.b64encode(b'z').decode()}]}
with patch.object(store, 'ask', fake_ask), patch.object(store, 'ea_registry', lambda *a, **k: 'ready'), \
patch.object(store, 'ea_touchup', lambda *a, **k: 'none'), patch.dict('os.environ', {'BL_STORE_PROTON': ''}):
store.prepare_ea(folder, {'id': 'Origin.OFR.1'}, str(compat), str(Path(tmp) / 'launch'))
self.assertEqual(asked['op'], 'ea-prepare')
self.assertEqual(asked['hardware'], probe)
self.assertEqual((compat / 'pfx/drive_c/ProgramData/L/x.dlf').read_bytes(), b'z')
def test_an_incomplete_cached_probe_is_probed_again(self):
with tempfile.TemporaryDirectory() as tmp:
pfx = Path(tmp) / 'pfx'
pfx.mkdir()
partial = {key: 'x' for key in store.EA_PROBE_FIELDS if key != 'osInstallDate'}
(pfx / store.EA_HARDWARE).write_text(json.dumps(partial))
self.assertFalse(store.probe_complete(partial))
self.assertEqual(store.ea_hardware(tmp, ''), ({}, 'no-proton'))
whole = dict(partial, osInstallDate='20261108')
(pfx / store.EA_HARDWARE).write_text(json.dumps(whole))
self.assertEqual(store.ea_hardware(tmp, ''), (whole, 'cached'))
if __name__ == '__main__':
unittest.main()
+197
View File
@@ -0,0 +1,197 @@
import json
import os
from pathlib import Path
import tempfile
import time
import unittest
from unittest.mock import patch
from test_store_launch import store
class RockstarLaunch(unittest.TestCase):
def test_service_directory_cannot_export_sessions_outside_the_prefix(self):
with tempfile.TemporaryDirectory() as root:
folder, sidecar, prefix, _, _ = self.setup_game(root)
outside = Path(root) / 'outside'
outside.mkdir()
target = prefix / 'pfx' / store.ROCKSTAR_FOLDER
target.parent.mkdir(parents=True)
target.symlink_to(outside, target_is_directory=True)
sentinel = outside / 'launch.json'
sentinel.write_text('keep')
with patch.object(store, 'ask') as ask:
self.assertEqual('invalid-service-path', store.prepare_rockstar(folder, sidecar, prefix, 'channel'))
ask.assert_not_called()
self.assertEqual('keep', sentinel.read_text())
def test_sdk_registration_does_not_use_an_untrusted_display_name_as_a_key(self):
with tempfile.TemporaryDirectory() as root:
folder, _, prefix, _, _ = self.setup_game(root)
with patch.object(store, 'wait_for_server', return_value=True):
self.assertTrue(store.rockstar_registry(folder, None, prefix, '', sdk_arch='x64'))
text = (prefix / 'pfx/system.reg').read_text()
self.assertIn(r'[Software\\Rockstar Games\\Rockstar Games Social Club]', text)
self.assertNotIn('Grand Theft Auto', text)
def test_root_metadata_is_found_after_many_assets(self):
with tempfile.TemporaryDirectory() as root:
folder = Path(root)
for index in range(300):
(folder / ('asset-%s.dat' % index)).write_bytes(b'asset')
(folder / 'title.rgl').write_bytes(b'RGLM' + bytes(108))
self.assertTrue(store.rockstar_sdk(folder, {'id': 'future_title', 'exe': 'Game.exe'}))
(folder / 'title.rgl').unlink()
(folder / 'Title.RGL').write_bytes(b'RGLM' + bytes(108))
self.assertTrue(store.rockstar_sdk(folder, {'id': 'future_title', 'exe': 'Game.exe'}))
def test_sdk_titles_receive_only_their_short_lived_game_session(self):
with tempfile.TemporaryDirectory() as root:
def change(values):
folder, sidecar, _, _, answer = values
sidecar['id'] = 'future_title'
(folder / 'socialclub.dll').write_bytes(b'game-runtime')
answer['session'] = {'accountId': '123', 'identity': 'player@example.invalid', 'ticket': 'game-session',
'ScAuthToken': 'never-export-refresh-token'}
result, path, _ = self.prepare(root, change)
self.assertEqual('ready', result)
data = json.loads(path.read_text())
self.assertEqual({'accountId', 'identity', 'ticket'}, set(data['session']))
self.assertNotIn('pipe', data)
self.assertNotIn('material', data)
self.assertNotIn('never-export-refresh-token', path.read_text())
self.assertEqual(0o600, path.stat().st_mode & 0o777)
def test_invalid_sdk_sessions_cannot_reuse_an_old_handoff(self):
for session in (None, {'accountId': '0', 'identity': 'player', 'ticket': 'session'},
{'accountId': '123', 'identity': 'player', 'ticket': 'bad\0session'}):
with self.subTest(session=session), tempfile.TemporaryDirectory() as root:
def change(values):
folder, sidecar, _, _, answer = values
sidecar['id'] = 'future_title'
(folder / 'socialclub.dll').write_bytes(b'game-runtime')
answer['session'] = session
result, path, _ = self.prepare(root, change)
self.assertEqual('invalid-sdk-session', result)
self.assertFalse(path.exists())
def test_sdk_detection_does_not_follow_external_metadata(self):
with tempfile.TemporaryDirectory() as root:
folder = Path(root) / 'game'
folder.mkdir()
metadata = Path(root) / 'outside.rgl'
metadata.write_bytes(b'RGLM' + bytes(108))
(folder / 'title.rgl').symlink_to(metadata)
self.assertFalse(store.rockstar_sdk(folder, {'id': 'future_title', 'exe': 'Game.exe'}))
def test_sdk_installer_cannot_escape_its_architecture_folder(self):
with tempfile.TemporaryDirectory() as root:
folder = Path(root) / 'game'
installer = folder / 'Installers/Social-Club-Setup.exe'
installer.parent.mkdir(parents=True)
installer.write_bytes(b'installer')
listing = type('Listing', (), {'returncode': 0, 'stdout': b'Path = x64/../../outside.dll\nSize = 1\n'})()
with patch.object(store.shutil, 'which', return_value='/bin/7z'), patch.object(store.subprocess, 'run', return_value=listing):
with self.assertRaises(ValueError):
store.rockstar_runtime(folder, folder / 'Game.exe', str(Path(root) / 'prefix'), 'x64')
self.assertFalse((Path(root) / 'outside.dll').exists())
def test_other_titles_can_launch_without_the_classic_pipe_service(self):
with tempfile.TemporaryDirectory() as root:
folder = Path(root)
sidecar = {'store': 'rockstar', 'id': 'rdr2', 'exe': 'RDR2.exe'}
with patch.object(store, 'find_store_game', return_value=(folder, sidecar)), \
patch.object(store, 'prepare_rockstar') as prepare, \
patch.object(store, 'ask') as ask, patch.dict(os.environ, {}, clear=True):
self.assertEqual(store.STORE_GAME, store.main([str(folder / 'RDR2.exe')]))
prepare.assert_not_called()
ask.assert_not_called()
def test_classic_authentication_failure_still_stops_launch(self):
with tempfile.TemporaryDirectory() as root:
folder = Path(root)
sidecar = {'store': 'rockstar', 'id': 'gtavc', 'exe': 'gta-vc.exe'}
with patch.object(store, 'find_store_game', return_value=(folder, sidecar)), \
patch.object(store, 'prepare_rockstar', return_value='session-not-owned'), \
patch.dict(os.environ, {}, clear=True):
self.assertEqual(store.RAN_FAILED, store.main([str(folder / 'gta-vc.exe')]))
def setup_game(self, root):
folder = Path(root) / 'game'
folder.mkdir()
exe = bytearray(128)
exe[:2] = b'MZ'
exe[0x3c:0x40] = (64).to_bytes(4, 'little')
exe[64:70] = b'PE\0\0\x4c\x01'
(folder / 'gta-vc.exe').write_bytes(exe)
(folder / 'MTLX.dll').write_bytes(b'vendor')
prefix = Path(root) / 'prefix'
(prefix / 'pfx').mkdir(parents=True)
(prefix / 'pfx/user.reg').write_text('WINE REGISTRY Version 2\n')
(prefix / 'pfx/system.reg').write_text('WINE REGISTRY Version 2\n')
service = Path(root) / 'service'
service.mkdir()
(service / 'Launcher32.exe').write_bytes(b'compiled-helper')
sidecar = {'store': 'rockstar', 'id': 'gtavc', 'exe': 'gta-vc.exe', 'args': ['one argument', '&literal']}
answer = {'ok': True, 'pipe': 'GTA-VC_Pipe', 'material': 'A' * 640,
'expiresAt': int(time.time() * 1000) + 90000, 'ticket': 'must-not-be-exported'}
return folder, sidecar, prefix, service, answer
def prepare(self, root, modify=lambda values: None):
values = self.setup_game(root)
modify(values)
folder, sidecar, prefix, service, answer = values
config = prefix / 'pfx' / store.ROCKSTAR_FOLDER / 'launch.json'
config.parent.mkdir(parents=True)
config.write_text('stale')
requests = []
def ask(channel, request, timeout):
requests.append(request)
return answer
with patch.object(store, 'ROCKSTAR_SERVICE', service), patch.object(store, 'rockstar_registry', return_value=True):
result = store.prepare_rockstar(folder, sidecar, str(prefix), str(Path(root) / 'channel'), ask_app=ask)
return result, config, requests
def test_handoff_contains_only_launch_fields_and_preserves_argument_boundaries(self):
with tempfile.TemporaryDirectory() as root:
result, path, requests = self.prepare(root)
self.assertEqual('ready', result)
data = json.loads(path.read_text())
self.assertEqual({'folder', 'exe', 'workdir', 'args', 'pipe', 'material', 'expiresAt'}, set(data))
self.assertEqual(['one argument', '&literal'], data['args'])
self.assertNotIn('must-not-be-exported', path.read_text())
self.assertEqual('rockstar-launch', requests[0]['op'])
self.assertEqual(b'compiled-helper', path.with_name('Launcher.exe').read_bytes())
def test_rejected_or_expired_sessions_cannot_reuse_stale_material(self):
for update in ({'ok': False, 'reason': 'not-owned'}, {'material': 'A' * 641}, {'expiresAt': 1}):
with self.subTest(update=update), tempfile.TemporaryDirectory() as root:
result, config, _ = self.prepare(root, lambda values: values[4].update(update))
self.assertNotEqual('ready', result)
self.assertFalse(config.exists())
def test_path_escape_does_not_request_account_data(self):
with tempfile.TemporaryDirectory() as root:
def change(values):
(Path(root) / 'outside.exe').write_bytes(b'MZ')
values[1]['exe'] = '../outside.exe'
result, config, requests = self.prepare(root, change)
self.assertEqual('invalid-game-path', result)
self.assertEqual([], requests)
self.assertFalse(config.exists())
def test_writes_both_registry_views_and_escapes_values(self):
with tempfile.TemporaryDirectory() as root:
folder, _, prefix, _, _ = self.setup_game(root)
with patch.object(store, 'wait_for_server', return_value=True):
self.assertTrue(store.rockstar_registry(folder, 'Grand Theft Auto: Vice City', prefix, ''))
text = (prefix / 'pfx/system.reg').read_text()
self.assertIn(r'[Software\\Rockstar Games\\Launcher]', text)
self.assertIn(r'[Software\\Wow6432Node\\Rockstar Games\\Launcher]', text)
self.assertIn('Grand Theft Auto: Vice City', text)
if __name__ == '__main__':
unittest.main()
+22
View File
@@ -1,7 +1,9 @@
import unittest
from tools.release.update_catalog import (
Cache,
asset_for_suffix,
merged_pr,
ci_description,
parse_gradle,
parse_variants,
@@ -10,6 +12,7 @@ from tools.release.update_catalog import (
recent_previews,
release_body_value,
stable_app_release,
unique_previews,
)
@@ -149,6 +152,25 @@ pubg com.tencent.ig -pubg
self.assertEqual("0.2.0", stable_app_release(releases)["tag_name"])
self.assertIsNone(stable_app_release(releases[:1]))
def test_merged_pr_comes_from_the_first_paragraph(self):
body = "**Merged to main** - [PR #2602](https://github.com/Droid-Deck/DroidDeck/pull/2602): fix: x\n\nSee [PR #9](u)."
self.assertEqual(2602, merged_pr({"body": body}))
self.assertEqual(0, merged_pr({"body": "**Pushed to main** without a PR - fix: x"}))
def test_previews_follow_commit_order_not_publish_order(self):
older = {"commit": "a" * 40, "committedAt": 100, "publishedAt": 900}
newer = {"commit": "b" * 40, "committedAt": 200, "publishedAt": 300}
again = {**newer, "publishedAt": 50}
self.assertEqual([newer, older], unique_previews([older, again, newer]))
def test_cache_reuses_commit_facts_from_the_last_catalog(self):
class NoNetwork:
def get(self, path):
raise AssertionError(path)
cache = Cache({"previews": [{"commit": "A" * 40, "author": "dev", "committedAt": 5}]})
self.assertEqual({"author": "dev", "committedAt": 5}, cache.commit(NoNetwork(), "o/r", "a" * 40))
if __name__ == "__main__":
unittest.main()
+66
View File
@@ -0,0 +1,66 @@
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
PROGRAM = r"""
#include <stdio.h>
#include <stdlib.h>
int unsetenv(const char *name) { return -1; }
int setenv(const char *name, const char *value, int overwrite) { return -1; }
int putenv(char *string) { return -1; }
int main(void) {
const char *names[] = {"LIBGL_KOPPER_DISABLE", "LIBGL_KOPPER_DISABLE_X", "ZINK_DEBUG", "VN_DEBUG"};
for (int i = 0; i < 4; i++) {
const char *value = getenv(names[i]);
printf("%s=%s\n", names[i], value ? value : "(unset)");
}
return 0;
}
"""
@unittest.skipUnless(shutil.which("cc"), "needs cc")
class VenusPreloadTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.tmp = Path(tempfile.mkdtemp())
source = cls.tmp / "program.c"
source.write_text(PROGRAM)
cls.program = cls.tmp / "program"
cls.library = cls.tmp / "libvenus.so"
subprocess.run(["cc", "-O2", "-Wall", "-Werror", "-o", str(cls.program), str(source)], check=True)
subprocess.run(["cc", "-O2", "-Wall", "-Werror", "-shared", "-fPIC", "-o", str(cls.library),
str(PRELOAD / "venus.c")], check=True)
@classmethod
def tearDownClass(cls):
shutil.rmtree(cls.tmp, ignore_errors=True)
def values(self, **extra):
env = {"PATH": os.environ.get("PATH", ""), "LD_PRELOAD": str(self.library), **extra}
result = subprocess.run([str(self.program)], env=env, capture_output=True, text=True, check=True)
return dict(line.split("=", 1) for line in result.stdout.splitlines())
def test_kopper_is_kept_when_environment_changes_are_refused(self):
values = self.values(VN_DEBUG="vtest", LIBGL_KOPPER_DISABLE="true", LIBGL_KOPPER_DISABLE_X="1",
ZINK_DEBUG="mem")
self.assertEqual(values["LIBGL_KOPPER_DISABLE"], "(unset)")
self.assertEqual(values["LIBGL_KOPPER_DISABLE_X"], "1")
self.assertEqual(values["ZINK_DEBUG"], "mem")
self.assertEqual(values["VN_DEBUG"], "vtest")
def test_other_sessions_keep_kopper_disabled(self):
self.assertEqual(self.values(LIBGL_KOPPER_DISABLE="true")["LIBGL_KOPPER_DISABLE"], "true")
self.assertEqual(self.values(VN_DEBUG="init", LIBGL_KOPPER_DISABLE="true")["LIBGL_KOPPER_DISABLE"], "true")
def test_absent_variable_is_harmless(self):
self.assertEqual(self.values(VN_DEBUG="vtest")["LIBGL_KOPPER_DISABLE"], "(unset)")
if __name__ == "__main__":
unittest.main()
+267
View File
@@ -0,0 +1,267 @@
import ctypes
import mmap
import shutil
from pathlib import Path
import struct
import subprocess
import tempfile
import unittest
from tools.tests.test_clock_pause_preload import clock_reset_command
from tools.tests.test_output_refresh import extract_function as extract_void_function
from tools.tests.test_scene_limit_hold import extract_function
SOURCE = Path(__file__).resolve().parents[2] / "app/src/main/cpp/waylandcomp/src/clock_domain.c"
HEADER = SOURCE.with_suffix(".h")
@unittest.skipUnless(shutil.which("cc"), "needs a C compiler")
class WaylandClockDomainTest(unittest.TestCase):
def test_host_timestamp_uses_the_guest_domain(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
control = root / "clock"
control.write_bytes(struct.pack("<q", 10_000_000_000))
program = root / "program.c"
program.write_text(
'#include <stdio.h>\n'
'#include "clock_domain.h"\n'
'int main(int argc, char **argv) { (void)argc;\n'
' droiddeck_clock_domain_set_control(argv[1]);\n'
' printf("%lld %u %lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL), '
' droiddeck_clock_domain_now_ms(), (long long)droiddeck_clock_domain_adjust_ns(5LL * 1000000000LL));\n'
' return 0;\n'
'}\n'
)
binary = root / "program"
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)],
check=True)
result = subprocess.run([str(binary), str(control)], capture_output=True, text=True, check=True)
adjusted, now_ms, clamped = map(int, result.stdout.split())
self.assertEqual(adjusted, 20_000_000_000)
self.assertGreaterEqual(now_ms, 0)
self.assertLessEqual(now_ms, 0xFFFFFFFF)
self.assertEqual(clamped, 0)
def test_paced_release_uses_kernel_time_across_pause_offsets(self):
compositor = SOURCE.with_name("compositor.c").read_text()
functions = extract_function(compositor, "now_ns") + "\n" + extract_void_function(compositor, "arm_release_timer")
harness = r'''
#define _GNU_SOURCE
#include <assert.h>
#include <fcntl.h>
#include <poll.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/timerfd.h>
#include <time.h>
#include <unistd.h>
#include "clock_domain.h"
struct pending_release { void *buffer; int64_t at_ns; struct pending_release *next; };
static struct pending_release *g_pending_releases;
static int g_release_timer_fd;
#define wl_list_for_each(pr, list, link) for (pr = *(list); pr; pr = pr->next)
static int buffer_release_blocked(void *buffer) { return buffer != NULL; }
@FUNCTIONS@
int main(int argc, char **argv) {
(void)argc;
droiddeck_clock_domain_set_control(argv[1]);
int control = open(argv[1], O_WRONLY);
assert(control >= 0);
g_release_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
assert(g_release_timer_fd >= 0);
const int64_t offsets[] = {0, 10000000000LL, 300000000000LL};
for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) {
assert(pwrite(control, &offsets[i], sizeof(offsets[i]), 0) == sizeof(offsets[i]));
struct timespec started, ended;
clock_gettime(CLOCK_MONOTONIC, &started);
int64_t start = now_ns();
struct pending_release blocked = {(void *)1, start + 1000000LL, NULL};
struct pending_release release = {NULL, start + 60000000LL, &blocked};
g_pending_releases = &release;
arm_release_timer();
int64_t next_offset = offsets[i] + 10000000000LL;
assert(pwrite(control, &next_offset, sizeof(next_offset), 0) == sizeof(next_offset));
struct pollfd pollfd = {g_release_timer_fd, POLLIN, 0};
assert(poll(&pollfd, 1, 1000) == 1);
clock_gettime(CLOCK_MONOTONIC, &ended);
int64_t elapsed = (ended.tv_sec - started.tv_sec) * 1000000000LL + ended.tv_nsec - started.tv_nsec;
assert(elapsed >= 50000000LL && elapsed < 1000000000LL);
uint64_t expirations;
assert(read(g_release_timer_fd, &expirations, sizeof(expirations)) == sizeof(expirations));
assert(expirations == 1);
g_pending_releases = &blocked;
arm_release_timer();
struct itimerspec remaining;
assert(timerfd_gettime(g_release_timer_fd, &remaining) == 0);
assert(remaining.it_value.tv_sec == 0 && remaining.it_value.tv_nsec == 0);
}
close(g_release_timer_fd);
close(control);
return 0;
}
'''
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
control = root / "clock"
control.write_bytes(struct.pack("<q", 0))
program = root / "program.c"
program.write_text(harness.replace("@FUNCTIONS@", functions))
binary = root / "program"
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent),
"-o", str(binary), str(program), str(SOURCE)], check=True)
subprocess.run([str(binary), str(control)], check=True, timeout=5)
def test_zero_and_missing_offsets_are_unchanged(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
control = root / "clock"
control.write_bytes(struct.pack("<q", 0))
program = root / "program.c"
program.write_text(
'#include <stdio.h>\n'
'#include "clock_domain.h"\n'
'int main(int argc, char **argv) { (void)argc;\n'
' droiddeck_clock_domain_set_control(argv[1]);\n'
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
' droiddeck_clock_domain_set_control(argv[2]);\n'
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
' return 0;\n'
'}\n'
)
binary = root / "program"
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)],
check=True)
result = subprocess.run([str(binary), str(control), str(root / "missing")], capture_output=True, text=True, check=True)
self.assertEqual(result.stdout.split(), ["30000000000", "30000000000"])
def test_replaced_control_file_updates_offset_without_invalidating_readers(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
control = root / "clock"
replacement = root / "replacement"
control.write_bytes(struct.pack("<q", 10_000_000_000))
replacement.write_bytes(struct.pack("<q", 20_000_000_000))
program = root / "program.c"
program.write_text(
'#include <stdio.h>\n'
'#include "clock_domain.h"\n'
'int main(int argc, char **argv) { (void)argc;\n'
' droiddeck_clock_domain_set_control(argv[1]);\n'
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
' if (rename(argv[2], argv[1]) != 0) return 1;\n'
' droiddeck_clock_domain_set_control(argv[1]);\n'
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
' return 0;\n'
'}\n'
)
binary = root / "program"
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)],
check=True)
result = subprocess.run([str(binary), str(control), str(replacement)], capture_output=True, text=True, check=True)
self.assertEqual(result.stdout.split(), ["20000000000", "10000000000"])
def test_session_transition_clears_stale_offset_but_live_failures_preserve_it(self):
harness = r'''
#include <assert.h>
#include <fcntl.h>
#include <stdint.h>
#include <unistd.h>
#include "clock_domain.h"
int main(int argc, char **argv) {
(void)argc;
int64_t shift = 10000000000LL;
int fd = open(argv[1], O_CREAT | O_RDWR, 0600);
assert(fd >= 0);
assert(write(fd, &shift, sizeof(shift)) == sizeof(shift));
droiddeck_clock_domain_set_control(argv[1]);
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL);
assert(unlink(argv[1]) == 0);
droiddeck_clock_domain_set_control(argv[1]);
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL);
int replacement = open(argv[1], O_CREAT | O_RDWR, 0600);
assert(replacement >= 0);
droiddeck_clock_domain_set_control(argv[1]);
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL);
droiddeck_clock_domain_set_control(NULL);
droiddeck_clock_domain_set_control(argv[1]);
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 30000000000LL);
shift = 20000000000LL;
assert(write(replacement, &shift, sizeof(shift)) == sizeof(shift));
droiddeck_clock_domain_set_control(argv[1]);
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 10000000000LL);
close(replacement);
close(fd);
return 0;
}
'''
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
program = root / "program.c"
program.write_text(harness)
binary = root / "program"
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent),
"-o", str(binary), str(program), str(SOURCE)], check=True)
subprocess.run([str(binary), str(root / "clock")], check=True, timeout=5)
host = SOURCE.parents[3] / "java/com/droiddeck/launcher/wayland/CompositorHost.kt"
self.assertIn("nativeSetClockControl(null)", host.read_text().split("fun newSession() {", 1)[1].split("}", 1)[0])
def test_startup_reset_keeps_host_and_guest_on_the_same_inode(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
control = root / "clock"
control.write_bytes(struct.pack("<q", 10_000_000_000))
library = root / "clock.so"
subprocess.run(["cc", "-shared", "-fPIC", "-pthread", "-Wall", "-Wextra", "-Werror",
"-o", str(library), str(SOURCE)], check=True)
host = ctypes.CDLL(str(library))
host.droiddeck_clock_domain_set_control.argtypes = [ctypes.c_char_p]
host.droiddeck_clock_domain_adjust_ns.argtypes = [ctypes.c_int64]
host.droiddeck_clock_domain_adjust_ns.restype = ctypes.c_int64
host.droiddeck_clock_domain_set_control(str(control).encode())
with control.open("r+b") as file, mmap.mmap(file.fileno(), 8) as guest:
inode = control.stat().st_ino
subprocess.run(["bash", "-c", clock_reset_command(control)],
check=True, timeout=5)
self.assertEqual(control.stat().st_ino, inode)
self.assertEqual(struct.unpack("<q", guest[:])[0], 0)
self.assertEqual(host.droiddeck_clock_domain_adjust_ns(30_000_000_000), 30_000_000_000)
file.seek(0)
file.write(struct.pack("<q", 20_000_000_000))
file.flush()
self.assertEqual(struct.unpack("<q", guest[:])[0], 20_000_000_000)
self.assertEqual(host.droiddeck_clock_domain_adjust_ns(30_000_000_000), 10_000_000_000)
host.droiddeck_clock_domain_set_control(None)
def test_initially_missing_control_is_mapped_after_creation(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
control = root / "clock"
replacement = root / "replacement"
replacement.write_bytes(struct.pack("<q", 20_000_000_000))
program = root / "program.c"
program.write_text(
'#include <stdio.h>\n'
'#include "clock_domain.h"\n'
'int main(int argc, char **argv) { (void)argc;\n'
' droiddeck_clock_domain_set_control(argv[1]);\n'
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
' if (rename(argv[2], argv[1]) != 0) return 1;\n'
' droiddeck_clock_domain_set_control(argv[1]);\n'
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
' return 0;\n'
'}\n'
)
binary = root / "program"
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent),
"-o", str(binary), str(program), str(SOURCE)], check=True)
result = subprocess.run([str(binary), str(control), str(replacement)], capture_output=True, text=True, check=True)
self.assertEqual(result.stdout.split(), ["30000000000", "10000000000"])
if __name__ == "__main__":
unittest.main()
+50 -3
View File
@@ -9,9 +9,16 @@ PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
PROGRAM = r"""
#include <stdio.h>
char *const *bl_webhelper_argv(const char *path, char *const argv[]);
#include <stdlib.h>
char *const *bl_webhelper_argv(const char *path, char *const argv[], char *const envp[]);
int main(int argc, char **argv) {
char *const *out = bl_webhelper_argv(argv[1], argv + 1);
const char *mode = getenv("TEST_NODE_MODE_CHILD");
static char node[64];
snprintf(node, sizeof node, "ELECTRON_RUN_AS_NODE=%s", mode ? mode : "");
char *node_env[] = {node, NULL};
char *plain_env[] = {"PATH=/usr/bin", NULL};
char *const *envp = mode ? node_env : plain_env;
char *const *out = bl_webhelper_argv(argv[1], argv + 1, (char *const *)envp);
for (int i = 0; out[i]; i++) printf("%s\n", out[i]);
return 0;
}
@@ -35,13 +42,28 @@ class WebhelperPreloadTest(unittest.TestCase):
def tearDownClass(cls):
shutil.rmtree(cls.tmp, ignore_errors=True)
def argv(self, *args, spec=None):
def argv(self, *args, spec=None, node_child=False, parent_node=False):
env = {k: v for k, v in os.environ.items() if k != "BL_WEBHELPER_ARGS"}
env.pop("ELECTRON_RUN_AS_NODE", None)
if spec is not None:
env["BL_WEBHELPER_ARGS"] = spec
if node_child is not False:
env["TEST_NODE_MODE_CHILD"] = "1" if node_child is True else node_child
else:
env.pop("TEST_NODE_MODE_CHILD", None)
if parent_node:
env["ELECTRON_RUN_AS_NODE"] = "1"
result = subprocess.run([str(self.program), *args], env=env, capture_output=True, text=True, check=True)
return result.stdout.splitlines()
def chromium(self, directory, name):
root = self.tmp / directory
root.mkdir(exist_ok=True)
executable = root / name
executable.touch()
(root / "chrome-sandbox").touch()
return str(executable)
def test_the_browser_process_keeps_its_helpers_in_process(self):
out = self.argv(WEBHELPER, "-lang=en_US", "--enable-features=A", "--no-sandbox", "--disable-features=B,C")
self.assertEqual(out, [WEBHELPER, "-lang=en_US", "--no-sandbox", "--no-zygote", "--in-process-gpu",
@@ -57,6 +79,31 @@ class WebhelperPreloadTest(unittest.TestCase):
other = ["/usr/bin/steam", "--enable-features=A"]
self.assertEqual(self.argv(*other), other)
def test_node_mode_from_the_child_environment_skips_sandbox_injection(self):
code = self.chromium("vscode", "code")
self.assertEqual(self.argv(code, node_child=True), [code])
def test_any_nonempty_node_mode_value_skips_sandbox_injection(self):
code = self.chromium("vscode-true", "code")
for value in ("true", "0", "yes"):
self.assertEqual(self.argv(code, node_child=value), [code])
def test_empty_node_mode_value_still_gets_sandbox_flag(self):
chrome = self.chromium("chromium-empty-mode", "chrome")
self.assertEqual(self.argv(chrome, node_child=""), [chrome, "--no-sandbox"])
def test_non_browser_helper_beside_chrome_sandbox_skips_injection_in_node_mode(self):
helper = self.chromium("vscode-helper", "remote-cli")
self.assertEqual(self.argv(helper, node_child=True), [helper])
def test_chromium_gui_launch_still_gets_sandbox_flag_from_explicit_environment(self):
chrome = self.chromium("chromium", "chrome")
self.assertEqual(self.argv(chrome), [chrome, "--no-sandbox"])
def test_parent_node_mode_does_not_override_the_explicit_child_environment(self):
chrome = self.chromium("chromium-parent-mode", "chrome")
self.assertEqual(self.argv(chrome, parent_node=True), [chrome, "--no-sandbox"])
def test_stock_turns_it_off(self):
args = [WEBHELPER, "--enable-features=A"]
self.assertEqual(self.argv(*args, spec="stock"), args)
+12
View File
@@ -92,6 +92,18 @@ class WinComponentsTest(unittest.TestCase):
self.assertEqual(names, ["ucrtbase"])
self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/ucrtbase.dll"), 0x8664)
def test_x64_visual_cpp_runtime_is_placed_in_arm64_system32(self):
proton = self.proton()
self.component("vc", ["msvcp140", "vcruntime140_1"], {
"system32/msvcp140.dll": self.pe_image(0x8664),
"system32/vcruntime140_1.dll": self.pe_image(0x8664),
})
self.pick("vc")
names, _ = self.apply(proton)
self.assertEqual(names, ["msvcp140", "vcruntime140_1"])
self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/msvcp140.dll"), 0x8664)
self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/vcruntime140_1.dll"), 0x8664)
def test_compatible_copy_keeps_override_when_other_architecture_copy_is_skipped(self):
proton = self.proton()
self.component("vc", ["ucrtbase"], {