2020-01-14 22:22:34 -05:00
|
|
|
package model
|
2016-03-02 09:33:49 -05:00
|
|
|
|
2020-01-19 15:37:41 -05:00
|
|
|
import (
|
2020-01-27 09:41:33 -05:00
|
|
|
"context"
|
|
|
|
|
|
2020-01-30 21:48:07 -05:00
|
|
|
"github.com/Masterminds/squirrel"
|
2020-01-19 15:37:41 -05:00
|
|
|
)
|
2016-03-18 11:33:50 -04:00
|
|
|
|
2016-03-03 22:44:28 -05:00
|
|
|
type QueryOptions struct {
|
2020-01-19 22:36:15 -05:00
|
|
|
Sort string
|
|
|
|
|
Order string
|
|
|
|
|
Max int
|
2020-01-15 23:49:20 -05:00
|
|
|
Offset int
|
2020-01-30 21:48:07 -05:00
|
|
|
Filters squirrel.Sqlizer
|
2024-05-19 12:35:30 -04:00
|
|
|
Seed string // for random sorting
|
2016-03-03 22:44:28 -05:00
|
|
|
}
|
2020-01-19 15:37:41 -05:00
|
|
|
|
|
|
|
|
type DataStore interface {
|
2026-09-25 18:06:10 -04:00
|
|
|
Library() LibraryRepository
|
|
|
|
|
Folder() FolderRepository
|
|
|
|
|
Album() AlbumRepository
|
|
|
|
|
Artist() ArtistRepository
|
|
|
|
|
MediaFile() MediaFileRepository
|
|
|
|
|
Genre() GenreRepository
|
|
|
|
|
Tag() TagRepository
|
|
|
|
|
Playlist() PlaylistRepository
|
|
|
|
|
PlayQueue() PlayQueueRepository
|
|
|
|
|
Transcoding() TranscodingRepository
|
|
|
|
|
Player() PlayerRepository
|
|
|
|
|
Radio() RadioRepository
|
|
|
|
|
Share() ShareRepository
|
|
|
|
|
Property() PropertyRepository
|
|
|
|
|
User() UserRepository
|
|
|
|
|
UserProps() UserPropsRepository
|
|
|
|
|
ScrobbleBuffer() ScrobbleBufferRepository
|
|
|
|
|
Scrobble() ScrobbleRepository
|
|
|
|
|
Plugin() PluginRepository
|
|
|
|
|
Artwork() ArtworkRepository
|
|
|
|
|
ArtworkQueue() ArtworkQueueRepository
|
2020-01-19 20:40:18 -05:00
|
|
|
|
2025-02-24 19:13:42 -05:00
|
|
|
WithTx(block func(tx DataStore) error, scope ...string) error
|
2025-02-26 19:01:49 -08:00
|
|
|
WithTxImmediate(block func(tx DataStore) error, scope ...string) error
|
fix(scanner): stop DB lock starvation during scans on slow storage (#6201)
* fix(artwork): pause the artwork worker while a scan is running
The artwork worker added in 0.64 writes to the database continuously, including while a scan runs. On slow storage the scanner holds the write lock for many seconds per folder, so the two writers keep timing each other out: artwork writes fail with "database is locked", and a single busy timeout on the scanner side aborts the whole scan. The worker now stops dispatching queue items while scanner.IsScanning reports true, including mid-batch, and resumes on the next poll after the scan ends. Artwork requests are unaffected, since they serve local art without the worker.
* fix(db): run ANALYZE one index at a time so writers are not starved
A full ANALYZE is a single write transaction, so every other write waits for it to finish and fails after the 15s busy timeout. On slow NAS storage it was measured taking over 26 minutes. The analysis now runs ANALYZE per index (per table for unindexed and WITHOUT ROWID tables), which produces the same sqlite_stat1 rows as a full ANALYZE, and pauses briefly between steps (up to 150ms, just above SQLite's longest busy-handler sleep) so waiting writers get the lock.
* fix(scanner): ignore Synology @eaDir metadata folders
Synology creates an @eaDir folder next to media files, holding one subfolder per file with generated thumbnails. The scanner and watcher treated them as regular folders, which on one reported library added tens of thousands of extra folders to every scan.
* fix(db): analyze tables with only partial indexes as a whole
A partial index does not record the table's row count, so a table whose only indexes are partial needs a table-level ANALYZE to get the sqlite_stat1 row a full ANALYZE would write. Navidrome's schema has no such table today, but the stepped analysis should match a full ANALYZE for any schema a future migration creates.
* fix(scanner): retry busy folder saves and stop phase 1 on a fatal error
On slow storage, a single SQLITE_BUSY while saving a folder aborted the whole scan, even when another writer held the lock only briefly. The folder save now runs as a retryable unit: on a busy error it waits (5s, 10s, 15s) and reruns the transaction, up to three times, before failing. Side effects that do not survive a rollback (the album ID map consumed by persistAlbum, the artwork queue items, the image-change record) are rebuilt per attempt or recorded only after a successful commit.
When a folder save does fail, phase 1 used to keep walking the library and reading tags for every remaining folder, discarding the results, before reporting the error; a reporter saw 40 silent minutes. The walk now stops as soon as the save fails, and the walker honors cancellation instead of blocking on its channel. Because an early stop leaves folders unvisited, phase 1 no longer marks unvisited folders missing when the phase failed; the resumed scan handles them.
* refactor(persistence): move busy retry into DataStore.WithTxRetry
The scanner retried its folder save itself, which meant it had to know SQLite error codes. WithTxRetry now owns that policy: it reruns the block in a fresh transaction on SQLITE_BUSY, up to three times with growing delays, and runs it only once when already inside a transaction, since the outer transaction would still hold the lock. The block receives the context to use, and attempts that will be retried carry a marker so a busy statement in them is logged as a warning; only the final attempt logs errors. The scanner's inner error logs are folded into wrapped errors, so a recovered retry no longer prints error-level lines, and the folder path travels in the log context.
* fix(persistence): join the enclosing transaction in a nested WithTxRetry
Called on a store that is already inside a transaction, WithTxRetry went through WithTx, which opens a second, independent transaction on another connection. That transaction waits on the lock the outer one holds and fails with SQLITE_BUSY, and if it does succeed the outer transaction cannot roll it back. It now runs the block on the enclosing transaction, which owns the lock, the commit and the rollback. Found by a Codex (gpt-6-sol) review.
* fix(scanner): retry the remaining scan writes on a busy database
Every write step after phase 1 still aborted the whole scan on a single SQLITE_BUSY: phase 1 finalize, phase 2 moves and purge, phase 3 album saves and play count refreshes, the deferred playlist import flag, library ScanBegin, GC, the missing-artwork enqueue, tag counts, and the final library update. They now go through WithTxRetry. The phase 2 move had to be made rerun-safe first: it changed the target track's ID inside the transaction, so a rerun would have deleted the moved track itself, and it marked album annotations as handled even when the transaction rolled back. It now works on a copy per attempt and records the annotation reassignment only after a commit.
Artist.RefreshStats is left alone: it updates artists in batches outside a transaction, and one transaction around all of them would hold the write lock for the whole refresh on slow storage. Phase 4 playlist imports go through the playlist service and are left for a follow-up.
* fix(scanner): claim the album before moving its annotations
The rerun-safe moveMatched checked processedAlbumAnnotations before its transaction and marked the album only after the commit. Phase 2 runs same-library and cross-library moves in separate pipeline stages, so two moves into one album could both pass the check; the second would reassign annotations again and overwrite the album's created_at. The album is now claimed under the lock before the transaction, as the old code effectively did, and the claim is released if the move fails so a later move can still reassign. Found by a Codex (gpt-6-sol) review.
* fix(artwork): keep artwork housekeeping from writing during scans
The artwork worker already pauses while a scan runs, but its housekeeping jobs did not: the hourly missing-artwork recheck (a bulk INSERT ... SELECT over albums and artists), the startup run of the same recheck, and the daily prune all kept competing with the scanner for the write lock. They now run through LockForMaintenance, like the scheduled DB analysis: they skip while a scan is running and keep a scan from starting until they finish. Skipping the recheck loses nothing, since each scan with changes queues missing artwork at its end.
* refactor(scanner): log retried step errors once, from the caller
Blocks passed to WithTxRetry still logged their own errors at error level on every attempt, so a busy error that a retry absorbed printed several error lines (GC printed three). They now return wrapped errors and the callers, which already log them, report the final outcome once. Also: drop a leftover variable in phase 1 finalize, check the walk context once, stop repeating the folder field that is already in the log context, stop shadowing finalize's err in phase 3, and format the WithTxRetry scope the same way as WithTx.
* test(scanner): make the scanner suite's temp DB cleanup best effort
Which DB file the process-wide DB handle opens depends on which spec touches it first. When the Scanner container wins the random order, its temp DB stays open until db.Close after RunSpecs, and on Windows removing the temp dir fails with 'being used by another process'. Ginkgo pins that on the container's last spec, which is now one of the busy-database specs. The sibling suites skip Windows for the same reason; this one now removes its temp dir on a best-effort basis instead, so it keeps running there.
2026-09-23 17:04:50 -04:00
|
|
|
// WithTxRetry runs block in a transaction, rerunning it while SQLite reports the database busy.
|
|
|
|
|
// For background work only (it can take minutes), and block must be safe to rerun after a rollback.
|
|
|
|
|
WithTxRetry(ctx context.Context, block func(ctx context.Context, tx DataStore) error, scope ...string) error
|
2025-11-14 22:15:43 -05:00
|
|
|
GC(ctx context.Context, libraryIDs ...int) error
|
2020-01-19 15:37:41 -05:00
|
|
|
}
|