diff --git a/docs/launcher.md b/docs/launcher.md index 0e674c66..64c60497 100644 --- a/docs/launcher.md +++ b/docs/launcher.md @@ -432,6 +432,21 @@ game folder is the default `\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 diff --git a/launcher/cli.py b/launcher/cli.py index 9341569b..9f444542 100644 --- a/launcher/cli.py +++ b/launcher/cli.py @@ -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]) diff --git a/launcher/jobs.py b/launcher/jobs.py index 46905a5d..f386d8c2 100644 --- a/launcher/jobs.py +++ b/launcher/jobs.py @@ -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() diff --git a/launcher/locks.py b/launcher/locks.py new file mode 100644 index 00000000..b972c881 --- /dev/null +++ b/launcher/locks.py @@ -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 (.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 (" is using "; 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) diff --git a/launcher/paths.py b/launcher/paths.py index d56ec74d..fd98c330 100644 --- a/launcher/paths.py +++ b/launcher/paths.py @@ -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' diff --git a/launcher/ui/app.py b/launcher/ui/app.py index 87bad706..c71bcb4f 100644 --- a/launcher/ui/app.py +++ b/launcher/ui/app.py @@ -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 diff --git a/tests/launcher_test.py b/tests/launcher_test.py index 02e21080..02a9b308 100644 --- a/tests/launcher_test.py +++ b/tests/launcher_test.py @@ -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):