github pacnpal/compressatorium v4.4.3
v4.4.3 - Nothing waits forever on a drive that stopped answering

latest releases: v4.6.0, v4.5.2, v4.5.1...
3 months ago

Compressatorium 4.4.3

Released 2026-08-17. Nothing waits forever on a drive that stopped answering.

One report started this: a Dolphin conversion sat at Converting... (1134s) against a
progress bar pinned at 0%, and there was no way to tell whether it was crawling or dead.
Pulling that thread found the same shape in five more places, all of them the same bug
written six times — a wait with no time limit on storage that had stopped answering.

That matters more here than in most applications, because a process blocked in
uninterruptible I/O does not die on SIGTERM or SIGKILL; the signal is only delivered
once the kernel I/O returns, which may be never. And with MAX_CONCURRENT_JOBS=1 — the
default — jobs run inline in the dispatcher, so one job that never finishes is every job
that never starts. Cancel sat on Cancelling… forever.

This release bounds every one of those waits, and makes the difference between slow and
stuck visible while it happens.


The short version

  • Every tool reports real status, not just a spinning clock — MB written and a MB/min
    rate, so a slow job reads as slow instead of as a hang. All nine tools, including the six
    that previously reported nothing.
  • One wedged conversion can no longer freeze the queue. Every wait on a subprocess is
    bounded and escalates to giving up; the stuck job fails with an explanation and the queue
    carries on.
  • Verification is bounded by default and Cancel actually stops it. It previously had no
    timeout at all out of the box, and Cancel was never observed.
  • Cleaning up after a failure can no longer freeze the queue — deleting a partial output
    on a dead mount used to be the one unbounded step left in an otherwise bounded chain.
  • A library scan or DAT match stops on a dead volume instead of stranding one live
    process per file, each invisible to the app.
  • The Convert and Jobs panel no longer collapses into a narrow strip between 900 and
    1279 px.

Slow, or stuck?

Most of these CLIs draw a progress bar only to a terminal and fall silent the moment their
output is captured to a pipe. With nothing to parse, the app showed a 0% bar and an elapsed
clock — identical whether the conversion was working or wedged.

Progress reporting is now shared infrastructure rather than something each tool wires up. A
tool's own percentages are used whenever it prints any; when it doesn't, status falls back
automatically to the output file growing on disk, reporting bytes written and a rate.

The rate is the part that matters. It is measured between consecutive samples, not as an
average since the start — a cumulative average is dominated by whatever the job did first,
so a conversion that wrote quickly and then stalled would keep advertising hundreds of
MB/min long after it stopped. Sampled, the byte count keeps climbing while the rate
collapses toward zero, which is exactly the distinction you need.

The same signal feeds the stall watchdog, which scales with input size (about 19 minutes
without growth for a 4.4 GB image). Tools with no parseable progress previously fed it
nothing, so a genuinely slow conversion could be killed as though it had wedged.


Verification is bounded, and cancellable

COMPRESSATORIUM_TOOL_VERIFY_TIMEOUT defaulted to 0 — disabled. Out of the box, a
verify that never returned never ended. It is reachable through Delete sources after
verification
, which is a commonly used option, and it froze the whole queue behind it.

Verify now gets the same adaptive bound the conversion path has had: a baseline plus a
per-GiB allowance for the file actually being read, capped. One flat number cannot serve
both a 400 MB CIA and a 90 GB PS3 ISO. Streaming verifiers also get a no-output stall bound.

ToolPlugin.verify() now takes a cancel_event and the job manager passes the job's own,
so Cancel terminates the verifier instead of being ignored. A run cut short reports
cancelled and becomes a CANCELLED job — never a failed verification, and never a reason
to delete a source.

With verify genuinely bounded, the stalled-job warning no longer exempts the verify phase:
a job wedged in verify is visible in the log again, timed from when verification started.


A dead volume stops the walk

When a child outlives SIGKILL it is abandoned — it keeps its pipes, its PID, and its grip
on whatever storage wedged it. That is the unavoidable price of not hanging the queue, but
it was reported exactly like an ordinary timeout, and callers reasonably read it as "this
one didn't work, move on."

On a batch against unresponsive storage that meant one stranded process per file, each
invisible to the app because its PID had already been untracked. An unkillable
dolphin-tool verify came back as "this disc has no embedded hash", so the scan recorded a
miss and opened the next file on the same dead share.

