Let one process work in a launcher folder at a time, and one job on the same thing.

The window already locked data/launcher.lock, but a second one closed without a word, the command line did not take
the lock, and nothing kept two jobs apart. The lock is now launcher/locks.py: the window, every command but check and
every job that changes files hold it, the one refused says who holds it, and a job names what it changes so that a
second one on the same thing fails before its first step.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
chrg6
2026-11-12 22:06:26 -05:00
parent ec9dd522b1
commit 3ca1541e0e
7 changed files with 421 additions and 38 deletions

View File

@@ -432,6 +432,21 @@ game folder is the default `<launcher>\game`. The dump is never touched.
`rebuild [--game D]`, `fonts`. `NX2navi.exe --desktop-shortcut on|off` and `--shortcuts on|off` are the stub's own.
`NX2navi-Setup.exe` takes `--dest DIR`, `--no-shortcuts`, `--no-launch` and `--quiet`.
## One launcher, one job
One process works in a launcher folder at a time (`launcher/locks.py`). The window holds the folder's lock,
`data/launcher.lock`, while it is open, every command of `launcher/cli.py` but `check` holds it while it runs, and a
job that changes files takes it too (the window's own jobs share the window's). The operating system keeps the lock
(`msvcrt.locking` on Windows, `flock` elsewhere) and lets go of it when the process ends, however it ends; who holds
it is written to `data/launcher.lock.owner`. A second window says who holds the folder in a message box and closes;
a command prints it and ends with exit code 1; a job fails with it before its first step.
Within one process, a job names what it changes (`jobs.Job.claims`: `game`, the game folder and the build tools;
`app`, the app folder's versions and the downloads), and a second job on the same thing fails at once with the first
one's name. An install, a rebuild and the rebuild of an update claim `game`; an update's download and the background
download claim `app`; the update check claims nothing and runs beside anything. Two launcher folders that share one
game folder are not kept apart: the lock belongs to the launcher folder.
## Releases
1. Bump `VERSION`; build the shader translator (`tools/build_xlate.py`).
@@ -511,7 +526,9 @@ folder, refusals), the shared save's zip (export of the save the game would load
files, the import of a zip with its backup, a zip in the saves folder, the menu's waiting import dropped, the zips it
refuses: no manifest, another format or game, a newer format, paths outside the save, links, damage), the install
job with a fake
`make_game.py` (with and without the prompts row), and the window's selftest when a display is there.
`make_game.py` (with and without the prompts row), the folder's lock (a second launcher process refused and told who
holds it, the lock gone when its holder is killed, a job and the command line refused while another process holds
it, two jobs on one folder), and the window's selftest when a display is there.
What goes wrong around a build is tested the same way, on made-up folders and stand-in processes: an update that
stops in its compile (the game stays installed, home says how to finish, the install goes on from the unpacked

View File

@@ -21,7 +21,7 @@ if __name__ == '__main__' and not __package__:
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
__package__ = 'launcher' # noqa: A001 — lets the relative imports below work when run as a script
from . import build, gamefiles, jobs, versions # noqa: E402
from . import build, gamefiles, jobs, locks, versions # noqa: E402
from .context import Context # noqa: E402
from .paths import Layout # noqa: E402
@@ -65,6 +65,24 @@ def main(argv=None):
p.add_argument('old')
a = ap.parse_args(argv)
ctx = Context(Layout(root=a.root) if a.root else None, echo=False)
if a.cmd == 'check': # reads the feed and changes nothing: it runs beside an open launcher
return run(a, ctx, None)
# Every other command changes the launcher's folder or the game's, as the window's jobs do: it holds the folder's
# lock (launcher/locks.py) from before it writes the settings until it ends, and is refused while the window or
# another command holds it
try:
held = locks.FileLock(ctx.layout.instance_lock, f'"{a.cmd}" from the command line', where=ctx.layout.root)
except locks.Busy as e:
print(f'error: {e}. Close it, or wait until it is done, and try again.', file=sys.stderr, flush=True)
return 1
try:
return run(a, ctx, held)
finally:
held.release()
def run(a, ctx, held):
"""One command. held: the launcher folder's lock, which `update` lets go of before the new version takes over."""
s = ctx.settings
if a.cmd == 'check':
@@ -93,6 +111,7 @@ def main(argv=None):
new = ctx.layout.apps / versions.display(check.release.version)
cli = new / 'launcher' / 'cli.py'
print(f'finishing in {versions.display(check.release.version)}', flush=True)
held.release() # the new version's command takes the lock itself
return subprocess.call([ctx.layout.python_for_builds(), str(cli), '--root', str(ctx.layout.root),
'continue-update', ctx.version])

View File

@@ -7,7 +7,7 @@ import threading
import time
import traceback
from . import build, feed, gamefiles, net, toolchain, updater, versions, winsys
from . import build, feed, gamefiles, locks, net, toolchain, updater, versions, winsys
RECHECK = 3600 # seconds between update checks while the launcher stays open, hidden during play included
@@ -15,7 +15,7 @@ PENDING, RUNNING, DONE, SKIPPED, FAILED = 'pending', 'running', 'done', 'skipped
# Failures whose message says all there is to say: the log gets one line for them (failure_line), not a traceback.
# A refused update check wrote 22 lines of two tracebacks into launcher.log each time.
PLAIN_FAILURES = (feed.FeedError, build.BuildError)
PLAIN_FAILURES = (feed.FeedError, build.BuildError, locks.Busy)
def failure_line(e):
@@ -102,6 +102,12 @@ class Step:
class Job:
kind = 'job'
title = ''
# What the job changes while it runs, for the lock between jobs (launcher/locks.py claim): 'game' is the game
# folder and the build tools, 'app' the app folder's versions and the downloads. A job with claims also holds the
# launcher folder's lock between processes while it runs; one without (the update check) changes no file and
# runs beside anything.
claims = ()
task = '' # the job as the holder of a lock is named (doing)
def __init__(self, ctx, step_ids, ver=''):
self.ctx = ctx
@@ -229,8 +235,31 @@ class Job:
self._main()
return self
def _main(self):
def doing(self):
"""The job in a few words ("the rebuild of the game"), for the one a lock refuses because of it."""
return self.task or f'a {self.kind} job'
def _hold(self):
"""Take what the job needs to itself before it runs (launcher/locks.py): the launcher folder against other
processes, then its claims against the other jobs of this one. locks.Busy, with nothing held, when either is
taken. Returns what _main lets go of when the job has ended."""
if not self.claims:
return None, None
layout = self.ctx.layout
try:
file = locks.FileLock(layout.instance_lock, self.doing(), where=layout.root)
except locks.Busy as e:
raise locks.Busy(f'{e}. Close it, or wait until it is done, and try again') from None
try:
return file, locks.claim(layout.root, self.claims, self.doing())
except locks.Busy:
file.release()
raise
def _main(self):
file = claimed = None
try:
file, claimed = self._hold()
self.run()
self.result = 'ok'
except net.Cancelled:
@@ -246,6 +275,9 @@ class Job:
if s.state == RUNNING:
s.state = FAILED if self.result == 'failed' else PENDING
s.value = 'Stopped' if self.result == 'failed' else 'Cancelled'
locks.release_claim(claimed)
if file:
file.release()
self.finished = time.time()
self._touch()
@@ -359,6 +391,8 @@ class Job:
class InstallJob(Job):
kind = 'install'
title = 'Installing'
claims = ('game',)
task = 'the installation of the game'
def __init__(self, ctx, dump, game_dir):
super().__init__(ctx, ['tools', 'check', 'exefs', 'romfs', 'lift', 'compile', 'shaders', *prompt_rows(ctx),
@@ -392,6 +426,8 @@ class InstallJob(Job):
class RebuildJob(Job):
kind = 'rebuild'
title = 'Rebuilding'
claims = ('game',)
task = 'the rebuild of the game'
retune = True # Rebuild the Game: the game's code for this processor's level (build.rebuild_args)
def __init__(self, ctx, game_dir, dump=''):
@@ -431,12 +467,14 @@ class ModsRebuildJob(RebuildJob):
class UpdateDownloadJob(Job):
"""Before the restart: download, check and stage the release, then switch app/current.txt to it."""
kind = 'update'
claims = ('app',)
def __init__(self, ctx, release):
ver = versions.display(release.version)
super().__init__(ctx, ['download', 'verify', 'tools_update', 'lift', 'compile_changed', 'swap', 'shaders'], ver)
self.release, self.ver = release, ver
self.title = f'Updating to {ver}'
self.task = f'the update to {ver}'
def run(self):
layout = self.ctx.layout
@@ -463,12 +501,14 @@ class ContinueUpdateJob(RebuildJob):
"""After the restart, in the new version: bring the tools to its lock and rebuild the game."""
retune = False # an update keeps the compiled game's level, so it compiles only what changed
kind = 'update'
claims = ('game', 'app') # the rebuild, then updater.prune in the app folder
def __init__(self, ctx, game_dir, old, dump=''):
Job.__init__(self, ctx, ['download', 'verify', 'tools_update', 'lift', 'compile_changed', 'swap', 'shaders',
*prompt_rows(ctx), 'scan'], ctx.layout.version)
self.game_dir, self.dump, self.old = str(game_dir), dump, old
self.title = f'Updating to {versions.display(ctx.layout.version)}'
self.task = f'the update to {versions.display(ctx.layout.version)}'
for sid, value in (('download', 'Done'), ('verify', 'Checksum OK')):
self.step(sid).state, self.step(sid).value, self.step(sid).fraction = DONE, value, 1.0
@@ -507,11 +547,13 @@ class StageJob(Job):
(updater.stage), while the launcher runs and the game too. Its thread runs at background priority, so the game
shares only the network with it. No screen shows it: the home screen's Updates row reads it."""
kind = 'stage'
claims = ('app',)
def __init__(self, ctx, release):
ver = versions.display(release.version)
super().__init__(ctx, ['download'], ver)
self.release, self.ver = release, ver
self.task = f'the background download of {ver}'
def run(self):
winsys.background_thread()

134
launcher/locks.py Normal file
View File

@@ -0,0 +1,134 @@
"""Who may work in a launcher folder: one process at a time, and in that process one job at a time on the same thing.
Two launchers on one folder each ran their own build into the same game folder, wrote the same settings and unpacked
an update over each other. So:
- FileLock is a lock between processes: a file locked by the operating system (msvcrt.locking on Windows, flock
elsewhere), which lets go of it when the process ends, however it ends. The window takes the one of its folder
(paths.Layout.instance_lock) for as long as it is open, launcher/cli.py for a command, and every job that changes
files while it runs (jobs.Job). A process that holds it already shares it with its own jobs. Who holds it is
written beside it (<lock>.owner), so that the one refused can say so.
- claim() is the lock between the jobs of one process: a job names what it changes (jobs.Job.claims: the game folder
and its build tools, the app folder), and a second job on the same thing is refused with the first one's name.
Both refuse with Busy, whose text names the holder; neither waits (FileLock for a few seconds when asked to, for a
launcher that is closing for its restart).
"""
import json
import os
import threading
import time
_guard = threading.Lock()
_files = {} # lock file path -> [the open file, how many FileLocks of this process share it]
_claims = {} # (folder, what is claimed) -> who claimed it
class Busy(Exception):
"""Another process or job holds what was asked for. Its text says who."""
def _key(path):
return os.path.normcase(os.path.abspath(str(path)))
def _os_lock(f):
"""Lock the open file f for this process without waiting. OSError when another open file holds the lock."""
if os.name == 'nt':
import msvcrt
f.seek(0)
msvcrt.locking(f.fileno(), msvcrt.LK_NBLCK, 1)
else:
import fcntl
fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
def owner(path):
"""Who holds the lock file path, as its holder wrote it ("the launcher window (process 1234, since 14:02)"), or
'another NX2navi' when that cannot be read. Only worth asking after the lock was refused: the note of a holder
that has ended stays."""
try:
with open(str(path) + '.owner', encoding='utf-8') as f:
o = json.load(f)
return f'{o["what"]} (process {int(o["pid"])}, since {time.strftime("%H:%M", time.localtime(o["since"]))})'
except (OSError, ValueError, KeyError, TypeError, OverflowError):
return 'another NX2navi'
class FileLock:
"""The lock file path held for this process until release() or the process's end. what says who holds it, for
the one that is refused. Raises Busy ("<the holder> is using <where>"; where is the lock's folder unless given)
when another process still holds it after wait seconds. A lock file that cannot be made or opened (a folder
that cannot be written) locks nothing and refuses nobody: the launcher must still start there."""
def __init__(self, path, what, wait=0.0, where=None):
self.path, self.key = path, _key(path)
deadline = time.time() + wait
while True:
with _guard:
if self._take(what):
return
if time.time() >= deadline:
raise Busy(f'{owner(path)} is using {where or os.path.dirname(os.path.abspath(str(path)))}')
time.sleep(0.25)
def _take(self, what):
"""True when this process holds the file now (or cannot lock at all), False when another process does."""
entry = _files.get(self.key)
if entry:
entry[1] += 1
return True
try:
f = open(self.path, 'a+')
except OSError:
self.key = None
return True
try:
_os_lock(f)
except OSError:
f.close()
return False
_files[self.key] = [f, 1]
try:
with open(str(self.path) + '.owner', 'w', encoding='utf-8') as o:
json.dump({'what': what, 'pid': os.getpid(), 'since': time.time()}, o)
except OSError:
pass
return True
def release(self):
"""Let go of the lock (the file is closed when the last FileLock of this process on it lets go). Calling it
again does nothing."""
with _guard:
key, self.key = self.key, None
entry = _files.get(key) if key else None
if entry:
entry[1] -= 1
if entry[1] <= 0:
del _files[key]
entry[0].close() # closing the file releases the operating system's lock
def __enter__(self):
return self
def __exit__(self, *exc):
self.release()
def claim(folder, names, who):
"""Claim each of names in folder for who (a job's description), all or none. Raises Busy with the holder of the
first one that is taken. Returns what release_claim() takes."""
keys = [(_key(folder), n) for n in names]
with _guard:
for k in keys:
if k in _claims:
raise Busy(f'{_claims[k]} is still running: wait for it to end, or cancel it')
for k in keys:
_claims[k] = who
return keys
def release_claim(keys):
with _guard:
for k in keys or ():
_claims.pop(k, None)

View File

@@ -72,6 +72,9 @@ class Layout:
self.cache = self.data / 'cache'
self.downloads = self.data / 'downloads'
self.settings = self.data / 'launcher.json'
# held by whichever process works in this folder: the window while it is open, launcher/cli.py for a command
# and every job that changes files (launcher/locks.py)
self.instance_lock = self.data / 'launcher.lock'
tool_root = self.root
if not ansi_safe(tool_root):
tool_root = Path(os.environ.get('SystemDrive', 'C:') + '\\') / 'NX2navi'

View File

@@ -37,7 +37,7 @@ import tkinter.font as tkfont
from pathlib import Path
from tkinter import filedialog
from .. import NAME, build, feed, gameini, gamefiles, jobs, mods, saves, steam, versions, winsys
from .. import NAME, build, feed, gameini, gamefiles, jobs, locks, mods, saves, steam, versions, winsys
from ..context import Context
from . import art, picture, sound
@@ -2673,28 +2673,26 @@ def parse_args(argv):
def single_instance(layout, wait):
"""An exclusive lock on data/launcher.lock for this process's life, or None when another launcher holds it after
wait seconds (the one an update restart replaces may still be closing)."""
path = layout.data / 'launcher.lock'
deadline = time.time() + wait
while True:
try:
f = open(path, 'a+')
try:
if os.name == 'nt':
import msvcrt
msvcrt.locking(f.fileno(), msvcrt.LK_NBLCK, 1)
else:
import fcntl
fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
return f
except OSError:
f.close()
raise
except OSError:
if time.time() >= deadline:
return None
time.sleep(0.25)
"""The launcher folder's lock (launcher/locks.py) for this window's life. locks.Busy, naming the holder, when
another launcher or a command of launcher/cli.py still holds it after wait seconds (the launcher an update
restart replaces may still be closing)."""
return locks.FileLock(layout.instance_lock, 'the launcher window', wait=wait, where=layout.root)
def tell(text):
"""A sentence for the player before the window is up: a message box that waits for OK."""
try:
if os.name == 'nt':
import ctypes
ctypes.windll.user32.MessageBoxW(None, text, NAME, 0x40)
else:
from tkinter import messagebox
root = tk.Tk()
root.withdraw()
messagebox.showinfo(NAME, text, parent=root)
root.destroy()
except Exception: # no display, no toolkit: the terminal that started it
print(text, file=sys.stderr)
def play_only(ctx):
@@ -2743,14 +2741,23 @@ def main(argv=None):
return code
lock = None
if not a.selftest:
lock = single_instance(ctx.layout, 20 if (a.continue_update or a.rolled_back) else 2)
if lock is None:
ctx.log('another launcher is running')
try:
lock = single_instance(ctx.layout, 20 if (a.continue_update or a.rolled_back) else 2)
except locks.Busy as e:
# A second window on the same folder would run its own jobs into the same game folder and settings. The
# first one may be out of sight (hidden while the game runs), so the player is told who holds the folder
ctx.log(f'not started: {e}')
tell(f'NX2navi is already running: {e}.\n\nIts window may be hidden while the game runs; it comes back '
'when you quit the game.')
return 0
root = tk.Tk(className='NX2navi')
app = App(root, ctx, a)
if a.selftest:
from .selftest import run
root.after(300, lambda: run(app, a.shots))
root.mainloop()
try:
root = tk.Tk(className='NX2navi')
app = App(root, ctx, a)
if a.selftest:
from .selftest import run
root.after(300, lambda: run(app, a.shots))
root.mainloop()
finally:
if lock:
lock.release()
return 0

View File

@@ -49,7 +49,7 @@ ROOT = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(ROOT))
sys.path.insert(0, str(ROOT / 'tools'))
from launcher import build, feed, gameini, gamefiles, jobs, net, saves, settings, toolchain, updater, versions, winsys # noqa: E402
from launcher import build, feed, gameini, gamefiles, jobs, locks, net, saves, settings, toolchain, updater, versions, winsys # noqa: E402
from launcher.context import Context # noqa: E402
from launcher.paths import Layout # noqa: E402
@@ -3681,6 +3681,167 @@ class JobTest(Tmp):
self.assertEqual(jobs.InstallJob(ctx, self.tmp / 'g.nup', game).args()[0], '--nup')
# ---------------------------------------------------------------- one launcher, one job
# Another launcher process: it takes the lock file argv[2] as argv[3], says so and holds it until its input closes.
HOLDER = ('import sys; sys.path.insert(0, sys.argv[1]); from launcher import locks; '
'lock = locks.FileLock(sys.argv[2], sys.argv[3]); print("held", flush=True); sys.stdin.read()')
class LockTest(Tmp):
"""launcher/locks.py: one process works in a launcher folder at a time, and in it one job on the same thing."""
make_ctx, patch_tools = JobTest.make_ctx, JobTest.patch_tools
def holder(self, layout, what='the launcher window'):
"""A second process holding layout's lock as what, until the test ends or it is killed."""
p = subprocess.Popen([sys.executable, '-c', HOLDER, str(ROOT), str(layout.instance_lock), what],
stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
def end():
p.kill()
p.wait()
p.stdin.close()
p.stdout.close()
self.addCleanup(end)
self.assertEqual(p.stdout.readline().strip(), 'held')
return p
def test_a_second_launcher_is_refused_and_told_who_holds_the_folder(self):
other = self.holder(self.layout)
with self.assertRaises(locks.Busy) as refused:
locks.FileLock(self.layout.instance_lock, 'the launcher window', where=self.layout.root)
self.assertIn(f'the launcher window (process {other.pid}, since ', str(refused.exception))
self.assertIn(str(self.layout.root), str(refused.exception))
try:
from launcher.ui import app
except ImportError as e:
self.skipTest(f'no window toolkit: {e}')
said = []
with mock.patch.object(app, 'tell', said.append), mock.patch.object(app.tk, 'Tk') as window, \
mock.patch.object(app.winsys, 'dpi_aware'), mock.patch.object(app.winsys, 'app_id'), \
mock.patch.object(app, 'single_instance', lambda layout, wait: locks.FileLock(
layout.instance_lock, 'the launcher window', where=layout.root)): # without the wait
self.assertEqual(app.main(['--root', str(self.layout.root)]), 0)
window.assert_not_called() # no second window
self.assertEqual(len(said), 1)
self.assertIn(f'NX2navi is already running: the launcher window (process {other.pid}', said[0])
def test_the_lock_goes_when_its_process_dies(self):
other = self.holder(self.layout)
other.kill() # no clean exit: the operating system lets go of the lock
other.wait()
mine = locks.FileLock(self.layout.instance_lock, 'the launcher window', wait=10)
self.addCleanup(mine.release)
# the window's own jobs share its lock, and it stays the window's until the window lets go of it
job = locks.FileLock(self.layout.instance_lock, 'a job')
job.release()
job.release() # letting go twice lets go once
self.assertIn(locks._key(self.layout.instance_lock), locks._files)
mine.release()
self.assertNotIn(locks._key(self.layout.instance_lock), locks._files)
def test_a_folder_that_cannot_hold_a_lock_file_refuses_nobody(self):
gone = self.tmp / 'no such folder' / 'launcher.lock'
with locks.FileLock(gone, 'the launcher window'), locks.FileLock(gone, 'another'):
self.assertFalse(gone.exists())
def test_a_job_does_not_run_while_another_process_holds_the_folder(self):
self.patch_tools()
ctx = self.make_ctx('ok')
self.addCleanup(ctx._file.close)
other = self.holder(ctx.layout, '"rebuild" from the command line')
j = jobs.InstallJob(ctx, self.tmp / 'g.nup', self.tmp / 'game').run_inline()
self.assertEqual(j.result, 'failed')
self.assertIn(f'"rebuild" from the command line (process {other.pid}', j.error)
self.assertIn('try again', j.error)
self.assertEqual({s.state for s in j.steps}, {jobs.PENDING}) # nothing of it ran
self.assertFalse(any('working on' in ln for ln in j.lines))
check = jobs.Job(ctx, []) # a job that changes no file (the update check) runs beside it
check.run = lambda: None
self.assertEqual(check.run_inline().result, 'ok')
other.stdin.close() # the other process ends
other.wait()
j = jobs.InstallJob(ctx, self.tmp / 'g.nup', self.tmp / 'game').run_inline()
self.assertEqual(j.result, 'ok', j.error)
self.assertEqual(locks._files, {}) # and the job let go of the folder when it ended
def test_two_jobs_on_one_folder(self):
self.patch_tools()
ctx = self.make_ctx('ok')
self.addCleanup(ctx._file.close)
started, go = threading.Event(), threading.Event()
class Slow(jobs.RebuildJob):
def run(self):
started.set()
go.wait(30)
first = Slow(ctx, self.tmp / 'game').start()
self.addCleanup(go.set)
self.assertTrue(started.wait(30))
second = jobs.RebuildJob(ctx, self.tmp / 'game').run_inline()
self.assertEqual(second.result, 'failed')
self.assertEqual(second.error, 'the rebuild of the game is still running: wait for it to end, or cancel it')
self.assertEqual({s.state for s in second.steps}, {jobs.PENDING})
install = jobs.InstallJob(ctx, self.tmp / 'g.nup', self.tmp / 'game').run_inline()
self.assertEqual(install.result, 'failed') # another kind of job on the same folder
self.assertIn('the rebuild of the game is still running', install.error)
class Download(jobs.Job): # what the background download claims: the app folder, not the game
claims = ('app',)
task = 'the background download of 9.9.9'
def run(self):
pass
self.assertEqual(Download(ctx, []).run_inline().result, 'ok')
elsewhere = Context(Layout(root=self.tmp / 'other root', app=ctx.layout.app))
self.addCleanup(elsewhere._file.close)
self.assertEqual(jobs.InstallJob(elsewhere, self.tmp / 'g.nup', self.tmp / 'game 2').run_inline().result, 'ok')
go.set()
for _ in range(300):
if first.result is not None:
break
time.sleep(0.1)
self.assertEqual(first.result, 'ok')
again = jobs.InstallJob(ctx, self.tmp / 'g.nup', self.tmp / 'game').run_inline()
self.assertEqual(again.result, 'ok', again.error) # the first job let go when it ended
self.assertEqual((locks._files, locks._claims), ({}, {}))
def test_a_failed_job_lets_go_of_the_folder(self):
self.patch_tools()
ctx = self.make_ctx('--fail')
self.addCleanup(ctx._file.close)
self.assertEqual(jobs.InstallJob(ctx, self.tmp / 'g.nup', self.tmp / 'game').run_inline().result, 'failed')
self.assertEqual((locks._files, locks._claims), ({}, {}))
def test_the_command_line_takes_the_folders_lock(self):
from launcher import cli
ctx = self.make_ctx('ok')
ctx._file.close()
root = ['--root', str(ctx.layout.root)]
ran = []
def run(a, ctx, held):
ran.append((a.cmd, held is not None and locks._key(ctx.layout.instance_lock) in locks._files))
ctx._file.close()
return 0
err = io.StringIO()
with mock.patch.object(cli, 'run', run), contextlib.redirect_stderr(err):
self.assertEqual(cli.main(root + ['tools']), 0)
self.assertEqual(ran, [('tools', True)]) # held while the command runs
self.assertEqual(locks._files, {}) # and let go of after
other = self.holder(ctx.layout)
self.assertEqual(cli.main(root + ['rebuild']), 1)
self.assertEqual(cli.main(root + ['install', '--dump', 'd.nup', '--game', str(self.tmp / 'game')]), 1)
self.assertEqual(len(ran), 1) # neither ran, and no setting was written
self.assertEqual(cli.main(root + ['check']), 0) # the update check changes nothing: it runs
self.assertEqual(ran[-1], ('check', False))
self.assertIn(f'error: the launcher window (process {other.pid}', err.getvalue())
self.assertIn('try again', err.getvalue())
# ---------------------------------------------------------------- the icon
class SavesTest(unittest.TestCase):