diff --git a/docs/development/steam-game-imports.md b/docs/development/steam-game-imports.md index 2e4a0cc3e7..52d69934fc 100644 --- a/docs/development/steam-game-imports.md +++ b/docs/development/steam-game-imports.md @@ -64,6 +64,17 @@ inherit those routes. Managed shortcuts are replaced; user-created shortcuts and unreadable shortcut files are preserved. Both routes use the existing ARM64 Proton registration. +## Adopting shared library folders + +At every session start, `droiddeck-steam-library` looks through `steamapps/common` of each +added library for non-empty folders no manifest names. A folder whose name is the +`config.installdir` of exactly one playable app in `appcache/appinfo.vdf` (the `game` +type wins over a demo; tools, DLC and ambiguous names are skipped) gets an +`appmanifest_.acf` with `Universe=1`, `StateFlags=4` and no build, so Steam verifies +the existing files and downloads only what differs. Existing manifests are never +rewritten, an app installed in another library is skipped, and only the added library is +written to. Ownership is not read before the client runs; Steam enforces the license. + ## Launcher artwork The installed Steam game scan lists each game's `appcache/librarycache/` diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-games b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-games index ac8213d41e..e8e2ff4e61 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-games +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-games @@ -1,9 +1,11 @@ #!/usr/bin/env python3 import ctypes as C +import functools import json import os from pathlib import Path import re +import runpy import shlex import subprocess import sys @@ -445,18 +447,22 @@ def park(steamapps): print(f"droiddeck-steam-games: {appid} is not here this session; its install is set aside until it is") +@functools.lru_cache(maxsize=1) +def compatibility(): + return runpy.run_path(os.path.join(os.path.dirname(os.path.abspath(__file__)), "steam-compatibility")) + + def seed_install(steam_root, game, appid): steamapps = Path(steam_root) / "steamapps" common = steamapps / "common" name = f"DroidDeck-{appid}" target = common / name source = Path(game["folder"]) - title = game["name"].replace("\\", "\\\\").replace('"', '\\"').replace("\n", " ").replace("\r", " ") - minimal = ('"AppState"\n{\n' + f' "appid" "{appid}"\n "Universe" "1"\n "name" "{title}"\n' - + f' "StateFlags" "4"\n "installdir" "{name}"\n' + '}\n') + manifest_text = compatibility()["manifest_text"] + minimal = manifest_text(appid, game["name"], name) legacy = minimal.replace(' "Universe" "1"\n', '') # Steam checks every file of an import with no build before updating it, from scratch each time it is interrupted. - bare = minimal[:-2] + ' "AutoUpdateBehavior" "1"\n}\n' + bare = manifest_text(appid, game["name"], name, True) build = installed_build(source, appid, name) if build is None: content = bare diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-library b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-library index 5577e1aad7..2aeac02bb3 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-library +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-library @@ -2,8 +2,10 @@ import json import os import re +import runpy import sys +BIN_DIR = os.path.dirname(os.path.abspath(__file__)) LIBRARIES = (("/mnt/droiddeck-sd", os.environ.get("BL_LIBRARY_LABEL", "SD Card")),) MAIN_LABEL = "Internal Storage" @@ -50,6 +52,77 @@ def register(steam_root, library, label): return len(apps) +def installdirs(libraries): + found = set() + for library in libraries: + steamapps = os.path.join(library, "steamapps") + try: + names = os.listdir(steamapps) + except OSError: + continue + for name in names: + if not re.fullmatch(r"appmanifest_\d+\.acf", name): + continue + try: + with open(os.path.join(steamapps, name), encoding="utf-8", errors="replace") as f: + m = re.search(r'"installdir"\s+"([^"]*)"', f.read(), re.I) + except OSError: + continue + if m: + found.add(m.group(1)) + return found + + +def populated(path): + try: + with os.scandir(path) as entries: + return next(entries, None) is not None + except OSError: + return False + + +def adoptable(library, known): + common = os.path.join(library, "steamapps", "common") + try: + names = sorted(os.listdir(common)) + except OSError: + return [] + return [n for n in names if n not in known and not n.startswith(".") + and os.path.isdir(os.path.join(common, n)) and populated(os.path.join(common, n))] + + +def adopt(steam_root, library): + compat = runpy.run_path(os.path.join(BIN_DIR, "steam-compatibility")) + known = compat["libraries"](steam_root) + folders = adoptable(library, installdirs(known + [library])) + if not folders: + return 0 + entries = compat["appinfo_entries"](os.path.join(steam_root, "appcache", "appinfo.vdf")) + by_dir = {} + for app, info in entries.items(): + if app not in compat["NOT_GAMES"] and info["type"] in compat["PLAYABLE_TYPES"] and info["installdir"]: + by_dir.setdefault(info["installdir"], []).append((app, info)) + steamapps = os.path.join(library, "steamapps") + adopted = 0 + for folder in folders: + matches = by_dir.get(folder, []) + games = [m for m in matches if m[1]["type"] == "game"] or matches + if len(games) != 1: + continue + app, info = games[0] + if any(os.path.isfile(os.path.join(root, "steamapps", "appmanifest_%s.acf" % app)) + for root in known + [library]): + continue + try: + with open(os.path.join(steamapps, "appmanifest_%s.acf" % app), "x", encoding="utf-8") as f: + f.write(compat["manifest_text"](app, info["name"] or folder, folder, True)) + except OSError: + continue + adopted += 1 + print("droiddeck-steam-library: adopted %s as app %s in %s" % (folder, app, library)) + return adopted + + RETIRED = ("/mnt/bannerlator",) RENAMED = (("/mnt/bannerlator-sd", "/mnt/droiddeck-sd"),) @@ -176,6 +249,7 @@ def main(): managed = libraries is not None for library, label in libraries if managed else LIBRARIES: if os.path.isdir(os.path.join(library, "steamapps")): + adopt(steam_root, library) register(steam_root, library, label) relabel(steam_root, library, label) else: diff --git a/tools/linuxfs/overlay/usr/local/bin/steam-compatibility b/tools/linuxfs/overlay/usr/local/bin/steam-compatibility index 0050c167c8..52a589d21d 100755 --- a/tools/linuxfs/overlay/usr/local/bin/steam-compatibility +++ b/tools/linuxfs/overlay/usr/local/bin/steam-compatibility @@ -893,7 +893,10 @@ def appinfo_entries(path, wanted=None): deck = common.get("steam_deck_compatibility") configuration = deck.get("configuration") if isinstance(deck, dict) else None recommended = configuration.get("recommended_runtime", "") if isinstance(configuration, dict) else "" + config = info.get("config") if isinstance(info.get("config"), dict) else {} entry = { + "name": str(common.get("name", "")), + "installdir": str(config.get("installdir", "")), "oslist": {part.strip().lower() for part in str(common.get("oslist", "")).split(",") if part.strip()}, "osarch": str(common.get("osarch", "")).lower(), "type": str(common.get("type", "")).lower(), @@ -960,6 +963,13 @@ def native_targets(steam_root, apps): return targets +def manifest_text(appid, name, installdir, bare=False): + title = name.replace("\\", "\\\\").replace('"', '\\"').replace("\n", " ").replace("\r", " ") + text = ('"AppState"\n{\n' + f' "appid" "{appid}"\n "Universe" "1"\n "name" "{title}"\n' + + f' "StateFlags" "4"\n "installdir" "{installdir}"\n' + '}\n') + return text[:-2] + ' "AutoUpdateBehavior" "1"\n}\n' if bare else text + + def app_manifest(steam_root, app): for library in libraries(steam_root): try: diff --git a/tools/tests/test_steam_adopt.py b/tools/tests/test_steam_adopt.py new file mode 100644 index 0000000000..71f1ead653 --- /dev/null +++ b/tools/tests/test_steam_adopt.py @@ -0,0 +1,147 @@ +import importlib.machinery +import importlib.util +import runpy +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch + +BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin" +APPINFO = runpy.run_path(str(Path(__file__).with_name("test_droiddeck_fex.py")))["AppInfoTest"].appinfo + + +def load(name): + loader = importlib.machinery.SourceFileLoader(name.replace("-", "_"), str(BIN / name)) + spec = importlib.util.spec_from_loader(loader.name, loader) + module = importlib.util.module_from_spec(spec) + loader.exec_module(module) + return module + + +library = load("droiddeck-steam-library") + + +def record(kind, installdir, name): + return {"common": {"type": kind, "name": name}, "config": {"installdir": installdir}} + + +class AdoptTest(unittest.TestCase): + def setUp(self): + temp = tempfile.TemporaryDirectory() + self.addCleanup(temp.cleanup) + root = Path(temp.name) + self.steam = root / "Steam" + self.card = root / "card" + self.common = self.card / "steamapps/common" + self.common.mkdir(parents=True) + (self.steam / "appcache").mkdir(parents=True) + (self.steam / "steamapps").mkdir() + self.write_info({ + 10: record("Game", "Alpha", 'Alpha "Deluxe"'), + 20: record("Game", "Beta", "Beta"), + 30: record("Tool", "Proton Thing", "Proton Thing"), + 40: record("Game", "Shared", "Shared Game"), + 41: record("Demo", "Shared", "Shared Demo"), + 50: record("Game", "Twin", "Twin One"), + 51: record("Game", "Twin", "Twin Two"), + }) + for patcher in (patch.object(library, "BIN_DIR", str(BIN)), + patch("builtins.print")): + patcher.start() + self.addCleanup(patcher.stop) + + def write_info(self, apps): + (self.steam / "appcache/appinfo.vdf").write_bytes(APPINFO(apps)) + + def folder(self, name, files=("data.bin",)): + path = self.common / name + path.mkdir(parents=True, exist_ok=True) + for f in files: + (path / f).write_text("x") + + def manifest(self, app, root=None): + return (root or self.card) / ("steamapps/appmanifest_%s.acf" % app) + + def adopt(self): + return library.adopt(str(self.steam), str(self.card)) + + def test_matched_folder_gets_a_validating_manifest(self): + self.folder("Alpha") + self.assertEqual(self.adopt(), 1) + text = self.manifest(10).read_text() + for line in ('"appid" "10"', '"Universe" "1"', '"StateFlags" "4"', '"installdir" "Alpha"', + '"name" "Alpha \\"Deluxe\\""', '"AutoUpdateBehavior" "1"'): + self.assertIn(line, text) + self.assertNotIn("buildid", text) + self.assertNotIn("InstalledDepots", text) + + def test_existing_manifest_is_untouched(self): + self.folder("Alpha") + self.manifest(10).write_text("mine") + self.assertEqual(self.adopt(), 0) + self.assertEqual(self.manifest(10).read_text(), "mine") + + def test_unmatched_empty_and_hidden_folders_are_skipped(self): + self.folder("Unknown") + self.folder(".hidden") + (self.common / "Beta").mkdir() + (self.common / "file.txt").write_text("x") + self.assertEqual(self.adopt(), 0) + self.assertEqual(list((self.card / "steamapps").glob("appmanifest_*")), []) + + def test_unreadable_game_folder_is_skipped_without_aborting(self): + self.folder("Unreadable") + real = library.os.scandir + + def scandir(path): + if str(path).endswith("Unreadable"): + raise PermissionError(path) + return real(path) + + with patch.object(library.os, "scandir", scandir): + self.assertEqual(library.adoptable(str(self.card), set()), []) + + def test_tool_type_app_is_skipped(self): + self.folder("Proton Thing") + self.assertEqual(self.adopt(), 0) + self.assertFalse(self.manifest(30).exists()) + + def test_game_wins_over_demo_and_ambiguous_games_are_skipped(self): + self.folder("Shared") + self.folder("Twin") + self.assertEqual(self.adopt(), 1) + self.assertTrue(self.manifest(40).exists()) + self.assertFalse(self.manifest(41).exists()) + self.assertFalse(self.manifest(50).exists() or self.manifest(51).exists()) + + def test_app_installed_in_another_library_is_left_alone(self): + self.folder("Alpha") + other = self.steam / "steamapps/appmanifest_10.acf" + other.write_text('"AppState"\n{\n\t"appid"\t"10"\n\t"installdir"\t"Elsewhere"\n}\n') + self.assertEqual(self.adopt(), 0) + self.assertFalse(self.manifest(10).exists()) + self.assertEqual(len(list(self.steam.glob("steamapps/appmanifest_*"))), 1) + + def test_adoption_is_idempotent_and_only_touches_the_given_library(self): + self.folder("Alpha") + self.folder("Beta") + self.assertEqual(self.adopt(), 2) + first = {n: self.manifest(n).read_text() for n in (10, 20)} + self.assertEqual(self.adopt(), 0) + self.assertEqual({n: self.manifest(n).read_text() for n in (10, 20)}, first) + self.assertEqual(list(self.steam.glob("steamapps/appmanifest_*")), []) + + def test_main_adopts_every_registered_library(self): + self.folder("Beta") + listing = self.steam.parent / "libraries.json" + listing.write_text('[{"path": "%s", "label": "SD Card"}]' % self.card) + with patch.dict("os.environ", {"BL_STEAM_LIBRARIES": str(listing)}), \ + patch("sys.argv", ["droiddeck-steam-library", str(self.steam)]): + library.main() + self.assertTrue(self.manifest(20).exists()) + self.assertIn(str(self.card), (self.steam / "steamapps/libraryfolders.vdf").read_text()) + self.assertIn('"20"', (self.steam / "steamapps/libraryfolders.vdf").read_text()) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_steam_games.py b/tools/tests/test_steam_games.py index 13235e68b4..08ffc90935 100644 --- a/tools/tests/test_steam_games.py +++ b/tools/tests/test_steam_games.py @@ -5,6 +5,7 @@ import os from pathlib import Path import shutil import subprocess +import runpy import tempfile import unittest import zlib @@ -26,6 +27,15 @@ shortcuts = load('droiddeck-steam-shortcuts') library = load('droiddeck-steam-library') +class ManifestTextTest(unittest.TestCase): + def test_minimal_and_bare_text_is_exact(self): + build = runpy.run_path(str(BIN / 'steam-compatibility'))['manifest_text'] + minimal = ('"AppState"\n{\n "appid" "7"\n "Universe" "1"\n "name" "A \\"B\\" C D"\n' + ' "StateFlags" "4"\n "installdir" "DroidDeck-7"\n}\n') + self.assertEqual(minimal, build(7, 'A "B"\nC\rD', 'DroidDeck-7')) + self.assertEqual(minimal[:-2] + ' "AutoUpdateBehavior" "1"\n}\n', build(7, 'A "B"\nC\rD', 'DroidDeck-7', True)) + + class ImportsTest(unittest.TestCase): def setUp(self): self.temp = tempfile.TemporaryDirectory()