Palash Debnath
73ebd6518d
* fix(errors): four failures that reached users as raw OS text (#1262, #1256, #1251, #1252) #1262 — a voice profile named in any non-latin-1 script 500'd every download endpoint with "'latin-1' codec can't encode characters in position 22-25". `attachment; filename="` is exactly 22 characters, so those were the first four characters of the user's own name. The sanitisers in front of the header filtered with str.isalnum(), which is True for every alphabetic script — they stripped punctuation and passed exactly what breaks the header. Ten sites, one RFC 6266 builder, plus a guard so an eleventh can't be hand-written. #1256 — a synth died on FileNotFoundError: 'ffprobe' and was reported as "an error OmniVoice doesn't recognize", on a Mac where the app's own ffprobe was resolvable the whole time. Our call sites pass explicit paths; a dependency shelling out by bare name does not. The resolved directories are now published on PATH, and the failure is classified either way. #1251 — "The paging file is too small" reached the user as a bare 500. It was already counted as an OOM, but that remedy (close apps, lighter engine) is wrong on a 32 GB machine — the fix is a Windows setting, and the hint now says which. Matched on the code in both the Python and Rust spellings. #1252/#1253 — deleting a dub mid-import crashed it with `ingest: 'mgw39lx3'`: str(KeyError) is the repr of the key. The pipeline blind-subscripted a job that DELETE /dub/history/{id} had popped minutes earlier. It now stops quietly, and no exception whose str() is a bare value can present itself that way again. * fix(engines): Unload 400'd, a wrong language said nothing, DRM was retried by hand (#1247, #1257, #1254) #1247 — list_loaded() advertises in-process engines as `engine:<id>` with "unloadable": true, but unload() only ever handled tts/diarization/sidecars. The panel was rendering a button for ids the dispatcher rejected. The engines already implement unload(); only the routing was missing. The contract test written for it immediately found a second instance — `capture-asr`, listed the same way with no branch either — which is why it enumerates the listing rather than hard-coding ids. #1257 — MLXAudioBackend.supported_languages() returns ["multi"] on the stated assumption that "each engine silently ignores languages it doesn't know". It doesn't; the library raises. So the picker offers all 646 languages and the rejection arrived as a bare list of 23 codes, naming neither the engine nor the way out. Enumerating each model's real language set would be a brittle map that goes stale every engine update — name the engine and the fix instead. #1254 — reported as intermittent: the same URL failed as DRM-protected, then succeeded on retry. Real DRM doesn't lapse; the player client varies. That is the same shape as the 403 case which already escalates through _YT_PLAYER_CLIENTS, so DRM now routes into it. If every client still refuses, the failure is classified instead of arriving as a raw yt-dlp line. * fix(review): close the delete race, narrow the tool match, sanitize the fallback Greptile P1 + CodeRabbit Major — verified real, and mine: splitting merge from save left a window where a delete lands between them, so the pending save UPSERTs the row straight back and a dub the user deleted reappears. Now one atomic step under _dub_jobs_lock, with both delete endpoints purging rows and memory under that same lock. That also fixed DELETE /dub/history, which deleted every row but evicted nothing — an in-flight job survived 'clear history' outright and re-saved itself on completion. CodeRabbit Minor (#1256): the media-tool match accepted any message ending in 'ffmpeg'/'ffprobe', so a missing FILE at /tmp/ffmpeg got the 'repair your media engine' remedy. Now requires the name unquoted-and-unqualified. CodeRabbit Major (#1262): `fallback` reached the header verbatim whenever the real name folded away entirely, walking past every guard the name goes through. Folded like the name. CodeRabbit Major (#1256): the PATH log printed resolved directories, and a user-set FFMPEG_PATH sits under their home. Logs a count now. CodeRabbit Minor (#1262): the subtitle-route assertion also passed against the pre-fix header; it now asserts filename*= too. Skipped: 'Highlights bullets must end with (#N)'. CLAUDE.md scopes that to the ### subsections; none of the seven pre-existing highlights carry refs, and tests/test_changelog_style.py encodes the rule already. * fix(review): the remaining unlocked save paths, an over-broad signature, two weak tests Greptile P1 — the mid-pipeline put_job + save_job pairs were still unlocked, so a clear-history landing between them left a ghost row behind the purge. Both go through put_and_save_job now; only the final completion gate decides whether a withdrawn job's work is kept. CodeRabbit Major (#1257) — 'unsupported language' as a bare prefix also matches 'Unsupported language model configuration', handing a model/config failure engine-switch advice it has no use for. The loose wordings now require the rejected thing to be a code or to end there. CodeRabbit Major (#1257) — the OOM test asserted on SOURCE TEXT, which passes even if the call is unreachable or its result discarded; #1224 taught this same lesson on this codebase. Both it and the language rewrite now drive the real _run_backend_inference with a raising backend. CodeRabbit Minor (#1257) — 'or "engine" in message' always passed, since the production template contains the word. Asserts the resolved class name now. CodeRabbit Major (#1252) — the delete-race test deleted the job BEFORE the merge, which only re-tested the absent case and would pass with the two steps still split. It now interleaves a real second thread against a slow save. CodeRabbit Major (#1256) — a hardcoded /tmp literal trips Ruff S108; built from tmp_path instead. * fix(review): a withdrawal must survive the job's first write CodeRabbit Major — the concern is real, though its suggested fix (gate the checkpoint on the job already existing) would break creation: an ingest's FIRST persistence is what creates the entry, so that gate would never pass. The actual defect is that dict membership cannot express 'withdrawn'. An absent key means 'not written yet' for a new job and 'deleted' for an established one — two opposite instructions from one signal. So a clear-history arriving before the first checkpoint was silently undone by that checkpoint recreating the row, and the run then persisted its result into history the user had just cleared. Tombstone it explicitly: the ingest declares itself in flight, a purge marks any in-flight id withdrawn, and both write paths refuse a withdrawn id. Released in , so it's bounded by concurrent ingests and can't poison a later run that reuses the id. That also fixed clear-history properly: a job with no row yet appears in no id list, so only an in-flight sweep can catch it. CodeRabbit Minor — my race test waited on an event that could not be set while the save held the lock, so it burned its full 2s timeout every run and synchronised nothing. It now waits for the purge thread to REACH the purge. * test(dub): the race test was not testing the race Caught by verifying fail-before rather than trusting the test: splitting merge from save — the exact resurrection bug — passed all 22 tests. The assertions checked WHAT happened (the save ran, the row was deleted, the job left memory) but never WHEN. A save landing after the delete is indistinguishable from one landing before if you only assert that both occurred — and 'after' is precisely the resurrection. Now recorded and asserted as an order. With merge+save atomic the purge cannot start until the save finishes, so the sequence is always save-then-delete; split them and it fails with ['delete', 'save']. That is the second time this test needed rewriting: v1 deleted the job before the merge and only re-checked the absent case, v2 interleaved a real thread but asserted the wrong thing. Both looked like tests. Also documents why the DB write sits inside the lock (atomicity beats a rare 5 s sqlite busy-timeout stall) and that no locked region calls another, so the non-reentrant lock cannot deadlock — verified by walking every locked region. * fix(dub): gate the withdrawal at save_job, not at its callers Greptile P1 — and the same class I'd already fixed, unfixed elsewhere. The withdrawal check sat in the two ingest helpers, but eight direct save_job call sites across dub generate / translate / export / core bypass those entirely. Deleting a dub mid-RENDER therefore still resurrected it, which is at least as likely as deleting mid-import. Moved the gate into save_job itself: one choke point, every caller inherits it, and the ninth cannot forget. That needs a re-entrant lock, since the atomic helpers call save_job while already holding it — a plain Lock would deadlock the backend, so a test pins the lock type and another exercises the nested path. Verified fail-before: removing the gate fails the new test. * fix(dub): the withdrawal only covered ingests, so it covered almost nothing Caught by testing the reported scenario directly instead of trusting a green suite: CI passed, 26 tests passed, and a dub deleted during a RENDER was still resurrected. The tombstone was scoped to in-flight ingests. But a dub is imported once and rendered many times, so the realistic delete lands during a render — long after its ingest ended — and end_ingest was CLEARING the tombstone at exactly that point. The rare case was protected and the common one left open. Now scoped to deletions, not ingests. Kept in a bounded LRU rather than cleared on completion, because there is no moment at which a delete stops mattering: any operation still holding that job can persist it. Re-importing an id is the only thing that legitimately revives it. Verified fail-before: the previous scoping fails three of the new tests. * refactor: move the dub delete-resurrection fix to its own PR (#1270) The six fixes left here are independent error-message changes that needed no corrections. The dub concurrency change needed five rounds, each finding something real in work that was already reviewed, tested and CI-green — the last of them being that the fix did not fix the reported case at all. Riding a release on that record is a bad trade, so it ships separately as #1270. This branch keeps #1262, #1256, #1251, #1247, #1257 and #1254; the KeyError message half goes with the dub PR, since it is that issue's other half.
91 lines
3.9 KiB
Python
91 lines
3.9 KiB
Python
"""RFC 6266 ``Content-Disposition`` construction.
|
|
|
|
#1262: exporting a voice profile whose name isn't spelled in Latin letters
|
|
returned a 500:
|
|
|
|
'latin-1' codec can't encode characters in position 22-25:
|
|
ordinal not in range(256)
|
|
|
|
``attachment; filename="`` is exactly 22 characters, so positions 22-25 were
|
|
the first four characters of the user's own profile name. HTTP header values
|
|
are latin-1 by definition, and every download endpoint built the header by
|
|
f-string interpolation, so any name outside latin-1 — Chinese, Japanese,
|
|
Korean, Greek, Cyrillic, Hebrew, emoji — crashed the request.
|
|
|
|
The sanitisers in front of those f-strings did not catch it because they all
|
|
filtered with ``str.isalnum()``, which is **True for every alphabetic script**,
|
|
not just ASCII. ``"我的声音".isalnum()`` is ``True``. They were removing
|
|
punctuation and passing the exact characters that break the header.
|
|
|
|
`content_disposition` is the one construction site: an ASCII-safe
|
|
``filename=`` that any client can read, plus the RFC 5987 ``filename*=`` that
|
|
gives modern browsers the user's real name back, correctly encoded.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
import unicodedata
|
|
from urllib.parse import quote
|
|
|
|
__all__ = ["ascii_filename", "content_disposition"]
|
|
|
|
#: Characters Windows forbids in a filename, plus the quoting/injection risks
|
|
#: (`"` and `\` end the quoted-string; CR/LF would split the header).
|
|
_UNSAFE = re.compile(r'[\\/:*?"<>|\r\n\t]')
|
|
|
|
|
|
def _fold(text: str) -> str:
|
|
"""One filename part, reduced to safe ASCII."""
|
|
folded = unicodedata.normalize("NFKD", text)
|
|
# Drop the combining marks NFKD split off, keeping the base letters.
|
|
folded = "".join(c for c in folded if not unicodedata.combining(c))
|
|
folded = folded.encode("ascii", "ignore").decode("ascii")
|
|
return _UNSAFE.sub("_", folded).strip()
|
|
|
|
|
|
def ascii_filename(filename: str, fallback: str = "download") -> str:
|
|
"""A latin-1-safe rendering of *filename* for the legacy ``filename=``.
|
|
|
|
Accented Latin is folded to its base letters (``Sébastien`` →
|
|
``Sebastien``) rather than deleted, since that stays readable. Scripts with
|
|
no ASCII form (CJK, Cyrillic, Hebrew, emoji) have no meaningful fold, so
|
|
they drop out and *fallback* carries the name — the ``filename*`` parameter
|
|
is what actually preserves those, and every browser released this decade
|
|
prefers it.
|
|
"""
|
|
raw = filename or ""
|
|
# Split the extension off FIRST: folding runs per-part so a name that is
|
|
# entirely non-ASCII loses its stem without also losing ".ovsvoice", which
|
|
# is what tells the OS (and the user) what the file actually is.
|
|
stem, dot, suffix = raw.rpartition(".")
|
|
if not dot:
|
|
stem, suffix = raw, ""
|
|
|
|
stem, suffix = _fold(stem), _fold(suffix)
|
|
if not stem.strip("_ ."):
|
|
stem = fallback
|
|
return f"{stem}.{suffix}" if suffix else stem
|
|
|
|
|
|
def content_disposition(
|
|
filename: str,
|
|
*,
|
|
disposition: str = "attachment",
|
|
fallback: str = "download",
|
|
) -> str:
|
|
"""A ``Content-Disposition`` value that is safe for ANY filename (#1262).
|
|
|
|
Emits both forms per RFC 6266 §4.3: ``filename=`` for the lowest common
|
|
denominator and ``filename*=UTF-8''…`` for the real name. Clients that
|
|
understand the extended form ignore the plain one, so the user gets
|
|
``我的声音.ovsvoice`` while nothing anywhere has to encode it as latin-1.
|
|
"""
|
|
# The fallback is a caller-supplied string that lands in the header
|
|
# verbatim whenever the real name folds away entirely, so it gets the same
|
|
# treatment as the name itself — otherwise a non-ASCII or quote/CRLF
|
|
# fallback walks straight past every guard here (#1262 review).
|
|
safe_fallback = _fold(fallback) or "download"
|
|
safe = ascii_filename(filename, fallback=safe_fallback)
|
|
encoded = quote(_UNSAFE.sub("_", filename or safe_fallback), safe="")
|
|
return f"{disposition}; filename=\"{safe}\"; filename*=UTF-8''{encoded}"
|