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
This commit is contained in:
MaxsTechReview authored and GitHub committed 2026-11-17 17:05:38 -05:00
1 parent cbde8b1f25
commit eb5aa7a536
2 files changed
+167 -8

No files matched your search

@@ -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
+145 -7
View File
@@ -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" '