Vito
a985af506b
* test(browser): seed resets on a scratch copy and publish them in one commit (#384) The concept and plain resets made hundreds of committed transactions on the live database; on a slow CI disk they queued behind WAL checkpoint syncs and took 30+ s. Each reset now copies the live database into a scratch database (backup API, no syncs), runs the unchanged seeder against it through an API proxy, and replaces the rows of the tables the seed changed in one live transaction. A commit by another live connection meanwhile fails the reset. tests/browser/reset_equivalence.py proves every reset kind leaves the same rows, files and response as the old path (PM_TEST_SEED_ON_LIVE=1). * test(browser): empty media folders by a rename, delete them in the background (#384) With the database commits gone, throttled resets still stalled in rmtree: unlinking the last fixture's files waits for their pending writeback. Each reseed now moves the old output and input folders into <root>/reset-trash and makes empty ones; a background thread deletes the trash, and the server's cleanup stops it and removes the rest before the temp root goes. * fix(test): recheck the live data version under the publish's write lock (#384) A writer whose transaction was open while the seed ran committed before BEGIN IMMEDIATE returned and its rows were overwritten. The publish now rechecks data_version under the lock, and restores foreign_keys and detaches the scratch database on every error path. * test(browser): keep the reset scratch database in /dev/shm when there is one (#384) Throttled runs still waited on the runner's disk while creating and rewriting the scratch database, whose pages were under writeback. * test(browser): keep the scratch on disk when /dev/shm is short, delete in place after cleanup (#384) The largest scratch copy is about 8 MB; Docker's default /dev/shm is 64 MB and shared with the browsers. A reset that empties a folder after the server's cleanup closed its trash deletes in place instead of starting a thread nobody stops. * fix(test): drop the gallery caches only after the reset's rows are published (#384) The seeders drop the Images listing at their end. Run on the scratch copy, that drop came before the publish, so a background walk in between could cache per-file values built from the live database's old rows: CI's inspector tag chip found 0 of 0 images. The proxy now records the drop and the seeder makes it after the publish, as the old reset did. * fix(test): remove /dev/shm reset scratch left by killed browser servers (#384) A server killed outright never runs its cleanup, and tmpfs keeps the scratch folder in memory until reboot: the Python suite's server tests left one per killed server. Scratch folders now carry the owner's pid, and each new one first removes those whose process is gone (POSIX only).
79 lines
2.6 KiB
Python
79 lines
2.6 KiB
Python
"""Empty a browser-test media folder without waiting for the disk (#384).
|
|
|
|
A reset used to ``shutil.rmtree`` the output and input folders the last
|
|
fixture wrote. Unlinking a file whose pages are still being written back
|
|
waits for that write, so on a slow CI disk a reset stalled in ``rmtree``.
|
|
``replace_folder`` renames the old folder into ``<parent>/reset-trash`` (one
|
|
metadata change) and makes a new empty one; a background thread deletes the
|
|
trash, and ``close_trash`` stops that thread and removes what is left before
|
|
the server's temp root goes.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import queue
|
|
import shutil
|
|
import threading
|
|
import uuid
|
|
from pathlib import Path
|
|
|
|
TRASH_NAME = "reset-trash"
|
|
|
|
|
|
class _Trash:
|
|
def __init__(self, directory: Path) -> None:
|
|
self.directory = directory
|
|
self._queue: "queue.SimpleQueue[Path | None]" = queue.SimpleQueue()
|
|
self._thread = threading.Thread(
|
|
target=self._work, name="pm-reset-trash", daemon=True
|
|
)
|
|
self._thread.start()
|
|
|
|
def _work(self) -> None:
|
|
while (folder := self._queue.get()) is not None:
|
|
shutil.rmtree(folder, ignore_errors=True)
|
|
|
|
def discard(self, folder: Path) -> None:
|
|
self.directory.mkdir(exist_ok=True)
|
|
moved = self.directory / f"{folder.name}-{uuid.uuid4().hex}"
|
|
folder.rename(moved)
|
|
self._queue.put(moved)
|
|
|
|
def close(self) -> None:
|
|
self._queue.put(None)
|
|
self._thread.join()
|
|
shutil.rmtree(self.directory, ignore_errors=True)
|
|
|
|
|
|
_trashes: dict[Path, _Trash] = {}
|
|
# Trash folders whose server has cleaned up: a reset still running then
|
|
# deletes in place instead of starting a thread nobody would stop.
|
|
_closed: set[Path] = set()
|
|
_lock = threading.Lock()
|
|
|
|
|
|
def replace_folder(folder: Path) -> None:
|
|
"""Make ``folder`` an empty folder; its old content is deleted later."""
|
|
folder = Path(folder)
|
|
if folder.exists():
|
|
directory = folder.parent / TRASH_NAME
|
|
with _lock:
|
|
trash = _trashes.get(directory)
|
|
if trash is None and directory not in _closed:
|
|
trash = _trashes[directory] = _Trash(directory)
|
|
if trash is not None:
|
|
trash.discard(folder)
|
|
if folder.exists():
|
|
shutil.rmtree(folder)
|
|
folder.mkdir()
|
|
|
|
|
|
def close_trash(parent: Path) -> None:
|
|
"""Stop deleting under ``parent``'s trash and remove it (blocking)."""
|
|
directory = Path(parent) / TRASH_NAME
|
|
with _lock:
|
|
_closed.add(directory)
|
|
trash = _trashes.pop(directory, None)
|
|
if trash is not None:
|
|
trash.close()
|