mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 12:56:06 +00:00
* chore: consistent code branding * fix: carry legacy overrides, queues and live sync rows across the rename * fix: keep queued legacy overrides on a failed rename and separate merged queue entries
343 lines
15 KiB
Python
343 lines
15 KiB
Python
#!/usr/bin/python3
|
|
import fcntl
|
|
import errno
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import runpy
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
|
|
BIN = Path(__file__).resolve().parent
|
|
IDLE = {"wineserver", "services.exe", "winedevice.exe", "explorer.exe", "rpcss.exe", "plugplay.exe",
|
|
"conhost.exe", "lsass.exe", "svchost.exe", "steam.exe", "wineboot.exe", "winemenubuilder.exe"}
|
|
|
|
|
|
def control(folder):
|
|
folder = Path(folder).resolve(strict=True)
|
|
root = folder / ".droiddeck-gog"
|
|
if root.is_symlink():
|
|
raise ValueError("GOG control directory is a symbolic link")
|
|
root.mkdir(exist_ok=True)
|
|
return root
|
|
|
|
|
|
def read(path):
|
|
if path.is_symlink():
|
|
raise ValueError("GOG metadata is a symbolic link")
|
|
return json.loads(path.read_text(encoding="utf-8"))
|
|
|
|
|
|
def write(path, value):
|
|
if path.is_symlink():
|
|
raise ValueError("GOG metadata is a symbolic link")
|
|
descriptor, name = tempfile.mkstemp(prefix=path.name + ".", suffix=".new", dir=path.parent)
|
|
temporary = Path(name)
|
|
try:
|
|
with os.fdopen(descriptor, "w") as stream:
|
|
json.dump(value, stream)
|
|
stream.flush()
|
|
os.fsync(stream.fileno())
|
|
os.replace(temporary, path)
|
|
directory = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY)
|
|
try:
|
|
try:
|
|
os.fsync(directory)
|
|
except OSError as error:
|
|
if error.errno not in (errno.EINVAL, errno.ENOTSUP):
|
|
raise
|
|
finally:
|
|
os.close(directory)
|
|
finally:
|
|
temporary.unlink(missing_ok=True)
|
|
|
|
|
|
def lock_file(root):
|
|
return os.fdopen(os.open(root / "lease", os.O_RDWR | os.O_CREAT | os.O_NOFOLLOW, 0o600), "r+")
|
|
|
|
|
|
def generation(pid):
|
|
try:
|
|
return Path("/proc/%s/stat" % pid).read_text().rsplit(")", 1)[1].split()[19]
|
|
except (OSError, IndexError):
|
|
return None
|
|
|
|
|
|
def lease(folder, owner):
|
|
root = control(folder)
|
|
with lock_file(root) as stream:
|
|
fcntl.lockf(stream, fcntl.LOCK_SH | fcntl.LOCK_NB)
|
|
sidecar = read(Path(folder) / ".droiddeck-store.json")
|
|
if sidecar.get("state", "installed") != "installed":
|
|
raise ValueError("Resume or recover the GOG update before playing")
|
|
journal = root / "operation.json"
|
|
if journal.exists() and read(journal).get("phase") != "download":
|
|
raise ValueError("GOG maintenance is incomplete")
|
|
start = generation(owner)
|
|
if start is None:
|
|
raise ValueError("Game launcher has exited")
|
|
print("ready", flush=True)
|
|
sys.stdout.close()
|
|
while generation(owner) == start:
|
|
time.sleep(0.25)
|
|
return 0
|
|
|
|
|
|
def desktop_environment(base, proc=Path("/proc")):
|
|
env = dict(base)
|
|
if env.get("DROIDDECK_GOG_DESKTOP") != "1":
|
|
return env
|
|
deadline = time.monotonic() + 45
|
|
while True:
|
|
for entry in proc.iterdir():
|
|
if not entry.name.isdigit():
|
|
continue
|
|
try:
|
|
command = (entry / "cmdline").read_bytes().split(b"\0")[0]
|
|
if command != b"/usr/bin/plasmashell":
|
|
continue
|
|
values = dict(os.fsdecode(item).split("=", 1) for item in (entry / "environ").read_bytes().split(b"\0") if b"=" in item)
|
|
if values.get("DD_DESKTOP") != "1" or values.get("XDG_RUNTIME_DIR") != env.get("XDG_RUNTIME_DIR"):
|
|
continue
|
|
if not values.get("DISPLAY") or values.get("WAYLAND_DISPLAY") == env.get("WAYLAND_DISPLAY"):
|
|
continue
|
|
for key in ("DISPLAY", "WAYLAND_DISPLAY", "XAUTHORITY", "DBUS_SESSION_BUS_ADDRESS", "DD_DESKTOP"):
|
|
if key in values:
|
|
env[key] = values[key]
|
|
return env
|
|
except (OSError, ValueError):
|
|
continue
|
|
if time.monotonic() >= deadline:
|
|
raise ValueError("The desktop display is not ready; resume the Linux session and verify recovery before retrying")
|
|
time.sleep(0.25)
|
|
|
|
|
|
def target_for(folder, appid, game):
|
|
run = runpy.run_path(str(BIN / "droiddeck-proton-run"))["main"].__globals__
|
|
root = os.environ.get("STEAM_COMPAT_CLIENT_INSTALL_PATH") or run["STEAM_ROOT"]
|
|
target = run["shortcut_target"](str(int(appid) & 0xffffffff), str(game), str(folder), root)
|
|
target.install = str(folder)
|
|
return run, root, target
|
|
|
|
|
|
def runner(folder, appid, game, graphical=False):
|
|
run, root, target = target_for(folder, appid, game)
|
|
available = run["tools"](root)
|
|
name, _ = run["choose_tool"](target.appid, run["mapping"](root), available)
|
|
if name is None:
|
|
raise ValueError("No Proton tool is installed for this game")
|
|
tool, command = available[name]
|
|
base = desktop_environment(os.environ) if graphical else dict(os.environ)
|
|
env = run["environment"](base, target, tool, root, window=base.get("DD_DESKTOP") == "1")
|
|
env["DROIDDECK_GOG_MAINTENANCE"] = "1"
|
|
env["FEX_X87REDUCEDPRECISION"] = "0"
|
|
env.pop("DD_STORE_EXIT", None)
|
|
return str(Path(tool) / command), env, target.compatdata
|
|
|
|
|
|
def active(prefix, proc=Path("/proc")):
|
|
result = []
|
|
prefix = os.path.realpath(os.path.join(prefix, "pfx"))
|
|
for entry in proc.iterdir():
|
|
if not entry.name.isdigit():
|
|
continue
|
|
try:
|
|
env = dict(part.split(b"=", 1) for part in (entry / "environ").read_bytes().split(b"\0") if b"=" in part)
|
|
if os.path.realpath(os.fsdecode(env.get(b"WINEPREFIX", b""))) != prefix:
|
|
continue
|
|
args = (entry / "cmdline").read_bytes().split(b"\0")
|
|
name = os.fsdecode(args[0]).replace("\\", "/").rsplit("/", 1)[-1].lower()
|
|
if name not in IDLE:
|
|
result.append(int(entry.name))
|
|
except (OSError, ValueError):
|
|
continue
|
|
return result
|
|
|
|
|
|
def idle(folder, appid, game):
|
|
_, _, target = target_for(folder, appid, game)
|
|
if active(target.compatdata):
|
|
raise ValueError("Close the GOG game before maintenance")
|
|
return 0
|
|
|
|
|
|
def validate_installer(folder, installer):
|
|
root = control(folder)
|
|
path = Path(installer)
|
|
if path.is_symlink() or not path.resolve(strict=True).is_relative_to(root / "downloads") or path.suffix.lower() != ".exe":
|
|
raise ValueError("The patch executable is outside GOG download storage")
|
|
with path.open("rb") as stream:
|
|
if stream.read(2) != b"MZ":
|
|
raise ValueError("The GOG patch is not a Windows executable")
|
|
return path
|
|
|
|
|
|
def installer_arguments(path):
|
|
with path.open("rb") as stream:
|
|
data = stream.read(4 * 1024 * 1024)
|
|
return ["/NOGUI"] if b"Inno Setup Setup Data" in data else []
|
|
|
|
|
|
def start(folder, appid, installer, game):
|
|
root = control(folder)
|
|
validate_installer(folder, installer)
|
|
with lock_file(root) as stream:
|
|
fcntl.lockf(stream, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
|
journal = read(root / "operation.json")
|
|
if journal.get("phase") != "patch-ready":
|
|
raise ValueError("The patch must be selected again before it can run")
|
|
idle(folder, appid, game)
|
|
journal["phase"] = "patch-starting"
|
|
write(root / "operation.json", journal)
|
|
write(root / "patch-status.json", {"state": "starting", "startedAt": time.time()})
|
|
with (root / "patch.log").open("ab") as log:
|
|
subprocess.Popen([sys.executable, str(Path(__file__).resolve()), "run", folder, appid, installer, game],
|
|
stdin=subprocess.DEVNULL, stdout=log, stderr=log, start_new_session=True, close_fds=True)
|
|
return 0
|
|
|
|
|
|
def status(folder):
|
|
root = control(folder)
|
|
path = root / "patch-status.json"
|
|
result = read(path)
|
|
ended = result.get("state") == "running" and generation(result.get("pid")) != result.get("generation")
|
|
abandoned = result.get("state") == "starting" and time.time() - result.get("startedAt", 0) > 60
|
|
if ended or abandoned:
|
|
result = {"state": "uncertain", "reason": "The patch helper ended without a confirmed result; verify recovery before retrying"}
|
|
write(path, result)
|
|
journal = read(root / "operation.json")
|
|
journal["phase"] = "patch-uncertain"
|
|
write(root / "operation.json", journal)
|
|
print(json.dumps(result), flush=True)
|
|
return 0
|
|
|
|
|
|
def run_patch(folder, appid, installer, game):
|
|
root = control(folder)
|
|
try:
|
|
with lock_file(root) as stream:
|
|
fcntl.lockf(stream, fcntl.LOCK_EX)
|
|
path = validate_installer(folder, installer)
|
|
command, env, prefix = runner(folder, appid, game, True)
|
|
if active(prefix):
|
|
raise ValueError("Close the GOG game before applying the patch")
|
|
journal = read(root / "operation.json")
|
|
if journal.get("phase") != "patch-starting":
|
|
raise ValueError("The patch is already running or needs recovery")
|
|
journal["phase"] = "patch-applying"
|
|
write(root / "operation.json", journal)
|
|
sidecar_path = Path(folder) / ".droiddeck-store.json"
|
|
sidecar = read(sidecar_path)
|
|
sidecar["state"] = "updating"
|
|
write(sidecar_path, sidecar)
|
|
installed_path = root / "installed.json"
|
|
if installed_path.is_file():
|
|
installed = read(installed_path)
|
|
installed.update(verified=False, manifest={}, files=[])
|
|
write(installed_path, installed)
|
|
write(root / "patch-status.json", {"state": "running", "pid": os.getpid(), "generation": generation(os.getpid())})
|
|
os.makedirs(prefix, exist_ok=True)
|
|
setup = runpy.run_path(str(BIN / "droiddeck-store-launch"))["main"].__globals__
|
|
previous = dict(os.environ)
|
|
try:
|
|
os.environ.update(env)
|
|
pfx = Path(prefix) / "pfx"
|
|
if not (pfx / "system.reg").is_file() or not (pfx / "drive_c/windows/system32/reg.exe").is_file():
|
|
subprocess.run([command, "run", "wineboot.exe", "-u"], env=env, timeout=90, check=True)
|
|
if not (pfx / "drive_c/windows/system32/reg.exe").is_file():
|
|
raise ValueError("Proton did not initialize the game's registry tool")
|
|
result = setup["apply_gog_registry"](Path(folder), prefix, command, installation=journal.get("before"))
|
|
if not result.startswith(("ready", "written=")):
|
|
raise ValueError("GOG registry preparation failed; the patch was not applied")
|
|
prepare_setup(folder, command, env)
|
|
finally:
|
|
os.environ.clear(); os.environ.update(previous)
|
|
proc = subprocess.Popen([command, "run", str(path), *installer_arguments(path)], cwd=str(path.parent), env=env)
|
|
code = proc.wait()
|
|
quiet_at = time.monotonic()
|
|
while True:
|
|
if active(prefix):
|
|
quiet_at = time.monotonic()
|
|
elif time.monotonic() - quiet_at >= 2:
|
|
break
|
|
time.sleep(0.25)
|
|
journal["phase"] = "patch-uncertain"
|
|
write(root / "operation.json", journal)
|
|
if code:
|
|
raise ValueError("GOG patch installer exited with code %d; inspect patch.log" % code)
|
|
write(root / "patch-status.json", {"state": "done", "exitCode": code})
|
|
return 0
|
|
except Exception as error:
|
|
write(root / "patch-status.json", {"state": "failed", "reason": str(error)})
|
|
return 1
|
|
|
|
|
|
def prepare_setup(folder, command, env):
|
|
root = control(folder)
|
|
record_path = root / "installed.json"
|
|
if not record_path.is_file():
|
|
return
|
|
journal = read(root / "operation.json")
|
|
record = journal.get("before") or read(record_path)
|
|
manifest = record.get("manifest", {})
|
|
if not record.get("build"):
|
|
return
|
|
info_path = Path(folder) / ("goggame-%s.info" % record["id"])
|
|
language = read(info_path).get("language", "") if info_path.is_file() else ""
|
|
legacy = manifest.get("product", {})
|
|
products = manifest.get("products", []) if not legacy else [
|
|
{"productId": str(item["gameID"]), "temp_executable": item["executable"].lstrip("/\\")}
|
|
for item in legacy.get("support_commands", [])
|
|
if "Neutral" in item.get("languages", []) or record.get("language") in item.get("languages", []) or language in item.get("languages", [])]
|
|
for product in products:
|
|
if str(product.get("productId")) not in record.get("products", []):
|
|
continue
|
|
program = None
|
|
if manifest.get("scriptInterpreter"):
|
|
if not (Path(folder) / ("goggame-%s.script" % product["productId"])).is_file():
|
|
continue
|
|
program = Path(folder) / "support/__redist/ISI/scriptinterpreter.exe"
|
|
elif product.get("temp_executable"):
|
|
relative = product["temp_executable"].replace("\\", "/")
|
|
for candidate in (Path(folder) / "support" / str(product["productId"]) / relative, Path(folder) / relative):
|
|
if candidate.is_file():
|
|
program = candidate
|
|
break
|
|
if program is None:
|
|
continue
|
|
if not program.resolve(strict=True).is_relative_to(Path(folder).resolve()):
|
|
raise ValueError("GOG setup executable leaves the installation")
|
|
windows = "Z:" + str(Path(folder).resolve()).replace("/", "\\")
|
|
args = ["/VERYSILENT", "/DIR=" + windows, "/ProductId=" + str(product["productId"]),
|
|
"/galaxyclient", "/buildId=" + str(legacy.get("timestamp", record["build"])), "/versionName=" + record.get("version", ""),
|
|
"/lang-code=" + record.get("language", "en-US"), "/supportDir=" + windows + "\\support", "/nodesktopshortcut"]
|
|
if language:
|
|
args += ["/Language=" + language, "/LANG=" + language.lower()]
|
|
result = subprocess.run([command, "run", str(program), *args], env=env, cwd=folder, timeout=120)
|
|
if result.returncode:
|
|
raise ValueError("GOG installation setup failed; the patch was not applied")
|
|
|
|
|
|
def main(argv):
|
|
if len(argv) == 3 and argv[0] == "lease":
|
|
return lease(argv[1], int(argv[2]))
|
|
if len(argv) == 4 and argv[0] == "idle":
|
|
return idle(*argv[1:])
|
|
if len(argv) == 2 and argv[0] == "status":
|
|
return status(argv[1])
|
|
if len(argv) == 5 and argv[0] == "start":
|
|
return start(*argv[1:])
|
|
if len(argv) == 5 and argv[0] == "run":
|
|
return run_patch(*argv[1:])
|
|
raise ValueError("Invalid GOG maintenance command")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
sys.exit(main(sys.argv[1:]))
|
|
except Exception as error:
|
|
print("GOG maintenance: " + str(error), file=sys.stderr)
|
|
sys.exit(1)
|