Fix runtime removal and first-run Steam setup (#185)

* Fix runtime removal races and show removal progress

* Bootstrap Steam from the selected client channel

* Show runtime progress below its Setup row

* Always stage current session helpers and verify APK assets

* Initialize Steam UI scale once using the handheld default
This commit is contained in:
Kurt Himebauch authored and GitHub committed 2026-10-03 22:03:26 -04:00
1 parent f5e204eb1d
commit db2e1d7da2
27 files changed
+978 -90

No files matched your search

+39
View File
@@ -0,0 +1,39 @@
import importlib.util
from pathlib import Path
import tempfile
import unittest
from zipfile import ZipFile
spec = importlib.util.spec_from_file_location(
'check_session_assets', Path(__file__).resolve().parents[1] / 'release/check_session_assets.py')
assets = importlib.util.module_from_spec(spec)
spec.loader.exec_module(assets)
class SessionAssetsTest(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
self.overlay = self.root / 'overlay'
self.helper = self.overlay / 'usr/local/bin/bannerlator-login1'
self.helper.parent.mkdir(parents=True)
self.helper.write_bytes(b'current helper')
self.apk = self.root / 'app.apk'
self.name = 'assets/linuxfs/usr/local/bin/bannerlator-login1'
def test_missing_required_helper_rejects_cached_bundle(self):
with ZipFile(self.apk, 'w') as package:
package.writestr('classes.dex', b'classes')
self.assertEqual(['missing ' + self.name], assets.check(self.apk, self.overlay))
def test_stale_helper_rejects_cached_bundle(self):
with ZipFile(self.apk, 'w') as package:
package.writestr(self.name, b'old helper')
self.assertEqual(['stale ' + self.name], assets.check(self.apk, self.overlay))
def test_current_helper_passes(self):
with ZipFile(self.apk, 'w') as package:
package.writestr(self.name, self.helper.read_bytes())
self.assertEqual([], assets.check(self.apk, self.overlay))
+115
View File
@@ -0,0 +1,115 @@
import hashlib
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
import zipfile
SCRIPT = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/bannerlator-steam-install'
class SteamInstallTest(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
self.home = self.root / 'home'
self.home.mkdir()
self.data = self.root / 'data'
self.steam = self.data / 'Steam'
self.cdn = self.root / 'cdn'
self.cdn.mkdir()
self.requests = self.root / 'requests'
self.bin = self.root / 'bin'
self.bin.mkdir()
# Only the network is faked: exercise real manifest parsing, checksums and zip extraction.
curl = self.bin / 'curl'
curl.write_text('''#!/bin/bash
set -eu
printf '%s\\n' "$2" >> "$TEST_REQUESTS"
cp "$TEST_CDN/${2##*/}" "$4"
''')
curl.chmod(0o755)
# macOS has shasum; the guest and Linux CI have sha256sum.
if shutil.which('sha256sum') is None:
sha = self.bin / 'sha256sum'
sha.write_text('#!/bin/bash\nexec shasum -a 256 "$@"\n')
sha.chmod(0o755)
self.env = dict(os.environ, HOME=str(self.home), XDG_DATA_HOME=str(self.data),
PATH=str(self.bin) + os.pathsep + os.environ['PATH'],
TEST_CDN=str(self.cdn), TEST_REQUESTS=str(self.requests))
self.env.pop('BL_STEAM_CHANNEL', None)
for channel in ('publicbeta', 'steamdeck_publicbeta'):
archive = self.cdn / (channel + '.zip')
with zipfile.ZipFile(archive, 'w') as package:
package.writestr('steamrtarm64/steam', channel)
package.writestr('linuxarm64/wrapper', 'wrapper')
digest = hashlib.sha256(archive.read_bytes()).hexdigest()
(self.cdn / ('steam_client_' + channel + '_linuxarm64')).write_text(
'"linuxarm64"\n{\n\t"version" "123456"\n'
'\t"client_linuxarm64_linuxarm64"\n\t{\n'
f'\t\t"file" "{archive.name}"\n\t\t"sha2" "{digest}"\n'
'\t}\n}\n')
def install(self, channel=None):
env = self.env.copy()
if channel is not None:
env['BL_STEAM_CHANNEL'] = channel
return subprocess.run(['bash', str(SCRIPT)], env=env, text=True, capture_output=True)
def assert_installed(self, channel):
result = self.install(channel)
self.assertEqual(0, result.returncode, result.stderr)
self.assertEqual(channel + '\n', (self.steam / 'package/beta').read_text())
self.assertEqual('123456\n', (self.steam / 'package/bannerlator-installed').read_text())
client = self.steam / 'steamrtarm64/steam'
self.assertTrue(os.access(client, os.X_OK))
self.assertEqual(channel, client.read_text())
self.assertEqual((self.steam / 'linuxarm64').resolve(), (self.home / '.steam/sdkarm64').resolve())
self.assertEqual([
'https://client-update.fastly.steamstatic.com/steam_client_' + channel + '_linuxarm64',
'https://client-update.fastly.steamstatic.com/' + channel + '.zip',
], self.requests.read_text().splitlines())
def test_unset_channel_downloads_deck_beta(self):
result = self.install()
self.assertEqual(0, result.returncode, result.stderr)
self.assertEqual('steamdeck_publicbeta\n', (self.steam / 'package/beta').read_text())
self.assertIn('/steam_client_steamdeck_publicbeta_linuxarm64\n', self.requests.read_text())
def test_explicit_deck_beta_downloads_matching_client(self):
self.assert_installed('steamdeck_publicbeta')
def test_explicit_public_beta_downloads_matching_client(self):
self.assert_installed('publicbeta')
def test_existing_install_is_left_for_steam_to_update(self):
self.assert_installed('steamdeck_publicbeta')
requests = self.requests.read_text()
result = self.install('publicbeta')
self.assertEqual(0, result.returncode, result.stderr)
self.assertEqual(requests, self.requests.read_text())
self.assertEqual('steamdeck_publicbeta\n', (self.steam / 'package/beta').read_text())
def test_failed_download_has_no_ready_marker_and_can_retry(self):
archive = self.cdn / 'publicbeta.zip'
original = archive.read_bytes()
archive.write_bytes(b'corrupt download')
self.assertNotEqual(0, self.install('publicbeta').returncode)
self.assertFalse((self.steam / 'package/bannerlator-installed').exists())
archive.write_bytes(original)
self.assertEqual(0, self.install('publicbeta').returncode)
self.assertEqual('publicbeta\n', (self.steam / 'package/beta').read_text())
def test_invalid_channel_fails_before_any_download(self):
result = self.install('../unknown')
self.assertNotEqual(0, result.returncode)
self.assertIn('unsupported Steam channel', result.stderr)
self.assertFalse(self.requests.exists())
if __name__ == '__main__':
unittest.main()
+98
View File
@@ -0,0 +1,98 @@
from pathlib import Path
import runpy
import tempfile
import unittest
BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin'
MODULE = runpy.run_path(str(BIN / 'bannerlator-steam-ui-scale'))
initialize = MODULE['initialize']
seed_text = MODULE['seed_text']
parse = MODULE['parse']
initial_scale = MODULE['initial_scale']
DISPLAY = MODULE['DISPLAY']
class SteamUiScaleTest(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
self.config = self.root / 'config/config.vdf'
self.config.parent.mkdir()
self.marker = self.config.with_name('droiddeck-ui-scale-initialized')
def scale(self, text):
return parse(text).get('InstallConfigStore').get('UI').get('display').get(DISPLAY).get('ScaleFactor')
def test_matches_the_thor_setting_and_scales_with_session_resolution(self):
self.assertAlmostEqual(1.3281567096710205, initial_scale(1280, 720), places=6)
self.assertAlmostEqual(2 * initial_scale(1280, 720), initial_scale(2560, 1440))
def test_fresh_client_gets_native_display_setting(self):
self.assertTrue(initialize(self.root, 1280, 720))
self.assertAlmostEqual(1.328156709, float(self.scale(self.config.read_text())))
self.assertTrue(self.marker.exists())
def test_current_automatic_record_does_not_count_as_a_user_choice(self):
self.config.write_text('''"InstallConfigStore" {
"UI" { "display" { "Current" { "ScaleFactor" "0.948683321475982666" } } }
}''')
self.assertTrue(initialize(self.root, 1280, 720))
self.assertAlmostEqual(initial_scale(1280, 720), float(self.scale(self.config.read_text())))
def test_existing_manual_scale_is_preserved_exactly(self):
text = f'"InstallConfigStore" {{ "UI" {{ "display" {{ "{DISPLAY}" {{ "ScaleFactor" "1.7" }} }} }} }}'
self.config.write_text(text)
self.assertFalse(initialize(self.root, 1280, 720))
self.assertEqual(text, self.config.read_text())
self.assertTrue(self.marker.exists())
def test_user_changes_after_initialization_survive_restart_and_resolution_change(self):
initialize(self.root, 1280, 720)
text = self.config.read_text().replace(self.scale(self.config.read_text()), '1.6')
self.config.write_text(text)
self.assertFalse(initialize(self.root, 1920, 1080))
self.assertEqual(text, self.config.read_text())
def test_user_returning_to_auto_does_not_get_the_default_again(self):
initialize(self.root, 1280, 720)
text = '"InstallConfigStore" { "UI" { "display" { "Current" { "ScaleFactor" "0.95" } } } }'
self.config.write_text(text)
self.assertFalse(initialize(self.root, 1280, 720))
self.assertEqual(text, self.config.read_text())
def test_existing_choices_for_other_displays_are_also_preserved(self):
text = '"InstallConfigStore" { "UI" { "display" { "External: other" { "ScaleFactor" "-1" } } } }'
self.assertEqual((text, False), seed_text(text, 1.328))
def test_unrelated_settings_comments_and_escaped_strings_keep_their_bytes(self):
text = r'''// Keep this comment
"InstallConfigStore" {
"Software" { "Valve" { "Steam" { "keep" "quoted \"text\" and { braces }" } } }
"UI" { // comment inside UI
"other" "unchanged"
}
}'''
updated, changed = seed_text(text, 1.328)
self.assertTrue(changed)
self.assertAlmostEqual(1.328, float(self.scale(updated)))
self.assertIn('"other" "unchanged"', updated)
self.assertIn('"keep" "quoted \\\"text\\\" and { braces }"', updated)
self.assertIn('// comment inside UI', updated)
at = parse(text).get('InstallConfigStore').get('UI').end
self.assertEqual(text, updated[:at] + updated[at + len(updated) - len(text):])
def test_invalid_config_is_never_rewritten_or_marked_initialized(self):
for text in ('"InstallConfigStore" {', 'garbage', '"InstallConfigStore" { "UI" "bad" }'):
self.config.write_text(text)
with self.assertRaises(ValueError):
initialize(self.root, 1280, 720)
self.assertEqual(text, self.config.read_text())
self.assertFalse(self.marker.exists())
def test_invalid_output_size_is_rejected(self):
with self.assertRaises(ValueError):
initialize(self.root, 0, 720)
self.assertFalse(self.config.exists())
self.assertFalse(self.marker.exists())