Now every pass that walks your library stops on the first one and says why: the metadata,
disc-ID and DAT-match phases of a scan, the background match job, and /dat/match-batch.
Single-file requests have no walk to stop, so they report it — /dat/match and the CHD and
Dolphin info endpoints answer 503 rather than presenting an abandoned read as a normal
result, which would invite a refresh that strands another process.

Two related repairs fell out of it. A stuck read is no longer mistaken for "this disc has
no ID"
— the two were the same empty answer, so the tagger would write a tag to a file the
stuck reader still held, and the scan would fall through to reading the whole disc from the
same share. And a conversion whose volume dies during tagging now fails instead of
hanging
: writing the disc-ID tag is best-effort and never failed a job, but everything the
job did next — measuring the output, verifying it — read that same drive.


Cleanup can't freeze the queue either

When a conversion fails, each tool deletes its partial output. On an unresponsive mount
stat and unlink block in uninterruptible I/O and cannot be cancelled, so the sequence
ended badly in the worst case: the converter wedges, the watchdog fires, the child is
abandoned correctly — and then cleanup blocks forever on the same dead mount and the job
never finalises. Those deletions now run through one shared bounded helper. A leftover
partial file is a much smaller problem than a frozen queue.


Fixed

  • The Convert and Jobs panel no longer collapses into a narrow strip on mid-width
    screens.
    Between 900 and 1279 CSS pixels — where a 4K monitor at 300% scaling, a laptop
    at high zoom, or a half-snapped window lands — the panel was never told to span the row,
    so the grid auto-placed it into the 220 px volumes-rail column: a squeezed sliver beside a
    huge empty cell, with the page scrolling forever. A laptop-width screenshot was added to
    the automated set so the in-between breakpoint stays covered.

Upgrade notes

No database migration. The schema is unchanged from 4.2.0 (0003 remains the head).

Verification now has a timeout where it previously had none. This is the one behaviour
change to be aware of. COMPRESSATORIUM_TOOL_VERIFY_TIMEOUT changes from 0 (disabled) to
1800, and is now a baseline to which COMPRESSATORIUM_TOOL_VERIFY_TIMEOUT_PER_GIB
(new, 600) is added for the size of the file being read, capped by
COMPRESSATORIUM_TOOL_VERIFY_TIMEOUT_CAP (new, 86400). The per-GiB allowance is a ~1.7
MB/s floor — generous for any healthy storage. A 90 GB PS3 ISO gets roughly 14.5 hours.
Set COMPRESSATORIUM_TOOL_VERIFY_TIMEOUT_PER_GIB=0 for a flat bound, or
COMPRESSATORIUM_TOOL_VERIFY_TIMEOUT=0 to disable this bound entirely and restore the old
behaviour.

CHD_VERIFY_PROGRESS_TIMEOUT is renamed, and its default is no longer 0. The new name
is COMPRESSATORIUM_TOOL_VERIFY_PROGRESS_TIMEOUT and it now defaults to 600 — a
streaming verifier that produces no output for ten minutes is stopped. The old name still
works
; it is kept as an accepted alias, so existing configurations are not broken. Note
this bound is independent of the overall verify timeout: zeroing one does not zero the
other.

One new per-tool override. COMPRESSATORIUM_JWUD_VERIFY_TIMEOUT, matching the existing
per-tool pattern. Unset means "use the shared value".

No API changes. No endpoint, mode string, or JSON shape was added, removed, or altered.

The image is unchanged in size. No new binaries or runtimes ship with this release.

Nothing new is stored in your browser.

If you had raised timeouts to work around a hang, you can put them back. The hangs this
release fixes were unbounded waits, not tight limits.


Full commit list since v4.4.2 (8 commits, oldest first)

  • 2f03cab chore: sync package.json to v4.4.2 [skip ci]
  • 6fa6160 Report status for every tool, and never wait on a child process unbounded (#263) (#265)
  • 4334866 Bound and cancel the verify stage (#266) (#271)
  • 193473c Update Web UI screenshots — Mon Aug 17 13:04:10 UTC 2026
  • a739577 Bound partial-output cleanup so a dead mount can't freeze the queue (#267) (#269)
  • 94c1be8 Fix convert/jobs panel collapsing into the rail column at 900–1279px (#272)
  • ff05b85 Update Web UI screenshots — Mon Aug 17 14:20:21 UTC 2026
  • 28e2b00 Stop the match and scan walks at an abandoned child (#268) (#270)

Closes #263, #266, #267, #268.

Don't miss a new compressatorium release

NewReleases is sending notifications on new releases.