From eb5aa7a53649012ccc7aa67b802bfcf48864bac1 Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Tue, 17 Nov 2026 17:05:38 -0500 Subject: [PATCH] fix: seed redist markers into new prefixes before install scripts (#2327) * fix: initialize Proton prefix before install scripts * game-env: start Proton first only for a new prefix * fix: wait for new prefix wineserver before seeding * game-env: find wineserver in either Proton layout * fix(steam): skip redist seeding when wineserver wait fails * fix(steam): probe new prefixes only when Proton has no template prefix * fix(steam): check the active Proton prefix template before seeding * fix(steam): use effective environment for redist seeding --- .../overlay/usr/local/bin/droiddeck-game-env | 23 ++- tools/tests/test_game_environment.py | 152 +++++++++++++++++- 2 files changed, 167 insertions(+), 8 deletions(-) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env index ef73b33156..e8c4224ef7 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env @@ -2,6 +2,7 @@ import hashlib import json import os +import platform import re import runpy import signal @@ -753,6 +754,26 @@ def mark_install_scripts(command, env): scripts = [path for path in scripts if os.path.isfile(path)] if not scripts: return [] + data = env.get("STEAM_COMPAT_DATA_PATH") + tool = os.path.dirname(command[0]) + new_prefix = data and not os.path.isfile(os.path.join(data, "pfx", "system.reg")) + template = "default_pfx" + if env.get("PROTON_USE_ARM64", "1") == "1" and platform.machine() == "aarch64" and os.path.isdir(os.path.join(tool, "files/bin-arm64")): + template = "default_pfx_arm64" + if new_prefix and not os.path.isfile(os.path.join(tool, "files/share", template, "system.reg")): + try: + subprocess.run([command[0], "run", "cmd.exe", "/c", "exit", "0"], env=env, + stdout=sys.stderr, stderr=sys.stderr, timeout=120, check=False) + except (OSError, subprocess.SubprocessError) as error: + print("droiddeck-game-env: prefix initialization failed (%s)" % error, file=sys.stderr) + try: + wineserver = next((path for path in (os.path.join(tool, "files", name, "wineserver") for name in ("bin-arm64", "bin")) + if os.access(path, os.X_OK)), os.path.join(tool, "files/bin-arm64/wineserver")) + subprocess.run([wineserver, "-w"], env=dict(env, WINEPREFIX=os.path.join(data, "pfx")), + stdout=sys.stderr, stderr=sys.stderr, timeout=120, check=True) + except (OSError, subprocess.SubprocessError) as error: + print("droiddeck-game-env: wineserver wait failed (%s)" % error, file=sys.stderr) + return scripts try: subprocess.run([SEED_REDISTS, root], env=dict(env, DROIDDECK_SEED_SCRIPTS="\n".join(scripts)), stdout=sys.stderr, timeout=60, check=False) @@ -1338,7 +1359,7 @@ def main(): if fixed: print("droiddeck-game-env: replaced foreign-architecture system DLLs with this Proton's own: %s" % ", ".join(fixed), file=sys.stderr) - scripts = mark_install_scripts(command, env) + scripts = mark_install_scripts(command, effective_env) if scripts and install_scripts_done(scripts, env): print("droiddeck-game-env: install scripts already run in this prefix; evaluator skipped", file=sys.stderr) return 0 diff --git a/tools/tests/test_game_environment.py b/tools/tests/test_game_environment.py index ad81472015..ac4d5e1927 100644 --- a/tools/tests/test_game_environment.py +++ b/tools/tests/test_game_environment.py @@ -803,11 +803,11 @@ class GameEnvironmentTest(unittest.TestCase): config.parent.mkdir(parents=True) config.write_text(json.dumps({"version": 1, "shared": {"PROTON_USE_ARM64": "1"}, "games": {"42": {"PROTON_USE_ARM64": "0"}}})) - seen_components, seen_repair, seen_start = [], [], [] + seen_components, seen_repair, seen_start, seen_mark = [], [], [], [] globals = MODULE["main"].__globals__ stubs = { "game_gpu": lambda env: env, - "mark_install_scripts": lambda command, env: [], + "mark_install_scripts": lambda command, env: seen_mark.append(env.copy()) or [], "install_scripts_done": lambda scripts, env: False, "scripts_digest": lambda scripts: None, "win_components": lambda *args: seen_components.append(args[3]) or "", @@ -844,6 +844,15 @@ class GameEnvironmentTest(unittest.TestCase): self.assertEqual(["0"], [env["PROTON_USE_ARM64"] for env in seen_components]) self.assertEqual(["0"], [env["PROTON_USE_ARM64"] for env in seen_repair]) self.assertEqual(["0"], [env["PROTON_USE_ARM64"] for env in seen_start]) + self.assertEqual(["0"], [env["PROTON_USE_ARM64"] for env in seen_mark]) + seen_mark.clear() + seen_start.clear() + command[1] = "run" + with patch.dict(os.environ, environment, clear=True), patch.object(sys, "argv", ["game-env", *command]), \ + patch.dict(globals, stubs): + self.assertEqual(MODULE["main"](), 7) + self.assertEqual(["1"], [env["PROTON_USE_ARM64"] for env in seen_mark]) + self.assertEqual(["1"], [env["PROTON_USE_ARM64"] for env in seen_start]) def test_keyboard_helper_is_off_unless_steam_keyboard_or_the_user_wants_it(self): cases = ( @@ -984,6 +993,9 @@ class GameEnvironmentTest(unittest.TestCase): def test_the_install_script_evaluator_gets_its_scripts_marked_first(self): with tempfile.TemporaryDirectory() as tmp: root = Path(tmp) + (root / "files/bin-arm64").mkdir(parents=True) + (root / "files/bin-arm64/wineserver").write_text("") + (root / "files/bin-arm64/wineserver").chmod(0o755) script = root / "legacycompat/evaluatorscript_409710.vdf" script.parent.mkdir(parents=True) script.write_text("{}") @@ -991,14 +1003,140 @@ class GameEnvironmentTest(unittest.TestCase): run = MODULE["mark_install_scripts"].__globals__["subprocess"].run MODULE["mark_install_scripts"].__globals__["subprocess"].run = lambda args, **kw: calls.append((args, kw["env"])) try: - env = {"STEAM_COMPAT_CLIENT_INSTALL_PATH": str(root)} - MODULE["mark_install_scripts"](["/proton", "run", str(root / "legacycompat/iscriptevaluator.exe"), "legacycompat\\evaluatorscript_409710.vdf"], env) + env = {"STEAM_COMPAT_CLIENT_INSTALL_PATH": str(root), "STEAM_COMPAT_DATA_PATH": str(root / "compatdata/409710")} + evaluator = [str(root / "proton"), "run", str(root / "legacycompat/iscriptevaluator.exe"), "legacycompat\\evaluatorscript_409710.vdf"] + MODULE["mark_install_scripts"](evaluator, env) MODULE["mark_install_scripts"](["/proton", "waitforexitandrun", "/game/Game.exe"], env) + self.assertEqual(len(calls), 3) + self.assertEqual(calls[0][0], [str(root / "proton"), "run", "cmd.exe", "/c", "exit", "0"]) + self.assertEqual(calls[0][1], env) + self.assertEqual(calls[1][0], [str(root / "files/bin-arm64/wineserver"), "-w"]) + self.assertEqual(calls[1][1]["WINEPREFIX"], str(root / "compatdata/409710/pfx")) + self.assertEqual(calls[1][1].get("DROIDDECK_SEED_SCRIPTS"), None) + self.assertEqual(calls[2][0][1], str(root)) + self.assertEqual(calls[2][1]["DROIDDECK_SEED_SCRIPTS"], str(script)) + (root / "compatdata/409710/pfx").mkdir(parents=True) + (root / "compatdata/409710/pfx/system.reg").write_text("") + calls.clear() + MODULE["mark_install_scripts"](evaluator, env) + self.assertEqual([args[0] for args, _ in calls], [MODULE["SEED_REDISTS"]]) finally: MODULE["mark_install_scripts"].__globals__["subprocess"].run = run - self.assertEqual(len(calls), 1) - self.assertEqual(calls[0][0][1], str(root)) - self.assertEqual(calls[0][1]["DROIDDECK_SEED_SCRIPTS"], str(script)) + + def test_the_install_script_seeder_runs_when_prefix_probe_times_out(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "files/bin-arm64").mkdir(parents=True) + (root / "files/bin-arm64/wineserver").write_text("") + (root / "files/bin-arm64/wineserver").chmod(0o755) + script = root / "legacycompat/evaluatorscript_409710.vdf" + script.parent.mkdir(parents=True) + script.write_text("{}") + calls = [] + run = MODULE["mark_install_scripts"].__globals__["subprocess"].run + + def fake_run(args, **kwargs): + calls.append((args, kwargs["env"])) + if len(calls) == 1: + raise subprocess.TimeoutExpired(args, 120) + + MODULE["mark_install_scripts"].__globals__["subprocess"].run = fake_run + try: + env = {"STEAM_COMPAT_CLIENT_INSTALL_PATH": str(root), "STEAM_COMPAT_DATA_PATH": str(root / "compatdata/409710")} + MODULE["mark_install_scripts"]([str(root / "proton"), "run", str(root / "legacycompat/iscriptevaluator.exe"), "legacycompat\\evaluatorscript_409710.vdf"], env) + self.assertEqual(calls[1][0], [str(root / "files/bin-arm64/wineserver"), "-w"]) + self.assertEqual(calls[2][0][0], MODULE["SEED_REDISTS"]) + finally: + MODULE["mark_install_scripts"].__globals__["subprocess"].run = run + + def test_the_install_script_seeder_skips_failed_wineserver_waits(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + script = root / "legacycompat/evaluatorscript_409710.vdf" + script.parent.mkdir(parents=True) + script.write_text("{}") + env = {"STEAM_COMPAT_CLIENT_INSTALL_PATH": str(root), "STEAM_COMPAT_DATA_PATH": str(root / "compatdata/409710")} + evaluator = [str(root / "proton"), "run", str(root / "legacycompat/iscriptevaluator.exe"), "legacycompat\\evaluatorscript_409710.vdf"] + wineserver = str(root / "files/bin-arm64/wineserver") + run = MODULE["mark_install_scripts"].__globals__["subprocess"].run + for failure in (subprocess.TimeoutExpired([wineserver, "-w"], 120), OSError("cannot start"), + subprocess.CalledProcessError(1, [wineserver, "-w"])): + with self.subTest(failure=type(failure).__name__): + calls = [] + + def fake_run(args, **kwargs): + calls.append((args, kwargs)) + if len(calls) == 2: + self.assertTrue(kwargs["check"]) + raise failure + + MODULE["mark_install_scripts"].__globals__["subprocess"].run = fake_run + try: + self.assertEqual(MODULE["mark_install_scripts"](evaluator, env), [str(script)]) + self.assertEqual(len(calls), 2) + self.assertEqual(calls[1][0], [wineserver, "-w"]) + self.assertEqual(calls[1][1]["env"]["WINEPREFIX"], str(root / "compatdata/409710/pfx")) + finally: + MODULE["mark_install_scripts"].__globals__["subprocess"].run = run + + def run_install_marker(self, root, env): + script = root / "legacycompat/evaluatorscript_409710.vdf" + script.parent.mkdir(parents=True, exist_ok=True) + script.write_text("{}") + calls = [] + module = MODULE["mark_install_scripts"].__globals__["subprocess"] + run = module.run + module.run = lambda args, **kw: calls.append((args, kw["env"])) + try: + evaluator = [str(root / "proton"), "run", str(root / "legacycompat/iscriptevaluator.exe"), "legacycompat\\evaluatorscript_409710.vdf"] + self.assertEqual(MODULE["mark_install_scripts"](evaluator, env), [str(script)]) + finally: + module.run = run + return calls + + def test_the_install_script_wait_finds_wineserver_in_files_bin(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "files/bin").mkdir(parents=True) + (root / "files/bin/wineserver").write_text("") + (root / "files/bin/wineserver").chmod(0o755) + calls = self.run_install_marker(root, {"STEAM_COMPAT_CLIENT_INSTALL_PATH": str(root), + "STEAM_COMPAT_DATA_PATH": str(root / "compatdata/409710")}) + self.assertEqual(calls[1][0], [str(root / "files/bin/wineserver"), "-w"]) + self.assertEqual(calls[2][0][0], MODULE["SEED_REDISTS"]) + + def test_the_install_script_seeder_skips_the_probe_without_compat_data(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + calls = self.run_install_marker(root, {"STEAM_COMPAT_CLIENT_INSTALL_PATH": str(root)}) + self.assertEqual([args[0] for args, _ in calls], [MODULE["SEED_REDISTS"]]) + + def test_the_install_script_seeder_checks_only_the_selected_template(self): + for machine in ("aarch64", "x86_64"): + for setting in (None, "1", "0", ""): + for arm64_bin in (False, True): + for template in ("default_pfx", "default_pfx_arm64"): + with self.subTest(machine=machine, setting=setting, arm64_bin=arm64_bin, template=template): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + if arm64_bin: + (root / "files/bin-arm64").mkdir(parents=True) + reg = root / "files/share" / template / "system.reg" + reg.parent.mkdir(parents=True) + reg.write_text("") + env = {"STEAM_COMPAT_CLIENT_INSTALL_PATH": str(root), + "STEAM_COMPAT_DATA_PATH": str(root / "compatdata/409710")} + if setting is not None: + env["PROTON_USE_ARM64"] = setting + before = dict(env) + with patch("platform.machine", return_value=machine): + calls = self.run_install_marker(root, env) + selected = "default_pfx_arm64" if machine == "aarch64" and arm64_bin and setting in (None, "1") else "default_pfx" + expected = [MODULE["SEED_REDISTS"]] + if template != selected: + expected = [str(root / "proton"), str(root / ("files/bin-arm64/wineserver")), *expected] + self.assertEqual([args[0] for args, _ in calls], expected) + self.assertEqual(env, before) SCRIPT = ('"evaluatorscript" { "0" { "appid" "228980" "compat_installscript" { "run process" { ' '"x64 14.28.29334.0" { "hasrunkey" "HKEY_LOCAL_MACHINE\\\\Software\\\\Valve\\\\Steam\\\\Apps\\\\CommonRedist\\\\vcredist\\\\2019" '