🎧 Your Personal Streaming Service
Go airsonicmadsonicmedia-servermusicmusic-servernavidromeopensubsonicraspberry-piself-hostedstreamerstreaming-apistreaming-audiosubsonicsubsonic-server
feat(artwork): new artwork pipeline with background resolution and Low Quality Image Placeholders (#5847)
Deluan Quintão944ca3100fce
diff --git a/adapters/deezer/deezer.go b/adapters/deezer/deezer.goindex d8e832cf1..742b8b1a5 100644--- a/adapters/deezer/deezer.go+++ b/adapters/deezer/deezer.go@@ -70,16 +70,27 @@ func (s *deezerAgent) GetArtistImages(ctx context.Context, _, name, _ string) ([{artist.PictureSmall, deezerApiPictureSmallSize},}for _, imgData := range possibleImages {- if imgData.URL != "" {+ if imgData.URL != "" && !isPlaceholderPicture(imgData.URL) {res = append(res, agents.ExternalImage{URL: imgData.URL,Size: imgData.Size,})}}+ if len(res) == 0 {+ return nil, agents.ErrNotFound+ }return res, nil}+// deezerEmptyPicturePath is Deezer's empty-image-id path shape for artists with no picture+// (…/images/artist//1000x1000-…), which serves a generic silhouette on any CDN host.+const deezerEmptyPicturePath = "/images/artist//"++func isPlaceholderPicture(url string) bool {+ return strings.Contains(url, deezerEmptyPicturePath)+}+func (s *deezerAgent) searchArtist(ctx context.Context, name string) (*Artist, error) {artists, err := s.client.searchArtists(ctx, name, deezerArtistSearchLimit)if errors.Is(err, ErrNotFound) || len(artists) == 0 {diff --git a/adapters/deezer/deezer_test.go b/adapters/deezer/deezer_test.goindex f478af115..360db1f13 100644--- a/adapters/deezer/deezer_test.go+++ b/adapters/deezer/deezer_test.go@@ -94,6 +94,54 @@ var _ = Describe("deezerAgent", func() {})})+ Describe("GetArtistImages", func() {+ var agent *deezerAgent+ var httpClient *fakeHttpClient++ BeforeEach(func() {+ httpClient = &fakeHttpClient{}+ agent = &deezerAgent{+ dataStore: &tests.MockDataStore{},+ client: newClient(httpClient),+ }+ })++ It("returns the real images when the artist has a picture", func() {+ httpClient.mock("https://api.deezer.com/search/artist", http.Response{+ StatusCode: 200,+ Body: io.NopCloser(bytes.NewBufferString(`{"data":[+ {"id":412,"name":"Queen","nb_fan":12744378,+ "picture_xl":"https://cdn-images.dzcdn.net/images/artist/abc/1000x1000-000000-80-0-0.jpg",+ "picture_big":"https://cdn-images.dzcdn.net/images/artist/abc/500x500-000000-80-0-0.jpg"}+ ],"total":1}`)),+ })++ images, err := agent.GetArtistImages(ctx, "", "Queen", "")++ Expect(err).ToNot(HaveOccurred())+ Expect(images).To(HaveLen(2))+ Expect(images[0].URL).To(ContainSubstring("1000x1000"))+ })++ It("returns ErrNotFound when the artist only has empty-id placeholder pictures", func() {+ httpClient.mock("https://api.deezer.com/search/artist", http.Response{+ StatusCode: 200,+ Body: io.NopCloser(bytes.NewBufferString(`{"data":[+ {"id":412,"name":"Queen","nb_fan":12744378,+ "picture_xl":"https://cdn-images.dzcdn.net/images/artist//1000x1000-000000-80-0-0.jpg",+ "picture_big":"https://cdn-images.dzcdn.net/images/artist//500x500-000000-80-0-0.jpg",+ "picture_medium":"https://cdn-images.dzcdn.net/images/artist//250x250-000000-80-0-0.jpg",+ "picture_small":"https://cdn-images.dzcdn.net/images/artist//56x56-000000-80-0-0.jpg"}+ ],"total":1}`)),+ })++ images, err := agent.GetArtistImages(ctx, "", "Queen", "")++ Expect(err).To(MatchError(agents.ErrNotFound))+ Expect(images).To(BeEmpty())+ })+ })+Describe("GetArtistBiography - Language Fallback", func() {var agent *deezerAgentvar httpClient *langAwareHttpClientdiff --git a/adapters/lastfm/agent.go b/adapters/lastfm/agent.goindex eb8f3d36e..f967595e3 100644--- a/adapters/lastfm/agent.go+++ b/adapters/lastfm/agent.go@@ -93,7 +93,7 @@ func (l *lastfmAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid strinvar resp agents.AlbumInfofor _, lang := range l.languages {var err error- a, err = l.callAlbumGetInfo(ctx, name, artist, mbid, lang)+ a, err = l.callAlbumGetInfo(ctx, name, artist, lang)if err != nil {return nil, err}@@ -114,7 +114,7 @@ func (l *lastfmAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid strin}func (l *lastfmAgent) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]agents.ExternalImage, error) {- a, err := l.callAlbumGetInfo(ctx, name, artist, mbid, l.languages[0])+ a, err := l.callAlbumGetInfo(ctx, name, artist, l.languages[0])if err != nil {return nil, err}@@ -286,22 +286,18 @@ func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string)return res, nil}-func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, mbid string, lang string) (*Album, error) {- a, err := l.client.albumGetInfo(ctx, name, artist, mbid, lang)- var lfErr *lastFMError- isLastFMError := errors.As(err, &lfErr)-- if mbid != "" && (isLastFMError && lfErr.Code == 6) {- log.Debug(ctx, "LastFM/album.getInfo could not find album by mbid, trying again", "album", name, "mbid", mbid)- return l.callAlbumGetInfo(ctx, name, artist, "", lang)- }-+// callAlbumGetInfo matches on name+artist only. Last.fm's album.getInfo by MBID is unreliable —+// a correct MBID can return a different album (or none) — so the MBID is deliberately not passed.+func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, lang string) (*Album, error) {+ a, err := l.client.albumGetInfo(ctx, name, artist, "", lang)if err != nil {- if isLastFMError && lfErr.Code == 6 {- log.Debug(ctx, "Album not found", "album", name, "mbid", mbid, err)- } else {- log.Error(ctx, "Error calling LastFM/album.getInfo", "album", name, "mbid", mbid, err)+ if lfErr, ok := errors.AsType[*lastFMError](err); ok && lfErr.Code == 6 {+ // A not-found is a definitive absence, not a fault: return the shared sentinel so the+ // artwork worker's breaker/transient checks don't retry it, and log it at Debug.+ log.Debug(ctx, "Album not found in Last.fm", "album", name, "artist", artist)+ return nil, agents.ErrNotFound}+ log.Error(ctx, "Error calling LastFM/album.getInfo", "album", name, "artist", artist, err)return nil, err}return a, nil@@ -313,6 +309,12 @@ func (l *lastfmAgent) callArtistGetInfo(ctx context.Context, name string, lang sa, err := l.client.artistGetInfo(ctx, name, lang)if err != nil {+ if lfErr, ok := errors.AsType[*lastFMError](err); ok && lfErr.Code == 6 {+ // A not-found is a definitive absence, not a fault: return the shared sentinel so it+ // doesn't trip the artwork worker's breaker, and log at Debug instead of Error.+ log.Debug(ctx, "Artist not found in Last.fm", "artist", name)+ return nil, agents.ErrNotFound+ }log.Error(ctx, "Error calling LastFM/artist.getInfo", "artist", name, err)return nil, err}diff --git a/adapters/lastfm/agent_test.go b/adapters/lastfm/agent_test.goindex 7e4e29294..94024b9ab 100644--- a/adapters/lastfm/agent_test.go+++ b/adapters/lastfm/agent_test.go@@ -539,7 +539,10 @@ var _ = Describe("lastfmAgent", func() {URL: "https://www.last.fm/music/Cher/Believe",}))Expect(httpClient.RequestCount).To(Equal(1))- Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("03c91c40-49a6-44a7-90e7-a700edf97a62"))+ // MBID is deliberately not sent — album.getInfo matches on name+artist only.+ Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())+ Expect(httpClient.SavedRequest.URL.Query().Get("album")).To(Equal("Believe"))+ Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("Cher"))})It("returns empty images if no images are available", func() {@@ -558,7 +561,7 @@ var _ = Describe("lastfmAgent", func() {_, err := agent.GetAlbumInfo(ctx, "123", "U2", "mbid-1234")Expect(err).To(HaveOccurred())Expect(httpClient.RequestCount).To(Equal(1))- Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))+ Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())})It("returns an error if Last.fm call returns an error", func() {@@ -566,23 +569,17 @@ var _ = Describe("lastfmAgent", func() {_, err := agent.GetAlbumInfo(ctx, "123", "U2", "mbid-1234")Expect(err).To(HaveOccurred())Expect(httpClient.RequestCount).To(Equal(1))- Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))+ Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())})- It("returns an error if Last.fm call returns an error 6 and mbid is empty", func() {+ It("returns an error when Last.fm returns an error 6 (album not found)", func() {httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}- _, err := agent.GetAlbumInfo(ctx, "123", "U2", "")+ _, err := agent.GetAlbumInfo(ctx, "123", "U2", "mbid-1234")Expect(err).To(HaveOccurred())+ // A definitive not-found must satisfy the sentinel, or the artwork worker retries it.+ Expect(errors.Is(err, agents.ErrNotFound)).To(BeTrue())Expect(httpClient.RequestCount).To(Equal(1))- })-- Context("MBID non existent in Last.fm", func() {- It("calls again when last.fm returns an error 6", func() {- httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}- _, _ = agent.GetAlbumInfo(ctx, "123", "U2", "mbid-1234")- Expect(httpClient.RequestCount).To(Equal(2))- Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())- })+ Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())})})@@ -613,6 +610,13 @@ var _ = Describe("lastfmAgent", func() {Expect(images[0].URL).To(Equal("https://lastfm.freetls.fastly.net/i/u/ar0/818148bf682d429dc21b59a73ef6f68e.png"))})+ It("maps a Last.fm error 6 (artist not found) to the shared not-found sentinel", func() {+ apiClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}+ _, err := agent.GetArtistImages(ctx, "123", "Nonexistent Artist", "")+ // Not a fault: runs of missing artists must not trip the worker's circuit breaker.+ Expect(errors.Is(err, agents.ErrNotFound)).To(BeTrue())+ })+It("returns empty list if image is the ignored default image", func() {fApi, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")apiClient.Res = http.Response{Body: fApi, StatusCode: 200}diff --git a/cmd/pls.go b/cmd/pls.goindex 95cbe4eec..184ca6fe7 100644--- a/cmd/pls.go+++ b/cmd/pls.go@@ -12,7 +12,7 @@ import ("strings""github.com/Masterminds/squirrel"- "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/playlists""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model"@@ -260,7 +260,7 @@ func runImport(ctx context.Context, files []string) {ctx = request.WithUser(ctx, *user)}- pls := playlists.NewPlaylists(ds, core.NewImageUploadService())+ pls := playlists.NewPlaylists(ds, artwork.NewUploader(ds))for _, file := range files {absPath, err := filepath.Abs(file)diff --git a/cmd/root.go b/cmd/root.goindex d9e766c32..ff1641bd3 100644--- a/cmd/root.go+++ b/cmd/root.go@@ -11,6 +11,7 @@ import ("github.com/go-chi/chi/v5/middleware""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/db""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model"@@ -88,6 +89,9 @@ func runNavidrome(ctx context.Context) {g.Go(startInsightsCollector(ctx))g.Go(scheduleDBAnalyzer(ctx))g.Go(startPluginManager(ctx))+ artworkWorker := CreateArtworkWorker()+ g.Go(startArtworkWorker(ctx, artworkWorker))+ g.Go(scheduleArtworkHousekeeping(ctx, artworkWorker))g.Go(runInitialScan(ctx))if conf.Server.Scanner.Enabled {g.Go(startScanWatcher(ctx))@@ -344,6 +348,68 @@ func startPlaybackServer(ctx context.Context) func() error {}}+// startArtworkWorker starts the background artwork acquisition worker. It always+// runs; the queue is simply empty until something enqueues work into it.+func startArtworkWorker(ctx context.Context, worker *artwork.Worker) func() error {+ return func() error {+ log.Info(ctx, "Starting artwork worker")+ return worker.Run(ctx)+ }+}++// scheduleArtworkHousekeeping runs the startup fingerprint backfill and registers the+// recurring stale-absent recheck and prune jobs.+func scheduleArtworkHousekeeping(ctx context.Context, worker *artwork.Worker) func() error {+ return func() error {+ schedulerInstance := scheduler.GetInstance()++ if _, err := schedulerInstance.Add(consts.ArtworkStaleAbsentRecheckSchedule, func() {+ if err := worker.EnqueueStaleAbsentAll(ctx); err != nil {+ log.Error(ctx, "Error enqueueing stale artwork rechecks", err)+ }+ if err := worker.EnqueueMissingAll(ctx); err != nil {+ log.Error(ctx, "Error enqueueing missing artwork rechecks", err)+ }+ }); err != nil {+ log.Error(ctx, "Error scheduling artwork stale-absent recheck", err)+ }++ if _, err := schedulerInstance.Add(consts.ArtworkPruneSchedule, func() {+ if err := worker.RunPrune(ctx); err != nil {+ log.Error(ctx, "Error running artwork prune", err)+ }+ }); err != nil {+ log.Error(ctx, "Error scheduling artwork prune", err)+ }++ // Also run the missing-row recheck once at startup so a never-scanned entity is picked up+ // immediately, not only on the next hourly tick (e.g. after enabling the feature).+ if err := worker.EnqueueMissingAll(ctx); err != nil {+ log.Error(ctx, "Error enqueueing missing artwork rechecks", err)+ }++ backfilled, err := worker.Backfill(ctx)+ if err != nil {+ log.Error(ctx, "Error running artwork backfill", err)+ return nil+ }+ if !backfilled {+ return nil+ }+ log.Info(ctx, "Artwork backfill enqueued, scheduling a follow-up prune")+ timer := time.NewTimer(consts.ArtworkPostBackfillPruneDelay)+ defer timer.Stop()+ select {+ case <-timer.C:+ if err := worker.RunPrune(ctx); err != nil {+ log.Error(ctx, "Error running post-backfill artwork prune", err)+ }+ case <-ctx.Done():+ }+ return nil+ }+}+// startPluginManager starts the plugin manager, if configured.func startPluginManager(ctx context.Context) func() error {return func() error {diff --git a/cmd/scan.go b/cmd/scan.goindex 320b401d4..08eccbf2a 100644--- a/cmd/scan.go+++ b/cmd/scan.go@@ -9,7 +9,7 @@ import ("os""strings"- "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/playlists""github.com/navidrome/navidrome/db""github.com/navidrome/navidrome/log"@@ -82,7 +82,7 @@ func runScanner(ctx context.Context) {sqlDB := db.Db()defer db.Db().Close()ds := persistence.New(sqlDB)- pls := playlists.NewPlaylists(ds, core.NewImageUploadService())+ pls := playlists.NewPlaylists(ds, artwork.NewUploader(ds))// Parse targets from command line or filevar scanTargets []model.ScanTargetdiff --git a/cmd/wire_gen.go b/cmd/wire_gen.goindex c4a797ef4..4bdd48422 100644--- a/cmd/wire_gen.go+++ b/cmd/wire_gen.go@@ -65,25 +65,18 @@ func CreateNativeAPIRouter(ctx context.Context) *nativeapi.Router {sqlDB := db.Db()dataStore := persistence.New(sqlDB)share := core.NewShare(dataStore)- imageUploadService := core.NewImageUploadService()- playlistsPlaylists := playlists.NewPlaylists(dataStore, imageUploadService)+ uploader := artwork.NewUploader(dataStore)+ playlistsPlaylists := playlists.NewPlaylists(dataStore, uploader)insights := metrics.GetInstance(dataStore)- fileCache := artwork.GetImageCache()- fFmpeg := ffmpeg.New()broker := events.GetBroker()metricsMetrics := metrics.GetPrometheusInstance(dataStore)- manager := plugins.GetManager(dataStore, broker, metricsMetrics)- agentsAgents := agents.GetAgents(dataStore, manager)- matcherMatcher := matcher.New(dataStore)- provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)- cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)- modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlistsPlaylists, metricsMetrics)+ modelScanner := scanner.New(ctx, dataStore, broker, playlistsPlaylists, metricsMetrics)watcher := scanner.GetWatcher(dataStore, modelScanner)+ manager := plugins.GetManager(dataStore, broker, metricsMetrics)library := core.NewLibrary(dataStore, modelScanner, watcher, broker, manager)user := core.NewUser(dataStore, manager)maintenance := core.NewMaintenance(dataStore)- router := nativeapi.New(dataStore, share, playlistsPlaylists, insights, library, user, maintenance, manager, imageUploadService)+ router := nativeapi.New(dataStore, share, playlistsPlaylists, insights, library, user, maintenance, manager, uploader)return router}@@ -91,23 +84,23 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {sqlDB := db.Db()dataStore := persistence.New(sqlDB)fileCache := artwork.GetImageCache()+ imageStore := artwork.GetImageStore()fFmpeg := ffmpeg.New()+ artworkArtwork := artwork.NewArtwork(dataStore, fileCache, imageStore, fFmpeg)+ transcodingCache := stream.GetTranscodingCache()+ mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)+ share := core.NewShare(dataStore)+ archiver := core.NewArchiver(mediaStreamer, dataStore, share)+ players := core.NewPlayers(dataStore)broker := events.GetBroker()metricsMetrics := metrics.GetPrometheusInstance(dataStore)manager := plugins.GetManager(dataStore, broker, metricsMetrics)agentsAgents := agents.GetAgents(dataStore, manager)matcherMatcher := matcher.New(dataStore)provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)- transcodingCache := stream.GetTranscodingCache()- mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)- share := core.NewShare(dataStore)- archiver := core.NewArchiver(mediaStreamer, dataStore, share)- players := core.NewPlayers(dataStore)- cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)- imageUploadService := core.NewImageUploadService()- playlistsPlaylists := playlists.NewPlaylists(dataStore, imageUploadService)- modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlistsPlaylists, metricsMetrics)+ uploader := artwork.NewUploader(dataStore)+ playlistsPlaylists := playlists.NewPlaylists(dataStore, uploader)+ modelScanner := scanner.New(ctx, dataStore, broker, playlistsPlaylists, metricsMetrics)playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)playbackServer := playback.GetInstance(dataStore)lyricsLyrics := lyrics.NewLyrics(dataStore, manager)@@ -121,21 +114,22 @@ func CreateJellyfinAPIRouter(ctx context.Context) *jellyfin.Router {sqlDB := db.Db()dataStore := persistence.New(sqlDB)fileCache := artwork.GetImageCache()+ imageStore := artwork.GetImageStore()fFmpeg := ffmpeg.New()+ artworkArtwork := artwork.NewArtwork(dataStore, fileCache, imageStore, fFmpeg)+ transcodingCache := stream.GetTranscodingCache()+ mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)+ transcodeDecider := stream.NewTranscodeDecider(dataStore, fFmpeg)+ players := core.NewPlayers(dataStore)broker := events.GetBroker()metricsMetrics := metrics.GetPrometheusInstance(dataStore)manager := plugins.GetManager(dataStore, broker, metricsMetrics)+ playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)+ uploader := artwork.NewUploader(dataStore)+ playlistsPlaylists := playlists.NewPlaylists(dataStore, uploader)agentsAgents := agents.GetAgents(dataStore, manager)matcherMatcher := matcher.New(dataStore)provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)- transcodingCache := stream.GetTranscodingCache()- mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)- transcodeDecider := stream.NewTranscodeDecider(dataStore, fFmpeg)- players := core.NewPlayers(dataStore)- playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)- imageUploadService := core.NewImageUploadService()- playlistsPlaylists := playlists.NewPlaylists(dataStore, imageUploadService)sonicSonic := sonic.New(dataStore, manager, matcherMatcher)lyricsLyrics := lyrics.NewLyrics(dataStore, manager)router := jellyfin.New(dataStore, artworkArtwork, mediaStreamer, transcodeDecider, players, playTracker, playlistsPlaylists, provider, sonicSonic, lyricsLyrics, broker)@@ -146,14 +140,9 @@ func CreatePublicRouter() *public.Router {sqlDB := db.Db()dataStore := persistence.New(sqlDB)fileCache := artwork.GetImageCache()+ imageStore := artwork.GetImageStore()fFmpeg := ffmpeg.New()- broker := events.GetBroker()- metricsMetrics := metrics.GetPrometheusInstance(dataStore)- manager := plugins.GetManager(dataStore, broker, metricsMetrics)- agentsAgents := agents.GetAgents(dataStore, manager)- matcherMatcher := matcher.New(dataStore)- provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)+ artworkArtwork := artwork.NewArtwork(dataStore, fileCache, imageStore, fFmpeg)transcodingCache := stream.GetTranscodingCache()mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)share := core.NewShare(dataStore)@@ -193,38 +182,22 @@ func CreatePrometheus() metrics.Metrics {func CreateScanner(ctx context.Context) model.Scanner {sqlDB := db.Db()dataStore := persistence.New(sqlDB)- fileCache := artwork.GetImageCache()- fFmpeg := ffmpeg.New()broker := events.GetBroker()+ uploader := artwork.NewUploader(dataStore)+ playlistsPlaylists := playlists.NewPlaylists(dataStore, uploader)metricsMetrics := metrics.GetPrometheusInstance(dataStore)- manager := plugins.GetManager(dataStore, broker, metricsMetrics)- agentsAgents := agents.GetAgents(dataStore, manager)- matcherMatcher := matcher.New(dataStore)- provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)- cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)- imageUploadService := core.NewImageUploadService()- playlistsPlaylists := playlists.NewPlaylists(dataStore, imageUploadService)- modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlistsPlaylists, metricsMetrics)+ modelScanner := scanner.New(ctx, dataStore, broker, playlistsPlaylists, metricsMetrics)return modelScanner}func CreateScanWatcher(ctx context.Context) scanner.Watcher {sqlDB := db.Db()dataStore := persistence.New(sqlDB)- fileCache := artwork.GetImageCache()- fFmpeg := ffmpeg.New()broker := events.GetBroker()+ uploader := artwork.NewUploader(dataStore)+ playlistsPlaylists := playlists.NewPlaylists(dataStore, uploader)metricsMetrics := metrics.GetPrometheusInstance(dataStore)- manager := plugins.GetManager(dataStore, broker, metricsMetrics)- agentsAgents := agents.GetAgents(dataStore, manager)- matcherMatcher := matcher.New(dataStore)- provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)- cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)- imageUploadService := core.NewImageUploadService()- playlistsPlaylists := playlists.NewPlaylists(dataStore, imageUploadService)- modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlistsPlaylists, metricsMetrics)+ modelScanner := scanner.New(ctx, dataStore, broker, playlistsPlaylists, metricsMetrics)watcher := scanner.GetWatcher(dataStore, modelScanner)return watcher}@@ -236,6 +209,20 @@ func GetPlaybackServer() playback.PlaybackServer {return playbackServer}+func CreateArtworkWorker() *artwork.Worker {+ sqlDB := db.Db()+ dataStore := persistence.New(sqlDB)+ imageStore := artwork.GetImageStore()+ broker := events.GetBroker()+ metricsMetrics := metrics.GetPrometheusInstance(dataStore)+ manager := plugins.GetManager(dataStore, broker, metricsMetrics)+ agentsAgents := agents.GetAgents(dataStore, manager)+ fFmpeg := ffmpeg.New()+ fileCache := artwork.GetImageCache()+ worker := artwork.NewWorker(dataStore, imageStore, agentsAgents, fFmpeg, broker, fileCache)+ return worker+}+func getPluginManager() *plugins.Manager {sqlDB := db.Db()dataStore := persistence.New(sqlDB)@@ -247,7 +234,7 @@ func getPluginManager() *plugins.Manager {// wire_injectors.go:-var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, jellyfin.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.GetWatcher, metrics.GetPrometheusInstance, db.Db, plugins.GetManager, sonic.New, wire.Bind(new(agents.PluginLoader), new(*plugins.Manager)), wire.Bind(new(scrobbler.PluginLoader), new(*plugins.Manager)), wire.Bind(new(lyrics.PluginLoader), new(*plugins.Manager)), wire.Bind(new(sonic.PluginLoader), new(*plugins.Manager)), wire.Bind(new(sonic.Engine), new(*sonic.Sonic)), wire.Bind(new(nativeapi.PluginManager), new(*plugins.Manager)), wire.Bind(new(core.PluginUnloader), new(*plugins.Manager)), wire.Bind(new(plugins.PluginMetricsRecorder), new(metrics.Metrics)), wire.Bind(new(core.Watcher), new(scanner.Watcher)))+var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, jellyfin.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.GetWatcher, metrics.GetPrometheusInstance, db.Db, plugins.GetManager, sonic.New, wire.Bind(new(agents.PluginLoader), new(*plugins.Manager)), wire.Bind(new(scrobbler.PluginLoader), new(*plugins.Manager)), wire.Bind(new(lyrics.PluginLoader), new(*plugins.Manager)), wire.Bind(new(sonic.PluginLoader), new(*plugins.Manager)), wire.Bind(new(sonic.Engine), new(*sonic.Sonic)), wire.Bind(new(nativeapi.PluginManager), new(*plugins.Manager)), wire.Bind(new(core.PluginUnloader), new(*plugins.Manager)), wire.Bind(new(plugins.PluginMetricsRecorder), new(metrics.Metrics)), wire.Bind(new(core.Watcher), new(scanner.Watcher)), wire.Bind(new(playlists.ImageUploadService), new(artwork.Uploader)))func GetPluginManager(ctx context.Context) *plugins.Manager {manager := getPluginManager()diff --git a/cmd/wire_injectors.go b/cmd/wire_injectors.goindex 94faa5af3..ae24b61fa 100644--- a/cmd/wire_injectors.go+++ b/cmd/wire_injectors.go@@ -14,6 +14,7 @@ import ("github.com/navidrome/navidrome/core/lyrics""github.com/navidrome/navidrome/core/metrics""github.com/navidrome/navidrome/core/playback"+ "github.com/navidrome/navidrome/core/playlists""github.com/navidrome/navidrome/core/scrobbler""github.com/navidrome/navidrome/core/sonic""github.com/navidrome/navidrome/db"@@ -56,6 +57,7 @@ var allProviders = wire.NewSet(wire.Bind(new(core.PluginUnloader), new(*plugins.Manager)),wire.Bind(new(plugins.PluginMetricsRecorder), new(metrics.Metrics)),wire.Bind(new(core.Watcher), new(scanner.Watcher)),+ wire.Bind(new(playlists.ImageUploadService), new(artwork.Uploader)),)func CreateDataStore() model.DataStore {@@ -136,6 +138,12 @@ func GetPlaybackServer() playback.PlaybackServer {))}+func CreateArtworkWorker() *artwork.Worker {+ panic(wire.Build(+ allProviders,+ ))+}+func getPluginManager() *plugins.Manager {panic(wire.Build(allProviders,diff --git a/conf/configuration.go b/conf/configuration.goindex 9b49fb264..5122b15eb 100644--- a/conf/configuration.go+++ b/conf/configuration.go@@ -144,6 +144,8 @@ type configOptions struct {DevArtworkThrottleBacklogLimit intDevArtworkThrottleBacklogTimeout time.DurationDevArtworkThrottleBuffered bool+ DevArtworkWorkerConcurrency int+ DevArtworkExternalMaxRPS intDevArtistInfoTimeToLive time.DurationDevAlbumInfoTimeToLive time.DurationDevExternalScanner bool@@ -1071,6 +1073,12 @@ func setViperDefaults() {viper.SetDefault("devartworkthrottlebackloglimit", consts.RequestThrottleBacklogLimit)viper.SetDefault("devartworkthrottlebacklogtimeout", consts.RequestThrottleBacklogTimeout)viper.SetDefault("devartworkthrottlebuffered", true)+ // Half the CPU count (min 2), so local resolution scales with the host but stays under the+ // SQLite pool (MaxOpenConns) — leaving connections for the scanner, scrobbles and the UI.+ viper.SetDefault("devartworkworkerconcurrency", max(2, runtime.NumCPU()/2))+ // External RPS gates outbound calls to third-party services (per service); it is bounded by+ // their tolerance, not the host, so it stays a small constant regardless of CPU count.+ viper.SetDefault("devartworkexternalmaxrps", 2)viper.SetDefault("devartistinfotimetolive", consts.ArtistInfoTimeToLive)viper.SetDefault("devalbuminfotimetolive", consts.AlbumInfoTimeToLive)viper.SetDefault("devexternalscanner", true)diff --git a/consts/consts.go b/consts/consts.goindex e1a535c79..46906b8b5 100644--- a/consts/consts.go+++ b/consts/consts.go@@ -24,6 +24,9 @@ const (LastDBAnalyzeAttemptAtKey = "LastDBAnalyzeAttemptAt"DBAnalyzePendingKey = "DBAnalyzePending"DBAnalyzeFailureCountKey = "DBAnalyzeFailureCount"+ // ArtConfFingerprintPropertyKey is the model.PropertyRepository key Backfill compares against+ // to detect artwork-affecting config changes across restarts.+ ArtConfFingerprintPropertyKey = "ArtConfFingerprint"UIAuthorizationHeader = "X-ND-Authorization"UIClientUniqueIDHeader = "X-ND-Client-Unique-Id"@@ -36,6 +39,10 @@ const (DBAnalyzeCheckSchedule = "@every 30m"DBAnalyzeMaxAge = 24 * time.Hour+ ArtworkStaleAbsentRecheckSchedule = "@every 1h"+ ArtworkPruneSchedule = "@daily"+ ArtworkPostBackfillPruneDelay = 10 * time.Minute+// DefaultEncryptionKey This is the encryption key used if none is specified in the `PasswordEncryptionKey` option// Never ever change this! Or it will break all Navidrome installations that don't set the config optionDefaultEncryptionKey = "just for obfuscation"@@ -80,6 +87,9 @@ const (I18nFolder = "i18n"ScanIgnoreFile = ".ndignore"ArtworkFolder = "artwork"+ // HashedArtworkFolder is a subtree of ArtworkFolder, kept apart from the name-addressed+ // upload folders beside it so Prune's sweep never reaches them.+ HashedArtworkFolder = "hashed"PlaceholderArtistArt = "artist-placeholder.webp"PlaceholderAlbumArt = "album-placeholder.webp"diff --git a/core/agents/agents.go b/core/agents/agents.goindex ead6dacd0..348f7d4e7 100644--- a/core/agents/agents.go+++ b/core/agents/agents.go@@ -124,6 +124,42 @@ func (a *Agents) AgentName() string {return "agents"}+// ArtistImageAgent pairs an enabled agent's name with its ArtistImageRetriever capability.+type ArtistImageAgent struct {+ Name string+ Retriever ArtistImageRetriever+}++// AlbumImageAgent pairs an enabled agent's name with its AlbumImageRetriever capability.+type AlbumImageAgent struct {+ Name string+ Retriever AlbumImageRetriever+}++// ArtistImageAgents returns the enabled agents implementing ArtistImageRetriever,+// in conf.Server.Agents order (same order the aggregate dispatch uses).+func (a *Agents) ArtistImageAgents() []ArtistImageAgent {+ var result []ArtistImageAgent+ for _, ea := range a.getEnabledAgentNames() {+ if retriever, ok := a.getAgent(ea).(ArtistImageRetriever); ok {+ result = append(result, ArtistImageAgent{Name: ea.name, Retriever: retriever})+ }+ }+ return result+}++// AlbumImageAgents returns the enabled agents implementing AlbumImageRetriever,+// in conf.Server.Agents order (same order the aggregate dispatch uses).+func (a *Agents) AlbumImageAgents() []AlbumImageAgent {+ var result []AlbumImageAgent+ for _, ea := range a.getEnabledAgentNames() {+ if retriever, ok := a.getAgent(ea).(AlbumImageRetriever); ok {+ result = append(result, AlbumImageAgent{Name: ea.name, Retriever: retriever})+ }+ }+ return result+}+func (a *Agents) GetArtistMBID(ctx context.Context, id string, name string) (string, error) {switch id {case consts.UnknownArtistID:diff --git a/core/agents/agents_test.go b/core/agents/agents_test.goindex 50285a084..e3087f995 100644--- a/core/agents/agents_test.go+++ b/core/agents/agents_test.go@@ -362,6 +362,64 @@ var _ = Describe("Agents", func() {})})})++ Describe("Image retriever enumeration", func() {+ var ag *Agents+ var artistImg, artistImg2 *testImageAgent+ var albumImg, albumImg2 *testAlbumImageAgent++ BeforeEach(func() {+ artistImg = &testImageAgent{Name: "artistImg"}+ artistImg2 = &testImageAgent{Name: "artistImg2"}+ albumImg = &testAlbumImageAgent{name: "albumImg"}+ albumImg2 = &testAlbumImageAgent{name: "albumImg2"}+ Register("artistImg", func(model.DataStore) Interface { return artistImg })+ Register("artistImg2", func(model.DataStore) Interface { return artistImg2 })+ Register("albumImg", func(model.DataStore) Interface { return albumImg })+ Register("albumImg2", func(model.DataStore) Interface { return albumImg2 })+ Register("noImages", func(model.DataStore) Interface { return &emptyAgent{} })+ })++ Describe("ArtistImageAgents", func() {+ It("returns only ArtistImageRetriever agents, named, in configured order", func() {+ conf.Server.Agents = "artistImg,noImages,artistImg2"+ ag = createAgents(ds, nil)++ result := ag.ArtistImageAgents()+ Expect(result).To(HaveLen(2))+ Expect(result[0].Name).To(Equal("artistImg"))+ Expect(result[0].Retriever).To(BeIdenticalTo(artistImg))+ Expect(result[1].Name).To(Equal("artistImg2"))+ Expect(result[1].Retriever).To(BeIdenticalTo(artistImg2))+ })++ It("is empty when external services are disabled", func() {+ conf.Server.Agents = "" // what disableExternalServices() sets when EnableExternalServices=false+ ag = createAgents(ds, nil)+ Expect(ag.ArtistImageAgents()).To(BeEmpty())+ })+ })++ Describe("AlbumImageAgents", func() {+ It("returns only AlbumImageRetriever agents, named, in configured order", func() {+ conf.Server.Agents = "albumImg,noImages,albumImg2"+ ag = createAgents(ds, nil)++ result := ag.AlbumImageAgents()+ Expect(result).To(HaveLen(2))+ Expect(result[0].Name).To(Equal("albumImg"))+ Expect(result[0].Retriever).To(BeIdenticalTo(albumImg))+ Expect(result[1].Name).To(Equal("albumImg2"))+ Expect(result[1].Retriever).To(BeIdenticalTo(albumImg2))+ })++ It("is empty when external services are disabled", func() {+ conf.Server.Agents = "" // what disableExternalServices() sets when EnableExternalServices=false+ ag = createAgents(ds, nil)+ Expect(ag.AlbumImageAgents()).To(BeEmpty())+ })+ })+ })})type mockAgent struct {@@ -497,3 +555,17 @@ func (t *testImageAgent) GetArtistImages(_ context.Context, id, name, mbid strint.Args = []any{id, name, mbid}return t.Images, t.Err}++type testAlbumImageAgent struct {+ name string+ Images []ExternalImage+ Err error+ Args []any+}++func (t *testAlbumImageAgent) AgentName() string { return t.name }++func (t *testAlbumImageAgent) GetAlbumImages(_ context.Context, name, artist, mbid string) ([]ExternalImage, error) {+ t.Args = []any{name, artist, mbid}+ return t.Images, t.Err+}diff --git a/core/artwork/agent_images.go b/core/artwork/agent_images.gonew file mode 100644index 000000000..c7032b62b--- /dev/null+++ b/core/artwork/agent_images.go@@ -0,0 +1,100 @@+package artwork++import (+ "context"+ "io"+ "net/url"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/utils/str"+)++// externalName mirrors the normalization the aggregate provider applies, so agent searches match.+func externalName(name string) string {+ if conf.Server.DevPreserveUnicodeInExternalCalls {+ return name+ }+ return str.Clear(name)+}++// bestImageURL returns the largest fetchable image URL. Only one is returned and its failure ends+// the agent's turn, so an unfetchable candidate must never win: url.Parse alone accepts anything.+func bestImageURL(imgs []agents.ExternalImage) *url.URL {+ var best *url.URL+ var bestSize int+ for i := range imgs {+ if imgs[i].URL == "" {+ continue+ }+ u, err := url.Parse(imgs[i].URL)+ if err != nil || !u.IsAbs() || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {+ continue+ }+ if best == nil || imgs[i].Size > bestSize {+ best, bestSize = u, imgs[i].Size+ }+ }+ return best+}++// fetchArtistImage tries each enabled artist-image agent in order. extErr is true only when no+// agent succeeded and at least one failed transiently.+func fetchArtistImage(ctx context.Context, ag *agents.Agents, gate gateFunc, ar model.Artist) (r io.ReadCloser, agentName string, extErr bool) {+ // Synthetic artists would otherwise get an unrelated agent result assigned to them.+ switch ar.ID {+ case consts.UnknownArtistID, consts.VariousArtistsID:+ return nil, "", false+ }+ name := externalName(ar.Name)+ for _, a := range ag.ArtistImageAgents() {+ reader, _, err := gate(a.Name, func() (io.ReadCloser, string, error) {+ imgs, err := a.Retriever.GetArtistImages(ctx, ar.ID, name, ar.MbzArtistID)+ if err != nil {+ return nil, "", err+ }+ u := bestImageURL(imgs)+ if u == nil {+ return nil, "", agents.ErrNotFound+ }+ return fromURL(ctx, u)+ })+ if reader != nil {+ return reader, a.Name, false+ }+ if isTransientExternal(err) {+ extErr = true+ log.Debug(ctx, "Artwork: External artist-image lookup failed", "agent", a.Name, "artist", ar.Name, err)+ }+ }+ return nil, "", extErr+}++// fetchAlbumImage is the album counterpart of fetchArtistImage.+func fetchAlbumImage(ctx context.Context, ag *agents.Agents, gate gateFunc, al model.Album) (r io.ReadCloser, agentName string, extErr bool) {+ name, artist := externalName(al.Name), externalName(al.AlbumArtist)+ for _, a := range ag.AlbumImageAgents() {+ reader, _, err := gate(a.Name, func() (io.ReadCloser, string, error) {+ imgs, err := a.Retriever.GetAlbumImages(ctx, name, artist, al.MbzAlbumID)+ if err != nil {+ return nil, "", err+ }+ u := bestImageURL(imgs)+ if u == nil {+ return nil, "", agents.ErrNotFound+ }+ return fromURL(ctx, u)+ })+ if reader != nil {+ return reader, a.Name, false+ }+ if isTransientExternal(err) {+ extErr = true+ log.Debug(ctx, "Artwork: External album-image lookup failed", "agent", a.Name, "album", al.Name, err)+ }+ }+ return nil, "", extErr+}diff --git a/core/artwork/agent_images_test.go b/core/artwork/agent_images_test.gonew file mode 100644index 000000000..716245c93--- /dev/null+++ b/core/artwork/agent_images_test.go@@ -0,0 +1,262 @@+package artwork++import (+ "context"+ "io"+ "net/http"+ "net/http/httptest"+ "strings"+ "sync"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest"+ "github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/tests"+ "github.com/navidrome/navidrome/utils/str"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++// fakeImageAgent is a built-in agent stub implementing both image retrievers; it+// records call counts so per-agent ordering and short-circuiting can be asserted.+type fakeImageAgent struct {+ name string+ imgs []agents.ExternalImage+ err error+ artistCalls int+ albumCalls int+ gotArtistName string+ gotAlbumName string+ // block, when set, holds every lookup until closed, standing in for a slow/rate-limited agent.+ block chan struct{}+ // mu guards the call counters: the worker resolves several items concurrently.+ mu sync.Mutex+}++func (f *fakeImageAgent) AgentName() string { return f.name }++func (f *fakeImageAgent) GetArtistImages(_ context.Context, _, name, _ string) ([]agents.ExternalImage, error) {+ if f.block != nil {+ <-f.block+ }+ f.mu.Lock()+ f.artistCalls+++ f.gotArtistName = name+ f.mu.Unlock()+ return f.imgs, f.err+}++func (f *fakeImageAgent) GetAlbumImages(_ context.Context, name, _, _ string) ([]agents.ExternalImage, error) {+ f.albumCalls+++ f.gotAlbumName = name+ return f.imgs, f.err+}++// imageAgents registers the fakes as built-in agents and enables them in order. The fakes+// ignore the DataStore, so reusing the process-wide GetAgents singleton across tests is safe.+func imageAgents(fakes ...*fakeImageAgent) *agents.Agents {+ names := make([]string, 0, len(fakes))+ for _, f := range fakes {+ fake := f+ agents.Register(fake.name, func(model.DataStore) agents.Interface { return fake })+ names = append(names, fake.name)+ }+ conf.Server.Agents = strings.Join(names, ",")+ return agents.GetAgents(&tests.MockDataStore{}, nil)+}++var _ = Describe("agent images", func() {+ var (+ ctx context.Context+ srv *httptest.Server+ )++ BeforeEach(func() {+ DeferCleanup(configtest.SetupConfig())+ ctx = context.Background()+ srv = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ _, _ = w.Write([]byte("image-bytes"))+ }))+ DeferCleanup(srv.Close)+ })++ img := func(path string, size int) agents.ExternalImage {+ return agents.ExternalImage{URL: srv.URL + path, Size: size}+ }++ Describe("bestImageURL", func() {+ It("picks the largest-Size URL and skips empty ones", func() {+ u := bestImageURL([]agents.ExternalImage{+ {URL: "http://x/small", Size: 10},+ {URL: "", Size: 9999},+ {URL: "http://x/big", Size: 100},+ })+ Expect(u).ToNot(BeNil())+ Expect(u.String()).To(Equal("http://x/big"))+ })++ It("skips a malformed largest URL and falls back to a valid smaller one", func() {+ u := bestImageURL([]agents.ExternalImage{+ {URL: "http://x/valid", Size: 10},+ {URL: "http://x/%zz", Size: 100}, // invalid percent-escape, largest+ })+ Expect(u).ToNot(BeNil())+ Expect(u.String()).To(Equal("http://x/valid"))+ })++ It("returns nil when there is no non-empty URL", func() {+ Expect(bestImageURL(nil)).To(BeNil())+ Expect(bestImageURL([]agents.ExternalImage{{URL: "", Size: 5}})).To(BeNil())+ })++ // Plugins hand these over as free-form strings, and url.Parse accepts them all. An+ // unfetchable candidate that wins here ends the agent's turn before its valid images run.+ DescribeTable("skips a candidate that cannot be fetched",+ func(badURL string) {+ u := bestImageURL([]agents.ExternalImage{+ {URL: badURL, Size: 100}, // largest, and first+ {URL: "https://cdn.example.com/ok.jpg", Size: 10},+ })+ Expect(u).ToNot(BeNil())+ Expect(u.String()).To(Equal("https://cdn.example.com/ok.jpg"))+ },+ Entry("a relative path", "images/big.jpg"),+ Entry("a root-relative path", "/images/big.jpg"),+ Entry("a scheme we cannot fetch", "ftp://host/big.jpg"),+ Entry("a scheme-relative URL", "//host/big.jpg"),+ Entry("a URL with no host", "http:///big.jpg"),+ )++ // Size is often 0 for every candidate, and only a strictly larger one replaces the first,+ // so an unfetchable entry in first position would otherwise stick.+ It("skips an unfetchable first candidate when every Size is zero", func() {+ u := bestImageURL([]agents.ExternalImage{+ {URL: "images/rel.jpg"},+ {URL: "https://cdn.example.com/ok.jpg"},+ })+ Expect(u).ToNot(BeNil())+ Expect(u.String()).To(Equal("https://cdn.example.com/ok.jpg"))+ })++ It("returns nil when no candidate is fetchable", func() {+ Expect(bestImageURL([]agents.ExternalImage{+ {URL: "images/a.jpg", Size: 10},+ {URL: "ftp://host/b.jpg", Size: 20},+ })).To(BeNil())+ })+ })++ Describe("fetchArtistImage", func() {+ It("returns the first agent's image and its name", func() {+ a := &fakeImageAgent{name: "agentA", imgs: []agents.ExternalImage{img("/a", 100)}}+ ag := imageAgents(a)++ r, name, extErr := fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: "ar1", Name: "Artist"})+ Expect(r).ToNot(BeNil())+ defer r.Close()+ Expect(name).To(Equal("agentA"))+ Expect(extErr).To(BeFalse())+ })++ It("skips the external lookup for synthetic artists", func() {+ a := &fakeImageAgent{name: "agentA", imgs: []agents.ExternalImage{img("/a", 100)}}+ ag := imageAgents(a)++ for _, id := range []string{consts.UnknownArtistID, consts.VariousArtistsID} {+ r, name, extErr := fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: id, Name: "Various Artists"})+ Expect(r).To(BeNil())+ Expect(name).To(BeEmpty())+ Expect(extErr).To(BeFalse())+ }+ Expect(a.artistCalls).To(Equal(0), "synthetic artists never reach the agents")+ })++ It("clears typographic characters from the query name unless preserving unicode", func() {+ conf.Server.DevPreserveUnicodeInExternalCalls = false+ a := &fakeImageAgent{name: "agentA"}+ ag := imageAgents(a)++ _, _, _ = fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: "ar1", Name: "AC’DC"})+ Expect(a.gotArtistName).To(Equal(str.Clear("AC’DC")))+ })++ It("falls through to a later agent, and its success beats the earlier error", func() {+ a := &fakeImageAgent{name: "agentA", err: errBreakerOpen}+ b := &fakeImageAgent{name: "agentB", imgs: []agents.ExternalImage{img("/b", 50)}}+ ag := imageAgents(a, b)++ r, name, extErr := fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: "ar1"})+ Expect(r).ToNot(BeNil())+ defer r.Close()+ Expect(name).To(Equal("agentB"))+ Expect(extErr).To(BeFalse(), "a later hit clears an earlier agent's error")+ Expect(a.artistCalls).To(Equal(1))+ Expect(b.artistCalls).To(Equal(1))+ })++ It("reports a clean miss when every agent finds nothing", func() {+ a := &fakeImageAgent{name: "agentA"} // no images, no error -> not found+ b := &fakeImageAgent{name: "agentB", err: agents.ErrNotFound}+ ag := imageAgents(a, b)++ r, name, extErr := fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: "ar1"})+ Expect(r).To(BeNil())+ Expect(name).To(BeEmpty())+ Expect(extErr).To(BeFalse(), "not-found is definitive, never a transient failure")+ })++ It("reports extErr when one agent fails transiently and the rest find nothing", func() {+ a := &fakeImageAgent{name: "agentA", err: agents.ErrNotFound}+ b := &fakeImageAgent{name: "agentB", err: context.DeadlineExceeded}+ ag := imageAgents(a, b)++ r, _, extErr := fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: "ar1"})+ Expect(r).To(BeNil())+ Expect(extErr).To(BeTrue())+ })+ })++ Describe("fetchAlbumImage", func() {+ It("returns the winning agent's image and name", func() {+ a := &fakeImageAgent{name: "agentA", imgs: []agents.ExternalImage{img("/a", 100)}}+ ag := imageAgents(a)++ r, name, extErr := fetchAlbumImage(ctx, ag, passthroughGate, model.Album{Name: "Album", AlbumArtist: "Artist"})+ Expect(r).ToNot(BeNil())+ defer r.Close()+ Expect(name).To(Equal("agentA"))+ Expect(extErr).To(BeFalse())+ Expect(a.albumCalls).To(Equal(1))+ })++ It("reports extErr when the only agent fails transiently", func() {+ a := &fakeImageAgent{name: "agentA", err: context.DeadlineExceeded}+ ag := imageAgents(a)++ r, _, extErr := fetchAlbumImage(ctx, ag, passthroughGate, model.Album{Name: "Album"})+ Expect(r).To(BeNil())+ Expect(extErr).To(BeTrue())+ })+ })++ Describe("gate naming", func() {+ It("invokes the gate once per agent, keyed by agent name", func() {+ a := &fakeImageAgent{name: "agentA", err: context.DeadlineExceeded}+ b := &fakeImageAgent{name: "agentB", imgs: []agents.ExternalImage{img("/b", 1)}}+ ag := imageAgents(a, b)++ var gatedNames []string+ gate := func(name string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {+ gatedNames = append(gatedNames, name)+ return f()+ }++ r, _, _ := fetchArtistImage(ctx, ag, gate, model.Artist{ID: "ar1"})+ Expect(r).ToNot(BeNil())+ defer r.Close()+ Expect(gatedNames).To(Equal([]string{"agentA", "agentB"}))+ })+ })+})diff --git a/core/artwork/artwork.go b/core/artwork/artwork.goindex b8c395c12..8ac8d9c9d 100644--- a/core/artwork/artwork.go+++ b/core/artwork/artwork.go@@ -1,134 +1,394 @@package artworkimport (+ "bytes""context""errors"- _ "image/gif"+ "fmt""io"+ "os""time"+ "github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core/external""github.com/navidrome/navidrome/core/ffmpeg""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/resources""github.com/navidrome/navidrome/utils/cache"- _ "golang.org/x/image/webp")var ErrUnavailable = errors.New("artwork unavailable")+// errStaleSource means the backing file's mtime no longer matches RefMtime, so the stored hash may be stale.+var errStaleSource = errors.New("artwork: source file changed since resolution")++// Image is one servable artwork response.+type Image struct {+ io.ReadCloser+ Hash string // pixel identity; "" for placeholders+ ETag string // representation validator; "" means Hash applies (full-size original)+ LastUpdated time.Time+ Placeholder bool+}++// representationTag varies with dimensions and encode settings, so a config change invalidates+// a revalidating client's cache even though the pixel hash is unchanged.+func representationTag(hash string, size int, square bool) string {+ return fmt.Sprintf("%s.%d.%v.%s", hash, size, square, formatQualityTag())+}+type Artwork interface {- Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (io.ReadCloser, time.Time, error)- GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (io.ReadCloser, time.Time, error)+ // Get returns ErrUnavailable when there is nothing to serve and model.ErrNotFound when+ // the id resolves to nothing, so the caller can pick placeholder vs 404.+ Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error)+ // GetOrPlaceholder accepts an artwork token or a raw entity id, falling back to the+ // kind's placeholder image (never resized, Placeholder=true).+ GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (*Image, error)}-func NewArtwork(ds model.DataStore, cache cache.FileCache, ffmpeg ffmpeg.FFmpeg, provider external.Provider) Artwork {- return &artwork{ds: ds, cache: cache, ffmpeg: ffmpeg, provider: provider}+func NewArtwork(ds model.DataStore, cache cache.FileCache, store *ImageStore, ffm ffmpeg.FFmpeg) Artwork {+ return &service{ds: ds, cache: cache, store: store, ffmpeg: ffm}}-type artwork struct {- ds model.DataStore- cache cache.FileCache- ffmpeg ffmpeg.FFmpeg- provider external.Provider+// entityExists reports whether the entity an artwork id points at is still there: state rows+// outlive a deleted entity until the next prune, so a servable row is not evidence of its owner.+func entityExists(ctx context.Context, ds model.DataStore, artID model.ArtworkID) bool {+ var found bool+ var err error+ switch artID.Kind {+ case model.KindArtistArtwork:+ found, err = ds.Artist(ctx).Exists(artID.ID)+ case model.KindAlbumArtwork:+ found, err = ds.Album(ctx).Exists(artID.ID)+ case model.KindMediaFileArtwork:+ found, err = ds.MediaFile(ctx).Exists(artID.ID)+ case model.KindPlaylistArtwork:+ found, err = ds.Playlist(ctx).Exists(artID.ID)+ case model.KindRadioArtwork:+ found, err = ds.Radio(ctx).Exists(artID.ID)+ case model.KindDiscArtwork:+ albumID, _, perr := model.ParseDiscArtworkID(artID.ID)+ if perr != nil {+ return false+ }+ found, err = ds.Album(ctx).Exists(albumID)+ default:+ return false+ }+ return err == nil && found}-type artworkReader interface {- cache.Item- LastUpdated() time.Time- Reader(ctx context.Context) (io.ReadCloser, string, error)+type service struct {+ ds model.DataStore+ cache cache.FileCache+ store *ImageStore+ ffmpeg ffmpeg.FFmpeg}-func (a *artwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (reader io.ReadCloser, lastUpdate time.Time, err error) {- artID, err := a.getArtworkId(ctx, id)+func (s *service) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (*Image, error) {+ artID, err := s.parseArtworkID(ctx, id)+ var img *Imageif err == nil {- reader, lastUpdate, err = a.Get(ctx, artID, size, square)+ img, err = s.Get(ctx, artID, size, square)}+ // Only a resolvable entity with no art gets a placeholder; an unknown id must stay+ // ErrNotFound so callers can still answer 404 / Subsonic error 70.if errors.Is(err, ErrUnavailable) {- if artID.Kind == model.KindArtistArtwork {- reader, _ = resources.FS().Open(consts.PlaceholderArtistArt)- } else {- reader, _ = resources.FS().Open(consts.PlaceholderAlbumArt)+ return placeholderImage(artID.Kind), nil+ }+ return img, err+}++func (s *service) Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error) {+ if artID.ID == "" {+ return nil, ErrUnavailable+ }+ if size < 0 {+ size = 0 // a negative size means full-size, not a giant (OOM) resize rectangle+ }+ switch artID.Kind {+ case model.KindDiscArtwork:+ return s.serveDisc(ctx, artID, size, square)+ case model.KindMediaFileArtwork:+ return s.serveMediaFile(ctx, artID, size, square)+ default:+ return s.serveEntity(ctx, artID, size, square)+ }+}++// requestRecheckAge throttles view-triggered rechecks so reopening a genuinely-absent page can't+// hammer external services; below staleAbsentAge to catch younger absences.+const requestRecheckAge = time.Hour++func (s *service) serveEntity(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error) {+ ia, err := s.ds.Artwork(ctx).GetItemArtwork(artID.Kind, artID.ID, model.ImageTypePrimary)+ switch {+ case errors.Is(err, model.ErrNotFound):+ return s.provisional(ctx, artID, size, square)+ case err != nil:+ return nil, err+ case ia.Hash == "":+ // Inserts an immediately-eligible recheck for a settled absent row.+ if time.Since(ia.AttemptedAt) > requestRecheckAge {+ s.enqueue(ctx, artID, model.ArtworkPriorityBump)+ }+ return nil, ErrUnavailable+ default:+ return s.serveHash(ctx, artID, ia, size, square)+ }+}++// serveSource is the one place bytes become an Image. hash is the pixel identity ("" for disc art)+// and doubles as the full-size validator, so an ETag is only needed when resized or hash is "".+func (s *service) serveSource(ctx context.Context, key, hash string, lastUpdate time.Time,+ size int, square bool, open func() (io.ReadCloser, error),+) (*Image, error) {+ if size == 0 && !square {+ rc, err := open()+ if err != nil {+ return nil, err+ }+ if rc == nil {+ return nil, ErrUnavailable+ }+ img := &Image{ReadCloser: rc, Hash: hash, LastUpdated: lastUpdate}+ if hash == "" {+ img.ETag = representationTag(key, size, square)+ }+ return img, nil+ }+ stream, err := s.cache.Get(ctx, &resizedItem{+ hash: key, size: size, square: square, ffmpeg: s.ffmpeg, open: open,+ })+ if err != nil {+ return nil, err+ }+ return &Image{ReadCloser: stream, Hash: hash, ETag: representationTag(key, size, square), LastUpdated: lastUpdate}, nil+}++// serveHash serves the bytes of a found state row. A mismatch/open error is dangling, but a+// cancelled request is not: it must not enqueue a re-resolution.+func (s *service) serveHash(ctx context.Context, artID model.ArtworkID, ia *model.ItemArtwork, size int, square bool) (*Image, error) {+ // Only this path can hand back a deleted entity's bytes; the others load their entity anyway.+ if !entityExists(ctx, s.ds, artID) {+ return nil, ErrUnavailable+ }+ art, err := s.ds.Artwork(ctx).GetImage(ia.Hash)+ if err != nil {+ if errors.Is(err, model.ErrNotFound) {+ return s.dangling(ctx, artID)+ }+ return nil, err+ }+ img, err := s.serveSource(ctx, ia.Hash, ia.Hash, ia.UpdatedAt, size, square,+ func() (io.ReadCloser, error) { return openOriginal(ia, art.Mime, s.store) })+ if err != nil {+ if errors.Is(err, context.Canceled) {+ return nil, err+ }+ log.Warn(ctx, "Artwork: Could not serve image", "artID", artID, "size", size, err)+ return s.dangling(ctx, artID)+ }+ return img, nil+}++// openOriginal enforces the mtime invariant: bytes are never served under a hash they no longer match.+func openOriginal(ia *model.ItemArtwork, mime string, store *ImageStore) (io.ReadCloser, error) {+ if isFileBacked(ia.Source) {+ f, err := os.Open(ia.SourcePath)+ if err != nil {+ return nil, err+ }+ info, err := f.Stat()+ if err != nil {+ f.Close()+ return nil, err+ }+ if ia.RefMtime != 0 && info.ModTime().UnixNano() != ia.RefMtime {+ f.Close()+ log.Debug("Artwork: Backing file changed since resolution", "path", ia.SourcePath,+ "hash", ia.Hash, "resolvedMtime", ia.RefMtime, "currentMtime", info.ModTime().UnixNano())+ return nil, errStaleSource+ }+ return f, nil+ }+ // Store-backed bytes still carry the source's mtime, to detect edits to embedded art.+ if ia.SourcePath != "" && ia.RefMtime != 0 {+ info, err := os.Stat(ia.SourcePath)+ if err != nil {+ return nil, err+ }+ if info.ModTime().UnixNano() != ia.RefMtime {+ log.Debug("Artwork: Source file changed since resolution", "path", ia.SourcePath,+ "hash", ia.Hash, "resolvedMtime", ia.RefMtime, "currentMtime", info.ModTime().UnixNano())+ return nil, errStaleSource}- return reader, consts.ServerStart, nil}- return reader, lastUpdate, err+ return store.Open(ia.Hash, mime)+}++// provisional serves local bytes for an entity with no state row, enqueuing the worker but+// never writing a state row itself.+func (s *service) provisional(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error) {+ item := model.ArtworkQueueItem{ItemKind: artID.Kind.Prefix(), ItemID: artID.ID, ImageType: model.ImageTypePrimary}+ res, err := newLocalResolver(s.ds, s.ffmpeg).resolve(ctx, item)+ if err != nil {+ return nil, err+ }+ s.enqueue(ctx, artID, model.ArtworkPriorityBump)+ log.Debug(ctx, "Artwork: Provisional read-through, no state row yet", "artID", artID,+ "source", res.source, "hit", res.reader != nil)+ return s.serveResolution(ctx, res, size, square)+}++// serveResolution turns a local resolution's bytes into a servable Image (byte-hash only, no decode).+func (s *service) serveResolution(ctx context.Context, res resolution, size int, square bool) (*Image, error) {+ if res.reader == nil {+ return nil, ErrUnavailable+ }+ defer res.reader.Close()+ data, err := readCapped(res.reader)+ if err != nil {+ return nil, ErrUnavailable+ }+ hash, err := hashImage(bytes.NewReader(data))+ if err != nil {+ return nil, ErrUnavailable+ }+ // Keyed by the byte-hash, so the entry lines up with the worker's eventual store entry.+ return s.serveSource(ctx, hash, hash, unixMtime(res.refMtime), size, square,+ func() (io.ReadCloser, error) { return io.NopCloser(bytes.NewReader(data)), nil })+}++func (s *service) serveMediaFile(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error) {+ // The setting is not in the config fingerprint, so honor it at serve time: a direct mf- URL+ // must fall back to disc/album instead of serving stale persisted embedded art.+ if !conf.Server.EnableMediaFileCoverArt {+ mf, err := s.ds.MediaFile(ctx).Get(artID.ID)+ if err != nil {+ return nil, err+ }+ return s.Get(ctx, mf.DiscCoverArtID(), size, square)+ }+ ia, err := s.ds.Artwork(ctx).GetItemArtwork(model.KindMediaFileArtwork, artID.ID, model.ImageTypePrimary)+ switch {+ case err == nil && ia.Hash != "":+ return s.serveHash(ctx, artID, ia, size, square)+ case err == nil:+ // absent row: fall through+ case errors.Is(err, model.ErrNotFound):+ // no row: fall through+ default:+ return nil, err+ }+ noRow := errors.Is(err, model.ErrNotFound)++ mf, err := s.ds.MediaFile(ctx).Get(artID.ID)+ if err != nil {+ return nil, err+ }+ if noRow && conf.Server.EnableMediaFileCoverArt && mf.HasCoverArt {+ return s.provisionalEmbedded(ctx, artID, *mf, size, square)+ }+ // Mirror MediaFile.CoverArtID: a track defers to its disc art, which falls back to the album.+ return s.Get(ctx, mf.DiscCoverArtID(), size, square)}-func (a *artwork) Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (reader io.ReadCloser, lastUpdate time.Time, err error) {- artReader, err := a.getArtworkReader(ctx, artID, size, square)+// provisionalEmbedded serves a track's embedded art immediately, leaving the state row to the worker.+func (s *service) provisionalEmbedded(ctx context.Context, artID model.ArtworkID, mf model.MediaFile, size int, square bool) (*Image, error) {+ lib, err := loadLibraryView(ctx, s.ds, mf.LibraryID)if err != nil {- return nil, time.Time{}, err+ return nil, err+ }+ res, ok := resolveEmbedded(ctx, lib, s.ffmpeg, mf.Path)+ s.enqueue(ctx, artID, model.ArtworkPriorityBump)+ if !ok {+ // Eligible but unextractable: fall back the way CoverArtID does, not to a placeholder.+ return s.Get(ctx, mf.DiscCoverArtID(), size, square)}+ return s.serveResolution(ctx, res, size, square)+}- r, err := a.cache.Get(ctx, artReader)+// serveDisc reads disc art through with no state row and no enqueue, falling back to the album cover.+func (s *service) serveDisc(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error) {+ dr, err := newDiscArtworkReader(ctx, s.ds, artID)+ if err != nil {+ return nil, err+ }+ // Single-disc albums run the chain too: a disc can carry art distinct from the album cover.+ selectImage := func() (io.ReadCloser, string, error) {+ funcs := dr.fromDiscArtPriority(ctx, s.ffmpeg, conf.Server.DiscArtPriority)+ return selectImageReader(ctx, artID, funcs...)+ }+ albumArtID := model.ArtworkID{Kind: model.KindAlbumArtwork, ID: dr.album.ID}+ // Disc art has no state row, hence no content hash: keying on id, album mtime and+ // DiscArtPriority lets a warm cache answer without running the chain or touching the disk.+ key := fmt.Sprintf("%s|%d|%s", artID.ID, dr.cacheTime().UnixNano(), conf.Server.DiscArtPriority)+ img, err := s.serveSource(ctx, key, "", dr.cacheTime(), size, square,+ func() (io.ReadCloser, error) { rc, _, err := selectImage(); return rc, err })if err != nil {- if !errors.Is(err, context.Canceled) && !errors.Is(err, ErrUnavailable) {- log.Error(ctx, "Error accessing image cache", "id", artID, "size", size, err)+ if errors.Is(err, context.Canceled) {+ return nil, err}- return nil, time.Time{}, err+ return s.Get(ctx, albumArtID, size, square)}- return r, artReader.LastUpdated(), nil+ return img, nil}-type coverArtGetter interface {+// dangling enqueues a re-resolution and reports unavailable, leaving the state row untouched.+func (s *service) dangling(ctx context.Context, artID model.ArtworkID) (*Image, error) {+ log.Debug(ctx, "Artwork: State row points at bytes we cannot serve, re-resolving", "artID", artID)+ s.enqueue(ctx, artID, model.ArtworkPriorityScan)+ return nil, ErrUnavailable+}++func (s *service) enqueue(ctx context.Context, artID model.ArtworkID, priority int) {+ err := s.ds.ArtworkQueue(ctx).EnqueuePreservingBackoff(model.ArtworkQueueItem{+ ItemKind: artID.Kind.Prefix(),+ ItemID: artID.ID,+ ImageType: model.ImageTypePrimary,+ Priority: priority,+ })+ if err != nil {+ log.Warn(ctx, "Artwork: Could not enqueue re-resolution", "artID", artID, err)+ }+}++func placeholderImage(kind model.Kind) *Image {+ path := consts.PlaceholderAlbumArt+ if kind == model.KindArtistArtwork {+ path = consts.PlaceholderArtistArt+ }+ r, _ := resources.FS().Open(path)+ return &Image{ReadCloser: r, Placeholder: true}+}++type coverArtIDGetter interface {CoverArtID() model.ArtworkID}-func (a *artwork) getArtworkId(ctx context.Context, id string) (model.ArtworkID, error) {+// parseArtworkID accepts an artwork token or a raw entity id, resolving the latter to its CoverArtID.+func (s *service) parseArtworkID(ctx context.Context, id string) (model.ArtworkID, error) {if id == "" {return model.ArtworkID{}, ErrUnavailable}- artID, err := model.ParseArtworkID(id)- if err == nil {+ if artID, err := model.ParseArtworkID(id); err == nil {return artID, nil}-- log.Trace(ctx, "ArtworkID invalid. Trying to figure out kind based on the ID", "id", id)- entity, err := model.GetEntityByID(ctx, a.ds, id)+ entity, err := model.GetEntityByID(ctx, s.ds, id)if err != nil {return model.ArtworkID{}, err}- if e, ok := entity.(coverArtGetter); ok {- artID = e.CoverArtID()- }- switch e := entity.(type) {- case *model.Artist:- log.Trace(ctx, "ID is for an Artist", "id", id, "name", e.Name, "artist", e.Name)- case *model.Album:- log.Trace(ctx, "ID is for an Album", "id", id, "name", e.Name, "artist", e.AlbumArtist)- case *model.MediaFile:- log.Trace(ctx, "ID is for a MediaFile", "id", id, "title", e.Title, "album", e.Album)- case *model.Playlist:- log.Trace(ctx, "ID is for a Playlist", "id", id, "name", e.Name)+ if e, ok := entity.(coverArtIDGetter); ok {+ return e.CoverArtID(), nil}- return artID, nil+ return model.ArtworkID{}, model.ErrNotFound}-func (a *artwork) getArtworkReader(ctx context.Context, artID model.ArtworkID, size int, square bool) (artworkReader, error) {- var artReader artworkReader- var err error- if size > 0 || square {- artReader, err = resizedFromOriginal(ctx, a, artID, size, square)- } else {- switch artID.Kind {- case model.KindArtistArtwork:- artReader, err = newArtistArtworkReader(ctx, a, artID, a.provider)- case model.KindAlbumArtwork:- artReader, err = newAlbumArtworkReader(ctx, a, artID, a.provider)- case model.KindMediaFileArtwork:- artReader, err = newMediafileArtworkReader(ctx, a, artID)- case model.KindPlaylistArtwork:- artReader, err = newPlaylistArtworkReader(ctx, a, artID)- case model.KindDiscArtwork:- artReader, err = newDiscArtworkReader(ctx, a, artID)- case model.KindRadioArtwork:- artReader, err = newRadioArtworkReader(ctx, a, artID)- default:- return nil, ErrUnavailable- }+func unixMtime(mtime int64) time.Time {+ if mtime <= 0 {+ return time.Time{}}- return artReader, err+ return time.Unix(0, mtime) // RefMtime is unix-nanoseconds}diff --git a/core/artwork/artwork_internal_test.go b/core/artwork/artwork_internal_test.godeleted file mode 100644index 5bcd82f23..000000000--- a/core/artwork/artwork_internal_test.go+++ /dev/null@@ -1,629 +0,0 @@-package artwork--import (- "context"- "errors"- "image"- "image/jpeg"- "image/png"- "io"- "os"- "path/filepath"- "time"-- _ "github.com/gen2brain/webp"- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/conf/configtest"- "github.com/navidrome/navidrome/log"- "github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/tests"- . "github.com/onsi/ginkgo/v2"- . "github.com/onsi/gomega"-)--var _ = Describe("Artwork", func() {- var aw *artwork- var ds model.DataStore- var ffmpeg *tests.MockFFmpeg- var folderRepo *fakeFolderRepo- ctx := log.NewContext(context.TODO())- var alOnlyEmbed, alEmbedNotFound, alOnlyExternal, alExternalNotFound, alMultipleCovers, alSingleDisc model.Album- var arMultipleCovers model.Artist- var mfWithEmbed, mfAnotherWithEmbed, mfWithoutEmbed, mfCorruptedCover model.MediaFile-- BeforeEach(func() {- DeferCleanup(configtest.SetupConfig())- conf.Server.ImageCacheSize = "0" // Disable cache- conf.Server.CoverArtPriority = "folder.*, cover.*, embedded , front.*"-- folderRepo = &fakeFolderRepo{}- libRepo := &tests.MockLibraryRepo{}- repoRoot, _ := os.Getwd()- libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})- ds = &tests.MockDataStore{- MockedTranscoding: &tests.MockTranscodingRepo{},- MockedFolder: folderRepo,- MockedLibrary: libRepo,- }- // Paths use forward slashes because the scanner stores fs.FS-relative paths in the DB.- alOnlyEmbed = model.Album{ID: "222", Name: "Only embed", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}}- alEmbedNotFound = model.Album{ID: "333", Name: "Embed not found", EmbedArtPath: "tests/fixtures/NON_EXISTENT.mp3", FolderIDs: []string{"f1"}}- alOnlyExternal = model.Album{ID: "444", Name: "Only external", FolderIDs: []string{"f1"}, Discs: model.Discs{1: "", 2: ""}}- alExternalNotFound = model.Album{ID: "555", Name: "External not found", FolderIDs: []string{"f2"}}- alSingleDisc = model.Album{ID: "888", Name: "Single disc", FolderIDs: []string{"f1"}, Discs: model.Discs{1: ""}}- arMultipleCovers = model.Artist{ID: "777", Name: "All options"}- alMultipleCovers = model.Album{- ID: "666",- Name: "All options",- EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3",- FolderIDs: []string{"f1"},- AlbumArtistID: "777",- }- mfWithEmbed = model.MediaFile{ID: "22", Path: "tests/fixtures/test.mp3", HasCoverArt: true, AlbumID: "222"}- mfAnotherWithEmbed = model.MediaFile{ID: "23", Path: "tests/fixtures/artist/an-album/test.mp3", HasCoverArt: true, AlbumID: "666"}- mfWithoutEmbed = model.MediaFile{ID: "44", Path: "tests/fixtures/test.ogg", AlbumID: "444"}- mfCorruptedCover = model.MediaFile{ID: "45", Path: "tests/fixtures/test.ogg", HasCoverArt: true, AlbumID: "444"}-- cache := GetImageCache()- ffmpeg = tests.NewMockFFmpeg("content from ffmpeg")- aw = NewArtwork(ds, cache, ffmpeg, nil).(*artwork)- })-- Describe("albumArtworkReader", func() {- Context("ID not found", func() {- It("returns ErrNotFound if album is not in the DB", func() {- _, err := newAlbumArtworkReader(ctx, aw, model.MustParseArtworkID("al-NOT-FOUND"), nil)- Expect(err).To(MatchError(model.ErrNotFound))- })- })- Context("Embed images", func() {- BeforeEach(func() {- folderRepo.result = nil- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{- alOnlyEmbed,- alEmbedNotFound,- })- })- It("returns embed cover", func() {- aw, err := newAlbumArtworkReader(ctx, aw, alOnlyEmbed.CoverArtID(), nil)- Expect(err).ToNot(HaveOccurred())- _, path, err := aw.Reader(ctx)- Expect(err).ToNot(HaveOccurred())- Expect(path).To(Equal("tests/fixtures/artist/an-album/test.mp3"))- })- It("returns ErrUnavailable if embed path is not available", func() {- ffmpeg.Error = errors.New("not available")- aw, err := newAlbumArtworkReader(ctx, aw, alEmbedNotFound.CoverArtID(), nil)- Expect(err).ToNot(HaveOccurred())- _, _, err = aw.Reader(ctx)- Expect(err).To(MatchError(ErrUnavailable))- })- })- Context("External images", func() {- BeforeEach(func() {- folderRepo.result = []model.Folder{}- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{- alOnlyExternal,- alExternalNotFound,- })- })- It("returns external cover", func() {- folderRepo.result = []model.Folder{{- Path: "tests/fixtures/artist/an-album",- ImageFiles: []string{"front.png"},- }}- aw, err := newAlbumArtworkReader(ctx, aw, alOnlyExternal.CoverArtID(), nil)- Expect(err).ToNot(HaveOccurred())- _, path, err := aw.Reader(ctx)- Expect(err).ToNot(HaveOccurred())- Expect(path).To(Equal("tests/fixtures/artist/an-album/front.png"))- })- It("returns ErrUnavailable if external file is not available", func() {- folderRepo.result = []model.Folder{}- aw, err := newAlbumArtworkReader(ctx, aw, alExternalNotFound.CoverArtID(), nil)- Expect(err).ToNot(HaveOccurred())- _, _, err = aw.Reader(ctx)- Expect(err).To(MatchError(ErrUnavailable))- })- })- Context("Multiple covers", func() {- BeforeEach(func() {- folderRepo.result = []model.Folder{{- Path: "tests/fixtures/artist/an-album",- ImageFiles: []string{"cover.jpg", "front.png", "artist.png"},- }}- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{- alMultipleCovers,- })- })- DescribeTable("CoverArtPriority",- func(priority string, expected string) {- conf.Server.CoverArtPriority = priority- aw, err := newAlbumArtworkReader(ctx, aw, alMultipleCovers.CoverArtID(), nil)- Expect(err).ToNot(HaveOccurred())- _, path, err := aw.Reader(ctx)- Expect(err).ToNot(HaveOccurred())- Expect(path).To(Equal(expected))- },- Entry(nil, " folder.* , cover.*,embedded,front.*", "tests/fixtures/artist/an-album/cover.jpg"),- Entry(nil, "front.* , cover.*, embedded ,folder.*", "tests/fixtures/artist/an-album/front.png"),- Entry(nil, " embedded , front.* , cover.*,folder.*", "tests/fixtures/artist/an-album/test.mp3"),- )- })- Context("LastUpdated", func() {- // Regression test for #5377: LastUpdated feeds the HTTP Last-Modified header.- // It must return max(album.UpdatedAt, ImagesUpdatedAt) so browsers revalidate- // cached cover art when only the image file changes.- now := time.Now().Truncate(time.Second)- DescribeTable("returns the max of album.UpdatedAt and ImagesUpdatedAt",- func(albumUpdatedAt, imagesUpdatedAt, expected time.Time) {- album := model.Album{ID: "al1", UpdatedAt: albumUpdatedAt}- folderRepo.result = []model.Folder{{ImagesUpdatedAt: imagesUpdatedAt}}- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{album})-- ar, err := newAlbumArtworkReader(ctx, aw, album.CoverArtID(), nil)- Expect(err).ToNot(HaveOccurred())- Expect(ar.LastUpdated()).To(Equal(expected))- },- Entry("album newer than images", now, now.Add(-1*time.Hour), now),- Entry("images newer than album", now.Add(-24*time.Hour), now.Add(-1*time.Hour), now.Add(-1*time.Hour)),- Entry("equal timestamps", now, now, now),- )- })- })- Describe("discArtworkReader", func() {- Context("LastUpdated", func() {- // Regression test for #5377: same bug as albumArtworkReader — disc covers- // must also revalidate when the image file changes, not only when media files do.- now := time.Now().Truncate(time.Second)- DescribeTable("returns the max of album.UpdatedAt and ImagesUpdatedAt",- func(albumUpdatedAt, imagesUpdatedAt, expected time.Time) {- album := model.Album{ID: "al1", UpdatedAt: albumUpdatedAt}- folderRepo.result = []model.Folder{{ImagesUpdatedAt: imagesUpdatedAt}}- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{album})- ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{- {ID: "mf1", AlbumID: "al1", DiscNumber: 1, Path: "tests/fixtures/test.mp3"},- })-- artID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("al1", 1), nil)- dr, err := newDiscArtworkReader(ctx, aw, artID)- Expect(err).ToNot(HaveOccurred())- Expect(dr.LastUpdated()).To(Equal(expected))- },- Entry("album newer than images", now, now.Add(-1*time.Hour), now),- Entry("images newer than album", now.Add(-24*time.Hour), now.Add(-1*time.Hour), now.Add(-1*time.Hour)),- Entry("equal timestamps", now, now, now),- )- })- })- Describe("artistArtworkReader", func() {- Context("Multiple covers", func() {- BeforeEach(func() {- repoRoot, err := os.Getwd()- Expect(err).ToNot(HaveOccurred())- folderRepo.result = []model.Folder{{- ID: "f1",- LibraryPath: testFileLibPath(repoRoot),- Path: "tests/fixtures/artist/an-album",- ImageFiles: []string{"artist.png"},- }}- ds.Artist(ctx).(*tests.MockArtistRepo).SetData(model.Artists{- arMultipleCovers,- })- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{- alMultipleCovers,- })- ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{- mfAnotherWithEmbed,- })- })- DescribeTable("ArtistArtPriority",- func(priority string, expected string) {- conf.Server.ArtistArtPriority = priority- aw, err := newArtistArtworkReader(ctx, aw, arMultipleCovers.CoverArtID(), nil)- Expect(err).ToNot(HaveOccurred())- _, path, err := aw.Reader(ctx)- Expect(err).ToNot(HaveOccurred())- Expect(filepath.ToSlash(path)).To(HaveSuffix(expected))- },- Entry(nil, " folder.* , artist.*,album/artist.*", "tests/fixtures/artist/artist.jpg"),- Entry(nil, "album/artist.*, folder.*,artist.*", "tests/fixtures/artist/an-album/artist.png"),- )- })- })- Describe("mediafileArtworkReader", func() {- Context("ID not found", func() {- It("returns ErrNotFound if mediafile is not in the DB", func() {- _, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-NOT-FOUND"))- Expect(err).To(MatchError(model.ErrNotFound))- })- })- Context("Embed images", func() {- BeforeEach(func() {- folderRepo.result = []model.Folder{{- Path: "tests/fixtures/artist/an-album",- ImageFiles: []string{"front.png"},- }}- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{- alOnlyEmbed,- alOnlyExternal,- alSingleDisc,- })- ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{- mfWithEmbed,- mfWithoutEmbed,- mfCorruptedCover,- })- })- It("returns embed cover", func() {- aw, err := newMediafileArtworkReader(ctx, aw, mfWithEmbed.CoverArtID())- Expect(err).ToNot(HaveOccurred())- _, path, err := aw.Reader(ctx)- Expect(err).ToNot(HaveOccurred())- Expect(path).To(Equal("tests/fixtures/test.mp3"))- })- It("returns embed cover if successfully extracted by ffmpeg", func() {- aw, err := newMediafileArtworkReader(ctx, aw, mfCorruptedCover.CoverArtID())- Expect(err).ToNot(HaveOccurred())- r, path, err := aw.Reader(ctx)- Expect(err).ToNot(HaveOccurred())- data, _ := io.ReadAll(r)- Expect(data).ToNot(BeEmpty())- Expect(path).To(Equal("tests/fixtures/test.ogg"))- })- It("returns album cover if cannot read embed artwork", func() {- // Force fromTag to fail- mfCorruptedCover.Path = "tests/fixtures/DOES_NOT_EXIST.ogg"- Expect(ds.MediaFile(ctx).(*tests.MockMediaFileRepo).Put(&mfCorruptedCover)).To(Succeed())- // Simulate ffmpeg error- ffmpeg.Error = errors.New("not available")-- aw, err := newMediafileArtworkReader(ctx, aw, mfCorruptedCover.CoverArtID())- Expect(err).ToNot(HaveOccurred())- _, path, err := aw.Reader(ctx)- Expect(err).ToNot(HaveOccurred())- Expect(path).To(Equal("al-444_0"))- })- It("returns album cover if media file has no cover art", func() {- aw, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-"+mfWithoutEmbed.ID))- Expect(err).ToNot(HaveOccurred())- _, path, err := aw.Reader(ctx)- Expect(err).ToNot(HaveOccurred())- Expect(path).To(Equal("al-444_0"))- })- It("falls back to disc cover art when media file has a disc number on a multi-disc album", func() {- mfWithDisc := model.MediaFile{ID: "46", Path: "tests/fixtures/test.ogg", AlbumID: "444", DiscNumber: 2}- Expect(ds.MediaFile(ctx).(*tests.MockMediaFileRepo).Put(&mfWithDisc)).To(Succeed())-- aw, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-"+mfWithDisc.ID))- Expect(err).ToNot(HaveOccurred())- _, path, err := aw.Reader(ctx)- Expect(err).ToNot(HaveOccurred())- // Should fall back to disc art, which itself falls back to album art- Expect(path).To(Equal("dc-444:2_0"))- })- It("falls back to album cover art for single-disc albums even with a disc number", func() {- mfOnSingleDisc := model.MediaFile{ID: "47", Path: "tests/fixtures/test.ogg", AlbumID: "888", DiscNumber: 1}- Expect(ds.MediaFile(ctx).(*tests.MockMediaFileRepo).Put(&mfOnSingleDisc)).To(Succeed())-- aw, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-"+mfOnSingleDisc.ID))- Expect(err).ToNot(HaveOccurred())- _, path, err := aw.Reader(ctx)- Expect(err).ToNot(HaveOccurred())- // Single-disc album should skip disc art and go straight to album art- Expect(path).To(Equal("al-888_0"))- })- })- })- Describe("playlistArtworkReader", func() {- Describe("findPlaylistSidecarPath", func() {- It("discovers sidecar image next to playlist file", func() {- tmpDir := GinkgoT().TempDir()- plsPath := filepath.Join(tmpDir, "MyPlaylist.m3u")- imgPath := filepath.Join(tmpDir, "MyPlaylist.jpg")- Expect(os.WriteFile(plsPath, []byte("#EXTM3U\n"), 0600)).To(Succeed())- Expect(os.WriteFile(imgPath, []byte("fake image"), 0600)).To(Succeed())-- result := findPlaylistSidecarPath(GinkgoT().Context(), plsPath)- Expect(result).To(Equal(imgPath))- })-- It("returns empty string when no sidecar image exists", func() {- tmpDir := GinkgoT().TempDir()- plsPath := filepath.Join(tmpDir, "MyPlaylist.m3u")- Expect(os.WriteFile(plsPath, []byte("#EXTM3U\n"), 0600)).To(Succeed())-- result := findPlaylistSidecarPath(GinkgoT().Context(), plsPath)- Expect(result).To(BeEmpty())- })-- It("returns empty string when playlist has no path", func() {- result := findPlaylistSidecarPath(GinkgoT().Context(), "")- Expect(result).To(BeEmpty())- })-- It("finds sidecar with different case base name", func() {- tmpDir := GinkgoT().TempDir()- plsPath := filepath.Join(tmpDir, "myplaylist.m3u")- imgPath := filepath.Join(tmpDir, "MyPlaylist.jpg")- Expect(os.WriteFile(plsPath, []byte("#EXTM3U\n"), 0600)).To(Succeed())- Expect(os.WriteFile(imgPath, []byte("fake image"), 0600)).To(Succeed())-- result := findPlaylistSidecarPath(GinkgoT().Context(), plsPath)- Expect(result).To(Equal(imgPath))- })- })-- Describe("fromPlaylistExternalImage", func() {- It("opens local path from ExternalImageURL", func() {- tmpDir := GinkgoT().TempDir()- imgPath := filepath.Join(tmpDir, "cover.jpg")- Expect(os.WriteFile(imgPath, []byte("external image data"), 0600)).To(Succeed())-- reader := &playlistArtworkReader{- pl: model.Playlist{ExternalImageURL: imgPath},- }- r, path, err := reader.fromPlaylistExternalImage(ctx)()- Expect(err).ToNot(HaveOccurred())- Expect(r).ToNot(BeNil())- Expect(path).To(Equal(imgPath))- data, _ := io.ReadAll(r)- Expect(string(data)).To(Equal("external image data"))- r.Close()- })-- It("returns nil when ExternalImageURL is empty", func() {- reader := &playlistArtworkReader{- pl: model.Playlist{ExternalImageURL: ""},- }- r, path, err := reader.fromPlaylistExternalImage(ctx)()- Expect(err).ToNot(HaveOccurred())- Expect(r).To(BeNil())- Expect(path).To(BeEmpty())- })-- It("returns error when local file does not exist", func() {- reader := &playlistArtworkReader{- pl: model.Playlist{ExternalImageURL: "/non/existent/path/cover.jpg"},- }- r, _, err := reader.fromPlaylistExternalImage(ctx)()- Expect(err).To(HaveOccurred())- Expect(r).To(BeNil())- })-- It("skips HTTP URL when EnableM3UExternalAlbumArt is false", func() {- conf.Server.EnableM3UExternalAlbumArt = false-- reader := &playlistArtworkReader{- pl: model.Playlist{ExternalImageURL: "https://example.com/cover.jpg"},- }- r, path, err := reader.fromPlaylistExternalImage(ctx)()- Expect(err).ToNot(HaveOccurred())- Expect(r).To(BeNil())- Expect(path).To(BeEmpty())- })-- It("still opens local path when EnableM3UExternalAlbumArt is false", func() {- conf.Server.EnableM3UExternalAlbumArt = false-- tmpDir := GinkgoT().TempDir()- imgPath := filepath.Join(tmpDir, "cover.jpg")- Expect(os.WriteFile(imgPath, []byte("local image"), 0600)).To(Succeed())-- reader := &playlistArtworkReader{- pl: model.Playlist{ExternalImageURL: imgPath},- }- r, path, err := reader.fromPlaylistExternalImage(ctx)()- Expect(err).ToNot(HaveOccurred())- Expect(r).ToNot(BeNil())- Expect(path).To(Equal(imgPath))- r.Close()- })- })- })-- Describe("resizedArtworkReader", func() {- BeforeEach(func() {- folderRepo.result = []model.Folder{{- Path: "tests/fixtures/artist/an-album",- ImageFiles: []string{"cover.jpg", "front.png"},- }}- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{- alMultipleCovers,- })- })- When("Square is false", func() {- It("returns PNG if original image is a PNG", func() {- conf.Server.CoverArtPriority = "front.png"- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 15, false)- Expect(err).ToNot(HaveOccurred())-- img, format, err := image.Decode(r)- Expect(err).ToNot(HaveOccurred())- Expect(format).To(Equal("png"))- Expect(img.Bounds().Size().X).To(Equal(15))- Expect(img.Bounds().Size().Y).To(Equal(15))- })- It("returns JPEG if original image is not a PNG", func() {- conf.Server.CoverArtPriority = "cover.jpg"- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 200, false)- Expect(err).ToNot(HaveOccurred())-- img, format, err := image.Decode(r)- Expect(format).To(Equal("jpeg"))- Expect(err).ToNot(HaveOccurred())- Expect(img.Bounds().Size().X).To(Equal(200))- Expect(img.Bounds().Size().Y).To(Equal(200))- })- })- When("When square is true", func() {- var alCover model.Album-- DescribeTable("resize",- func(srcFormat string, expectedFormat string, landscape bool, size int) {- coverFileName := "cover." + srcFormat- dirName := createImage(srcFormat, landscape, size)- alCover = model.Album{- ID: "444",- Name: "Only external",- FolderIDs: []string{"tmp"},- }- folderRepo.result = []model.Folder{{ImageFiles: []string{coverFileName}}}- rootLibRepo := &tests.MockLibraryRepo{}- rootLibRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(dirName)}})- ds.(*tests.MockDataStore).MockedLibrary = rootLibRepo- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{- alCover,- })-- conf.Server.CoverArtPriority = coverFileName- r, _, err := aw.Get(context.Background(), alCover.CoverArtID(), size, true)- Expect(err).ToNot(HaveOccurred())-- img, format, err := image.Decode(r)- Expect(err).ToNot(HaveOccurred())- Expect(format).To(Equal(expectedFormat))- Expect(img.Bounds().Size().X).To(Equal(size))- Expect(img.Bounds().Size().Y).To(Equal(size))- },- Entry("portrait png image", "png", "png", false, 200),- Entry("landscape png image", "png", "png", true, 200),- Entry("portrait jpg image", "jpg", "png", false, 200),- Entry("landscape jpg image", "jpg", "png", true, 200),- )- })- When("EnableWebPEncoding is true and square is false", func() {- BeforeEach(func() {- conf.Server.EnableWebPEncoding = true- })- It("returns WebP even if original image is a PNG", func() {- conf.Server.CoverArtPriority = "front.png"- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 15, false)- Expect(err).ToNot(HaveOccurred())-- img, format, err := image.Decode(r)- Expect(err).ToNot(HaveOccurred())- Expect(format).To(Equal("webp"))- Expect(img.Bounds().Size().X).To(Equal(15))- Expect(img.Bounds().Size().Y).To(Equal(15))- })- It("returns WebP if original image is not a PNG", func() {- conf.Server.CoverArtPriority = "cover.jpg"- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 200, false)- Expect(err).ToNot(HaveOccurred())-- img, format, err := image.Decode(r)- Expect(format).To(Equal("webp"))- Expect(err).ToNot(HaveOccurred())- Expect(img.Bounds().Size().X).To(Equal(200))- Expect(img.Bounds().Size().Y).To(Equal(200))- })- })- When("EnableWebPEncoding is false and square is false", func() {- BeforeEach(func() {- conf.Server.EnableWebPEncoding = false- })- It("returns PNG if original image is a PNG", func() {- conf.Server.CoverArtPriority = "front.png"- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 15, false)- Expect(err).ToNot(HaveOccurred())-- img, format, err := image.Decode(r)- Expect(err).ToNot(HaveOccurred())- Expect(format).To(Equal("png"))- Expect(img.Bounds().Size().X).To(Equal(15))- Expect(img.Bounds().Size().Y).To(Equal(15))- })- It("returns JPEG if original image is a JPG", func() {- conf.Server.CoverArtPriority = "cover.jpg"- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 200, false)- Expect(err).ToNot(HaveOccurred())-- img, format, err := image.Decode(r)- Expect(err).ToNot(HaveOccurred())- Expect(format).To(Equal("jpeg"))- Expect(img.Bounds().Size().X).To(Equal(200))- Expect(img.Bounds().Size().Y).To(Equal(200))- })- })- When("EnableWebPEncoding is false and square is true", func() {- var alCover model.Album-- BeforeEach(func() {- conf.Server.EnableWebPEncoding = false- })- It("returns PNG for square mode", func() {- dirName := createImage("png", false, 200)- alCover = model.Album{- ID: "444",- Name: "Only external",- FolderIDs: []string{"tmp"},- }- folderRepo.result = []model.Folder{{ImageFiles: []string{"cover.png"}}}- rootLibRepo := &tests.MockLibraryRepo{}- rootLibRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(dirName)}})- ds.(*tests.MockDataStore).MockedLibrary = rootLibRepo- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{alCover})-- conf.Server.CoverArtPriority = "cover.png"- r, _, err := aw.Get(context.Background(), alCover.CoverArtID(), 200, true)- Expect(err).ToNot(HaveOccurred())-- img, format, err := image.Decode(r)- Expect(err).ToNot(HaveOccurred())- Expect(format).To(Equal("png"))- Expect(img.Bounds().Size().X).To(Equal(200))- Expect(img.Bounds().Size().Y).To(Equal(200))- })- })- When("Requested size is larger than original", func() {- It("clamps size to original dimensions", func() {- conf.Server.CoverArtPriority = "front.png"- // front.png is 16x16, requesting 99999 should return at original size- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 99999, false)- Expect(err).ToNot(HaveOccurred())-- img, _, err := image.Decode(r)- Expect(err).ToNot(HaveOccurred())- // Should be clamped to original size (16), not 99999- Expect(img.Bounds().Size().X).To(Equal(16))- Expect(img.Bounds().Size().Y).To(Equal(16))- })-- It("clamps square size to original dimensions", func() {- conf.Server.CoverArtPriority = "front.png"- // front.png is 16x16, requesting 99999 with square should return 16x16 square- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 99999, true)- Expect(err).ToNot(HaveOccurred())-- img, _, err := image.Decode(r)- Expect(err).ToNot(HaveOccurred())- // Should be clamped to original size (16), not 99999- Expect(img.Bounds().Size().X).To(Equal(16))- Expect(img.Bounds().Size().Y).To(Equal(16))- })- })- })-})--func createImage(format string, landscape bool, size int) string {- var img image.Image-- if landscape {- img = image.NewRGBA(image.Rect(0, 0, size, size/2))- } else {- img = image.NewRGBA(image.Rect(0, 0, size/2, size))- }-- tmpDir := GinkgoT().TempDir()- f, _ := os.Create(filepath.Join(tmpDir, "cover."+format))- defer f.Close()- switch format {- case "png":- _ = png.Encode(f, img)- case "jpg":- _ = jpeg.Encode(f, img, &jpeg.Options{Quality: 75})- }-- return tmpDir-}diff --git a/core/artwork/artwork_suite_test.go b/core/artwork/artwork_suite_test.goindex d42d7f3e4..1ea82b7fa 100644--- a/core/artwork/artwork_suite_test.go+++ b/core/artwork/artwork_suite_test.go@@ -11,13 +11,26 @@ import ("github.com/navidrome/navidrome/core/storage""github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/metadata""github.com/navidrome/navidrome/tests". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega"+ "go.uber.org/goleak")func TestArtwork(t *testing.T) {+ // Runs unconditionally: the two leaks below are pre-existing and out of this+ // package's control, so they're ignored by exact top-function instead.+ defer goleak.VerifyNone(t,+ goleak.IgnoreTopFunction("github.com/onsi/ginkgo/v2/internal/interrupt_handler.(*InterruptHandler).registerForInterrupts.func2"),+ // notify's own init() starts a singleton tree the moment it's imported (via+ // core/storage/local or plugins); recursive on darwin, nonrecursive on linux.+ goleak.IgnoreTopFunction("github.com/rjeczalik/notify.(*recursiveTree).dispatch"),+ goleak.IgnoreTopFunction("github.com/rjeczalik/notify.(*nonrecursiveTree).dispatch"),+ goleak.IgnoreTopFunction("github.com/rjeczalik/notify.(*nonrecursiveTree).internal"),+ )+tests.Init(t, false)log.SetLevel(log.LevelFatal)RegisterFailHandler(Fail)@@ -25,7 +38,6 @@ func TestArtwork(t *testing.T) {}// osDirFS wraps os.DirFS as a storage.MusicFS for integration tests.-// ReadTags is not used by albumArtworkReader, so it is left as a stub.type osDirFS struct{ fs.FS }func (o osDirFS) ReadTags(...string) (map[string]metadata.Info, error) { return nil, nil }@@ -69,3 +81,37 @@ func (s *osDirStorage) FS() (storage.MusicFS, error) {}return osDirFS{os.DirFS(s.root)}, nil}++// fakeFolderRepo covers the three FolderRepository methods the resolvers reach for. The zero value+// answers as an unremarkable library does; the fields drive the album-root lookup and its failures.+type fakeFolderRepo struct {+ model.FolderRepository+ result []model.Folder+ err error+ parentResult *model.Folder+ getErr error+ getCallCount int+ // hasOtherAudio is returned by HasAudioOutsideFolders (the album-root check).+ // False means the parent qualifies as an album root.+ hasOtherAudio bool+ otherAudioErr error+}++func (f *fakeFolderRepo) GetAll(...model.QueryOptions) ([]model.Folder, error) {+ return f.result, f.err+}++func (f *fakeFolderRepo) HasAudioOutsideFolders(model.Folder, []string) (bool, error) {+ return f.hasOtherAudio, f.otherAudioErr+}++func (f *fakeFolderRepo) Get(string) (*model.Folder, error) {+ f.getCallCount+++ if f.getErr != nil {+ return nil, f.getErr+ }+ if f.parentResult != nil {+ return f.parentResult, nil+ }+ return nil, model.ErrNotFound+}diff --git a/core/artwork/artwork_test.go b/core/artwork/artwork_test.goindex adddd0dc3..c6b848101 100644--- a/core/artwork/artwork_test.go+++ b/core/artwork/artwork_test.go@@ -1,57 +1,523 @@-package artwork_test+package artworkimport (+ "bytes""context"+ "image""io"+ "os"+ "path/filepath"+ "time""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/conf/configtest""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/resources""github.com/navidrome/navidrome/tests"+ "github.com/navidrome/navidrome/utils/cache". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega")var _ = Describe("Artwork", func() {- var aw artwork.Artwork- var ds model.DataStore- var ffmpeg *tests.MockFFmpeg+ var (+ ctx context.Context+ ds *tests.MockDataStore+ artRepo *tests.MockArtworkRepo+ queueRepo *tests.MockArtworkQueueRepo+ albumRepo *tests.MockAlbumRepo+ mfRepo *tests.MockMediaFileRepo+ folderRepo *fakeFolderRepo+ libRepo *tests.MockLibraryRepo+ ffm *tests.MockFFmpeg+ store *ImageStore+ imgCache cache.FileCache+ svc Artwork+ repoRoot string+ coverBytes []byte+ seedEntity func(kind, id string)+ )++ primaryKey := func(kind, id string) string { return kind + "|" + id + "|" + model.ImageTypePrimary }++ seedFoundStore := func(kind, id string, imgBytes []byte) string {+ hash, err := hashImage(bytes.NewReader(imgBytes))+ Expect(err).ToNot(HaveOccurred())+ Expect(store.Write(hash, "image/jpeg", bytes.NewReader(imgBytes))).To(Succeed())+ Expect(artRepo.PutImage(&model.Artwork{Hash: hash, Mime: "image/jpeg"})).To(Succeed())+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: kind, ItemID: id, Hash: hash, Source: "external"})).To(Succeed())+ seedEntity(kind, id)+ return hash+ }++ // Without its owning entity, a state row is not served at all.+ seedEntity = func(kind, id string) {+ GinkgoHelper()+ switch kind {+ case "al":+ Expect(albumRepo.Put(&model.Album{ID: id, Name: "Album"})).To(Succeed())+ case "mf":+ Expect(mfRepo.Put(&model.MediaFile{ID: id})).To(Succeed())+ }+ }++ readAll := func(img *Image) []byte {+ GinkgoHelper()+ defer img.Close()+ data, err := io.ReadAll(img)+ Expect(err).ToNot(HaveOccurred())+ return data+ }BeforeEach(func() {DeferCleanup(configtest.SetupConfig())- conf.Server.ImageCacheSize = "0" // Disable cache- cache := artwork.GetImageCache()- ffmpeg = tests.NewMockFFmpeg("content from ffmpeg")- aw = artwork.NewArtwork(ds, cache, ffmpeg, nil)+ ctx = context.Background()+ var err error+ repoRoot, err = os.Getwd()+ Expect(err).ToNot(HaveOccurred())+ coverBytes, err = os.ReadFile(filepath.Join(repoRoot, "tests/fixtures/artist/an-album/cover.jpg"))+ Expect(err).ToNot(HaveOccurred())++ conf.Server.EnableWebPEncoding = false+ conf.Server.CoverArtQuality = 75+ conf.Server.CoverArtPriority = "cover.*"+ conf.Server.DiscArtPriority = "cover.*"+ conf.Server.CacheFolder = conf.NewDir(GinkgoT().TempDir())++ artRepo = tests.CreateMockArtworkRepo()+ queueRepo = tests.CreateMockArtworkQueueRepo()+ albumRepo = tests.CreateMockAlbumRepo()+ mfRepo = tests.CreateMockMediaFileRepo()+ folderRepo = &fakeFolderRepo{}+ libRepo = &tests.MockLibraryRepo{}+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})+ ds = &tests.MockDataStore{+ MockedArtwork: artRepo,+ MockedArtworkQueue: queueRepo,+ MockedAlbum: albumRepo,+ MockedMediaFile: mfRepo,+ MockedFolder: folderRepo,+ MockedLibrary: libRepo,+ }+ ffm = tests.NewMockFFmpeg("")+ store = NewImageStore(GinkgoT().TempDir())+ imgCache = cache.NewFileCache("ServingTest", "100MB", "images", 0,+ func(ctx context.Context, arg cache.Item) (io.Reader, error) {+ return arg.(artworkReader).Reader(ctx)+ })+ Eventually(func() bool { return imgCache.Available(ctx) }).Should(BeTrue())+ svc = NewArtwork(ds, imgCache, store, ffm)})- Context("GetOrPlaceholder", func() {- Context("Empty ID", func() {- It("returns placeholder if album is not in the DB", func() {- r, _, err := aw.GetOrPlaceholder(context.Background(), "", 0, false)- Expect(err).ToNot(HaveOccurred())+ Describe("found state", func() {+ It("serves a store-backed found image sized (cache miss resizes, second call is a cache hit)", func() {+ seedFoundStore("al", "al1", coverBytes)- ph, err := resources.FS().Open(consts.PlaceholderAlbumArt)- Expect(err).ToNot(HaveOccurred())- phBytes, err := io.ReadAll(ph)- Expect(err).ToNot(HaveOccurred())+ img, err := svc.Get(ctx, model.MustParseArtworkID("al-al1"), 100, false)+ Expect(err).ToNot(HaveOccurred())+ // A resized response versions its ETag with the encode settings, not the pixel hash.+ Expect(img.ETag).To(Equal(representationTag(img.Hash, 100, false)))+ Expect(img.ETag).ToNot(Equal(img.Hash))+ resized := readAll(img)+ cfg, _, err := image.DecodeConfig(bytes.NewReader(resized))+ Expect(err).ToNot(HaveOccurred())+ Expect(cfg.Width).To(Equal(100))- result, err := io.ReadAll(r)- Expect(err).ToNot(HaveOccurred())+ // Deleting the store file proves the warm entry serves without touching the original.+ hash, _ := hashImage(bytes.NewReader(coverBytes))+ Expect(os.Remove(store.path(hash, "image/jpeg"))).To(Succeed())+ Eventually(func(g Gomega) {+ img2, err := svc.Get(ctx, model.MustParseArtworkID("al-al1"), 100, false)+ g.Expect(err).ToNot(HaveOccurred())+ g.Expect(readAll(img2)).To(Equal(resized))+ }).Should(Succeed())+ })- Expect(result).To(Equal(phBytes))- })+ It("treats a negative size as a full-size request, not a giant resize", func() {+ seedFoundStore("al", "alneg", coverBytes)++ img, err := svc.Get(ctx, model.MustParseArtworkID("al-alneg"), -2000000000, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(coverBytes), "original bytes, no resize (would OOM)")+ })++ It("streams a file-backed found image at full size", func() {+ dir := GinkgoT().TempDir()+ imgPath := filepath.Join(dir, "cover.jpg")+ Expect(os.WriteFile(imgPath, coverBytes, 0600)).To(Succeed())+ mtime := fileMtime(imgPath)+ Expect(artRepo.PutImage(&model.Artwork{Hash: "aaaaaaaaaaaaaaaa", Mime: "image/jpeg"})).To(Succeed())+ seedEntity("al", "al2")+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{+ ItemKind: "al", ItemID: "al2", Hash: "aaaaaaaaaaaaaaaa",+ Source: "folder", SourcePath: imgPath, RefMtime: mtime,+ })).To(Succeed())++ img, err := svc.Get(ctx, model.MustParseArtworkID("al-al2"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(coverBytes))+ })++ It("treats a full-size mtime mismatch as dangling: unavailable, re-enqueued at Scan, state untouched", func() {+ dir := GinkgoT().TempDir()+ imgPath := filepath.Join(dir, "cover.jpg")+ Expect(os.WriteFile(imgPath, coverBytes, 0600)).To(Succeed())+ Expect(artRepo.PutImage(&model.Artwork{Hash: "bbbbbbbbbbbbbbbb", Mime: "image/jpeg"})).To(Succeed())+ seedEntity("al", "al3")+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{+ ItemKind: "al", ItemID: "al3", Hash: "bbbbbbbbbbbbbbbb",+ Source: "folder", SourcePath: imgPath, RefMtime: fileMtime(imgPath) + 999,+ })).To(Succeed())++ _, err := svc.Get(ctx, model.MustParseArtworkID("al-al3"), 0, false)+ Expect(err).To(MatchError(ErrUnavailable))+ Expect(queueRepo.Data[primaryKey("al", "al3")].Priority).To(Equal(model.ArtworkPriorityScan))+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al3", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Hash).To(Equal("bbbbbbbbbbbbbbbb"))+ })++ It("enforces the mtime rule on the sized (loader) path too", func() {+ dir := GinkgoT().TempDir()+ imgPath := filepath.Join(dir, "cover.jpg")+ Expect(os.WriteFile(imgPath, coverBytes, 0600)).To(Succeed())+ Expect(artRepo.PutImage(&model.Artwork{Hash: "cccccccccccccccc", Mime: "image/jpeg"})).To(Succeed())+ seedEntity("al", "al3b")+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{+ ItemKind: "al", ItemID: "al3b", Hash: "cccccccccccccccc",+ Source: "folder", SourcePath: imgPath, RefMtime: fileMtime(imgPath) + 999,+ })).To(Succeed())++ _, err := svc.Get(ctx, model.MustParseArtworkID("al-al3b"), 100, false)+ Expect(err).To(MatchError(ErrUnavailable))+ Expect(queueRepo.Data[primaryKey("al", "al3b")].Priority).To(Equal(model.ArtworkPriorityScan))+ })++ // State rows outlive a deleted entity until the next prune.+ It("refuses to serve a found row whose entity is gone", func() {+ hash := seedFoundStore("al", "alzz", coverBytes)+ Expect(hash).ToNot(BeEmpty())+ albumRepo.SetData(model.Albums{}) // the album is deleted; its artwork row survives++ _, err := svc.Get(ctx, model.MustParseArtworkID("al-alzz"), 0, false)+ Expect(err).To(MatchError(ErrUnavailable))+ })++ It("does not re-enqueue a recently-attempted absent state", func() {+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{+ ItemKind: "al", ItemID: "al4", AttemptedAt: time.Now(),+ })).To(Succeed())++ _, err := svc.Get(ctx, model.MustParseArtworkID("al-al4"), 0, false)+ Expect(err).To(MatchError(ErrUnavailable))+ Expect(queueRepo.Data).To(BeEmpty())+ })++ It("promotes a stale absent state at Bump priority on view", func() {+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{+ ItemKind: "al", ItemID: "al4b", AttemptedAt: time.Now().Add(-2 * requestRecheckAge),+ })).To(Succeed())++ _, err := svc.Get(ctx, model.MustParseArtworkID("al-al4b"), 0, false)+ Expect(err).To(MatchError(ErrUnavailable))+ Expect(queueRepo.Data[primaryKey("al", "al4b")].Priority).To(Equal(model.ArtworkPriorityBump))+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al4b", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Hash).To(BeEmpty())})})- Context("Get", func() {- Context("Empty ID", func() {- It("returns an ErrUnavailable error", func() {- _, _, err := aw.Get(context.Background(), model.ArtworkID{}, 0, false)- Expect(err).To(MatchError(artwork.ErrUnavailable))- })++ Describe("provisional read-through", func() {+ It("serves local folder art, enqueues a Bump, and writes no state row", func() {+ folderRepo.result = []model.Folder{{Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"}}}+ albumRepo.SetData(model.Albums{{ID: "al5", Name: "Album", FolderIDs: []string{"f1"}}})++ img, err := svc.Get(ctx, model.MustParseArtworkID("al-al5"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(coverBytes))++ Expect(queueRepo.Data[primaryKey("al", "al5")].Priority).To(Equal(model.ArtworkPriorityBump))+ _, err = artRepo.GetItemArtwork(model.KindAlbumArtwork, "al5", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ })++ It("returns ErrUnavailable and enqueues a Bump when nothing local resolves", func() {+ folderRepo.result = nil+ albumRepo.SetData(model.Albums{{ID: "al6", Name: "Album"}})++ _, err := svc.Get(ctx, model.MustParseArtworkID("al-al6"), 0, false)+ Expect(err).To(MatchError(ErrUnavailable))+ Expect(queueRepo.Data[primaryKey("al", "al6")].Priority).To(Equal(model.ArtworkPriorityBump))+ _, err = artRepo.GetItemArtwork(model.KindAlbumArtwork, "al6", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))})})++ Describe("media file", func() {+ It("serves a track's own found art", func() {+ seedFoundStore("mf", "mf1", coverBytes)++ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf1"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(coverBytes))+ })++ It("ignores a resolved mf row and delegates to the album when per-track art is disabled", func() {+ conf.Server.EnableMediaFileCoverArt = false+ seedFoundStore("mf", "mf7", []byte("stale embedded track art"))+ seedFoundStore("al", "albz", coverBytes)+ mfRepo.SetData(model.MediaFiles{{ID: "mf7", AlbumID: "albz"}})++ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf7"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(coverBytes), "album art, not the persisted embedded art")+ })++ It("delegates to the album when the track's state is absent", func() {+ seedFoundStore("al", "albm", coverBytes)+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "mf", ItemID: "mf2"})).To(Succeed())+ mfRepo.SetData(model.MediaFiles{{ID: "mf2", AlbumID: "albm"}})++ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf2"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(coverBytes))+ _, mfEnq := queueRepo.Data[primaryKey("mf", "mf2")]+ Expect(mfEnq).To(BeFalse())+ })++ It("delegates to the album (no enqueue) when the track is not embedded-eligible", func() {+ conf.Server.EnableMediaFileCoverArt = true+ seedFoundStore("al", "albn", coverBytes)+ mfRepo.SetData(model.MediaFiles{{ID: "mf3", AlbumID: "albn", HasCoverArt: false}})++ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf3"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(coverBytes))+ _, mfEnq := queueRepo.Data[primaryKey("mf", "mf3")]+ Expect(mfEnq).To(BeFalse())+ })++ It("extracts embedded art provisionally and enqueues the track when eligible", func() {+ conf.Server.EnableMediaFileCoverArt = true+ mfRepo.SetData(model.MediaFiles{{+ ID: "mf4", AlbumID: "albo", HasCoverArt: true,+ Path: "tests/fixtures/artist/an-album/test.mp3", LibraryID: 0,+ }})++ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf4"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(len(readAll(img))).To(BeNumerically(">", 0))+ Expect(queueRepo.Data[primaryKey("mf", "mf4")].Priority).To(Equal(model.ArtworkPriorityBump))+ _, err = artRepo.GetItemArtwork(model.KindMediaFileArtwork, "mf4", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ })++ It("delegates a multi-disc track to its disc art, not straight to the album", func() {+ folderRepo.result = []model.Folder{{Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"}}}+ albumRepo.SetData(model.Albums{{ID: "aldd", Name: "Album", FolderIDs: []string{"f1"}, Discs: model.Discs{1: "One", 2: "Two"}}})+ seedFoundStore("al", "aldd", []byte("album-art-distinct")) // album's own found art differs+ mfRepo.SetData(model.MediaFiles{{ID: "mf5", AlbumID: "aldd", DiscNumber: 1, HasCoverArt: false}})++ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf5"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ // The disc-folder image, not the album's own art: proof it routed through serveDisc.+ Expect(readAll(img)).To(Equal(coverBytes))+ })++ It("falls back to the album when an eligible track's embedded art will not extract", func() {+ conf.Server.EnableMediaFileCoverArt = true+ // HasCoverArt is set, but the file is not audio, so nothing extracts.+ mfRepo.SetData(model.MediaFiles{{+ ID: "mfbad", AlbumID: "albad", LibraryID: 0, HasCoverArt: true,+ Path: "tests/fixtures/artist/an-album/front.png",+ }})+ albumRepo.SetData(model.Albums{{ID: "albad", Name: "Album"}})+ seedFoundStore("al", "albad", coverBytes)++ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mfbad"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(coverBytes), "a placeholder here would be worse than the album cover")+ })++ It("routes a single-disc track through disc resolution too", func() {+ // DiscArtPriority applies to single-disc albums too, over the album's own found art.+ folderRepo.result = []model.Folder{{Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"}}}+ albumRepo.SetData(model.Albums{{ID: "alsd", Name: "Album", FolderIDs: []string{"f1"}, Discs: model.Discs{1: ""}}})+ seedFoundStore("al", "alsd", []byte("album-art-distinct"))+ mfRepo.SetData(model.MediaFiles{{ID: "mf6", AlbumID: "alsd", DiscNumber: 1, HasCoverArt: false}})++ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf6"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(coverBytes))+ })+ })++ Describe("disc", func() {+ It("serves a local disc-folder image", func() {+ folderRepo.result = []model.Folder{{Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"}}}+ albumRepo.SetData(model.Albums{{ID: "aldc", Name: "Album", FolderIDs: []string{"f1"}}})++ img, err := svc.Get(ctx, model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("aldc", 1), nil), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(coverBytes))+ })++ // The resize cache keys on id + album mtime, not on the bytes, so dropping the source+ // between the two requests is what shows a warm hit never touches the filesystem.+ It("serves a sized disc image from cache without re-reading the source", func() {+ folderRepo.result = []model.Folder{{Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"}}}+ albumRepo.SetData(model.Albums{{ID: "aldc3", Name: "Album", FolderIDs: []string{"f1"}}})+ discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("aldc3", 1), nil)++ first, err := svc.Get(ctx, discID, 64, false)+ Expect(err).ToNot(HaveOccurred())+ warmed := readAll(first)+ Expect(warmed).ToNot(BeEmpty())++ folderRepo.result = nil++ second, err := svc.Get(ctx, discID, 64, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(second)).To(Equal(warmed), "a warm sized request must not touch the source")+ })++ // A disc image can change without the album row changing, so the key folds in ImagesUpdatedAt.+ It("invalidates the cached image when the folder's images change", func() {+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"},+ ImagesUpdatedAt: time.Now().Add(-time.Hour),+ }}+ albumRepo.SetData(model.Albums{{ID: "aldc4", Name: "Album", FolderIDs: []string{"f1"}}})+ discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("aldc4", 1), nil)++ first, err := svc.Get(ctx, discID, 64, false)+ Expect(err).ToNot(HaveOccurred())+ firstKey := first.ETag+ readAll(first)++ folderRepo.result[0].ImagesUpdatedAt = time.Now()+ second, err := svc.Get(ctx, discID, 64, false)+ Expect(err).ToNot(HaveOccurred())+ readAll(second)+ Expect(second.ETag).ToNot(Equal(firstKey), "a replaced image must not keep the old cache entry")+ })++ // Disc art has no content hash, so without an explicit validator every ETag would be empty.+ It("gives a full-size disc image a validator that tracks the source", func() {+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"},+ ImagesUpdatedAt: time.Now().Add(-time.Hour),+ }}+ albumRepo.SetData(model.Albums{{ID: "aldc5", Name: "Album", FolderIDs: []string{"f1"}}})+ discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("aldc5", 1), nil)++ first, err := svc.Get(ctx, discID, 0, false)+ Expect(err).ToNot(HaveOccurred())+ readAll(first)+ Expect(first.ETag).ToNot(BeEmpty())++ folderRepo.result[0].ImagesUpdatedAt = time.Now()+ second, err := svc.Get(ctx, discID, 0, false)+ Expect(err).ToNot(HaveOccurred())+ readAll(second)+ Expect(second.ETag).ToNot(Equal(first.ETag), "a replaced image must not revalidate as unchanged")+ })++ It("falls back to album art when no disc image matches", func() {+ folderRepo.result = nil+ albumRepo.SetData(model.Albums{{ID: "aldc2", Name: "Album"}})+ seedFoundStore("al", "aldc2", coverBytes)++ img, err := svc.Get(ctx, model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("aldc2", 1), nil), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(coverBytes))+ })+ })++ Describe("GetOrPlaceholder", func() {+ It("accepts a raw entity id and serves its cover art", func() {+ albumRepo.SetData(model.Albums{{ID: "rawal", Name: "Album"}})+ seedFoundStore("al", "rawal", coverBytes)++ img, err := svc.GetOrPlaceholder(ctx, "rawal", 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(img.Placeholder).To(BeFalse())+ Expect(readAll(img)).To(Equal(coverBytes))+ })++ It("falls back to the album placeholder ignoring size and square", func() {+ img, err := svc.GetOrPlaceholder(ctx, "", 300, true)+ Expect(err).ToNot(HaveOccurred())+ Expect(img.Placeholder).To(BeTrue())+ Expect(img.Hash).To(BeEmpty())+ Expect(img.LastUpdated).To(BeZero())++ ph, err := resources.FS().Open(consts.PlaceholderAlbumArt)+ Expect(err).ToNot(HaveOccurred())+ phBytes, _ := io.ReadAll(ph)+ Expect(readAll(img)).To(Equal(phBytes))+ })++ It("falls back to the artist placeholder for an absent artist", func() {+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "arph"})).To(Succeed())++ img, err := svc.GetOrPlaceholder(ctx, "ar-arph", 300, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(img.Placeholder).To(BeTrue())++ ph, err := resources.FS().Open(consts.PlaceholderArtistArt)+ Expect(err).ToNot(HaveOccurred())+ phBytes, _ := io.ReadAll(ph)+ Expect(readAll(img)).To(Equal(phBytes))+ })++ // "No art" and "no such entity" are different answers: clients 404 only on the latter.+ It("reports not-found rather than a placeholder for an id with no entity", func() {+ _, err := svc.GetOrPlaceholder(ctx, "al-nosuchalbum", 0, false)+ Expect(err).To(MatchError(model.ErrNotFound))++ _, err = svc.GetOrPlaceholder(ctx, "nosuchrawid", 0, false)+ Expect(err).To(MatchError(model.ErrNotFound))+ })+ })+})++func fileMtime(path string) int64 {+ GinkgoHelper()+ info, err := os.Stat(path)+ Expect(err).ToNot(HaveOccurred())+ return info.ModTime().UnixNano()+}++var _ = Describe("EntityExists", func() {+ var ctx context.Context+ var ds *tests.MockDataStore++ BeforeEach(func() {+ ctx = context.Background()+ albumRepo := tests.CreateMockAlbumRepo()+ albumRepo.SetData(model.Albums{{ID: "al1"}})+ artistRepo := tests.CreateMockArtistRepo()+ artistRepo.SetData(model.Artists{{ID: "ar1"}})+ radioRepo := tests.CreateMockedRadioRepo()+ Expect(radioRepo.Put(&model.Radio{ID: "ra1", Name: "R"})).To(Succeed())+ ds = &tests.MockDataStore{MockedAlbum: albumRepo, MockedArtist: artistRepo, MockedRadio: radioRepo}+ })++ DescribeTable("reports whether the owning entity is still there",+ func(id string, expected bool) {+ Expect(entityExists(ctx, ds, model.MustParseArtworkID(id))).To(Equal(expected))+ },+ Entry("existing album", "al-al1", true),+ Entry("deleted album", "al-gone", false),+ Entry("existing artist", "ar-ar1", true),+ Entry("deleted artist", "ar-gone", false),+ Entry("existing radio", "ra-ra1", true),+ Entry("deleted radio", "ra-gone", false),+ // Disc art has no entity of its own; it stands or falls with its album.+ Entry("disc of an existing album", "dc-al1:1", true),+ Entry("disc of a deleted album", "dc-gone:1", false),+ Entry("malformed disc id", "dc-nodiscnum", false),+ )})diff --git a/core/artwork/benchmark_e2e_test.go b/core/artwork/benchmark_e2e_test.godeleted file mode 100644index bf3d435a8..000000000--- a/core/artwork/benchmark_e2e_test.go+++ /dev/null@@ -1,189 +0,0 @@-package artwork--import (- "context"- "fmt"- "image/jpeg"- "io"- "os"- "path/filepath"- "runtime"- "sync"- "testing"- "time"-- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/conf/configtest"- "github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/tests"- "github.com/navidrome/navidrome/utils/cache"-)--// setupE2EBenchmark creates an artwork instance with a real album cover image on disk,-// backed by either a real file cache or disabled cache depending on cacheSize.-// Note: This benchmarks artwork.Get() directly (not the full HTTP handler), which covers-// the critical path (source selection, decode, resize, encode, cache). This is a deliberate-// spec deviation — the full HTTP round-trip benchmark requires significant infrastructure-// (DB, scanner, fake filesystem) and can be added later if HTTP overhead proves significant.-//-// Depends on fakeFolderRepo defined in reader_artist_test.go (same package, compiled together).-func setupE2EBenchmark(b *testing.B, cacheSize string) (Artwork, model.ArtworkID, func()) {- b.Helper()- cleanup := configtest.SetupConfig()- b.Cleanup(cleanup)-- tmpDir, err := os.MkdirTemp("", "artwork-bench-*")- if err != nil {- b.Fatal(err)- }-- // Create a realistic cover image on disk- coverPath := filepath.Join(tmpDir, "cover.jpg")- coverImg := generateGradientImage(1000, 1000)- f, err := os.Create(coverPath)- if err != nil {- b.Fatal(err)- }- if err := jpeg.Encode(f, coverImg, &jpeg.Options{Quality: 90}); err != nil {- f.Close()- b.Fatal(err)- }- f.Close()-- // Configure cache- conf.Server.ImageCacheSize = cacheSize- conf.Server.CacheFolder = conf.NewDir(tmpDir)- conf.Server.CoverArtQuality = 75- conf.Server.CoverArtPriority = "cover.*"-- // Set up mock data store with album pointing to our cover.- // Set UpdatedAt so CoverArtID().LastUpdate is consistent across calls.- album := model.Album{- ID: "bench-album-1",- Name: "Benchmark Album",- FolderIDs: []string{"f1"},- UpdatedAt: time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),- }- folderRepo := &fakeFolderRepo{- result: []model.Folder{{- Path: tmpDir,- ImageFiles: []string{"cover.jpg"},- }},- }- ds := &tests.MockDataStore{- MockedTranscoding: &tests.MockTranscodingRepo{},- MockedFolder: folderRepo,- }- ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{album})-- artID := album.CoverArtID()-- imgCache := cache.NewFileCache("BenchImage", cacheSize, "bench-images", 0,- func(ctx context.Context, arg cache.Item) (io.Reader, error) {- r, _, err := arg.(artworkReader).Reader(ctx)- return r, err- })-- // Wait for cache init if enabled- if cacheSize != "0" {- for !imgCache.Available(context.Background()) && !imgCache.Disabled(context.Background()) {- runtime.Gosched() // Yield to allow background init goroutine to run- }- }-- ffmpeg := tests.NewMockFFmpeg("fallback content")- aw := NewArtwork(ds, imgCache, ffmpeg, nil)-- cleanupAll := func() {- os.RemoveAll(tmpDir)- }- return aw, artID, cleanupAll-}--func BenchmarkArtworkGetE2E(b *testing.B) {- cacheConfigs := []struct {- name string- cacheSize string- }{- {"no_cache", "0"},- {"with_cache", "100MB"},- }- sizes := []int{0, 300}-- for _, cc := range cacheConfigs {- for _, size := range sizes {- b.Run(fmt.Sprintf("%s/size_%d", cc.name, size), func(b *testing.B) {- aw, artID, cleanup := setupE2EBenchmark(b, cc.cacheSize)- defer cleanup()-- // Warm the cache on first call if cache is enabled- if cc.cacheSize != "0" {- r, _, err := aw.Get(context.Background(), artID, size, size > 0)- if err != nil {- b.Fatal(err)- }- _, _ = io.ReadAll(r)- r.Close()- }-- b.ResetTimer()- for i := 0; i < b.N; i++ {- r, _, err := aw.Get(context.Background(), artID, size, size > 0)- if err != nil {- b.Fatal(err)- }- _, _ = io.ReadAll(r)- r.Close()- }- })- }- }-}--func BenchmarkArtworkGetE2EConcurrent(b *testing.B) {- cacheConfigs := []struct {- name string- cacheSize string- }{- {"no_cache", "0"},- {"with_cache", "100MB"},- }- concurrencyLevels := []int{10, 50}-- for _, cc := range cacheConfigs {- for _, n := range concurrencyLevels {- b.Run(fmt.Sprintf("%s/goroutines_%d", cc.name, n), func(b *testing.B) {- aw, artID, cleanup := setupE2EBenchmark(b, cc.cacheSize)- defer cleanup()-- // Warm cache- if cc.cacheSize != "0" {- r, _, _ := aw.Get(context.Background(), artID, 300, true)- if r != nil {- _, _ = io.ReadAll(r)- r.Close()- }- }-- b.ResetTimer()- for i := 0; i < b.N; i++ {- var wg sync.WaitGroup- wg.Add(n)- for range n {- go func() {- defer wg.Done()- r, _, err := aw.Get(context.Background(), artID, 300, true)- if err != nil {- b.Error(err)- return- }- _, _ = io.ReadAll(r)- r.Close()- }()- }- wg.Wait()- }- })- }- }-}diff --git a/core/artwork/benchmark_helpers_test.go b/core/artwork/benchmark_helpers_test.goindex 0076506f3..f3201d412 100644--- a/core/artwork/benchmark_helpers_test.go+++ b/core/artwork/benchmark_helpers_test.go@@ -4,6 +4,7 @@ import ("bytes""image""image/color"+ "image/draw""image/jpeg""image/png""testing"@@ -45,3 +46,11 @@ func generateGradientImage(width, height int) *image.RGBA {}return img}++// gradientNRGBA mirrors generateGradientImage in the type makeThumbnail hands the encoders.+func gradientNRGBA(size int) *image.NRGBA {+ src := generateGradientImage(size, size)+ dst := image.NewNRGBA(src.Bounds())+ draw.Draw(dst, dst.Bounds(), src, src.Bounds().Min, draw.Src)+ return dst+}diff --git a/core/artwork/blurhash/blurhash.go b/core/artwork/blurhash/blurhash.gonew file mode 100644index 000000000..ca5bf7026--- /dev/null+++ b/core/artwork/blurhash/blurhash.go@@ -0,0 +1,191 @@+// Package blurhash implements the blurhash encoding (https://github.com/woltapp/blurhash),+// parameterized to match Jellyfin so clients see equivalent hashes.+package blurhash++import (+ "errors"+ "image"+ "image/draw"+ "math"+ "strings"+ "sync"++ xdraw "golang.org/x/image/draw"+)++const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~"++// maxInputSize: larger inputs are slower with no visible difference in the result.+const maxInputSize = 128++// components picks x/y component counts targeting ~16 near-square tiles.+func components(width, height int) (int, int) {+ xf := math.Sqrt(16.0 * float64(width) / float64(height))+ yf := xf * float64(height) / float64(width)+ return min(int(xf)+1, 9), min(int(yf)+1, 9)+}++// Encode returns the blurhash of img, deriving the component counts from its aspect ratio.+func Encode(img image.Image) (string, error) {+ if img.Bounds().Dx() == 0 || img.Bounds().Dy() == 0 {+ return "", errors.New("blurhash: empty image")+ }+ // Pre-downscale: its rounding can flip a component count, and the hash is a client cache key.+ xComp, yComp := components(img.Bounds().Dx(), img.Bounds().Dy())+ src := pixelsOf(downscale(img))+ w, h := src.w, src.h++ cosX := make([][]float64, xComp)+ for i := range cosX {+ cosX[i] = make([]float64, w)+ for x := range cosX[i] {+ cosX[i][x] = math.Cos(math.Pi * float64(i) * float64(x) / float64(w))+ }+ }+ cosY := make([][]float64, yComp)+ for j := range cosY {+ cosY[j] = make([]float64, h)+ for y := range cosY[j] {+ cosY[j][y] = math.Cos(math.Pi * float64(j) * float64(y) / float64(h))+ }+ }++ lin := srgbToLinearTable()+ factors := make([][3]float64, xComp*yComp)+ for y := range h {+ row := src.pix[y*src.stride:]+ for x := range w {+ p := x * 4+ r, g, b := row[p], row[p+1], row[p+2]+ if src.straight {+ r, g, b = premultiply(r, g, b, row[p+3])+ }+ lr, lg, lb := lin[r], lin[g], lin[b]+ for j := range yComp {+ for i := range xComp {+ basis := cosX[i][x] * cosY[j][y]+ f := &factors[j*xComp+i]+ f[0] += basis * lr+ f[1] += basis * lg+ f[2] += basis * lb+ }+ }+ }+ }+ for idx := range factors {+ norm := 2.0+ if idx == 0 {+ norm = 1.0+ }+ scale := norm / float64(w*h)+ factors[idx][0] *= scale+ factors[idx][1] *= scale+ factors[idx][2] *= scale+ }++ var sb strings.Builder+ sb.WriteString(encode83((xComp-1)+(yComp-1)*9, 1))++ // Derived counts are at least 1x9, so there is always at least one AC factor.+ ac := factors[1:]+ actualMax := 0.0+ for _, f := range ac {+ actualMax = max(actualMax, math.Abs(f[0]), math.Abs(f[1]), math.Abs(f[2]))+ }+ quantMax := int(max(0, min(82, math.Floor(actualMax*166-0.5))))+ maxVal := float64(quantMax+1) / 166+ sb.WriteString(encode83(quantMax, 1))++ dc := factors[0]+ sb.WriteString(encode83(linearToSRGB(dc[0])<<16|linearToSRGB(dc[1])<<8|linearToSRGB(dc[2]), 4))+ for _, f := range ac {+ sb.WriteString(encode83(quantAC(f[0], maxVal)*19*19+quantAC(f[1], maxVal)*19+quantAC(f[2], maxVal), 2))+ }+ return sb.String(), nil+}++// pixels is direct Pix access for the pixel loop, avoiding a per-pixel allocation via image.At.+type pixels struct {+ pix []uint8+ stride int+ w, h int+ // straight marks non-premultiplied alpha, which the loop premultiplies to keep the hash+ // identical to the one an equivalent *image.RGBA produces.+ straight bool+}++// pixelsOf accepts the two types the artwork pipeline produces without copying, and converts+// anything else.+func pixelsOf(img image.Image) pixels {+ b := img.Bounds()+ switch src := img.(type) {+ case *image.RGBA:+ return pixels{pix: src.Pix, stride: src.Stride, w: b.Dx(), h: b.Dy()}+ case *image.NRGBA:+ return pixels{pix: src.Pix, stride: src.Stride, w: b.Dx(), h: b.Dy(), straight: true}+ }+ dst := image.NewRGBA(image.Rect(0, 0, b.Dx(), b.Dy()))+ draw.Draw(dst, dst.Bounds(), img, b.Min, draw.Src)+ return pixels{pix: dst.Pix, stride: dst.Stride, w: b.Dx(), h: b.Dy()}+}++func premultiply(r, g, b, a uint8) (uint8, uint8, uint8) {+ if a == 255 {+ return r, g, b+ }+ return uint8(uint32(r) * uint32(a) / 255), uint8(uint32(g) * uint32(a) / 255), uint8(uint32(b) * uint32(a) / 255)+}++var srgbToLinearTable = sync.OnceValue(func() *[256]float64 {+ var t [256]float64+ for i := range t {+ t[i] = srgbToLinear(i)+ }+ return &t+})++func downscale(img image.Image) image.Image {+ b := img.Bounds()+ w, h := b.Dx(), b.Dy()+ if w <= maxInputSize && h <= maxInputSize {+ return img+ }+ scale := float64(maxInputSize) / float64(max(w, h))+ dst := image.NewRGBA(image.Rect(0, 0, max(1, int(float64(w)*scale)), max(1, int(float64(h)*scale))))+ xdraw.ApproxBiLinear.Scale(dst, dst.Bounds(), img, b, draw.Src, nil)+ return dst+}++func quantAC(v, maxVal float64) int {+ return int(max(0, min(18, math.Floor(signPow(v/maxVal, 0.5)*9+9.5))))+}++func signPow(v, exp float64) float64 {+ return math.Copysign(math.Pow(math.Abs(v), exp), v)+}++func srgbToLinear(v int) float64 {+ f := float64(v) / 255+ if f <= 0.04045 {+ return f / 12.92+ }+ return math.Pow((f+0.055)/1.055, 2.4)+}++func linearToSRGB(v float64) int {+ v = min(max(0, v), 1)+ if v <= 0.0031308 {+ return int(v*12.92*255 + 0.5)+ }+ return int((1.055*math.Pow(v, 1/2.4)-0.055)*255 + 0.5)+}++// encode83 encodes value as a fixed-width, big-endian base83 string of the given length.+func encode83(value, length int) string {+ b := make([]byte, length)+ for i := length - 1; i >= 0; i-- {+ b[i] = alphabet[value%83]+ value /= 83+ }+ return string(b)+}diff --git a/core/artwork/blurhash/blurhash_suite_test.go b/core/artwork/blurhash/blurhash_suite_test.gonew file mode 100644index 000000000..b0e96d7a7--- /dev/null+++ b/core/artwork/blurhash/blurhash_suite_test.go@@ -0,0 +1,17 @@+package blurhash_test++import (+ "testing"++ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++func TestBlurHash(t *testing.T) {+ tests.Init(t, false)+ log.SetLevel(log.LevelFatal)+ RegisterFailHandler(Fail)+ RunSpecs(t, "BlurHash Suite")+}diff --git a/core/artwork/blurhash/blurhash_test.go b/core/artwork/blurhash/blurhash_test.gonew file mode 100644index 000000000..91187165e--- /dev/null+++ b/core/artwork/blurhash/blurhash_test.go@@ -0,0 +1,137 @@+package blurhash_test++import (+ "image"+ "image/color"+ "strings"++ "github.com/navidrome/navidrome/core/artwork/blurhash"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~"++func decode83(s string) int {+ v := 0+ for _, c := range s {+ v = v*83 + strings.IndexRune(alphabet, c)+ }+ return v+}++func solidImage(w, h int, c color.NRGBA) image.Image {+ img := image.NewNRGBA(image.Rect(0, 0, w, h))+ for y := range h {+ for x := range w {+ img.SetNRGBA(x, y, c)+ }+ }+ return img+}++func gradientImage(w, h int) image.Image {+ img := image.NewNRGBA(image.Rect(0, 0, w, h))+ for y := range h {+ for x := range w {+ img.SetNRGBA(x, y, color.NRGBA{R: uint8(255 * x / w), G: uint8(255 * y / h), B: 128, A: 255})+ }+ }+ return img+}++var _ = Describe("Encode input types", func() {+ // The pipeline hands Encode an *image.NRGBA; reading it must stay equivalent to the+ // premultiplied *image.RGBA it used to receive, or every hash silently shifts.+ buildPair := func(alpha uint8) (*image.NRGBA, *image.RGBA) {+ const size = 40+ nrgba := image.NewNRGBA(image.Rect(0, 0, size, size))+ rgba := image.NewRGBA(image.Rect(0, 0, size, size))+ for y := range size {+ for x := range size {+ c := color.NRGBA{+ R: uint8(255 * x / size), G: uint8(255 * y / size),+ B: uint8((x + y) * 255 / (2 * size)), A: alpha,+ }+ nrgba.SetNRGBA(x, y, c)+ rgba.Set(x, y, c) // image.RGBA.Set premultiplies+ }+ }+ return nrgba, rgba+ }++ DescribeTable("gives an NRGBA the same hash as the premultiplied RGBA it replaces",+ func(alpha uint8) {+ nrgba, rgba := buildPair(alpha)+ fromNRGBA, err := blurhash.Encode(nrgba)+ Expect(err).ToNot(HaveOccurred())+ fromRGBA, err := blurhash.Encode(rgba)+ Expect(err).ToNot(HaveOccurred())+ Expect(fromNRGBA).To(Equal(fromRGBA))+ },+ Entry("opaque", uint8(255)),+ Entry("partly transparent", uint8(128)),+ Entry("fully transparent, which premultiplication crushes to black", uint8(0)),+ )+})++var _ = Describe("Encode", func() {+ // The size flag encodes (xComp-1) + (yComp-1)*9.+ DescribeTable("derives component counts from aspect ratio (Jellyfin formula)",+ func(w, h, expectedX, expectedY int) {+ hash, err := blurhash.Encode(gradientImage(w, h))+ Expect(err).ToNot(HaveOccurred())+ Expect(decode83(hash[:1])).To(Equal((expectedX - 1) + (expectedY-1)*9))+ },+ Entry("square album art", 60, 60, 5, 5),+ Entry("smallest square", 1, 1, 5, 5),+ Entry("landscape 16:9", 192, 108, 6, 4),+ Entry("portrait 9:16", 108, 192, 4, 6),+ Entry("extreme landscape capped at 9", 1000, 10, 9, 1),+ Entry("extreme portrait capped at 9", 10, 1000, 1, 9),+ )++ It("rejects an empty image", func() {+ _, err := blurhash.Encode(image.NewNRGBA(image.Rect(0, 0, 0, 0)))+ Expect(err).To(HaveOccurred())+ })++ It("produces the spec-mandated length", func() {+ // 1 (size flag) + 1 (max AC) + 4 (DC) + 2 per AC component; a square derives 5x5+ h, err := blurhash.Encode(solidImage(8, 8, color.NRGBA{R: 10, G: 20, B: 30, A: 255}))+ Expect(err).ToNot(HaveOccurred())+ Expect(h).To(HaveLen(4 + 2 + 2*(5*5-1)))+ })++ It("stores the average color in the DC component", func() {+ h, err := blurhash.Encode(solidImage(16, 16, color.NRGBA{R: 200, G: 100, B: 50, A: 255}))+ Expect(err).ToNot(HaveOccurred())+ dc := decode83(h[2:6])+ Expect(dc >> 16).To(BeNumerically("~", 200, 1))+ Expect((dc >> 8) & 0xFF).To(BeNumerically("~", 100, 1))+ Expect(dc & 0xFF).To(BeNumerically("~", 50, 1))+ })++ It("is deterministic", func() {+ img := gradientImage(64, 64)+ h1, err1 := blurhash.Encode(img)+ h2, err2 := blurhash.Encode(img)+ Expect(err1).ToNot(HaveOccurred())+ Expect(err2).ToNot(HaveOccurred())+ Expect(h1).To(Equal(h2))+ })++ It("produces different hashes for different images", func() {+ h1, _ := blurhash.Encode(solidImage(16, 16, color.NRGBA{R: 255, A: 255}))+ h2, _ := blurhash.Encode(gradientImage(16, 16))+ Expect(h1).ToNot(Equal(h2))+ })++ It("downscales large images internally without changing the result materially", func() {+ big, err := blurhash.Encode(solidImage(1000, 1000, color.NRGBA{R: 60, G: 120, B: 180, A: 255}))+ Expect(err).ToNot(HaveOccurred())+ small, err := blurhash.Encode(solidImage(16, 16, color.NRGBA{R: 60, G: 120, B: 180, A: 255}))+ Expect(err).ToNot(HaveOccurred())+ Expect(big[2:6]).To(Equal(small[2:6]))+ })+})diff --git a/core/artwork/cache_warmer.go b/core/artwork/cache_warmer.godeleted file mode 100644index 5090d638e..000000000--- a/core/artwork/cache_warmer.go+++ /dev/null@@ -1,162 +0,0 @@-package artwork--import (- "context"- "fmt"- "io"- "maps"- "slices"- "sync"- "time"-- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/log"- "github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/model/request"- "github.com/navidrome/navidrome/utils/cache"- "github.com/navidrome/navidrome/utils/pl"-)--type CacheWarmer interface {- PreCache(artID model.ArtworkID)-}--// NewCacheWarmer creates a new CacheWarmer instance. The CacheWarmer will pre-cache Artwork images in the background-// to speed up the response time when the image is requested by the UI. The cache is pre-populated with the original-// image size, as well as the size defined by the UICoverArtSize config option.-func NewCacheWarmer(artwork Artwork, cache cache.FileCache) CacheWarmer {- // If image cache is disabled, return a NOOP implementation- if conf.Server.ImageCacheSize == "0" || !conf.Server.EnableArtworkPrecache {- return &noopCacheWarmer{}- }-- // If the file cache is disabled, return a NOOP implementation- if cache.Disabled(context.Background()) {- log.Debug("Image cache disabled. Cache warmer will not run")- return &noopCacheWarmer{}- }-- a := &cacheWarmer{- artwork: artwork,- cache: cache,- buffer: make(map[model.ArtworkID]struct{}),- wakeSignal: make(chan struct{}, 1),- coverArtSize: conf.Server.UICoverArtSize,- }-- // Create a context with a fake admin user, to be able to pre-cache Playlist CoverArts- ctx := request.WithUser(context.TODO(), model.User{IsAdmin: true})- go a.run(ctx)- return a-}--type cacheWarmer struct {- artwork Artwork- buffer map[model.ArtworkID]struct{}- mutex sync.Mutex- cache cache.FileCache- wakeSignal chan struct{}- coverArtSize int-}--func (a *cacheWarmer) PreCache(artID model.ArtworkID) {- if a.cache.Disabled(context.Background()) {- return- }- a.mutex.Lock()- defer a.mutex.Unlock()- a.buffer[artID] = struct{}{}- a.sendWakeSignal()-}--func (a *cacheWarmer) sendWakeSignal() {- // Don't block if the previous signal was not read yet- select {- case a.wakeSignal <- struct{}{}:- default:- }-}--func (a *cacheWarmer) run(ctx context.Context) {- for {- a.waitSignal(ctx, 10*time.Second)- if ctx.Err() != nil {- break- }-- if a.cache.Disabled(ctx) {- a.mutex.Lock()- pending := len(a.buffer)- a.buffer = make(map[model.ArtworkID]struct{})- a.mutex.Unlock()- if pending > 0 {- log.Trace(ctx, "Cache disabled, discarding precache buffer", "bufferLen", pending)- }- return- }-- // If cache not available, keep waiting- if !a.cache.Available(ctx) {- a.mutex.Lock()- bufferLen := len(a.buffer)- a.mutex.Unlock()- if bufferLen > 0 {- log.Trace(ctx, "Cache not available, buffering precache request", "bufferLen", bufferLen)- }- continue- }-- a.mutex.Lock()-- // If there's nothing to send, keep waiting- if len(a.buffer) == 0 {- a.mutex.Unlock()- continue- }-- batch := slices.Collect(maps.Keys(a.buffer))- a.buffer = make(map[model.ArtworkID]struct{})- a.mutex.Unlock()-- a.processBatch(ctx, batch)- }-}--func (a *cacheWarmer) waitSignal(ctx context.Context, timeout time.Duration) {- select {- case <-time.After(timeout):- case <-a.wakeSignal:- case <-ctx.Done():- }-}--func (a *cacheWarmer) processBatch(ctx context.Context, batch []model.ArtworkID) {- log.Trace(ctx, "PreCaching a new batch of artwork", "batchSize", len(batch))- input := pl.FromSlice(ctx, batch)- errs := pl.Sink(ctx, 4, input, a.doCacheImage)- for err := range errs {- log.Debug(ctx, "Error warming cache", err)- }-}--func (a *cacheWarmer) doCacheImage(ctx context.Context, id model.ArtworkID) error {- ctx, cancel := context.WithTimeout(ctx, 10*time.Second)- defer cancel()-- size := a.coverArtSize- r, _, err := a.artwork.Get(ctx, id, size, true)- if err != nil {- return fmt.Errorf("caching id='%s', size=%d: %w", id, size, err)- }- _, err = io.Copy(io.Discard, r)- r.Close()- return err-}--func NoopCacheWarmer() CacheWarmer {- return &noopCacheWarmer{}-}--type noopCacheWarmer struct{}--func (a *noopCacheWarmer) PreCache(model.ArtworkID) {}diff --git a/core/artwork/cache_warmer_test.go b/core/artwork/cache_warmer_test.godeleted file mode 100644index a5da2004c..000000000--- a/core/artwork/cache_warmer_test.go+++ /dev/null@@ -1,245 +0,0 @@-package artwork--import (- "context"- "errors"- "fmt"- "io"- "strings"- "sync"- "sync/atomic"- "time"-- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/conf/configtest"- "github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/utils/cache"- . "github.com/onsi/ginkgo/v2"- . "github.com/onsi/gomega"-)--var _ = Describe("CacheWarmer", func() {- var (- fc *mockFileCache- aw *mockArtwork- )-- BeforeEach(func() {- DeferCleanup(configtest.SetupConfig())- fc = &mockFileCache{}- aw = &mockArtwork{}- })-- Context("initialization", func() {- It("returns noop when cache is disabled", func() {- fc.SetDisabled(true)- cw := NewCacheWarmer(aw, fc)- _, ok := cw.(*noopCacheWarmer)- Expect(ok).To(BeTrue())- })-- It("returns noop when ImageCacheSize is 0", func() {- conf.Server.ImageCacheSize = "0"- cw := NewCacheWarmer(aw, fc)- _, ok := cw.(*noopCacheWarmer)- Expect(ok).To(BeTrue())- })-- It("returns noop when EnableArtworkPrecache is false", func() {- conf.Server.EnableArtworkPrecache = false- cw := NewCacheWarmer(aw, fc)- _, ok := cw.(*noopCacheWarmer)- Expect(ok).To(BeTrue())- })-- It("returns real implementation when properly configured", func() {- conf.Server.ImageCacheSize = "100MB"- conf.Server.EnableArtworkPrecache = true- fc.SetDisabled(false)- cw := NewCacheWarmer(aw, fc)- _, ok := cw.(*cacheWarmer)- Expect(ok).To(BeTrue())- })- })-- Context("buffer management", func() {- BeforeEach(func() {- conf.Server.ImageCacheSize = "100MB"- conf.Server.EnableArtworkPrecache = true- fc.SetDisabled(false)- })-- It("drops buffered items when cache becomes disabled", func() {- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)- cw.PreCache(model.MustParseArtworkID("al-test"))- fc.SetDisabled(true)- Eventually(func() int {- cw.mutex.Lock()- defer cw.mutex.Unlock()- return len(cw.buffer)- }).Should(Equal(0))- })-- It("adds multiple items to buffer", func() {- fc.SetReady(false) // Make cache unavailable so items stay in buffer- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)- cw.PreCache(model.MustParseArtworkID("al-1"))- cw.PreCache(model.MustParseArtworkID("al-2"))- cw.mutex.Lock()- defer cw.mutex.Unlock()- Expect(len(cw.buffer)).To(Equal(2))- })-- It("deduplicates items in buffer", func() {- fc.SetReady(false) // Make cache unavailable so items stay in buffer- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)- cw.PreCache(model.MustParseArtworkID("al-1"))- cw.PreCache(model.MustParseArtworkID("al-1"))- cw.mutex.Lock()- defer cw.mutex.Unlock()- Expect(len(cw.buffer)).To(Equal(1))- })- })-- Context("error handling", func() {- BeforeEach(func() {- conf.Server.ImageCacheSize = "100MB"- conf.Server.EnableArtworkPrecache = true- fc.SetDisabled(false)- })-- It("continues processing after artwork retrieval error", func() {- aw.err = errors.New("artwork error")- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)- cw.PreCache(model.MustParseArtworkID("al-error"))- cw.PreCache(model.MustParseArtworkID("al-1"))-- Eventually(func() int {- cw.mutex.Lock()- defer cw.mutex.Unlock()- return len(cw.buffer)- }).Should(Equal(0))- })-- It("continues processing after cache error", func() {- fc.err = errors.New("cache error")- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)- cw.PreCache(model.MustParseArtworkID("al-error"))- cw.PreCache(model.MustParseArtworkID("al-1"))-- Eventually(func() int {- cw.mutex.Lock()- defer cw.mutex.Unlock()- return len(cw.buffer)- }).Should(Equal(0))- })- })-- Context("background processing", func() {- BeforeEach(func() {- conf.Server.ImageCacheSize = "100MB"- conf.Server.EnableArtworkPrecache = true- fc.SetDisabled(false)- })-- It("processes items in batches", func() {- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)- for i := range 5 {- cw.PreCache(model.MustParseArtworkID(fmt.Sprintf("al-%d", i)))- }-- Eventually(func() int {- cw.mutex.Lock()- defer cw.mutex.Unlock()- return len(cw.buffer)- }).Should(Equal(0))- })-- It("wakes up on new items", func() {- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)-- // Add first batch- cw.PreCache(model.MustParseArtworkID("al-1"))- Eventually(func() int {- cw.mutex.Lock()- defer cw.mutex.Unlock()- return len(cw.buffer)- }).Should(Equal(0))-- // Add second batch- cw.PreCache(model.MustParseArtworkID("al-2"))- Eventually(func() int {- cw.mutex.Lock()- defer cw.mutex.Unlock()- return len(cw.buffer)- }).Should(Equal(0))- })-- It("pre-caches UICoverArtSize", func() {- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)- cw.PreCache(model.MustParseArtworkID("al-1"))-- Eventually(func() []int {- return aw.getCachedSizes()- }).Should(ContainElements(conf.Server.UICoverArtSize))- })- })-})--type mockArtwork struct {- err error- mu sync.Mutex- cachedSizes []int-}--func (m *mockArtwork) Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (io.ReadCloser, time.Time, error) {- if m.err != nil {- return nil, time.Time{}, m.err- }- m.mu.Lock()- m.cachedSizes = append(m.cachedSizes, size)- m.mu.Unlock()- return io.NopCloser(strings.NewReader("test")), time.Now(), nil-}--func (m *mockArtwork) getCachedSizes() []int {- m.mu.Lock()- defer m.mu.Unlock()- result := make([]int, len(m.cachedSizes))- copy(result, m.cachedSizes)- return result-}--func (m *mockArtwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (io.ReadCloser, time.Time, error) {- return m.Get(ctx, model.ArtworkID{}, size, square)-}--type mockFileCache struct {- disabled atomic.Bool- ready atomic.Bool- err error-}--func (f *mockFileCache) Get(ctx context.Context, item cache.Item) (*cache.CachedStream, error) {- if f.err != nil {- return nil, f.err- }- return &cache.CachedStream{Reader: io.NopCloser(strings.NewReader("cached"))}, nil-}--func (f *mockFileCache) Available(ctx context.Context) bool {- return f.ready.Load() && !f.disabled.Load()-}--func (f *mockFileCache) Disabled(ctx context.Context) bool {- return f.disabled.Load()-}--func (f *mockFileCache) SetDisabled(v bool) {- f.disabled.Store(v)- f.ready.Store(true)-}--func (f *mockFileCache) SetReady(v bool) {- f.ready.Store(v)-}diff --git a/core/artwork/reader_disc.go b/core/artwork/disc.gosimilarity index 60%rename from core/artwork/reader_disc.gorename to core/artwork/disc.goindex 0f648c987..21f596b60 100644--- a/core/artwork/reader_disc.go+++ b/core/artwork/disc.go@@ -2,7 +2,6 @@ package artworkimport ("context"- "crypto/md5""fmt""io""path"@@ -12,16 +11,16 @@ import ("time""github.com/Masterminds/squirrel"- "github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/core/ffmpeg""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/utils"+ "github.com/navidrome/navidrome/utils/slice")+// discArtworkReader resolves disc-level artwork from a library's folder images+// and embedded tags. It is used by the serving path's provisional disc read-through.type discArtworkReader struct {- cacheKey- a *artworkalbum model.AlbumdiscNumber intimgFiles []string // library-relative, forward-slash, no leading slash@@ -29,27 +28,40 @@ type discArtworkReader struct {isMultiFolder boolfirstTrackRel string // library-relative; for fromTag / ffmpeg via lib.Abslib libraryView- updatedAt *time.Time+ // Newest ImagesUpdatedAt across the album's and this disc's folders: an image can be+ // replaced without the album row changing, so this is what makes a cache key notice it.+ imagesUpdatedAt time.Time}-func newDiscArtworkReader(ctx context.Context, a *artwork, artID model.ArtworkID) (*discArtworkReader, error) {+// cacheTime is the disc image's validity stamp: any of these moving means the selection may+// have changed.+func (d *discArtworkReader) cacheTime() time.Time {+ return utils.TimeNewest(d.album.UpdatedAt, d.album.ImportedAt, d.imagesUpdatedAt)+}++func newDiscArtworkReader(ctx context.Context, ds model.DataStore, artID model.ArtworkID) (*discArtworkReader, error) {albumID, discNumber, err := model.ParseDiscArtworkID(artID.ID)if err != nil {return nil, fmt.Errorf("invalid disc artwork id '%s': %w", artID.ID, err)}- al, err := a.ds.Album(ctx).Get(albumID)+ al, err := ds.Album(ctx).Get(albumID)if err != nil {return nil, err}- _, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, a.ds, *al)+ _, imgFiles, albumImagesAt, err := loadAlbumFoldersPaths(ctx, ds, *al)if err != nil {return nil, err}+ var imagesUpdatedAt time.Time+ if albumImagesAt != nil {+ imagesUpdatedAt = *albumImagesAt+ }+// Query mediafiles for this album + disc to find folder associations and first track- mfs, err := a.ds.MediaFile(ctx).GetAll(model.QueryOptions{+ mfs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{Sort: "track_number",Order: "ASC",Filters: squirrel.Eq{"album_id": albumID, "disc_number": discNumber},@@ -58,29 +70,25 @@ func newDiscArtworkReader(ctx context.Context, a *artwork, artID model.ArtworkIDreturn nil, err}- lib, err := loadLibraryView(ctx, a.ds, al.LibraryID)+ lib, err := loadLibraryView(ctx, ds, al.LibraryID)if err != nil {return nil, err}// Build disc folder set and find first track. mf.Path is already library-relative.var firstTrackRel string- allFolderIDs := make(map[string]bool)for _, mf := range mfs {- allFolderIDs[mf.FolderID] = true- if firstTrackRel == "" {+ if mf.Path != "" {firstTrackRel = filepath.ToSlash(mf.Path)+ break}}+ folderIDs := slice.Unique(slice.Map(mfs, func(mf model.MediaFile) string { return mf.FolderID }))// Resolve folder IDs to library-relative pathsdiscFoldersRel := make(map[string]bool)- if len(allFolderIDs) > 0 {- folderIDs := make([]string, 0, len(allFolderIDs))- for id := range allFolderIDs {- folderIDs = append(folderIDs, id)- }- folders, err := a.ds.Folder(ctx).GetAll(model.QueryOptions{+ if len(folderIDs) > 0 {+ folders, err := ds.Folder(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"folder.id": folderIDs},})if err != nil {@@ -89,49 +97,20 @@ func newDiscArtworkReader(ctx context.Context, a *artwork, artID model.ArtworkIDfor _, f := range folders {rel := strings.TrimPrefix(path.Join(f.Path, f.Name), "/")discFoldersRel[rel] = true+ imagesUpdatedAt = utils.TimeNewest(imagesUpdatedAt, f.ImagesUpdatedAt)}}- isMultiFolder := len(al.FolderIDs) > 1-- r := &discArtworkReader{- a: a,- album: *al,- discNumber: discNumber,- imgFiles: imgFiles,- discFoldersRel: discFoldersRel,- isMultiFolder: isMultiFolder,- firstTrackRel: firstTrackRel,- lib: lib,- updatedAt: imagesUpdatedAt,- }- r.cacheKey.artID = artID- r.cacheKey.lastUpdate = utils.TimeNewest(al.UpdatedAt, al.ImportedAt)- if imagesUpdatedAt != nil {- r.cacheKey.lastUpdate = utils.TimeNewest(r.cacheKey.lastUpdate, *imagesUpdatedAt)- }- return r, nil-}--func (d *discArtworkReader) Key() string {- hash := md5.Sum([]byte(conf.Server.DiscArtPriority))- return fmt.Sprintf(- "%s.%x",- d.cacheKey.Key(),- hash,- )-}--func (d *discArtworkReader) LastUpdated() time.Time {- return d.lastUpdate-}--func (d *discArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {- var ff = d.fromDiscArtPriority(ctx, d.a.ffmpeg, conf.Server.DiscArtPriority)- // Fallback to album cover art- albumArtID := model.NewArtworkID(model.KindAlbumArtwork, d.album.ID, &d.album.UpdatedAt)- ff = append(ff, fromAlbum(ctx, d.a, albumArtID))- return selectImageReader(ctx, d.cacheKey.artID, ff...)+ return &discArtworkReader{+ album: *al,+ discNumber: discNumber,+ imgFiles: imgFiles,+ discFoldersRel: discFoldersRel,+ isMultiFolder: len(al.FolderIDs) > 1,+ firstTrackRel: firstTrackRel,+ lib: lib,+ imagesUpdatedAt: imagesUpdatedAt,+ }, nil}func (d *discArtworkReader) fromDiscArtPriority(ctx context.Context, ffmpeg ffmpeg.FFmpeg, priority string) []sourceFunc {@@ -162,14 +141,13 @@ func (d *discArtworkReader) fromDiscArtPriority(ctx context.Context, ffmpeg ffmpfunc (d *discArtworkReader) fromDiscSubtitle(ctx context.Context, subtitle string) sourceFunc {return func() (io.ReadCloser, string, error) {for _, file := range d.imgFiles {- name := path.Base(file)- stem := strings.TrimSuffix(name, path.Ext(name))+ stem := utils.BaseName(file)if !strings.EqualFold(stem, subtitle) {continue}f, err := d.lib.FS.Open(file)if err != nil {- log.Warn(ctx, "Could not open disc art file", "file", file, err)+ log.Warn(ctx, "Artwork: Could not open disc art file", "file", file, err)continue}return f, file, nil@@ -178,19 +156,12 @@ func (d *discArtworkReader) fromDiscSubtitle(ctx context.Context, subtitle strin}}-// globMetaChars holds the substitution metacharacters understood by-// filepath.Match. The '\' escape character is intentionally excluded:-// disc art patterns come from user config and never include escaped-// metachars in practice, and treating '\' as a metachar would misalign-// the literal-prefix extraction in extractDiscNumber.+// filepath.Match's '\' escape is excluded on purpose: treating it as a metachar+// would misalign the literal-prefix extraction in extractDiscNumber.const globMetaChars = "*?["-// extractDiscNumber parses the disc number from a filename matched by a-// filepath.Match-style glob pattern.-//-// Both pattern and filename must already be lowercased by the caller, which-// is also expected to have verified that filepath.Match(pattern, filename)-// is true before calling this function.+// extractDiscNumber parses the disc number from a filename matched by a filepath.Match-style+// glob. Caller must lowercase both args and have already verified the match.func extractDiscNumber(pattern, filename string) (int, bool) {metaIdx := strings.IndexAny(pattern, globMetaChars)if metaIdx < 0 {@@ -216,9 +187,8 @@ func extractDiscNumber(pattern, filename string) (int, bool) {return num, true}-// fromExternalFile returns a sourceFunc that matches image files against a glob-// pattern. A numbered filename whose number equals the target disc wins over-// any unnumbered candidate; callers must pass a lowercase pattern.+// fromExternalFile matches image files against a (lowercase) glob pattern. A numbered+// filename whose number equals the target disc wins over any unnumbered candidate.func (d *discArtworkReader) fromExternalFile(ctx context.Context, pattern string) sourceFunc {isLiteral := !strings.ContainsAny(pattern, globMetaChars)return func() (io.ReadCloser, string, error) {@@ -227,7 +197,7 @@ func (d *discArtworkReader) fromExternalFile(ctx context.Context, pattern stringname := strings.ToLower(path.Base(file))match, err := filepath.Match(pattern, name)if err != nil {- log.Warn(ctx, "Error matching disc art file to pattern", "pattern", pattern, "file", file)+ log.Warn(ctx, "Artwork: Error matching disc art file to pattern", "pattern", pattern, "file", file)continue}if !match {@@ -241,7 +211,7 @@ func (d *discArtworkReader) fromExternalFile(ctx context.Context, pattern string}f, err := d.lib.FS.Open(file)if err != nil {- log.Warn(ctx, "Could not open disc art file", "file", file, err)+ log.Warn(ctx, "Artwork: Could not open disc art file", "file", file, err)continue}return f, file, nil@@ -257,7 +227,7 @@ func (d *discArtworkReader) fromExternalFile(ctx context.Context, pattern stringfor _, file := range fallbacks {f, err := d.lib.FS.Open(file)if err != nil {- log.Warn(ctx, "Could not open disc art file", "file", file, err)+ log.Warn(ctx, "Artwork: Could not open disc art file", "file", file, err)continue}return f, file, nildiff --git a/core/artwork/reader_disc_test.go b/core/artwork/disc_test.gosimilarity index 100%rename from core/artwork/reader_disc_test.gorename to core/artwork/disc_test.godiff --git a/core/artwork/dominant/dominant.go b/core/artwork/dominant/dominant.gonew file mode 100644index 000000000..2bbda8ae9--- /dev/null+++ b/core/artwork/dominant/dominant.go@@ -0,0 +1,127 @@+// Package dominant extracts an image's dominant colour, for use as a flat placeholder while the+// real artwork loads.+package dominant++import (+ "fmt"+ "image"+ "math"+ "sort"+)++const (+ // 4 bits per channel: coarse enough that near-identical pixels land together, fine enough that+ // distinct colours stay apart.+ bits = 4+ nBins = 1 << (3 * bits)+ // Only the heaviest bins can win, and merging is O(n^2) over whatever survives.+ maxBins = 64+ // Oklab distance below which two bins are the same colour to the eye. Merging matters because a+ // gradient splits across adjacent bins and would otherwise lose to a smaller flat region.+ mergeDist = 0.10+)++type bin struct {+ r, g, b float64+ n float64+}++// Color returns the dominant colour as "#rrggbb", or "" when the image has no pixels. It reports+// presence, not salience: a mostly white sleeve returns white.+func Color(img image.Image) string {+ var bins [nBins]bin+ total := 0+ eachPixel(img, func(r, g, b uint8) {+ i := int(r>>(8-bits))<<(2*bits) | int(g>>(8-bits))<<bits | int(b>>(8-bits))+ bins[i].r += float64(r)+ bins[i].g += float64(g)+ bins[i].b += float64(b)+ bins[i].n+++ total+++ })+ if total == 0 {+ return ""+ }++ used := make([]bin, 0, 32)+ for i := range bins {+ if bins[i].n > 0 {+ used = append(used, bins[i])+ }+ }+ sort.Slice(used, func(i, j int) bool { return used[i].n > used[j].n })+ if len(used) > maxBins {+ used = used[:maxBins]+ }++ merged := make([]bin, 0, len(used))+ for _, b := range used {+ if i := nearest(merged, b); i >= 0 {+ merged[i].r += b.r+ merged[i].g += b.g+ merged[i].b += b.b+ merged[i].n += b.n+ continue+ }+ merged = append(merged, b)+ }++ best := merged[0]+ for _, m := range merged[1:] {+ if m.n > best.n {+ best = m+ }+ }+ return fmt.Sprintf("#%02x%02x%02x",+ uint8(best.r/best.n+0.5), uint8(best.g/best.n+0.5), uint8(best.b/best.n+0.5))+}++func nearest(merged []bin, b bin) int {+ bl, ba, bb := oklab(b.r/b.n, b.g/b.n, b.b/b.n)+ for i, m := range merged {+ ml, ma, mb := oklab(m.r/m.n, m.g/m.n, m.b/m.n)+ if math.Sqrt((bl-ml)*(bl-ml)+(ba-ma)*(ba-ma)+(bb-mb)*(bb-mb)) < mergeDist {+ return i+ }+ }+ return -1+}++// eachPixel walks the image, taking the NRGBA fast path the artwork pipeline always hits: both hash+// encoders already read the shared thumbnail in that form.+func eachPixel(img image.Image, fn func(r, g, b uint8)) {+ if p, ok := img.(*image.NRGBA); ok {+ for y := range p.Rect.Dy() {+ row := p.Pix[y*p.Stride : y*p.Stride+p.Rect.Dx()*4]+ for x := 0; x < len(row); x += 4 {+ fn(row[x], row[x+1], row[x+2])+ }+ }+ return+ }+ b := img.Bounds()+ for y := b.Min.Y; y < b.Max.Y; y++ {+ for x := b.Min.X; x < b.Max.X; x++ {+ r, g, bl, _ := img.At(x, y).RGBA()+ fn(uint8(r>>8), uint8(g>>8), uint8(bl>>8))+ }+ }+}++func srgbToLinear(v float64) float64 {+ v /= 255+ if v <= 0.04045 {+ return v / 12.92+ }+ return math.Pow((v+0.055)/1.055, 2.4)+}++func oklab(r, g, b float64) (float64, float64, float64) {+ lr, lg, lb := srgbToLinear(r), srgbToLinear(g), srgbToLinear(b)+ l := math.Cbrt(0.4122214708*lr + 0.5363325363*lg + 0.0514459929*lb)+ m := math.Cbrt(0.2119034982*lr + 0.6806995451*lg + 0.1073969566*lb)+ s := math.Cbrt(0.0883024619*lr + 0.2817188376*lg + 0.6299787005*lb)+ return 0.2104542553*l + 0.7936177850*m - 0.0040720468*s,+ 1.9779984951*l - 2.4285922050*m + 0.4505937099*s,+ 0.0259040371*l + 0.7827717662*m - 0.8086757660*s+}diff --git a/core/artwork/dominant/dominant_suite_test.go b/core/artwork/dominant/dominant_suite_test.gonew file mode 100644index 000000000..56dbd6209--- /dev/null+++ b/core/artwork/dominant/dominant_suite_test.go@@ -0,0 +1,17 @@+package dominant_test++import (+ "testing"++ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++func TestDominant(t *testing.T) {+ tests.Init(t, false)+ log.SetLevel(log.LevelFatal)+ RegisterFailHandler(Fail)+ RunSpecs(t, "Dominant Suite")+}diff --git a/core/artwork/dominant/dominant_test.go b/core/artwork/dominant/dominant_test.gonew file mode 100644index 000000000..da7fed09c--- /dev/null+++ b/core/artwork/dominant/dominant_test.go@@ -0,0 +1,91 @@+package dominant_test++import (+ "image"+ "image/color"++ "github.com/navidrome/navidrome/core/artwork/dominant"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++// fill paints rect with c onto img.+func fill(img *image.NRGBA, r image.Rectangle, c color.NRGBA) {+ for y := r.Min.Y; y < r.Max.Y; y++ {+ for x := r.Min.X; x < r.Max.X; x++ {+ img.SetNRGBA(x, y, c)+ }+ }+}++func newImg(w, h int, c color.NRGBA) *image.NRGBA {+ img := image.NewNRGBA(image.Rect(0, 0, w, h))+ fill(img, img.Bounds(), c)+ return img+}++var _ = Describe("Color", func() {+ It("returns a solid image's own colour", func() {+ Expect(dominant.Color(newImg(20, 20, color.NRGBA{0x33, 0x66, 0x99, 255}))).To(Equal("#336699"))+ })++ It("returns empty for an image with no pixels", func() {+ Expect(dominant.Color(image.NewNRGBA(image.Rect(0, 0, 0, 0)))).To(Equal(""))+ })++ // Presence, not salience: this is a placeholder, so the large field wins even though the small+ // patch is the more interesting colour.+ It("picks the largest area, not the most vivid one", func() {+ img := newImg(20, 20, color.NRGBA{0xfa, 0xfa, 0xfa, 255})+ fill(img, image.Rect(0, 0, 4, 4), color.NRGBA{0xff, 0x00, 0x00, 255})+ Expect(dominant.Color(img)).To(Equal("#fafafa"))+ })++ It("reports a near-black cover as near-black", func() {+ img := newImg(20, 20, color.NRGBA{0x05, 0x05, 0x05, 255})+ fill(img, image.Rect(0, 0, 5, 5), color.NRGBA{0x00, 0xff, 0x00, 255})+ Expect(dominant.Color(img)).To(Equal("#050505"))+ })++ // A gradient splits across many quantisation bins. Without merging, each slice is smaller than+ // the flat block and the block would win despite covering far less of the image.+ It("merges a gradient's bins so it beats a smaller flat block", func() {+ img := image.NewNRGBA(image.Rect(0, 0, 40, 40))+ for y := range 40 {+ for x := range 40 {+ // 30 columns of blue gradient == 75% of the image+ if x < 30 {+ img.SetNRGBA(x, y, color.NRGBA{0x10, 0x20, uint8(0xa0 + x), 255})+ } else {+ img.SetNRGBA(x, y, color.NRGBA{0xff, 0xcc, 0x00, 255})+ }+ }+ }+ got := dominant.Color(img)+ Expect(got).To(HavePrefix("#1020"), "expected the blue gradient, got "+got)+ })++ It("is deterministic", func() {+ img := image.NewNRGBA(image.Rect(0, 0, 30, 30))+ for y := range 30 {+ for x := range 30 {+ img.SetNRGBA(x, y, color.NRGBA{uint8(x * 7), uint8(y * 5), uint8(x + y), 255})+ }+ }+ first := dominant.Color(img)+ for range 5 {+ Expect(dominant.Color(img)).To(Equal(first))+ }+ })++ It("handles images that are not NRGBA", func() {+ src := newImg(10, 10, color.NRGBA{0x20, 0x40, 0x60, 255})+ rgba := image.NewRGBA(src.Bounds())+ for y := range 10 {+ for x := range 10 {+ rgba.Set(x, y, src.At(x, y))+ }+ }+ Expect(dominant.Color(rgba)).To(Equal("#204060"))+ })+})diff --git a/core/artwork/e2e/acquire_serve_test.go b/core/artwork/e2e/acquire_serve_test.gonew file mode 100644index 000000000..d6c374e39--- /dev/null+++ b/core/artwork/e2e/acquire_serve_test.go@@ -0,0 +1,326 @@+package e2e++import (+ "context"+ "encoding/base64"+ "errors"+ "io"+ "os"+ "time"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest"+ "github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/core/artwork"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/server/events"+ "github.com/navidrome/navidrome/tests"+ "github.com/navidrome/navidrome/utils/cache"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++// Covers the enqueue → drain → serve chain; per-source resolution rules live in the unit suites.+var _ = Describe("Acquisition → serve loop", func() {+ var (+ ctx context.Context+ ds *tests.MockDataStore+ artRepo *tests.MockArtworkRepo+ queueRepo *tests.MockArtworkQueueRepo+ albumRepo *tests.MockAlbumRepo+ artistRepo *tests.MockArtistRepo+ mfRepo *tests.MockMediaFileRepo+ plRepo *tests.MockPlaylistRepo+ radioRepo *tests.MockedRadioRepo+ folderRepo *fakeFolderRepo+ libRepo *tests.MockLibraryRepo+ store *artwork.ImageStore+ svc artwork.Artwork+ worker *artwork.Worker+ coverBytes []byte+ )++ itemFound := func(kind model.Kind, id string) func() bool {+ return func() bool {+ ia, err := artRepo.GetItemArtwork(kind, id, model.ImageTypePrimary)+ return err == nil && ia.Hash != ""+ }+ }+ itemAbsent := func(kind model.Kind, id string) func() bool {+ return func() bool {+ ia, err := artRepo.GetItemArtwork(kind, id, model.ImageTypePrimary)+ return err == nil && ia.Hash == ""+ }+ }+ // Enqueues the way the serving paths do, so the drain is driven by a plain queue row.+ bump := func(kind, id string) {+ GinkgoHelper()+ Expect(ds.ArtworkQueue(ctx).EnqueuePreservingBackoff(model.ArtworkQueueItem{+ ItemKind: kind, ItemID: id, ImageType: model.ImageTypePrimary,+ Priority: model.ArtworkPriorityBump,+ })).To(Succeed())+ }++ BeforeEach(func() {+ DeferCleanup(configtest.SetupConfig())+ ctx = context.Background()+ repoRoot, err := os.Getwd()+ Expect(err).ToNot(HaveOccurred())+ coverBytes = readFixture(coverFixture)++ conf.Server.CacheFolder = conf.NewDir(GinkgoT().TempDir())+ conf.Server.DataFolder = conf.NewDir(GinkgoT().TempDir())+ conf.Server.CoverArtPriority = "cover.jpg"+ conf.Server.ArtistArtPriority = "artist.png" // keeps artist resolution offline+ conf.Server.EnableMediaFileCoverArt = true+ conf.Server.DevArtworkWorkerConcurrency = 1++ folderRepo = &fakeFolderRepo{}+ libRepo = &tests.MockLibraryRepo{}+ libRepo.SetData(model.Libraries{{ID: 0, Path: repoRoot}})+ artRepo = tests.CreateMockArtworkRepo()+ queueRepo = tests.CreateMockArtworkQueueRepo()+ albumRepo = tests.CreateMockAlbumRepo()+ artistRepo = tests.CreateMockArtistRepo()+ mfRepo = tests.CreateMockMediaFileRepo()+ plRepo = tests.CreateMockPlaylistRepo()+ radioRepo = tests.CreateMockedRadioRepo()+ radioRepo.Data = map[string]*model.Radio{}+ ds = &tests.MockDataStore{+ MockedArtwork: artRepo,+ MockedArtworkQueue: queueRepo,+ MockedAlbum: albumRepo,+ MockedArtist: artistRepo,+ MockedMediaFile: mfRepo,+ MockedPlaylist: plRepo,+ MockedRadio: radioRepo,+ MockedFolder: folderRepo,+ MockedLibrary: libRepo,+ }+ ffm := tests.NewMockFFmpeg("")+ store = artwork.NewImageStore(GinkgoT().TempDir())+ // size=0 requests stream originals, so this reader is never called (serving_test covers resizing).+ imgCache := cache.NewFileCache("ArtworkPipelineE2E", "100MB", "images", 0,+ func(context.Context, cache.Item) (io.Reader, error) {+ return nil, errors.New("resize not exercised in e2e")+ })+ Eventually(func() bool { return imgCache.Available(ctx) }).Should(BeTrue())++ svc = artwork.NewArtwork(ds, imgCache, store, ffm)+ worker = artwork.NewWorker(ds, store, agents.GetAgents(ds, nil), ffm, events.NoopBroker(), imgCache)+ })++ seedFolderAlbum := func(albumID string) {+ folderRepo.result = []model.Folder{{Path: albumFolderPath, ImageFiles: []string{"cover.jpg"}}}+ albumRepo.SetData(model.Albums{{ID: albumID, Name: "Album", FolderIDs: []string{"f1"}, LibraryID: 0}})+ }++ It("acquires album folder art and serves the exact bytes under its hash", func() {+ seedFolderAlbum("al1")+ bump("al", "al1")+ runWorkerUntil(ctx, worker, itemFound(model.KindAlbumArtwork, "al1"))++ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("folder"))++ img, err := svc.Get(ctx, model.MustParseArtworkID("al-al1"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(img.Hash).To(Equal(ia.Hash))+ Expect(img.Placeholder).To(BeFalse())+ Expect(readAll(img)).To(Equal(coverBytes))+ })++ It("acquires an artist's uploaded image and serves it", func() {+ name := writeUpload(consts.EntityArtist, "artist-e2e.png", artistPngFixture)+ artistRepo.SetData(model.Artists{{ID: "ar1", Name: "Artist", UploadedImage: name}})+ bump("ar", "ar1")+ runWorkerUntil(ctx, worker, itemFound(model.KindArtistArtwork, "ar1"))++ ia, err := artRepo.GetItemArtwork(model.KindArtistArtwork, "ar1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("upload"))++ img, err := svc.Get(ctx, model.MustParseArtworkID("ar-ar1"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(img.Hash).To(Equal(ia.Hash))+ Expect(readAll(img)).To(Equal(readFixture(artistPngFixture)))+ })++ It("generates a playlist grid from its tracks' album art and serves it from the store", func() {+ seedFolderAlbum("al1")+ plRepo.SetData(model.Playlists{{ID: "pl1", Name: "Playlist"}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"al1"}}+ bump("pl", "pl1")+ runWorkerUntil(ctx, worker, itemFound(model.KindPlaylistArtwork, "pl1"))++ ia, err := artRepo.GetItemArtwork(model.KindPlaylistArtwork, "pl1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("generated"))++ img, err := svc.Get(ctx, model.MustParseArtworkID("pl-pl1"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(img.Hash).To(Equal(ia.Hash))+ art, err := artRepo.GetImage(ia.Hash)+ Expect(err).ToNot(HaveOccurred())+ Expect(art.Mime).To(Equal("image/png"))+ Expect(len(readAll(img))).To(BeNumerically(">", 0))+ })++ It("acquires a radio station's uploaded image and serves it", func() {+ name := writeUpload(consts.EntityRadio, "radio-e2e.jpg", coverFixture)+ radioRepo.Data["ra1"] = &model.Radio{ID: "ra1", Name: "Station", UploadedImage: name}+ bump("ra", "ra1")+ runWorkerUntil(ctx, worker, itemFound(model.KindRadioArtwork, "ra1"))++ ia, err := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("upload"))++ img, err := svc.Get(ctx, model.MustParseArtworkID("ra-ra1"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(img.Hash).To(Equal(ia.Hash))+ Expect(readAll(img)).To(Equal(coverBytes))+ })++ It("serves an unresolved track provisionally, then upgrades to the worker's state row", func() {+ mfRepo.SetData(model.MediaFiles{{+ ID: "mf1", AlbumID: "al1", HasCoverArt: true, LibraryID: 0, Path: mp3Fixture,+ }})++ provisional, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf1"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(provisional.Placeholder).To(BeFalse())+ Expect(provisional.Hash).ToNot(BeEmpty())+ provisionalBytes := readAll(provisional)+ Expect(len(provisionalBytes)).To(BeNumerically(">", 0))++ _, err = artRepo.GetItemArtwork(model.KindMediaFileArtwork, "mf1", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound), "provisional serving must not write a state row")++ // The provisional read enqueued a Bump; drain it.+ runWorkerUntil(ctx, worker, itemFound(model.KindMediaFileArtwork, "mf1"))+ ia, err := artRepo.GetItemArtwork(model.KindMediaFileArtwork, "mf1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("embedded"))+ Expect(ia.Hash).To(Equal(provisional.Hash))++ resolved, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf1"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(resolved.Hash).To(Equal(ia.Hash))+ Expect(readAll(resolved)).To(Equal(provisionalBytes))+ })++ It("stores dimensions, mime and a real blurhash alongside the acquired bytes", func() {+ seedFolderAlbum("al1")+ bump("al", "al1")+ runWorkerUntil(ctx, worker, itemFound(model.KindAlbumArtwork, "al1"))++ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ art, err := artRepo.GetImage(ia.Hash)+ Expect(err).ToNot(HaveOccurred())+ Expect(art.Mime).To(Equal("image/jpeg"))+ Expect(art.Width).To(BeNumerically(">", 0))+ Expect(art.Height).To(BeNumerically(">", 0))+ Expect(art.SizeBytes).To(BeNumerically("==", len(coverBytes)))+ // Never a synthesized value: both hashes are encoded from the real pixels.+ Expect(art.BlurHash).ToNot(BeEmpty())+ Expect(art.ThumbHash).ToNot(BeEmpty())+ raw, err := base64.StdEncoding.DecodeString(art.ThumbHash)+ Expect(err).ToNot(HaveOccurred())+ Expect(len(raw)).To(BeNumerically(">=", 5))+ })++ It("acquires GIF artwork, whose decoder only core/artwork's blank import registers", func() {+ writeUploadedImage(consts.EntityRadio, "station.gif", gifFixture)+ radioRepo.Data["ra1"] = &model.Radio{ID: "ra1", Name: "Station", UploadedImage: "station.gif"}+ bump("ra", "ra1")+ runWorkerUntil(ctx, worker, itemFound(model.KindRadioArtwork, "ra1"))++ ia, err := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ art, err := artRepo.GetImage(ia.Hash)+ Expect(err).ToNot(HaveOccurred())+ Expect(art.Mime).To(Equal("image/gif"))+ Expect(art.Width).To(BeNumerically("==", 4))+ })++ It("deduplicates byte-identical art across entities onto one image row", func() {+ folderRepo.result = []model.Folder{{Path: albumFolderPath, ImageFiles: []string{"cover.jpg"}}}+ albumRepo.SetData(model.Albums{+ {ID: "al1", Name: "Album", FolderIDs: []string{"f1"}, LibraryID: 0},+ {ID: "al2", Name: "Same Cover", FolderIDs: []string{"f1"}, LibraryID: 0},+ })+ bump("al", "al1")+ bump("al", "al2")+ runWorkerUntil(ctx, worker, func() bool {+ return itemFound(model.KindAlbumArtwork, "al1")() && itemFound(model.KindAlbumArtwork, "al2")()+ })++ ia1, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ ia2, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al2", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia1.Hash).To(Equal(ia2.Hash), "identical bytes must share one content hash")+ Expect(readAll(mustGet(svc.Get(ctx, model.MustParseArtworkID("al-al2"), 0, false)))).To(Equal(coverBytes))+ })++ It("stops serving a file-backed image once its source file changes underneath", func() {+ name := writeUpload(consts.EntityRadio, "radio-stale.jpg", coverFixture)+ radioRepo.Data["ra1"] = &model.Radio{ID: "ra1", Name: "Station", UploadedImage: name}+ bump("ra", "ra1")+ runWorkerUntil(ctx, worker, itemFound(model.KindRadioArtwork, "ra1"))++ ia, err := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ staleHash := ia.Hash++ path := model.UploadedImagePath(consts.EntityRadio, name)+ Expect(os.WriteFile(path, readFixture(artistPngFixture), 0o600)).To(Succeed())+ newer := time.Now().Add(2 * time.Second)+ Expect(os.Chtimes(path, newer, newer)).To(Succeed())++ // The mtime no longer matches the state row, so the stale bytes are not served.+ _, err = svc.Get(ctx, model.MustParseArtworkID("ra-ra1"), 0, false)+ Expect(err).To(MatchError(artwork.ErrUnavailable))++ // That failed read enqueued a re-resolution.+ runWorkerUntil(ctx, worker, func() bool {+ cur, gerr := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra1", model.ImageTypePrimary)+ return gerr == nil && cur.Hash != "" && cur.Hash != staleHash+ })+ img, err := svc.Get(ctx, model.MustParseArtworkID("ra-ra1"), 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(readAll(img)).To(Equal(readFixture(artistPngFixture)))+ })++ It("records an absent state for an entity with no art and reports it unavailable", func() {+ albumRepo.SetData(model.Albums{{ID: "alx", Name: "Artless", LibraryID: 0}})+ bump("al", "alx")+ runWorkerUntil(ctx, worker, itemAbsent(model.KindAlbumArtwork, "alx"))++ _, err := svc.Get(ctx, model.MustParseArtworkID("al-alx"), 0, false)+ Expect(err).To(MatchError(artwork.ErrUnavailable))++ img, err := svc.GetOrPlaceholder(ctx, "al-alx", 0, false)+ Expect(err).ToNot(HaveOccurred())+ Expect(img.Placeholder).To(BeTrue())+ })+})++func mustGet(img *artwork.Image, err error) *artwork.Image {+ GinkgoHelper()+ Expect(err).ToNot(HaveOccurred())+ return img+}++// Raw bytes on purpose: encoding a GIF here would register image/gif in the test binary, masking+// the production import the spec above guards.+var gifFixture = []byte{+ 0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x04, 0x00, 0x04, 0x00, 0x80, 0x00,+ 0x00, 0x2e, 0x86, 0xc1, 0xf4, 0xd0, 0x3f, 0x2c, 0x00, 0x00, 0x00, 0x00,+ 0x04, 0x00, 0x04, 0x00, 0x00, 0x02, 0x05, 0x44, 0x7c, 0x67, 0xb8, 0x05,+ 0x00, 0x3b,+}diff --git a/core/artwork/e2e/album_test.go b/core/artwork/e2e/album_test.goindex 5e61684cc..7b5e7b4a3 100644--- a/core/artwork/e2e/album_test.go+++ b/core/artwork/e2e/album_test.go@@ -1,4 +1,4 @@-package artworke2e_test+package e2eimport ("testing/fstest"@@ -9,14 +9,11 @@ import (. "github.com/onsi/gomega")-const (- defaultCoverPriority = "cover.*, folder.*, front.*, embedded, external"- defaultDiscPriority = "disc*.*, cd*.*, cover.*, folder.*, front.*, discsubtitle, embedded"-)-+// The in-memory library FS cannot satisfy the os.Open(SourcePath) used to serve folder art, so+// folder scenarios assert on the worker's state row (Source + SourcePath) instead of the bytes.var _ = Describe("Album artwork resolution", func() {BeforeEach(func() {- setupHarness()+ setupResolutionHarness()})When("an album has a single folder with cover.jpg at the album root", func() {@@ -28,12 +25,10 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = defaultCoverPrioritysetLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/cover.jpg": imageFile("album-root"),+ "Artist/Album/cover.jpg": smallPNG("album-root"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")})})@@ -55,16 +50,16 @@ var _ = Describe("Album artwork resolution", func() {setLayout(fstest.MapFS{"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "Track CD1"),"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "Track CD2"),- "Artist/Album/cover.jpg": imageFile("album-root"),- "Artist/Album/CD1/cover.jpg": imageFile("disc1"),- "Artist/Album/CD2/cover.jpg": imageFile("disc2"),+ "Artist/Album/cover.jpg": smallPNG("album-root"),+ "Artist/Album/CD1/cover.jpg": smallPNG("disc1"),+ "Artist/Album/CD2/cover.jpg": smallPNG("disc2"),})scan()al := firstAlbum()Expect(al.FolderIDs).To(HaveLen(2),- "sanity check: scanner should treat the two disc subfolders as one multi-disc album")- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root")))+ "sanity check: the two disc subfolders should form one multi-disc album")+ expectAlbumFolderCover(al, "Artist/Album/cover.jpg")})})@@ -86,14 +81,12 @@ var _ = Describe("Album artwork resolution", func() {setLayout(fstest.MapFS{"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "Track CD1"),"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "Track CD2"),- "Artist/Album/folder.jpg": imageFile("album-root"),- "Artist/Album/CD1/folder.jpg": imageFile("disc1"),- "Artist/Album/CD2/folder.jpg": imageFile("disc2"),+ "Artist/Album/folder.jpg": smallPNG("album-root"),+ "Artist/Album/CD1/folder.jpg": smallPNG("disc1"),+ "Artist/Album/CD2/folder.jpg": smallPNG("disc2"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/folder.jpg")})})@@ -109,12 +102,10 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = defaultCoverPrioritysetLayout(fstest.MapFS{"Artist/Album/disc1/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/cover.jpg": imageFile("album-root"),+ "Artist/Album/cover.jpg": smallPNG("album-root"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")})})@@ -133,14 +124,12 @@ var _ = Describe("Album artwork resolution", func() {setLayout(fstest.MapFS{"Album/CD1/01 - Track.mp3": trackFile(1, "Track CD1"),"Album/CD2/01 - Track.mp3": trackFile(1, "Track CD2"),- "Album/cover.jpg": imageFile("album-root"),- "Album/CD1/folder.jpg": imageFile("disc1"),- "Album/CD2/folder.jpg": imageFile("disc2"),+ "Album/cover.jpg": smallPNG("album-root"),+ "Album/CD1/folder.jpg": smallPNG("disc1"),+ "Album/CD2/folder.jpg": smallPNG("disc2"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root")))+ expectAlbumFolderCover(firstAlbum(), "Album/cover.jpg")})})@@ -153,14 +142,14 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = "embedded, cover.*, folder.*, front.*, external"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"has_picture": "true"}),- "Artist/Album/cover.jpg": imageFile("external"),+ "Artist/Album/cover.jpg": smallPNG("external"),})scan()- // Swap in real MP3 bytes so libFS.Open returns a taglib-readable stream.replaceWithRealMP3("Artist/Album/01 - Track.mp3")- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(embeddedArtBytes))+ ia := acquire(model.KindAlbumArtwork, firstAlbum().ID)+ Expect(ia.Source).To(Equal("embedded"))+ Expect(storedBytes(ia)).To(Equal(embeddedArtBytes))})})@@ -176,8 +165,9 @@ var _ = Describe("Album artwork resolution", func() {scan()replaceWithRealMP3("Artist/Album/01 - Track.mp3")- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(embeddedArtBytes))+ ia := acquire(model.KindAlbumArtwork, firstAlbum().ID)+ Expect(ia.Source).To(Equal("embedded"))+ Expect(storedBytes(ia)).To(Equal(embeddedArtBytes))})})@@ -190,12 +180,10 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = "cover.*, folder.*"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/Cover.JPG": imageFile("case-insensitive"),+ "Artist/Album/Cover.JPG": smallPNG("case-insensitive"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("case-insensitive")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/Cover.JPG")})})@@ -209,30 +197,25 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = "cover.*"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/cover.jpg": imageFile("primary"),- "Artist/Album/cover.1.jpg": imageFile("secondary"),+ "Artist/Album/cover.jpg": smallPNG("primary"),+ "Artist/Album/cover.1.jpg": smallPNG("secondary"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("primary")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")})})When("the album has no cover and CoverArtPriority lists only file patterns", func() {// Artist/// └── Album/- // └── 01 - Track.mp3 (no image files — returns ErrUnavailable)- It("returns ErrUnavailable", func() {+ // └── 01 - Track.mp3 (no image files — settles absent)+ It("settles absent", func() {conf.Server.CoverArtPriority = "cover.*, folder.*"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),})scan()-- al := firstAlbum()- _, err := readArtworkOrErr(model.NewArtworkID(model.KindAlbumArtwork, al.ID, &al.UpdatedAt))- Expect(err).To(HaveOccurred())+ expectAlbumAbsent(firstAlbum())})})@@ -248,12 +231,10 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = defaultCoverPrioritysetLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/folder.jpg": imageFile("folder"),+ "Artist/Album/folder.jpg": smallPNG("folder"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("folder")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/folder.jpg")})})@@ -266,12 +247,10 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = defaultCoverPrioritysetLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/front.jpg": imageFile("front"),+ "Artist/Album/front.jpg": smallPNG("front"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("front")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/front.jpg")})})@@ -286,14 +265,12 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = defaultCoverPrioritysetLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/cover.jpg": imageFile("cover"),- "Artist/Album/folder.jpg": imageFile("folder"),- "Artist/Album/front.jpg": imageFile("front"),+ "Artist/Album/cover.jpg": smallPNG("cover"),+ "Artist/Album/folder.jpg": smallPNG("folder"),+ "Artist/Album/front.jpg": smallPNG("front"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("cover")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")})})@@ -307,13 +284,11 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = defaultCoverPrioritysetLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/folder.jpg": imageFile("folder"),- "Artist/Album/front.jpg": imageFile("front"),+ "Artist/Album/folder.jpg": smallPNG("folder"),+ "Artist/Album/front.jpg": smallPNG("front"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("folder")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/folder.jpg")})})@@ -328,14 +303,12 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = "cover.*"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/cover.2.jpg": imageFile("second"),- "Artist/Album/cover.jpg": imageFile("primary"),- "Artist/Album/cover.1.jpg": imageFile("first"),+ "Artist/Album/cover.2.jpg": smallPNG("second"),+ "Artist/Album/cover.jpg": smallPNG("primary"),+ "Artist/Album/cover.1.jpg": smallPNG("first"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("primary")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")})})@@ -348,12 +321,10 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = "bogus.*, cover.*"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/cover.jpg": imageFile("cover"),+ "Artist/Album/cover.jpg": smallPNG("cover"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("cover")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")})})@@ -371,21 +342,16 @@ var _ = Describe("Album artwork resolution", func() {It("does not use the artist image as album art", func() {conf.Server.CoverArtPriority = defaultCoverPrioritysetLayout(fstest.MapFS{- "Artist/folder.jpg": imageFile("artist-thumbnail"),+ "Artist/folder.jpg": smallPNG("artist-thumbnail"),"Artist/Album A/01 - Track.mp3": trackFile(1, "Track A", map[string]any{"album": "Album A", "albumartist": "Artist"}),"Artist/Album B/01 - Track.mp3": trackFile(1, "Track B", map[string]any{"album": "Album B", "albumartist": "Artist"}),- "Artist/Album B/cover.jpg": imageFile("album-b"),+ "Artist/Album B/cover.jpg": smallPNG("album-b"),})scan()- alA := albumByName("Album A")- _, err := readArtworkOrErr(alA.CoverArtID())- Expect(err).To(HaveOccurred(),- "Album A has no images of its own, so it must fall through to the placeholder "+- "instead of inheriting the artist folder's folder.jpg")-- alB := albumByName("Album B")- Expect(readArtwork(alB.CoverArtID())).To(Equal(imageBytes("album-b")))+ // Album B first: the acquire in expectAlbumAbsent would settle Album B too.+ expectAlbumFolderCover(albumByName("Album B"), "Artist/Album B/cover.jpg")+ expectAlbumAbsent(albumByName("Album A"))})})@@ -402,21 +368,58 @@ var _ = Describe("Album artwork resolution", func() {It("does not use the artist image as album art for the spread album", func() {conf.Server.CoverArtPriority = defaultCoverPrioritysetLayout(fstest.MapFS{- "Artist/folder.jpg": imageFile("artist-thumbnail"),+ "Artist/folder.jpg": smallPNG("artist-thumbnail"),"Artist/Album A/01 - Track.mp3": trackFile(1, "Track A1", map[string]any{"album": "Album A", "albumartist": "Artist"}),"Artist/Album A bonus/02 - Track.mp3": trackFile(2, "Track A2", map[string]any{"album": "Album A", "albumartist": "Artist"}),"Artist/Album B/01 - Track.mp3": trackFile(1, "Track B", map[string]any{"album": "Album B", "albumartist": "Artist"}),- "Artist/Album B/cover.jpg": imageFile("album-b"),+ "Artist/Album B/cover.jpg": smallPNG("album-b"),})scan()alA := albumByName("Album A")Expect(alA.FolderIDs).To(HaveLen(2),- "sanity check: scanner should treat the two sibling folders as one spread album")- _, err := readArtworkOrErr(alA.CoverArtID())- Expect(err).To(HaveOccurred(),- "the spread album has no images of its own, so it must fall through to the "+- "placeholder instead of inheriting the artist folder's folder.jpg")+ "sanity check: the two sibling folders should form one spread album")+ expectAlbumAbsent(alA)+ })+ })++ // albumRootParent refuses the library root as an album root (parent.ParentID == "").+ When("a multi-disc album sits directly at the library root with a cover.jpg beside it", func() {+ // (library root)+ // ├── cover.jpg ← must NOT be adopted+ // ├── CD1/+ // │ └── 01 - Track.mp3+ // └── CD2/+ // └── 01 - Track.mp3+ It("does not adopt the library-root image as album art", func() {+ conf.Server.CoverArtPriority = defaultCoverPriority+ setLayout(fstest.MapFS{+ "cover.jpg": smallPNG("library-root"),+ "CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"album": "Rootless", "disc": "1"}),+ "CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"album": "Rootless", "disc": "2"}),+ })+ scan()+ expectAlbumAbsent(firstAlbum())+ })+ })++ // The shallower artist-folder cover.jpg would win the basename tie, but albumRootParent skips+ // the parent folder for a single-folder album that has images of its own.+ When("a single-folder album has its own cover.jpg and the artist folder has one too", func() {+ // Artist/+ // ├── cover.jpg ← shallower, but must NOT win+ // └── Album/+ // ├── 01 - Track.mp3+ // └── cover.jpg ← should win+ It("prefers the album's own cover over the shallower artist-folder cover", func() {+ conf.Server.CoverArtPriority = defaultCoverPriority+ setLayout(fstest.MapFS{+ "Artist/cover.jpg": smallPNG("artist-image"),+ "Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),+ "Artist/Album/cover.jpg": smallPNG("album-own"),+ })+ scan()+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")})})@@ -430,13 +433,13 @@ var _ = Describe("Album artwork resolution", func() {// ├── Album A bonus/// │ └── 02 - Track.mp3 (album: "Album A")// └── Album B/- // └── 01 - Track.mp3+ // └── 01 - Track.mp3 (other-album audio: rejects the artist folder as a root)It("prefers the album's own art over the artist image", func() {conf.Server.CoverArtPriority = defaultCoverPrioritysetLayout(fstest.MapFS{- "Artist/cover.jpg": imageFile("artist-image"),+ "Artist/cover.jpg": smallPNG("artist-image"),"Artist/Album A/01 - Track.mp3": trackFile(1, "Track A1", map[string]any{"album": "Album A", "albumartist": "Artist"}),- "Artist/Album A/front.jpg": imageFile("album-a-front"),+ "Artist/Album A/front.jpg": smallPNG("album-a-front"),"Artist/Album A bonus/02 - Track.mp3": trackFile(2, "Track A2", map[string]any{"album": "Album A", "albumartist": "Artist"}),"Artist/Album B/01 - Track.mp3": trackFile(1, "Track B", map[string]any{"album": "Album B", "albumartist": "Artist"}),})@@ -444,8 +447,8 @@ var _ = Describe("Album artwork resolution", func() {alA := albumByName("Album A")Expect(alA.FolderIDs).To(HaveLen(2),- "sanity check: scanner should treat the two sibling folders as one spread album")- Expect(readArtwork(alA.CoverArtID())).To(Equal(imageBytes("album-a-front")))+ "sanity check: the two sibling folders should form one spread album")+ expectAlbumFolderCover(alA, "Artist/Album A/front.jpg")})})@@ -458,12 +461,10 @@ var _ = Describe("Album artwork resolution", func() {conf.Server.CoverArtPriority = "embedded, cover.*"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/cover.jpg": imageFile("cover"),+ "Artist/Album/cover.jpg": smallPNG("cover"),})scan()-- al := firstAlbum()- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("cover")))+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")})})})diff --git a/core/artwork/e2e/artist_test.go b/core/artwork/e2e/artist_test.goindex 2079d37ce..5a9396cc3 100644--- a/core/artwork/e2e/artist_test.go+++ b/core/artwork/e2e/artist_test.go@@ -1,4 +1,4 @@-package artworke2e_test+package e2eimport ("os"@@ -8,6 +8,7 @@ import ("github.com/Masterminds/squirrel""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/model". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega"@@ -16,9 +17,11 @@ import (// Doc reference:// https://www.navidrome.org/docs/usage/library/artwork/#artists// Default ArtistArtPriority is "artist.*, album/artist.*, external".+// Library-folder images are file-backed (asserted on the worker state row); uploaded and+// image-folder images are real files on disk (asserted byte-for-byte).var _ = Describe("Artist artwork resolution", func() {BeforeEach(func() {- setupHarness()+ setupResolutionHarness()})When("the artist folder contains an artist.jpg", func() {@@ -30,13 +33,10 @@ var _ = Describe("Artist artwork resolution", func() {conf.Server.ArtistArtPriority = "artist.*, album/artist.*, external"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),- "Artist/artist.jpg": imageFile("artist-folder"),+ "Artist/artist.jpg": smallPNG("artist-folder"),})scan()-- ar := soleArtist()- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")})})@@ -49,13 +49,10 @@ var _ = Describe("Artist artwork resolution", func() {conf.Server.ArtistArtPriority = "artist.*, album/artist.*, external"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),- "Artist/Album/artist.jpg": imageFile("album-artist"),+ "Artist/Album/artist.jpg": smallPNG("album-artist"),})scan()-- ar := soleArtist()- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)- Expect(readArtwork(artID)).To(Equal(imageBytes("album-artist")))+ expectArtistFolder(soleArtist(), "Artist/Album/artist.jpg")})})@@ -69,14 +66,11 @@ var _ = Describe("Artist artwork resolution", func() {conf.Server.ArtistArtPriority = "artist.*, album/artist.*, external"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),- "Artist/artist.jpg": imageFile("artist-folder"),- "Artist/Album/artist.jpg": imageFile("album-artist"),+ "Artist/artist.jpg": smallPNG("artist-folder"),+ "Artist/Album/artist.jpg": smallPNG("album-artist"),})scan()-- ar := soleArtist()- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")})})@@ -89,13 +83,10 @@ var _ = Describe("Artist artwork resolution", func() {conf.Server.ArtistArtPriority = "artist.*"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),- "Artist/artist.jpg": imageFile("artist-folder"),+ "Artist/artist.jpg": smallPNG("artist-folder"),})scan()-- ar := soleArtist()- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")})})@@ -111,14 +102,11 @@ var _ = Describe("Artist artwork resolution", func() {setLayout(fstest.MapFS{"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "Track 1", map[string]any{"albumartist": "Artist", "album": "Album"}),"Artist/Album/CD2/02 - Track.mp3": trackFile(2, "Track 2", map[string]any{"albumartist": "Artist", "album": "Album"}),- "Artist/artist.jpg": imageFile("artist-folder"),- "Artist/Album/artist.jpg": imageFile("album-artist"),+ "Artist/artist.jpg": smallPNG("artist-folder"),+ "Artist/Album/artist.jpg": smallPNG("album-artist"),})scan()-- ar := soleArtist()- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")})})@@ -136,14 +124,11 @@ var _ = Describe("Artist artwork resolution", func() {"Artist/Album1/CD1/01 - Track.mp3": trackFile(1, "Track 1", map[string]any{"albumartist": "Artist", "album": "Album1"}),"Artist/Album1/CD2/02 - Track.mp3": trackFile(2, "Track 2", map[string]any{"albumartist": "Artist", "album": "Album1"}),"Artist/Album2/03 - Track.mp3": trackFile(3, "Track 3", map[string]any{"albumartist": "Artist", "album": "Album2"}),- "Artist/artist.jpg": imageFile("artist-folder"),- "Artist/Album1/artist.jpg": imageFile("album-artist"),+ "Artist/artist.jpg": smallPNG("artist-folder"),+ "Artist/Album1/artist.jpg": smallPNG("album-artist"),})scan()-- ar := soleArtist()- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")})})@@ -164,14 +149,11 @@ var _ = Describe("Artist artwork resolution", func() {"Artist/Album1/CD2/02 - Track.mp3": trackFile(2, "Track 2", map[string]any{"albumartist": "Artist", "album": "Album1"}),"Artist/Album2/CD1/03 - Track.mp3": trackFile(3, "Track 3", map[string]any{"albumartist": "Artist", "album": "Album2"}),"Artist/Album2/CD2/04 - Track.mp3": trackFile(4, "Track 4", map[string]any{"albumartist": "Artist", "album": "Album2"}),- "Artist/artist.jpg": imageFile("artist-folder"),- "Artist/Album1/artist.jpg": imageFile("album-artist"),+ "Artist/artist.jpg": smallPNG("artist-folder"),+ "Artist/Album1/artist.jpg": smallPNG("album-artist"),})scan()-- ar := soleArtist()- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")})})@@ -189,18 +171,19 @@ var _ = Describe("Artist artwork resolution", func() {conf.Server.ArtistArtPriority = "artist.*, album/artist.*, external"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),- "Artist/artist.jpg": imageFile("artist-folder"),+ "Artist/artist.jpg": smallPNG("artist-folder"),})scan()ar := soleArtist()uploaded := ar.ID + "_upload.jpg"- writeUploadedImage(consts.EntityArtist, uploaded, imageBytes("artist-uploaded"))+ writeUploadedImage(consts.EntityArtist, uploaded, pngBytes("artist-uploaded"))ar.UploadedImage = uploaded- Expect(ds.Artist(ctx).Put(&ar)).To(Succeed())+ Expect(rds.Artist(rctx).Put(&ar)).To(Succeed())- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-uploaded")))+ ia := acquire(model.KindArtistArtwork, ar.ID)+ Expect(ia.Source).To(Equal("upload"))+ Expect(serveBytes(model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil))).To(Equal(pngBytes("artist-uploaded")))})})@@ -213,13 +196,36 @@ var _ = Describe("Artist artwork resolution", func() {conf.Server.ArtistArtPriority = "album/artist.*, external"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),- "Artist/Album/artist.jpg": imageFile("album-artist"),+ "Artist/Album/artist.jpg": smallPNG("album-artist"),+ })+ scan()+ expectArtistFolder(soleArtist(), "Artist/Album/artist.jpg")+ })+ })++ // resolveArtist only samples albums where this artist is the SOLE album artist, so a+ // collaboration or compilation never donates its images as the artist's own.+ When("the artist's only album is credited to two album artists", func() {+ // Artist/+ // └── Collab Album/ (album artists: "Artist" + a collaborator)+ // ├── 01 - Track.mp3+ // └── artist.jpg ← must NOT become the artist image+ It("ignores the album's images and settles absent", func() {+ conf.Server.ArtistArtPriority = "album/artist.*"+ // " / " is a default artists split separator, so this single tag yields two album artists.+ setLayout(fstest.MapFS{+ "Artist/Collab Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist / Collaborator"}),+ "Artist/Collab Album/artist.jpg": smallPNG("collab-artist"),})scan()+ Expect(firstAlbum().Participants[model.RoleAlbumArtist]).To(HaveLen(2),+ "sanity check: the album must be credited to two album artists")ar := soleArtist()- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)- Expect(readArtwork(artID)).To(Equal(imageBytes("album-artist")))+ ia := acquire(model.KindArtistArtwork, ar.ID)+ Expect(ia.Hash).To(BeEmpty())+ Expect(serveErr(model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil))).+ To(MatchError(artwork.ErrUnavailable))})})@@ -232,7 +238,7 @@ var _ = Describe("Artist artwork resolution", func() {// └── 01 - Track.mp3 (no artist.* present in library)It("returns the image from the configured artist image folder", func() {imgFolder := GinkgoT().TempDir()- Expect(os.WriteFile(filepath.Join(imgFolder, "Artist.jpg"), imageBytes("image-folder"), 0600)).To(Succeed())+ Expect(os.WriteFile(filepath.Join(imgFolder, "Artist.jpg"), pngBytes("image-folder"), 0o600)).To(Succeed())conf.Server.ArtistImageFolder = imgFolderconf.Server.ArtistArtPriority = "image-folder, artist.*, album/artist.*"@@ -242,15 +248,16 @@ var _ = Describe("Artist artwork resolution", func() {scan()ar := soleArtist()- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)- Expect(readArtwork(artID)).To(Equal(imageBytes("image-folder")))+ ia := acquire(model.KindArtistArtwork, ar.ID)+ Expect(ia.Source).To(Equal("folder"))+ Expect(serveBytes(model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil))).To(Equal(pngBytes("image-folder")))})})})func soleArtist() model.Artist {GinkgoHelper()- artists, err := ds.Artist(ctx).GetAll(model.QueryOptions{+ artists, err := rds.Artist(rctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"artist.name": "Artist"},})Expect(err).ToNot(HaveOccurred())diff --git a/core/artwork/e2e/disc_test.go b/core/artwork/e2e/disc_test.goindex 667079458..5fdd5f27b 100644--- a/core/artwork/e2e/disc_test.go+++ b/core/artwork/e2e/disc_test.go@@ -1,18 +1,20 @@-package artworke2e_test+package e2eimport ("fmt""testing/fstest""github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/core/artwork". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega")+// Disc art is a serve-time read through the library FS (no worker state row), so per-disc images+// are asserted byte-for-byte, while album-root covers are asserted on the state row.var _ = Describe("Disc artwork resolution", func() {BeforeEach(func() {- setupHarness()+ setupResolutionHarness()})When("the album is single-disc with a disc1.jpg in the only folder", func() {@@ -24,32 +26,25 @@ var _ = Describe("Disc artwork resolution", func() {conf.Server.DiscArtPriority = "disc*.*, cd*.*, cover.*, folder.*, front.*, embedded"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/disc1.jpg": imageFile("disc1-image"),+ "Artist/Album/disc1.jpg": smallPNG("disc1-image"),})scan()-- al := firstAlbum()- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)- Expect(readArtwork(discID)).To(Equal(imageBytes("disc1-image")))+ expectDiscImage(firstAlbum(), 1, "disc1-image")})})When("the album has no per-disc image and no album cover", func() {// Artist/// └── Album/- // └── 01 - Track.mp3 (no disc or album art — returns ErrUnavailable)- It("returns ErrUnavailable for the disc lookup", func() {+ // └── 01 - Track.mp3 (no disc or album art — nothing to serve)+ It("reports the disc lookup as unavailable", func() {conf.Server.DiscArtPriority = "disc*.*, cd*.*"conf.Server.CoverArtPriority = "cover.*, folder.*"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),})scan()-- al := firstAlbum()- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)- _, err := readArtworkOrErr(discID)- Expect(err).To(HaveOccurred())+ Expect(serveErr(discArtID(firstAlbum(), 1))).To(MatchError(artwork.ErrUnavailable))})})@@ -63,13 +58,10 @@ var _ = Describe("Disc artwork resolution", func() {conf.Server.CoverArtPriority = defaultCoverPrioritysetLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/cover.jpg": imageFile("album-cover"),+ "Artist/Album/cover.jpg": smallPNG("album-cover"),})scan()-- al := firstAlbum()- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)- Expect(readArtwork(discID)).To(Equal(imageBytes("album-cover")))+ expectDiscImage(firstAlbum(), 1, "album-cover")})})@@ -83,14 +75,11 @@ var _ = Describe("Disc artwork resolution", func() {conf.Server.DiscArtPriority = "disc*.*"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/disc1.jpg": imageFile("disc-one"),- "Artist/Album/disc10.jpg": imageFile("disc-ten"),+ "Artist/Album/disc1.jpg": smallPNG("disc-one"),+ "Artist/Album/disc10.jpg": smallPNG("disc-ten"),})scan()-- al := firstAlbum()- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)- Expect(readArtwork(discID)).To(Equal(imageBytes("disc-one")))+ expectDiscImage(firstAlbum(), 1, "disc-one")})})@@ -108,14 +97,11 @@ var _ = Describe("Disc artwork resolution", func() {setLayout(fstest.MapFS{"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),- "Artist/Album/CD1/disc1.jpg": imageFile("disc-1"),- "Artist/Album/CD2/disc2.jpg": imageFile("disc-2"),+ "Artist/Album/CD1/disc1.jpg": smallPNG("disc-1"),+ "Artist/Album/CD2/disc2.jpg": smallPNG("disc-2"),})scan()-- al := firstAlbum()- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 2), &al.UpdatedAt)- Expect(readArtwork(discID)).To(Equal(imageBytes("disc-2")))+ expectDiscImage(firstAlbum(), 2, "disc-2")})})@@ -136,14 +122,11 @@ var _ = Describe("Disc artwork resolution", func() {setLayout(fstest.MapFS{"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),- "Artist/Album/CD1/disc1.jpg": imageFile("disc-1"),- "Artist/Album/CD2/cd2.png": imageFile("cd-2"),+ "Artist/Album/CD1/disc1.jpg": smallPNG("disc-1"),+ "Artist/Album/CD2/cd2.png": smallPNG("cd-2"),})scan()-- al := firstAlbum()- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 2), &al.UpdatedAt)- Expect(readArtwork(discID)).To(Equal(imageBytes("cd-2")))+ expectDiscImage(firstAlbum(), 2, "cd-2")})})@@ -161,14 +144,11 @@ var _ = Describe("Disc artwork resolution", func() {setLayout(fstest.MapFS{"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),- "Artist/Album/CD1/cover.jpg": imageFile("disc1-cover"),- "Artist/Album/CD2/cover.jpg": imageFile("disc2-cover"),+ "Artist/Album/CD1/cover.jpg": smallPNG("disc1-cover"),+ "Artist/Album/CD2/cover.jpg": smallPNG("disc2-cover"),})scan()-- al := firstAlbum()- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)- Expect(readArtwork(discID)).To(Equal(imageBytes("disc1-cover")))+ expectDiscImage(firstAlbum(), 1, "disc1-cover")})})@@ -188,17 +168,15 @@ var _ = Describe("Disc artwork resolution", func() {setLayout(fstest.MapFS{"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),- "Artist/Album/CD1/disc1.jpg": imageFile("disc-1"),- "Artist/Album/CD2/cd2.png": imageFile("cd-2"),- "Artist/Album/cover.jpg": imageFile("album-cover"),+ "Artist/Album/CD1/disc1.jpg": smallPNG("disc-1"),+ "Artist/Album/CD2/cd2.png": smallPNG("cd-2"),+ "Artist/Album/cover.jpg": smallPNG("album-cover"),})scan()al := firstAlbum()for _, n := range []int{1, 2} {- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, n), &al.UpdatedAt)- Expect(readArtwork(discID)).To(Equal(imageBytes("album-cover")),- "disc %d should use the album cover when DiscArtPriority is empty", n)+ expectDiscImage(al, n, "album-cover")}})})@@ -223,17 +201,15 @@ var _ = Describe("Disc artwork resolution", func() {"Artist/Album/disc1/02 - Track.mp3": trackFile(2, "T2", map[string]any{"disc": "1"}),"Artist/Album/disc2/01 - Track.mp3": trackFile(1, "T3", map[string]any{"disc": "2"}),"Artist/Album/disc2/02 - Track.mp3": trackFile(2, "T4", map[string]any{"disc": "2"}),- "Artist/Album/disc1/disc1.jpg": imageFile("disc-1"),- "Artist/Album/disc2/cd2.png": imageFile("cd-2"),- "Artist/Album/cover.jpg": imageFile("album-root"),+ "Artist/Album/disc1/disc1.jpg": smallPNG("disc-1"),+ "Artist/Album/disc2/cd2.png": smallPNG("cd-2"),+ "Artist/Album/cover.jpg": smallPNG("album-root"),})scan()al := firstAlbum()- disc1ID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)- disc2ID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 2), &al.UpdatedAt)- Expect(readArtwork(disc1ID)).To(Equal(imageBytes("disc-1")))- Expect(readArtwork(disc2ID)).To(Equal(imageBytes("cd-2")))+ expectDiscImage(al, 1, "disc-1")+ expectDiscImage(al, 2, "cd-2")})})@@ -246,13 +222,10 @@ var _ = Describe("Disc artwork resolution", func() {conf.Server.DiscArtPriority = "discsubtitle"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1", "discsubtitle": "Bonus Tracks"}),- "Artist/Album/Bonus Tracks.jpg": imageFile("bonus-tracks"),+ "Artist/Album/Bonus Tracks.jpg": smallPNG("bonus-tracks"),})scan()-- al := firstAlbum()- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)- Expect(readArtwork(discID)).To(Equal(imageBytes("bonus-tracks")))+ expectDiscImage(firstAlbum(), 1, "bonus-tracks")})})@@ -286,26 +259,22 @@ var _ = Describe("Disc artwork resolution", func() {"Disc 12 (History of the Grateful Dead, Volume One (Bear's Choice))",}layout := fstest.MapFS{- "Pop; Rock/Grateful Dead/(2001) The Golden Road/cover.jpg": imageFile("album-root-cover"),+ "Pop; Rock/Grateful Dead/(2001) The Golden Road/cover.jpg": smallPNG("album-root-cover"),}for i, name := range discNames {discNum := i + 1prefix := fmt.Sprintf("Pop; Rock/Grateful Dead/(2001) The Golden Road/%s/", name)layout[prefix+"01 - Track.mp3"] = trackFile(1, fmt.Sprintf("T%d", discNum), map[string]any{"disc": fmt.Sprintf("%d", discNum)})- layout[prefix+"folder.jpg"] = imageFile(fmt.Sprintf("disc-%02d-folder", discNum))+ layout[prefix+"folder.jpg"] = smallPNG(fmt.Sprintf("disc-%02d-folder", discNum))}setLayout(layout)scan()al := firstAlbum()-- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root-cover")))-+ expectAlbumFolderCover(al, "(2001) The Golden Road/cover.jpg")for i := range discNames {discNum := i + 1- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, discNum), &al.UpdatedAt)- Expect(readArtwork(discID)).To(Equal(imageBytes(fmt.Sprintf("disc-%02d-folder", discNum))),- "disc %d should use its own folder.jpg", discNum)+ expectDiscImage(al, discNum, fmt.Sprintf("disc-%02d-folder", discNum))}})})@@ -328,24 +297,20 @@ var _ = Describe("Disc artwork resolution", func() {conf.Server.DiscArtPriority = defaultDiscPriorityconf.Server.CoverArtPriority = defaultCoverPrioritylayout := fstest.MapFS{- "Album/cover.jpg": imageFile("album-root-cover"),+ "Album/cover.jpg": smallPNG("album-root-cover"),}for i := 1; i <= 3; i++ {prefix := fmt.Sprintf("Album/Disc %02d/", i)layout[prefix+"01 - Track.mp3"] = trackFile(1, fmt.Sprintf("T%d", i), map[string]any{"disc": fmt.Sprintf("%d", i)})- layout[prefix+"folder.jpg"] = imageFile(fmt.Sprintf("disc-%02d-folder", i))+ layout[prefix+"folder.jpg"] = smallPNG(fmt.Sprintf("disc-%02d-folder", i))}setLayout(layout)scan()al := firstAlbum()-- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root-cover")))-+ expectAlbumFolderCover(al, "Album/cover.jpg")for i := 1; i <= 3; i++ {- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, i), &al.UpdatedAt)- Expect(readArtwork(discID)).To(Equal(imageBytes(fmt.Sprintf("disc-%02d-folder", i))),- "disc %d should use its own folder.jpg", i)+ expectDiscImage(al, i, fmt.Sprintf("disc-%02d-folder", i))}})})@@ -359,13 +324,10 @@ var _ = Describe("Disc artwork resolution", func() {conf.Server.DiscArtPriority = "discsubtitle, cover.*"setLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1", "discsubtitle": "Bonus Tracks"}),- "Artist/Album/cover.jpg": imageFile("cover"),+ "Artist/Album/cover.jpg": smallPNG("cover"),})scan()-- al := firstAlbum()- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)- Expect(readArtwork(discID)).To(Equal(imageBytes("cover")))+ expectDiscImage(firstAlbum(), 1, "cover")})})})diff --git a/core/artwork/e2e/e2e_suite_test.go b/core/artwork/e2e/e2e_suite_test.gonew file mode 100644index 000000000..8881da3a6--- /dev/null+++ b/core/artwork/e2e/e2e_suite_test.go@@ -0,0 +1,83 @@+// Package e2e exercises the artwork pipeline end to end: the real Worker drains the queue and the+// real Service serves the result, over a real ImageStore and real library files.+package e2e++import (+ "context"+ "io"+ "os"+ "path/filepath"+ "testing"+ "time"++ _ "github.com/navidrome/navidrome/adapters/gotaglib" // registers the "taglib" local-storage extractor+ "github.com/navidrome/navidrome/core/artwork"+ _ "github.com/navidrome/navidrome/core/storage/local"+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++func TestArtworkE2E(t *testing.T) {+ tests.Init(t, false)+ log.SetLevel(log.LevelFatal)+ RegisterFailHandler(Fail)+ RunSpecs(t, "Artwork Pipeline E2E Suite")+}++// Fixtures relative to the project root (tests.Init chdirs there).+const (+ coverFixture = "tests/fixtures/artist/an-album/cover.jpg"+ mp3Fixture = "tests/fixtures/artist/an-album/test.mp3"+ artistPngFixture = "tests/fixtures/artist/an-album/artist.png"+ albumFolderPath = "tests/fixtures/artist/an-album"+)++func readFixture(rel string) []byte {+ GinkgoHelper()+ data, err := os.ReadFile(rel)+ Expect(err).ToNot(HaveOccurred(), "reading fixture %q", rel)+ return data+}++func readAll(img *artwork.Image) []byte {+ GinkgoHelper()+ Expect(img).ToNot(BeNil())+ defer img.Close()+ data, err := io.ReadAll(img)+ Expect(err).ToNot(HaveOccurred())+ return data+}++func runWorkerUntil(ctx context.Context, worker *artwork.Worker, until func() bool) {+ GinkgoHelper()+ runCtx, cancel := context.WithCancel(ctx)+ done := make(chan error, 1)+ go func() { done <- worker.Run(runCtx) }()+ Eventually(until, 5*time.Second, 10*time.Millisecond).Should(BeTrue())+ cancel()+ Eventually(done, 2*time.Second).Should(Receive(BeNil()))+}++type fakeFolderRepo struct {+ model.FolderRepository+ result []model.Folder+}++func (f *fakeFolderRepo) GetAll(...model.QueryOptions) ([]model.Folder, error) { return f.result, nil }++func (f *fakeFolderRepo) HasAudioOutsideFolders(model.Folder, []string) (bool, error) {+ return false, nil+}++func (f *fakeFolderRepo) Get(string) (*model.Folder, error) { return nil, model.ErrNotFound }++func writeUpload(entityType, name, srcFixture string) string {+ GinkgoHelper()+ dst := model.UploadedImagePath(entityType, name)+ Expect(os.MkdirAll(filepath.Dir(dst), 0o755)).To(Succeed())+ Expect(os.WriteFile(dst, readFixture(srcFixture), 0o600)).To(Succeed())+ return name+}diff --git a/core/artwork/e2e/helpers_test.go b/core/artwork/e2e/helpers_test.godeleted file mode 100644index ddc926cec..000000000--- a/core/artwork/e2e/helpers_test.go+++ /dev/null@@ -1,184 +0,0 @@-package artworke2e_test--import (- "bytes"- "context"- _ "embed"- "errors"- "hash/fnv"- "image"- "image/color"- "image/png"- "io"- "maps"- "net/url"- "os"- "path/filepath"- "testing/fstest"-- "github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core/external"- "github.com/navidrome/navidrome/core/storage/storagetest"- "github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/resources"- "github.com/navidrome/navidrome/tests"- . "github.com/onsi/ginkgo/v2"- . "github.com/onsi/gomega"- "go.senan.xyz/taglib"-)--// realMP3WithEmbeddedArt is the bytes of the canonical test fixture that-// contains a valid MP3 stream with an embedded picture. Used in the-// embedded-art e2e scenarios where FakeFS's JSON-encoded tag data isn't-// readable by taglib. Swap this into fakeFS.MapFS *after* scanning so the-// scanner still populates EmbedArtPath via the JSON-tagged track, and the-// artwork reader gets real bytes when it calls libFS.Open.-//-//go:embed testdata/embedded_art.mp3-var realMP3WithEmbeddedArt []byte--// embeddedArtBytes is the exact image payload that the artwork reader will-// extract from realMP3WithEmbeddedArt. Computed once via taglib so tests can-// assert byte-for-byte equality — if this ever differs it means the reader-// pulled from a different source.-var embeddedArtBytes = extractEmbeddedArt(realMP3WithEmbeddedArt)--func extractEmbeddedArt(mp3 []byte) []byte {- tf, err := taglib.OpenStream(bytes.NewReader(mp3))- if err != nil {- panic("embedded-art fixture: taglib.OpenStream failed: " + err.Error())- }- defer tf.Close()- images := tf.Properties().Images- if len(images) == 0 {- panic("embedded-art fixture has no embedded images")- }- data, err := tf.Image(0)- if err != nil || len(data) == 0 {- panic("embedded-art fixture: could not read image 0")- }- return data-}--// replaceWithRealMP3 swaps the FakeFS entry at the given library-relative-// path so libFS.Open returns an MP3 stream taglib can parse.-func replaceWithRealMP3(relPath string) {- GinkgoHelper()- fakeFS.MapFS[relPath] = &fstest.MapFile{Data: realMP3WithEmbeddedArt}-}--// placeholderBytes returns the bundled album-placeholder image bytes — the-// same stream the artwork reader emits when every source falls through.-func placeholderBytes() []byte {- GinkgoHelper()- r, err := resources.FS().Open(consts.PlaceholderAlbumArt)- Expect(err).ToNot(HaveOccurred())- defer r.Close()- data, err := io.ReadAll(r)- Expect(err).ToNot(HaveOccurred())- return data-}--// writeUploadedImage drops `filename` into <DataFolder>/artwork/<entity>/ with-// the given bytes, matching the on-disk layout expected by-// model.UploadedImagePath.-func writeUploadedImage(entity, filename string, data []byte) {- GinkgoHelper()- dir := filepath.Dir(model.UploadedImagePath(entity, filename))- Expect(os.MkdirAll(dir, 0755)).To(Succeed())- Expect(os.WriteFile(filepath.Join(dir, filename), data, 0600)).To(Succeed())-}--func newNoopFFmpeg() *tests.MockFFmpeg {- ff := tests.NewMockFFmpeg("")- ff.Error = errors.New("noop")- return ff-}--// trackFile builds a FakeFS MP3 entry with optional tag overrides.-func trackFile(num int, title string, extra ...map[string]any) *fstest.MapFile {- tags := storagetest.Track(num, title)- for _, e := range extra {- maps.Copy(tags, e)- }- return storagetest.MP3(tags)-}--// imageFile builds a label-keyed image entry. The bytes are deterministic-// per-label so tests can assert which file won.-func imageFile(label string) *fstest.MapFile {- return &fstest.MapFile{Data: []byte("image:" + label)}-}--// realPNG builds a minimal 2x2 PNG with a color derived from label. Needed by-// tests that feed the bytes into image.Decode (e.g. playlist tiled covers).-func realPNG(label string) *fstest.MapFile {- img := image.NewRGBA(image.Rect(0, 0, 2, 2))- // Derive a deterministic color per label.- h := fnv.New32a()- _, _ = h.Write([]byte(label))- sum := h.Sum32()- c := color.RGBA{R: byte(sum), G: byte(sum >> 8), B: byte(sum >> 16), A: 255}- for y := range 2 {- for x := range 2 {- img.Set(x, y, c)- }- }- var buf bytes.Buffer- Expect(png.Encode(&buf, img)).To(Succeed())- return &fstest.MapFile{Data: buf.Bytes()}-}--// imageBytes returns the bytes that imageFile(label) writes.-func imageBytes(label string) []byte { return imageFile(label).Data }--// setLayout populates fakeFS with the given map. Call after setupHarness.-// All paths must be forward-slash and relative (no leading "/").-func setLayout(files fstest.MapFS) {- GinkgoHelper()- fakeFS.SetFiles(files)-}--func readArtwork(artID model.ArtworkID) []byte {- GinkgoHelper()- r, _, err := aw.Get(ctx, artID, 0, false)- Expect(err).ToNot(HaveOccurred())- defer r.Close()- b, err := io.ReadAll(r)- Expect(err).ToNot(HaveOccurred())- return b-}--func readArtworkOrErr(artID model.ArtworkID) ([]byte, error) {- r, _, err := aw.Get(ctx, artID, 0, false)- if err != nil {- return nil, err- }- defer r.Close()- return io.ReadAll(r)-}--// noopProvider implements external.Provider with not-found returns so the-// "external" priority entry never produces a result.-type noopProvider struct{}--func (n *noopProvider) UpdateAlbumInfo(context.Context, string) (*model.Album, error) {- return nil, model.ErrNotFound-}-func (n *noopProvider) UpdateArtistInfo(context.Context, string, int, bool) (*model.Artist, error) {- return nil, model.ErrNotFound-}-func (n *noopProvider) SimilarSongs(context.Context, string, int) (model.MediaFiles, error) {- return nil, nil-}-func (n *noopProvider) TopSongs(context.Context, string, string, int) (model.MediaFiles, error) {- return nil, nil-}-func (n *noopProvider) ArtistImage(context.Context, string) (*url.URL, error) {- return nil, model.ErrNotFound-}-func (n *noopProvider) AlbumImage(context.Context, string) (*url.URL, error) {- return nil, model.ErrNotFound-}--var _ external.Provider = (*noopProvider)(nil)diff --git a/core/artwork/e2e/mediafile_test.go b/core/artwork/e2e/mediafile_test.goindex 1f43a3827..d26756dcd 100644--- a/core/artwork/e2e/mediafile_test.go+++ b/core/artwork/e2e/mediafile_test.go@@ -1,4 +1,4 @@-package artworke2e_test+package e2eimport ("testing/fstest"@@ -17,13 +17,11 @@ import (// 2. For multi-disc albums, disc-level artwork// 3. Album cover art//-// FakeFS cannot synthesize taglib-readable embedded JPEGs, so scenario (1)-// is covered by the existing embedded-art album tests (which currently-// Skip under FakeFS). The tests below cover (2) and (3): the fallback-// chain for tracks without embedded art.-var _ = Describe("MediaFile artwork fallback", func() {+// Embedded art lands in the content-addressed store (asserted byte-for-byte); disc-level art is a+// serve-time read through the library FS.+var _ = Describe("MediaFile artwork resolution", func() {BeforeEach(func() {- setupHarness()+ setupResolutionHarness()})When("a multi-disc album track has no embedded art", func() {@@ -42,14 +40,14 @@ var _ = Describe("MediaFile artwork fallback", func() {setLayout(fstest.MapFS{"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),- "Artist/Album/CD1/disc1.jpg": imageFile("disc-1"),- "Artist/Album/CD2/disc2.jpg": imageFile("disc-2"),- "Artist/Album/cover.jpg": imageFile("album-root"),+ "Artist/Album/CD1/disc1.jpg": smallPNG("disc-1"),+ "Artist/Album/CD2/disc2.jpg": smallPNG("disc-2"),+ "Artist/Album/cover.jpg": smallPNG("album-root"),})scan()mf := mediafileOn("Artist/Album/CD2/01 - Track.mp3")- Expect(readArtwork(mf.CoverArtID())).To(Equal(imageBytes("disc-2")))+ Expect(serveBytes(mf.CoverArtID())).To(Equal(pngBytes("disc-2")))})})@@ -63,12 +61,12 @@ var _ = Describe("MediaFile artwork fallback", func() {conf.Server.DiscArtPriority = defaultDiscPrioritysetLayout(fstest.MapFS{"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),- "Artist/Album/cover.jpg": imageFile("album-cover"),+ "Artist/Album/cover.jpg": smallPNG("album-cover"),})scan()mf := mediafileOn("Artist/Album/01 - Track.mp3")- Expect(readArtwork(mf.CoverArtID())).To(Equal(imageBytes("album-cover")))+ Expect(serveBytes(mf.CoverArtID())).To(Equal(pngBytes("album-cover")))})})@@ -86,19 +84,60 @@ var _ = Describe("MediaFile artwork fallback", func() {setLayout(fstest.MapFS{"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),- "Artist/Album/cover.jpg": imageFile("album-root"),+ "Artist/Album/cover.jpg": smallPNG("album-root"),})scan()mf := mediafileOn("Artist/Album/CD2/01 - Track.mp3")- Expect(readArtwork(mf.CoverArtID())).To(Equal(imageBytes("album-root")))+ Expect(serveBytes(mf.CoverArtID())).To(Equal(pngBytes("album-root")))+ })+ })++ When("a track has its own embedded art", func() {+ // Artist/+ // └── Album/+ // └── 01 - Track.mp3 ← has embedded picture (wins over every fallback)+ It("resolves the track's embedded image into the store", func() {+ conf.Server.CoverArtPriority = defaultCoverPriority+ setLayout(fstest.MapFS{+ "Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"has_picture": "true"}),+ })+ scan()+ replaceWithRealMP3("Artist/Album/01 - Track.mp3")++ mf := mediafileOn("Artist/Album/01 - Track.mp3")+ ia := acquire(model.KindMediaFileArtwork, mf.ID)+ Expect(ia.Source).To(Equal("embedded"))+ Expect(storedBytes(ia)).To(Equal(embeddedArtBytes))+ })+ })++ When("EnableMediaFileCoverArt is turned off after the track was scanned", func() {+ // Artist/+ // └── Album/+ // ├── 01 - Track.mp3 ← has embedded picture (must NOT be served)+ // └── cover.jpg ← wins (per-track art disabled at serve time)+ It("serves the album cover instead of the track's embedded art", func() {+ conf.Server.CoverArtPriority = defaultCoverPriority+ setLayout(fstest.MapFS{+ "Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"has_picture": "true"}),+ "Artist/Album/cover.jpg": smallPNG("album-cover"),+ })+ scan()+ replaceWithRealMP3("Artist/Album/01 - Track.mp3")++ // The setting is not part of the artwork fingerprint, so it must be honored at serve time.+ conf.Server.EnableMediaFileCoverArt = false+ mf := mediafileOn("Artist/Album/01 - Track.mp3")+ trackArtID := model.NewArtworkID(model.KindMediaFileArtwork, mf.ID, nil)+ Expect(serveBytes(trackArtID)).To(Equal(pngBytes("album-cover")))})})})func mediafileOn(relPath string) model.MediaFile {GinkgoHelper()- mfs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{+ mfs, err := rds.MediaFile(rctx).GetAll(model.QueryOptions{Filters: squirrel.Like{"media_file.path": relPath},})Expect(err).ToNot(HaveOccurred())diff --git a/core/artwork/e2e/playlist_test.go b/core/artwork/e2e/playlist_test.goindex d28efca8e..f5ac8a7e3 100644--- a/core/artwork/e2e/playlist_test.go+++ b/core/artwork/e2e/playlist_test.go@@ -1,13 +1,16 @@-package artworke2e_test+package e2eimport (+ "image/color""os""path/filepath""testing/fstest""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/utils/slice". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega")@@ -17,14 +20,13 @@ import (// 2. Sidecar image next to the .m3u file (same basename, any image ext)// 3. ExternalImageURL (http/https requires EnableM3UExternalAlbumArt; local path always allowed)// 4. Generated 2x2 tiled cover from the playlist's albums-// 5. Album placeholder image+// 5. Absent//-// The library FS is FakeFS, but uploaded/sidecar/local-external images are-// real files on disk — the reader reads them via os.Open, so the tests-// place them in a real tempdir under DataFolder.+// The library is an in-memory FS, but uploaded/sidecar/local-external images are real files on+// disk — the resolver reads them via os.Open, so those tests place them in a real tempdir.var _ = Describe("Playlist artwork resolution", func() {BeforeEach(func() {- setupHarness()+ setupResolutionHarness()})When("a playlist has an uploaded image", func() {@@ -33,11 +35,12 @@ var _ = Describe("Playlist artwork resolution", func() {// └── playlist/// └── pl-1_upload.jpg ← matched by UploadedImagePath() (highest priority)It("returns the uploaded image bytes", func() {- writeUploadedImage(consts.EntityPlaylist, "pl-1_upload.jpg", imageBytes("playlist-upload"))-+ writeUploadedImage(consts.EntityPlaylist, "pl-1_upload.jpg", pngBytes("playlist-upload"))pl := putPlaylist(model.Playlist{ID: "pl-1", Name: "Test", UploadedImage: "pl-1_upload.jpg"})- Expect(readArtwork(pl.CoverArtID())).To(Equal(imageBytes("playlist-upload")))+ ia := acquire(model.KindPlaylistArtwork, pl.ID)+ Expect(ia.Source).To(Equal("upload"))+ Expect(serveBytes(pl.CoverArtID())).To(Equal(pngBytes("playlist-upload")))})})@@ -48,12 +51,14 @@ var _ = Describe("Playlist artwork resolution", func() {It("returns the sidecar image", func() {dir := GinkgoT().TempDir()m3uPath := filepath.Join(dir, "MyList.m3u")- Expect(os.WriteFile(m3uPath, []byte("#EXTM3U\n"), 0600)).To(Succeed())- Expect(os.WriteFile(filepath.Join(dir, "MyList.jpg"), imageBytes("sidecar"), 0600)).To(Succeed())+ Expect(os.WriteFile(m3uPath, []byte("#EXTM3U\n"), 0o600)).To(Succeed())+ Expect(os.WriteFile(filepath.Join(dir, "MyList.jpg"), pngBytes("sidecar"), 0o600)).To(Succeed())pl := putPlaylist(model.Playlist{ID: "pl-2", Name: "MyList", Path: m3uPath})- Expect(readArtwork(pl.CoverArtID())).To(Equal(imageBytes("sidecar")))+ ia := acquire(model.KindPlaylistArtwork, pl.ID)+ Expect(ia.Source).To(Equal("folder"))+ Expect(serveBytes(pl.CoverArtID())).To(Equal(pngBytes("sidecar")))})})@@ -64,12 +69,12 @@ var _ = Describe("Playlist artwork resolution", func() {It("matches case-insensitively", func() {dir := GinkgoT().TempDir()m3uPath := filepath.Join(dir, "MyList.m3u")- Expect(os.WriteFile(m3uPath, []byte("#EXTM3U\n"), 0600)).To(Succeed())- Expect(os.WriteFile(filepath.Join(dir, "MyList.PNG"), imageBytes("sidecar-png"), 0600)).To(Succeed())+ Expect(os.WriteFile(m3uPath, []byte("#EXTM3U\n"), 0o600)).To(Succeed())+ Expect(os.WriteFile(filepath.Join(dir, "MyList.PNG"), pngBytes("sidecar-png"), 0o600)).To(Succeed())pl := putPlaylist(model.Playlist{ID: "pl-3", Name: "MyList", Path: m3uPath})- Expect(readArtwork(pl.CoverArtID())).To(Equal(imageBytes("sidecar-png")))+ Expect(serveBytes(pl.CoverArtID())).To(Equal(pngBytes("sidecar-png")))})})@@ -80,31 +85,39 @@ var _ = Describe("Playlist artwork resolution", func() {conf.Server.EnableM3UExternalAlbumArt = false // local paths bypass the toggledir := GinkgoT().TempDir()imgPath := filepath.Join(dir, "cover.jpg")- Expect(os.WriteFile(imgPath, imageBytes("external-local"), 0600)).To(Succeed())+ Expect(os.WriteFile(imgPath, pngBytes("external-local"), 0o600)).To(Succeed())pl := putPlaylist(model.Playlist{ID: "pl-4", Name: "WithExt", ExternalImageURL: imgPath})- Expect(readArtwork(pl.CoverArtID())).To(Equal(imageBytes("external-local")))+ Expect(serveBytes(pl.CoverArtID())).To(Equal(pngBytes("external-local")))})})When("a playlist has an http(s) ExternalImageURL and EnableM3UExternalAlbumArt is false", func() {- // (no local files — http source is gated off, reader falls through to placeholder)- It("skips the URL and falls through to the bundled placeholder", func() {+ // (no local files — the http source is gated off, so resolution settles absent)+ It("skips the URL and settles absent", func() {conf.Server.EnableM3UExternalAlbumArt = false-pl := putPlaylist(model.Playlist{ID: "pl-5", Name: "HttpGated", ExternalImageURL: "https://example.com/cover.jpg"})- Expect(readArtwork(pl.CoverArtID())).To(Equal(placeholderBytes()))+ ia := acquire(model.KindPlaylistArtwork, pl.ID)+ Expect(ia.Hash).To(BeEmpty())+ Expect(serveErr(pl.CoverArtID())).To(MatchError(artwork.ErrUnavailable))++ img, err := rsvc.GetOrPlaceholder(rctx, pl.CoverArtID().String(), 0, false)+ Expect(err).ToNot(HaveOccurred())+ defer img.Close()+ Expect(img.Placeholder).To(BeTrue())})})When("a playlist has no images and no tracks", func() {- // (reader falls all the way through to the bundled album placeholder)- It("returns the album placeholder", func() {+ // (no uploaded/sidecar/external image and no album art to sample)+ It("settles absent", func() {pl := putPlaylist(model.Playlist{ID: "pl-6", Name: "Empty"})- Expect(readArtwork(pl.CoverArtID())).To(Equal(placeholderBytes()))+ ia := acquire(model.KindPlaylistArtwork, pl.ID)+ Expect(ia.Hash).To(BeEmpty())+ Expect(serveErr(pl.CoverArtID())).To(MatchError(artwork.ErrUnavailable))})})@@ -113,37 +126,79 @@ var _ = Describe("Playlist artwork resolution", func() {// Artist/// ├── AlbumA/// │ ├── 01 - Track.mp3- // │ └── cover.png (real PNG — wins as tile 1 source)+ // │ └── cover.png ← tile 1 source// └── AlbumB/// ├── 01 - Track.mp3- // └── cover.png (real PNG — wins as tile 2 source)- // Playlist "pl-7" references tracks from both albums, so the reader- // generates a 2x2 tiled cover from 2 distinct album art tiles (the- // tiled generator mirrors when it has fewer than 4 unique tiles).+ // └── cover.png ← tile 2 source+ // Playlist "pl-7" references tracks from both albums, so the worker generates a tiled+ // cover from 2 distinct album art tiles (mirrored to fill the 2x2 grid).It("generates a tiled cover from album art", func() {conf.Server.CoverArtPriority = "cover.*"setLayout(fstest.MapFS{"Artist/AlbumA/01 - Track.mp3": trackFile(1, "TA", map[string]any{"album": "AlbumA"}),- "Artist/AlbumA/cover.png": realPNG("albumA"),+ "Artist/AlbumA/cover.png": smallPNG("albumA"),"Artist/AlbumB/01 - Track.mp3": trackFile(1, "TB", map[string]any{"album": "AlbumB"}),- "Artist/AlbumB/cover.png": realPNG("albumB"),+ "Artist/AlbumB/cover.png": smallPNG("albumB"),})scan()- // Pull the scanned mediafile IDs so we can attach them to the playlist.- mfs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{})+ mfs, err := rds.MediaFile(rctx).GetAll(model.QueryOptions{})Expect(err).ToNot(HaveOccurred())Expect(mfs).To(HaveLen(2))pl := model.Playlist{ID: "pl-7", Name: "Mix", OwnerID: "admin-1"}pl.AddMediaFilesByID([]string{mfs[0].ID, mfs[1].ID})- Expect(ds.Playlist(ctx).Put(&pl)).To(Succeed())+ Expect(rds.Playlist(rctx).Put(&pl)).To(Succeed())- data := readArtwork(pl.CoverArtID())- // The tiled cover is a PNG-encoded 600x600 image (tileSize const).- // Exact bytes vary (random album order), so assert format + non-trivial size.+ ia := acquire(model.KindPlaylistArtwork, pl.ID)+ Expect(ia.Source).To(Equal("generated"))+ data := storedBytes(ia)+ // The tiled cover is a PNG-encoded image; exact bytes vary (random album order).Expect(data[:8]).To(Equal([]byte{0x89, 'P', 'N', 'G', 0x0d, 0x0a, 0x1a, 0x0a}))- Expect(len(data)).To(BeNumerically(">", 1000))+ // Two tiles are mirrored into the 2x2 grid as [A B B A], so opposite corners match.+ q := gridQuadrants(data)+ Expect(q[0]).To(Equal(q[3]))+ Expect(q[1]).To(Equal(q[2]))+ Expect(q[0]).ToNot(Equal(q[1]))+ })+ })++ When("a playlist has tracks from four albums, each with its own cover", func() {+ // Library:+ // Artist/+ // ├── AlbumA/{01 - Track.mp3, cover.png} ← tile 1+ // ├── AlbumB/{01 - Track.mp3, cover.png} ← tile 2+ // ├── AlbumC/{01 - Track.mp3, cover.png} ← tile 3+ // └── AlbumD/{01 - Track.mp3, cover.png} ← tile 4+ It("fills all four grid quadrants with distinct album art", func() {+ conf.Server.CoverArtPriority = "cover.*"+ layout := fstest.MapFS{}+ for _, name := range []string{"AlbumA", "AlbumB", "AlbumC", "AlbumD"} {+ layout["Artist/"+name+"/01 - Track.mp3"] = trackFile(1, "T"+name, map[string]any{"album": name})+ layout["Artist/"+name+"/cover.png"] = smallPNG(name)+ }+ setLayout(layout)+ scan()++ mfs, err := rds.MediaFile(rctx).GetAll(model.QueryOptions{})+ Expect(err).ToNot(HaveOccurred())+ Expect(mfs).To(HaveLen(4))+ ids := slice.Map(mfs, func(mf model.MediaFile) string { return mf.ID })++ pl := model.Playlist{ID: "pl-8", Name: "Four", OwnerID: "admin-1"}+ pl.AddMediaFilesByID(ids)+ Expect(rds.Playlist(rctx).Put(&pl)).To(Succeed())++ ia := acquire(model.KindPlaylistArtwork, pl.ID)+ Expect(ia.Source).To(Equal("generated"))+ q := gridQuadrants(storedBytes(ia))+ Expect([]color.RGBA{q[0], q[1], q[2], q[3]}).To(HaveLen(4))+ Expect(q[0]).ToNot(Equal(q[1]))+ Expect(q[0]).ToNot(Equal(q[2]))+ Expect(q[0]).ToNot(Equal(q[3]))+ Expect(q[1]).ToNot(Equal(q[2]))+ Expect(q[1]).ToNot(Equal(q[3]))+ Expect(q[2]).ToNot(Equal(q[3]))})})})@@ -153,6 +208,6 @@ func putPlaylist(pl model.Playlist) model.Playlist {if pl.OwnerID == "" {pl.OwnerID = "admin-1"}- Expect(ds.Playlist(ctx).Put(&pl)).To(Succeed())+ Expect(rds.Playlist(rctx).Put(&pl)).To(Succeed())return pl}diff --git a/core/artwork/e2e/radio_test.go b/core/artwork/e2e/radio_test.goindex 73ee5f377..bba85224a 100644--- a/core/artwork/e2e/radio_test.go+++ b/core/artwork/e2e/radio_test.go@@ -1,15 +1,18 @@-package artworke2e_test+package e2eimport ("github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/model". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega")+// Radio art is uploaded-image-only, with no fallback. Uploads are real files on disk, so they+// serve back byte-for-byte; a radio with no upload settles absent.var _ = Describe("Radio artwork resolution", func() {BeforeEach(func() {- setupHarness()+ setupResolutionHarness()})When("a radio has an uploaded image", func() {@@ -18,25 +21,25 @@ var _ = Describe("Radio artwork resolution", func() {// └── radio/// └── rd-1_logo.jpg ← matched by UploadedImagePath()It("returns the uploaded image bytes", func() {- writeUploadedImage(consts.EntityRadio, "rd-1_logo.jpg", imageBytes("radio-logo"))-+ writeUploadedImage(consts.EntityRadio, "rd-1_logo.jpg", pngBytes("radio-logo"))rd := model.Radio{ID: "rd-1", Name: "Test Radio", StreamUrl: "https://example.com/stream", UploadedImage: "rd-1_logo.jpg"}- Expect(ds.Radio(ctx).Put(&rd)).To(Succeed())+ Expect(rds.Radio(rctx).Put(&rd)).To(Succeed())- artID := model.NewArtworkID(model.KindRadioArtwork, rd.ID, nil)- Expect(readArtwork(artID)).To(Equal(imageBytes("radio-logo")))+ ia := acquire(model.KindRadioArtwork, rd.ID)+ Expect(ia.Source).To(Equal("upload"))+ Expect(serveBytes(model.NewArtworkID(model.KindRadioArtwork, rd.ID, nil))).To(Equal(pngBytes("radio-logo")))})})When("a radio has no uploaded image", func() {- // (no files on disk — reader has no sources to fall back to)- It("returns ErrUnavailable", func() {+ // (no files on disk — the resolver has no sources to fall back to)+ It("settles absent", func() {rd := model.Radio{ID: "rd-2", Name: "Bare Radio", StreamUrl: "https://example.com/stream"}- Expect(ds.Radio(ctx).Put(&rd)).To(Succeed())+ Expect(rds.Radio(rctx).Put(&rd)).To(Succeed())- artID := model.NewArtworkID(model.KindRadioArtwork, rd.ID, nil)- _, err := readArtworkOrErr(artID)- Expect(err).To(HaveOccurred())+ ia := acquire(model.KindRadioArtwork, rd.ID)+ Expect(ia.Hash).To(BeEmpty())+ Expect(serveErr(model.NewArtworkID(model.KindRadioArtwork, rd.ID, nil))).To(MatchError(artwork.ErrUnavailable))})})})diff --git a/core/artwork/e2e/resolution_harness_test.go b/core/artwork/e2e/resolution_harness_test.gonew file mode 100644index 000000000..1168393df--- /dev/null+++ b/core/artwork/e2e/resolution_harness_test.go@@ -0,0 +1,365 @@+package e2e++import (+ "bytes"+ "context"+ "fmt"+ "hash/fnv"+ "image"+ "image/color"+ "image/png"+ "io"+ "maps"+ "os"+ "path/filepath"+ "strings"+ "sync"+ "testing/fstest"+ "time"++ _ "github.com/navidrome/navidrome/adapters/gotaglib"+ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest"+ "github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/core/artwork"+ "github.com/navidrome/navidrome/core/metrics"+ "github.com/navidrome/navidrome/core/playlists"+ "github.com/navidrome/navidrome/core/storage/storagetest"+ "github.com/navidrome/navidrome/db"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/model/request"+ "github.com/navidrome/navidrome/persistence"+ "github.com/navidrome/navidrome/scanner"+ "github.com/navidrome/navidrome/server/events"+ "github.com/navidrome/navidrome/tests"+ "github.com/navidrome/navidrome/tests/harness"+ "github.com/navidrome/navidrome/utils/cache"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+ "go.senan.xyz/taglib"+)++const fakeLibScheme = "artworkfake"+const fakeLibPath = fakeLibScheme + ":///music"++const (+ defaultCoverPriority = "cover.*, folder.*, front.*, embedded, external"+ defaultDiscPriority = "disc*.*, cd*.*, cover.*, folder.*, front.*, discsubtitle, embedded"+)++var (+ rctx context.Context+ rds *tests.MockDataStore+ rstore *artwork.ImageStore+ rsvc artwork.Artwork+ rworker *artwork.Worker+ fakeFS *storagetest.FakeFS+)++// The go-sqlite3 singleton holds the file open for the whole suite, and Windows cannot unlink a+// file with a live handle, so the DB cannot live in Ginkgo's per-spec TempDir.+var suiteDBTempDir string++// Migrating the schema costs ~400ms, so it runs once per suite and specs reset by truncating.+var userTables []string++var _ = BeforeSuite(func() {+ suiteDBTempDir = GinkgoT().TempDir()++ DeferCleanup(configtest.SetupConfig())+ conf.Server.DbPath = filepath.Join(suiteDBTempDir, "artwork-resolution-e2e.db") + "?_journal_mode=WAL"+ conf.Server.DataFolder = conf.NewDir(GinkgoT().TempDir())+ db.Db().SetMaxOpenConns(1)+ db.Init(request.WithUser(context.Background(), model.User{ID: "admin-1", IsAdmin: true}))++ userTables = harness.ResettableTables()+})++var _ = AfterSuite(func() {+ db.Close(context.Background())+})++func setupResolutionHarness() {+ DeferCleanup(configtest.SetupConfig())++ tempDir := GinkgoT().TempDir()+ conf.Server.DbPath = filepath.Join(suiteDBTempDir, "artwork-resolution-e2e.db") + "?_journal_mode=WAL"+ conf.Server.DataFolder = conf.NewDir(tempDir)+ conf.Server.MusicFolder = fakeLibPath+ conf.Server.DevExternalScanner = false+ conf.Server.ImageCacheSize = "0"+ conf.Server.EnableExternalServices = false+ conf.Server.EnableMediaFileCoverArt = true+ conf.Server.DevArtworkWorkerConcurrency = 1++ rctx = request.WithUser(GinkgoT().Context(), model.User{ID: "admin-1", UserName: "admin", IsAdmin: true})+ harness.TruncateDB(userTables)++ rds = &tests.MockDataStore{RealDS: persistence.New(db.Db())}++ adminUser := model.User{ID: "admin-1", UserName: "admin", Name: "Admin", IsAdmin: true, NewPassword: "password"}+ Expect(rds.User(rctx).Put(&adminUser)).To(Succeed())++ lib := model.Library{ID: 1, Name: "Music", Path: fakeLibPath}+ Expect(rds.Library(rctx).Put(&lib)).To(Succeed())+ Expect(rds.User(rctx).SetUserLibraries(adminUser.ID, []int{lib.ID})).To(Succeed())++ loadEmbeddedFixture()++ fakeFS = &storagetest.FakeFS{}+ storagetest.Register(fakeLibScheme, fakeFS)++ ffm := tests.NewMockFFmpeg("")+ rstore = artwork.NewImageStore(filepath.Join(tempDir, consts.HashedArtworkFolder))+ // size=0 requests stream originals, so this reader is never called (serving_test covers resizing).+ imgCache := cache.NewFileCache("ArtworkResolutionE2E", "100MB", "images", 0,+ func(context.Context, cache.Item) (io.Reader, error) {+ return nil, fmt.Errorf("resize not exercised in e2e")+ })+ Eventually(func() bool { return imgCache.Available(rctx) }).Should(BeTrue())++ rsvc = artwork.NewArtwork(rds, imgCache, rstore, ffm)+ rworker = artwork.NewWorker(rds, rstore, agents.GetAgents(rds, nil), ffm, events.NoopBroker(), imgCache)+}++// setLayout paths must be relative and forward-slash.+func setLayout(files fstest.MapFS) {+ GinkgoHelper()+ fakeFS.SetFiles(files)+}++func scan() {+ GinkgoHelper()+ s := scanner.New(rctx, rds, events.NoopBroker(),+ playlists.NewPlaylists(rds, artwork.NewUploader(rds)), metrics.NewNoopInstance())+ _, err := s.ScanAll(rctx, true)+ Expect(err).ToNot(HaveOccurred())+}++func acquire(kind model.Kind, id string) model.ItemArtwork {+ GinkgoHelper()+ // Enqueues the way the serving paths do, so the drain is driven by a plain queue row.+ Expect(rds.ArtworkQueue(rctx).EnqueuePreservingBackoff(model.ArtworkQueueItem{+ ItemKind: kind.Prefix(), ItemID: id, ImageType: model.ImageTypePrimary,+ Priority: model.ArtworkPriorityBump,+ })).To(Succeed())+ var ia *model.ItemArtwork+ runResolutionWorkerUntil(func() bool {+ got, err := rds.Artwork(rctx).GetItemArtwork(kind, id, model.ImageTypePrimary)+ if err != nil {+ return false+ }+ ia = got+ return true+ })+ return *ia+}++func runResolutionWorkerUntil(until func() bool) {+ GinkgoHelper()+ runCtx, cancel := context.WithCancel(rctx)+ done := make(chan error, 1)+ go func() { done <- rworker.Run(runCtx) }()+ Eventually(until, 5*time.Second, 10*time.Millisecond).Should(BeTrue())+ cancel()+ Eventually(done, 2*time.Second).Should(Receive(BeNil()))+}++func serveBytes(artID model.ArtworkID) []byte {+ GinkgoHelper()+ img, err := rsvc.Get(rctx, artID, 0, false)+ Expect(err).ToNot(HaveOccurred())+ defer img.Close()+ data, err := io.ReadAll(img)+ Expect(err).ToNot(HaveOccurred())+ return data+}++func serveErr(artID model.ArtworkID) error {+ img, err := rsvc.Get(rctx, artID, 0, false)+ if img != nil {+ img.Close()+ }+ return err+}++func libFileBytes(suffix string) []byte {+ GinkgoHelper()+ var match string+ for name := range fakeFS.MapFS {+ if strings.HasSuffix(name, suffix) {+ Expect(match).To(BeEmpty(), "suffix %q is ambiguous: %q and %q", suffix, match, name)+ match = name+ }+ }+ Expect(match).ToNot(BeEmpty(), "no library file ends with %q", suffix)+ return fakeFS.MapFS[match].Data+}++// Serving before acquiring is deliberate: with no state row the request resolves through the+// library FS, while a settled folder row is read with os.Open, which the in-memory FS cannot serve.+func expectAlbumFolderCover(al model.Album, suffix string) {+ GinkgoHelper()+ requireNoStateRow(model.KindAlbumArtwork, al.ID)+ Expect(serveBytes(al.CoverArtID())).To(Equal(libFileBytes(suffix)))+ ia := acquire(model.KindAlbumArtwork, al.ID)+ Expect(ia.Source).To(Equal("folder"))+ Expect(filepath.ToSlash(ia.SourcePath)).To(HaveSuffix(suffix))+}++// A drain settles every ready item, so byte-level folder assertions must precede any acquire.+func requireNoStateRow(kind model.Kind, id string) {+ GinkgoHelper()+ _, err := rds.Artwork(rctx).GetItemArtwork(kind, id, model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound),+ "assert %s %q before acquiring any other entity in this spec", kind, id)+}++func expectAlbumAbsent(al model.Album) {+ GinkgoHelper()+ ia := acquire(model.KindAlbumArtwork, al.ID)+ Expect(ia.Hash).To(BeEmpty())+ Expect(serveErr(al.CoverArtID())).To(MatchError(artwork.ErrUnavailable))+}++func expectArtistFolder(ar model.Artist, suffix string) {+ GinkgoHelper()+ requireNoStateRow(model.KindArtistArtwork, ar.ID)+ Expect(serveBytes(model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil))).To(Equal(libFileBytes(suffix)))+ ia := acquire(model.KindArtistArtwork, ar.ID)+ Expect(ia.Source).To(Equal("folder"))+ Expect(filepath.ToSlash(ia.SourcePath)).To(HaveSuffix(suffix))+}++func writeUploadedImage(entity, filename string, data []byte) {+ GinkgoHelper()+ dst := model.UploadedImagePath(entity, filename)+ Expect(os.MkdirAll(filepath.Dir(dst), 0o755)).To(Succeed())+ Expect(os.WriteFile(dst, data, 0o600)).To(Succeed())+}++func discArtID(al model.Album, disc int) model.ArtworkID {+ return model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, disc), &al.UpdatedAt)+}++// Disc art is a pure serve-time read through the library FS: no worker, no state row.+func expectDiscImage(al model.Album, disc int, label string) {+ GinkgoHelper()+ Expect(serveBytes(discArtID(al, disc))).To(Equal(pngBytes(label)))+}++// Samples in rect() order: top-left, top-right, bottom-left, bottom-right.+func gridQuadrants(data []byte) [4]color.RGBA {+ GinkgoHelper()+ img, _, err := image.Decode(bytes.NewReader(data))+ Expect(err).ToNot(HaveOccurred())+ b := img.Bounds()+ qw, qh := b.Dx()/4, b.Dy()/4+ at := func(x, y int) color.RGBA {+ c := color.RGBAModel.Convert(img.At(b.Min.X+x, b.Min.Y+y))+ return c.(color.RGBA)+ }+ return [4]color.RGBA{at(qw, qh), at(3*qw, qh), at(qw, 3*qh), at(3*qw, 3*qh)}+}++// Store-backed sources only (embedded/generated); file-backed ones assert on ia.SourcePath.+func storedBytes(ia model.ItemArtwork) []byte {+ GinkgoHelper()+ art, err := rds.Artwork(rctx).GetImage(ia.Hash)+ Expect(err).ToNot(HaveOccurred())+ r, err := rstore.Open(ia.Hash, art.Mime)+ Expect(err).ToNot(HaveOccurred())+ defer r.Close()+ data, err := io.ReadAll(r)+ Expect(err).ToNot(HaveOccurred())+ return data+}++// The pixel color derives from label, so each label yields distinct, still-decodable bytes.+func smallPNG(label string) *fstest.MapFile {+ h := fnv.New32a()+ _, _ = h.Write([]byte(label))+ sum := h.Sum32()+ c := color.RGBA{R: byte(sum), G: byte(sum >> 8), B: byte(sum >> 16), A: 255}+ img := image.NewRGBA(image.Rect(0, 0, 2, 2))+ for y := range 2 {+ for x := range 2 {+ img.Set(x, y, c)+ }+ }+ var buf bytes.Buffer+ Expect(png.Encode(&buf, img)).To(Succeed())+ return &fstest.MapFile{Data: buf.Bytes()}+}++func pngBytes(label string) []byte {+ GinkgoHelper()+ return smallPNG(label).Data+}++func trackFile(num int, title string, extra ...map[string]any) *fstest.MapFile {+ tags := storagetest.Track(num, title)+ for _, e := range extra {+ maps.Copy(tags, e)+ }+ return storagetest.MP3(tags)+}++// FakeFS's JSON-encoded tags aren't taglib-readable, so embedded-art specs swap in these real MP3+// bytes after scanning. Loaded lazily: tests.Init must chdir to the project root first.+var (+ embeddedFixtureOnce sync.Once+ embeddedArtFixture []byte+ embeddedArtBytes []byte+)++func loadEmbeddedFixture() {+ embeddedFixtureOnce.Do(func() {+ embeddedArtFixture = readFixture(mp3Fixture)+ embeddedArtBytes = extractEmbeddedArt(embeddedArtFixture)+ })+}++func extractEmbeddedArt(mp3 []byte) []byte {+ tf, err := taglib.OpenStream(bytes.NewReader(mp3))+ if err != nil {+ panic("embedded-art fixture: taglib.OpenStream failed: " + err.Error())+ }+ defer tf.Close()+ images := tf.Properties().Images+ if len(images) == 0 {+ panic("embedded-art fixture has no embedded images")+ }+ data, err := tf.Image(0)+ if err != nil || len(data) == 0 {+ panic("embedded-art fixture: could not read image 0")+ }+ return data+}++func replaceWithRealMP3(relPath string) {+ GinkgoHelper()+ fakeFS.MapFS[relPath] = &fstest.MapFile{Data: embeddedArtFixture}+}++func firstAlbum() model.Album {+ GinkgoHelper()+ albums, err := rds.Album(rctx).GetAll(model.QueryOptions{})+ Expect(err).ToNot(HaveOccurred())+ Expect(albums).To(HaveLen(1), "expected exactly one album, got %d", len(albums))+ return albums[0]+}++func albumByName(name string) model.Album {+ GinkgoHelper()+ albums, err := rds.Album(rctx).GetAll(model.QueryOptions{})+ Expect(err).ToNot(HaveOccurred())+ for _, al := range albums {+ if al.Name == name {+ return al+ }+ }+ Fail(fmt.Sprintf("album %q not found among %d albums", name, len(albums)))+ return model.Album{}+}diff --git a/core/artwork/e2e/suite_test.go b/core/artwork/e2e/suite_test.godeleted file mode 100644index 06cc05b6f..000000000--- a/core/artwork/e2e/suite_test.go+++ /dev/null@@ -1,120 +0,0 @@-package artworke2e_test--import (- "context"- "fmt"- "path/filepath"- "testing"-- _ "github.com/navidrome/navidrome/adapters/gotaglib"- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/conf/configtest"- "github.com/navidrome/navidrome/core"- "github.com/navidrome/navidrome/core/artwork"- "github.com/navidrome/navidrome/core/metrics"- "github.com/navidrome/navidrome/core/playlists"- "github.com/navidrome/navidrome/core/storage/storagetest"- "github.com/navidrome/navidrome/db"- "github.com/navidrome/navidrome/log"- "github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/model/request"- "github.com/navidrome/navidrome/persistence"- "github.com/navidrome/navidrome/scanner"- "github.com/navidrome/navidrome/server/events"- "github.com/navidrome/navidrome/tests"- . "github.com/onsi/ginkgo/v2"- . "github.com/onsi/gomega"-)--func TestArtworkE2E(t *testing.T) {- tests.Init(t, false)- log.SetLevel(log.LevelFatal)- RegisterFailHandler(Fail)- RunSpecs(t, "Artwork E2E Suite")-}--const fakeLibScheme = "artworkfake"-const fakeLibPath = fakeLibScheme + ":///music"--var (- ctx context.Context- ds *tests.MockDataStore- aw artwork.Artwork- fakeFS *storagetest.FakeFS-)--// The DB file lives in a suite-level tempdir: the go-sqlite3 singleton keeps-// the file open for the whole suite, and Ginkgo's per-spec TempDir cleanup-// can't unlink a file with a live handle on Windows. A suite-level tempdir-// combined with an AfterSuite close avoids the lock conflict.-var suiteDBTempDir string--var _ = BeforeSuite(func() {- suiteDBTempDir = GinkgoT().TempDir()-})--var _ = AfterSuite(func() {- db.Close(GinkgoT().Context())-})--func setupHarness() {- DeferCleanup(configtest.SetupConfig())-- tempDir := GinkgoT().TempDir()- // Reuse the suite-level DB path so the singleton connection keeps working- // across specs (see suiteDBTempDir comment).- conf.Server.DbPath = filepath.Join(suiteDBTempDir, "artwork-e2e.db") + "?_journal_mode=WAL"- conf.Server.DataFolder = conf.NewDir(tempDir)- conf.Server.MusicFolder = fakeLibPath- conf.Server.DevExternalScanner = false- conf.Server.ImageCacheSize = "0" // disabled cache → reader runs on every call- conf.Server.EnableExternalServices = false-- db.Db().SetMaxOpenConns(1)- ctx = request.WithUser(GinkgoT().Context(), model.User{ID: "admin-1", UserName: "admin", IsAdmin: true})- db.Init(ctx)- DeferCleanup(func() { Expect(tests.ClearDB()).To(Succeed()) })-- ds = &tests.MockDataStore{RealDS: persistence.New(db.Db())}-- adminUser := model.User{ID: "admin-1", UserName: "admin", Name: "Admin", IsAdmin: true, NewPassword: "password"}- Expect(ds.User(ctx).Put(&adminUser)).To(Succeed())-- lib := model.Library{ID: 1, Name: "Music", Path: fakeLibPath}- Expect(ds.Library(ctx).Put(&lib)).To(Succeed())- Expect(ds.User(ctx).SetUserLibraries(adminUser.ID, []int{lib.ID})).To(Succeed())-- fakeFS = &storagetest.FakeFS{}- storagetest.Register(fakeLibScheme, fakeFS)-- aw = artwork.NewArtwork(ds, artwork.GetImageCache(), newNoopFFmpeg(), &noopProvider{})-}--func scan() {- GinkgoHelper()- s := scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())- _, err := s.ScanAll(ctx, true)- Expect(err).ToNot(HaveOccurred())-}--func firstAlbum() model.Album {- GinkgoHelper()- albums, err := ds.Album(ctx).GetAll(model.QueryOptions{})- Expect(err).ToNot(HaveOccurred())- Expect(albums).To(HaveLen(1), "expected exactly one album, got %d", len(albums))- return albums[0]-}--func albumByName(name string) model.Album {- GinkgoHelper()- albums, err := ds.Album(ctx).GetAll(model.QueryOptions{})- Expect(err).ToNot(HaveOccurred())- for _, al := range albums {- if al.Name == name {- return al- }- }- Fail(fmt.Sprintf("album %q not found among %d albums", name, len(albums)))- return model.Album{}-}diff --git a/core/artwork/e2e/testdata/embedded_art.mp3 b/core/artwork/e2e/testdata/embedded_art.mp3deleted file mode 100644index 18cb90674..000000000Binary files a/core/artwork/e2e/testdata/embedded_art.mp3 and /dev/null differdiff --git a/core/artwork/reader_album.go b/core/artwork/folders_album.gosimilarity index 63%rename from core/artwork/reader_album.gorename to core/artwork/folders_album.goindex 58a47c8ae..88f0181a3 100644--- a/core/artwork/reader_album.go+++ b/core/artwork/folders_album.go@@ -3,107 +3,19 @@ package artworkimport ("cmp""context"- "crypto/md5""errors"- "fmt"- "io""path""slices""strings""time""github.com/Masterminds/squirrel"- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/core/external"- "github.com/navidrome/navidrome/core/ffmpeg""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/utils""github.com/navidrome/navidrome/utils/natural""github.com/navidrome/navidrome/utils/slice")-type albumArtworkReader struct {- cacheKey- a *artwork- provider external.Provider- album model.Album- updatedAt *time.Time- imgFiles []string // library-relative, forward-slash, no leading slash- lib libraryView-}--func newAlbumArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID, provider external.Provider) (*albumArtworkReader, error) {- al, err := artwork.ds.Album(ctx).Get(artID.ID)- if err != nil {- return nil, err- }- _, imgFiles, imagesUpdateAt, err := loadAlbumFoldersPaths(ctx, artwork.ds, *al)- if err != nil {- return nil, err- }- lib, err := loadLibraryView(ctx, artwork.ds, al.LibraryID)- if err != nil {- return nil, err- }- a := &albumArtworkReader{- a: artwork,- provider: provider,- album: *al,- updatedAt: imagesUpdateAt,- imgFiles: imgFiles,- lib: lib,- }- a.cacheKey.artID = artID- a.cacheKey.lastUpdate = utils.TimeNewest(al.UpdatedAt, al.ImportedAt)- if imagesUpdateAt != nil {- a.cacheKey.lastUpdate = utils.TimeNewest(a.cacheKey.lastUpdate, *imagesUpdateAt)- }- return a, nil-}--func (a *albumArtworkReader) Key() string {- hashInput := conf.Server.CoverArtPriority- if conf.Server.EnableExternalServices {- hashInput = conf.Server.Agents + hashInput- }- hash := md5.Sum([]byte(hashInput))- return fmt.Sprintf(- "%s.%x.%t",- a.cacheKey.Key(),- hash,- conf.Server.EnableExternalServices,- )-}-func (a *albumArtworkReader) LastUpdated() time.Time {- return a.lastUpdate-}--func (a *albumArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {- var ff = a.fromCoverArtPriority(ctx, a.a.ffmpeg, conf.Server.CoverArtPriority)- return selectImageReader(ctx, a.artID, ff...)-}--func (a *albumArtworkReader) fromCoverArtPriority(ctx context.Context, ffmpeg ffmpeg.FFmpeg, priority string) []sourceFunc {- var ff []sourceFunc- for pattern := range strings.SplitSeq(strings.ToLower(priority), ",") {- pattern = strings.TrimSpace(pattern)- switch {- case pattern == "embedded":- embedRel := a.album.EmbedArtPath- ff = append(ff,- fromTag(ctx, a.lib.FS, embedRel),- fromFFmpegTag(ctx, ffmpeg, a.lib.Abs(embedRel)),- )- case pattern == "external":- ff = append(ff, fromAlbumExternalSource(ctx, a.album, a.provider))- case len(a.imgFiles) > 0:- ff = append(ff, fromExternalFile(ctx, a.lib.FS, a.imgFiles, pattern))- }- }- return ff-}-func loadAlbumFoldersPaths(ctx context.Context, ds model.DataStore, album model.Album) ([]string, []string, *time.Time, error) {folders, err := loadFolders(ctx, ds, album.FolderIDs)if err != nil {@@ -169,7 +81,7 @@ func albumRootParent(ctx context.Context, ds model.DataStore, folders []model.Fo}parent, err := ds.Folder(ctx).Get(commonParentID)if errors.Is(err, model.ErrNotFound) {- log.Warn(ctx, "Parent folder not found for album cover art lookup", "parentID", commonParentID)+ log.Warn(ctx, "Artwork: Parent folder not found for album cover art lookup", "parentID", commonParentID)return nil, nil}if err != nil {diff --git a/core/artwork/folders_album_test.go b/core/artwork/folders_album_test.gonew file mode 100644index 000000000..a263dbaaf--- /dev/null+++ b/core/artwork/folders_album_test.go@@ -0,0 +1,214 @@+package artwork++import (+ "context"+ "errors"+ "time"++ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++// The e2e specs cover which image wins for a layout; these pin what a layout cannot reach: that+// the album-root parent is only fetched when it could qualify, and what happens when that fails.+var _ = Describe("loadAlbumFoldersPaths", func() {+ var (+ ctx context.Context+ ds *tests.MockDataStore+ repo *fakeFolderRepo+ album model.Album+ now time.Time+ )++ BeforeEach(func() {+ ctx = context.Background()+ now = time.Now().Truncate(time.Second)+ repo = &fakeFolderRepo{}+ ds = &tests.MockDataStore{MockedFolder: repo}+ album = model.Album{+ ID: "album1",+ Name: "Album",+ FolderIDs: []string{"folder1", "folder2", "folder3"},+ }+ })++ It("does not query the parent when it is already one of the album's folders", func() {+ repo.result = []model.Folder{+ {ID: "folder1", Path: "Artist", Name: "Album", ParentID: "folder2",+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},+ {ID: "folder2", Path: "", Name: "Artist", ImagesUpdatedAt: now},+ }++ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)++ Expect(err).ToNot(HaveOccurred())+ Expect(imgFiles).To(ConsistOf("Artist/Album/cover.jpg"))+ Expect(repo.getCallCount).To(BeZero())+ })++ It("does not query the parent when the album's folders have different parents", func() {+ repo.result = []model.Folder{+ {ID: "folder1", Path: "Artist1/Album", Name: "part1", ParentID: "parentA",+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},+ {ID: "folder2", Path: "Artist2/Album", Name: "part2", ParentID: "parentB",+ ImagesUpdatedAt: now},+ }++ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)++ Expect(err).ToNot(HaveOccurred())+ Expect(imgFiles).To(ConsistOf("Artist1/Album/part1/cover.jpg"))+ Expect(repo.getCallCount).To(BeZero())+ })++ It("does not query the parent for a single-folder album that has images of its own", func() {+ repo.result = []model.Folder{+ {ID: "folder1", Path: "Artist", Name: "Album", ParentID: "artistFolder",+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},+ }++ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)++ Expect(err).ToNot(HaveOccurred())+ Expect(imgFiles).To(ConsistOf("Artist/Album/cover.jpg"))+ Expect(repo.getCallCount).To(BeZero())+ })++ It("does not promote the library root, so its images never become album art", func() {+ repo.result = []model.Folder{+ {ID: "folder1", Path: ".", Name: "AlbumPart1", ParentID: "rootFolder",+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},+ {ID: "folder2", Path: ".", Name: "AlbumPart2", ParentID: "rootFolder",+ ImagesUpdatedAt: now},+ }+ repo.parentResult = &model.Folder{ID: "rootFolder", Name: ".", ImageFiles: []string{"unrelated.jpg"}}++ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)++ Expect(err).ToNot(HaveOccurred())+ Expect(imgFiles).To(ConsistOf("AlbumPart1/cover.jpg"))+ Expect(repo.getCallCount).To(Equal(1))+ })++ It("does not promote a parent that holds another album's audio", func() {+ repo.result = []model.Folder{+ {ID: "folder1", Path: "Artist/Album", Name: "CD1", ParentID: "albumFolder",+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},+ {ID: "folder2", Path: "Artist/Album", Name: "CD2", ParentID: "albumFolder",+ ImagesUpdatedAt: now},+ }+ repo.parentResult = &model.Folder{ID: "albumFolder", Path: "Artist", Name: "Album",+ ParentID: "artistFolder", ImageFiles: []string{"artist.jpg"}}+ repo.hasOtherAudio = true++ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)++ Expect(err).ToNot(HaveOccurred())+ Expect(imgFiles).To(ConsistOf("Artist/Album/CD1/cover.jpg"))+ })++ It("promotes the album root parent into the returned paths", func() {+ repo.result = []model.Folder{+ {ID: "folder1", Path: "Artist/Album", Name: "CD1", ParentID: "albumFolder",+ ImagesUpdatedAt: now},+ {ID: "folder2", Path: "Artist/Album", Name: "CD2", ParentID: "albumFolder",+ ImagesUpdatedAt: now},+ }+ repo.parentResult = &model.Folder{ID: "albumFolder", Path: "Artist", Name: "Album",+ ParentID: "artistFolder", ImageFiles: []string{"cover.jpg"}}++ paths, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)++ Expect(err).ToNot(HaveOccurred())+ Expect(imgFiles).To(ConsistOf("Artist/Album/cover.jpg"))+ Expect(paths).To(HaveLen(3))+ })++ It("propagates errors from the album-root check", func() {+ repo.result = []model.Folder{+ {ID: "folder1", Path: "Artist/Album", Name: "disc1", ParentID: "albumFolder",+ ImagesUpdatedAt: now},+ }+ repo.parentResult = &model.Folder{ID: "albumFolder", Path: "Artist", Name: "Album",+ ParentID: "artistFolder", ImageFiles: []string{"cover.jpg"}}+ repo.otherAudioErr = errors.New("db connection failed")++ _, _, _, err := loadAlbumFoldersPaths(ctx, ds, album)++ Expect(err).To(MatchError("db connection failed"))+ })++ It("propagates non-ErrNotFound errors from the parent folder lookup", func() {+ repo.result = []model.Folder{+ {ID: "folder1", Path: "Artist/Album", Name: "CD1", ParentID: "parentFolder",+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},+ {ID: "folder2", Path: "Artist/Album", Name: "CD2", ParentID: "parentFolder",+ ImagesUpdatedAt: now},+ }+ repo.getErr = errors.New("db connection failed")++ _, _, _, err := loadAlbumFoldersPaths(ctx, ds, album)++ Expect(err).To(MatchError("db connection failed"))+ Expect(repo.getCallCount).To(Equal(1))+ })++ It("continues when the parent folder has been deleted", func() {+ repo.result = []model.Folder{+ {ID: "folder1", Path: "Artist/Album", Name: "CD1", ParentID: "missingParent",+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},+ {ID: "folder2", Path: "Artist/Album", Name: "CD2", ParentID: "missingParent",+ ImagesUpdatedAt: now},+ }++ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)++ Expect(err).ToNot(HaveOccurred())+ Expect(imgFiles).To(ConsistOf("Artist/Album/CD1/cover.jpg"))+ Expect(repo.getCallCount).To(Equal(1))+ })+})++// folderImages is the sort that decides which of several same-named images wins, so it is pinned+// directly rather than through a layout that can only show the winner.+var _ = Describe("folderImages", func() {+ It("prefers base filenames over numeric-suffixed ones", func() {+ imgFiles, _ := folderImages([]model.Folder{+ {Path: "Artist", Name: "Album", ImageFiles: []string{"cover.1.jpg", "cover.jpg", "cover.2.jpg"}},+ })++ Expect(imgFiles).To(HaveExactElements(+ "Artist/Album/cover.jpg", "Artist/Album/cover.1.jpg", "Artist/Album/cover.2.jpg"))+ })++ It("prefers shallower paths when the base filenames tie", func() {+ imgFiles, _ := folderImages([]model.Folder{+ {Path: "Artist/Album", Name: "CD1", ImageFiles: []string{"cover.jpg"}},+ {Path: "Artist", Name: "Album", ImageFiles: []string{"cover.jpg"}},+ })++ Expect(imgFiles).To(HaveExactElements("Artist/Album/cover.jpg", "Artist/Album/CD1/cover.jpg"))+ })++ It("sorts case-insensitively", func() {+ imgFiles, _ := folderImages([]model.Folder{+ {Path: "Artist", Name: "Album", ImageFiles: []string{"Cover.jpg", "back.JPG"}},+ })++ Expect(imgFiles).To(HaveExactElements("Artist/Album/back.JPG", "Artist/Album/Cover.jpg"))+ })++ It("reports the newest ImagesUpdatedAt across the folders", func() {+ now := time.Now().Truncate(time.Second)+ newest := now.Add(5 * time.Minute)++ _, updatedAt := folderImages([]model.Folder{+ {Path: "Artist", Name: "Album", ImagesUpdatedAt: now},+ {Path: "Artist/Album", Name: "CD1", ImagesUpdatedAt: newest},+ })++ Expect(updatedAt).To(Equal(newest))+ })+})diff --git a/core/artwork/folders_artist.go b/core/artwork/folders_artist.gonew file mode 100644index 000000000..1ca1ce034--- /dev/null+++ b/core/artwork/folders_artist.go@@ -0,0 +1,210 @@+package artwork++import (+ "context"+ "errors"+ "fmt"+ "io"+ "io/fs"+ "os"+ "path"+ "path/filepath"+ "slices"+ "strings"+ "time"++ "github.com/Masterminds/squirrel"+ "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/utils"+ "github.com/navidrome/navidrome/utils/slice"+ "github.com/navidrome/navidrome/utils/str"+)++const (+ maxArtistFolderTraversalDepth = 3+)++func fromArtistFolder(ctx context.Context, libFS fs.FS, libPath, artistFolder, pattern string) sourceFunc {+ return func() (io.ReadCloser, string, error) {+ if libFS == nil {+ return nil, "", fmt.Errorf("artist folder lookup unavailable")+ }+ rel, err := filepath.Rel(libPath, artistFolder)+ if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {+ return nil, "", fmt.Errorf(`artist folder '%s' is outside library '%s'`, artistFolder, libPath)+ }+ // fs.Glob needs forward slashes; filepath.Rel returns backslashes on Windows.+ rel = filepath.ToSlash(rel)+ current := artistFolder+ var unreadable error+ for range maxArtistFolderTraversalDepth {+ reader, hit, err := findImageInFolder(ctx, libFS, rel, current, pattern)+ if err == nil {+ return reader, hit, nil+ }+ if errors.Is(err, errSourceUnreadable) {+ unreadable = err+ }+ if rel == "." {+ break // reached library root+ }+ rel = path.Dir(rel)+ current = filepath.Dir(current)+ }+ if unreadable != nil {+ return nil, "", unreadable+ }+ return nil, "", fmt.Errorf(`no matches for '%s' in '%s' or its parent directories (within library)`, pattern, artistFolder)+ }+}++// findImageInFolder returns the first image matching pattern; absFolder is only used for+// the returned display path and log messages.+func findImageInFolder(ctx context.Context, libFS fs.FS, relFolder, absFolder, pattern string) (io.ReadCloser, string, error) {+ log.Trace(ctx, "Artwork: Looking for artist image", "pattern", pattern, "folder", absFolder)+ globPattern := pattern+ if relFolder != "." {+ globPattern = path.Join(escapeGlobLiteral(relFolder), pattern)+ }+ matches, err := fs.Glob(libFS, globPattern)+ if err != nil {+ log.Warn(ctx, "Artwork: Error matching artist image pattern", "pattern", pattern, "folder", absFolder, err)+ return nil, "", err+ }++ imagePaths := slice.Filter(matches, model.IsImageFile)++ // Prefer base filenames over numeric-suffixed ones (artist.jpg before artist.1.jpg)+ slices.SortFunc(imagePaths, compareImageFiles)++ var openErr error+ for _, p := range imagePaths {+ f, err := libFS.Open(p)+ if err != nil {+ log.Warn(ctx, "Artwork: Could not open cover art file", "file", p, err)+ openErr = fmt.Errorf("%w: %s: %w", errSourceUnreadable, p, err)+ continue+ }+ _, name := path.Split(p)+ return f, filepath.Join(absFolder, name), nil+ }+ if openErr != nil {+ return nil, "", openErr+ }++ return nil, "", fmt.Errorf(`no matches for '%s' in '%s'`, pattern, absFolder)+}++func escapeGlobLiteral(s string) string {+ var b strings.Builder+ b.Grow(len(s))+ for _, r := range s {+ switch r {+ case '\\', '*', '?', '[', ']':+ b.WriteByte('\\')+ }+ b.WriteRune(r)+ }+ return b.String()+}++// loadArtistAlbumRoots returns one path per album — the deepest folder holding+// all of that album's tracks — so an album split into disc subfolders can't+// pull the artist folder's common prefix below the artist level.+func loadArtistAlbumRoots(ctx context.Context, ds model.DataStore, albums model.Albums) ([]string, []string, *time.Time, error) {+ var folderIDs []string+ for _, album := range albums {+ folderIDs = append(folderIDs, album.FolderIDs...)+ }+ folders, err := loadFolders(ctx, ds, folderIDs)+ if err != nil {+ return nil, nil, nil, err+ }++ pathByID := slice.ToMap(folders, func(f model.Folder) (string, string) {+ return f.ID, f.AbsolutePath()+ })+ var roots []string+ for _, album := range albums {+ var albumPaths []string+ for _, fid := range album.FolderIDs {+ if p, ok := pathByID[fid]; ok {+ albumPaths = append(albumPaths, p)+ }+ }+ if len(albumPaths) > 0 {+ roots = append(roots, commonDir(albumPaths))+ }+ }++ imgFiles, updatedAt := folderImages(folders)+ return roots, imgFiles, &updatedAt, nil+}++// commonDir returns the deepest directory containing all paths. Trailing+// separators keep the comparison on segment boundaries, so a shared name+// fragment (".../Album" and ".../Album2") is never read as a shared directory.+func commonDir(paths []string) string {+ sep := string(filepath.Separator)+ common := str.LongestCommonPrefix(slice.Map(paths, func(p string) string { return p + sep }))+ if !strings.HasSuffix(common, sep) {+ common, _ = filepath.Split(common)+ }+ return filepath.Clean(common)+}++func loadArtistFolder(ctx context.Context, ds model.DataStore, albums model.Albums, paths []string) (string, time.Time, error) {+ if len(albums) == 0 {+ return "", time.Time{}, nil+ }+ libID := albums[0].LibraryID // TODO: Support albums spanning multiple libraries++ // paths holds one root per album: two or more distinct roots already meet at+ // the artist folder, while a single root is an album folder needing a climb.+ roots := slices.Compact(slices.Sorted(slices.Values(paths)))+ folderPath := commonDir(roots)+ if len(roots) < 2 {+ folderPath = filepath.Dir(folderPath)+ }++ // TODO: Hacky, but the easiest way to get the folder ID ATM+ libPath := core.AbsolutePath(ctx, ds, libID, "")+ folderID := model.FolderID(model.Library{ID: libID, Path: libPath}, folderPath)++ log.Trace(ctx, "Artwork: Calculating artist folder details", "folderPath", folderPath, "folderID", folderID,+ "libPath", libPath, "libID", libID, "albumPaths", paths)++ folders, err := ds.Folder(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"folder.id": folderID, "missing": false}})+ if err != nil || len(folders) == 0 {+ log.Warn(ctx, "Artwork: Could not find folder for artist", "folderPath", folderPath, "id", folderID,+ "libPath", libPath, "libID", libID, err)+ return "", time.Time{}, err+ }+ return folderPath, folders[0].ImagesUpdatedAt, nil+}++// findImageInArtistFolder matches an image by MBID or artist name (case-insensitive), "" if none.+func findImageInArtistFolder(folder, mbzArtistID, artistName string) string {+ entries, err := os.ReadDir(folder)+ if err != nil {+ return ""+ }+ for _, candidate := range []string{mbzArtistID, artistName} {+ if candidate == "" {+ continue+ }+ for _, entry := range entries {+ if entry.IsDir() {+ continue+ }+ name := entry.Name()+ base := utils.BaseName(name)+ if strings.EqualFold(base, candidate) && model.IsImageFile(name) {+ return filepath.Join(folder, name)+ }+ }+ }+ return ""+}diff --git a/core/artwork/folders_artist_paths_test.go b/core/artwork/folders_artist_paths_test.gonew file mode 100644index 000000000..cc8af3e63--- /dev/null+++ b/core/artwork/folders_artist_paths_test.go@@ -0,0 +1,117 @@+package artwork++import (+ "context"+ "errors"+ "path/filepath"+ "time"++ "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++// commonDir and loadArtistFolder decide how far above the albums the artist folder sits. A layout+// can only show the image that won, so the arithmetic is pinned here.+var _ = Describe("commonDir", func() {+ It("returns the folder itself for a single path", func() {+ Expect(commonDir([]string{filepath.FromSlash("/music/artist/album")})).+ To(Equal(filepath.FromSlash("/music/artist/album")))+ })++ It("returns the deepest shared folder", func() {+ Expect(commonDir([]string{+ filepath.FromSlash("/music/artist/album/cd1"),+ filepath.FromSlash("/music/artist/album/cd2"),+ })).To(Equal(filepath.FromSlash("/music/artist/album")))+ })++ It("does not read a shared name fragment as a shared folder", func() {+ Expect(commonDir([]string{+ filepath.FromSlash("/music/artist/Album"),+ filepath.FromSlash("/music/artist/Album2"),+ })).To(Equal(filepath.FromSlash("/music/artist")))+ })+})++var _ = Describe("loadArtistFolder", func() {+ var (+ ctx context.Context+ ds *tests.MockDataStore+ repo *fakeFolderRepo+ albums model.Albums+ updatedAt time.Time+ )++ BeforeEach(func() {+ ctx = context.Background()+ DeferCleanup(stubCoreAbsolutePath())++ updatedAt = time.Now().Truncate(time.Second).Add(5 * time.Minute)+ repo = &fakeFolderRepo{result: []model.Folder{{ImagesUpdatedAt: updatedAt}}}+ ds = &tests.MockDataStore{MockedFolder: repo}+ albums = model.Albums{{LibraryID: 1, ID: "album1", Name: "Album 1"}}+ })++ It("returns empty when the artist has no albums", func() {+ folder, upd, err := loadArtistFolder(ctx, ds, model.Albums{}, []string{"/dummy/path"})++ Expect(err).ToNot(HaveOccurred())+ Expect(folder).To(BeEmpty())+ Expect(upd).To(BeZero())+ })++ It("climbs above the album folder when the artist has a single album root", func() {+ folder, upd, err := loadArtistFolder(ctx, ds, albums,+ []string{filepath.FromSlash("/music/artist/album1")})++ Expect(err).ToNot(HaveOccurred())+ Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))+ Expect(upd).To(Equal(updatedAt))+ })++ It("climbs above the shared folder when two albums live in the same one", func() {+ folder, upd, err := loadArtistFolder(ctx, ds, albums, []string{+ filepath.FromSlash("/music/artist/split"),+ filepath.FromSlash("/music/artist/split"),+ })++ Expect(err).ToNot(HaveOccurred())+ Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))+ Expect(upd).To(Equal(updatedAt))+ })++ It("stops at the folder where distinct album roots already meet", func() {+ folder, upd, err := loadArtistFolder(ctx, ds, albums, []string{+ filepath.FromSlash("/music/artist/album1"),+ filepath.FromSlash("/music/artist/album2"),+ })++ Expect(err).ToNot(HaveOccurred())+ Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))+ Expect(upd).To(Equal(updatedAt))+ })++ It("returns the error when the folder lookup fails", func() {+ repo.err = errors.New("fake error")++ folder, upd, err := loadArtistFolder(ctx, ds, albums, []string{+ filepath.FromSlash("/music/artist/album1"),+ filepath.FromSlash("/music/artist/album2"),+ })++ Expect(err).To(MatchError(ContainSubstring("fake error")))+ Expect(folder).To(BeEmpty())+ Expect(upd).To(BeZero())+ })+})++func stubCoreAbsolutePath() func() {+ original := core.AbsolutePath+ core.AbsolutePath = func(context.Context, model.DataStore, int, string) string {+ return filepath.FromSlash("/music")+ }+ return func() { core.AbsolutePath = original }+}diff --git a/core/artwork/folders_artist_test.go b/core/artwork/folders_artist_test.gonew file mode 100644index 000000000..a35e40232--- /dev/null+++ b/core/artwork/folders_artist_test.go@@ -0,0 +1,47 @@+package artwork++import (+ "context"+ "errors"+ "io/fs"+ "testing/fstest"++ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++// unreadableFS globs like its embedded MapFS but refuses to open anything. Injecting the error+// keeps this independent of the filesystem: os.Chmod does not restrict read access on Windows.+type unreadableFS struct{ fstest.MapFS }++func (u unreadableFS) Open(string) (fs.File, error) { return nil, fs.ErrPermission }++var _ = Describe("findImageInFolder", func() {+ var ctx context.Context+ var files fstest.MapFS++ BeforeEach(func() {+ ctx = context.Background()+ files = fstest.MapFS{"artist.jpg": &fstest.MapFile{Data: []byte("img")}}+ })++ It("returns the first matching image", func() {+ r, hit, err := findImageInFolder(ctx, files, ".", "/lib", "artist.*")+ Expect(err).ToNot(HaveOccurred())+ defer r.Close()+ Expect(hit).To(HaveSuffix("artist.jpg"))+ })++ // The glob matched, so the image exists; failing to open it says nothing about whether the+ // artist has one, and must not let the resolver settle on absent.+ It("reports a matched but unreadable image as unreadable, not as a miss", func() {+ _, _, err := findImageInFolder(ctx, unreadableFS{files}, ".", "/lib", "artist.*")+ Expect(err).To(MatchError(errSourceUnreadable))+ })++ It("reports a plain miss when nothing matches", func() {+ _, _, err := findImageInFolder(ctx, files, ".", "/lib", "nothing.*")+ Expect(err).To(HaveOccurred())+ Expect(errors.Is(err, errSourceUnreadable)).To(BeFalse(), "no match is definitive, not transient")+ })+})diff --git a/core/artwork/gate.go b/core/artwork/gate.gonew file mode 100644index 000000000..a64c11a20--- /dev/null+++ b/core/artwork/gate.go@@ -0,0 +1,120 @@+package artwork++import (+ "errors"+ "io"+ "sync"+ "time"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+ "golang.org/x/time/rate"+)++const (+ breakerThreshold = 5+ breakerProbeAfter = time.Minute+)++var errBreakerOpen = errors.New("artwork: external circuit breaker open")++// gateFunc gates one named external fetch (rate limit + circuit breaker per name).+type gateFunc = func(name string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error)++func passthroughGate(_ string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {+ return f()+}++// isTransientExternal reports whether an external failure is worth retrying; a not-found+// (from either package) is a definitive answer, not a fault.+func isTransientExternal(err error) bool {+ return err != nil && !errors.Is(err, agents.ErrNotFound) && !errors.Is(err, model.ErrNotFound)+}++// extGate is one agent's rate limiter and circuit breaker, so a failing provider backs off+// in isolation from the others.+type extGate struct {+ limiter *rate.Limiter+ breaker *breaker+}++// gate runs a named external step through that agent's rate limiter and circuit breaker.+func (w *Worker) gate(name string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {+ g := w.gateFor(name)+ if !g.breaker.allow() {+ log.Debug(w.runCtx, "Artwork: Skipping agent, circuit breaker open", "agent", name)+ return nil, "", errBreakerOpen+ }+ // Timed separately so a throttled agent isn't mistaken for a slow provider.+ waitStart := time.Now()+ if err := g.limiter.Wait(w.runCtx); err != nil {+ return nil, "", err+ }+ callStart := time.Now()+ r, path, err := f()+ g.breaker.record(name, err)+ log.Trace(w.runCtx, "Artwork: External agent call", "agent", name, "hit", r != nil,+ "limiterWait", callStart.Sub(waitStart), "elapsed", time.Since(callStart), err)+ return r, path, err+}++// gateFor lazily creates the per-name gate on first use.+func (w *Worker) gateFor(name string) *extGate {+ w.gatesMu.Lock()+ defer w.gatesMu.Unlock()+ if g, ok := w.gates[name]; ok {+ return g+ }+ rps := conf.Server.DevArtworkExternalMaxRPS+ limit := rate.Inf+ if rps > 0 {+ limit = rate.Limit(rps)+ }+ g := &extGate{limiter: rate.NewLimiter(limit, max(1, rps)), breaker: newBreaker()}+ w.gates[name] = g+ return g+}++// breaker opens after breakerThreshold consecutive errors and admits a single probe once+// breakerProbeAfter has elapsed; a success re-closes it.+type breaker struct {+ mu sync.Mutex+ failures int+ openedAt time.Time+}++func newBreaker() *breaker { return &breaker{} }++func (b *breaker) allow() bool {+ b.mu.Lock()+ defer b.mu.Unlock()+ if b.failures < breakerThreshold {+ return true+ }+ if time.Since(b.openedAt) >= breakerProbeAfter {+ b.openedAt = time.Now() // start a fresh probe window so only one caller passes+ return true+ }+ return false+}++func (b *breaker) record(name string, err error) {+ b.mu.Lock()+ defer b.mu.Unlock()+ // A not-found is a definitive answer, not a fault; keep in sync with isTransientExternal.+ if err == nil || errors.Is(err, model.ErrNotFound) || errors.Is(err, agents.ErrNotFound) {+ if b.failures >= breakerThreshold {+ log.Info("Artwork: Circuit breaker closed for agent", "agent", name)+ }+ b.failures = 0+ return+ }+ b.failures+++ if b.failures == breakerThreshold {+ b.openedAt = time.Now()+ log.Warn("Artwork: Circuit breaker opened for agent", "agent", name,+ "consecutiveFailures", b.failures, "probeAfter", breakerProbeAfter, err)+ }+}diff --git a/core/artwork/hash_encoder_bench_test.go b/core/artwork/hash_encoder_bench_test.gonew file mode 100644index 000000000..2bc4b90ba--- /dev/null+++ b/core/artwork/hash_encoder_bench_test.go@@ -0,0 +1,51 @@+package artwork++import (+ "fmt"+ "image"+ "testing"++ "github.com/navidrome/navidrome/core/artwork/blurhash"+ "github.com/navidrome/navidrome/core/artwork/thumbhash"+)++// hashEncoders are the two placeholder hashes decodeArtwork computes from one shared thumbnail.+var hashEncoders = []struct {+ name string+ encode func(image.Image) error+}{+ {"blurhash", func(img image.Image) error { _, err := blurhash.Encode(img); return err }},+ {"thumbhash", func(img image.Image) error { _, err := thumbhash.Encode(img); return err }},+}++func benchEncoder(b *testing.B, encode func(image.Image) error, img image.Image) {+ b.Helper()+ b.ReportAllocs()+ for b.Loop() {+ if err := encode(img); err != nil {+ b.Fatal(err)+ }+ }+}++// BenchmarkHashEncodersAtInputSize is the bar: both encoders are handed the identical image+// makeThumbnail produces, so neither is measured with a conversion the other avoids.+func BenchmarkHashEncodersAtInputSize(b *testing.B) {+ img := gradientNRGBA(thumbnailSize)+ for _, e := range hashEncoders {+ b.Run(e.name, func(b *testing.B) { benchEncoder(b, e.encode, img) })+ }+}++// BenchmarkHashEncoders sweeps past the pipeline's input size, where each package's own defensive+// downscale starts to dominate. thumbnailSize itself is covered by the benchmark above.+func BenchmarkHashEncoders(b *testing.B) {+ for _, size := range []int{300, 600, 900, 1200, 1500} {+ img := gradientNRGBA(size)+ for _, e := range hashEncoders {+ b.Run(fmt.Sprintf("%s/%dx%d", e.name, size, size), func(b *testing.B) {+ benchEncoder(b, e.encode, img)+ })+ }+ }+}diff --git a/core/artwork/housekeeping.go b/core/artwork/housekeeping.gonew file mode 100644index 000000000..ce72a6c8e--- /dev/null+++ b/core/artwork/housekeeping.go@@ -0,0 +1,129 @@+package artwork++import (+ "context"+ "crypto/md5"+ "encoding/hex"+ "fmt"+ "slices"+ "time"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/core/auth"+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/utils/slice"+)++const staleAbsentAge = 24 * time.Hour++// recheckKinds omits media files: they resolve embedded-only, at scan or on view.+var recheckKinds = []model.Kind{+ model.KindArtistArtwork, model.KindAlbumArtwork, model.KindPlaylistArtwork, model.KindRadioArtwork,+}++// hasRecheckPath reports whether a periodic job will revisit this kind, making an absent settle recoverable.+func hasRecheckPath(prefix string) bool {+ kind, ok := model.ParseKind(prefix)+ return ok && slices.Contains(recheckKinds, kind)+}++// artworkEpoch invalidates all resolution state when bumped; bump it whenever resolution semantics change.+const artworkEpoch = 1++// fingerprint covers the inputs that affect resolution outcomes; a change invalidates stored state.+func fingerprint() string {+ raw := fmt.Sprintf("%s|%s|%s|%s|%t|%t|%d",+ conf.Server.CoverArtPriority, conf.Server.ArtistArtPriority, conf.Server.ArtistImageFolder,+ conf.Server.Agents, conf.Server.EnableExternalServices, conf.Server.EnableM3UExternalAlbumArt, artworkEpoch)+ sum := md5.Sum([]byte(raw)) //nolint:gosec // fingerprint, not security-sensitive+ return hex.EncodeToString(sum[:])+}++// backfill enqueues artwork resolution for every entity when the config fingerprint changed.+func backfill(ctx context.Context, ds model.DataStore) (bool, error) {+ start := time.Now()+ ctx = auth.WithAdminUser(ctx, ds)+ current := fingerprint()+ props := ds.Property(ctx)+ stored, err := props.DefaultGet(consts.ArtConfFingerprintPropertyKey, "")+ if err != nil {+ return false, err+ }+ if stored == current {+ return false, nil+ }++ // Artists first: few entities, most external-dependent, so they get a queue headstart.+ kinds := []struct {+ kind model.Kind+ fetch func() ([]string, error)+ }{+ {model.KindArtistArtwork, func() ([]string, error) { return ds.Artist(ctx).GetAllIDs() }},+ {model.KindAlbumArtwork, func() ([]string, error) { return ds.Album(ctx).GetAllIDs() }},+ {model.KindPlaylistArtwork, func() ([]string, error) { return ds.Playlist(ctx).GetAllIDs() }},+ {model.KindRadioArtwork, func() ([]string, error) { return ds.Radio(ctx).GetAllIDs() }},+ }+ for _, k := range kinds {+ ids, err := k.fetch()+ if err != nil {+ return false, err+ }+ if err := enqueueBackfillKind(ctx, ds, k.kind, ids); err != nil {+ return false, err+ }+ }++ if err := props.Put(consts.ArtConfFingerprintPropertyKey, current); err != nil {+ return false, err+ }+ log.Info(ctx, "Artwork: Config fingerprint changed, backfill enqueued", "elapsed", time.Since(start))+ return true, nil+}++func enqueueBackfillKind(ctx context.Context, ds model.DataStore, kind model.Kind, ids []string) error {+ if len(ids) == 0 {+ return nil+ }+ items := slice.Map(ids, func(id string) model.ArtworkQueueItem {+ return model.ArtworkQueueItem{+ ItemKind: kind.Prefix(), ItemID: id, ImageType: model.ImageTypePrimary, Priority: model.ArtworkPriorityBackfill,+ }+ })+ return ds.ArtworkQueue(ctx).Enqueue(items...)+}++func enqueueStaleAbsentAll(ctx context.Context, ds model.DataStore) error {+ cutoff := time.Now().Add(-staleAbsentAge)+ queue := ds.ArtworkQueue(ctx)+ for _, kind := range recheckKinds {+ if _, err := queue.EnqueueStaleAbsent(kind, cutoff); err != nil {+ return err+ }+ }+ return nil+}++// enqueueMissingAll is the safety net for entities a scan never enqueued (added between scans, or scanner off).+func enqueueMissingAll(ctx context.Context, ds model.DataStore) error {+ queue := ds.ArtworkQueue(ctx)+ for _, kind := range recheckKinds {+ if _, err := queue.EnqueueAllMissing(kind, model.ArtworkPriorityRecheck); err != nil {+ return err+ }+ }+ return nil+}++// Refresh drops an item's resolved artwork state and re-queues it at Bump priority.+func Refresh(ctx context.Context, ds model.DataStore, kind model.Kind, id string) error {+ if err := ds.Artwork(ctx).DeleteForItems(kind, []string{id}); err != nil {+ return fmt.Errorf("clearing artwork state: %w", err)+ }+ item := model.ArtworkQueueItem{ItemKind: kind.Prefix(), ItemID: id, ImageType: model.ImageTypePrimary, Priority: model.ArtworkPriorityBump}+ if err := ds.ArtworkQueue(ctx).Enqueue(item); err != nil {+ return fmt.Errorf("enqueuing artwork refresh: %w", err)+ }+ return nil+}diff --git a/core/artwork/housekeeping_test.go b/core/artwork/housekeeping_test.gonew file mode 100644index 000000000..3b75c5186--- /dev/null+++ b/core/artwork/housekeeping_test.go@@ -0,0 +1,261 @@+package artwork++import (+ "context"+ "slices"+ "time"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest"+ "github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/model/request"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++// visibilityPlaylistDS models playlist_repository's userFilter: a private playlist is only+// visible when the ctx carries an admin, so headless work must wrap ctx with one first.+type visibilityPlaylistDS struct {+ *tests.MockDataStore+ private model.Playlist+ tracks model.PlaylistTrackRepository+}++func (v *visibilityPlaylistDS) Playlist(ctx context.Context) model.PlaylistRepository {+ repo := tests.CreateMockPlaylistRepo()+ repo.TracksRepo = v.tracks+ if u, ok := request.UserFrom(ctx); ok && u.IsAdmin {+ repo.SetData(model.Playlists{v.private})+ }+ return repo+}++func adminUserRepo() *tests.MockedUserRepo {+ repo := tests.CreateMockUserRepo()+ Expect(repo.Put(&model.User{ID: "admin", UserName: "admin", IsAdmin: true})).To(Succeed())+ return repo+}++// orderTrackingQueueRepo records the item kind of each Enqueue call, so tests can+// assert phase ordering (artists-first) that same-priority timestamps can't guarantee.+type orderTrackingQueueRepo struct {+ *tests.MockArtworkQueueRepo+ callKinds []string+}++func (o *orderTrackingQueueRepo) Enqueue(items ...model.ArtworkQueueItem) error {+ if len(items) > 0 {+ o.callKinds = append(o.callKinds, items[0].ItemKind)+ }+ return o.MockArtworkQueueRepo.Enqueue(items...)+}++var _ = Describe("Housekeeping", func() {+ var (+ ctx context.Context+ ds *tests.MockDataStore+ queueRepo *orderTrackingQueueRepo+ propRepo *tests.MockedPropertyRepo+ )++ BeforeEach(func() {+ DeferCleanup(configtest.SetupConfig())+ ctx = context.Background()+ conf.Server.CoverArtPriority = "embedded, folder"+ conf.Server.ArtistArtPriority = "artist.jpg"+ conf.Server.Agents = "spotify"+ conf.Server.EnableExternalServices = true++ queueRepo = &orderTrackingQueueRepo{MockArtworkQueueRepo: tests.CreateMockArtworkQueueRepo()}+ propRepo = &tests.MockedPropertyRepo{}+ ds = &tests.MockDataStore{MockedArtworkQueue: queueRepo, MockedProperty: propRepo}+ })++ seedEntities := func() {+ artistRepo := tests.CreateMockArtistRepo()+ artistRepo.SetData(model.Artists{{ID: "ar1"}, {ID: "ar2"}})+ ds.MockedArtist = artistRepo++ albumRepo := tests.CreateMockAlbumRepo()+ albumRepo.SetData(model.Albums{{ID: "al1"}})+ ds.MockedAlbum = albumRepo++ playlistRepo := tests.CreateMockPlaylistRepo()+ playlistRepo.SetData(model.Playlists{{ID: "pl1"}})+ ds.MockedPlaylist = playlistRepo++ radioRepo := tests.CreateMockedRadioRepo()+ radioRepo.All = model.Radios{{ID: "ra1"}}+ ds.MockedRadio = radioRepo+ }++ Describe("Fingerprint", func() {+ It("changes when a fingerprint-affecting config value changes", func() {+ f1 := fingerprint()+ conf.Server.CoverArtPriority = "folder, embedded"+ f2 := fingerprint()+ Expect(f1).NotTo(Equal(f2))+ })++ It("changes when ArtistImageFolder changes", func() {+ conf.Server.ArtistImageFolder = "/before"+ f1 := fingerprint()+ conf.Server.ArtistImageFolder = "/after"+ Expect(fingerprint()).NotTo(Equal(f1))+ })++ It("changes when EnableM3UExternalAlbumArt is toggled", func() {+ conf.Server.EnableM3UExternalAlbumArt = false+ f1 := fingerprint()+ conf.Server.EnableM3UExternalAlbumArt = true+ Expect(fingerprint()).NotTo(Equal(f1))+ })++ It("does not change when the server version changes", func() {+ original := consts.Version+ DeferCleanup(func() { consts.Version = original })+ f1 := fingerprint()+ consts.Version = original + "-next"+ Expect(fingerprint()).To(Equal(f1),+ "the version must not invalidate artwork state: it would re-resolve every entity on every build")+ })+ })++ Describe("Backfill", func() {+ It("enqueues nothing and returns false when the stored fingerprint matches", func() {+ seedEntities()+ Expect(propRepo.Put(consts.ArtConfFingerprintPropertyKey, fingerprint())).To(Succeed())++ did, err := backfill(ctx, ds)+ Expect(err).ToNot(HaveOccurred())+ Expect(did).To(BeFalse())++ count, err := queueRepo.Count()+ Expect(err).ToNot(HaveOccurred())+ Expect(count).To(BeZero())+ })++ It("runs the backfill when no fingerprint was ever stored", func() {+ seedEntities()++ did, err := backfill(ctx, ds)+ Expect(err).ToNot(HaveOccurred())+ Expect(did).To(BeTrue())++ count, err := queueRepo.Count()+ Expect(err).ToNot(HaveOccurred())+ Expect(count).To(Equal(int64(5))) // 2 artists + 1 album + 1 playlist + 1 radio++ stored, err := propRepo.Get(consts.ArtConfFingerprintPropertyKey)+ Expect(err).ToNot(HaveOccurred())+ Expect(stored).To(Equal(fingerprint()))+ })++ It("enqueues a private playlist by resolving it under an admin context", func() {+ ds.MockedUser = adminUserRepo()+ vds := &visibilityPlaylistDS{+ MockDataStore: ds,+ private: model.Playlist{ID: "plPrivate", OwnerID: "admin"},+ tracks: &tests.MockPlaylistTrackRepo{},+ }++ did, err := backfill(ctx, vds)+ Expect(err).ToNot(HaveOccurred())+ Expect(did).To(BeTrue())+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "pl", "plPrivate")).ToNot(BeNil())+ })++ It("enqueues artists before albums/playlists/radios, all at Backfill priority", func() {+ seedEntities()+ Expect(propRepo.Put(consts.ArtConfFingerprintPropertyKey, "stale-fingerprint")).To(Succeed())++ did, err := backfill(ctx, ds)+ Expect(err).ToNot(HaveOccurred())+ Expect(did).To(BeTrue())++ Expect(queueRepo.callKinds).ToNot(BeEmpty())+ firstOther := slices.IndexFunc(queueRepo.callKinds, func(k string) bool { return k != "ar" })+ Expect(firstOther).ToNot(Equal(0), "artists must be the first Enqueue call")+ if firstOther >= 0 {+ Expect(queueRepo.callKinds[firstOther:]).ToNot(ContainElement("ar"),+ "no artist Enqueue may follow another kind")+ }++ for _, it := range queueRepo.Data {+ Expect(it.Priority).To(Equal(model.ArtworkPriorityBackfill))+ Expect(it.ItemKind).To(BeElementOf("ar", "al", "pl", "ra"))+ }+ })+ })++ Describe("EnqueueStaleAbsentAll", func() {+ var artRepo *tests.MockArtworkRepo++ BeforeEach(func() {+ artRepo = tests.CreateMockArtworkRepo()+ ds.MockedArtwork = artRepo+ queueRepo.ItemArtworkSource = artRepo+ })++ It("enqueues only absent entries older than the recheck window, across all kinds", func() {+ old := time.Now().Add(-48 * time.Hour)+ recent := time.Now().Add(-time.Hour)++ artRepo.ItemData["ar-stale"] = model.ItemArtwork{ItemKind: "ar", ItemID: "ar1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: old}+ artRepo.ItemData["al-stale"] = model.ItemArtwork{ItemKind: "al", ItemID: "al1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: old}+ artRepo.ItemData["pl-stale"] = model.ItemArtwork{ItemKind: "pl", ItemID: "pl1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: old}+ artRepo.ItemData["ra-stale"] = model.ItemArtwork{ItemKind: "ra", ItemID: "ra1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: old}+ artRepo.ItemData["ar-recent"] = model.ItemArtwork{ItemKind: "ar", ItemID: "ar2", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: recent}+ artRepo.ItemData["al-resolved"] = model.ItemArtwork{ItemKind: "al", ItemID: "al2", ImageType: model.ImageTypePrimary, Hash: "somehash", AttemptedAt: old}++ err := enqueueStaleAbsentAll(ctx, ds)+ Expect(err).ToNot(HaveOccurred())++ Expect(queueRepo.Data).To(HaveLen(4))+ for _, it := range queueRepo.Data {+ Expect(it.Priority).To(Equal(model.ArtworkPriorityRecheck))+ }+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "ar", "ar1")).ToNot(BeNil())+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "al", "al1")).ToNot(BeNil())+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "pl", "pl1")).ToNot(BeNil())+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "ra", "ra1")).ToNot(BeNil())+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "ar", "ar2")).To(BeNil())+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "al", "al2")).To(BeNil())+ })+ })++ Describe("EnqueueMissingAll", func() {+ var artRepo *tests.MockArtworkRepo++ BeforeEach(func() {+ artRepo = tests.CreateMockArtworkRepo()+ ds.MockedArtwork = artRepo+ queueRepo.ItemArtworkSource = artRepo+ queueRepo.ExistingIDs = map[string]map[string]bool{+ "al": {"al1": true, "al2": true},+ "ar": {"ar1": true},+ "pl": {"pl1": true},+ "ra": {"ra1": true},+ }+ })++ It("enqueues only entities that have no item_artwork row, across all kinds", func() {+ artRepo.ItemData["al-resolved"] = model.ItemArtwork{ItemKind: "al", ItemID: "al1", ImageType: model.ImageTypePrimary, Hash: "somehash", AttemptedAt: time.Now()}+ artRepo.ItemData["ar-absent"] = model.ItemArtwork{ItemKind: "ar", ItemID: "ar1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: time.Now()}++ err := enqueueMissingAll(ctx, ds)+ Expect(err).ToNot(HaveOccurred())++ for _, it := range queueRepo.Data {+ Expect(it.Priority).To(Equal(model.ArtworkPriorityRecheck))+ }+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "al", "al2")).ToNot(BeNil())+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "pl", "pl1")).ToNot(BeNil())+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "ra", "ra1")).ToNot(BeNil())+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "al", "al1")).To(BeNil())+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "ar", "ar1")).To(BeNil())+ })+ })+})diff --git a/core/artwork/image_cache.go b/core/artwork/image_cache.goindex ac0f63794..39938a755 100644--- a/core/artwork/image_cache.go+++ b/core/artwork/image_cache.go@@ -1,30 +1,22 @@package artworkimport (+ "bytes""context"- "fmt""io"- "time""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/core/ffmpeg""github.com/navidrome/navidrome/utils/cache""github.com/navidrome/navidrome/utils/singleton")-type cacheKey struct {- artID model.ArtworkID- lastUpdate time.Time-}--func (k *cacheKey) Key() string {- return fmt.Sprintf(- "%s-%s.%d",- k.artID.Kind,- k.artID.ID,- k.lastUpdate.UnixMilli(),- )+// artworkReader is the cache.Item the image cache loader dispatches on: Reader+// produces the (possibly resized) bytes to store under Key.+type artworkReader interface {+ cache.Item+ Reader(ctx context.Context) (io.ReadCloser, error)}type imageCache struct {@@ -36,9 +28,45 @@ func GetImageCache() cache.FileCache {return &imageCache{FileCache: cache.NewFileCache("Image", conf.Server.ImageCacheSize, consts.ImageCacheDir, consts.DefaultImageCacheMaxItems,func(ctx context.Context, arg cache.Item) (io.Reader, error) {- r, _, err := arg.(artworkReader).Reader(ctx)- return r, err+ return arg.(artworkReader).Reader(ctx)}),}})}++// resizedItem is an artworkReader that resizes bytes opened by open() and caches the+// result under a hash-derived key.+type resizedItem struct {+ hash string+ size int+ square bool+ ffmpeg ffmpeg.FFmpeg+ open func() (io.ReadCloser, error)+}++// Key is the ETag namespaced for the cache, so the validator a client holds and the entry it+// validates can never drift apart.+func (r *resizedItem) Key() string {+ return "h-" + representationTag(r.hash, r.size, r.square)+}++func (r *resizedItem) Reader(ctx context.Context) (io.ReadCloser, error) {+ orig, err := r.open()+ if err != nil {+ return nil, err+ }+ defer orig.Close()+ data, err := readCapped(orig)+ if err != nil {+ return nil, err+ }+ resized, _, err := resizeImageData(ctx, r.ffmpeg, data, r.size, r.square)+ if err != nil || resized == nil {+ // Resize failed or image already within bounds: serve the original bytes.+ return io.NopCloser(bytes.NewReader(data)), nil+ }+ if rc, ok := resized.(io.ReadCloser); ok {+ return rc, nil+ }+ return io.NopCloser(resized), nil+}diff --git a/core/artwork/image_store.go b/core/artwork/image_store.gonew file mode 100644index 000000000..5dbe727e4--- /dev/null+++ b/core/artwork/image_store.go@@ -0,0 +1,155 @@+package artwork++import (+ "context"+ "errors"+ "fmt"+ "io"+ "io/fs"+ "os"+ "path/filepath"+ "strings"+ "time"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/log"+ "github.com/zeebo/xxh3"+)++// ImageStore is the content-addressed store for artwork images with no library file backing them.+type ImageStore struct {+ root string+}++func NewImageStore(rootDir string) *ImageStore {+ return &ImageStore{root: rootDir}+}++func GetImageStore() *ImageStore {+ return NewImageStore(filepath.Join(conf.Server.DataFolder.String(), consts.ArtworkFolder, consts.HashedArtworkFolder))+}++// extForMime must stay stable across OSes: extensions are baked into stored paths and re-derived on Open.+func extForMime(m string) string {+ switch m {+ case "image/jpeg":+ return ".jpg"+ case "image/png":+ return ".png"+ case "image/gif":+ return ".gif"+ case "image/webp":+ return ".webp"+ }+ return ".img"+}++func hashImage(r io.Reader) (string, error) {+ d := xxh3.New()+ if _, err := io.Copy(d, r); err != nil {+ return "", err+ }+ return fmt.Sprintf("%016x", d.Sum64()), nil+}++// validHash guards path sharding: a malformed hash would slice-panic or inject path separators.+func validHash(hash string) bool {+ if len(hash) != 16 {+ return false+ }+ for _, c := range []byte(hash) {+ if (c < '0' || c > '9') && (c < 'a' || c > 'f') {+ return false+ }+ }+ return true+}++func (s *ImageStore) path(hash, mimeType string) string {+ return filepath.Join(s.root, hash[0:2], hash[2:4], hash+extForMime(mimeType))+}++func (s *ImageStore) Write(hash, mimeType string, r io.Reader) error {+ if !validHash(hash) {+ return fmt.Errorf("imagestore: invalid hash %q", hash)+ }+ dst := s.path(hash, mimeType)+ if _, err := os.Stat(dst); err == nil {+ // A touched mtime marks the file live so a concurrent prune spares it.+ now := time.Now()+ if err := os.Chtimes(dst, now, now); err == nil {+ return nil+ }+ // touch failed (likely pruned concurrently) — fall through and rewrite it+ }+ if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {+ return err+ }+ tmp, err := os.CreateTemp(filepath.Dir(dst), "."+hash+".tmp*")+ if err != nil {+ return err+ }+ defer os.Remove(tmp.Name())+ if _, err := io.Copy(tmp, r); err != nil {+ tmp.Close()+ return err+ }+ if err := tmp.Close(); err != nil {+ return err+ }+ return os.Rename(tmp.Name(), dst)+}++func (s *ImageStore) Open(hash, mimeType string) (io.ReadCloser, error) {+ if !validHash(hash) {+ return nil, fmt.Errorf("imagestore: invalid hash %q", hash)+ }+ return os.Open(s.path(hash, mimeType))+}++// Sweep removes store files not accepted by keep. Files modified after cutoff are always+// kept: their acquisition row may not be committed yet.+func (s *ImageStore) Sweep(ctx context.Context, cutoff time.Time, keep func(hash, ext string) bool) (int, error) {+ removed, failed := 0, 0+ var lastErr error+ err := filepath.WalkDir(s.root, func(path string, d fs.DirEntry, err error) error {+ if err != nil || d.IsDir() {+ return err+ }+ if err := ctx.Err(); err != nil {+ return err+ }+ info, err := d.Info()+ if err != nil {+ return err+ }+ if info.ModTime().After(cutoff) {+ return nil+ }+ name := d.Name()+ remove := strings.HasPrefix(name, ".") // abandoned temp file past the grace window+ if !remove {+ ext := filepath.Ext(name)+ remove = !keep(strings.TrimSuffix(name, ext), ext)+ }+ if remove {+ // #nosec G122 -- path comes from WalkDir over our own store root, no attacker-controlled symlinks+ if err := os.Remove(path); err != nil {+ // One unremovable file must not strand the rest of the store until the next prune.+ failed, lastErr = failed+1, err+ return nil //nolint:nilerr // counted and reported in aggregate below+ }+ removed+++ }+ return nil+ })+ // Aggregated: a store that has gone read-only would otherwise warn once per file, every prune.+ if failed > 0 {+ log.Warn(ctx, "Artwork: Could not remove store files", "count", failed, "swept", removed, lastErr)+ }+ if errors.Is(err, fs.ErrNotExist) {+ return removed, nil+ }+ return removed, err+}diff --git a/core/artwork/image_store_test.go b/core/artwork/image_store_test.gonew file mode 100644index 000000000..f7b2467ca--- /dev/null+++ b/core/artwork/image_store_test.go@@ -0,0 +1,228 @@+package artwork++import (+ "bytes"+ "context"+ "io"+ "os"+ "path/filepath"+ "time"++ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++var _ = Describe("ImageStore", func() {+ var store *ImageStore+ var root string+ var ctx context.Context++ BeforeEach(func() {+ root = GinkgoT().TempDir()+ store = NewImageStore(root)+ ctx = context.Background()+ })++ It("hashes deterministically", func() {+ h1, err := hashImage(bytes.NewReader([]byte("some image bytes")))+ Expect(err).ToNot(HaveOccurred())+ h2, _ := hashImage(bytes.NewReader([]byte("some image bytes")))+ Expect(h1).To(Equal(h2))+ Expect(h1).To(HaveLen(16))+ h3, _ := hashImage(bytes.NewReader([]byte("other bytes")))+ Expect(h3).ToNot(Equal(h1))+ })++ It("writes sharded and reads back", func() {+ data := []byte("jpeg-bytes")+ h, _ := hashImage(bytes.NewReader(data))+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())++ Expect(filepath.Join(root, h[0:2], h[2:4], h+".jpg")).To(BeAnExistingFile())++ rc, err := store.Open(h, "image/jpeg")+ Expect(err).ToNot(HaveOccurred())+ defer rc.Close()+ got, _ := io.ReadAll(rc)+ Expect(got).To(Equal(data))+ })++ It("is idempotent on duplicate writes and preserves the original content", func() {+ data := []byte("dup")+ h, _ := hashImage(bytes.NewReader(data))+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())+ // A duplicate write only touches mtime; passing different bytes under the same+ // hash proves the second reader is never consumed to overwrite the file.+ Expect(store.Write(h, "image/png", bytes.NewReader([]byte("not-dup")))).To(Succeed())++ rc, err := store.Open(h, "image/png")+ Expect(err).ToNot(HaveOccurred())+ defer rc.Close()+ got, err := io.ReadAll(rc)+ Expect(err).ToNot(HaveOccurred())+ Expect(got).To(Equal(data))+ })++ It("refreshes the mtime on a duplicate write", func() {+ data := []byte("touch-me")+ h, _ := hashImage(bytes.NewReader(data))+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())+ old := time.Now().Add(-2 * time.Hour)+ Expect(os.Chtimes(store.path(h, "image/png"), old, old)).To(Succeed())++ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())++ info, err := os.Stat(store.path(h, "image/png"))+ Expect(err).ToNot(HaveOccurred())+ Expect(info.ModTime()).To(BeTemporally(">", time.Now().Add(-time.Minute)))+ })++ It("rewrites the bytes when the existing file vanished before the liveness touch", func() {+ data := []byte("vanishing")+ h, _ := hashImage(bytes.NewReader(data))+ for range 10 {+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())+ Expect(os.Remove(store.path(h, "image/png"))).To(Succeed())+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())++ rc, err := store.Open(h, "image/png")+ Expect(err).ToNot(HaveOccurred())+ got, _ := io.ReadAll(rc)+ rc.Close()+ Expect(got).To(Equal(data))+ }+ })++ It("returns fs.ErrNotExist for missing images", func() {+ _, err := store.Open("beefbeefbeefbeef", "image/jpeg")+ Expect(os.IsNotExist(err)).To(BeTrue())+ })++ It("rejects invalid hashes instead of panicking", func() {+ for _, h := range []string{"", "ab", "BEEFBEEFBEEFBEEF", "../../../../etcpw", "beefbeefbeefbee/"} {+ Expect(store.Write(h, "image/jpeg", bytes.NewReader([]byte("x")))).To(MatchError(ContainSubstring("invalid hash")))+ _, err := store.Open(h, "image/jpeg")+ Expect(err).To(MatchError(ContainSubstring("invalid hash")))+ }+ })++ It("sweeps unknown files, keeps known ones", func() {+ d1 := []byte("keep-me")+ h1, _ := hashImage(bytes.NewReader(d1))+ Expect(store.Write(h1, "image/jpeg", bytes.NewReader(d1))).To(Succeed())+ d2 := []byte("orphan")+ h2, _ := hashImage(bytes.NewReader(d2))+ Expect(store.Write(h2, "image/jpeg", bytes.NewReader(d2))).To(Succeed())++ old := time.Now().Add(-2 * time.Hour)+ Expect(os.Chtimes(store.path(h2, "image/jpeg"), old, old)).To(Succeed())++ removed, err := store.Sweep(ctx, time.Now().Add(-time.Hour), func(h, _ string) bool { return h == h1 })+ Expect(err).ToNot(HaveOccurred())+ Expect(removed).To(Equal(1))+ _, err = store.Open(h2, "image/jpeg")+ Expect(os.IsNotExist(err)).To(BeTrue())+ rc, err := store.Open(h1, "image/jpeg")+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })++ It("sweeps a stale mime variant of a known hash, keeps the current one", func() {+ data := []byte("same-bytes")+ h, _ := hashImage(bytes.NewReader(data))+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())+ old := time.Now().Add(-2 * time.Hour)+ Expect(os.Chtimes(store.path(h, "image/png"), old, old)).To(Succeed())+ Expect(os.Chtimes(store.path(h, "image/jpeg"), old, old)).To(Succeed())++ // The recorded mime is image/jpeg, so the .png variant is obsolete.+ removed, err := store.Sweep(ctx, time.Now().Add(-time.Hour), func(hash, ext string) bool {+ return hash == h && ext == ".jpg"+ })+ Expect(err).ToNot(HaveOccurred())+ Expect(removed).To(Equal(1))+ _, err = store.Open(h, "image/png")+ Expect(os.IsNotExist(err)).To(BeTrue())+ rc, err := store.Open(h, "image/jpeg")+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })++ It("keeps young unknown files inside the grace window", func() {+ d := []byte("fresh-orphan")+ h, _ := hashImage(bytes.NewReader(d))+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(d))).To(Succeed())++ removed, err := store.Sweep(ctx, time.Now().Add(-time.Hour), func(string, string) bool { return false })+ Expect(err).ToNot(HaveOccurred())+ Expect(removed).To(Equal(0))+ rc, err := store.Open(h, "image/jpeg")+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })++ It("removes abandoned temp files past the grace window, keeps fresh ones", func() {+ oldTmp := filepath.Join(root, ".old.tmp")+ Expect(os.WriteFile(oldTmp, []byte("x"), 0600)).To(Succeed())+ old := time.Now().Add(-2 * time.Hour)+ Expect(os.Chtimes(oldTmp, old, old)).To(Succeed())++ freshTmp := filepath.Join(root, ".fresh.tmp")+ Expect(os.WriteFile(freshTmp, []byte("y"), 0600)).To(Succeed())++ removed, err := store.Sweep(ctx, time.Now().Add(-time.Hour), func(string, string) bool { return true })+ Expect(err).ToNot(HaveOccurred())+ Expect(removed).To(Equal(1))+ Expect(oldTmp).ToNot(BeAnExistingFile())+ Expect(freshTmp).To(BeAnExistingFile())+ })++ It("keeps sweeping past a file it cannot remove", func() {+ tests.SkipOnWindows("uses Unix file permission bits")+ if os.Geteuid() == 0 {+ Skip("read-only dir cannot block root (e.g. tests in a container)")+ }+ old := time.Now().Add(-2 * time.Hour)+ // "blocked" sorts before "ok", so the walk hits the unremovable file first.+ blockedDir := filepath.Join(root, "blocked")+ Expect(os.MkdirAll(blockedDir, 0755)).To(Succeed())+ blocked := filepath.Join(blockedDir, "a.jpg")+ Expect(os.WriteFile(blocked, []byte("x"), 0600)).To(Succeed())+ Expect(os.Chtimes(blocked, old, old)).To(Succeed())++ okDir := filepath.Join(root, "ok")+ Expect(os.MkdirAll(okDir, 0755)).To(Succeed())+ reachable := filepath.Join(okDir, "b.jpg")+ Expect(os.WriteFile(reachable, []byte("y"), 0600)).To(Succeed())+ Expect(os.Chtimes(reachable, old, old)).To(Succeed())++ Expect(os.Chmod(blockedDir, 0500)).To(Succeed())+ DeferCleanup(func() { _ = os.Chmod(blockedDir, 0755) })++ removed, err := store.Sweep(ctx, time.Now().Add(-time.Hour), func(string, string) bool { return false })+ Expect(err).ToNot(HaveOccurred())+ Expect(removed).To(Equal(1))+ Expect(blocked).To(BeAnExistingFile())+ Expect(reachable).ToNot(BeAnExistingFile())+ })++ // Prune holds the worker's write lock for the whole sweep, and shutdown waits on the+ // worker, so an uncancellable walk over a large store stalls it until SIGKILL.+ It("abandons the walk when the context is cancelled", func() {+ old := time.Now().Add(-2 * time.Hour)+ for _, name := range []string{"a", "b", "c", "d"} {+ p := filepath.Join(root, name+".jpg")+ Expect(os.WriteFile(p, []byte("x"), 0600)).To(Succeed())+ Expect(os.Chtimes(p, old, old)).To(Succeed())+ }+ cancelCtx, cancel := context.WithCancel(ctx)+ cancel()++ _, err := store.Sweep(cancelCtx, time.Now().Add(-time.Hour), func(string, string) bool { return false })+ Expect(err).To(MatchError(context.Canceled))+ matches, _ := filepath.Glob(filepath.Join(root, "*.jpg"))+ Expect(matches).To(HaveLen(4), "a cancelled sweep must not keep deleting")+ })+})diff --git a/core/artwork/library_fs.go b/core/artwork/library_fs.goindex ff557294e..6e6099325 100644--- a/core/artwork/library_fs.go+++ b/core/artwork/library_fs.go@@ -2,7 +2,9 @@ package artworkimport ("context"+ "net/url""path/filepath"+ "strings""github.com/navidrome/navidrome/core/storage""github.com/navidrome/navidrome/model"@@ -40,5 +42,23 @@ func loadLibraryView(ctx context.Context, ds model.DataStore, libID int) (librarif err != nil {return libraryView{}, err}- return libraryView{FS: fs, absRoot: lib.Path}, nil+ return libraryView{FS: fs, absRoot: localOSRoot(lib.Path)}, nil+}++// localOSRoot maps a library path to its on-disk root so Abs() yields paths os.Open/os.Stat accept:+// a file:// URL becomes its parsed OS path (bare paths already are; non-local schemes stay unchanged).+func localOSRoot(libPath string) string {+ if !strings.Contains(libPath, "://") {+ return libPath+ }+ u, err := url.Parse(libPath)+ if err != nil || u.Scheme != storage.LocalSchemaID {+ return libPath+ }+ // Windows drive URLs (file://C:/Music) put the volume in Host; rejoin it, matching+ // core/storage/local's newLocalStorage so os.Open/os.Stat get a valid path.+ if filepath.VolumeName(u.Host) != "" {+ return filepath.Join(u.Host, u.Path)+ }+ return u.Path}diff --git a/core/artwork/library_fs_test.go b/core/artwork/library_fs_test.goindex acf08fda3..22498e7a1 100644--- a/core/artwork/library_fs_test.go+++ b/core/artwork/library_fs_test.go@@ -32,6 +32,13 @@ var _ = Describe("loadLibraryView", Ordered, func() {Expect(lib.absRoot).To(Equal("fake:///music"))})+ It("normalizes a library path to an OS root that Abs can join for os.Open/os.Stat", func() {+ // file:// URLs become their parsed OS path; bare paths and non-local schemes are unchanged.+ Expect(localOSRoot("file:///music/library")).To(Equal("/music/library"))+ Expect(localOSRoot("/music/library")).To(Equal("/music/library"))+ Expect(localOSRoot("fake:///music")).To(Equal("fake:///music"))+ })+It("returns an error when the library does not exist", func() {_, err := loadLibraryView(ctx, ds, 999)Expect(err).To(HaveOccurred())diff --git a/core/artwork/playlist_cover.go b/core/artwork/playlist_cover.gonew file mode 100644index 000000000..e74b64808--- /dev/null+++ b/core/artwork/playlist_cover.go@@ -0,0 +1,116 @@+package artwork++import (+ "bytes"+ "context"+ "image"+ "image/draw"+ "image/png"+ "io"+ "os"+ "path/filepath"+ "strings"++ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/utils"+ xdraw "golang.org/x/image/draw"+)++const tileSize = 600++// findPlaylistSidecarPath finds an image beside plsPath with the same base name (case-insensitive).+func findPlaylistSidecarPath(ctx context.Context, plsPath string) string {+ if plsPath == "" {+ return ""+ }+ dir := filepath.Dir(plsPath)+ base := strings.TrimSuffix(filepath.Base(plsPath), filepath.Ext(plsPath))++ entries, err := os.ReadDir(dir)+ if err != nil {+ log.Warn(ctx, "Artwork: Could not read directory for playlist sidecar", "dir", dir, err)+ return ""+ }+ for _, entry := range entries {+ name := entry.Name()+ nameBase := utils.BaseName(name)+ if !entry.IsDir() && strings.EqualFold(nameBase, base) && model.IsImageFile(name) {+ return filepath.Join(dir, name)+ }+ }+ return ""+}++func rect(pos int) image.Rectangle {+ r := image.Rectangle{}+ switch pos {+ case 1:+ r.Min.X = tileSize / 2+ case 2:+ r.Min.Y = tileSize / 2+ case 3:+ r.Min.X = tileSize / 2+ r.Min.Y = tileSize / 2+ }+ r.Max.X = r.Min.X + tileSize/2+ r.Max.Y = r.Min.Y + tileSize/2+ return r+}++// fillCenter center-crops src and scales it to fill dstW x dstH exactly.+func fillCenter(src image.Image, dstW, dstH int) image.Image {+ srcBounds := src.Bounds()+ srcW := srcBounds.Dx()+ srcH := srcBounds.Dy()++ srcAspect := float64(srcW) / float64(srcH)+ dstAspect := float64(dstW) / float64(dstH)++ var cropRect image.Rectangle+ if srcAspect > dstAspect {+ cropW := int(float64(srcH) * dstAspect)+ cropX := (srcW - cropW) / 2+ cropRect = image.Rect(srcBounds.Min.X+cropX, srcBounds.Min.Y, srcBounds.Min.X+cropX+cropW, srcBounds.Max.Y)+ } else {+ cropH := int(float64(srcW) / dstAspect)+ cropY := (srcH - cropH) / 2+ cropRect = image.Rect(srcBounds.Min.X, srcBounds.Min.Y+cropY, srcBounds.Max.X, srcBounds.Min.Y+cropY+cropH)+ }++ dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))+ xdraw.CatmullRom.Scale(dst, dst.Bounds(), src, cropRect, draw.Src, nil)+ return dst+}++// decodeTile runs before the processor's size guards apply, so it enforces the caps itself.+func decodeTile(r io.ReadCloser) (image.Image, error) {+ data, err := readCapped(r)+ if err != nil {+ return nil, err+ }+ img, _, err := decodeCapped(data)+ if err != nil {+ return nil, err+ }+ return fillCenter(img, tileSize/2, tileSize/2), nil+}++func assembleTiles(tiles []image.Image) (io.ReadCloser, error) {+ buf := new(bytes.Buffer)+ var err error+ if len(tiles) == 4 {+ rgba := image.NewRGBA(image.Rectangle{Max: image.Point{X: tileSize - 1, Y: tileSize - 1}})+ draw.Draw(rgba, rect(0), tiles[0], image.Point{}, draw.Src)+ draw.Draw(rgba, rect(1), tiles[1], image.Point{}, draw.Src)+ draw.Draw(rgba, rect(2), tiles[2], image.Point{}, draw.Src)+ draw.Draw(rgba, rect(3), tiles[3], image.Point{}, draw.Src)+ err = png.Encode(buf, rgba)+ } else {+ err = png.Encode(buf, tiles[0])+ }+ if err != nil {+ return nil, err+ }+ return io.NopCloser(buf), nil+}diff --git a/core/artwork/processor.go b/core/artwork/processor.gonew file mode 100644index 000000000..c3cf15b71--- /dev/null+++ b/core/artwork/processor.go@@ -0,0 +1,311 @@+package artwork++import (+ "bytes"+ "context"+ "encoding/base64"+ "errors"+ "fmt"+ "image"+ "image/draw"+ _ "image/gif" // the only artwork format with no other importer in this package+ "io"+ "sync"+ "time"++ "github.com/navidrome/navidrome/core/artwork/blurhash"+ "github.com/navidrome/navidrome/core/artwork/dominant"+ "github.com/navidrome/navidrome/core/artwork/thumbhash"+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+ xdraw "golang.org/x/image/draw"+)++// outcome tells the worker whether to delete the queue row (found/absent) or reschedule it.+type outcome int++const (+ outcomeFound outcome = iota+ // outcomeFoundStale: state was written and is served, but a higher-priority external+ // source failed, so the row must retry to give it another chance.+ outcomeFoundStale+ outcomeAbsent+ outcomeFailed+)++func (o outcome) String() string {+ switch o {+ case outcomeFound:+ return "found"+ case outcomeFoundStale:+ return "foundStale"+ case outcomeAbsent:+ return "absent"+ default:+ return "failed"+ }+}++// thumbnailSize is the max dimension fed to both hash encoders; thumbhash rejects anything larger.+const thumbnailSize = 100++// maxImageBytes caps a resolved image read: a user-editable ExternalImageURL could point at+// an arbitrarily large endpoint.+const maxImageBytes = 20 << 20++// maxImagePixels guards against decompression bombs: a tiny file can declare a canvas that+// image.Decode would expand into gigabytes.+const maxImagePixels = 64 << 20++// acquired is what a successful acquire persisted, handed back so the caller can warm the resize+// cache without re-reading the rows and the file it just wrote.+type acquired struct {+ ia *model.ItemArtwork+ mime string+ data []byte+}++// processor turns one queue item into stored artwork; settling the queue row is the Worker's job.+type processor struct {+ ds model.DataStore+ store *ImageStore+ resolver *resolver+ pruneLock sync.Locker+}++// acquire resolves one queue item end to end: find an image, hash/decode/+// blurhash it, place its bytes, and persist the resulting state.+func (p *processor) acquire(ctx context.Context, item model.ArtworkQueueItem) (out outcome, got *acquired) {+ repo := p.ds.Artwork(ctx)+ start := time.Now()+ defer func() {+ log.Debug(ctx, "Artwork: Acquisition finished", "kind", item.ItemKind, "id", item.ItemID,+ "outcome", out, "elapsed", time.Since(start))+ }()++ res, err := p.resolver.resolve(ctx, item)+ if err != nil {+ log.Warn(ctx, "Artwork: Could not resolve item", "kind", item.ItemKind, "id", item.ItemID, err)+ return outcomeFailed, nil+ }+ if res.reader == nil {+ if res.extError || res.localError {+ // A fault is not a definitive "no image": never settle absent, keep serving old state.+ log.Debug(ctx, "Artwork: No image, but a source faulted; keeping previous state",+ "kind", item.ItemKind, "id", item.ItemID, "extError", res.extError, "localError", res.localError)+ return outcomeFailed, nil+ }+ return writeAbsent(ctx, repo, item), nil+ }+ defer res.reader.Close()++ readStart := time.Now()+ data, err := readCapped(res.reader)+ if err != nil {+ log.Warn(ctx, "Artwork: Failed to read resolved image", "kind", item.ItemKind, "id", item.ItemID, "source", res.source, err)+ return outcomeFailed, nil+ }+ log.Debug(ctx, "Artwork: Read resolved image", "kind", item.ItemKind, "id", item.ItemID,+ "source", res.source, "bytes", len(data), "elapsed", time.Since(readStart))++ hashStart := time.Now()+ hash, err := hashImage(bytes.NewReader(data))+ if err != nil {+ log.Warn(ctx, "Artwork: Failed to hash image", "kind", item.ItemKind, "id", item.ItemID, err)+ return outcomeFailed, nil+ }+ log.Trace(ctx, "Artwork: Hashed image", "kind", item.ItemKind, "id", item.ItemID,+ "hash", hash, "bytes", len(data), "elapsed", time.Since(hashStart))++ art, err := repo.GetImage(hash)+ switch {+ case err == nil:+ log.Debug(ctx, "Artwork: Reusing a known image, skipping decode", "kind", item.ItemKind,+ "id", item.ItemID, "hash", hash)+ case errors.Is(err, model.ErrNotFound):+ decodeStart := time.Now()+ art, err = decodeArtwork(ctx, hash, data)+ if err != nil {+ log.Warn(ctx, "Artwork: Failed to decode resolved image", "kind", item.ItemKind, "id", item.ItemID, err)+ return outcomeFailed, nil+ }+ log.Debug(ctx, "Artwork: Decoded new image", "kind", item.ItemKind, "id", item.ItemID, "hash", hash,+ "width", art.Width, "height", art.Height, "mime", art.Mime, "elapsed", time.Since(decodeStart))+ default:+ log.Warn(ctx, "Artwork: Failed to look up image hash", "kind", item.ItemKind, "id", item.ItemID, err)+ return outcomeFailed, nil+ }+ art.SizeBytes = int64(len(data))++ ia, err := p.persist(repo, item, art, res, data)+ if err != nil {+ log.Warn(ctx, "Artwork: Failed to persist resolved image", "kind", item.ItemKind, "id", item.ItemID, err)+ return outcomeFailed, nil+ }+ got = &acquired{ia: ia, mime: art.Mime, data: data}+ if res.extError {+ log.Debug(ctx, "Artwork: Serving a lower-priority source after an external failure",+ "kind", item.ItemKind, "id", item.ItemID, "source", res.source)+ return outcomeFoundStale, got+ }+ return outcomeFound, got+}++// persist places the bytes and commits the rows referencing them, excluding Prune for that+// window only so a slow resolution can never hold it off.+func (p *processor) persist(repo model.ArtworkRepository, item model.ArtworkQueueItem,+ art *model.Artwork, res resolution, data []byte,+) (*model.ItemArtwork, error) {+ if p.pruneLock != nil {+ p.pruneLock.Lock()+ defer p.pruneLock.Unlock()+ }+ sourcePath, refMtime, err := placeBytes(p.store, art, res, data)+ if err != nil {+ return nil, fmt.Errorf("writing image store: %w", err)+ }+ if err := repo.PutImage(art); err != nil {+ return nil, fmt.Errorf("persisting artwork image: %w", err)+ }+ ia := &model.ItemArtwork{+ ItemKind: item.ItemKind,+ ItemID: item.ItemID,+ ImageType: item.ImageType,+ Hash: art.Hash,+ Source: res.source,+ SourcePath: sourcePath,+ RefMtime: refMtime,+ AttemptedAt: time.Now(),+ }+ // PutItemArtwork stamps UpdatedAt on ia, so the returned struct matches the persisted row.+ if err := repo.PutItemArtwork(ia); err != nil {+ return nil, fmt.Errorf("persisting item artwork state: %w", err)+ }+ return ia, nil+}++// writeAbsent records a known-absent state: every source answered definitively "no".+func writeAbsent(ctx context.Context, repo model.ArtworkRepository, item model.ArtworkQueueItem) outcome {+ err := repo.PutItemArtwork(&model.ItemArtwork{+ ItemKind: item.ItemKind,+ ItemID: item.ItemID,+ ImageType: item.ImageType,+ AttemptedAt: time.Now(),+ })+ if err != nil {+ log.Warn(ctx, "Artwork: Failed to persist absent state", "kind", item.ItemKind, "id", item.ItemID, err)+ return outcomeFailed+ }+ log.Debug(ctx, "Artwork: Settled absent, every source answered definitively",+ "kind", item.ItemKind, "id", item.ItemID)+ return outcomeAbsent+}++func readCapped(r io.Reader) ([]byte, error) {+ data, err := io.ReadAll(io.LimitReader(r, maxImageBytes+1))+ if err != nil {+ return nil, err+ }+ if len(data) > maxImageBytes {+ return nil, fmt.Errorf("image exceeds size cap %d", maxImageBytes)+ }+ return data, nil+}++// decodeCapped rejects declared dimensions over maxImagePixels before the full-decode allocation.+func decodeCapped(data []byte) (image.Image, string, error) {+ cfg, format, err := image.DecodeConfig(bytes.NewReader(data))+ if err != nil {+ return nil, "", fmt.Errorf("decode image config: %w", err)+ }+ // Compared by division so the cap cannot be defeated by an int64 overflow.+ if cfg.Width <= 0 || cfg.Height <= 0 || cfg.Width > maxImagePixels/cfg.Height {+ return nil, "", fmt.Errorf("image dimensions %dx%d exceed pixel cap %d", cfg.Width, cfg.Height, maxImagePixels)+ }+ img, _, err := image.Decode(bytes.NewReader(data))+ if err != nil {+ return nil, "", fmt.Errorf("decode image: %w", err)+ }+ return img, format, nil+}++// decodeArtwork builds a new Artwork row from raw bytes: dimensions, mime and the two+// placeholder hashes, both encoded from one shared downscaled thumbnail.+func decodeArtwork(ctx context.Context, hash string, data []byte) (*model.Artwork, error) {+ img, format, err := decodeCapped(data)+ if err != nil {+ return nil, err+ }++ thumb := makeThumbnail(img, thumbnailSize)+ bh, err := blurhash.Encode(thumb)+ if err != nil {+ log.Warn(ctx, "Artwork: Blurhash encoding failed", "hash", hash, err)+ bh = ""+ }++ var th string+ if raw, err := thumbhash.Encode(thumb); err != nil {+ log.Warn(ctx, "Artwork: Thumbhash encoding failed", "hash", hash, err)+ } else {+ th = base64.StdEncoding.EncodeToString(raw)+ }++ return &model.Artwork{+ Hash: hash,+ Mime: mimeForFormat(format),+ Width: img.Bounds().Dx(),+ Height: img.Bounds().Dy(),+ BlurHash: bh,+ ThumbHash: th,+ DominantColor: dominant.Color(thumb),+ }, nil+}++// makeThumbnail downscales img to fit within maxSize on its longest side; it never upscales.+func makeThumbnail(img image.Image, maxSize int) image.Image {+ b := img.Bounds()+ w, h := b.Dx(), b.Dy()+ if w <= maxSize && h <= maxSize {+ return toFastScaleType(img)+ }+ scale := float64(maxSize) / float64(max(w, h))+ // NRGBA, not RGBA: thumbhash requires straight alpha, and blurhash reads this type without+ // converting, so neither encoder allocates a second copy of the thumbnail.+ dst := image.NewNRGBA(image.Rect(0, 0, max(1, int(float64(w)*scale)), max(1, int(float64(h)*scale))))+ xdraw.CatmullRom.Scale(dst, dst.Bounds(), toFastScaleType(img), b, draw.Src, nil)+ return dst+}++// isFileBacked reports whether the bytes already live in a library/upload file, so the+// content-addressed store must not duplicate them.+func isFileBacked(source string) bool {+ return source == "folder" || source == "upload"+}++// placeBytes reports the item's backing-file provenance and writes the bytes into the store+// for the sources that have none.+func placeBytes(store *ImageStore, art *model.Artwork, res resolution, data []byte) (sourcePath string, refMtime int64, err error) {+ if isFileBacked(res.source) {+ return res.sourcePath, res.refMtime, nil+ }+ if res.source == "embedded" {+ sourcePath, refMtime = res.sourcePath, res.refMtime+ }+ return sourcePath, refMtime, store.Write(art.Hash, art.Mime, bytes.NewReader(data))+}++// mimeForFormat maps an image.Decode format name to its MIME type; extForMime is the inverse.+func mimeForFormat(format string) string {+ switch format {+ case "jpeg":+ return "image/jpeg"+ case "png":+ return "image/png"+ case "gif":+ return "image/gif"+ case "webp":+ return "image/webp"+ }+ return "application/octet-stream"+}diff --git a/core/artwork/processor_test.go b/core/artwork/processor_test.gonew file mode 100644index 000000000..d326dde09--- /dev/null+++ b/core/artwork/processor_test.go@@ -0,0 +1,495 @@+package artwork++import (+ "context"+ "encoding/binary"+ "errors"+ "hash/crc32"+ "image"+ "image/color"+ "net/http"+ "net/http/httptest"+ "os"+ "path/filepath"+ "runtime"+ "time"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest"+ "github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++// DecodeConfig reads only the header, so the pixel data can be omitted entirely.+func pngHeaderWithDims(w, h uint32) []byte {+ ihdr := make([]byte, 13)+ binary.BigEndian.PutUint32(ihdr[0:], w)+ binary.BigEndian.PutUint32(ihdr[4:], h)+ ihdr[8] = 8 // bit depth+ ihdr[9] = 2 // color type: truecolor+ chunk := append([]byte("IHDR"), ihdr...)+ out := []byte{0x89, 'P', 'N', 'G', 0x0d, 0x0a, 0x1a, 0x0a}+ out = binary.BigEndian.AppendUint32(out, uint32(len(ihdr)))+ out = append(out, chunk...)+ return binary.BigEndian.AppendUint32(out, crc32.ChecksumIEEE(chunk))+}++var _ = Describe("processor.acquire", func() {+ var (+ ctx context.Context+ ds *tests.MockDataStore+ folderRepo *fakeFolderRepo+ libRepo *tests.MockLibraryRepo+ ffm *tests.MockFFmpeg+ ag *agents.Agents+ store *ImageStore+ artRepo *tests.MockArtworkRepo+ repoRoot string+ proc *processor+ )++ BeforeEach(func() {+ DeferCleanup(configtest.SetupConfig())+ ctx = context.Background()+ var err error+ repoRoot, err = os.Getwd()+ Expect(err).ToNot(HaveOccurred())++ folderRepo = &fakeFolderRepo{}+ libRepo = &tests.MockLibraryRepo{}+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})+ ffm = tests.NewMockFFmpeg("")+ ag = agents.GetAgents(&tests.MockDataStore{}, nil)+ artRepo = tests.CreateMockArtworkRepo()+ ds = &tests.MockDataStore{+ MockedFolder: folderRepo,+ MockedLibrary: libRepo,+ MockedArtwork: artRepo,+ }+ ds.MockedAlbum = tests.CreateMockAlbumRepo()+ store = NewImageStore(GinkgoT().TempDir())+ proc = &processor{ds: ds, store: store, resolver: newResolver(ds, ag, ffm, nil)}++ conf.Server.CoverArtPriority = "cover.jpg, embedded"+ })++ It("found-folder: persists state from a folder image, writes no store file, keeps sourcePath/refMtime", func() {+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al1", Name: "Album", FolderIDs: []string{"f1"}},+ })++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al1"})+ Expect(out).To(Equal(outcomeFound))++ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Hash).ToNot(BeEmpty())+ Expect(ia.Source).To(Equal("folder"))+ Expect(filepath.ToSlash(ia.SourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/cover.jpg"))+ Expect(ia.RefMtime).To(BeNumerically(">", 0))++ art, err := artRepo.GetImage(ia.Hash)+ Expect(err).ToNot(HaveOccurred())+ // Every placeholder is derived from the one shared thumbnail, so all three land together.+ Expect(art.BlurHash).ToNot(BeEmpty())+ Expect(art.ThumbHash).ToNot(BeEmpty())+ Expect(art.DominantColor).To(MatchRegexp(`^#[0-9a-f]{6}$`))+ _, err = store.Open(ia.Hash, art.Mime)+ Expect(os.IsNotExist(err)).To(BeTrue(), "folder-backed art must not be duplicated into the store")+ })++ Describe("prune lock scope", func() {+ var lock *countingLocker++ BeforeEach(func() {+ lock = &countingLocker{}+ proc.pruneLock = lock+ })++ It("holds it once across the write window", func() {+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "alL1", Name: "Album", FolderIDs: []string{"f1"}},+ })++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alL1"})+ Expect(out).To(Equal(outcomeFound))+ Expect(lock.locks).To(BeNumerically(">", 0), "the write window must exclude prune")+ Expect(lock.held()).To(BeFalse(), "the window must close before acquire returns")+ })++ // Resolution can reach the network, so holding the lock across it would let one slow+ // provider block prune, and every drain queued behind prune's writer.+ It("never takes it while only resolving", func() {+ folderRepo.result = nil+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "alL2", Name: "Album", FolderIDs: []string{"f1"}},+ })++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alL2"})+ Expect(out).To(Equal(outcomeAbsent))+ Expect(lock.locks).To(BeZero())+ })+ })++ It("found-embedded: writes a store file and computes a non-empty blurhash from a real fixture", func() {+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al2", Name: "Album", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}},+ })+ folderRepo.result = nil++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al2"})+ Expect(out).To(Equal(outcomeFound))++ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al2", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("embedded"))+ Expect(filepath.ToSlash(ia.SourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/test.mp3"))++ art, err := artRepo.GetImage(ia.Hash)+ Expect(err).ToNot(HaveOccurred())+ Expect(art.BlurHash).ToNot(BeEmpty())++ rc, err := store.Open(ia.Hash, art.Mime)+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })++ It("absent: no local source and no external error persists a known-absent state", func() {+ folderRepo.result = nil+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al3", Name: "Album"},+ })++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al3"})+ Expect(out).To(Equal(outcomeAbsent))++ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al3", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Hash).To(BeEmpty())+ Expect(ia.Source).To(BeEmpty())+ Expect(ia.AttemptedAt).To(BeTemporally("~", time.Now(), time.Second))+ })++ It("failed-on-unreadable-local: a listed cover that will not open never records absent", func() {+ conf.Server.CoverArtPriority = "cover.jpg"+ // A folder listing that names a cover the FS will not hand over: a stale mount.+ libRoot := GinkgoT().TempDir()+ Expect(os.MkdirAll(filepath.Join(libRoot, "an-album"), 0o755)).To(Succeed())+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(libRoot)}})+ folderRepo.result = []model.Folder{{Path: "an-album", ImageFiles: []string{"cover.jpg"}}}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al-io", Name: "Album", FolderIDs: []string{"f1"}},+ })++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al-io"})+ Expect(out).To(Equal(outcomeFailed))++ _, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al-io", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound), "an I/O fault must not be recorded as absent")+ })++ // An upload outranks every source, so an unreadable one must not let a lower one take over.+ It("failed-on-unreadable-upload: an upload that will not open never records absent", func() {+ if runtime.GOOS == "windows" {+ // The file would still open, so the spec would pass on the decode error instead.+ Skip("chmod does not restrict read access on Windows")+ }+ radioRepo := tests.CreateMockedRadioRepo()+ radioRepo.Data = map[string]*model.Radio{}+ ds.MockedRadio = radioRepo+ dir := GinkgoT().TempDir()+ conf.Server.DataFolder = conf.NewDir(dir)+ upload := model.UploadedImagePath(consts.EntityRadio, "ra-io.jpg")+ Expect(os.MkdirAll(filepath.Dir(upload), 0o755)).To(Succeed())+ Expect(os.WriteFile(upload, []byte("x"), 0o600)).To(Succeed())+ Expect(os.Chmod(upload, 0o000)).To(Succeed()) // present, but unreadable+ DeferCleanup(func() { _ = os.Chmod(upload, 0o600) })+ radioRepo.Data["ra-io"] = &model.Radio{ID: "ra-io", Name: "Station", UploadedImage: "ra-io.jpg"}++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "ra", ItemID: "ra-io"})+ Expect(out).To(Equal(outcomeFailed))++ _, err := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra-io", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound), "an unreadable upload must not be recorded as absent")+ })++ It("failed-on-extError: leaves the item's state untouched", func() {+ conf.Server.CoverArtPriority = "external"+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al4", Name: "Album"},+ })+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al4"})+ Expect(out).To(Equal(outcomeFailed))++ _, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al4", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ })++ It("found-stale: a fallback hit after a transient external failure persists state and returns outcomeFoundStale", func() {+ conf.Server.CoverArtPriority = "external, cover.jpg"+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "alstale", Name: "Album", FolderIDs: []string{"f1"}},+ })+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alstale"})+ Expect(out).To(Equal(outcomeFoundStale))++ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alstale", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Hash).ToNot(BeEmpty())+ Expect(ia.Source).To(Equal("folder"))+ })++ It("found-external: persists source as external:<agentName> and stores the fetched bytes", func() {+ conf.Server.CoverArtPriority = "external"+ imgBytes, err := os.ReadFile(filepath.Join(repoRoot, "tests/fixtures/artist/an-album/cover.jpg"))+ Expect(err).ToNot(HaveOccurred())+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ _, _ = w.Write(imgBytes)+ }))+ DeferCleanup(srv.Close)++ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "alext", Name: "Album"}})+ imageAgents(&fakeImageAgent{name: "deezerFake", imgs: []agents.ExternalImage{{URL: srv.URL, Size: 500}}})++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alext"})+ Expect(out).To(Equal(outcomeFound))++ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alext", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("external:deezerFake"))+ Expect(ia.Hash).ToNot(BeEmpty())++ art, err := artRepo.GetImage(ia.Hash)+ Expect(err).ToNot(HaveOccurred())+ rc, err := store.Open(ia.Hash, art.Mime)+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })++ It("dedup: a second item with identical bytes skips decode and reuses the artwork row", func() {+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al5", Name: "Album A", FolderIDs: []string{"f1"}},+ {ID: "al6", Name: "Album B", FolderIDs: []string{"f1"}},+ })++ out1, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al5"})+ Expect(out1).To(Equal(outcomeFound))+ ia1, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al5", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())++ // A re-decode instead of a hash dedup would overwrite this sentinel.+ poisoned := artRepo.Data[ia1.Hash]+ poisoned.BlurHash = "SENTINEL"+ artRepo.Data[ia1.Hash] = poisoned++ out2, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al6"})+ Expect(out2).To(Equal(outcomeFound))+ ia2, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al6", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia2.Hash).To(Equal(ia1.Hash))++ reused, err := artRepo.GetImage(ia1.Hash)+ Expect(err).ToNot(HaveOccurred())+ Expect(reused.BlurHash).To(Equal("SENTINEL"))+ })++ It("two items, two files, identical bytes: each item keeps its own provenance; the shared artwork row is written once", func() {+ // Byte-identical files share one hash, but provenance is per item.+ libRoot := GinkgoT().TempDir()+ imgBytes, err := os.ReadFile(filepath.Join(repoRoot, "tests/fixtures/artist/an-album/cover.jpg"))+ Expect(err).ToNot(HaveOccurred())+ for sub, mtime := range map[string]int64{"album-a": 1000, "album-b": 2000} {+ dir := filepath.Join(libRoot, sub)+ Expect(os.MkdirAll(dir, 0755)).To(Succeed())+ img := filepath.Join(dir, "cover.jpg")+ Expect(os.WriteFile(img, imgBytes, 0600)).To(Succeed())+ Expect(os.Chtimes(img, time.Unix(mtime, 0), time.Unix(mtime, 0))).To(Succeed())+ }+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(libRoot)}})+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "alA", Name: "Album A", FolderIDs: []string{"fa"}},+ {ID: "alB", Name: "Album B", FolderIDs: []string{"fb"}},+ })++ folderRepo.result = []model.Folder{{Path: "album-a", ImageFiles: []string{"cover.jpg"}}}+ outN, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alA"})+ Expect(outN).To(Equal(outcomeFound))+ iaA, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alA", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(iaA.Source).To(Equal("folder"))+ Expect(filepath.ToSlash(iaA.SourcePath)).To(HaveSuffix("album-a/cover.jpg"))+ Expect(iaA.RefMtime).To(Equal(time.Unix(1000, 0).UnixNano()))++ // A re-decode instead of a hash dedup would overwrite this sentinel.+ poisoned := artRepo.Data[iaA.Hash]+ poisoned.BlurHash = "SENTINEL"+ artRepo.Data[iaA.Hash] = poisoned++ folderRepo.result = []model.Folder{{Path: "album-b", ImageFiles: []string{"cover.jpg"}}}+ outN, _ = proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alB"})+ Expect(outN).To(Equal(outcomeFound))+ iaB, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alB", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(iaB.Hash).To(Equal(iaA.Hash))+ Expect(filepath.ToSlash(iaB.SourcePath)).To(HaveSuffix("album-b/cover.jpg"))+ Expect(iaB.RefMtime).To(Equal(time.Unix(2000, 0).UnixNano()))++ iaAafter, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alA", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(filepath.ToSlash(iaAafter.SourcePath)).To(HaveSuffix("album-a/cover.jpg"))+ Expect(iaAafter.RefMtime).To(Equal(time.Unix(1000, 0).UnixNano()))++ Expect(artRepo.Data).To(HaveLen(1))+ reused, err := artRepo.GetImage(iaA.Hash)+ Expect(err).ToNot(HaveOccurred())+ Expect(reused.BlurHash).To(Equal("SENTINEL"))+ })++ It("decode failure on found bytes: fails without writing state", func() {+ tmpDir := GinkgoT().TempDir()+ conf.Server.DataFolder = conf.NewDir(tmpDir)+ Expect(os.MkdirAll(filepath.Join(tmpDir, "artwork", "radio"), 0755)).To(Succeed())+ imgPath := filepath.Join(tmpDir, "artwork", "radio", "ra1_test.jpg")+ Expect(os.WriteFile(imgPath, []byte("not actually an image"), 0600)).To(Succeed())++ radioRepo := tests.CreateMockedRadioRepo()+ radioRepo.Data = map[string]*model.Radio{"ra1": {ID: "ra1", Name: "Radio", UploadedImage: "ra1_test.jpg"}}+ ds.MockedRadio = radioRepo++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "ra", ItemID: "ra1"})+ Expect(out).To(Equal(outcomeFailed))++ _, err := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra1", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ })++ It("oversized read: a resolved image larger than the cap fails without writing state", func() {+ tmpDir := GinkgoT().TempDir()+ conf.Server.DataFolder = conf.NewDir(tmpDir)+ Expect(os.MkdirAll(filepath.Join(tmpDir, "artwork", "radio"), 0755)).To(Succeed())+ imgPath := filepath.Join(tmpDir, "artwork", "radio", "big_test.jpg")+ f, err := os.Create(imgPath)+ Expect(err).ToNot(HaveOccurred())+ Expect(f.Truncate(maxImageBytes + 1)).To(Succeed())+ Expect(f.Close()).To(Succeed())++ radioRepo := tests.CreateMockedRadioRepo()+ radioRepo.Data = map[string]*model.Radio{"big": {ID: "big", Name: "Radio", UploadedImage: "big_test.jpg"}}+ ds.MockedRadio = radioRepo++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "ra", ItemID: "big"})+ Expect(out).To(Equal(outcomeFailed))++ _, err = artRepo.GetItemArtwork(model.KindRadioArtwork, "big", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ })++ // The cap is compared by division so an overflowing product cannot slip past it; no supported+ // format can declare these dimensions, so this pins the arithmetic, not a live hole.+ DescribeTable("rejects out-of-range declared dimensions",+ func(w, h uint32) {+ _, err := decodeArtwork(ctx, "bomb", pngHeaderWithDims(w, h))+ Expect(err).To(HaveOccurred())+ },+ Entry("both dimensions at the 32-bit maximum", uint32(0xffffffff), uint32(0xffffffff)),+ Entry("both dimensions at the signed 32-bit maximum", uint32(0x7fffffff), uint32(0x7fffffff)),+ Entry("zero width", uint32(0), uint32(100)),+ Entry("zero height", uint32(100), uint32(0)),+ )++ It("decompression bomb: rejects huge declared dimensions before the full decode", func() {+ data := pngHeaderWithDims(50000, 50000) // 2.5 gigapixels, far above the cap+ _, err := decodeArtwork(ctx, "bomb", data)+ Expect(err).To(HaveOccurred())+ Expect(err.Error()).To(ContainSubstring("dimensions"))+ })++ It("store write failure: fails without writing state", func() {+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al7", Name: "Album", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}},+ })+ folderRepo.result = nil++ // A store root that is a plain file makes every MkdirAll under it fail.+ blockedRoot := filepath.Join(GinkgoT().TempDir(), "not-a-dir")+ Expect(os.WriteFile(blockedRoot, []byte("x"), 0600)).To(Succeed())+ proc.store = NewImageStore(blockedRoot)++ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al7"})+ Expect(out).To(Equal(outcomeFailed))++ _, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al7", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ })+})++type countingLocker struct {+ locks int+ unlocks int+}++func (l *countingLocker) Lock() { l.locks++ }+func (l *countingLocker) Unlock() { l.unlocks++ }+func (l *countingLocker) held() bool { return l.locks != l.unlocks }++var _ = Describe("makeThumbnail", func() {+ // Both encoders read Pix directly and thumbhash needs straight alpha, so emitting NRGBA is+ // what keeps either of them from allocating a converted copy of the thumbnail.+ It("emits NRGBA when it downscales", func() {+ src := image.NewRGBA(image.Rect(0, 0, 400, 300))+ Expect(makeThumbnail(src, 100)).To(BeAssignableToTypeOf(&image.NRGBA{}))+ })++ It("fits the longest side to maxSize and keeps the aspect ratio", func() {+ src := image.NewRGBA(image.Rect(0, 0, 400, 300))+ b := makeThumbnail(src, 100).Bounds()+ Expect(b.Dx()).To(Equal(100))+ Expect(b.Dy()).To(Equal(75))+ })++ It("never upscales an image already within bounds", func() {+ src := image.NewRGBA(image.Rect(0, 0, 40, 30))+ Expect(makeThumbnail(src, 100).Bounds()).To(Equal(src.Bounds()))+ })++ // A fully transparent pixel's colour cannot survive any resample, since the scaler works in+ // premultiplied space and multiplying by zero is not invertible. Partial alpha is the case+ // that distinguishes straight storage from premultiplied.+ It("keeps partly transparent colour straight rather than premultiplied", func() {+ src := image.NewNRGBA(image.Rect(0, 0, 400, 400))+ for y := range 400 {+ for x := range 400 {+ src.SetNRGBA(x, y, color.NRGBA{R: 200, G: 40, B: 90, A: 128})+ }+ }+ thumb, ok := makeThumbnail(src, 100).(*image.NRGBA)+ Expect(ok).To(BeTrue())+ // Premultiplied storage would have halved this to ~100.+ Expect(thumb.Pix[0]).To(BeNumerically("==", 200))+ Expect(thumb.Pix[3]).To(BeNumerically("==", 128))+ })+})diff --git a/core/artwork/prune.go b/core/artwork/prune.gonew file mode 100644index 000000000..c79458b8f--- /dev/null+++ b/core/artwork/prune.go@@ -0,0 +1,63 @@+package artwork++import (+ "context"+ "time"++ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+)++// pruneMinAge guards the window between artwork insert and item_artwork upsert.+const pruneMinAge = time.Hour++func prune(ctx context.Context, ds model.DataStore, store *ImageStore) error {+ start := time.Now()+ defer func() { log.Debug(ctx, "Artwork: Prune finished", "elapsed", time.Since(start)) }()+ repo := ds.Artwork(ctx)++ purged, err := repo.PurgeDanglingItems()+ if err != nil {+ return err+ }+ if purged > 0 {+ log.Info(ctx, "Artwork: Purged dangling item state", "count", purged)+ }++ // Queue rows for deleted entities would otherwise retry forever (Get -> not found -> failed).+ queuePurged, err := ds.ArtworkQueue(ctx).PurgeDangling()+ if err != nil {+ return err+ }+ if queuePurged > 0 {+ log.Info(ctx, "Artwork: Purged dangling queue rows", "count", queuePurged)+ }++ // Files younger than the grace window may belong to acquisitions whose rows aren't committed yet.+ cutoff := time.Now().Add(-pruneMinAge)+ orphans, err := repo.PurgeOrphans(cutoff)+ if err != nil {+ return err+ }+ if orphans > 0 {+ log.Info(ctx, "Artwork: Removed orphan image rows", "count", orphans)+ }++ // Read after the delete, so the sweep below reclaims the files of the rows just removed.+ mimes, err := repo.GetMimeByHash()+ if err != nil {+ return err+ }+ removed, err := store.Sweep(ctx, cutoff, func(hash, ext string) bool {+ // A known hash under a stale extension is a superseded mime variant — reclaim it.+ m, ok := mimes[hash]+ return ok && ext == extForMime(m)+ })+ if err != nil {+ return err+ }+ if removed > 0 {+ log.Info(ctx, "Artwork: Swept stray files", "count", removed)+ }+ return nil+}diff --git a/core/artwork/prune_test.go b/core/artwork/prune_test.gonew file mode 100644index 000000000..8b8504f89--- /dev/null+++ b/core/artwork/prune_test.go@@ -0,0 +1,239 @@+package artwork++import (+ "bytes"+ "context"+ "errors"+ "os"+ "path/filepath"+ "time"++ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++type flakyGetArtworkRepo struct {+ *tests.MockArtworkRepo+}++func (f *flakyGetArtworkRepo) GetMimeByHash() (map[string]string, error) {+ return nil, errors.New("db locked")+}++var _ = Describe("Prune", func() {+ var ds *tests.MockDataStore+ var store *ImageStore+ var awRepo *tests.MockArtworkRepo++ BeforeEach(func() {+ ds = &tests.MockDataStore{}+ awRepo = ds.Artwork(context.Background()).(*tests.MockArtworkRepo)+ store = NewImageStore(GinkgoT().TempDir())+ })++ // PutImage refreshes created_at like the SQL repo, so fixtures are aged directly.+ ageArtwork := func(h string, t time.Time) {+ a := awRepo.Data[h]+ a.CreatedAt = t+ awRepo.Data[h] = a+ }++ It("purges dangling item_artwork state for gone entities, summed across kinds", func() {+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "gone-album", ImageType: model.ImageTypePrimary})).To(Succeed())+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "gone-artist", ImageType: model.ImageTypePrimary})).To(Succeed())+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "live-artist", ImageType: model.ImageTypePrimary})).To(Succeed())+ awRepo.ExistingIDs = map[string]map[string]bool{+ "al": {},+ "ar": {"live-artist": true},+ }++ Expect(prune(context.Background(), ds, store)).To(Succeed())++ _, err := awRepo.GetItemArtwork(model.KindAlbumArtwork, "gone-album", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ _, err = awRepo.GetItemArtwork(model.KindArtistArtwork, "gone-artist", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ _, err = awRepo.GetItemArtwork(model.KindArtistArtwork, "live-artist", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ })++ It("purges dangling artwork_queue rows for gone entities", func() {+ queueRepo := tests.CreateMockArtworkQueueRepo()+ Expect(queueRepo.Enqueue(+ model.ArtworkQueueItem{ItemKind: "al", ItemID: "gone-album", ImageType: model.ImageTypePrimary},+ model.ArtworkQueueItem{ItemKind: "al", ItemID: "live-album", ImageType: model.ImageTypePrimary},+ )).To(Succeed())+ queueRepo.ExistingIDs = map[string]map[string]bool{"al": {"live-album": true}}+ ds.MockedArtworkQueue = queueRepo++ Expect(prune(context.Background(), ds, store)).To(Succeed())++ Expect(findQueued(queueRepo, "al", "gone-album")).To(BeNil())+ Expect(findQueued(queueRepo, "al", "live-album")).ToNot(BeNil())+ })++ It("deletes orphan rows and their store files, keeps referenced ones", func() {+ data := []byte("orphan-bytes")+ h, _ := hashImage(bytes.NewReader(data))+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())+ old := time.Now().Add(-2 * time.Hour)+ Expect(os.Chtimes(store.path(h, "image/jpeg"), old, old)).To(Succeed())+ Expect(awRepo.PutImage(&model.Artwork{Hash: h, Mime: "image/jpeg"})).To(Succeed())+ ageArtwork(h, old)++ kept := []byte("kept-bytes")+ hk, _ := hashImage(bytes.NewReader(kept))+ Expect(store.Write(hk, "image/jpeg", bytes.NewReader(kept))).To(Succeed())+ Expect(awRepo.PutImage(&model.Artwork{Hash: hk, Mime: "image/jpeg"})).To(Succeed())++ Expect(prune(context.Background(), ds, store)).To(Succeed())++ _, err := awRepo.GetImage(h)+ Expect(err).To(MatchError(model.ErrNotFound))+ _, err = store.Open(h, "image/jpeg")+ Expect(os.IsNotExist(err)).To(BeTrue())+ rc, err := store.Open(hk, "image/jpeg")+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })++ It("spares an aged row that item_artwork state still references", func() {+ data := []byte("reacquired-bytes")+ h, _ := hashImage(bytes.NewReader(data))+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())+ Expect(awRepo.PutImage(&model.Artwork{Hash: h, Mime: "image/jpeg"})).To(Succeed())+ ageArtwork(h, time.Now().Add(-2*time.Hour))+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "a1",+ ImageType: model.ImageTypePrimary, Hash: h, Source: "folder"})).To(Succeed())++ Expect(prune(context.Background(), ds, store)).To(Succeed())++ _, err := awRepo.GetImage(h)+ Expect(err).ToNot(HaveOccurred())+ rc, err := store.Open(h, "image/jpeg")+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })++ It("spares an unreferenced row recreated inside the grace window", func() {+ data := []byte("fresh-reacquired-bytes")+ h, _ := hashImage(bytes.NewReader(data))+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())+ // Reacquisition refreshed created_at, so the row is unreferenced but too young to drop.+ Expect(awRepo.PutImage(&model.Artwork{Hash: h, Mime: "image/jpeg"})).To(Succeed())++ Expect(prune(context.Background(), ds, store)).To(Succeed())++ _, err := awRepo.GetImage(h)+ Expect(err).ToNot(HaveOccurred())+ rc, err := store.Open(h, "image/jpeg")+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })++ It("spares an orphan file freshly touched by an overlapping acquisition", func() {+ data := []byte("racing-bytes")+ h, _ := hashImage(bytes.NewReader(data))+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())+ Expect(awRepo.PutImage(&model.Artwork{Hash: h, Mime: "image/jpeg"})).To(Succeed())+ ageArtwork(h, time.Now().Add(-2*time.Hour))+ // The row is orphaned, but a concurrent acquisition just touched the file's mtime.++ Expect(prune(context.Background(), ds, store)).To(Succeed())++ rc, err := store.Open(h, "image/jpeg")+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })++ It("sweeps store files that have no artwork row", func() {+ stray := []byte("no-row-bytes")+ h, _ := hashImage(bytes.NewReader(stray))+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(stray))).To(Succeed())+ old := time.Now().Add(-2 * time.Hour)+ Expect(os.Chtimes(store.path(h, "image/jpeg"), old, old)).To(Succeed())++ Expect(prune(context.Background(), ds, store)).To(Succeed())++ _, err := store.Open(h, "image/jpeg")+ Expect(os.IsNotExist(err)).To(BeTrue())+ })++ It("sweeps an obsolete mime variant of a reacquired hash", func() {+ data := []byte("variant-bytes")+ h, _ := hashImage(bytes.NewReader(data))+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())+ old := time.Now().Add(-2 * time.Hour)+ Expect(os.Chtimes(store.path(h, "image/png"), old, old)).To(Succeed())+ Expect(os.Chtimes(store.path(h, "image/jpeg"), old, old)).To(Succeed())+ // The row records the current mime; the .png file is a superseded variant.+ Expect(awRepo.PutImage(&model.Artwork{Hash: h, Mime: "image/jpeg"})).To(Succeed())++ Expect(prune(context.Background(), ds, store)).To(Succeed())++ _, err := store.Open(h, "image/png")+ Expect(os.IsNotExist(err)).To(BeTrue())+ rc, err := store.Open(h, "image/jpeg")+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })++ It("reclaims the other orphan files when one of them cannot be removed", func() {+ tests.SkipOnWindows("uses Unix file permission bits")+ if os.Geteuid() == 0 {+ Skip("read-only dir cannot block root (e.g. tests in a container)")+ }+ old := time.Now().Add(-2 * time.Hour)++ blocked := []byte("blocked-bytes")+ hb, _ := hashImage(bytes.NewReader(blocked))+ Expect(store.Write(hb, "image/jpeg", bytes.NewReader(blocked))).To(Succeed())+ Expect(os.Chtimes(store.path(hb, "image/jpeg"), old, old)).To(Succeed())+ Expect(awRepo.PutImage(&model.Artwork{Hash: hb, Mime: "image/jpeg"})).To(Succeed())+ ageArtwork(hb, old)++ good := []byte("good-bytes")+ hg, _ := hashImage(bytes.NewReader(good))+ Expect(store.Write(hg, "image/jpeg", bytes.NewReader(good))).To(Succeed())+ Expect(os.Chtimes(store.path(hg, "image/jpeg"), old, old)).To(Succeed())+ Expect(awRepo.PutImage(&model.Artwork{Hash: hg, Mime: "image/jpeg"})).To(Succeed())+ ageArtwork(hg, old)++ // A read-only shard directory makes os.Remove fail (EACCES) for hb's file only.+ shardDir := filepath.Dir(store.path(hb, "image/jpeg"))+ Expect(shardDir).ToNot(Equal(filepath.Dir(store.path(hg, "image/jpeg"))), "fixtures must land in different shards")+ Expect(os.Chmod(shardDir, 0500)).To(Succeed())+ DeferCleanup(func() { _ = os.Chmod(shardDir, 0755) })++ Expect(prune(context.Background(), ds, store)).To(Succeed())++ _, err := awRepo.GetImage(hg)+ Expect(err).To(MatchError(model.ErrNotFound))+ _, err = store.Open(hg, "image/jpeg")+ Expect(os.IsNotExist(err)).To(BeTrue())++ // The row purge does not depend on file removal, so only the file survives.+ _, err = awRepo.GetImage(hb)+ Expect(err).To(MatchError(model.ErrNotFound))+ rc, err := store.Open(hb, "image/jpeg")+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })++ It("never sweeps files on a transient DB error", func() {+ ds.MockedArtwork = &flakyGetArtworkRepo{MockArtworkRepo: tests.CreateMockArtworkRepo()}++ data := []byte("live-bytes")+ h, _ := hashImage(bytes.NewReader(data))+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())++ Expect(prune(context.Background(), ds, store)).ToNot(Succeed())++ rc, err := store.Open(h, "image/jpeg")+ Expect(err).ToNot(HaveOccurred())+ rc.Close()+ })+})diff --git a/core/artwork/reader_album_test.go b/core/artwork/reader_album_test.godeleted file mode 100644index c95ddedaa..000000000--- a/core/artwork/reader_album_test.go+++ /dev/null@@ -1,481 +0,0 @@-package artwork--import (- "context"- "errors"- "path/filepath"- "time"-- "github.com/navidrome/navidrome/model"- . "github.com/onsi/ginkgo/v2"- . "github.com/onsi/gomega"-)--var _ = Describe("Album Artwork Reader", func() {- Describe("loadAlbumFoldersPaths", func() {- var (- ctx context.Context- ds *fakeDataStore- repo *fakeFolderRepo- album model.Album- now time.Time- expectedAt time.Time- )-- BeforeEach(func() {- ctx = context.Background()- now = time.Now().Truncate(time.Second)- expectedAt = now.Add(5 * time.Minute)-- // Set up the test folders with image files- repo = &fakeFolderRepo{}- ds = &fakeDataStore{- folderRepo: repo,- }- album = model.Album{- ID: "album1",- Name: "Album",- FolderIDs: []string{"folder1", "folder2", "folder3"},- }- })-- It("returns sorted image files", func() {- repo.result = []model.Folder{- {- Path: "Artist/Album/Disc1",- ImagesUpdatedAt: expectedAt,- ImageFiles: []string{"cover.jpg", "back.jpg", "cover.1.jpg"},- },- {- Path: "Artist/Album/Disc2",- ImagesUpdatedAt: now,- ImageFiles: []string{"cover.jpg"},- },- {- Path: "Artist/Album/Disc10",- ImagesUpdatedAt: now,- ImageFiles: []string{"cover.jpg"},- },- }-- _, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(*imagesUpdatedAt).To(Equal(expectedAt))-- // Check that image files are sorted by base name (without extension)- Expect(imgFiles).To(HaveLen(5))-- // Files should be sorted by base filename without extension, then by full path- // "back" < "cover", so back.jpg comes first- // Then all cover.jpg files, sorted by path- Expect(imgFiles[0]).To(Equal("Artist/Album/Disc1/back.jpg"))- Expect(imgFiles[1]).To(Equal("Artist/Album/Disc1/cover.jpg"))- Expect(imgFiles[2]).To(Equal("Artist/Album/Disc2/cover.jpg"))- Expect(imgFiles[3]).To(Equal("Artist/Album/Disc10/cover.jpg"))- Expect(imgFiles[4]).To(Equal("Artist/Album/Disc1/cover.1.jpg"))- })-- It("prioritizes files without numeric suffixes", func() {- // Test case for issue #4683: cover.jpg should come before cover.1.jpg- repo.result = []model.Folder{- {- Path: "Artist/Album",- ImagesUpdatedAt: now,- ImageFiles: []string{"cover.1.jpg", "cover.jpg", "cover.2.jpg"},- },- }-- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(imgFiles).To(HaveLen(3))-- // cover.jpg should come first because "cover" < "cover.1" < "cover.2"- Expect(imgFiles[0]).To(Equal("Artist/Album/cover.jpg"))- Expect(imgFiles[1]).To(Equal("Artist/Album/cover.1.jpg"))- Expect(imgFiles[2]).To(Equal("Artist/Album/cover.2.jpg"))- })-- It("handles case-insensitive sorting", func() {- // Test that Cover.jpg and cover.jpg are treated as equivalent- repo.result = []model.Folder{- {- Path: "Artist/Album",- ImagesUpdatedAt: now,- ImageFiles: []string{"Folder.jpg", "cover.jpg", "BACK.jpg"},- },- }-- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(imgFiles).To(HaveLen(3))-- // Files should be sorted case-insensitively: BACK, cover, Folder- Expect(imgFiles[0]).To(Equal("Artist/Album/BACK.jpg"))- Expect(imgFiles[1]).To(Equal("Artist/Album/cover.jpg"))- Expect(imgFiles[2]).To(Equal("Artist/Album/Folder.jpg"))- })-- It("includes images from parent folder for multi-disc albums", func() {- // Simulates: Artist/Album/cover.jpg with tracks in Artist/Album/CD1/ and Artist/Album/CD2/- repo.result = []model.Folder{- {- ID: "folder1",- Path: "Artist/Album",- Name: "CD1",- ParentID: "parentFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{},- },- {- ID: "folder2",- Path: "Artist/Album",- Name: "CD2",- ParentID: "parentFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{},- },- }- repo.parentResult = &model.Folder{- ID: "parentFolder",- Path: "Artist",- Name: "Album",- ParentID: "artistFolder",- ImagesUpdatedAt: expectedAt,- ImageFiles: []string{"cover.jpg", "back.jpg"},- }-- _, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(*imagesUpdatedAt).To(Equal(expectedAt))- Expect(imgFiles).To(HaveLen(2))- Expect(imgFiles[0]).To(Equal("Artist/Album/back.jpg"))- Expect(imgFiles[1]).To(Equal("Artist/Album/cover.jpg"))- })-- It("does not query parent when parent ID is already in album folders", func() {- // When the parent folder is already one of the album's folders, skip it- repo.result = []model.Folder{- {- ID: "folder1",- Path: "Artist",- Name: "Album",- ParentID: "folder2",- ImagesUpdatedAt: now,- ImageFiles: []string{"cover.jpg"},- },- {- ID: "folder2",- Path: "",- Name: "Artist",- ImagesUpdatedAt: now,- ImageFiles: []string{},- },- }-- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(imgFiles).To(HaveLen(1))- Expect(imgFiles[0]).To(Equal("Artist/Album/cover.jpg"))- // Get should not have been called (parent already in folder set)- Expect(repo.getCallCount).To(Equal(0))- })-- It("does not query parent when folders have different parents", func() {- // When album folders span different parents, don't search any parent- repo.result = []model.Folder{- {- ID: "folder1",- Path: "Artist1/Album",- Name: "part1",- ParentID: "parentA",- ImagesUpdatedAt: now,- ImageFiles: []string{"cover.jpg"},- },- {- ID: "folder2",- Path: "Artist2/Album",- Name: "part2",- ParentID: "parentB",- ImagesUpdatedAt: now,- ImageFiles: []string{},- },- }-- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(imgFiles).To(HaveLen(1))- Expect(imgFiles[0]).To(Equal("Artist1/Album/part1/cover.jpg"))- // Get should not have been called (different parents)- Expect(repo.getCallCount).To(Equal(0))- })-- It("does not include library root parent for multi-folder albums", func() {- // Two album parts directly under the library root — parent is the root itself- repo.result = []model.Folder{- {- ID: "folder1",- Path: ".",- Name: "AlbumPart1",- ParentID: "rootFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{"cover.jpg"},- },- {- ID: "folder2",- Path: ".",- Name: "AlbumPart2",- ParentID: "rootFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{},- },- }- repo.parentResult = &model.Folder{- ID: "rootFolder",- Path: "",- Name: ".",- ParentID: "",- ImageFiles: []string{"unrelated.jpg"},- }-- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(imgFiles).To(HaveLen(1))- Expect(imgFiles[0]).To(Equal("AlbumPart1/cover.jpg"))- Expect(repo.getCallCount).To(Equal(1))- })-- It("includes top-level album folder for multi-disc albums", func() {- // Album folder directly under library root, with disc subfolders- repo.result = []model.Folder{- {- ID: "folder1",- Path: "Album",- Name: "Disc1",- ParentID: "albumFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{"folder.jpg"},- },- {- ID: "folder2",- Path: "Album",- Name: "Disc2",- ParentID: "albumFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{"folder.jpg"},- },- }- repo.parentResult = &model.Folder{- ID: "albumFolder",- Path: ".",- Name: "Album",- ParentID: "rootFolder",- ImagesUpdatedAt: expectedAt,- ImageFiles: []string{"cover.jpg"},- }-- _, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(*imagesUpdatedAt).To(Equal(expectedAt))- Expect(imgFiles).To(HaveLen(3))- Expect(imgFiles[0]).To(Equal("Album/cover.jpg"))- Expect(imgFiles[1]).To(Equal("Album/Disc1/folder.jpg"))- Expect(imgFiles[2]).To(Equal("Album/Disc2/folder.jpg"))- Expect(repo.getCallCount).To(Equal(1))- })-- It("does not query parent for single-folder albums that already have images", func() {- repo.result = []model.Folder{- {- ID: "folder1",- Path: "Artist",- Name: "Album",- ParentID: "artistFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{"cover.jpg"},- },- }-- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(imgFiles).To(HaveLen(1))- Expect(imgFiles[0]).To(Equal("Artist/Album/cover.jpg"))- Expect(repo.getCallCount).To(Equal(0))- })-- It("includes parent images for single-disc-subfolder albums", func() {- repo.result = []model.Folder{- {- ID: "folder1",- Path: "Artist/Album",- Name: "disc1",- ParentID: "albumFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{},- },- }- repo.parentResult = &model.Folder{- ID: "albumFolder",- Path: "Artist",- Name: "Album",- ParentID: "artistFolder",- ImagesUpdatedAt: expectedAt,- ImageFiles: []string{"cover.jpg"},- }-- _, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(*imagesUpdatedAt).To(Equal(expectedAt))- Expect(imgFiles).To(HaveLen(1))- Expect(imgFiles[0]).To(Equal("Artist/Album/cover.jpg"))- Expect(repo.getCallCount).To(Equal(1))- })-- It("promotes the album root parent into the returned paths", func() {- repo.result = []model.Folder{- {- ID: "folder1",- Path: "Artist",- Name: "Album",- ParentID: "artistFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{},- },- }- repo.parentResult = &model.Folder{- ID: "artistFolder",- Path: ".",- Name: "Artist",- ParentID: "libraryRoot",- ImagesUpdatedAt: expectedAt,- ImageFiles: []string{"folder.jpg"},- }-- paths, _, _, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(paths).To(Equal([]string{filepath.Join("Artist", "Album"), "Artist"}))- })-- It("does not include parent images when other albums' audio lives under the parent", func() {- // Simulates: Artist/folder.jpg with Artist/Album (no images) and- // another album's tracks elsewhere under the artist folder- repo.result = []model.Folder{- {- ID: "folder1",- Path: "Artist",- Name: "Album",- ParentID: "artistFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{},- },- }- repo.parentResult = &model.Folder{- ID: "artistFolder",- Path: ".",- Name: "Artist",- ParentID: "libraryRoot",- ImagesUpdatedAt: expectedAt,- ImageFiles: []string{"folder.jpg"},- }- repo.hasOtherAudio = true-- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(imgFiles).To(BeEmpty())- })-- It("propagates errors from the album-root check", func() {- repo.result = []model.Folder{- {- ID: "folder1",- Path: "Artist/Album",- Name: "disc1",- ParentID: "albumFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{},- },- }- repo.parentResult = &model.Folder{- ID: "albumFolder",- Path: "Artist",- Name: "Album",- ParentID: "artistFolder",- ImagesUpdatedAt: expectedAt,- ImageFiles: []string{"cover.jpg"},- }- repo.otherAudioErr = errors.New("db connection failed")-- _, _, _, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).To(MatchError("db connection failed"))- })-- It("propagates non-ErrNotFound errors from parent folder lookup", func() {- repo.result = []model.Folder{- {- ID: "folder1",- Path: "Artist/Album",- Name: "CD1",- ParentID: "parentFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{"cover.jpg"},- },- {- ID: "folder2",- Path: "Artist/Album",- Name: "CD2",- ParentID: "parentFolder",- ImagesUpdatedAt: now,- ImageFiles: []string{},- },- }- repo.getErr = errors.New("db connection failed")-- _, _, _, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).To(MatchError("db connection failed"))- Expect(repo.getCallCount).To(Equal(1))- })-- It("continues gracefully when parent folder is not found", func() {- // Parent folder may have been deleted; should log a warning and continue- repo.result = []model.Folder{- {- ID: "folder1",- Path: "Artist/Album",- Name: "CD1",- ParentID: "missingParent",- ImagesUpdatedAt: now,- ImageFiles: []string{"cover.jpg"},- },- {- ID: "folder2",- Path: "Artist/Album",- Name: "CD2",- ParentID: "missingParent",- ImagesUpdatedAt: now,- ImageFiles: []string{},- },- }- // parentResult is nil, so Get will return ErrNotFound-- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)-- Expect(err).ToNot(HaveOccurred())- Expect(imgFiles).To(HaveLen(1))- Expect(imgFiles[0]).To(Equal("Artist/Album/CD1/cover.jpg"))- Expect(repo.getCallCount).To(Equal(1))- })- })-})diff --git a/core/artwork/reader_artist.go b/core/artwork/reader_artist.godeleted file mode 100644index fe5bcb196..000000000--- a/core/artwork/reader_artist.go+++ /dev/null@@ -1,359 +0,0 @@-package artwork--import (- "context"- "crypto/md5"- "fmt"- "io"- "io/fs"- "os"- "path"- "path/filepath"- "slices"- "strings"- "time"-- "github.com/Masterminds/squirrel"- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/core"- "github.com/navidrome/navidrome/core/external"- "github.com/navidrome/navidrome/log"- "github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/utils/slice"- "github.com/navidrome/navidrome/utils/str"-)--const (- // maxArtistFolderTraversalDepth defines how many directory levels to search- // when looking for artist images (artist folder + parent directories)- maxArtistFolderTraversalDepth = 3-)--type artistReader struct {- cacheKey- a *artwork- provider external.Provider- artist model.Artist- artistFolder string- imgFiles []string- imgFolderImgPath string // cached path from ArtistImageFolder lookup- lib libraryView-}--func newArtistArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID, provider external.Provider) (*artistReader, error) {- ar, err := artwork.ds.Artist(ctx).Get(artID.ID)- if err != nil {- return nil, err- }- // Only consider albums where the artist is the sole album artist.- als, err := artwork.ds.Album(ctx).GetAll(model.QueryOptions{- Filters: squirrel.And{- squirrel.Eq{"album_artist_id": artID.ID},- squirrel.Eq{"json_array_length(participants, '$.albumartist')": 1},- },- })- if err != nil {- return nil, err- }- albumPaths, imgFiles, imagesUpdatedAt, err := loadArtistAlbumRoots(ctx, artwork.ds, als)- if err != nil {- return nil, err- }- artistFolder, artistFolderLastUpdate, err := loadArtistFolder(ctx, artwork.ds, als, albumPaths)- if err != nil {- return nil, err- }- var lib libraryView- if len(als) > 0 {- lib, err = loadLibraryView(ctx, artwork.ds, als[0].LibraryID)- if err != nil {- return nil, err- }- }- a := &artistReader{- a: artwork,- provider: provider,- artist: *ar,- artistFolder: artistFolder,- imgFiles: imgFiles,- lib: lib,- }- // TODO Find a way to factor in the ExternalUpdateInfoAt in the cache key. Problem is that it can- // change _after_ retrieving from external sources, making the key invalid- //a.cacheKey.lastUpdate = ar.ExternalInfoUpdatedAt-- a.cacheKey.lastUpdate = *imagesUpdatedAt- if ar.UpdatedAt != nil && ar.UpdatedAt.After(a.cacheKey.lastUpdate) {- a.cacheKey.lastUpdate = *ar.UpdatedAt- }- if artistFolderLastUpdate.After(a.cacheKey.lastUpdate) {- a.cacheKey.lastUpdate = artistFolderLastUpdate- }- if conf.Server.ArtistImageFolder != "" && strings.Contains(strings.ToLower(conf.Server.ArtistArtPriority), "image-folder") {- a.imgFolderImgPath = findImageInArtistFolder(conf.Server.ArtistImageFolder, ar.MbzArtistID, ar.Name)- if a.imgFolderImgPath != "" {- if info, err := os.Stat(a.imgFolderImgPath); err == nil && info.ModTime().After(a.cacheKey.lastUpdate) {- a.cacheKey.lastUpdate = info.ModTime()- }- }- }- a.cacheKey.artID = artID- return a, nil-}--func (a *artistReader) Key() string {- hash := md5.Sum([]byte(conf.Server.Agents))- return fmt.Sprintf(- "%s.%t.%x",- a.cacheKey.Key(),- conf.Server.EnableExternalServices,- hash,- )-}--func (a *artistReader) LastUpdated() time.Time {- return a.lastUpdate-}--func (a *artistReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {- ff := []sourceFunc{a.fromArtistUploadedImage()}- ff = append(ff, a.fromArtistArtPriority(ctx, conf.Server.ArtistArtPriority)...)- return selectImageReader(ctx, a.artID, ff...)-}--func (a *artistReader) fromArtistUploadedImage() sourceFunc {- return fromLocalFile(a.artist.UploadedImagePath())-}--func (a *artistReader) fromArtistArtPriority(ctx context.Context, priority string) []sourceFunc {- var ff []sourceFunc- for pattern := range strings.SplitSeq(strings.ToLower(priority), ",") {- pattern = strings.TrimSpace(pattern)- switch {- case pattern == "external":- ff = append(ff, fromArtistExternalSource(ctx, a.artist, a.provider))- case pattern == "image-folder":- ff = append(ff, a.fromArtistImageFolder(ctx))- case strings.HasPrefix(pattern, "album/"):- if a.lib.FS != nil {- ff = append(ff, fromExternalFile(ctx, a.lib.FS, a.imgFiles, strings.TrimPrefix(pattern, "album/")))- }- default:- ff = append(ff, fromArtistFolder(ctx, a.lib.FS, a.lib.absRoot, a.artistFolder, pattern))- }- }- return ff-}--// fromArtistFolder walks up from artistFolder toward libPath looking for a-// file matching pattern. Traversal is bounded by both maxArtistFolderTraversalDepth-// and the library root: once we reach libPath (or if artistFolder is outside-// libPath), the walk stops. All reads go through libFS, which keeps artwork-// resolution scoped to the configured library.-func fromArtistFolder(ctx context.Context, libFS fs.FS, libPath, artistFolder, pattern string) sourceFunc {- return func() (io.ReadCloser, string, error) {- if libFS == nil {- return nil, "", fmt.Errorf("artist folder lookup unavailable")- }- rel, err := filepath.Rel(libPath, artistFolder)- if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {- return nil, "", fmt.Errorf(`artist folder '%s' is outside library '%s'`, artistFolder, libPath)- }- // fs.Glob / path.Join below expect forward-slash paths; filepath.Rel may- // return backslash separators on Windows.- rel = filepath.ToSlash(rel)- current := artistFolder- for range maxArtistFolderTraversalDepth {- reader, hit, err := findImageInFolder(ctx, libFS, rel, current, pattern)- if err == nil {- return reader, hit, nil- }- if rel == "." {- break // reached library root; don't traverse above it- }- rel = path.Dir(rel)- current = filepath.Dir(current)- }- return nil, "", fmt.Errorf(`no matches for '%s' in '%s' or its parent directories (within library)`, pattern, artistFolder)- }-}--// findImageInFolder globs libFS at relFolder for pattern and returns the first-// matching image. absFolder is used only for the returned display path and log-// messages so callers see absolute-looking paths consistent with the rest of-// the artwork pipeline.-func findImageInFolder(ctx context.Context, libFS fs.FS, relFolder, absFolder, pattern string) (io.ReadCloser, string, error) {- log.Trace(ctx, "looking for artist image", "pattern", pattern, "folder", absFolder)- globPattern := pattern- if relFolder != "." {- globPattern = path.Join(escapeGlobLiteral(relFolder), pattern)- }- matches, err := fs.Glob(libFS, globPattern)- if err != nil {- log.Warn(ctx, "Error matching artist image pattern", "pattern", pattern, "folder", absFolder, err)- return nil, "", err- }-- // Filter to valid image files- var imagePaths []string- for _, m := range matches {- if !model.IsImageFile(m) {- continue- }- imagePaths = append(imagePaths, m)- }-- // Sort image files by prioritizing base filenames without numeric- // suffixes (e.g., artist.jpg before artist.1.jpg)- slices.SortFunc(imagePaths, compareImageFiles)-- for _, p := range imagePaths {- f, err := libFS.Open(p)- if err != nil {- log.Warn(ctx, "Could not open cover art file", "file", p, err)- continue- }- _, name := path.Split(p)- return f, filepath.Join(absFolder, name), nil- }-- return nil, "", fmt.Errorf(`no matches for '%s' in '%s'`, pattern, absFolder)-}--func escapeGlobLiteral(s string) string {- var b strings.Builder- b.Grow(len(s))- for _, r := range s {- switch r {- case '\\', '*', '?', '[', ']':- b.WriteByte('\\')- }- b.WriteRune(r)- }- return b.String()-}--// loadArtistAlbumRoots returns one path per album — the deepest folder holding-// all of that album's tracks — so an album split into disc subfolders can't-// pull the artist folder's common prefix below the artist level.-func loadArtistAlbumRoots(ctx context.Context, ds model.DataStore, albums model.Albums) ([]string, []string, *time.Time, error) {- var folderIDs []string- for _, album := range albums {- folderIDs = append(folderIDs, album.FolderIDs...)- }- folders, err := loadFolders(ctx, ds, folderIDs)- if err != nil {- return nil, nil, nil, err- }-- pathByID := slice.ToMap(folders, func(f model.Folder) (string, string) {- return f.ID, f.AbsolutePath()- })- var roots []string- for _, album := range albums {- var albumPaths []string- for _, fid := range album.FolderIDs {- if p, ok := pathByID[fid]; ok {- albumPaths = append(albumPaths, p)- }- }- if len(albumPaths) > 0 {- roots = append(roots, commonDir(albumPaths))- }- }-- imgFiles, updatedAt := folderImages(folders)- return roots, imgFiles, &updatedAt, nil-}--// commonDir returns the deepest directory containing all paths. Trailing-// separators keep the comparison on segment boundaries, so a shared name-// fragment (".../Album" and ".../Album2") is never read as a shared directory.-func commonDir(paths []string) string {- sep := string(filepath.Separator)- common := str.LongestCommonPrefix(slice.Map(paths, func(p string) string { return p + sep }))- if !strings.HasSuffix(common, sep) {- common, _ = filepath.Split(common)- }- return filepath.Clean(common)-}--func loadArtistFolder(ctx context.Context, ds model.DataStore, albums model.Albums, paths []string) (string, time.Time, error) {- if len(albums) == 0 {- return "", time.Time{}, nil- }- libID := albums[0].LibraryID // Just need one of the albums, as they should all be in the same Library - for now! TODO: Support multiple libraries-- // paths holds one root per album: two or more distinct roots already meet at- // the artist folder, while a single root is an album folder needing a climb.- roots := slices.Compact(slices.Sorted(slices.Values(paths)))- folderPath := commonDir(roots)- if len(roots) < 2 {- folderPath = filepath.Dir(folderPath)- }-- // Manipulate the path to get the folder ID- // TODO: This is a bit hacky, but it's the easiest way to get the folder ID, ATM- libPath := core.AbsolutePath(ctx, ds, libID, "")- folderID := model.FolderID(model.Library{ID: libID, Path: libPath}, folderPath)-- log.Trace(ctx, "Calculating artist folder details", "folderPath", folderPath, "folderID", folderID,- "libPath", libPath, "libID", libID, "albumPaths", paths)-- // Get the last update time for the folder- folders, err := ds.Folder(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"folder.id": folderID, "missing": false}})- if err != nil || len(folders) == 0 {- log.Warn(ctx, "Could not find folder for artist", "folderPath", folderPath, "id", folderID,- "libPath", libPath, "libID", libID, err)- return "", time.Time{}, err- }- return folderPath, folders[0].ImagesUpdatedAt, nil-}--func (a *artistReader) fromArtistImageFolder(ctx context.Context) sourceFunc {- return func() (io.ReadCloser, string, error) {- folder := conf.Server.ArtistImageFolder- if folder == "" {- return nil, "", nil- }- // Use cached path from newArtistArtworkReader if available,- // avoiding a second directory scan.- path := a.imgFolderImgPath- if path == "" {- path = findImageInArtistFolder(folder, a.artist.MbzArtistID, a.artist.Name)- }- if path == "" {- return nil, "", fmt.Errorf("no image found for artist %q in %s", a.artist.Name, folder)- }- f, err := os.Open(path)- if err != nil {- return nil, "", err- }- return f, path, nil- }-}--// findImageInArtistFolder scans a folder for an image file matching the artist's MBID or name-// (case-insensitive). Returns the full path, or empty string if not found.-func findImageInArtistFolder(folder, mbzArtistID, artistName string) string {- entries, err := os.ReadDir(folder)- if err != nil {- return ""- }- for _, candidate := range []string{mbzArtistID, artistName} {- if candidate == "" {- continue- }- for _, entry := range entries {- if entry.IsDir() {- continue- }- name := entry.Name()- base := strings.TrimSuffix(name, filepath.Ext(name))- if strings.EqualFold(base, candidate) && model.IsImageFile(name) {- return filepath.Join(folder, name)- }- }- }- return ""-}diff --git a/core/artwork/reader_artist_test.go b/core/artwork/reader_artist_test.godeleted file mode 100644index c75f8447e..000000000--- a/core/artwork/reader_artist_test.go+++ /dev/null@@ -1,761 +0,0 @@-package artwork--import (- "context"- "errors"- "io"- "io/fs"- "os"- "path/filepath"- "time"-- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/conf/configtest"- "github.com/navidrome/navidrome/core"- "github.com/navidrome/navidrome/model"- . "github.com/onsi/ginkgo/v2"- . "github.com/onsi/gomega"-)--var _ = Describe("artistArtworkReader", func() {- var _ = Describe("loadArtistFolder", func() {- var (- ctx context.Context- fds *fakeDataStore- repo *fakeFolderRepo- albums model.Albums- paths []string- now time.Time- expectedUpdTime time.Time- )-- BeforeEach(func() {- ctx = context.Background()- DeferCleanup(stubCoreAbsolutePath())-- now = time.Now().Truncate(time.Second)- expectedUpdTime = now.Add(5 * time.Minute)- repo = &fakeFolderRepo{- result: []model.Folder{- {- ImagesUpdatedAt: expectedUpdTime,- },- },- err: nil,- }- fds = &fakeDataStore{- folderRepo: repo,- }- albums = model.Albums{- {LibraryID: 1, ID: "album1", Name: "Album 1"},- }- })-- When("no albums provided", func() {- It("returns empty and zero time", func() {- folder, upd, err := loadArtistFolder(ctx, fds, model.Albums{}, []string{"/dummy/path"})- Expect(err).ToNot(HaveOccurred())- Expect(folder).To(BeEmpty())- Expect(upd).To(BeZero())- })- })-- When("artist has only one album", func() {- It("returns the parent folder", func() {- paths = []string{- filepath.FromSlash("/music/artist/album1"),- }- folder, upd, err := loadArtistFolder(ctx, fds, albums, paths)- Expect(err).ToNot(HaveOccurred())- Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))- Expect(upd).To(Equal(expectedUpdTime))- })- })-- When("the artist have multiple albums", func() {- It("returns the common prefix for the albums paths", func() {- paths = []string{- filepath.FromSlash("/music/library/artist/one"),- filepath.FromSlash("/music/library/artist/two"),- }- folder, upd, err := loadArtistFolder(ctx, fds, albums, paths)- Expect(err).ToNot(HaveOccurred())- Expect(folder).To(Equal(filepath.FromSlash("/music/library/artist")))- Expect(upd).To(Equal(expectedUpdTime))- })- })-- When("two albums share the same folder", func() {- It("climbs above the shared album folder", func() {- paths = []string{- filepath.FromSlash("/music/artist/split"),- filepath.FromSlash("/music/artist/split"),- }- folder, upd, err := loadArtistFolder(ctx, fds, albums, paths)- Expect(err).ToNot(HaveOccurred())- Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))- Expect(upd).To(Equal(expectedUpdTime))- })- })-- When("the album paths contain same prefix", func() {- It("returns the common prefix", func() {- paths = []string{- filepath.FromSlash("/music/artist/album1"),- filepath.FromSlash("/music/artist/album2"),- }- folder, upd, err := loadArtistFolder(ctx, fds, albums, paths)- Expect(err).ToNot(HaveOccurred())- Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))- Expect(upd).To(Equal(expectedUpdTime))- })- })-- When("ds.Folder().GetAll returns an error", func() {- It("returns an error", func() {- paths = []string{- filepath.FromSlash("/music/artist/album1"),- filepath.FromSlash("/music/artist/album2"),- }- repo.err = errors.New("fake error")- folder, upd, err := loadArtistFolder(ctx, fds, albums, paths)- Expect(err).To(MatchError(ContainSubstring("fake error")))- // Folder and time are empty on error.- Expect(folder).To(BeEmpty())- Expect(upd).To(BeZero())- })- })- })-- var _ = Describe("fromArtistFolder", func() {- var (- ctx context.Context- tempDir string- libFS fs.FS- testFunc sourceFunc- )-- BeforeEach(func() {- ctx = context.Background()- tempDir = GinkgoT().TempDir()- libFS = os.DirFS(tempDir)- })-- When("artist folder contains matching image", func() {- BeforeEach(func() {- // Create test structure: /temp/artist/artist.jpg- artistDir := filepath.Join(tempDir, "artist")- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())-- artistImagePath := filepath.Join(artistDir, "artist.jpg")- Expect(os.WriteFile(artistImagePath, []byte("fake image data"), 0600)).To(Succeed())-- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")- })-- It("finds and returns the image", func() {- reader, path, err := testFunc()- Expect(err).ToNot(HaveOccurred())- Expect(reader).ToNot(BeNil())- Expect(path).To(ContainSubstring("artist.jpg"))-- // Verify we can read the content- data, err := io.ReadAll(reader)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("fake image data"))- reader.Close()- })- })-- When("artist folder name contains glob metacharacters", func() {- BeforeEach(func() {- artistDir := filepath.Join(tempDir, "Artist [Live]")- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())-- artistImagePath := filepath.Join(artistDir, "artist.jpg")- Expect(os.WriteFile(artistImagePath, []byte("bracketed artist image"), 0600)).To(Succeed())-- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")- })-- It("treats the folder path literally when globbing through the library fs", func() {- reader, path, err := testFunc()- Expect(err).ToNot(HaveOccurred())- Expect(reader).ToNot(BeNil())- Expect(path).To(ContainSubstring("Artist [Live]" + string(filepath.Separator) + "artist.jpg"))-- data, err := io.ReadAll(reader)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("bracketed artist image"))- reader.Close()- })- })-- When("artist folder is empty but parent contains image", func() {- BeforeEach(func() {- // Create test structure: /temp/parent/artist.jpg and /temp/parent/artist/album/- parentDir := filepath.Join(tempDir, "parent")- artistDir := filepath.Join(parentDir, "artist")- albumDir := filepath.Join(artistDir, "album")- Expect(os.MkdirAll(albumDir, 0755)).To(Succeed())-- // Put artist image in parent directory- artistImagePath := filepath.Join(parentDir, "artist.jpg")- Expect(os.WriteFile(artistImagePath, []byte("parent image"), 0600)).To(Succeed())-- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")- })-- It("finds image in parent directory", func() {- reader, path, err := testFunc()- Expect(err).ToNot(HaveOccurred())- Expect(reader).ToNot(BeNil())- Expect(path).To(ContainSubstring("parent" + string(filepath.Separator) + "artist.jpg"))-- data, err := io.ReadAll(reader)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("parent image"))- reader.Close()- })- })-- When("image is two levels up", func() {- BeforeEach(func() {- // Create test structure: /temp/grandparent/artist.jpg and /temp/grandparent/parent/artist/- grandparentDir := filepath.Join(tempDir, "grandparent")- parentDir := filepath.Join(grandparentDir, "parent")- artistDir := filepath.Join(parentDir, "artist")- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())-- // Put artist image in grandparent directory- artistImagePath := filepath.Join(grandparentDir, "artist.jpg")- Expect(os.WriteFile(artistImagePath, []byte("grandparent image"), 0600)).To(Succeed())-- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")- })-- It("finds image in grandparent directory", func() {- reader, path, err := testFunc()- Expect(err).ToNot(HaveOccurred())- Expect(reader).ToNot(BeNil())- Expect(path).To(ContainSubstring("grandparent" + string(filepath.Separator) + "artist.jpg"))-- data, err := io.ReadAll(reader)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("grandparent image"))- reader.Close()- })- })-- When("images exist at multiple levels", func() {- BeforeEach(func() {- // Create test structure with images at multiple levels- grandparentDir := filepath.Join(tempDir, "grandparent")- parentDir := filepath.Join(grandparentDir, "parent")- artistDir := filepath.Join(parentDir, "artist")- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())-- // Put artist images at all levels- Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist level"), 0600)).To(Succeed())- Expect(os.WriteFile(filepath.Join(parentDir, "artist.jpg"), []byte("parent level"), 0600)).To(Succeed())- Expect(os.WriteFile(filepath.Join(grandparentDir, "artist.jpg"), []byte("grandparent level"), 0600)).To(Succeed())-- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")- })-- It("prioritizes the closest (artist folder) image", func() {- reader, path, err := testFunc()- Expect(err).ToNot(HaveOccurred())- Expect(reader).ToNot(BeNil())- Expect(path).To(ContainSubstring("artist" + string(filepath.Separator) + "artist.jpg"))-- data, err := io.ReadAll(reader)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("artist level"))- reader.Close()- })- })-- When("pattern matches multiple files", func() {- BeforeEach(func() {- artistDir := filepath.Join(tempDir, "artist")- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())-- // Create multiple matching files- Expect(os.WriteFile(filepath.Join(artistDir, "artist.abc"), []byte("text file"), 0600)).To(Succeed())- Expect(os.WriteFile(filepath.Join(artistDir, "artist.png"), []byte("png image"), 0600)).To(Succeed())- Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("jpg image"), 0600)).To(Succeed())-- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")- })-- It("returns the first valid image file in sorted order", func() {- reader, path, err := testFunc()- Expect(err).ToNot(HaveOccurred())- Expect(reader).ToNot(BeNil())-- // Should return an image file,- // Files are sorted: jpg comes before png alphabetically.- // .abc comes first, but it's not an image.- Expect(path).To(ContainSubstring("artist.jpg"))- reader.Close()- })- })-- When("prioritizing files without numeric suffixes", func() {- BeforeEach(func() {- // Test case for issue #4683: artist.jpg should come before artist.1.jpg- artistDir := filepath.Join(tempDir, "artist")- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())-- // Create multiple matches with and without numeric suffixes- Expect(os.WriteFile(filepath.Join(artistDir, "artist.1.jpg"), []byte("artist 1"), 0600)).To(Succeed())- Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist main"), 0600)).To(Succeed())- Expect(os.WriteFile(filepath.Join(artistDir, "artist.2.jpg"), []byte("artist 2"), 0600)).To(Succeed())-- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")- })-- It("returns artist.jpg before artist.1.jpg and artist.2.jpg", func() {- reader, path, err := testFunc()- Expect(err).ToNot(HaveOccurred())- Expect(reader).ToNot(BeNil())- Expect(path).To(ContainSubstring("artist.jpg"))-- // Verify it's the main file, not a numbered variant- data, err := io.ReadAll(reader)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("artist main"))- reader.Close()- })- })-- When("handling case-insensitive sorting", func() {- BeforeEach(func() {- // Test case to ensure case-insensitive natural sorting- artistDir := filepath.Join(tempDir, "artist")- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())-- // Create files with mixed case names- Expect(os.WriteFile(filepath.Join(artistDir, "Folder.jpg"), []byte("folder"), 0600)).To(Succeed())- Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist"), 0600)).To(Succeed())- Expect(os.WriteFile(filepath.Join(artistDir, "BACK.jpg"), []byte("back"), 0600)).To(Succeed())-- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "*.*")- })-- It("sorts case-insensitively", func() {- reader, path, err := testFunc()- Expect(err).ToNot(HaveOccurred())- Expect(reader).ToNot(BeNil())-- // Should return artist.jpg first (case-insensitive: "artist" < "back" < "folder")- Expect(path).To(ContainSubstring("artist.jpg"))-- data, err := io.ReadAll(reader)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("artist"))- reader.Close()- })- })-- When("no matching files exist anywhere", func() {- BeforeEach(func() {- artistDir := filepath.Join(tempDir, "artist")- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())-- // Create non-matching files- Expect(os.WriteFile(filepath.Join(artistDir, "cover.jpg"), []byte("cover image"), 0600)).To(Succeed())-- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")- })-- It("returns an error", func() {- reader, path, err := testFunc()- Expect(err).To(HaveOccurred())- Expect(reader).To(BeNil())- Expect(path).To(BeEmpty())- Expect(err.Error()).To(ContainSubstring("no matches for 'artist.*'"))- Expect(err.Error()).To(ContainSubstring("parent directories"))- })- })-- When("directory traversal reaches filesystem root", func() {- BeforeEach(func() {- // Start from a shallow directory to test root boundary- artistDir := filepath.Join(tempDir, "artist")- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())-- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")- })-- It("handles root boundary gracefully", func() {- reader, path, err := testFunc()- Expect(err).To(HaveOccurred())- Expect(reader).To(BeNil())- Expect(path).To(BeEmpty())- // Should not panic or cause infinite loop- })- })-- When("file exists but cannot be opened", func() {- BeforeEach(func() {- artistDir := filepath.Join(tempDir, "artist")- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())-- // Create a file that cannot be opened (permission denied)- restrictedFile := filepath.Join(artistDir, "artist.jpg")- Expect(os.WriteFile(restrictedFile, []byte("restricted"), 0600)).To(Succeed())-- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")- })-- It("logs warning and continues searching", func() {- // This test depends on the ability to restrict file permissions- // For now, we'll just ensure it doesn't panic and returns appropriate error- reader, _, err := testFunc()- // The file should be readable in test environment, so this will succeed- // In a real scenario with permission issues, it would continue searching- if err == nil {- Expect(reader).ToNot(BeNil())- reader.Close()- }- })- })-- When("single album artist scenario (original issue)", func() {- BeforeEach(func() {- // Simulate the exact folder structure from the issue:- // /music/artist/album1/ (single album)- // /music/artist/artist.jpg (artist image that should be found)- artistDir := filepath.Join(tempDir, "music", "artist")- albumDir := filepath.Join(artistDir, "album1")- Expect(os.MkdirAll(albumDir, 0755)).To(Succeed())-- // Create artist.jpg in the artist folder (this was not being found before)- artistImagePath := filepath.Join(artistDir, "artist.jpg")- Expect(os.WriteFile(artistImagePath, []byte("single album artist image"), 0600)).To(Succeed())-- // The fromArtistFolder is called with the artist folder path- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")- })-- It("finds artist.jpg in artist folder for single album artist", func() {- reader, path, err := testFunc()- Expect(err).ToNot(HaveOccurred())- Expect(reader).ToNot(BeNil())- Expect(path).To(ContainSubstring("artist.jpg"))- Expect(path).To(ContainSubstring("artist"))-- // Verify the content- data, err := io.ReadAll(reader)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("single album artist image"))- reader.Close()- })- })- })-- Describe("fromArtistUploadedImage", func() {- var (- tempDir string- reader *artistReader- )-- BeforeEach(func() {- DeferCleanup(configtest.SetupConfig())- tempDir = GinkgoT().TempDir()- conf.Server.DataFolder = conf.NewDir(tempDir)-- // Create the artwork/artist directory- Expect(os.MkdirAll(filepath.Join(tempDir, "artwork", "artist"), 0755)).To(Succeed())-- reader = &artistReader{}- })-- When("artist has an uploaded image", func() {- It("returns the uploaded image", func() {- imgPath := filepath.Join(tempDir, "artwork", "artist", "ar-1_test.jpg")- Expect(os.WriteFile(imgPath, []byte("uploaded artist image"), 0600)).To(Succeed())-- reader.artist = model.Artist{ID: "ar-1", UploadedImage: "ar-1_test.jpg"}- sf := reader.fromArtistUploadedImage()- r, path, err := sf()- Expect(err).ToNot(HaveOccurred())- Expect(r).ToNot(BeNil())- Expect(path).To(Equal(imgPath))-- data, err := io.ReadAll(r)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("uploaded artist image"))- r.Close()- })- })-- When("artist has no uploaded image", func() {- It("returns nil reader (falls through)", func() {- reader.artist = model.Artist{ID: "ar-1"}- sf := reader.fromArtistUploadedImage()- r, path, err := sf()- Expect(err).ToNot(HaveOccurred())- Expect(r).To(BeNil())- Expect(path).To(BeEmpty())- })- })- })-- Describe("fromArtistImageFolder", func() {- var (- ctx context.Context- tempDir string- ar *artistReader- )-- BeforeEach(func() {- ctx = context.Background()- DeferCleanup(configtest.SetupConfig())- tempDir = GinkgoT().TempDir()- ar = &artistReader{}- })-- When("ArtistImageFolder is not configured", func() {- It("returns nil (skips)", func() {- conf.Server.ArtistImageFolder = ""- ar.artist = model.Artist{Name: "Test Artist"}- sf := ar.fromArtistImageFolder(ctx)- r, path, err := sf()- Expect(err).ToNot(HaveOccurred())- Expect(r).To(BeNil())- Expect(path).To(BeEmpty())- })- })-- When("image exists matching MBID", func() {- It("finds the image by MBID", func() {- conf.Server.ArtistImageFolder = tempDir- mbid := "f27ec8db-af05-4f36-916e-3d57f91ecf5e"- imgPath := filepath.Join(tempDir, mbid+".jpg")- Expect(os.WriteFile(imgPath, []byte("mbid image"), 0600)).To(Succeed())-- ar.artist = model.Artist{Name: "Test Artist", MbzArtistID: mbid}- sf := ar.fromArtistImageFolder(ctx)- r, path, err := sf()- Expect(err).ToNot(HaveOccurred())- Expect(r).ToNot(BeNil())- Expect(path).To(Equal(imgPath))-- data, err := io.ReadAll(r)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("mbid image"))- r.Close()- })- })-- When("MBID match is case-insensitive", func() {- It("finds the image regardless of case", func() {- conf.Server.ArtistImageFolder = tempDir- mbid := "F27EC8DB-AF05-4F36-916E-3D57F91ECF5E"- imgPath := filepath.Join(tempDir, "f27ec8db-af05-4f36-916e-3d57f91ecf5e.png")- Expect(os.WriteFile(imgPath, []byte("mbid case image"), 0600)).To(Succeed())-- ar.artist = model.Artist{Name: "Test Artist", MbzArtistID: mbid}- sf := ar.fromArtistImageFolder(ctx)- r, path, err := sf()- Expect(err).ToNot(HaveOccurred())- Expect(r).ToNot(BeNil())- Expect(path).To(Equal(imgPath))- r.Close()- })- })-- When("no MBID file exists but artist name file does", func() {- It("falls back to artist name match", func() {- conf.Server.ArtistImageFolder = tempDir- imgPath := filepath.Join(tempDir, "Test Artist.jpg")- Expect(os.WriteFile(imgPath, []byte("name image"), 0600)).To(Succeed())-- ar.artist = model.Artist{Name: "Test Artist", MbzArtistID: "nonexistent-mbid"}- sf := ar.fromArtistImageFolder(ctx)- r, path, err := sf()- Expect(err).ToNot(HaveOccurred())- Expect(r).ToNot(BeNil())- Expect(path).To(Equal(imgPath))-- data, err := io.ReadAll(r)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("name image"))- r.Close()- })- })-- When("artist name match is case-insensitive", func() {- It("matches regardless of case", func() {- conf.Server.ArtistImageFolder = tempDir- imgPath := filepath.Join(tempDir, "test artist.jpg")- Expect(os.WriteFile(imgPath, []byte("case insensitive"), 0600)).To(Succeed())-- ar.artist = model.Artist{Name: "Test Artist"}- sf := ar.fromArtistImageFolder(ctx)- r, path, err := sf()- Expect(err).ToNot(HaveOccurred())- Expect(r).ToNot(BeNil())- Expect(path).To(Equal(imgPath))- r.Close()- })- })-- When("both MBID and name files exist", func() {- It("prefers MBID over name match", func() {- conf.Server.ArtistImageFolder = tempDir- mbid := "f27ec8db-af05-4f36-916e-3d57f91ecf5e"- mbidPath := filepath.Join(tempDir, mbid+".jpg")- namePath := filepath.Join(tempDir, "Test Artist.jpg")- Expect(os.WriteFile(mbidPath, []byte("mbid image"), 0600)).To(Succeed())- Expect(os.WriteFile(namePath, []byte("name image"), 0600)).To(Succeed())-- ar.artist = model.Artist{Name: "Test Artist", MbzArtistID: mbid}- sf := ar.fromArtistImageFolder(ctx)- r, path, err := sf()- Expect(err).ToNot(HaveOccurred())- Expect(r).ToNot(BeNil())- Expect(path).To(Equal(mbidPath))-- data, err := io.ReadAll(r)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("mbid image"))- r.Close()- })- })-- When("no matching image found", func() {- It("returns an error", func() {- conf.Server.ArtistImageFolder = tempDir- // Create an unrelated file- Expect(os.WriteFile(filepath.Join(tempDir, "other.jpg"), []byte("other"), 0600)).To(Succeed())-- ar.artist = model.Artist{Name: "Test Artist"}- sf := ar.fromArtistImageFolder(ctx)- r, _, err := sf()- Expect(err).To(HaveOccurred())- Expect(r).To(BeNil())- Expect(err.Error()).To(ContainSubstring("no image found"))- })- })-- When("cached imgFolderImgPath is set", func() {- It("uses cached path instead of scanning", func() {- conf.Server.ArtistImageFolder = tempDir- imgPath := filepath.Join(tempDir, "cached.jpg")- Expect(os.WriteFile(imgPath, []byte("cached image"), 0600)).To(Succeed())-- ar.artist = model.Artist{Name: "Test Artist"}- ar.imgFolderImgPath = imgPath- sf := ar.fromArtistImageFolder(ctx)- r, path, err := sf()- Expect(err).ToNot(HaveOccurred())- Expect(r).ToNot(BeNil())- Expect(path).To(Equal(imgPath))-- data, err := io.ReadAll(r)- Expect(err).ToNot(HaveOccurred())- Expect(string(data)).To(Equal("cached image"))- r.Close()- })- })- })-- Describe("findImageInArtistFolder", func() {- var tempDir string-- BeforeEach(func() {- tempDir = GinkgoT().TempDir()- })-- When("matching file exists by MBID", func() {- It("returns the file path", func() {- mbid := "f27ec8db-af05-4f36-916e-3d57f91ecf5e"- imgPath := filepath.Join(tempDir, mbid+".jpg")- Expect(os.WriteFile(imgPath, []byte("image"), 0600)).To(Succeed())-- path := findImageInArtistFolder(tempDir, mbid, "Test")- Expect(path).To(Equal(imgPath))- })- })-- When("matching file exists by name", func() {- It("returns the file path", func() {- imgPath := filepath.Join(tempDir, "Test Artist.png")- Expect(os.WriteFile(imgPath, []byte("image"), 0600)).To(Succeed())-- path := findImageInArtistFolder(tempDir, "", "Test Artist")- Expect(path).To(Equal(imgPath))- })- })-- When("no matching file exists", func() {- It("returns empty string", func() {- path := findImageInArtistFolder(tempDir, "", "Unknown Artist")- Expect(path).To(BeEmpty())- })- })-- When("folder does not exist", func() {- It("returns empty string", func() {- path := findImageInArtistFolder("/nonexistent/path", "", "Test")- Expect(path).To(BeEmpty())- })- })- })-})--type fakeFolderRepo struct {- model.FolderRepository- result []model.Folder- parentResult *model.Folder- getErr error- getCallCount int- err error- // hasOtherAudio is returned by HasAudioOutsideFolders (the album-root- // check). False means the parent qualifies as an album root.- hasOtherAudio bool- otherAudioErr error-}--func (f *fakeFolderRepo) GetAll(...model.QueryOptions) ([]model.Folder, error) {- return f.result, f.err-}--func (f *fakeFolderRepo) HasAudioOutsideFolders(model.Folder, []string) (bool, error) {- return f.hasOtherAudio, f.otherAudioErr-}--func (f *fakeFolderRepo) Get(id string) (*model.Folder, error) {- f.getCallCount++- if f.getErr != nil {- return nil, f.getErr- }- if f.parentResult != nil {- return f.parentResult, nil- }- return nil, model.ErrNotFound-}--type fakeDataStore struct {- model.DataStore- folderRepo *fakeFolderRepo-}--func (fds *fakeDataStore) Folder(_ context.Context) model.FolderRepository {- return fds.folderRepo-}--func stubCoreAbsolutePath() func() {- // Override core.AbsolutePath to return a fixed string during tests.- original := core.AbsolutePath- core.AbsolutePath = func(_ context.Context, ds model.DataStore, libID int, p string) string {- return filepath.FromSlash("/music")- }- return func() {- core.AbsolutePath = original- }-}diff --git a/core/artwork/reader_mediafile.go b/core/artwork/reader_mediafile.godeleted file mode 100644index eac3c5e70..000000000--- a/core/artwork/reader_mediafile.go+++ /dev/null@@ -1,82 +0,0 @@-package artwork--import (- "context"- "fmt"- "io"- "time"-- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/model"-)--type mediafileArtworkReader struct {- cacheKey- a *artwork- mediafile model.MediaFile- album model.Album- lib libraryView-}--func newMediafileArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID) (*mediafileArtworkReader, error) {- mf, err := artwork.ds.MediaFile(ctx).Get(artID.ID)- if err != nil {- return nil, err- }- al, err := artwork.ds.Album(ctx).Get(mf.AlbumID)- if err != nil {- return nil, err- }- _, _, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, artwork.ds, *al)- if err != nil {- return nil, err- }- lib, err := loadLibraryView(ctx, artwork.ds, mf.LibraryID)- if err != nil {- return nil, err- }- a := &mediafileArtworkReader{- a: artwork,- mediafile: *mf,- album: *al,- lib: lib,- }- a.cacheKey.artID = artID- a.cacheKey.lastUpdate = mf.UpdatedAt- if al.UpdatedAt.After(a.cacheKey.lastUpdate) {- a.cacheKey.lastUpdate = al.UpdatedAt- }- if imagesUpdatedAt != nil && imagesUpdatedAt.After(a.cacheKey.lastUpdate) {- a.cacheKey.lastUpdate = *imagesUpdatedAt- }- return a, nil-}--func (a *mediafileArtworkReader) Key() string {- return fmt.Sprintf(- "%s.%t",- a.cacheKey.Key(),- conf.Server.EnableMediaFileCoverArt,- )-}-func (a *mediafileArtworkReader) LastUpdated() time.Time {- return a.lastUpdate-}--func (a *mediafileArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {- var ff []sourceFunc- if a.mediafile.CoverArtID().Kind == model.KindMediaFileArtwork {- ff = []sourceFunc{- fromTag(ctx, a.lib.FS, a.mediafile.Path),- fromFFmpegTag(ctx, a.a.ffmpeg, a.lib.Abs(a.mediafile.Path)),- }- }- // For multi-disc albums, fall back to disc artwork first; for single-disc albums,- // skip disc resolution (it would just fall through to album art anyway).- if len(a.album.Discs) > 1 {- ff = append(ff, fromAlbum(ctx, a.a, a.mediafile.DiscCoverArtID()))- } else {- ff = append(ff, fromAlbum(ctx, a.a, a.mediafile.AlbumCoverArtID()))- }- return selectImageReader(ctx, a.artID, ff...)-}diff --git a/core/artwork/reader_playlist.go b/core/artwork/reader_playlist.godeleted file mode 100644index 09707843d..000000000--- a/core/artwork/reader_playlist.go+++ /dev/null@@ -1,269 +0,0 @@-package artwork--import (- "bytes"- "context"- "errors"- "image"- "image/draw"- "image/png"- "io"- "net/url"- "os"- "path/filepath"- "strings"- "time"-- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/log"- "github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/utils/slice"- xdraw "golang.org/x/image/draw"-)--type playlistArtworkReader struct {- cacheKey- a *artwork- pl model.Playlist-}--const tileSize = 600--func newPlaylistArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID) (*playlistArtworkReader, error) {- pl, err := artwork.ds.Playlist(ctx).Get(artID.ID)- if err != nil {- return nil, err- }- a := &playlistArtworkReader{- a: artwork,- pl: *pl,- }- a.cacheKey.artID = artID- a.cacheKey.lastUpdate = pl.UpdatedAt-- // Check sidecar and ExternalImageURL local file ModTimes for cache invalidation.- // If either is newer than the playlist's UpdatedAt, use that instead so the- // cache is busted when a user replaces a sidecar image or local file reference.- for _, path := range []string{- findPlaylistSidecarPath(ctx, pl.Path),- pl.ExternalImageURL,- } {- if path == "" || strings.HasPrefix(path, "http://") || strings.HasPrefix(path, "https://") {- continue- }- if info, err := os.Stat(path); err == nil {- if info.ModTime().After(a.cacheKey.lastUpdate) {- a.cacheKey.lastUpdate = info.ModTime()- }- }- }-- return a, nil-}--func (a *playlistArtworkReader) LastUpdated() time.Time {- return a.lastUpdate-}--func (a *playlistArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {- return selectImageReader(ctx, a.artID,- a.fromPlaylistUploadedImage(),- a.fromPlaylistSidecar(ctx),- a.fromPlaylistExternalImage(ctx),- a.fromGeneratedTiledCover(ctx),- fromAlbumPlaceholder(),- )-}--func (a *playlistArtworkReader) fromPlaylistUploadedImage() sourceFunc {- return fromLocalFile(a.pl.UploadedImagePath())-}--func (a *playlistArtworkReader) fromPlaylistSidecar(ctx context.Context) sourceFunc {- return fromLocalFile(findPlaylistSidecarPath(ctx, a.pl.Path))-}--func (a *playlistArtworkReader) fromPlaylistExternalImage(ctx context.Context) sourceFunc {- return func() (io.ReadCloser, string, error) {- imgURL := a.pl.ExternalImageURL- if imgURL == "" {- return nil, "", nil- }- parsed, err := url.Parse(imgURL)- if err != nil {- return nil, "", err- }- if parsed.Scheme == "http" || parsed.Scheme == "https" {- if !conf.Server.EnableM3UExternalAlbumArt {- return nil, "", nil- }- return fromURL(ctx, parsed)- }- return fromLocalFile(imgURL)()- }-}--// fromLocalFile returns a sourceFunc that opens the given local path.-// Returns (nil, "", nil) if path is empty — signalling "not found, try next source".-func fromLocalFile(path string) sourceFunc {- return func() (io.ReadCloser, string, error) {- if path == "" {- return nil, "", nil- }- f, err := os.Open(path)- if err != nil {- return nil, "", err- }- return f, path, nil- }-}--// findPlaylistSidecarPath scans the directory of the playlist file for a sidecar-// image file with the same base name (case-insensitive). Returns empty string if-// no matching image is found or if plsPath is empty.-func findPlaylistSidecarPath(ctx context.Context, plsPath string) string {- if plsPath == "" {- return ""- }- dir := filepath.Dir(plsPath)- base := strings.TrimSuffix(filepath.Base(plsPath), filepath.Ext(plsPath))-- entries, err := os.ReadDir(dir)- if err != nil {- log.Warn(ctx, "Could not read directory for playlist sidecar", "dir", dir, err)- return ""- }- for _, entry := range entries {- name := entry.Name()- nameBase := strings.TrimSuffix(name, filepath.Ext(name))- if !entry.IsDir() && strings.EqualFold(nameBase, base) && model.IsImageFile(name) {- return filepath.Join(dir, name)- }- }- return ""-}--func (a *playlistArtworkReader) fromGeneratedTiledCover(ctx context.Context) sourceFunc {- return func() (io.ReadCloser, string, error) {- tiles, err := a.loadTiles(ctx)- if err != nil {- return nil, "", err- }- r, err := a.createTiledImage(ctx, tiles)- return r, "", err- }-}--func toAlbumArtworkIDs(albumIDs []string) []model.ArtworkID {- return slice.Map(albumIDs, func(id string) model.ArtworkID {- al := model.Album{ID: id}- return al.CoverArtID()- })-}--func (a *playlistArtworkReader) loadTiles(ctx context.Context) ([]image.Image, error) {- tracksRepo := a.a.ds.Playlist(ctx).Tracks(a.pl.ID, false)- albumIds, err := tracksRepo.GetAlbumIDs(model.QueryOptions{Max: 4, Sort: "random()"})- if err != nil {- log.Error(ctx, "Error getting album IDs for playlist", "id", a.pl.ID, "name", a.pl.Name, err)- return nil, err- }- ids := toAlbumArtworkIDs(albumIds)-- var tiles []image.Image- for _, id := range ids {- r, _, err := fromAlbum(ctx, a.a, id)()- if err == nil {- tile, err := a.createTile(ctx, r)- if err == nil {- tiles = append(tiles, tile)- }- _ = r.Close()- }- if len(tiles) == 4 {- break- }- }- switch len(tiles) {- case 0:- return nil, errors.New("could not find any eligible cover")- case 2:- tiles = append(tiles, tiles[1], tiles[0])- case 3:- tiles = append(tiles, tiles[0])- }- return tiles, nil-}--func (a *playlistArtworkReader) createTile(_ context.Context, r io.ReadCloser) (image.Image, error) {- img, _, err := image.Decode(r)- if err != nil {- return nil, err- }- return fillCenter(img, tileSize/2, tileSize/2), nil-}--func (a *playlistArtworkReader) createTiledImage(_ context.Context, tiles []image.Image) (io.ReadCloser, error) {- buf := new(bytes.Buffer)- var rgba draw.Image- var err error- if len(tiles) == 4 {- rgba = image.NewRGBA(image.Rectangle{Max: image.Point{X: tileSize - 1, Y: tileSize - 1}})- draw.Draw(rgba, rect(0), tiles[0], image.Point{}, draw.Src)- draw.Draw(rgba, rect(1), tiles[1], image.Point{}, draw.Src)- draw.Draw(rgba, rect(2), tiles[2], image.Point{}, draw.Src)- draw.Draw(rgba, rect(3), tiles[3], image.Point{}, draw.Src)- err = png.Encode(buf, rgba)- } else {- err = png.Encode(buf, tiles[0])- }- if err != nil {- return nil, err- }- return io.NopCloser(buf), nil-}--func rect(pos int) image.Rectangle {- r := image.Rectangle{}- switch pos {- case 1:- r.Min.X = tileSize / 2- case 2:- r.Min.Y = tileSize / 2- case 3:- r.Min.X = tileSize / 2- r.Min.Y = tileSize / 2- }- r.Max.X = r.Min.X + tileSize/2- r.Max.Y = r.Min.Y + tileSize/2- return r-}--// fillCenter crops the source image from the center and scales it to fill dstW x dstH exactly,-// equivalent to imaging.Fill with Center anchor.-func fillCenter(src image.Image, dstW, dstH int) image.Image {- srcBounds := src.Bounds()- srcW := srcBounds.Dx()- srcH := srcBounds.Dy()-- // Calculate crop rectangle (center crop to match destination aspect ratio)- srcAspect := float64(srcW) / float64(srcH)- dstAspect := float64(dstW) / float64(dstH)-- var cropRect image.Rectangle- if srcAspect > dstAspect {- // Source is wider — crop horizontally- cropW := int(float64(srcH) * dstAspect)- cropX := (srcW - cropW) / 2- cropRect = image.Rect(srcBounds.Min.X+cropX, srcBounds.Min.Y, srcBounds.Min.X+cropX+cropW, srcBounds.Max.Y)- } else {- // Source is taller — crop vertically- cropH := int(float64(srcW) / dstAspect)- cropY := (srcH - cropH) / 2- cropRect = image.Rect(srcBounds.Min.X, srcBounds.Min.Y+cropY, srcBounds.Max.X, srcBounds.Min.Y+cropY+cropH)- }-- dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))- xdraw.CatmullRom.Scale(dst, dst.Bounds(), src, cropRect, draw.Src, nil)- return dst-}diff --git a/core/artwork/reader_radio.go b/core/artwork/reader_radio.godeleted file mode 100644index 22db6e302..000000000--- a/core/artwork/reader_radio.go+++ /dev/null@@ -1,40 +0,0 @@-package artwork--import (- "context"- "io"- "time"-- "github.com/navidrome/navidrome/model"-)--type radioArtworkReader struct {- cacheKey- a *artwork- radio model.Radio-}--func newRadioArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID) (*radioArtworkReader, error) {- r, err := artwork.ds.Radio(ctx).Get(artID.ID)- if err != nil {- return nil, err- }- a := &radioArtworkReader{a: artwork, radio: *r}- a.cacheKey.artID = artID- a.cacheKey.lastUpdate = r.UpdatedAt- return a, nil-}--func (a *radioArtworkReader) LastUpdated() time.Time {- return a.lastUpdate-}--func (a *radioArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {- return selectImageReader(ctx, a.artID,- a.fromRadioUploadedImage(),- )-}--func (a *radioArtworkReader) fromRadioUploadedImage() sourceFunc {- return fromLocalFile(a.radio.UploadedImagePath())-}diff --git a/core/artwork/reader_radio_test.go b/core/artwork/reader_radio_test.godeleted file mode 100644index 37ce1d827..000000000--- a/core/artwork/reader_radio_test.go+++ /dev/null@@ -1,84 +0,0 @@-package artwork--import (- "context"- "os"- "path/filepath"-- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/conf/configtest"- "github.com/navidrome/navidrome/model"- . "github.com/onsi/ginkgo/v2"- . "github.com/onsi/gomega"-)--var _ = Describe("radioArtworkReader", func() {- var (- tempDir string- reader *radioArtworkReader- )-- BeforeEach(func() {- DeferCleanup(configtest.SetupConfig())- tempDir = GinkgoT().TempDir()- conf.Server.DataFolder = conf.NewDir(tempDir)-- Expect(os.MkdirAll(filepath.Join(tempDir, "artwork", "radio"), 0755)).To(Succeed())-- reader = &radioArtworkReader{}- })-- Describe("fromRadioUploadedImage", func() {- When("radio has an uploaded image", func() {- It("returns the uploaded image", func() {- imgPath := filepath.Join(tempDir, "artwork", "radio", "rd-1_test.jpg")- Expect(os.WriteFile(imgPath, []byte("uploaded radio image"), 0600)).To(Succeed())-- reader.radio = model.Radio{ID: "rd-1", UploadedImage: "rd-1_test.jpg"}- sf := reader.fromRadioUploadedImage()- r, path, err := sf()- Expect(err).ToNot(HaveOccurred())- Expect(r).ToNot(BeNil())- Expect(path).To(Equal(imgPath))- r.Close()- })- })-- When("radio has no uploaded image", func() {- It("returns nil reader (falls through)", func() {- reader.radio = model.Radio{ID: "rd-1"}- sf := reader.fromRadioUploadedImage()- r, path, err := sf()- Expect(err).ToNot(HaveOccurred())- Expect(r).To(BeNil())- Expect(path).To(BeEmpty())- })- })- })-- Describe("Reader", func() {- When("radio has an uploaded image", func() {- It("returns the image reader", func() {- imgPath := filepath.Join(tempDir, "artwork", "radio", "rd-1_test.jpg")- Expect(os.WriteFile(imgPath, []byte("uploaded radio image"), 0600)).To(Succeed())-- reader.radio = model.Radio{ID: "rd-1", UploadedImage: "rd-1_test.jpg"}- reader.cacheKey.artID = model.ArtworkID{Kind: model.KindRadioArtwork, ID: "rd-1"}- r, _, err := reader.Reader(context.Background())- Expect(err).ToNot(HaveOccurred())- Expect(r).ToNot(BeNil())- r.Close()- })- })-- When("radio has no uploaded image", func() {- It("returns ErrUnavailable", func() {- reader.radio = model.Radio{ID: "rd-1"}- reader.cacheKey.artID = model.ArtworkID{Kind: model.KindRadioArtwork, ID: "rd-1"}- r, _, err := reader.Reader(context.Background())- Expect(err).To(MatchError(ErrUnavailable))- Expect(r).To(BeNil())- })- })- })-})diff --git a/core/artwork/reader_resized.go b/core/artwork/reader_resized.godeleted file mode 100644index cd16cbada..000000000--- a/core/artwork/reader_resized.go+++ /dev/null@@ -1,209 +0,0 @@-package artwork--import (- "bytes"- "context"- "fmt"- "image"- "image/draw"- "image/jpeg"- "image/png"- "io"- "sync"- "time"-- "github.com/gen2brain/webp"- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/log"- "github.com/navidrome/navidrome/model"- xdraw "golang.org/x/image/draw"-)--func init() {- conf.AddHook(func() {- // gen2brain/webp selects native (purego/libwebp) vs WASM in its own- // package init() and exposes the result only via webp.Dynamic(); there is- // no runtime way to switch back. On 32-bit ARM/x86 the purego callback path- // crashes (issue #5597), so those builds must be compiled with the- // "nodynamic" tag (see Dockerfile), which makes webp.Dynamic() report an- // error here and forces the safe WASM path.- if err := webp.Dynamic(); err != nil {- log.Debug("Using WASM WebP encoder/decoder", "reason", err)- } else {- log.Debug("Using native libwebp for WebP encoding/decoding")- }- })-}--var bufPool = sync.Pool{- New: func() any {- return new(bytes.Buffer)- },-}--type resizedArtworkReader struct {- artID model.ArtworkID- cacheKey string- lastUpdate time.Time- size int- square bool- a *artwork-}--func resizedFromOriginal(ctx context.Context, a *artwork, artID model.ArtworkID, size int, square bool) (*resizedArtworkReader, error) {- r := &resizedArtworkReader{a: a}- r.artID = artID- r.size = size- r.square = square-- // Get lastUpdated and cacheKey from original artwork- original, err := a.getArtworkReader(ctx, artID, 0, false)- if err != nil {- return nil, err- }- r.cacheKey = original.Key()- r.lastUpdate = original.LastUpdated()- return r, nil-}--func (a *resizedArtworkReader) Key() string {- baseKey := fmt.Sprintf("%s.%d", a.cacheKey, a.size)- if a.square {- return baseKey + ".square"- }- return fmt.Sprintf("%s.%d", baseKey, conf.Server.CoverArtQuality)-}--func (a *resizedArtworkReader) LastUpdated() time.Time {- return a.lastUpdate-}--func (a *resizedArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {- // Get artwork in original size, possibly from cache- orig, _, err := a.a.Get(ctx, a.artID, 0, false)- if err != nil {- return nil, "", err- }- defer orig.Close()-- resized, origSize, err := a.resizeImage(ctx, orig)- if resized == nil {- log.Trace(ctx, "Image smaller than requested size", "artID", a.artID, "original", origSize, "resized", a.size, "square", a.square)- } else {- log.Trace(ctx, "Resizing artwork", "artID", a.artID, "original", origSize, "resized", a.size, "square", a.square)- }- if err != nil {- log.Warn(ctx, "Could not resize image. Will return image as is", "artID", a.artID, "size", a.size, "square", a.square, err)- }- if err != nil || resized == nil {- // if we couldn't resize the image, return the original- orig, _, err = a.a.Get(ctx, a.artID, 0, false)- return orig, "", err- }- // Preserve ReadCloser semantics if the resized reader already supports Close- // (e.g., ffmpeg pipe), otherwise wrap with NopCloser- if rc, ok := resized.(io.ReadCloser); ok {- return rc, fmt.Sprintf("%s@%d", a.artID, a.size), nil- }- return io.NopCloser(resized), fmt.Sprintf("%s@%d", a.artID, a.size), nil-}--func (a *resizedArtworkReader) resizeImage(ctx context.Context, reader io.Reader) (io.Reader, int, error) {- data, err := io.ReadAll(reader)- if err != nil {- return nil, 0, fmt.Errorf("reading image data: %w", err)- }-- // Preserve animation for animated images- if isAnimatedGIF(data) {- if a.a.ffmpeg.IsAvailable() {- // Animated GIF: convert to animated WebP via ffmpeg (with optional resize)- r, err := a.a.ffmpeg.ConvertAnimatedImage(ctx, bytes.NewReader(data), a.size, conf.Server.CoverArtQuality)- if err == nil {- return r, 0, nil- }- log.Warn(ctx, "Could not convert animated GIF, falling back to static", err)- }- } else if isAnimatedWebP(data) || isAnimatedPNG(data) {- // Animated WebP/APNG: return original as-is (ffmpeg can't re-encode these)- return bytes.NewReader(data), 0, nil- }-- return resizeStaticImage(data, a.size, a.square)-}--// toFastScaleType converts images whose concrete type has no optimized scaler-// in x/image/draw (e.g. *image.NYCbCrA from WebP, *image.Paletted from indexed-// PNGs) into *image.RGBA, which has a fast path. Without this, CatmullRom.Scale-// falls back to a generic per-pixel At()/RGBA() loop that is several times-// slower. Fast-path types are returned unchanged.-func toFastScaleType(img image.Image) image.Image {- switch img.(type) {- case *image.RGBA, *image.NRGBA, *image.Gray, *image.YCbCr:- return img- default:- rgba := image.NewRGBA(img.Bounds())- draw.Draw(rgba, rgba.Bounds(), img, img.Bounds().Min, draw.Src)- return rgba- }-}--func resizeStaticImage(data []byte, size int, square bool) (io.Reader, int, error) {- original, format, err := image.Decode(bytes.NewReader(data))- if err != nil {- return nil, 0, err- }-- bounds := original.Bounds()- originalSize := max(bounds.Max.X, bounds.Max.Y)-- // Clamp size to original dimensions - upscaling wastes resources and adds no information- if size > originalSize {- size = originalSize- }-- if originalSize <= size && !square {- return nil, originalSize, nil- }-- // Calculate aspect-fit dimensions- srcW, srcH := bounds.Dx(), bounds.Dy()- scale := float64(size) / float64(max(srcW, srcH))- dstW := int(float64(srcW) * scale)- dstH := int(float64(srcH) * scale)-- var dst *image.NRGBA- var dstRect image.Rectangle- if square {- // Square canvas with image centered (transparent padding via zero-initialized NRGBA)- dst = image.NewNRGBA(image.Rect(0, 0, size, size))- offsetX := (size - dstW) / 2- offsetY := (size - dstH) / 2- dstRect = image.Rect(offsetX, offsetY, offsetX+dstW, offsetY+dstH)- } else {- // Tight-fit canvas- dst = image.NewNRGBA(image.Rect(0, 0, dstW, dstH))- dstRect = dst.Bounds()- }- original = toFastScaleType(original)- xdraw.CatmullRom.Scale(dst, dstRect, original, bounds, draw.Src, nil)-- buf := bufPool.Get().(*bytes.Buffer)- buf.Reset()- if conf.Server.EnableWebPEncoding {- err = webp.Encode(buf, dst, webp.Options{Quality: conf.Server.CoverArtQuality})- } else if format == "png" || square {- err = png.Encode(buf, dst)- } else {- err = jpeg.Encode(buf, dst, &jpeg.Options{Quality: conf.Server.CoverArtQuality})- }- if err != nil {- bufPool.Put(buf)- return nil, originalSize, err- }- // Copy bytes before returning buffer to pool (pool may reuse the buffer)- encoded := make([]byte, buf.Len())- copy(encoded, buf.Bytes())- bufPool.Put(buf)- return bytes.NewReader(encoded), originalSize, nil-}diff --git a/core/artwork/reader_resized_test.go b/core/artwork/reader_resized_test.godeleted file mode 100644index 7c14f5e44..000000000--- a/core/artwork/reader_resized_test.go+++ /dev/null@@ -1,176 +0,0 @@-package artwork--import (- "bytes"- "context"- "errors"- "io"-- "github.com/navidrome/navidrome/core/ffmpeg"- "github.com/navidrome/navidrome/tests"- . "github.com/onsi/ginkgo/v2"- . "github.com/onsi/gomega"-)--var _ = Describe("resizeImage", func() {- var mockFF *tests.MockFFmpeg- var r *resizedArtworkReader-- BeforeEach(func() {- mockFF = tests.NewMockFFmpeg("converted-animated-data")- r = &resizedArtworkReader{- size: 300,- square: false,- a: &artwork{ffmpeg: mockFF},- }- })-- Describe("animated GIF handling", func() {- It("converts animated GIF via ffmpeg when available", func() {- data := createAnimatedGIF(3)- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))- Expect(err).ToNot(HaveOccurred())- Expect(result).ToNot(BeNil())-- // Should have been processed by ffmpeg (mock returns "converted-animated-data")- output, err := io.ReadAll(result)- Expect(err).ToNot(HaveOccurred())- Expect(output).To(Equal(data)) // MockFFmpeg echoes input back- })-- It("falls back to static resize when ffmpeg fails for animated GIF", func() {- mockFF.Error = errors.New("ffmpeg failed")- // Use size smaller than image so static resize actually produces output- r.size = 1- data := createAnimatedGIF(3)- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))- // Should fall through to static resize successfully (no ffmpeg error propagated)- Expect(err).ToNot(HaveOccurred())- Expect(result).ToNot(BeNil())-- // Verify it's a static image (WebP encoded), not the ffmpeg error- output, err := io.ReadAll(result)- Expect(err).ToNot(HaveOccurred())- Expect(len(output)).To(BeNumerically(">", 0))- })-- It("preserves animation for square thumbnails with animated GIF", func() {- r.square = true- data := createAnimatedGIF(3)- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))- Expect(err).ToNot(HaveOccurred())- Expect(result).ToNot(BeNil())-- // Should have been processed by ffmpeg (mock returns input data)- output, err := io.ReadAll(result)- Expect(err).ToNot(HaveOccurred())- Expect(output).To(Equal(data))- })- })-- Describe("animated WebP handling", func() {- It("returns animated WebP data as-is when not square", func() {- data := createAnimatedWebPBytes()- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))- Expect(err).ToNot(HaveOccurred())- Expect(result).ToNot(BeNil())-- // Should return original data unchanged- output, err := io.ReadAll(result)- Expect(err).ToNot(HaveOccurred())- Expect(output).To(Equal(data))- })-- It("preserves animated WebP for square thumbnails", func() {- r.square = true- data := createAnimatedWebPBytes()- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))- Expect(err).ToNot(HaveOccurred())- Expect(result).ToNot(BeNil())-- // Should return original data unchanged- output, err := io.ReadAll(result)- Expect(err).ToNot(HaveOccurred())- Expect(output).To(Equal(data))- })- })-- Describe("animated PNG handling", func() {- It("returns animated PNG data as-is when not square", func() {- data := createAPNGBytes()- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))- Expect(err).ToNot(HaveOccurred())- Expect(result).ToNot(BeNil())-- // Should return original data unchanged- output, err := io.ReadAll(result)- Expect(err).ToNot(HaveOccurred())- Expect(output).To(Equal(data))- })-- It("preserves animated PNG for square thumbnails", func() {- r.square = true- data := createAPNGBytes()- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))- Expect(err).ToNot(HaveOccurred())- Expect(result).ToNot(BeNil())-- // Should return original data unchanged- output, err := io.ReadAll(result)- Expect(err).ToNot(HaveOccurred())- Expect(output).To(Equal(data))- })- })-- Describe("static image handling", func() {- It("resizes a static PNG normally", func() {- data := createStaticPNGBytes()- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))- // Static PNG is 2x2, size 300 is larger, so should return nil (no upscale)- Expect(err).ToNot(HaveOccurred())- Expect(result).To(BeNil())- })- })-- Describe("ReadCloser preservation", func() {- It("preserves Close semantics from ffmpeg ReadCloser", func() {- // Create a trackable ReadCloser- tracker := &closeTracker{Reader: bytes.NewReader([]byte("test data"))}- mockFF2 := &mockFFmpegWithCloser{tracker: tracker}- r.a = &artwork{ffmpeg: mockFF2}-- data := createAnimatedGIF(3)- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))- Expect(err).ToNot(HaveOccurred())-- // The result should be an io.ReadCloser (the tracker)- rc, ok := result.(io.ReadCloser)- Expect(ok).To(BeTrue())- Expect(rc.Close()).ToNot(HaveOccurred())- Expect(tracker.closed).To(BeTrue())- })- })-})--// closeTracker is an io.ReadCloser that tracks whether Close was called.-type closeTracker struct {- io.Reader- closed bool-}--func (c *closeTracker) Close() error {- c.closed = true- return nil-}--// mockFFmpegWithCloser is a minimal FFmpeg mock that returns a specific ReadCloser-// for ConvertAnimatedImage, allowing us to verify Close propagation.-type mockFFmpegWithCloser struct {- ffmpeg.FFmpeg- tracker *closeTracker-}--func (m *mockFFmpegWithCloser) IsAvailable() bool { return true }-func (m *mockFFmpegWithCloser) ConvertAnimatedImage(_ context.Context, _ io.Reader, _ int, _ int) (io.ReadCloser, error) {- return m.tracker, nil-}diff --git a/core/artwork/resize.go b/core/artwork/resize.gonew file mode 100644index 000000000..9536c3bb1--- /dev/null+++ b/core/artwork/resize.go@@ -0,0 +1,144 @@+package artwork++import (+ "bytes"+ "context"+ "fmt"+ "image"+ "image/draw"+ "image/jpeg"+ "image/png"+ "io"+ "sync"+ "time"++ "github.com/gen2brain/webp"+ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/core/ffmpeg"+ "github.com/navidrome/navidrome/log"+ xdraw "golang.org/x/image/draw"+)++func init() {+ conf.AddHook(func() {+ // gen2brain/webp picks native vs WASM in its own init(), with no way to switch at+ // runtime: 32-bit builds need the "nodynamic" tag (see Dockerfile) to force WASM.+ if err := webp.Dynamic(); err != nil {+ log.Debug("Artwork: Using WASM WebP encoder/decoder", "reason", err)+ } else {+ log.Debug("Artwork: Using native libwebp for WebP encoding/decoding")+ }+ })+}++var bufPool = sync.Pool{+ New: func() any {+ return new(bytes.Buffer)+ },+}++// resizeImageData resizes raw image bytes to fit size, preserving animation where+// possible. A nil reader means the image was already within bounds (no resize needed).+func resizeImageData(ctx context.Context, ffm ffmpeg.FFmpeg, data []byte, size int, square bool) (io.Reader, int, error) {+ start := time.Now()+ defer func() {+ log.Trace(ctx, "Artwork: Resized image", "bytes", len(data), "size", size, "square", square,+ "elapsed", time.Since(start))+ }()+ if isAnimatedGIF(data) {+ if ffm.IsAvailable() {+ // Animated GIF: convert to animated WebP via ffmpeg (with optional resize)+ r, err := ffm.ConvertAnimatedImage(ctx, bytes.NewReader(data), size, conf.Server.CoverArtQuality)+ if err == nil {+ return r, 0, nil+ }+ log.Warn(ctx, "Artwork: Could not convert animated GIF, falling back to static", err)+ }+ } else if isAnimatedWebP(data) || isAnimatedPNG(data) {+ // Animated WebP/APNG: return original as-is (ffmpeg can't re-encode these)+ return bytes.NewReader(data), 0, nil+ }++ return resizeStaticImage(data, size, square)+}++// toFastScaleType converts types x/image/draw has no optimized scaler for (e.g. *image.NYCbCrA,+// *image.Paletted) to *image.RGBA, avoiding CatmullRom.Scale's generic per-pixel fallback.+func toFastScaleType(img image.Image) image.Image {+ switch img.(type) {+ case *image.RGBA, *image.NRGBA, *image.Gray, *image.YCbCr:+ return img+ default:+ rgba := image.NewRGBA(img.Bounds())+ draw.Draw(rgba, rgba.Bounds(), img, img.Bounds().Min, draw.Src)+ return rgba+ }+}++func resizeStaticImage(data []byte, size int, square bool) (io.Reader, int, error) {+ original, format, err := image.Decode(bytes.NewReader(data))+ if err != nil {+ return nil, 0, err+ }++ bounds := original.Bounds()+ originalSize := max(bounds.Max.X, bounds.Max.Y)++ // Clamp size to original dimensions - upscaling wastes resources and adds no information+ if size > originalSize {+ size = originalSize+ }++ if originalSize <= size && !square {+ return nil, originalSize, nil+ }++ // Calculate aspect-fit dimensions+ srcW, srcH := bounds.Dx(), bounds.Dy()+ scale := float64(size) / float64(max(srcW, srcH))+ dstW := int(float64(srcW) * scale)+ dstH := int(float64(srcH) * scale)++ var dst *image.NRGBA+ var dstRect image.Rectangle+ if square {+ // Square canvas with image centered (transparent padding via zero-initialized NRGBA)+ dst = image.NewNRGBA(image.Rect(0, 0, size, size))+ offsetX := (size - dstW) / 2+ offsetY := (size - dstH) / 2+ dstRect = image.Rect(offsetX, offsetY, offsetX+dstW, offsetY+dstH)+ } else {+ // Tight-fit canvas+ dst = image.NewNRGBA(image.Rect(0, 0, dstW, dstH))+ dstRect = dst.Bounds()+ }+ original = toFastScaleType(original)+ xdraw.CatmullRom.Scale(dst, dstRect, original, bounds, draw.Src, nil)++ buf := bufPool.Get().(*bytes.Buffer)+ buf.Reset()+ if conf.Server.EnableWebPEncoding {+ err = webp.Encode(buf, dst, webp.Options{Quality: conf.Server.CoverArtQuality})+ } else if format == "png" || square {+ err = png.Encode(buf, dst)+ } else {+ err = jpeg.Encode(buf, dst, &jpeg.Options{Quality: conf.Server.CoverArtQuality})+ }+ if err != nil {+ bufPool.Put(buf)+ return nil, originalSize, err+ }+ // Copy bytes before returning buffer to pool (pool may reuse the buffer)+ encoded := bytes.Clone(buf.Bytes())+ bufPool.Put(buf)+ return bytes.NewReader(encoded), originalSize, nil+}++// formatQualityTag folds the encoder config (WebP toggle + quality) into a cache-key+// fragment, so flipping either setting invalidates previously-encoded sized artwork.+func formatQualityTag() string {+ if conf.Server.EnableWebPEncoding {+ return fmt.Sprintf("webp%d", conf.Server.CoverArtQuality)+ }+ return fmt.Sprintf("q%d", conf.Server.CoverArtQuality)+}diff --git a/core/artwork/resolve.go b/core/artwork/resolve.gonew file mode 100644index 000000000..11711469d--- /dev/null+++ b/core/artwork/resolve.go@@ -0,0 +1,452 @@+package artwork++import (+ "context"+ "errors"+ "fmt"+ "image"+ "io"+ "io/fs"+ "net/url"+ "os"+ "strings"++ "github.com/Masterminds/squirrel"+ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/core/ffmpeg"+ "github.com/navidrome/navidrome/model"+)++// resolution is one attempted acquisition outcome for an entity.+type resolution struct {+ reader io.ReadCloser // nil when no source yielded an image+ source string // model.ItemArtwork.Source value: "folder", "embedded", "external", "upload", "generated"+ sourcePath string // backing library/upload file (folder/upload: the image; embedded: the audio file); "" otherwise+ refMtime int64 // sourcePath mtime (unix-nanoseconds) at resolution; 0 when no sourcePath+ // external source errored/timed out. With no reader it forces failed (never absent);+ // on a hit a higher-priority external step failed—serve this, but retry later.+ extError bool+ // a local source that should have been readable wasn't. With no reader it forces failed,+ // so a transient I/O fault never records absent.+ localError bool+}++// chainState carries what a priority walk has seen so far. A hit takes extErr with it so a+// transient external failure still retries; localErr is dropped, as the scanner re-lists changes.+type chainState struct{ extErr, localErr bool }++// try stamps the accumulated external failure onto a hit, and records the miss otherwise.+func (c *chainState) try(res resolution, ok bool) (resolution, bool) {+ if ok {+ res.extError = c.extErr+ return res, true+ }+ c.localErr = c.localErr || res.localError+ return resolution{}, false+}++// exhausted is the outcome when no source in the chain yielded an image.+func (c *chainState) exhausted() resolution {+ return resolution{extError: c.extErr, localError: c.localErr}+}++// externalSource holds the agents to ask and the rate limiter/circuit breaker to ask them through.+type externalSource struct {+ agents *agents.Agents+ gate gateFunc+}++// resolver walks a kind's priority chain and returns the first hit; a nil ext means local-only.+type resolver struct {+ ds model.DataStore+ ffmpeg ffmpeg.FFmpeg+ ext *externalSource+}++func newResolver(ds model.DataStore, ag *agents.Agents, ffm ffmpeg.FFmpeg, gate gateFunc) *resolver {+ if gate == nil {+ gate = passthroughGate+ }+ return &resolver{ds: ds, ffmpeg: ffm, ext: &externalSource{agents: ag, gate: gate}}+}++// newLocalResolver builds a resolver that can neither reach the network nor sample album art+// for the worker-built grid.+func newLocalResolver(ds model.DataStore, ffm ffmpeg.FFmpeg) *resolver {+ return &resolver{ds: ds, ffmpeg: ffm}+}++func (r *resolver) resolve(ctx context.Context, item model.ArtworkQueueItem) (resolution, error) {+ kind, _ := model.ParseKind(item.ItemKind)+ switch kind {+ case model.KindAlbumArtwork:+ return r.resolveAlbum(ctx, item.ItemID)+ case model.KindArtistArtwork:+ return r.resolveArtist(ctx, item.ItemID)+ case model.KindPlaylistArtwork:+ return r.resolvePlaylist(ctx, item.ItemID)+ case model.KindRadioArtwork:+ return r.resolveRadio(ctx, item.ItemID)+ case model.KindMediaFileArtwork:+ return r.resolveMediaFile(ctx, item.ItemID)+ default:+ return resolution{}, fmt.Errorf("artwork: kind %q is not resolvable by the worker", item.ItemKind)+ }+}++// fetchExternalAlbum and fetchExternalArtist are the only places resolution touches the network,+// so a local-only resolver is stopped here rather than at each point in the chain walk.+func (r *resolver) fetchExternalAlbum(ctx context.Context, al model.Album) (io.ReadCloser, string, bool) {+ if r.ext == nil {+ return nil, "", false+ }+ return fetchAlbumImage(ctx, r.ext.agents, r.ext.gate, al)+}++func (r *resolver) fetchExternalArtist(ctx context.Context, ar model.Artist) (io.ReadCloser, string, bool) {+ if r.ext == nil {+ return nil, "", false+ }+ return fetchArtistImage(ctx, r.ext.agents, r.ext.gate, ar)+}++// resolveAlbum walks conf.Server.CoverArtPriority over the folder, embedded and external sources.+func (r *resolver) resolveAlbum(ctx context.Context, albumID string) (resolution, error) {+ al, err := r.ds.Album(ctx).Get(albumID)+ if err != nil {+ return resolution{}, err+ }+ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, r.ds, *al)+ if err != nil {+ return resolution{}, err+ }+ lib, err := loadLibraryView(ctx, r.ds, al.LibraryID)+ if err != nil {+ return resolution{}, err+ }++ var chain chainState+ for pattern := range strings.SplitSeq(strings.ToLower(conf.Server.CoverArtPriority), ",") {+ pattern = strings.TrimSpace(pattern)+ switch {+ case pattern == "embedded":+ if res, ok := chain.try(resolveEmbedded(ctx, lib, r.ffmpeg, al.EmbedArtPath)); ok {+ return res, nil+ }+ case pattern == "external":+ if rd, name, isErr := r.fetchExternalAlbum(ctx, *al); rd != nil {+ return resolution{reader: rd, source: "external:" + name}, nil+ } else if isErr {+ chain.extErr = true+ }+ case len(imgFiles) > 0:+ if res, ok := chain.try(resolveFolderFile(ctx, lib, imgFiles, pattern)); ok {+ return res, nil+ }+ }+ }+ return chain.exhausted(), nil+}++// resolveArtist tries the uploaded image first, then walks conf.Server.ArtistArtPriority.+func (r *resolver) resolveArtist(ctx context.Context, artistID string) (resolution, error) {+ ar, err := r.ds.Artist(ctx).Get(artistID)+ if err != nil {+ return resolution{}, err+ }+ upload, ok := resolveLocalFile(ar.UploadedImagePath(), "upload")+ if ok {+ return upload, nil+ }+ if upload.localError {+ // The upload outranks every other source; falling through would persist a lower-priority+ // image as if the upload were gone.+ return upload, nil+ }++ // Only consider albums where the artist is the sole album artist.+ als, err := r.ds.Album(ctx).GetAll(model.QueryOptions{+ Filters: squirrel.And{+ squirrel.Eq{"album_artist_id": artistID},+ squirrel.Eq{"json_array_length(participants, '$.albumartist')": 1},+ },+ })+ if err != nil {+ return resolution{}, err+ }+ albumPaths, imgFiles, _, err := loadArtistAlbumRoots(ctx, r.ds, als)+ if err != nil {+ return resolution{}, err+ }+ artistFolder, _, err := loadArtistFolder(ctx, r.ds, als, albumPaths)+ if err != nil {+ return resolution{}, err+ }+ var lib libraryView+ if len(als) > 0 {+ lib, err = loadLibraryView(ctx, r.ds, als[0].LibraryID)+ if err != nil {+ return resolution{}, err+ }+ }++ var chain chainState+ for pattern := range strings.SplitSeq(strings.ToLower(conf.Server.ArtistArtPriority), ",") {+ pattern = strings.TrimSpace(pattern)+ switch {+ case pattern == "external":+ if rd, name, isErr := r.fetchExternalArtist(ctx, *ar); rd != nil {+ return resolution{reader: rd, source: "external:" + name}, nil+ } else if isErr {+ chain.extErr = true+ }+ case pattern == "image-folder":+ if res, ok := chain.try(resolveArtistImageFolder(ar)); ok {+ return res, nil+ }+ case strings.HasPrefix(pattern, "album/"):+ if lib.FS == nil {+ continue+ }+ if res, ok := chain.try(resolveFolderFile(ctx, lib, imgFiles, strings.TrimPrefix(pattern, "album/"))); ok {+ return res, nil+ }+ default:+ if lib.FS == nil || artistFolder == "" {+ continue+ }+ if res, ok := chain.try(resolveArtistFolderPattern(ctx, lib, artistFolder, pattern)); ok {+ return res, nil+ }+ }+ }+ return chain.exhausted(), nil+}++// resolvePlaylist tries the uploaded image, the sidecar and ExternalImageURL, then a generated grid.+func (r *resolver) resolvePlaylist(ctx context.Context, playlistID string) (resolution, error) {+ pl, err := r.ds.Playlist(ctx).Get(playlistID)+ if err != nil {+ return resolution{}, err+ }++ var extErr bool+ for _, src := range []struct{ path, source string }{+ {pl.UploadedImagePath(), "upload"},+ {findPlaylistSidecarPath(ctx, pl.Path), "folder"},+ } {+ res, ok := resolveLocalFile(src.path, src.source)+ if ok {+ return res, nil+ }+ if res.localError {+ // These outrank the generated grid; falling through would replace them with it.+ return res, nil+ }+ }+ // A local ExternalImageURL is file-backed and served in place; only http(s) needs the gated fetch.+ localImg, remoteImg := classifyPlaylistImage(pl.ExternalImageURL)+ if localImg != "" {+ res, ok := resolveLocalFile(localImg, "folder")+ if ok {+ return res, nil+ }+ if res.localError {+ return res, nil+ }+ }+ if r.ext == nil {+ // The remote fetch and the generated grid are worker-only; a request must do neither.+ return resolution{}, nil+ }+ if remoteImg != nil && conf.Server.EnableM3UExternalAlbumArt {+ sf := func() (io.ReadCloser, string, error) { return fromURL(ctx, remoteImg) }+ if res, ok, isErr := resolveExternalStep(r.ext.gate, "m3u", sf); ok {+ return res, nil+ } else if isErr {+ extErr = true+ }+ }++ albumIDs, err := r.ds.Playlist(ctx).Tracks(pl.ID, false).GetAlbumIDs(model.QueryOptions{Max: 4, Sort: "random()"})+ if err != nil {+ return resolution{}, err+ }++ var tiles []image.Image+ var tileErr error // first internal (non-external) tile failure, e.g. album deleted mid-flight+ for _, albumID := range albumIDs {+ res, err := r.resolveAlbum(ctx, albumID)+ if err != nil {+ if tileErr == nil {+ tileErr = err+ }+ continue+ }+ if res.extError {+ extErr = true+ }+ if res.reader == nil {+ continue+ }+ tile, decErr := decodeTile(res.reader)+ res.reader.Close()+ if decErr == nil {+ tiles = append(tiles, tile)+ }+ if len(tiles) == 4 {+ break+ }+ }+ if len(tiles) == 0 {+ // A tile-level failure must never resolve as a clean absent.+ if tileErr != nil {+ return resolution{}, fmt.Errorf("resolvePlaylist: sampled album art failed: %w", tileErr)+ }+ return resolution{extError: extErr}, nil+ }+ // Grow to 4 tiles by repeating what we have.+ switch len(tiles) {+ case 2:+ tiles = append(tiles, tiles[1], tiles[0])+ case 3:+ tiles = append(tiles, tiles[0])+ }+ grid, err := assembleTiles(tiles)+ if err != nil {+ return resolution{extError: extErr}, nil //nolint:nilerr // encode failure is a soft "no image", not a resolution error+ }+ return resolution{reader: grid, source: "generated", extError: extErr}, nil+}++// resolveRadio serves only an uploaded image; there is no fallback.+func (r *resolver) resolveRadio(ctx context.Context, radioID string) (resolution, error) {+ radio, err := r.ds.Radio(ctx).Get(radioID)+ if err != nil {+ return resolution{}, err+ }+ res, _ := resolveLocalFile(radio.UploadedImagePath(), "upload")+ return res, nil+}++// resolveMediaFile resolves a track's own embedded art only, so disabled or missing cover art+// is a definitive absent.+func (r *resolver) resolveMediaFile(ctx context.Context, id string) (resolution, error) {+ mf, err := r.ds.MediaFile(ctx).Get(id)+ if err != nil {+ return resolution{}, err+ }+ if !conf.Server.EnableMediaFileCoverArt || !mf.HasCoverArt {+ return resolution{}, nil+ }+ lib, err := loadLibraryView(ctx, r.ds, mf.LibraryID)+ if err != nil {+ return resolution{}, err+ }+ res, _ := resolveEmbedded(ctx, lib, r.ffmpeg, mf.Path)+ return res, nil+}++// resolveExternalStep runs a single external sourceFunc through the named gate. extErr excludes+// a not-found, which is a definitive "no" rather than a failure.+func resolveExternalStep(gate gateFunc, name string, sf sourceFunc) (res resolution, ok bool, extErr bool) {+ r, path, err := gate(name, sf)+ if r != nil {+ return resolution{reader: r, source: "external", sourcePath: path}, true, false+ }+ return resolution{}, false, err != nil && !errors.Is(err, model.ErrNotFound)+}++// classifyPlaylistImage splits a playlist ExternalImageURL into a local filesystem path or a+// remote http(s) URL; at most one is set.+func classifyPlaylistImage(imageURL string) (localPath string, remote *url.URL) {+ if imageURL == "" {+ return "", nil+ }+ u, err := url.Parse(imageURL)+ if err != nil {+ return imageURL, nil // unparseable → treat as a local path+ }+ switch u.Scheme {+ case "http", "https":+ return "", u+ case "file":+ return u.Path, nil+ default:+ return imageURL, nil+ }+}++func resolveEmbedded(ctx context.Context, lib libraryView, ffm ffmpeg.FFmpeg, embedRel string) (resolution, bool) {+ if embedRel == "" {+ return resolution{}, false+ }+ abs := lib.Abs(embedRel)+ var unreadable bool+ for _, sf := range []sourceFunc{fromTag(ctx, lib.FS, embedRel), fromFFmpegTag(ctx, ffm, abs)} {+ r, _, err := sf()+ if r != nil {+ return resolution{reader: r, source: "embedded", sourcePath: abs, refMtime: mtimeViaFS(lib.FS, embedRel)}, true+ }+ unreadable = unreadable || errors.Is(err, errSourceUnreadable)+ }+ return resolution{localError: unreadable}, false+}++func resolveFolderFile(ctx context.Context, lib libraryView, imgFiles []string, pattern string) (resolution, bool) {+ r, path, err := fromExternalFile(ctx, lib.FS, imgFiles, pattern)()+ if r == nil {+ return resolution{localError: errors.Is(err, errSourceUnreadable)}, false+ }+ return resolution{reader: r, source: "folder", sourcePath: lib.Abs(path), refMtime: mtimeViaFS(lib.FS, path)}, true+}++func resolveArtistImageFolder(ar *model.Artist) (resolution, bool) {+ folder := conf.Server.ArtistImageFolder+ if folder == "" {+ return resolution{}, false+ }+ return resolveLocalFile(findImageInArtistFolder(folder, ar.MbzArtistID, ar.Name), "folder")+}++func resolveArtistFolderPattern(ctx context.Context, lib libraryView, artistFolder, pattern string) (resolution, bool) {+ r, path, err := fromArtistFolder(ctx, lib.FS, lib.absRoot, artistFolder, pattern)()+ if r == nil {+ return resolution{localError: errors.Is(err, errSourceUnreadable)}, false+ }+ return resolution{reader: r, source: "folder", sourcePath: path, refMtime: mtimeOf(path)}, true+}++// resolveLocalFile opens an absolute path directly. A missing path is "no source"; any other+// open failure says nothing about whether the image exists.+func resolveLocalFile(path, source string) (resolution, bool) {+ if path == "" {+ return resolution{}, false+ }+ f, err := os.Open(path)+ if err != nil {+ return resolution{localError: !errors.Is(err, fs.ErrNotExist)}, false+ }+ return resolution{reader: f, source: source, sourcePath: path, refMtime: mtimeOf(path)}, true+}++func mtimeOf(path string) int64 {+ info, err := os.Stat(path)+ if err != nil {+ return 0+ }+ return info.ModTime().UnixNano()+}++// mtimeViaFS stats through the library FS, since library roots in tests may not be real OS paths.+func mtimeViaFS(fsys fs.FS, name string) int64 {+ if fsys == nil || name == "" {+ return 0+ }+ info, err := fs.Stat(fsys, name)+ if err != nil {+ return 0+ }+ return info.ModTime().UnixNano()+}diff --git a/core/artwork/resolve_test.go b/core/artwork/resolve_test.gonew file mode 100644index 000000000..fc1a6a3ff--- /dev/null+++ b/core/artwork/resolve_test.go@@ -0,0 +1,632 @@+package artwork++import (+ "bytes"+ "context"+ "errors"+ "image"+ "io"+ "net/http"+ "net/http/httptest"+ "os"+ "path/filepath"+ "sync/atomic"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++var _ = Describe("resolveItem", func() {+ var (+ ctx context.Context+ ds *tests.MockDataStore+ folderRepo *fakeFolderRepo+ libRepo *tests.MockLibraryRepo+ ffm *tests.MockFFmpeg+ ag *agents.Agents+ repoRoot string+ )++ BeforeEach(func() {+ DeferCleanup(configtest.SetupConfig())+ ctx = context.Background()+ var err error+ repoRoot, err = os.Getwd()+ Expect(err).ToNot(HaveOccurred())++ folderRepo = &fakeFolderRepo{}+ libRepo = &tests.MockLibraryRepo{}+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})+ ffm = tests.NewMockFFmpeg("")+ ag = agents.GetAgents(&tests.MockDataStore{}, nil)+ ds = &tests.MockDataStore{+ MockedFolder: folderRepo,+ MockedLibrary: libRepo,+ }+ })++ Describe("kind dispatch", func() {+ It("returns an error for kinds the worker never enqueues", func() {+ _, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "zz", ItemID: "x"})+ Expect(err).To(HaveOccurred())+ })+ })++ Describe("media file", func() {+ BeforeEach(func() {+ conf.Server.EnableMediaFileCoverArt = true+ ds.MockedMediaFile = tests.CreateMockMediaFileRepo()+ })++ It("resolves embedded art from the track file", func() {+ ds.MockedMediaFile.(*tests.MockMediaFileRepo).SetData(model.MediaFiles{+ {ID: "mf1", LibraryID: 0, Path: "tests/fixtures/artist/an-album/test.mp3", HasCoverArt: true},+ })++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "mf", ItemID: "mf1"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("embedded"))+ Expect(filepath.ToSlash(res.sourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/test.mp3"))+ Expect(res.refMtime).To(BeNumerically(">", 0))+ Expect(res.extError).To(BeFalse())+ })++ It("resolves absent when the track has no cover art", func() {+ ds.MockedMediaFile.(*tests.MockMediaFileRepo).SetData(model.MediaFiles{+ {ID: "mf2", LibraryID: 0, Path: "tests/fixtures/artist/an-album/test.mp3", HasCoverArt: false},+ })++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "mf", ItemID: "mf2"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ Expect(res.extError).To(BeFalse())+ })++ It("resolves absent when media file cover art is disabled", func() {+ conf.Server.EnableMediaFileCoverArt = false+ ds.MockedMediaFile.(*tests.MockMediaFileRepo).SetData(model.MediaFiles{+ {ID: "mf3", LibraryID: 0, Path: "tests/fixtures/artist/an-album/test.mp3", HasCoverArt: true},+ })++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "mf", ItemID: "mf3"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ })++ It("returns the error when the track is not in the DB", func() {+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "mf", ItemID: "missing"})+ Expect(err).To(MatchError(model.ErrNotFound))+ Expect(res.reader).To(BeNil())+ })+ })++ Describe("album", func() {+ BeforeEach(func() {+ conf.Server.CoverArtPriority = "cover.jpg, embedded"+ ds.MockedAlbum = tests.CreateMockAlbumRepo()+ })++ It("resolves folder art from the library FS", func() {+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al1", Name: "Album", FolderIDs: []string{"f1"}},+ })++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al1"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("folder"))+ Expect(filepath.ToSlash(res.sourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/cover.jpg"))+ Expect(res.refMtime).To(BeNumerically(">", 0))+ Expect(res.extError).To(BeFalse())+ })++ It("falls back to embedded art when no folder image matches", func() {+ folderRepo.result = nil+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al2", Name: "Album", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}},+ })++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al2"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("embedded"))+ Expect(filepath.ToSlash(res.sourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/test.mp3"))+ Expect(res.refMtime).To(BeNumerically(">", 0))+ })++ It("sets extError when the external source errors without being not-found", func() {+ conf.Server.CoverArtPriority = "external"+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al3", Name: "Album"},+ })+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al3"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ Expect(res.extError).To(BeTrue())+ })++ It("does not set extError when the external source reports not-found", func() {+ conf.Server.CoverArtPriority = "external"+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al4", Name: "Album"},+ })+ // no image agents enabled -> the external step is a definitive not-found++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al4"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ Expect(res.extError).To(BeFalse())+ })++ It("carries extError onto a fallback folder hit after a transient external failure", func() {+ conf.Server.CoverArtPriority = "external, cover.jpg"+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al6", Name: "Album", FolderIDs: []string{"f1"}},+ })+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al6"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("folder"))+ Expect(res.extError).To(BeTrue())+ })++ It("does not carry extError onto a fallback folder hit after a definitive external not-found", func() {+ conf.Server.CoverArtPriority = "external, cover.jpg"+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al7", Name: "Album", FolderIDs: []string{"f1"}},+ })+ // no image agents enabled -> the external step is a definitive not-found++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al7"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("folder"))+ Expect(res.extError).To(BeFalse())+ })++ It("routes the external step through the injected gate, keyed by agent name", func() {+ conf.Server.CoverArtPriority = "external"+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al5", Name: "Album"},+ })+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("boom")})+ var gatedNames []string+ gate := func(name string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {+ gatedNames = append(gatedNames, name)+ return f()+ }++ res, err := newResolver(ds, ag, ffm, gate).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al5"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.extError).To(BeTrue())+ Expect(gatedNames).To(Equal([]string{"failAgent"}))+ })+ })++ Describe("artist", func() {+ It("resolves the uploaded image before any priority chain lookup", func() {+ tmpDir := GinkgoT().TempDir()+ conf.Server.DataFolder = conf.NewDir(tmpDir)+ Expect(os.MkdirAll(filepath.Join(tmpDir, "artwork", "artist"), 0755)).To(Succeed())+ imgPath := filepath.Join(tmpDir, "artwork", "artist", "ar1_test.jpg")+ Expect(os.WriteFile(imgPath, []byte("uploaded artist image"), 0600)).To(Succeed())++ artistRepo := tests.CreateMockArtistRepo()+ artistRepo.SetData(model.Artists{{ID: "ar1", Name: "Artist", UploadedImage: "ar1_test.jpg"}})+ ds.MockedArtist = artistRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar1"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("upload"))+ Expect(res.sourcePath).To(Equal(imgPath))+ })++ It("falls through to the ArtistArtPriority chain when there is no upload", func() {+ conf.Server.ArtistArtPriority = "album/artist.*"+ folderRepo.result = []model.Folder{{+ LibraryPath: testFileLibPath(repoRoot),+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"artist.png"},+ }}+ artistRepo := tests.CreateMockArtistRepo()+ artistRepo.SetData(model.Artists{{ID: "ar2", Name: "Artist"}})+ ds.MockedArtist = artistRepo+ ds.MockedAlbum = tests.CreateMockAlbumRepo()+ ds.MockedAlbum.(*tests.MockAlbumRepo).All = model.Albums{+ {ID: "al9", Name: "Album", LibraryID: 0, FolderIDs: []string{"f1"}},+ }++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar2"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("folder"))+ Expect(filepath.ToSlash(res.sourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/artist.png"))+ })++ It("sets extError when the external source errors without being not-found", func() {+ conf.Server.ArtistArtPriority = "external"+ artistRepo := tests.CreateMockArtistRepo()+ artistRepo.SetData(model.Artists{{ID: "ar3", Name: "Artist"}})+ ds.MockedArtist = artistRepo+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar3"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ Expect(res.extError).To(BeTrue())+ })++ It("does not set extError when the external source reports not-found", func() {+ conf.Server.ArtistArtPriority = "external"+ artistRepo := tests.CreateMockArtistRepo()+ artistRepo.SetData(model.Artists{{ID: "ar4", Name: "Artist"}})+ ds.MockedArtist = artistRepo+ // no image agents enabled -> the external step is a definitive not-found++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar4"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ Expect(res.extError).To(BeFalse())+ })++ It("routes the external step through the injected gate, keyed by agent name", func() {+ conf.Server.ArtistArtPriority = "external"+ artistRepo := tests.CreateMockArtistRepo()+ artistRepo.SetData(model.Artists{{ID: "ar5", Name: "Artist"}})+ ds.MockedArtist = artistRepo+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("boom")})+ var gatedNames []string+ gate := func(name string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {+ gatedNames = append(gatedNames, name)+ return f()+ }++ res, err := newResolver(ds, ag, ffm, gate).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar5"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.extError).To(BeTrue())+ Expect(gatedNames).To(Equal([]string{"failAgent"}))+ })+ })++ Describe("radio", func() {+ It("yields an empty resolution when there is no uploaded image", func() {+ tmpDir := GinkgoT().TempDir()+ conf.Server.DataFolder = conf.NewDir(tmpDir)++ radioRepo := tests.CreateMockedRadioRepo()+ radioRepo.Data = map[string]*model.Radio{"ra1": {ID: "ra1", Name: "Radio"}}+ ds.MockedRadio = radioRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ra", ItemID: "ra1"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res).To(Equal(resolution{}))+ })++ It("resolves the uploaded image when set", func() {+ tmpDir := GinkgoT().TempDir()+ conf.Server.DataFolder = conf.NewDir(tmpDir)+ Expect(os.MkdirAll(filepath.Join(tmpDir, "artwork", "radio"), 0755)).To(Succeed())+ imgPath := filepath.Join(tmpDir, "artwork", "radio", "ra2_test.jpg")+ Expect(os.WriteFile(imgPath, []byte("uploaded radio image"), 0600)).To(Succeed())++ radioRepo := tests.CreateMockedRadioRepo()+ radioRepo.Data = map[string]*model.Radio{"ra2": {ID: "ra2", Name: "Radio", UploadedImage: "ra2_test.jpg"}}+ ds.MockedRadio = radioRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ra", ItemID: "ra2"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("upload"))+ Expect(res.sourcePath).To(Equal(imgPath))+ })+ })++ Describe("playlist", func() {+ BeforeEach(func() {+ conf.Server.CoverArtPriority = "cover.jpg"+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum = tests.CreateMockAlbumRepo()+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "t1", Name: "T1", FolderIDs: []string{"f1"}},+ {ID: "t2", Name: "T2", FolderIDs: []string{"f1"}},+ {ID: "t3", Name: "T3", FolderIDs: []string{"f1"}},+ {ID: "t4", Name: "T4", FolderIDs: []string{"f1"}},+ })+ })++ DescribeTable("yields a generated grid from up to 4 album tiles",+ func(albumIDs []string, expectedSize int) {+ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "pl1", Name: "Playlist"}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: albumIDs}+ ds.MockedPlaylist = plRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pl1"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("generated"))++ img, format, err := image.Decode(res.reader)+ Expect(err).ToNot(HaveOccurred())+ Expect(format).To(Equal("png"))+ Expect(img.Bounds().Dx()).To(Equal(expectedSize))+ Expect(img.Bounds().Dy()).To(Equal(expectedSize))+ },+ // tileSize-1: the 4-tile canvas is built as [0, tileSize-1].+ Entry("1 album -> single tile", []string{"t1"}, tileSize/2),+ Entry("2 albums -> duplicated to 4 tiles", []string{"t1", "t2"}, tileSize-1),+ Entry("3 albums -> duplicated to 4 tiles", []string{"t1", "t2", "t3"}, tileSize-1),+ Entry("4 albums -> full grid", []string{"t1", "t2", "t3", "t4"}, tileSize-1),+ )++ It("resolves the uploaded image before the generated grid", func() {+ tmpDir := GinkgoT().TempDir()+ conf.Server.DataFolder = conf.NewDir(tmpDir)+ Expect(os.MkdirAll(filepath.Join(tmpDir, "artwork", "playlist"), 0755)).To(Succeed())+ imgPath := filepath.Join(tmpDir, "artwork", "playlist", "plu_test.jpg")+ Expect(os.WriteFile(imgPath, []byte("uploaded playlist image"), 0600)).To(Succeed())++ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "plu", Name: "Playlist", UploadedImage: "plu_test.jpg"}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1", "t2"}}+ ds.MockedPlaylist = plRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "plu"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("upload"))+ Expect(res.sourcePath).To(Equal(imgPath))+ })++ It("resolves a sidecar image next to the playlist file before the grid", func() {+ plDir := GinkgoT().TempDir()+ Expect(os.WriteFile(filepath.Join(plDir, "list.m3u"), []byte("#EXTM3U"), 0600)).To(Succeed())+ Expect(os.WriteFile(filepath.Join(plDir, "list.jpg"), []byte("sidecar image"), 0600)).To(Succeed())++ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "pls", Name: "Playlist", Path: filepath.Join(plDir, "list.m3u")}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1", "t2"}}+ ds.MockedPlaylist = plRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pls"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("folder"))+ Expect(filepath.ToSlash(res.sourcePath)).To(HaveSuffix("list.jpg"))+ })++ It("serves a local ExternalImageURL as a file-backed reference (staleness-checked)", func() {+ dir := GinkgoT().TempDir()+ imgPath := filepath.Join(dir, "cover.png")+ Expect(os.WriteFile(imgPath, []byte("local external image"), 0600)).To(Succeed())++ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "pll", Name: "Playlist", ExternalImageURL: imgPath}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}+ ds.MockedPlaylist = plRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pll"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("folder"))+ Expect(res.sourcePath).To(Equal(imgPath))+ Expect(res.refMtime).To(BeNumerically(">", 0))+ })++ It("routes ExternalImageURL through extGate and sets extError on transient failure", func() {+ conf.Server.EnableM3UExternalAlbumArt = true+ folderRepo.result = nil // no grid tiles, so the external failure is what surfaces++ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "ple", Name: "Playlist", ExternalImageURL: "http://example.com/cover.jpg"}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}+ ds.MockedPlaylist = plRepo++ var gatedNames []string+ gate := func(name string, _ func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {+ gatedNames = append(gatedNames, name)+ return nil, "", errors.New("network down")+ }++ res, err := newResolver(ds, ag, ffm, gate).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "ple"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ Expect(res.extError).To(BeTrue())+ Expect(gatedNames).To(Equal([]string{"m3u"}), "the playlist URL fetch is gated under \"m3u\"")+ })++ It("treats a missing local ExternalImageURL as a definitive miss, not extError", func() {+ folderRepo.result = nil // no grid tiles, so the local-file miss is what surfaces++ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "plm", Name: "Playlist", ExternalImageURL: "/nonexistent/path/cover.jpg"}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}+ ds.MockedPlaylist = plRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "plm"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ Expect(res.extError).To(BeFalse())+ })++ It("treats an ExternalImageURL 404 as a definitive miss and falls through to the grid", func() {+ conf.Server.EnableM3UExternalAlbumArt = true+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ w.WriteHeader(http.StatusNotFound)+ }))+ defer srv.Close()++ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "pl404", Name: "Playlist", ExternalImageURL: srv.URL}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}+ ds.MockedPlaylist = plRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pl404"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).ToNot(BeNil())+ defer res.reader.Close()+ Expect(res.source).To(Equal("generated"))+ Expect(res.extError).To(BeFalse())+ })++ // A local resolver holds no agents: reaching the external branch would panic, not degrade.+ It("skips the external step instead of dereferencing absent agents", func() {+ conf.Server.CoverArtPriority = "external"+ ds.MockedAlbum = tests.CreateMockAlbumRepo()+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "alx", Name: "Album"}})++ res, err := newLocalResolver(ds, ffm).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alx"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ Expect(res.extError).To(BeFalse(), "a skipped step is not a failed one")+ })++ // The worker resolving the same playlist is asserted alongside, so this cannot pass vacuously.+ It("resolves a playlist locally without fetching remotely or building the grid", func() {+ conf.Server.EnableM3UExternalAlbumArt = true+ var hits atomic.Int32+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ hits.Add(1)+ w.WriteHeader(http.StatusNotFound)+ }))+ defer srv.Close()++ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "pllocal", Name: "Playlist", ExternalImageURL: srv.URL}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}+ ds.MockedPlaylist = plRepo+ item := model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pllocal"}++ res, err := newLocalResolver(ds, ffm).resolve(ctx, item)+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil(), "no local source, and the grid is worker-only")+ Expect(hits.Load()).To(BeZero(), "a request must never reach the network")++ worker, err := newResolver(ds, ag, ffm, nil).resolve(ctx, item)+ Expect(err).ToNot(HaveOccurred())+ Expect(worker.reader).ToNot(BeNil())+ defer worker.reader.Close()+ Expect(worker.source).To(Equal("generated"), "the worker does build the grid")+ Expect(hits.Load()).To(Equal(int32(1)), "and the worker does fetch")+ })++ It("treats an ExternalImageURL 500 as a transient failure and sets extError", func() {+ conf.Server.EnableM3UExternalAlbumArt = true+ folderRepo.result = nil // no grid tiles, so the external failure is what surfaces+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ w.WriteHeader(http.StatusInternalServerError)+ }))+ defer srv.Close()++ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "pl500", Name: "Playlist", ExternalImageURL: srv.URL}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}+ ds.MockedPlaylist = plRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pl500"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ Expect(res.extError).To(BeTrue())+ })++ It("yields an empty resolution when no album has art", func() {+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "empty1", Name: "Empty"},+ })+ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "pl2", Name: "Playlist"}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"empty1"}}+ ds.MockedPlaylist = plRepo+ folderRepo.result = nil++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pl2"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ Expect(res.source).To(BeEmpty())+ })++ It("skips a grid tile whose declared dimensions are a decompression bomb", func() {+ libRoot := GinkgoT().TempDir()+ Expect(os.MkdirAll(filepath.Join(libRoot, "bomb"), 0755)).To(Succeed())+ Expect(os.WriteFile(filepath.Join(libRoot, "bomb", "cover.jpg"), pngHeaderWithDims(50000, 50000), 0600)).To(Succeed())+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(libRoot)}})+ folderRepo.result = []model.Folder{{Path: "bomb", ImageFiles: []string{"cover.jpg"}}}++ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "plbomb", Name: "Playlist"}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}+ ds.MockedPlaylist = plRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "plbomb"})+ Expect(err).ToNot(HaveOccurred())+ Expect(res.reader).To(BeNil())+ Expect(res.source).To(BeEmpty())+ })++ It("does not resolve as absent when every sampled album fails to resolve", func() {+ // The album ids are absent from MockAlbumRepo, so every tile fails non-externally.+ plRepo := tests.CreateMockPlaylistRepo()+ plRepo.SetData(model.Playlists{{ID: "pl3", Name: "Playlist"}})+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"missing1", "missing2"}}+ ds.MockedPlaylist = plRepo++ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pl3"})+ Expect(err).To(HaveOccurred())+ Expect(res).To(Equal(resolution{}))+ })+ })+})++// decodeTile runs before the processor's own guards, so it must enforce the caps itself.+var _ = Describe("decodeTile", func() {+ It("rejects a decompression bomb before the full decode", func() {+ data := pngHeaderWithDims(50000, 50000) // 2.5 gigapixels, far above the cap+ _, err := decodeTile(io.NopCloser(bytes.NewReader(data)))+ Expect(err).To(HaveOccurred())+ Expect(err.Error()).To(ContainSubstring("dimensions"))+ })++ It("rejects a tile larger than the size cap", func() {+ data := bytes.Repeat([]byte{0}, maxImageBytes+1)+ _, err := decodeTile(io.NopCloser(bytes.NewReader(data)))+ Expect(err).To(HaveOccurred())+ })+})diff --git a/core/artwork/sources.go b/core/artwork/sources.goindex 04a9257fb..885ca03cf 100644--- a/core/artwork/sources.go+++ b/core/artwork/sources.go@@ -3,6 +3,7 @@ package artworkimport ("bytes""context"+ "errors""fmt""io""io/fs"@@ -16,14 +17,16 @@ import ("time""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core/external""github.com/navidrome/navidrome/core/ffmpeg""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/resources""go.senan.xyz/taglib")+// errSourceUnreadable marks a candidate the resolver knows exists but could not read. Failing+// to open it is not evidence the entity has no artwork, so callers must not settle on absent.+var errSourceUnreadable = errors.New("artwork source unreadable")+func selectImageReader(ctx context.Context, artID model.ArtworkID, extractFuncs ...sourceFunc) (io.ReadCloser, string, error) {for _, f := range extractFuncs {if ctx.Err() != nil {@@ -32,11 +35,11 @@ func selectImageReader(ctx context.Context, artID model.ArtworkID, extractFuncsstart := time.Now()r, path, err := f()if r != nil {- msg := fmt.Sprintf("Found %s artwork", artID.Kind)+ msg := fmt.Sprintf("Artwork: Found %s artwork", artID.Kind)log.Debug(ctx, msg, "artID", artID, "path", path, "source", f, "elapsed", time.Since(start))return r, path, nil}- log.Trace(ctx, "Failed trying to extract artwork", "artID", artID, "source", f, "elapsed", time.Since(start), err)+ log.Trace(ctx, "Artwork: Failed trying to extract artwork", "artID", artID, "source", f, "elapsed", time.Since(start), err)}return nil, "", fmt.Errorf("could not get `%s` cover art for %s: %w", artID.Kind, artID, ErrUnavailable)}@@ -55,11 +58,12 @@ func (f sourceFunc) String() string {func fromExternalFile(ctx context.Context, libFS fs.FS, files []string, pattern string) sourceFunc {return func() (io.ReadCloser, string, error) {+ var openErr errorfor _, file := range files {_, name := filepath.Split(file)match, err := filepath.Match(pattern, strings.ToLower(name))if err != nil {- log.Warn(ctx, "Error matching cover art file to pattern", "pattern", pattern, "file", file)+ log.Warn(ctx, "Artwork: Error matching cover art file to pattern", "pattern", pattern, "file", file)continue}if !match {@@ -67,11 +71,15 @@ func fromExternalFile(ctx context.Context, libFS fs.FS, files []string, pattern}f, err := libFS.Open(file)if err != nil {- log.Warn(ctx, "Could not open cover art file", "file", file, err)+ log.Warn(ctx, "Artwork: Could not open cover art file", "file", file, err)+ openErr = fmt.Errorf("%w: %s: %w", errSourceUnreadable, file, err)continue}return f, file, nil}+ if openErr != nil {+ return nil, "", openErr+ }return nil, "", fmt.Errorf("pattern '%s' not matched by files %v", pattern, files)}}@@ -90,7 +98,7 @@ func fromTag(ctx context.Context, libFS fs.FS, relPath string) sourceFunc {}f, err := libFS.Open(relPath)if err != nil {- return nil, "", err+ return nil, "", fmt.Errorf("%w: %s: %w", errSourceUnreadable, relPath, err)}rs, ok := f.(io.ReadSeeker)if !ok {@@ -103,7 +111,7 @@ func fromTag(ctx context.Context, libFS fs.FS, relPath string) sourceFunc {)if err != nil {f.Close()- return nil, "", err+ return nil, "", fmt.Errorf("%w: %s: %w", errSourceUnreadable, relPath, err)}// Close in LIFO order: tf first (it holds rs internally), then f.defer f.Close()@@ -127,12 +135,12 @@ func findBestImageIndex(ctx context.Context, images []taglib.ImageDesc, path strfor _, regex := range picTypeRegexes {for i, img := range images {if regex.MatchString(img.Type) {- log.Trace(ctx, "Found embedded image", "type", img.Type, "path", path)+ log.Trace(ctx, "Artwork: Found embedded image", "type", img.Type, "path", path)return i}}}- log.Trace(ctx, "Could not find a front image. Getting the first one", "type", images[0].Type, "path", path)+ log.Trace(ctx, "Artwork: Could not find a front image. Getting the first one", "type", images[0].Type, "path", path)return 0}@@ -171,44 +179,6 @@ type readCloser struct {io.Closer}-func fromAlbum(ctx context.Context, a *artwork, id model.ArtworkID) sourceFunc {- return func() (io.ReadCloser, string, error) {- r, _, err := a.Get(ctx, id, 0, false)- if err != nil {- return nil, "", err- }- return r, id.String(), nil- }-}--func fromAlbumPlaceholder() sourceFunc {- return func() (io.ReadCloser, string, error) {- r, _ := resources.FS().Open(consts.PlaceholderAlbumArt)- return r, consts.PlaceholderAlbumArt, nil- }-}-func fromArtistExternalSource(ctx context.Context, ar model.Artist, provider external.Provider) sourceFunc {- return func() (io.ReadCloser, string, error) {- imageUrl, err := provider.ArtistImage(ctx, ar.ID)- if err != nil {- return nil, "", err- }-- return fromURL(ctx, imageUrl)- }-}--func fromAlbumExternalSource(ctx context.Context, al model.Album, provider external.Provider) sourceFunc {- return func() (io.ReadCloser, string, error) {- imageUrl, err := provider.AlbumImage(ctx, al.ID)- if err != nil {- return nil, "", err- }-- return fromURL(ctx, imageUrl)- }-}-func fromURL(ctx context.Context, imageUrl *url.URL) (io.ReadCloser, string, error) {hc := http.Client{Timeout: 5 * time.Second}req, _ := http.NewRequestWithContext(ctx, http.MethodGet, imageUrl.String(), nil)@@ -217,6 +187,12 @@ func fromURL(ctx context.Context, imageUrl *url.URL) (io.ReadCloser, string, errif err != nil {return nil, "", err}+ // An agent-advertised URL that 404s is a definitive miss, not a fault: settle absent+ // instead of retrying forever and tripping the artwork breaker.+ if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusGone {+ resp.Body.Close()+ return nil, "", model.ErrNotFound+ }if resp.StatusCode != http.StatusOK {resp.Body.Close()return nil, "", fmt.Errorf("error retrieving artwork from %s: %s", imageUrl, resp.Status)diff --git a/core/artwork/thumbhash/testdata/alpha.png b/core/artwork/thumbhash/testdata/alpha.pngnew file mode 100644index 000000000..6ac85943aBinary files /dev/null and b/core/artwork/thumbhash/testdata/alpha.png differdiff --git a/core/artwork/thumbhash/testdata/gen_fixtures.mjs b/core/artwork/thumbhash/testdata/gen_fixtures.mjsnew file mode 100644index 000000000..b2e488b51--- /dev/null+++ b/core/artwork/thumbhash/testdata/gen_fixtures.mjs@@ -0,0 +1,90 @@+// Generates lossless PNG fixtures <=100px. Run: node gen_fixtures.mjs+import { writeFileSync } from 'fs'+import { deflateSync } from 'zlib'++const crcTable = Array.from({ length: 256 }, (_, n) => {+ let c = n+ for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1+ return c >>> 0+})+const crc32 = (buf) => {+ let c = 0xffffffff+ for (const b of buf) c = crcTable[(c ^ b) & 0xff] ^ (c >>> 8)+ return (c ^ 0xffffffff) >>> 0+}+const chunk = (type, data) => {+ const len = Buffer.alloc(4)+ len.writeUInt32BE(data.length)+ const body = Buffer.concat([Buffer.from(type, 'ascii'), data])+ const crc = Buffer.alloc(4)+ crc.writeUInt32BE(crc32(body))+ return Buffer.concat([len, body, crc])+}+const png = (w, h, rgba) => {+ const ihdr = Buffer.alloc(13)+ ihdr.writeUInt32BE(w, 0)+ ihdr.writeUInt32BE(h, 4)+ ihdr[8] = 8 // bit depth+ ihdr[9] = 6 // truecolor + alpha+ const raw = Buffer.alloc(h * (w * 4 + 1))+ for (let y = 0; y < h; y++) {+ raw[y * (w * 4 + 1)] = 0 // filter: none+ for (let x = 0; x < w * 4; x++) raw[y * (w * 4 + 1) + 1 + x] = rgba[y * w * 4 + x]+ }+ return Buffer.concat([+ Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),+ chunk('IHDR', ihdr),+ chunk('IDAT', deflateSync(raw)),+ chunk('IEND', Buffer.alloc(0)),+ ])+}++// A ramp has exactly-zero DCT coefficients, and a zero coefficient's nibble is decided by float+// rounding noise, so no two summation orders agree on it. Dither gives every coefficient signal.+let seed = 0+const dither = () => {+ seed ^= seed << 13+ seed ^= seed >>> 17+ seed ^= seed << 5+ seed >>>= 0+ return (seed % 9) - 4+}+const shade = (v) => Math.max(0, Math.min(255, v + dither()))++const make = (w, h, fn) => {+ seed = 0x9e3779b9+ const rgba = new Uint8Array(w * h * 4)+ for (let y = 0; y < h; y++)+ for (let x = 0; x < w; x++) fn(rgba, (y * w + x) * 4, x, y, w, h)+ return png(w, h, rgba)+}++const gradient = (rgba, i, x, y, w, h) => {+ rgba[i] = shade(Math.floor((255 * x) / w))+ rgba[i + 1] = shade(Math.floor((255 * y) / h))+ rgba[i + 2] = shade(Math.floor((255 * (x + y)) / (w + h)))+ rgba[i + 3] = 255+}+const solid = (rgba, i) => {+ rgba[i] = 60+ rgba[i + 1] = 120+ rgba[i + 2] = 180+ rgba[i + 3] = 255+}+// RGB must vary with position too: a constant color composited over its own average cancels to a+// flat L/P/Q (the bug this fixture exists to catch), so pair a color gradient with the alpha ramp.+const alphaRamp = (rgba, i, x, y, w, h) => {+ rgba[i] = shade(Math.floor((255 * x) / w))+ rgba[i + 1] = shade(Math.floor((255 * y) / h))+ rgba[i + 2] = shade(Math.floor((255 * (x + y)) / (w + h)))+ rgba[i + 3] = shade(Math.floor((255 * (x + 2 * y)) / (w + 2 * h)))+}++const out = new URL('.', import.meta.url).pathname+writeFileSync(out + 'square.png', make(100, 100, gradient))+writeFileSync(out + 'landscape.png', make(100, 60, gradient))+writeFileSync(out + 'portrait.png', make(60, 100, gradient))+writeFileSync(out + 'alpha.png', make(80, 80, alphaRamp))+writeFileSync(out + 'solid.png', make(64, 64, solid))+writeFileSync(out + 'tiny.png', make(1, 1, solid))+console.log('fixtures written')diff --git a/core/artwork/thumbhash/testdata/gen_generated.mjs b/core/artwork/thumbhash/testdata/gen_generated.mjsnew file mode 100644index 000000000..e8eae585e--- /dev/null+++ b/core/artwork/thumbhash/testdata/gen_generated.mjs@@ -0,0 +1,28 @@+// Produces generated.json: ThumbHashes of synthetic images, from the vendored reference.+// The pixels are a pure function of their index, so Go rebuilds them byte-for-byte from the same+// formula and only the hashes need committing. Run: node gen_generated.mjs+import { writeFileSync } from 'fs'+import { rgbaToThumbHash } from './thumbhash.js'++const COUNT = 300++// mix is a stateless 32-bit finaliser; Go's mix in thumbhash_test.go must match it exactly.+const mix = (n) => {+ n = Math.imul(n ^ (n >>> 16), 2246822507) >>> 0+ n = Math.imul(n ^ (n >>> 13), 3266489909) >>> 0+ return (n ^ (n >>> 16)) >>> 0+}++const out = []+for (let i = 0; i < COUNT; i++) {+ const w = 1 + (mix(i * 3 + 1) % 100)+ const h = 1 + (mix(i * 3 + 2) % 100)+ const rgba = new Uint8Array(w * h * 4)+ for (let k = 0; k < rgba.length; k++) rgba[k] = mix(i * 1000003 + k) & 255+ // Random alpha is opaque essentially never, so half are forced opaque to exercise the 7x7+ // no-alpha layout as often as the 5x5-plus-alpha one.+ if (i % 2 === 0) for (let k = 3; k < rgba.length; k += 4) rgba[k] = 255+ out.push({ w, h, hash: Buffer.from(rgbaToThumbHash(w, h, rgba)).toString('base64') })+}+writeFileSync(new URL('.', import.meta.url).pathname + 'generated.json', JSON.stringify(out) + '\n')+console.log(`${out.length} vectors; first ${out[0].w}x${out[0].h} ${out[0].hash}`)diff --git a/core/artwork/thumbhash/testdata/gen_golden.mjs b/core/artwork/thumbhash/testdata/gen_golden.mjsnew file mode 100644index 000000000..2825e0709--- /dev/null+++ b/core/artwork/thumbhash/testdata/gen_golden.mjs@@ -0,0 +1,37 @@+// Produces golden.json from the vendored reference. Run: node gen_golden.mjs+import { readFileSync, writeFileSync, readdirSync } from 'fs'+import { inflateSync } from 'zlib'+import { rgbaToThumbHash } from './thumbhash.js'++// Minimal reader for the exact PNGs gen_fixtures.mjs writes: 8-bit RGBA, filter 0, single IDAT.+const readPNG = (buf) => {+ let w = 0, h = 0+ const idat = []+ for (let off = 8; off < buf.length; ) {+ const len = buf.readUInt32BE(off)+ const type = buf.toString('ascii', off + 4, off + 8)+ const data = buf.subarray(off + 8, off + 8 + len)+ if (type === 'IHDR') {+ w = data.readUInt32BE(0)+ h = data.readUInt32BE(4)+ if (data[8] !== 8 || data[9] !== 6) throw new Error('expected 8-bit RGBA')+ } else if (type === 'IDAT') idat.push(data)+ off += 12 + len+ }+ const raw = inflateSync(Buffer.concat(idat))+ const rgba = new Uint8Array(w * h * 4)+ for (let y = 0; y < h; y++) {+ if (raw[y * (w * 4 + 1)] !== 0) throw new Error('expected filter 0')+ for (let x = 0; x < w * 4; x++) rgba[y * w * 4 + x] = raw[y * (w * 4 + 1) + 1 + x]+ }+ return { w, h, rgba }+}++const dir = new URL('.', import.meta.url).pathname+const golden = {}+for (const name of readdirSync(dir).filter((f) => f.endsWith('.png')).sort()) {+ const { w, h, rgba } = readPNG(readFileSync(dir + name))+ golden[name] = Buffer.from(rgbaToThumbHash(w, h, rgba)).toString('base64')+}+writeFileSync(dir + 'golden.json', JSON.stringify(golden, null, 2) + '\n')+console.log(golden)diff --git a/core/artwork/thumbhash/testdata/generated.json b/core/artwork/thumbhash/testdata/generated.jsonnew file mode 100644index 000000000..1b49bbb03--- /dev/null+++ b/core/artwork/thumbhash/testdata/generated.json@@ -0,0 +1 @@+[{"w":28,"h":79,"hash":"4AcCCgBFgGVnc6OLh2u/b7Y="},{"w":94,"h":86,"hash":"4PeBBYAIBZlXeaVKmwl6Zx+i9EeEUqdlGA=="},{"w":61,"h":88,"hash":"3/cBBQCxf6l3ioV1WadpmG+B7Pm4"},{"w":29,"h":41,"hash":"H/iBDAIHX5Chbnyqawdo8otij7N3a0qJBA=="},{"w":63,"h":74,"hash":"3wcCBgB0x884dZeDiopMhclYDUpUAm4="},{"w":29,"h":25,"hash":"HwiCBIIHF79zi6+Gg2fAhk/4fEtnapaYDQ=="},{"w":57,"h":98,"hash":"H/gBBABIejmXynwHHoVAnvdXSw=="},{"w":71,"h":69,"hash":"IPiBBYAHmD2KUW/lQQyLaLCDh0KklFn32g=="},{"w":71,"h":50,"hash":"3/cBBYBohqhLaJpwZoZUd011gBCJ"},{"w":89,"h":83,"hash":"4PeBBYAHkBp+Q/bXx0CSiZ+sT4Z4fIyYZg=="},{"w":92,"h":57,"hash":"IPgBBICgJdaPlJqBnUfQcGbwdA=="},{"w":39,"h":95,"hash":"3/eBAgAIymeYlAuWDQ9RUidjZat7jxk="},{"w":100,"h":82,"hash":"4AcCBoDiuKh2N+TrR6fh9nFm+5lp8Kc="},{"w":92,"h":93,"hash":"HwiCBQAIuI2JaEYDVRA6gU/q5PxIULPapw=="},{"w":67,"h":90,"hash":"IPgBBQC1bGaGk47Hl3+nddp6vwuY"},{"w":78,"h":71,"hash":"HwiCBYAHmZZIYn9JhXCLjZaQSWV2ZUGrfw=="},{"w":85,"h":42,"hash":"4AcCA4KeKZCAlcZzkAz7i6k="},{"w":8,"h":50,"hash":"3/eBCQAH+IVwSkj7IiZPL/h0dYpCSEg="},{"w":13,"h":78,"hash":"HwgCCQJGjqtkmUowdno/3fY="},{"w":66,"h":95,"hash":"HwiCAwAHCjuAqh2Fn/H9K5loYGiYmJU="},{"w":2,"h":84,"hash":"nvcFEQJ7c7iHmKwJj5iHCGA="},{"w":37,"h":32,"hash":"IAiCBIIIldBHeXKZ6f3EA2DV0K2GZkvDBA=="},{"w":41,"h":25,"hash":"3wcCDII7Jst5c0WFhga8cEnTBg=="},{"w":57,"h":26,"hash":"IPiBAoAIuvRneZfgjPSmAhZrl9W8SPU="},{"w":31,"h":40,"hash":"IPgBDQK6o7REKkCxJ1cXRlNqsK+B"},{"w":7,"h":69,"hash":"3veBCQIHdoKrFgYOxqU5cAVYqapmgjQ="},{"w":82,"h":59,"hash":"3/cBBYD4M6tIe6iJenZX0jv3i6QF"},{"w":85,"h":48,"hash":"IAiCA4AHyKR2lgvPG0TFBnXQWGkydzw="},{"w":53,"h":67,"hash":"HwgCBgKbVol5V393ersDOea29bSlZPk="},{"w":79,"h":26,"hash":"IAiCAoAI6QZtSGnvJmnwcJiHZquG+Hc="},{"w":14,"h":28,"hash":"3/cBDAJIhLeYi1+pu1owyIVvMg=="},{"w":85,"h":78,"hash":"4AeCBYAHXPhldaZ2ibVPVQmKh/iJlZQrig=="},{"w":26,"h":67,"hash":"H/gBCwI4T6OnR3GPhq81kGo="},{"w":51,"h":13,"hash":"IPiBCYII24eGC4VNfYAJR/S6V8WLeyg="},{"w":57,"h":81,"hash":"4AcCBQCoojSIY0qYe3f3UQGuawz+"},{"w":8,"h":72,"hash":"4PeBCQIHSUVYVn8ANrQoB3UWWYiXWbA="},{"w":89,"h":40,"hash":"IAgCA4LDe0AG5hb2aM8bcEM="},{"w":55,"h":94,"hash":"3/eBAwAHpIVmT7VvjwahW2NPhkiaDok="},{"w":59,"h":81,"hash":"H/gBDQBERoZIo4nKhqgKaJYvSkVA"},{"w":41,"h":45,"hash":"3/eBBQAHdeyYm3UGRR99adcGQ0RwRZpGmA=="},{"w":11,"h":28,"hash":"HxgCCwLHZnhGlGVggoAJ6GU="},{"w":8,"h":36,"hash":"4PeBCQIIbWHpldBF78rO/EKZaaiAqHo="},{"w":40,"h":100,"hash":"IAgCAwAIT2uoiESGs1BDrxw="},{"w":63,"h":33,"hash":"3weCA4IHmrEpmk9KVK92+LOxI+sLqfs="},{"w":72,"h":63,"hash":"HwgCBoCYlQZkaHeXaeabRJit12VwH7Y="},{"w":29,"h":90,"hash":"3/eBAgAIzqlo+KRtoAl1qh2KO7ZwWWo="},{"w":81,"h":26,"hash":"IPgBAoJVdauz6giWSnhgCYk="},{"w":92,"h":76,"hash":"IPiBBIAHrET8bFvpCZQdZQubVvO0vEV5DQ=="},{"w":85,"h":99,"hash":"3wcCBgB4L9nVxUhpWUyqb76n4LjPOfw="},{"w":79,"h":72,"hash":"4AeCBYAHWneox5/01wN7aHnvSAZscNB3qA=="},{"w":76,"h":18,"hash":"4PcBCoL6mZdmelSFz5UU9EQ="},{"w":78,"h":90,"hash":"4PeBBAAIDnhKoKRQpgBqMJy+iar8L4pZDg=="},{"w":72,"h":13,"hash":"3+cBCYKsdkJZyx6/lICO+8I="},{"w":78,"h":19,"hash":"H/iBAYAImX9hwHSeDXImENV3UIN1hMc="},{"w":29,"h":34,"hash":"IAgCDgB+WIp4KreKyhKJX6mqKKCvEI0="},{"w":63,"h":43,"hash":"H/iBA4AI++eiSIlZkLl/ZwKZhrlnSqg="},{"w":19,"h":79,"hash":"3wcCCgD1k3t0hnYqBHm6Di4="},{"w":82,"h":44,"hash":"3/eBA4AIqi2AjW6pr5YLmwF+OlNou7s="},{"w":70,"h":24,"hash":"3wcCCoAyRWCKl2Z3kHa6A1o="},{"w":28,"h":93,"hash":"4PeBCgAHwrsHVqZgqIePdy6kkJh4RRY="},{"w":44,"h":28,"hash":"H/gBBIJ2xMevRKKpZ4bnUTD6hQ=="},{"w":77,"h":9,"hash":"HwiCCYIIxixdZgmgw/m6OIcDrDM6WZ0="},{"w":59,"h":39,"hash":"H/gBBYKlW6qoh11be/NmovTQCbYc"},{"w":9,"h":93,"hash":"4PeBAQIHFVn4p5mIv/DH95KWbUXgUOk="},{"w":9,"h":96,"hash":"3wcCAQKKqluVczewLNPP0G8="},{"w":54,"h":83,"hash":"IPiBAwAIZVRaj5dvnH4NiFfGpfFPxjg="},{"w":75,"h":3,"hash":"3/cFEYR4iPWKmIiV99OsmPc="},{"w":96,"h":42,"hash":"4PeBAoAHcJqRe3qfQ6f3THWIkFi2ivY="},{"w":74,"h":8,"hash":"4PcBCYJ8JYC0NJh5+a5HnaA="},{"w":2,"h":95,"hash":"oPeBCQR3f82Im7eL3/dIdXgHiHiHiHc="},{"w":40,"h":25,"hash":"3/cBDIJGPXu1PFWvGyI2SH8JWA=="},{"w":48,"h":56,"hash":"H/iBDAAHU4OHDHmKpoT1qngAiHZWl2d4CQ=="},{"w":71,"h":18,"hash":"3/cBCoBFzceDtlBaL20Z8Ok="},{"w":60,"h":44,"hash":"3/eBBIAHqreoZmb9ePMT+YS4hIZZmncHCg=="},{"w":42,"h":25,"hash":"3/cBDIKPdrNMd9eNmFlSn7SZCw=="},{"w":64,"h":67,"hash":"IPiBBQAHbSpXaJBWxEgLybIIa6jFdgxmsw=="},{"w":74,"h":85,"hash":"4AcCBgCVe0R0W1l7eTSq0/dH+zScBSU="},{"w":42,"h":71,"hash":"4AeCAwAIZyCedbhPdZlPiaKXHQRSNeA="},{"w":61,"h":34,"hash":"H/gBBII/nL94LK58lLTVCUz9Jw=="},{"w":26,"h":66,"hash":"4AeCCgAISob0BHp4m1BvNhVnCiiFAtM="},{"w":17,"h":62,"hash":"IAgCCgI8jI9nEofooGprka8="},{"w":58,"h":90,"hash":"IAiCAwAI+Rt0bsP6o/o02aef81rcY4g="},{"w":41,"h":96,"hash":"H/gBAwDLuolgvElQHQppYPY="},{"w":57,"h":6,"hash":"IPiBCYIIh0q8dn/PhQBnd8ApWKNbdKo="},{"w":38,"h":47,"hash":"4PcBDgI6lpeRR2aABrhXvWW0UNaEIHg="},{"w":76,"h":6,"hash":"3xeCCYAISIuiIk91a6CpEKQVvUdsBYc="},{"w":85,"h":66,"hash":"H/gBBYDvamWWd5h1Vo2YlvdTB6/w"},{"w":7,"h":52,"hash":"4AeCCQII+ZuGYmj6XPaXdqa3B0a2dNA="},{"w":1,"h":4,"hash":"Hhk+UjgIh2iYh4iYGIuPh/g="},{"w":19,"h":26,"hash":"3weCDAIHY2JJumCmuqb1ToC4Yy94dxtUBw=="},{"w":63,"h":98,"hash":"3/cBBQBSUpp6Kn2Gnn+ikgXX5EBM"},{"w":36,"h":27,"hash":"IPiBBIAHh6xAemiM6Of5b5+q+XOJtpUwBg=="},{"w":69,"h":50,"hash":"IAgCBYK2ilWImIhgd8ikFPeoVvSn"},{"w":17,"h":100,"hash":"HwiCAQAI8el0tLUJG2OAFon6I0mAZ8U="},{"w":59,"h":24,"hash":"4AcCC4Inv4c4e2OIYDUGV7g="},{"w":57,"h":48,"hash":"3/eBBIAHBXh6Y4qllpB1ryKBqvqpSomhDA=="},{"w":90,"h":41,"hash":"IAgCC4CidBWGNweJm6+coBY="},{"w":68,"h":3,"hash":"oBiCCYII8hsmqlAgxcXwJHh2mAVZhWc="},{"w":77,"h":25,"hash":"4PcBCoL0iEqFdXO2zo+n9Eo="},{"w":50,"h":41,"hash":"HwiCBIAHSK9XhZbW6qiAX4j+o1Yn5JPmBA=="},{"w":95,"h":87,"hash":"3/cBBoBbqfUutpKElbmKm4B0C4I0ePA="},{"w":19,"h":7,"hash":"H/iBCoIYmUl/V1VESZ+mA6eLeHenBnY="},{"w":62,"h":28,"hash":"3wcCC4JqV4G1jAeTn3ttsvs="},{"w":80,"h":84,"hash":"HwiCBQAItaKauK+3WPxqSRf6TQlTiYgs1w=="},{"w":58,"h":11,"hash":"IPgBCYJWdVboUvKJ+nc6wI4="},{"w":62,"h":1,"hash":"oRjCKYZ3iIiIiHCXiJCLCIeIiIiAd/g="},{"w":83,"h":84,"hash":"IAgCBwCXsHOreqRrykpmV4t8lq9nsqEP"},{"w":38,"h":50,"hash":"HwiCBAAIMJSGqHiF+EsGGyZ/MLJmynBjAA=="},{"w":90,"h":25,"hash":"4AcCAoAmQEenlsuKgE4WyvY="},{"w":44,"h":34,"hash":"4AeCDIAIlUgqYFOZB1WIemC1gMKUhIq2Bg=="},{"w":44,"h":58,"hash":"4AcCDQJ1xMubx4YIEjhy2ct7H/IW"},{"w":53,"h":97,"hash":"3/eBAwAIfvkuWL5QdinGj6Tb3EAkpKk="},{"w":46,"h":78,"hash":"3wcCBAD69gtnSeOmSQvGoFC4QA=="},{"w":1,"h":91,"hash":"Xui9GQR3CIiHeIgIiXhfqAj3h4iHiHg="},{"w":62,"h":53,"hash":"HwgCBoDPnGynWGlHeHhaWbZ4ymtwP7k="},{"w":31,"h":16,"hash":"HwiCC4IHYMrnVnx9T5138ke3RXBlSHs="},{"w":79,"h":89,"hash":"3wcCBgCwS65nmVZ1Z3pFOze0G4xfP4U="},{"w":88,"h":46,"hash":"HwiCA4AIeft1qUicgPivQEqYkHp7hEY="},{"w":42,"h":42,"hash":"IAgCBwJd0ybqWZCUd6pdbkhHCZnq9ZoE"},{"w":33,"h":75,"hash":"4AeCAgAIin9mWYoCq51AulUCcmlfBB0="},{"w":74,"h":1,"hash":"3ic+AYp4h4eIiAiHD4hcjQg="},{"w":55,"h":35,"hash":"4AeCA4AIeIClN5NyENOgNZyaiIljBmw="},{"w":2,"h":11,"hash":"HlgKIQZwiHh0aZdocCUKd0w="},{"w":29,"h":33,"hash":"IPiBDAIH9lRItpqqd6CWmKAo+ad49JdoCg=="},{"w":63,"h":40,"hash":"HwgCBIBmUIs2Vol2OVgfOEvSHw=="},{"w":77,"h":90,"hash":"4PeBBAAINniEP5lGAIykwV9XCmS5VmjHCg=="},{"w":78,"h":14,"hash":"3wcCCYBGGoFHx5agj3xrR+8="},{"w":37,"h":40,"hash":"4PeBBQAHy1gEeihmdftWmwDn5DhniHAnSA=="},{"w":79,"h":27,"hash":"H/gBCoCc92ZmanaKgGcGl5k="},{"w":32,"h":86,"hash":"3weCAgAHW6NocGpT+AjOVShetbR/aso="},{"w":14,"h":30,"hash":"H/gBCwLNrIeFxaZPd6YvX1o="},{"w":33,"h":30,"hash":"oAeCBYIHarRwplZVhZj915j1dwd5Y352aQ=="},{"w":62,"h":95,"hash":"H/gBBQB5kGdZ1udkd3lJiV2PbAVc"},{"w":38,"h":93,"hash":"3weCAgAH5D7FRwOFXbAZ+fVpeYk0iHY="},{"w":47,"h":32,"hash":"3/cBDYJ0r1iqSJRkd6p3V3s/a9B/"},{"w":24,"h":9,"hash":"3weCCoIXijxlaV+Eb3RI9odfWVeFVEo="},{"w":17,"h":54,"hash":"4PcBAgSYZHWYgGhbIwMCqHU="},{"w":8,"h":78,"hash":"X/iBAQIIiFJTAjdPiZYEl2PU18bU8nQ="},{"w":8,"h":29,"hash":"HvgBCgYccKvOOXhJ20mAnyg="},{"w":90,"h":54,"hash":"H/iBA4AIb+2Md4RWn/Kfe/FJlyZ1jaQ="},{"w":88,"h":16,"hash":"H/gBCYBnc+aN1jVQYFe1Ov4="},{"w":38,"h":43,"hash":"IAiCBAAHzaaMBvyTQkB3gJ94bziEt4h4AQ=="},{"w":45,"h":33,"hash":"H/gBDYLClnt/2qJ5pLuZZpLzfW+Z"},{"w":9,"h":54,"hash":"3weCAQIIGp+aj3Wd9/GWhYjzxmlbRNg="},{"w":97,"h":47,"hash":"HwgCC4DRtDd8iLn5CHJ3Dnc="},{"w":69,"h":50,"hash":"HwiCBIAHyWepeKMEBzTqh8/5k21oaT90Bw=="},{"w":13,"h":65,"hash":"3/cBCQJpo8dpn410PLfAMvg="},{"w":25,"h":30,"hash":"IPiBBAIHqzf2RJS69XfSTG8Ld2qHiYe2Bw=="},{"w":35,"h":77,"hash":"IPgBAwC/xkaVdZYoy6K/wGU="},{"w":71,"h":99,"hash":"3/eBBAAI8jHjH4eYVgrLOHcQSAdCRrQ3Cw=="},{"w":51,"h":61,"hash":"HwgCDgB4ioRm1K+IiVmHolm68zhYANY="},{"w":99,"h":81,"hash":"4AeCBIAH/JSLl4h51voehr91sfZoWH5pBw=="},{"w":58,"h":89,"hash":"4AcCBQAN9jWNunlhuGOXV/qTrGQG"},{"w":92,"h":16,"hash":"H/iBAYAHzWadOEC11RAUXzefbZKQ2lw="},{"w":20,"h":9,"hash":"3vcBC4R6lm+5cB20+YmS1Ag="},{"w":87,"h":10,"hash":"3+eBAYII7ZVjl0/0dZfQebdwhKU8pfo="},{"w":59,"h":3,"hash":"nwcCCYIU+4fttp4sIM3/v4Y="},{"w":13,"h":39,"hash":"H/iBCgII915YU3MIrA+InAykfK6VeHk="},{"w":22,"h":87,"hash":"3/cBCgJ3MMpXK6a/3GXAf2Y="},{"w":20,"h":61,"hash":"H/iBCgIHcMhmxIC4f1uGBYYJhDl0p9c="},{"w":66,"h":33,"hash":"HwgCBIIVdWCYY5inCWn6Zwzbhg=="},{"w":24,"h":56,"hash":"HwiCAgAIV60ZefWzRA93WHxypWdW1wc="},{"w":36,"h":4,"hash":"HvgBGYaQohaH1cJad41gsFs="},{"w":93,"h":76,"hash":"IPiBBIAIcF8CZi2l97tl7aDCr7ubuXQ4Bg=="},{"w":50,"h":49,"hash":"IAgCB4K8Q4h4hHd5l/iUSzW62DWwG5AE"},{"w":89,"h":33,"hash":"H/iBAoAItPphyoZ4+FLXCCappHhPZLM="},{"w":88,"h":38,"hash":"4PcBA4Dgi0XjhoOT8obwtio="},{"w":92,"h":5,"hash":"4PeBAYII9+Mpe4oUCPQYNXqZtjd56L8="},{"w":16,"h":43,"hash":"HwgCCwLaREjvVTaWYGcna/o="},{"w":43,"h":25,"hash":"H/iBC4IIh7kDmbD1XptgRBwqiJg/xcs="},{"w":23,"h":15,"hash":"IAgCFYLE742XWmeuhhpXpJRT8NAa"},{"w":81,"h":7,"hash":"IPiBAYII/XuJaMxPhJlP16ewLUeXWQQ="},{"w":43,"h":10,"hash":"4PcBCoLS3wRpnEkUcvkwb3Q="},{"w":40,"h":31,"hash":"4PeBBIAHbvoid+O8vCBou5CEhcBWSHukBg=="},{"w":2,"h":54,"hash":"XggCGQh2P1eHhUhzil+FCIM="},{"w":81,"h":51,"hash":"HwiCA4AIXq5fhicHMAp5mmqAO6paeLQ="},{"w":66,"h":34,"hash":"3wcCBIKiaF02Rp91WXV/yMDyNw=="},{"w":82,"h":74,"hash":"4PeBBYAIuB98SKHF1VCErjT2iqiJh49Jlw=="},{"w":68,"h":37,"hash":"H/gBBICMWJmAh1d2Z4isj9tQYw=="},{"w":97,"h":1,"hash":"nxe+GYR3d3iIiIBYh8+FCId4iIiAd/g="},{"w":35,"h":74,"hash":"IAgCAwJaeHZYpGRvC0sBaJg="},{"w":84,"h":16,"hash":"4AeCAYIHtlwCmBe5QIZI/dVrfKfVQJM="},{"w":25,"h":39,"hash":"HwgCDAJR+5x4R7xqGLm9dQAwSA=="},{"w":7,"h":89,"hash":"3weCAQIH71t0jh3R8bisB2CGlqVZa/w="},{"w":11,"h":93,"hash":"4PcBEQIIiUqUVniGpkCGDmY="},{"w":28,"h":16,"hash":"3/eBC4AHZgaLiVrzW/ntHXFCuDtPelc="},{"w":47,"h":1,"hash":"4OdBGYaHiHiIiAh4+ojcfPg="},{"w":83,"h":79,"hash":"4PeBBYAHWU/JlHJmlyqL8DdUi9V3hwhJZQ=="},{"w":31,"h":58,"hash":"3/cBDACMjykH1lXXk4f1m1lXwA=="},{"w":87,"h":27,"hash":"3/eBAoAIWAuadHnSkGf6ZDCpWDbDVHk="},{"w":16,"h":25,"hash":"HxgCDALVgxjVRLTpv0gXoIL7lg=="},{"w":95,"h":6,"hash":"3/eBAYAHNhipdw3ol29wPIUrqUSnB0Y="},{"w":40,"h":79,"hash":"3/cBBACXn5bth4n5V0ifeYb4CA=="},{"w":37,"h":88,"hash":"3/eBAgAHatYMrGagPXqAUTT0aZlkV6k="},{"w":7,"h":64,"hash":"H/gBCQI1U92VyEzQtwv3UiI="},{"w":73,"h":44,"hash":"4AeCA4AI27s6T2uqZi+wyMCreGFnrNs="},{"w":13,"h":53,"hash":"H/gBCgKVPabFiVmfjzmJPgc="},{"w":26,"h":88,"hash":"4AeCAQAH+JrYmobr0Ntl9nJ0DUiHpaU="},{"w":92,"h":96,"hash":"H/gBBwDjZwxVe4qVdpSGh3maxpnPRPAB"},{"w":22,"h":93,"hash":"IPiBAQAIem4GeFLLT5awR4mPYXKA5Tc="},{"w":11,"h":63,"hash":"3/cBCQIEtyd3dmiLRl8zsW8="},{"w":1,"h":16,"hash":"IUbCgRB3CIiHeHj3iIhgOAj3homHiJg="},{"w":86,"h":54,"hash":"3wcCBIBmpUU+NtE5BapGT91XLw=="},{"w":45,"h":45,"hash":"3/eBBQAIjRSWIMBjFweKEy/f4ohbs78Dtw=="},{"w":86,"h":72,"hash":"IPgBBoDpdbynqIevhmp4hEio9NP2gBk="},{"w":56,"h":61,"hash":"HwiCBQAH/ErFesNrqQBrC8foSKc/e7px+A=="},{"w":36,"h":82,"hash":"IPgBAwDXSB9klzdqJkDSCJM="},{"w":19,"h":26,"hash":"IPiBBAIHimHC+WqsTSHQA8CFXPR1aWR7Bw=="},{"w":63,"h":30,"hash":"4AcCC4I3YoJa+ltaWY+Hed8="},{"w":22,"h":67,"hash":"H/iBCgAIdFg69+dzCKkNMJDF6aaPSyc="},{"w":7,"h":4,"hash":"XggGJIgRdYiZWVxIaK+wffh5Sg=="},{"w":65,"h":44,"hash":"H/iBA4AI2jgH3cmnUEkHdX5wtrmFaHQ="},{"w":97,"h":19,"hash":"HwgCCYBPdSVmN45n94dKaAM="},{"w":67,"h":11,"hash":"HwiCCYIImJywpza6bza/d0WndXmo+Dc="},{"w":83,"h":76,"hash":"3wcCBoAIXnqYdVekp+pHk3pn3blfP2g="},{"w":80,"h":98,"hash":"IAiCBAAI39GbiZdfdejP/6+SXIhJSPW3BA=="},{"w":72,"h":86,"hash":"3/cBBgKS+2i4h4h1a46YhnlKwb9G+qc="},{"w":78,"h":29,"hash":"3weCAoAIY2hKCQcA2gp4mpvrhouJX2c="},{"w":91,"h":1,"hash":"IfhBEYZ3iIeIiAiIB4j1i4g="},{"w":68,"h":99,"hash":"IAiCAwAIvewBFkMMqfxbLHqvcVbUZms="},{"w":79,"h":4,"hash":"4AcCCYSbW4Z9nYBL6TpgcE0="},{"w":80,"h":44,"hash":"IAiCA4IHxb+flWn5zAqJiPi0z6Vxk5g="},{"w":43,"h":36,"hash":"4PcBDoC6Qb9xjJWgeX5rc6hoklAaxH8="},{"w":61,"h":21,"hash":"4PeBAoAHoJ2KVFQu/C75JX+S/veGdqI="},{"w":23,"h":93,"hash":"4AcCCgKo/IiJRxNo2ZmfDd0="},{"w":96,"h":65,"hash":"HwiCA4AIgHXGaTw2+itpEHn4d5dxd6c="},{"w":90,"h":27,"hash":"IPgBCoBhgm/V6idYX+m39Sg="},{"w":81,"h":31,"hash":"3weCAoAHn6dXpYipr98KiLRmcGlrmIc="},{"w":73,"h":41,"hash":"3/cBBIA25bcwaFfYQdYCSqbxlg=="},{"w":91,"h":68,"hash":"3/eBBIAI0Jd2OHJIevfJgHx8NNZGpwl/CA=="},{"w":94,"h":74,"hash":"IPgBBoBvTGmIeYhay4x3Z3U3pn8gD0I="},{"w":72,"h":34,"hash":"3weCAoAHQIe83bnPpAqzRjjYpIKvlzc="},{"w":51,"h":34,"hash":"HwgCBYA6fzbdPH26bIaJuMpavwGt"},{"w":55,"h":33,"hash":"H/iBA4AHNLA1nUbPzZ4NNVOQpXiZ11k="},{"w":92,"h":20,"hash":"4PcBAoL2t02KyoishKT/vWc="},{"w":1,"h":94,"hash":"Hvi9CQKICId4iIgYj3tPOAj3h4iHiHg="},{"w":46,"h":34,"hash":"HwgCDYCYTefPhieK2bw3PMCa2Lrw"},{"w":64,"h":30,"hash":"IAiCAoAHTDx/WamEcJBD9saIKnufjmc="},{"w":36,"h":19,"hash":"HwgCDIKHuMmduHeamoBgk/PTeg=="},{"w":90,"h":94,"hash":"IAiCBQAHZy+dmah1KFYwiwVXfURlxoBptQ=="},{"w":89,"h":49,"hash":"H/gBBIBpkIl5rJU5yJrcT/x9UQ=="},{"w":34,"h":2,"hash":"Y8iBCYSIVbsJgXeT+wc2iYeHh4eHiAc="},{"w":25,"h":40,"hash":"3wcCDAKkNHd3x4wKpngw3Pa3Cw=="},{"w":47,"h":32,"hash":"IPiBA4AHl3CHY4VS/WGvOem9n4xZNiY="},{"w":53,"h":96,"hash":"4PcBBAB4zFkHVnZ5Vnb+cQoyqA=="},{"w":47,"h":93,"hash":"4PeBAwAHovPYd5nJhr9y84volUge9qQ="},{"w":86,"h":89,"hash":"4AcCBwIxnclaVpZmhwuXeIqsOUOABWQF"},{"w":40,"h":90,"hash":"IPiBAgAIzWDGoI4lL8cOkpTyeDiGmHY="},{"w":38,"h":66,"hash":"H/gBBAK5wb10WqSEx3BqgHasQA=="},{"w":12,"h":21,"hash":"4AeCAwIHU5iHp/TaqbBfi7ypznOSRIA="},{"w":54,"h":29,"hash":"3/cBBILTCdd3yod7eIVwrqfOnw=="},{"w":78,"h":77,"hash":"3weCBYAIfO9WhGEMTcBzWAd3QJc6hLVohw=="},{"w":88,"h":96,"hash":"3/cBBgCfiF9LQRun2ME2UJ5yuGC1Dgg="},{"w":49,"h":89,"hash":"4PeBAwAIKc/XsRei+QLKXFcyRHdFSvM="},{"w":19,"h":41,"hash":"3wcCCwKIj4pZgGhJXAfKXfQ="},{"w":70,"h":53,"hash":"IPiBBIII2CpoSAcGTfhW94S4b3aFdlqmBQ=="},{"w":55,"h":57,"hash":"4PcBBwAGraR0aVs6blrol9aYrApGsBgG"},{"w":54,"h":29,"hash":"3/eBC4AHyLBqhpD4VxQX9hqwzY9DuVg="},{"w":15,"h":75,"hash":"HwgCCQKJ9qeHapW2EDvPhPc="},{"w":93,"h":81,"hash":"H/iBBIAHC2WedpVnfngIVnX/YBI7RopLBw=="},{"w":64,"h":96,"hash":"4AcCBQCMiJ5GnFu6rDv1yHqfSLQP"},{"w":76,"h":44,"hash":"IPiBA4AHqQeWWI2puG+/SsVZfH+EKFc="},{"w":88,"h":33,"hash":"IAgCA4L4N5JQnp1odH8Id50="},{"w":1,"h":34,"hash":"Xue9MQaICIh3iHj3h3WfiAj3h4iId4g="},{"w":30,"h":4,"hash":"IOgFGYa2AneplIqU+YGncKc="},{"w":92,"h":76,"hash":"HwiCBIAHKrOomZBJlckKC2XFT54JnMSLCA=="},{"w":91,"h":16,"hash":"IPgBCYLldw2ryLmLYHjxVkk="},{"w":3,"h":26,"hash":"3yeGCQIYiY/WpUpL9DmJ/2WYd4anCrk="},{"w":2,"h":14,"hash":"YNcFCQ56SgeK1ld+hvp2+FY="},{"w":93,"h":90,"hash":"IPiBBYAHlR+Hm5gJyPdlAqqImTuPWXlFeA=="},{"w":47,"h":88,"hash":"3/cBBAALd4h3lHZpeIlfs6NTDQ=="},{"w":35,"h":32,"hash":"4AeCBYIHdgJPGVxze8rQrvpIvplllljXBw=="},{"w":38,"h":5,"hash":"4AcCCYRTKNxEawW3UJsl/5Y="},{"w":8,"h":78,"hash":"H/iBCQIHjIUIg8cEM2XQxWp6oKdah5A="},{"w":39,"h":36,"hash":"3/cBDoJQZreZx2RPmKWGpxpkSXA6/EM="},{"w":55,"h":13,"hash":"HwiCAYAHfuUceQxcnO/ZMFE234F3aZY="},{"w":13,"h":56,"hash":"IAgCCgJ7gviHc4ur2H4A1gI="},{"w":26,"h":22,"hash":"3weCBIIHx2iLhiCf+OrZYBToaS9I6Zd1BA=="},{"w":83,"h":19,"hash":"3wcCCoL5dJtjKLdzdZvA/G0="},{"w":7,"h":9,"hash":"IRiCDAQXc8cFtlkd8SmVQIVf+rcJWDm7BA=="},{"w":90,"h":43,"hash":"4PcBA4BWXGyC3oWPkJfDrgo="},{"w":43,"h":77,"hash":"IPiBAwAHhT8asHZ/VIr3tMogVkNnm1g="},{"w":36,"h":27,"hash":"IPgBBYKokWWJhMqLlilFBLsGpL/F"},{"w":86,"h":62,"hash":"3weCBIAHsSsGVZlmSOT8f6tyeRCPwHh6DA=="},{"w":63,"h":89,"hash":"IAgCBQC69pVJd3nafFOo1Xr893oE"},{"w":69,"h":98,"hash":"4AeCBAAHidVTQLuXiQbeVJ9H32iHhUaHAg=="},{"w":12,"h":58,"hash":"HwgCCQKZX0iHh3rGb6X1Nec="},{"w":7,"h":7,"hash":"YPeFFQYXh8baRainTwmCfET7/Km5ia0jxw=="},{"w":40,"h":12,"hash":"IPgBEoSX8Ul3WeSbcLd1Zfg="},{"w":93,"h":47,"hash":"4PeBA4AHY4N7pPu7oJO5AnmeQLYcRLk="},{"w":15,"h":42,"hash":"4AcCCwJ0D/zATmOWM/r3xXM="},{"w":67,"h":45,"hash":"3/eBA4AHVbr4h517mv+eZprFsJioaoQ="},{"w":67,"h":74,"hash":"IAgCBgBqmUc1R2d6iqtrigl4lSf/VXQ="},{"w":29,"h":67,"hash":"3weCAgAHYJRmaGqgmaOAV5q0AZR2akk="},{"w":43,"h":10,"hash":"4AcCCoL8SVDXdVsyiECVaK8="},{"w":75,"h":40,"hash":"IAiCA4AHw2mXw6/AoA5Eo8onAwY4s2o="},{"w":73,"h":91,"hash":"3wcCBgDFhsbJlnmDaYxwRZZUl5GAfzY="},{"w":21,"h":54,"hash":"4AeCAgIHWamZCKf0fNZpTyw6aHxHXzM="},{"w":98,"h":52,"hash":"H/gBBICZZsltiKuMUHewoYEI5g=="},{"w":2,"h":29,"hash":"XwiCCQR3cpuYwKqODEIHWXgHiHiIiIc="}]diff --git a/core/artwork/thumbhash/testdata/golden.json b/core/artwork/thumbhash/testdata/golden.jsonnew file mode 100644index 000000000..578986e75--- /dev/null+++ b/core/artwork/thumbhash/testdata/golden.json@@ -0,0 +1,8 @@+{+ "alpha.png": "JOiFBQ4nkIexh3p4iA8uB+lYhIeAh3d4dw==",+ "landscape.png": "3wcOFJpwh4eBh3d4iIePgAj3hw==",+ "portrait.png": "3/cNFBqBB4iId4d3d4iAjwj4hw==",+ "solid.png": "HoUBBwB4eHeHd3hweId3h3h4B2+Ih4gA",+ "square.png": "H/gNBxpwh4dwd3eIiHd3iHeHeJ+dcH8I",+ "tiny.png": "HoU9tx4I9wiIh4hwj3CI+AiIcH/494cP"+}diff --git a/core/artwork/thumbhash/testdata/landscape.png b/core/artwork/thumbhash/testdata/landscape.pngnew file mode 100644index 000000000..413851f47Binary files /dev/null and b/core/artwork/thumbhash/testdata/landscape.png differdiff --git a/core/artwork/thumbhash/testdata/portrait.png b/core/artwork/thumbhash/testdata/portrait.pngnew file mode 100644index 000000000..bc6e5f0deBinary files /dev/null and b/core/artwork/thumbhash/testdata/portrait.png differdiff --git a/core/artwork/thumbhash/testdata/solid.png b/core/artwork/thumbhash/testdata/solid.pngnew file mode 100644index 000000000..3c53a36bfBinary files /dev/null and b/core/artwork/thumbhash/testdata/solid.png differdiff --git a/core/artwork/thumbhash/testdata/square.png b/core/artwork/thumbhash/testdata/square.pngnew file mode 100644index 000000000..a81000cbcBinary files /dev/null and b/core/artwork/thumbhash/testdata/square.png differdiff --git a/core/artwork/thumbhash/testdata/thumbhash.js b/core/artwork/thumbhash/testdata/thumbhash.jsnew file mode 100644index 000000000..369b118ec--- /dev/null+++ b/core/artwork/thumbhash/testdata/thumbhash.js@@ -0,0 +1,288 @@+/**+ * Encodes an RGBA image to a ThumbHash. RGB should not be premultiplied by A.+ *+ * @param w The width of the input image. Must be ≤100px.+ * @param h The height of the input image. Must be ≤100px.+ * @param rgba The pixels in the input image, row-by-row. Must have w*h*4 elements.+ * @returns The ThumbHash as a Uint8Array.+ */+export function rgbaToThumbHash(w, h, rgba) {+ // Encoding an image larger than 100x100 is slow with no benefit+ if (w > 100 || h > 100) throw new Error(`${w}x${h} doesn't fit in 100x100`)+ let { PI, round, max, cos, abs } = Math++ // Determine the average color+ let avg_r = 0, avg_g = 0, avg_b = 0, avg_a = 0+ for (let i = 0, j = 0; i < w * h; i++, j += 4) {+ let alpha = rgba[j + 3] / 255+ avg_r += alpha / 255 * rgba[j]+ avg_g += alpha / 255 * rgba[j + 1]+ avg_b += alpha / 255 * rgba[j + 2]+ avg_a += alpha+ }+ if (avg_a) {+ avg_r /= avg_a+ avg_g /= avg_a+ avg_b /= avg_a+ }++ let hasAlpha = avg_a < w * h+ let l_limit = hasAlpha ? 5 : 7 // Use fewer luminance bits if there's alpha+ let lx = max(1, round(l_limit * w / max(w, h)))+ let ly = max(1, round(l_limit * h / max(w, h)))+ let l = [] // luminance+ let p = [] // yellow - blue+ let q = [] // red - green+ let a = [] // alpha++ // Convert the image from RGBA to LPQA (composite atop the average color)+ for (let i = 0, j = 0; i < w * h; i++, j += 4) {+ let alpha = rgba[j + 3] / 255+ let r = avg_r * (1 - alpha) + alpha / 255 * rgba[j]+ let g = avg_g * (1 - alpha) + alpha / 255 * rgba[j + 1]+ let b = avg_b * (1 - alpha) + alpha / 255 * rgba[j + 2]+ l[i] = (r + g + b) / 3+ p[i] = (r + g) / 2 - b+ q[i] = r - g+ a[i] = alpha+ }++ // Encode using the DCT into DC (constant) and normalized AC (varying) terms+ let encodeChannel = (channel, nx, ny) => {+ let dc = 0, ac = [], scale = 0, fx = []+ for (let cy = 0; cy < ny; cy++) {+ for (let cx = 0; cx * ny < nx * (ny - cy); cx++) {+ let f = 0+ for (let x = 0; x < w; x++)+ fx[x] = cos(PI / w * cx * (x + 0.5))+ for (let y = 0; y < h; y++)+ for (let x = 0, fy = cos(PI / h * cy * (y + 0.5)); x < w; x++)+ f += channel[x + y * w] * fx[x] * fy+ f /= w * h+ if (cx || cy) {+ ac.push(f)+ scale = max(scale, abs(f))+ } else {+ dc = f+ }+ }+ }+ if (scale)+ for (let i = 0; i < ac.length; i++)+ ac[i] = 0.5 + 0.5 / scale * ac[i]+ return [dc, ac, scale]+ }+ let [l_dc, l_ac, l_scale] = encodeChannel(l, max(3, lx), max(3, ly))+ let [p_dc, p_ac, p_scale] = encodeChannel(p, 3, 3)+ let [q_dc, q_ac, q_scale] = encodeChannel(q, 3, 3)+ let [a_dc, a_ac, a_scale] = hasAlpha ? encodeChannel(a, 5, 5) : []++ // Write the constants+ let isLandscape = w > h+ let header24 = round(63 * l_dc) | (round(31.5 + 31.5 * p_dc) << 6) | (round(31.5 + 31.5 * q_dc) << 12) | (round(31 * l_scale) << 18) | (hasAlpha << 23)+ let header16 = (isLandscape ? ly : lx) | (round(63 * p_scale) << 3) | (round(63 * q_scale) << 9) | (isLandscape << 15)+ let hash = [header24 & 255, (header24 >> 8) & 255, header24 >> 16, header16 & 255, header16 >> 8]+ let ac_start = hasAlpha ? 6 : 5+ let ac_index = 0+ if (hasAlpha) hash.push(round(15 * a_dc) | (round(15 * a_scale) << 4))++ // Write the varying factors+ for (let ac of hasAlpha ? [l_ac, p_ac, q_ac, a_ac] : [l_ac, p_ac, q_ac])+ for (let f of ac)+ hash[ac_start + (ac_index >> 1)] |= round(15 * f) << ((ac_index++ & 1) << 2)+ return new Uint8Array(hash)+}++/**+ * Decodes a ThumbHash to an RGBA image. RGB is not be premultiplied by A.+ *+ * @param hash The bytes of the ThumbHash.+ * @returns The width, height, and pixels of the rendered placeholder image.+ */+export function thumbHashToRGBA(hash) {+ let { PI, min, max, cos, round } = Math++ // Read the constants+ let header24 = hash[0] | (hash[1] << 8) | (hash[2] << 16)+ let header16 = hash[3] | (hash[4] << 8)+ let l_dc = (header24 & 63) / 63+ let p_dc = ((header24 >> 6) & 63) / 31.5 - 1+ let q_dc = ((header24 >> 12) & 63) / 31.5 - 1+ let l_scale = ((header24 >> 18) & 31) / 31+ let hasAlpha = header24 >> 23+ let p_scale = ((header16 >> 3) & 63) / 63+ let q_scale = ((header16 >> 9) & 63) / 63+ let isLandscape = header16 >> 15+ let lx = max(3, isLandscape ? hasAlpha ? 5 : 7 : header16 & 7)+ let ly = max(3, isLandscape ? header16 & 7 : hasAlpha ? 5 : 7)+ let a_dc = hasAlpha ? (hash[5] & 15) / 15 : 1+ let a_scale = (hash[5] >> 4) / 15++ // Read the varying factors (boost saturation by 1.25x to compensate for quantization)+ let ac_start = hasAlpha ? 6 : 5+ let ac_index = 0+ let decodeChannel = (nx, ny, scale) => {+ let ac = []+ for (let cy = 0; cy < ny; cy++)+ for (let cx = cy ? 0 : 1; cx * ny < nx * (ny - cy); cx++)+ ac.push((((hash[ac_start + (ac_index >> 1)] >> ((ac_index++ & 1) << 2)) & 15) / 7.5 - 1) * scale)+ return ac+ }+ let l_ac = decodeChannel(lx, ly, l_scale)+ let p_ac = decodeChannel(3, 3, p_scale * 1.25)+ let q_ac = decodeChannel(3, 3, q_scale * 1.25)+ let a_ac = hasAlpha && decodeChannel(5, 5, a_scale)++ // Decode using the DCT into RGB+ let ratio = thumbHashToApproximateAspectRatio(hash)+ let w = round(ratio > 1 ? 32 : 32 * ratio)+ let h = round(ratio > 1 ? 32 / ratio : 32)+ let rgba = new Uint8Array(w * h * 4), fx = [], fy = []+ for (let y = 0, i = 0; y < h; y++) {+ for (let x = 0; x < w; x++, i += 4) {+ let l = l_dc, p = p_dc, q = q_dc, a = a_dc++ // Precompute the coefficients+ for (let cx = 0, n = max(lx, hasAlpha ? 5 : 3); cx < n; cx++)+ fx[cx] = cos(PI / w * (x + 0.5) * cx)+ for (let cy = 0, n = max(ly, hasAlpha ? 5 : 3); cy < n; cy++)+ fy[cy] = cos(PI / h * (y + 0.5) * cy)++ // Decode L+ for (let cy = 0, j = 0; cy < ly; cy++)+ for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx * ly < lx * (ly - cy); cx++, j++)+ l += l_ac[j] * fx[cx] * fy2++ // Decode P and Q+ for (let cy = 0, j = 0; cy < 3; cy++) {+ for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 3 - cy; cx++, j++) {+ let f = fx[cx] * fy2+ p += p_ac[j] * f+ q += q_ac[j] * f+ }+ }++ // Decode A+ if (hasAlpha)+ for (let cy = 0, j = 0; cy < 5; cy++)+ for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 5 - cy; cx++, j++)+ a += a_ac[j] * fx[cx] * fy2++ // Convert to RGB+ let b = l - 2 / 3 * p+ let r = (3 * l - b + q) / 2+ let g = r - q+ rgba[i] = max(0, 255 * min(1, r))+ rgba[i + 1] = max(0, 255 * min(1, g))+ rgba[i + 2] = max(0, 255 * min(1, b))+ rgba[i + 3] = max(0, 255 * min(1, a))+ }+ }+ return { w, h, rgba }+}++/**+ * Extracts the average color from a ThumbHash. RGB is not be premultiplied by A.+ *+ * @param hash The bytes of the ThumbHash.+ * @returns The RGBA values for the average color. Each value ranges from 0 to 1.+ */+export function thumbHashToAverageRGBA(hash) {+ let { min, max } = Math+ let header = hash[0] | (hash[1] << 8) | (hash[2] << 16)+ let l = (header & 63) / 63+ let p = ((header >> 6) & 63) / 31.5 - 1+ let q = ((header >> 12) & 63) / 31.5 - 1+ let hasAlpha = header >> 23+ let a = hasAlpha ? (hash[5] & 15) / 15 : 1+ let b = l - 2 / 3 * p+ let r = (3 * l - b + q) / 2+ let g = r - q+ return {+ r: max(0, min(1, r)),+ g: max(0, min(1, g)),+ b: max(0, min(1, b)),+ a+ }+}++/**+ * Extracts the approximate aspect ratio of the original image.+ *+ * @param hash The bytes of the ThumbHash.+ * @returns The approximate aspect ratio (i.e. width / height).+ */+export function thumbHashToApproximateAspectRatio(hash) {+ let header = hash[3]+ let hasAlpha = hash[2] & 0x80+ let isLandscape = hash[4] & 0x80+ let lx = isLandscape ? hasAlpha ? 5 : 7 : header & 7+ let ly = isLandscape ? header & 7 : hasAlpha ? 5 : 7+ return lx / ly+}++/**+ * Encodes an RGBA image to a PNG data URL. RGB should not be premultiplied by+ * A. This is optimized for speed and simplicity and does not optimize for size+ * at all. This doesn't do any compression (all values are stored uncompressed).+ *+ * @param w The width of the input image. Must be ≤100px.+ * @param h The height of the input image. Must be ≤100px.+ * @param rgba The pixels in the input image, row-by-row. Must have w*h*4 elements.+ * @returns A data URL containing a PNG for the input image.+ */+export function rgbaToDataURL(w, h, rgba) {+ let row = w * 4 + 1+ let idat = 6 + h * (5 + row)+ let bytes = [+ 137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0,+ w >> 8, w & 255, 0, 0, h >> 8, h & 255, 8, 6, 0, 0, 0, 0, 0, 0, 0,+ idat >>> 24, (idat >> 16) & 255, (idat >> 8) & 255, idat & 255,+ 73, 68, 65, 84, 120, 1+ ]+ let table = [+ 0, 498536548, 997073096, 651767980, 1994146192, 1802195444, 1303535960,+ 1342533948, -306674912, -267414716, -690576408, -882789492, -1687895376,+ -2032938284, -1609899400, -1111625188+ ]+ let a = 1, b = 0+ for (let y = 0, i = 0, end = row - 1; y < h; y++, end += row - 1) {+ bytes.push(y + 1 < h ? 0 : 1, row & 255, row >> 8, ~row & 255, (row >> 8) ^ 255, 0)+ for (b = (b + a) % 65521; i < end; i++) {+ let u = rgba[i] & 255+ bytes.push(u)+ a = (a + u) % 65521+ b = (b + a) % 65521+ }+ }+ bytes.push(+ b >> 8, b & 255, a >> 8, a & 255, 0, 0, 0, 0,+ 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130+ )+ for (let [start, end] of [[12, 29], [37, 41 + idat]]) {+ let c = ~0+ for (let i = start; i < end; i++) {+ c ^= bytes[i]+ c = (c >>> 4) ^ table[c & 15]+ c = (c >>> 4) ^ table[c & 15]+ }+ c = ~c+ bytes[end++] = c >>> 24+ bytes[end++] = (c >> 16) & 255+ bytes[end++] = (c >> 8) & 255+ bytes[end++] = c & 255+ }+ return 'data:image/png;base64,' + btoa(String.fromCharCode(...bytes))+}++/**+ * Decodes a ThumbHash to a PNG data URL. This is a convenience function that+ * just calls "thumbHashToRGBA" followed by "rgbaToDataURL".+ *+ * @param hash The bytes of the ThumbHash.+ * @returns A data URL containing a PNG for the rendered ThumbHash.+ */+export function thumbHashToDataURL(hash) {+ let image = thumbHashToRGBA(hash)+ return rgbaToDataURL(image.w, image.h, image.rgba)+}diff --git a/core/artwork/thumbhash/testdata/tiny.png b/core/artwork/thumbhash/testdata/tiny.pngnew file mode 100644index 000000000..ab635e11aBinary files /dev/null and b/core/artwork/thumbhash/testdata/tiny.png differdiff --git a/core/artwork/thumbhash/thumbhash.go b/core/artwork/thumbhash/thumbhash.gonew file mode 100644index 000000000..a255bec42--- /dev/null+++ b/core/artwork/thumbhash/thumbhash.go@@ -0,0 +1,257 @@+// Package thumbhash implements the ThumbHash encoding algorithm (https://github.com/evanw/thumbhash).+package thumbhash++import (+ "errors"+ "image"+ "image/draw"+ "math"++ xdraw "golang.org/x/image/draw"+)++// maxInputSize is the algorithm's hard limit: larger inputs are rejected by every implementation.+const maxInputSize = 100++// term is one DCT coefficient's frequency pair, in the reference's triangular scan order.+type term struct{ cx, cy int }++// Encode returns the ThumbHash of img: 24 bytes when opaque, 25 with alpha. Output matches+// evanw/thumbhash except where a coefficient lands on a quantization tie, where a nibble may differ by 1.+func Encode(img image.Image) ([]byte, error) {+ rgba := toNRGBA(downscale(img))+ b := rgba.Bounds()+ w, h := b.Dx(), b.Dy()+ if w == 0 || h == 0 {+ return nil, errors.New("thumbhash: empty image")+ }++ avgR, avgG, avgB, avgA := averageColor(rgba, w, h)+ hasAlpha := avgA < float64(w*h)+ if avgA > 0 {+ avgR /= avgA+ avgG /= avgA+ avgB /= avgA+ }++ lLimit := 7.0+ if hasAlpha {+ lLimit = 5.0+ }+ maxWH := float64(max(w, h))+ lx := max(1, int(math.Round(lLimit*float64(w)/maxWH)))+ ly := max(1, int(math.Round(lLimit*float64(h)/maxWH)))++ lTerms := terms(max(3, lx), max(3, ly))+ pTerms := terms(3, 3)+ qTerms := terms(3, 3)+ var aTerms []term+ if hasAlpha {+ aTerms = terms(5, 5)+ }++ // The widest coefficient region wins: 3x3 chroma, 5x5 alpha, and luma's own lx by ly.+ chan5 := 3+ if hasAlpha {+ chan5 = 5+ }+ nx := max(max(3, lx), chan5)+ cosX := cosTable(nx, w)+ cosY := cosTable(max(max(3, ly), chan5), h)++ lAcc := make([]float64, len(lTerms))+ pAcc := make([]float64, len(pTerms))+ qAcc := make([]float64, len(qTerms))+ aAcc := make([]float64, len(aTerms))+ rowL := make([]float64, nx)+ rowP := make([]float64, nx)+ rowQ := make([]float64, nx)+ rowA := make([]float64, nx)++ for y := range h {+ clear(rowL)+ clear(rowP)+ clear(rowQ)+ clear(rowA)+ row := rgba.Pix[y*rgba.Stride:]+ for x := range w {+ j := x * 4+ alpha := float64(row[j+3]) / 255+ r := avgR*(1-alpha) + alpha/255*float64(row[j])+ g := avgG*(1-alpha) + alpha/255*float64(row[j+1])+ bl := avgB*(1-alpha) + alpha/255*float64(row[j+2])+ lv := (r + g + bl) / 3+ pv := (r+g)/2 - bl+ qv := r - g+ for cx := range nx {+ f := cosX[cx][x]+ rowL[cx] += lv * f+ rowP[cx] += pv * f+ rowQ[cx] += qv * f+ }+ // hasAlpha is loop-invariant, so this costs a predicted branch rather than a quarter+ // of the inner loop that opaque images never need.+ if hasAlpha {+ for cx := range nx {+ rowA[cx] += alpha * cosX[cx][x]+ }+ }+ }+ accumulate(lAcc, lTerms, rowL, cosY, y)+ accumulate(pAcc, pTerms, rowP, cosY, y)+ accumulate(qAcc, qTerms, rowQ, cosY, y)+ accumulate(aAcc, aTerms, rowA, cosY, y)+ }++ n := float64(w * h)+ lDC, lAC, lScale := normalize(lAcc, n)+ pDC, pAC, pScale := normalize(pAcc, n)+ qDC, qAC, qScale := normalize(qAcc, n)+ aDC, aAC, aScale := normalize(aAcc, n)++ return pack(w, h, hasAlpha, lx, ly,+ lDC, pDC, qDC, aDC, lScale, pScale, qScale, aScale, lAC, pAC, qAC, aAC), nil+}++// terms lists the (cx, cy) pairs of the reference's triangular coefficient region, in write order.+func terms(nx, ny int) []term {+ var ts []term+ for cy := range ny {+ for cx := 0; cx*ny < nx*(ny-cy); cx++ {+ ts = append(ts, term{cx, cy})+ }+ }+ return ts+}++// cosTable precomputes cos(pi/size * c * (i+0.5)) with the reference's exact expression, so the+// table values are bit-identical to recomputing them per coefficient.+func cosTable(n, size int) [][]float64 {+ t := make([][]float64, n)+ for c := range n {+ t[c] = make([]float64, size)+ for i := range size {+ t[c][i] = math.Cos(math.Pi / float64(size) * float64(c) * (float64(i) + 0.5))+ }+ }+ return t+}++func averageColor(rgba *image.NRGBA, w, h int) (r, g, b, a float64) {+ for y := range h {+ row := rgba.Pix[y*rgba.Stride:]+ for x := range w {+ j := x * 4+ alpha := float64(row[j+3]) / 255+ r += alpha / 255 * float64(row[j])+ g += alpha / 255 * float64(row[j+1])+ b += alpha / 255 * float64(row[j+2])+ a += alpha+ }+ }+ return r, g, b, a+}++// accumulate folds one row's per-cx sums into the term accumulators, so the pixel loop costs+// nx multiplies per pixel instead of one per coefficient.+func accumulate(acc []float64, ts []term, row []float64, cosY [][]float64, y int) {+ for k, t := range ts {+ acc[k] += row[t.cx] * cosY[t.cy][y]+ }+}++// normalize splits the accumulators into DC and scaled AC terms, matching the reference: a constant+// image leaves scale at 0, which skips normalization rather than mapping the terms to the midpoint.+func normalize(acc []float64, n float64) (dc float64, ac []float64, scale float64) {+ if len(acc) == 0 {+ return 0, nil, 0+ }+ dc = acc[0] / n+ ac = make([]float64, len(acc)-1)+ for i, v := range acc[1:] {+ ac[i] = v / n+ scale = max(scale, math.Abs(ac[i]))+ }+ if scale > 0 {+ for i := range ac {+ ac[i] = 0.5 + 0.5/scale*ac[i]+ }+ }+ return dc, ac, scale+}++func pack(w, h int, hasAlpha bool, lx, ly int,+ lDC, pDC, qDC, aDC, lScale, pScale, qScale, aScale float64,+ lAC, pAC, qAC, aAC []float64,+) []byte {+ isLandscape := 0+ if w > h {+ isLandscape = 1+ }+ alphaBit := 0+ if hasAlpha {+ alphaBit = 1+ }+ header24 := int(math.Round(63*lDC)) | int(math.Round(31.5+31.5*pDC))<<6 |+ int(math.Round(31.5+31.5*qDC))<<12 | int(math.Round(31*lScale))<<18 | alphaBit<<23+ lead := lx+ if isLandscape == 1 {+ lead = ly+ }+ header16 := lead | int(math.Round(63*pScale))<<3 | int(math.Round(63*qScale))<<9 | isLandscape<<15++ acs := [][]float64{lAC, pAC, qAC}+ acStart := 5+ if hasAlpha {+ acs = append(acs, aAC)+ acStart = 6+ }+ acCount := 0+ for _, ac := range acs {+ acCount += len(ac)+ }++ hash := make([]byte, acStart+(acCount+1)/2)+ hash[0] = byte(header24 & 255)+ hash[1] = byte((header24 >> 8) & 255)+ hash[2] = byte(header24 >> 16)+ hash[3] = byte(header16 & 255)+ hash[4] = byte(header16 >> 8)+ if hasAlpha {+ hash[5] = byte(int(math.Round(15*aDC)) | int(math.Round(15*aScale))<<4)+ }+ acIndex := 0+ for _, ac := range acs {+ for _, f := range ac {+ hash[acStart+(acIndex>>1)] |= byte(int(math.Round(15*f)) << ((acIndex & 1) << 2))+ acIndex+++ }+ }+ return hash+}++// NRGBA, not RGBA: ThumbHash requires non-premultiplied RGB and the pipeline hands us a+// premultiplied *image.RGBA, which draw.Draw un-premultiplies on the way in.+func toNRGBA(img image.Image) *image.NRGBA {+ // Conservative: a sub-image re-slices Pix so the loops would read it correctly too, but the+ // copy costs nothing on the origin-anchored images the pipeline actually produces.+ if nrgba, ok := img.(*image.NRGBA); ok && nrgba.Rect.Min == (image.Point{}) {+ return nrgba+ }+ b := img.Bounds()+ dst := image.NewNRGBA(image.Rect(0, 0, b.Dx(), b.Dy()))+ draw.Draw(dst, dst.Bounds(), img, b.Min, draw.Src)+ return dst+}++func downscale(img image.Image) image.Image {+ b := img.Bounds()+ w, h := b.Dx(), b.Dy()+ if w <= maxInputSize && h <= maxInputSize {+ return img+ }+ scale := float64(maxInputSize) / float64(max(w, h))+ dst := image.NewNRGBA(image.Rect(0, 0, max(1, int(float64(w)*scale)), max(1, int(float64(h)*scale))))+ xdraw.ApproxBiLinear.Scale(dst, dst.Bounds(), img, b, draw.Src, nil)+ return dst+}diff --git a/core/artwork/thumbhash/thumbhash_suite_test.go b/core/artwork/thumbhash/thumbhash_suite_test.gonew file mode 100644index 000000000..11a6f0e25--- /dev/null+++ b/core/artwork/thumbhash/thumbhash_suite_test.go@@ -0,0 +1,17 @@+package thumbhash_test++import (+ "testing"++ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++func TestThumbHash(t *testing.T) {+ tests.Init(t, false)+ log.SetLevel(log.LevelFatal)+ RegisterFailHandler(Fail)+ RunSpecs(t, "ThumbHash Suite")+}diff --git a/core/artwork/thumbhash/thumbhash_test.go b/core/artwork/thumbhash/thumbhash_test.gonew file mode 100644index 000000000..4832c25bc--- /dev/null+++ b/core/artwork/thumbhash/thumbhash_test.go@@ -0,0 +1,194 @@+package thumbhash_test++import (+ "encoding/base64"+ "encoding/json"+ "image"+ "image/color"+ "image/draw"+ _ "image/png"+ "os"+ "path/filepath"+ "runtime"+ "slices"++ "github.com/navidrome/navidrome/core/artwork/thumbhash"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++// testdataDir is resolved via runtime.Caller because tests.Init (thumbhash_suite_test.go) chdirs+// the process to the repo root, which would break a plain relative "testdata" path.+var testdataDir = func() string {+ _, file, _, _ := runtime.Caller(0)+ return filepath.Join(filepath.Dir(file), "testdata")+}()++// fixtureImage decodes a testdata PNG. NRGBA, not RGBA: ThumbHash needs non-premultiplied pixels,+// and RGBA would silently premultiply every fixture that has alpha.+func fixtureImage(name string) *image.NRGBA {+ GinkgoHelper()+ f, err := os.Open(filepath.Join(testdataDir, name))+ Expect(err).ToNot(HaveOccurred())+ defer f.Close()+ src, _, err := image.Decode(f)+ Expect(err).ToNot(HaveOccurred())+ b := src.Bounds()+ dst := image.NewNRGBA(image.Rect(0, 0, b.Dx(), b.Dy()))+ draw.Draw(dst, dst.Bounds(), src, b.Min, draw.Src)+ return dst+}++// headerOnlyFixtures have mathematically-zero AC content, so every AC nibble is float rounding+// noise sitting on a quantization tie; only the header bytes carry signal.+var headerOnlyFixtures = []string{"solid.png", "tiny.png"}++func loadJSON[T any](name string) T {+ GinkgoHelper()+ data, err := os.ReadFile(filepath.Join(testdataDir, name))+ Expect(err).ToNot(HaveOccurred())+ var out T+ Expect(json.Unmarshal(data, &out)).To(Succeed())+ return out+}++func loadGoldens() map[string]string {+ GinkgoHelper()+ golden := loadJSON[map[string]string]("golden.json")+ Expect(golden).ToNot(BeEmpty())+ return golden+}++// mix is a stateless 32-bit finaliser matching gen_generated.mjs, so both languages build the+// same synthetic pixels and only the reference's hashes need committing.+func mix(n uint32) uint32 {+ n = (n ^ (n >> 16)) * 2246822507+ n = (n ^ (n >> 13)) * 3266489909+ return n ^ (n >> 16)+}++func generatedImage(i int) *image.NRGBA {+ w := 1 + int(mix(uint32(i)*3+1)%100)+ h := 1 + int(mix(uint32(i)*3+2)%100)+ img := image.NewNRGBA(image.Rect(0, 0, w, h))+ for k := range img.Pix {+ img.Pix[k] = byte(mix(uint32(i)*1000003 + uint32(k)))+ }+ if i%2 == 0 {+ for k := 3; k < len(img.Pix); k += 4 {+ img.Pix[k] = 255+ }+ }+ return img+}++var _ = Describe("Encode", func() {+ It("matches every golden vector", func() {+ for name, want := range loadGoldens() {+ if slices.Contains(headerOnlyFixtures, name) {+ continue // see the dedicated header-only spec below+ }+ got, err := thumbhash.Encode(fixtureImage(name))+ Expect(err).ToNot(HaveOccurred(), "fixture %s", name)+ Expect(base64.StdEncoding.EncodeToString(got)).To(Equal(want), "fixture %s", name)+ }+ })++ It("reproduces the well-conditioned header of the ill-conditioned fixtures", func() {+ for _, name := range headerOnlyFixtures {+ want, err := base64.StdEncoding.DecodeString(loadGoldens()[name])+ Expect(err).ToNot(HaveOccurred(), "fixture %s", name)+ got, err := thumbhash.Encode(fixtureImage(name))+ Expect(err).ToNot(HaveOccurred(), "fixture %s", name)+ Expect(got[:5]).To(Equal(want[:5]), "fixture %s header bytes", name)+ }+ })++ // The PNG fixtures cannot reach every layout; these sweep random sizes, aspects and both the+ // 7x7 no-alpha and 5x5-plus-alpha coefficient regions against the same reference.+ It("matches the reference on 300 generated images", func() {+ vectors := loadJSON[[]struct {+ W, H int+ Hash string+ }]("generated.json")+ Expect(vectors).ToNot(BeEmpty())+ for i, want := range vectors {+ img := generatedImage(i)+ Expect(img.Bounds().Dx()).To(Equal(want.W), "vector %d width", i)+ Expect(img.Bounds().Dy()).To(Equal(want.H), "vector %d height", i)+ got, err := thumbhash.Encode(img)+ Expect(err).ToNot(HaveOccurred(), "vector %d", i)+ Expect(base64.StdEncoding.EncodeToString(got)).To(Equal(want.Hash), "vector %d (%dx%d)", i, want.W, want.H)+ }+ })++ It("quantizes a uniform image's scales to zero", func() {+ got, err := thumbhash.Encode(fixtureImage("solid.png"))+ Expect(err).ToNot(HaveOccurred())+ header24 := int(got[0]) | int(got[1])<<8 | int(got[2])<<16+ header16 := int(got[3]) | int(got[4])<<8+ Expect((header24>>18)&31).To(Equal(0), "lScale")+ Expect((header16>>3)&63).To(Equal(0), "pScale")+ Expect((header16>>9)&63).To(Equal(0), "qScale")+ })++ It("produces 24 bytes for a square opaque image", func() {+ got, err := thumbhash.Encode(fixtureImage("square.png"))+ Expect(err).ToNot(HaveOccurred())+ Expect(got).To(HaveLen(24))+ })++ It("produces 25 bytes when the image has alpha", func() {+ got, err := thumbhash.Encode(fixtureImage("alpha.png"))+ Expect(err).ToNot(HaveOccurred())+ Expect(got).To(HaveLen(25))+ })++ It("downscales an oversized image rather than failing", func() {+ img := image.NewNRGBA(image.Rect(0, 0, 500, 300))+ for i := range img.Pix {+ img.Pix[i] = byte(i)+ }+ got, err := thumbhash.Encode(img)+ Expect(err).ToNot(HaveOccurred())+ Expect(len(got)).To(BeNumerically(">=", 5))+ })++ It("encodes a 1x1 image", func() {+ img := image.NewNRGBA(image.Rect(0, 0, 1, 1))+ img.Set(0, 0, color.NRGBA{R: 60, G: 120, B: 180, A: 255})+ got, err := thumbhash.Encode(img)+ Expect(err).ToNot(HaveOccurred())+ Expect(got).ToNot(BeEmpty())+ })++ It("encodes a sub-image like an origin-anchored copy of the same region", func() {+ parent := image.NewNRGBA(image.Rect(0, 0, 60, 50))+ for i := range parent.Pix {+ parent.Pix[i] = byte(i * 7 % 251)+ }+ region := image.Rect(10, 7, 40, 30)+ cropped := image.NewNRGBA(image.Rect(0, 0, region.Dx(), region.Dy()))+ draw.Draw(cropped, cropped.Bounds(), parent, region.Min, draw.Src)++ got, err := thumbhash.Encode(parent.SubImage(region))+ Expect(err).ToNot(HaveOccurred())+ want, err := thumbhash.Encode(cropped)+ Expect(err).ToNot(HaveOccurred())+ Expect(got).To(Equal(want))+ })++ It("rejects an empty image", func() {+ _, err := thumbhash.Encode(image.NewRGBA(image.Rect(0, 0, 0, 0)))+ Expect(err).To(HaveOccurred())+ })++ It("is deterministic", func() {+ img := fixtureImage("square.png")+ first, err := thumbhash.Encode(img)+ Expect(err).ToNot(HaveOccurred())+ second, err := thumbhash.Encode(img)+ Expect(err).ToNot(HaveOccurred())+ Expect(first).To(Equal(second))+ })+})diff --git a/core/image_upload.go b/core/artwork/uploader.gosimilarity index 55%rename from core/image_upload.gorename to core/artwork/uploader.goindex eb61b225a..9c38ae2e5 100644--- a/core/image_upload.go+++ b/core/artwork/uploader.go@@ -1,4 +1,4 @@-package core+package artworkimport ("context"@@ -15,13 +15,7 @@ import ("github.com/navidrome/navidrome/utils")-type ImageUploadService interface {- SetImage(ctx context.Context, entityType string, entityID string, name string, oldPath string, reader io.Reader, ext string) (filename string, err error)- RemoveImage(ctx context.Context, path string) error-}--// MaxImageUploadSize returns the configured MaxImageUploadSize in bytes, or the built-in default-// when it's unset/invalid. Shared by every API that accepts image uploads.+// MaxImageUploadSize returns the configured max upload size in bytes, or the built-in default.func MaxImageUploadSize() int64 {if size, err := humanize.ParseBytes(conf.Server.MaxImageUploadSize); err == nil && size > 0 {return int64(size)@@ -30,13 +24,30 @@ func MaxImageUploadSize() int64 {return int64(size)}-type imageUploadService struct{}+// Uploader stores a user-uploaded entity image and invalidates that entity's artwork state.+type Uploader interface {+ SetImage(ctx context.Context, entityType string, entityID string, name string, oldPath string, reader io.Reader, ext string) (filename string, err error)+ RemoveImage(ctx context.Context, path string) error+ // EnqueueArtwork re-resolves the item's artwork. Call it AFTER persisting the new+ // filename, or the worker resolves the old one.+ EnqueueArtwork(ctx context.Context, entityType, entityID string)+}++var uploadEntityKind = map[string]model.Kind{+ consts.EntityArtist: model.KindArtistArtwork,+ consts.EntityPlaylist: model.KindPlaylistArtwork,+ consts.EntityRadio: model.KindRadioArtwork,+}++type uploader struct {+ ds model.DataStore+}-func NewImageUploadService() ImageUploadService {- return &imageUploadService{}+func NewUploader(ds model.DataStore) Uploader {+ return &uploader{ds: ds}}-func (s *imageUploadService) SetImage(ctx context.Context, entityType string, entityID string, name string, oldPath string, reader io.Reader, ext string) (string, error) {+func (s *uploader) SetImage(ctx context.Context, entityType string, entityID string, name string, oldPath string, reader io.Reader, ext string) (string, error) {filename := imageFilename(entityID, name, ext)absPath := model.UploadedImagePath(entityType, filename)@@ -44,14 +55,12 @@ func (s *imageUploadService) SetImage(ctx context.Context, entityType string, enreturn "", fmt.Errorf("creating image directory: %w", err)}- // Remove old image if it existsif oldPath != "" {if err := os.Remove(oldPath); err != nil && !os.IsNotExist(err) {- log.Warn(ctx, "Failed to remove old image", "path", oldPath, err)+ log.Warn(ctx, "Artwork: Failed to remove old image", "path", oldPath, err)}}- // Save new imagef, err := os.Create(absPath)if err != nil {return "", fmt.Errorf("creating image file: %w", err)@@ -61,11 +70,20 @@ func (s *imageUploadService) SetImage(ctx context.Context, entityType string, enif _, err := io.Copy(f, reader); err != nil {return "", fmt.Errorf("writing image file: %w", err)}-return filename, nil}-func (s *imageUploadService) RemoveImage(ctx context.Context, path string) error {+func (s *uploader) EnqueueArtwork(ctx context.Context, entityType, id string) {+ kind, ok := uploadEntityKind[entityType]+ if !ok {+ return+ }+ if err := Refresh(ctx, s.ds, kind, id); err != nil {+ log.Warn(ctx, "Artwork: Could not refresh artwork after upload", "kind", kind, "id", id, err)+ }+}++func (s *uploader) RemoveImage(ctx context.Context, path string) error {if path == "" {return nil}diff --git a/core/image_upload_test.go b/core/artwork/uploader_test.gosimilarity index 60%rename from core/image_upload_test.gorename to core/artwork/uploader_test.goindex e7648df34..44f5ede26 100644--- a/core/image_upload_test.go+++ b/core/artwork/uploader_test.go@@ -1,4 +1,4 @@-package core_test+package artworkimport ("context"@@ -9,20 +9,26 @@ import ("github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/conf/configtest""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/tests". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega")-var _ = Describe("ImageUploadService", func() {- var svc core.ImageUploadService+var _ = Describe("Uploader", func() {+ var svc Uploadervar tmpDir string+ var artRepo *tests.MockArtworkRepo+ var queueRepo *tests.MockArtworkQueueRepoBeforeEach(func() {DeferCleanup(configtest.SetupConfig())tmpDir = GinkgoT().TempDir()conf.Server.DataFolder = conf.NewDir(tmpDir)- svc = core.NewImageUploadService()+ artRepo = tests.CreateMockArtworkRepo()+ queueRepo = tests.CreateMockArtworkQueueRepo()+ ds := &tests.MockDataStore{MockedArtwork: artRepo, MockedArtworkQueue: queueRepo}+ svc = NewUploader(ds)})Describe("SetImage", func() {@@ -69,6 +75,49 @@ var _ = Describe("ImageUploadService", func() {_, err := svc.SetImage(ctx, consts.EntityArtist, "ar-1", "Name", "/nonexistent/path.jpg", reader, ".jpg")Expect(err).ToNot(HaveOccurred())})++ It("does not touch artwork state or the queue (that is EnqueueArtwork's job, post-Put)", func() {+ ctx := context.Background()+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{+ ItemKind: "ar", ItemID: "ar-1", Hash: "oldhash", Source: "external",+ })).To(Succeed())++ _, err := svc.SetImage(ctx, consts.EntityArtist, "ar-1", "Pink Floyd", "", strings.NewReader("img"), ".jpg")+ Expect(err).ToNot(HaveOccurred())++ // SetImage only writes the file; the state row survives and nothing is queued until+ // the caller has persisted the new filename and called EnqueueArtwork.+ _, err = artRepo.GetItemArtwork(model.KindArtistArtwork, "ar-1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(queueRepo.DequeueBatch(1000)).To(BeEmpty())+ })+ })++ Describe("EnqueueArtwork", func() {+ It("clears artwork state and enqueues a Bump", func() {+ ctx := context.Background()+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{+ ItemKind: "ar", ItemID: "ar-1", Hash: "oldhash", Source: "external",+ })).To(Succeed())++ svc.EnqueueArtwork(ctx, consts.EntityArtist, "ar-1")++ _, err := artRepo.GetItemArtwork(model.KindArtistArtwork, "ar-1", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))++ queued, err := queueRepo.DequeueBatch(1000)+ Expect(err).ToNot(HaveOccurred())+ Expect(queued).To(ContainElement(SatisfyAll(+ HaveField("ItemKind", "ar"),+ HaveField("ItemID", "ar-1"),+ HaveField("Priority", model.ArtworkPriorityBump),+ )))+ })++ It("is a no-op for an unknown entity type", func() {+ svc.EnqueueArtwork(context.Background(), "unknown", "x-1")+ Expect(queueRepo.DequeueBatch(1000)).To(BeEmpty())+ })})Describe("RemoveImage", func() {@@ -105,21 +154,21 @@ var _ = Describe("MaxImageUploadSize", func() {It("returns the configured size when valid", func() {conf.Server.MaxImageUploadSize = "20MB"- Expect(core.MaxImageUploadSize()).To(Equal(int64(20_000_000)))+ Expect(MaxImageUploadSize()).To(Equal(int64(20_000_000)))})It("returns the default size when config is empty", func() {conf.Server.MaxImageUploadSize = ""- Expect(core.MaxImageUploadSize()).To(Equal(int64(10_000_000)))+ Expect(MaxImageUploadSize()).To(Equal(int64(10_000_000)))})It("returns the default size when config is invalid", func() {conf.Server.MaxImageUploadSize = "not-a-size"- Expect(core.MaxImageUploadSize()).To(Equal(int64(10_000_000)))+ Expect(MaxImageUploadSize()).To(Equal(int64(10_000_000)))})It("parses raw byte values", func() {conf.Server.MaxImageUploadSize = "52428800"- Expect(core.MaxImageUploadSize()).To(Equal(int64(52_428_800)))+ Expect(MaxImageUploadSize()).To(Equal(int64(52_428_800)))})})diff --git a/core/artwork/wire_providers.go b/core/artwork/wire_providers.goindex 63231b54a..54c2ad397 100644--- a/core/artwork/wire_providers.go+++ b/core/artwork/wire_providers.go@@ -7,5 +7,7 @@ import (var Set = wire.NewSet(NewArtwork,GetImageCache,- NewCacheWarmer,+ NewWorker,+ GetImageStore,+ NewUploader,)diff --git a/core/artwork/worker.go b/core/artwork/worker.gonew file mode 100644index 000000000..3042c47b0--- /dev/null+++ b/core/artwork/worker.go@@ -0,0 +1,318 @@+package artwork++import (+ "bytes"+ "cmp"+ "context"+ "io"+ "math"+ "math/rand/v2"+ "sync"+ "time"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/core/auth"+ "github.com/navidrome/navidrome/core/ffmpeg"+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/server/events"+ "github.com/navidrome/navidrome/utils/cache"+)++const (+ workerPollInterval = 5 * time.Second+ backoffBase = 5 * time.Second+ // giveUpAfter bounds the retry budget from enqueue; past it the item falls to the+ // periodic stale-absent recheck.+ giveUpAfter = 12 * time.Hour+)++// drainPool drains one class of work with its own slot budget, so a blocking kind cannot+// occupy slots another kind needs.+type drainPool struct {+ name string+ kinds []string+ concurrency int+}++// Worker drains the artwork queue: each external agent is rate-limited and circuit-broken+// independently, and pruneMu serializes prune against the store-write window.+type Worker struct {+ proc *processor+ cache cache.FileCache+ ffmpeg ffmpeg.FFmpeg+ broker events.Broker+ pruneMu sync.RWMutex+ pools []*drainPool+ runCtx context.Context++ gatesMu sync.Mutex+ gates map[string]*extGate+}++func NewWorker(ds model.DataStore, store *ImageStore, ag *agents.Agents, ffmpeg ffmpeg.FFmpeg, broker events.Broker, imgCache cache.FileCache) *Worker {+ w := &Worker{+ proc: &processor{ds: ds, store: store},+ cache: imgCache,+ ffmpeg: ffmpeg,+ broker: broker,+ pools: newDrainPools(),+ runCtx: context.Background(),+ gates: map[string]*extGate{},+ }+ w.proc.resolver = newResolver(ds, ag, ffmpeg, w.gate)+ w.proc.pruneLock = w.pruneMu.RLocker()+ return w+}++// newDrainPools splits the drain by what bounds it: gate() holds a slot while waiting for its+// rate-limit permit, so a sleeping lookup would crowd out a cover sitting on disk.+func newDrainPools() []*drainPool {+ budget := conf.MaxOpenConns() // floored at 4, so both remainders below stay positive+ local := min(max(1, conf.Server.DevArtworkWorkerConcurrency), budget-1)+ // More external slots than the rate allows would only sleep in the limiter.+ external := min(max(2, 2*conf.Server.DevArtworkExternalMaxRPS), budget-local)+ return []*drainPool{+ {name: "local", kinds: localDrainKinds, concurrency: local},+ {name: "external", kinds: externalDrainKinds, concurrency: external},+ }+}++// Kind is a proxy for cost: an album that reaches an external agent still costs a local slot.+var (+ externalDrainKinds = []string{model.KindArtistArtwork.Prefix()}+ localDrainKinds = []string{+ model.KindAlbumArtwork.Prefix(),+ model.KindPlaylistArtwork.Prefix(),+ model.KindRadioArtwork.Prefix(),+ model.KindMediaFileArtwork.Prefix(),+ }+)++// Run blocks draining the queue until ctx is cancelled.+func (w *Worker) Run(ctx context.Context) error {+ w.runCtx = ctx+ var wg sync.WaitGroup+ for _, p := range w.pools {+ wg.Go(func() { w.runPool(ctx, p) })+ }+ wg.Wait()+ return nil+}++func (w *Worker) runPool(ctx context.Context, p *drainPool) {+ ticker := time.NewTicker(workerPollInterval)+ defer ticker.Stop()+ for {+ n, err := w.drain(ctx, p.concurrency, p.kinds...)+ if err != nil && ctx.Err() == nil {+ log.Warn(ctx, "Artwork: Worker drain failed", "pool", p.name, err)+ }+ if ctx.Err() != nil {+ return+ }+ if n > 0 {+ continue+ }+ select {+ case <-ctx.Done():+ return+ case <-ticker.C:+ }+ }+}++// RunPrune runs prune under the worker's write lock, so no acquisition can place+// a file while orphans are being reclaimed. This is the only sanctioned prune path.+func (w *Worker) RunPrune(ctx context.Context) error {+ w.pruneMu.Lock()+ defer w.pruneMu.Unlock()+ return prune(ctx, w.proc.ds, w.proc.store)+}++// Backfill enqueues every entity for re-resolution when the artwork config fingerprint changed,+// artists first. It reports whether anything was enqueued.+func (w *Worker) Backfill(ctx context.Context) (bool, error) {+ return backfill(ctx, w.proc.ds)+}++// EnqueueStaleAbsentAll requeues known-absent entries older than staleAbsentAge.+func (w *Worker) EnqueueStaleAbsentAll(ctx context.Context) error {+ return enqueueStaleAbsentAll(ctx, w.proc.ds)+}++// EnqueueMissingAll requeues entities with no artwork state row: the safety net for anything+// a scan never enqueued.+func (w *Worker) EnqueueMissingAll(ctx context.Context) error {+ return enqueueMissingAll(ctx, w.proc.ds)+}++func (w *Worker) drain(ctx context.Context, concurrency int, kinds ...string) (int, error) {+ // Dequeue well past the pool size so a slow external lookup never idles the other slots.+ // DequeueBatch does not mark rows taken, so this is one query per pass, not per slot.+ items, err := w.proc.ds.ArtworkQueue(ctx).DequeueBatch(max(16, 4*concurrency), kinds...)+ if err != nil {+ return 0, err+ }+ if len(items) == 0 {+ return 0, nil+ }+ drainStart := time.Now()+ // Private playlists need an admin identity; resolved per drain because the worker can+ // start before any admin exists.+ ctx = auth.WithAdminUser(ctx, w.proc.ds)+ sem := make(chan struct{}, concurrency)+ var wg sync.WaitGroup+ var refreshMu sync.Mutex+ var refresh []model.ArtworkQueueItem+ for _, item := range items {+ select {+ case sem <- struct{}{}:+ case <-ctx.Done():+ wg.Wait()+ return len(items), nil+ }+ wg.Go(func() {+ defer func() { <-sem }()+ out, got := w.process(ctx, item)+ // Absent counts as a visible change too: clients must drop a previously-served+ // immutable cover.+ if out == outcomeFound || out == outcomeFoundStale || out == outcomeAbsent {+ refreshMu.Lock()+ refresh = append(refresh, item)+ refreshMu.Unlock()+ }+ // Post-outcome: the queue row is already settled, so warming the cache can't+ // block or alter queue ops.+ if got != nil {+ w.precache(ctx, got)+ }+ })+ }+ wg.Wait()+ w.broadcastRefresh(ctx, refresh)+ log.Debug(ctx, "Artwork: Drained a batch", "kinds", kinds, "items", len(items),+ "refreshed", len(refresh), "concurrency", concurrency, "elapsed", time.Since(drainStart))+ return len(items), nil+}++// artworkKindToResource maps a kind to its UI resource name; media_file maps to "song", so+// this can't derive from Kind.String().+var artworkKindToResource = map[model.Kind]string{+ model.KindAlbumArtwork: "album",+ model.KindArtistArtwork: "artist",+ model.KindPlaylistArtwork: "playlist",+ model.KindRadioArtwork: "radio",+ model.KindMediaFileArtwork: "song",+}++// broadcastRefresh emits one coalesced RefreshResource for the batch, so UIs re-fetch the+// affected records and pick up the new coverArt id.+func (w *Worker) broadcastRefresh(ctx context.Context, found []model.ArtworkQueueItem) {+ if len(found) == 0 {+ return+ }+ event := &events.RefreshResource{}+ byResource := map[string][]string{}+ for _, it := range found {+ kind, _ := model.ParseKind(it.ItemKind)+ if res, ok := artworkKindToResource[kind]; ok {+ byResource[res] = append(byResource[res], it.ItemID)+ }+ }+ if len(byResource) == 0 {+ return+ }+ for res, ids := range byResource {+ event = event.With(res, ids...)+ }+ w.broker.SendBroadcastMessage(ctx, event)+}++func (w *Worker) process(ctx context.Context, item model.ArtworkQueueItem) (outcome, *acquired) {+ item.ImageType = cmp.Or(item.ImageType, model.ImageTypePrimary)+ out, got := w.proc.acquire(ctx, item)++ queue := w.proc.ds.ArtworkQueue(ctx)+ switch out {+ case outcomeFound, outcomeAbsent:+ // A scan that re-enqueued this row mid-flight reset its retry_at, so the row survives+ // here and the next drain re-resolves it.+ if err := queue.DeleteIfUnchanged(item.ItemKind, item.ItemID, item.ImageType, item.RetryAt); err != nil {+ log.Warn(ctx, "Artwork: Could not delete processed queue item", "kind", item.ItemKind, "id", item.ItemID, err)+ }+ case outcomeFoundStale, outcomeFailed:+ retryAt := time.Now().Add(backoff(item.Attempts))+ if retryAt.Before(item.EnqueuedAt.Add(giveUpAfter)) {+ // A mid-flight re-enqueue reset retry_at; stale backoff must not stomp its+ // fresh, immediate eligibility.+ if err := queue.MarkFailedIfUnchanged(item.ItemKind, item.ItemID, item.ImageType, item.RetryAt, retryAt); err != nil {+ log.Warn(ctx, "Artwork: Could not reschedule failed queue item", "kind", item.ItemKind, "id", item.ItemID, err)+ }+ log.Debug(ctx, "Artwork: Rescheduled item", "kind", item.ItemKind, "id", item.ItemID,+ "outcome", out, "attempts", item.Attempts+1, "retryIn", time.Until(retryAt),+ "budgetLeft", time.Until(item.EnqueuedAt.Add(giveUpAfter)))+ break+ }+ // Absent is only recoverable where a periodic recheck revisits it, so other kinds keep+ // no row; art already being served is kept, as exhaustion means unreachable, not removed.+ settled := "kept previous state"+ if out == outcomeFailed && hasRecheckPath(item.ItemKind) && !w.hasResolvedArtwork(ctx, item) {+ writeAbsent(ctx, w.proc.ds.Artwork(ctx), item)+ settled = "recorded absent"+ }+ log.Info(ctx, "Artwork: Retry budget exhausted, giving up", "kind", item.ItemKind, "id", item.ItemID,+ "outcome", out, "attempts", item.Attempts+1, "budget", giveUpAfter, "settled", settled)+ if err := queue.DeleteIfUnchanged(item.ItemKind, item.ItemID, item.ImageType, item.RetryAt); err != nil {+ log.Warn(ctx, "Artwork: Could not remove exhausted queue item", "kind", item.ItemKind, "id", item.ItemID, err)+ }+ }+ return out, got+}++func (w *Worker) hasResolvedArtwork(ctx context.Context, item model.ArtworkQueueItem) bool {+ kind, ok := model.ParseKind(item.ItemKind)+ if !ok {+ return false+ }+ ia, err := w.proc.ds.Artwork(ctx).GetItemArtwork(kind, item.ItemID, item.ImageType)+ return err == nil && ia.Hash != ""+}++// precache warms the resize cache at the UI cover size from the bytes just acquired, so the+// first UI request hits without re-reading the rows or the file.+func (w *Worker) precache(ctx context.Context, got *acquired) {+ if !conf.Server.EnableArtworkPrecache || w.cache == nil || w.cache.Disabled(ctx) {+ return+ }+ precacheStart := time.Now()+ // Same key as the serving path: square must match what the list surfaces request, or this+ // warms a key nothing reads.+ item := &resizedItem{+ hash: got.ia.Hash,+ size: conf.Server.UICoverArtSize,+ square: true,+ ffmpeg: w.ffmpeg,+ open: func() (io.ReadCloser, error) { return io.NopCloser(bytes.NewReader(got.data)), nil },+ }+ stream, err := w.cache.Get(ctx, item)+ if err != nil {+ log.Debug(ctx, "Artwork: Precache failed", "kind", got.ia.ItemKind, "id", got.ia.ItemID, err)+ return+ }+ _, _ = io.Copy(io.Discard, stream)+ _ = stream.Close()+ log.Trace(ctx, "Artwork: Precached UI size", "kind", got.ia.ItemKind, "id", got.ia.ItemID,+ "size", conf.Server.UICoverArtSize, "elapsed", time.Since(precacheStart))+}++// backoffFor returns min(5s×4^n, giveUpAfter) scaled by (1+jitter), with jitter in [-0.4, 0.4].+func backoffFor(attempts int, jitter float64) time.Duration {+ d := min(float64(backoffBase)*math.Pow(4, float64(attempts)), float64(giveUpAfter))+ return time.Duration(d * (1 + jitter))+}++func backoff(attempts int) time.Duration {+ return backoffFor(attempts, rand.Float64()*0.8-0.4) //nolint:gosec // retry jitter, not security-sensitive+}diff --git a/core/artwork/worker_soak_test.go b/core/artwork/worker_soak_test.gonew file mode 100644index 000000000..eb7346102--- /dev/null+++ b/core/artwork/worker_soak_test.go@@ -0,0 +1,146 @@+package artwork++import (+ "context"+ "io"+ "os"+ "runtime"+ "testing"+ "time"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++// Deliberately >2000: a leak guard favors a stable signal over speed.+const soakCycles = 2200++var _ = Describe("Worker soak", func() {+ It("does not leak goroutines, heap, or fds over many acquisition cycles", func() {+ if testing.Short() {+ Skip("skipping soak test in short mode")+ }+ DeferCleanup(configtest.SetupConfig())++ repoRoot, err := os.Getwd()+ Expect(err).ToNot(HaveOccurred())++ libRepo := &tests.MockLibraryRepo{}+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})+ folderRepo := &fakeFolderRepo{result: []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}}+ ffm := tests.NewMockFFmpeg("")+ ag := agents.GetAgents(&tests.MockDataStore{}, nil)+ artRepo := tests.CreateMockArtworkRepo()+ albumRepo := tests.CreateMockAlbumRepo()+ albumRepo.SetData(model.Albums{+ {ID: "al-folder", Name: "Folder Album", FolderIDs: []string{"f1"}},+ {ID: "al-embed", Name: "Embedded Album", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}},+ })+ ds := &tests.MockDataStore{+ MockedFolder: folderRepo,+ MockedLibrary: libRepo,+ MockedArtwork: artRepo,+ MockedAlbum: albumRepo,+ }+ store := NewImageStore(GinkgoT().TempDir())+ proc := &processor{ds: ds, store: store, resolver: newResolver(ds, ag, ffm, nil)}+ conf.Server.CoverArtPriority = "cover.jpg, embedded"++ // Dangling refs mirror an entity deleted after being enqueued.+ items := []model.ArtworkQueueItem{+ {ItemKind: "al", ItemID: "al-folder"},+ {ItemKind: "al", ItemID: "al-embed"},+ {ItemKind: "al", ItemID: "al-does-not-exist"},+ {ItemKind: "ra", ItemID: "ra-does-not-exist"},+ }++ fdCount := func() int {+ if runtime.GOOS != "linux" {+ return -1+ }+ entries, err := os.ReadDir("/proc/self/fd")+ if err != nil {+ return -1+ }+ return len(entries)+ }++ settleGoroutines := func() int {+ // Background goroutines wind down late, so poll for two consecutive equal samples.+ prev := -1+ for range 100 {+ runtime.GC()+ n := runtime.NumGoroutine()+ if n == prev {+ return n+ }+ prev = n+ time.Sleep(10 * time.Millisecond)+ }+ return prev+ }++ baselineGoroutines := settleGoroutines()+ baselineFDs := fdCount()++ var heapAt10Pct uint64+ start := time.Now()+ for i := range soakCycles {+ it := items[i%len(items)]+ out, _ := proc.acquire(context.Background(), it)++ // Read-back exercises the surfaces a caller would use after acquisition.+ if out == outcomeFound {+ kind, _ := model.ParseKind(it.ItemKind)+ ia, err := artRepo.GetItemArtwork(kind, it.ItemID, model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred(), "cycle %d: GetItemArtwork", i)+ art, err := artRepo.GetImage(ia.Hash)+ Expect(err).ToNot(HaveOccurred(), "cycle %d: GetImage", i)+ rc, err := store.Open(ia.Hash, art.Mime)+ switch {+ case err == nil:+ _, _ = io.Copy(io.Discard, rc)+ rc.Close()+ case os.IsNotExist(err):+ // Folder-backed art has no store file; that's expected.+ default:+ Expect(err).ToNot(HaveOccurred(), "cycle %d: store.Open", i)+ }+ }++ if i == soakCycles/10 {+ runtime.GC()+ var ms runtime.MemStats+ runtime.ReadMemStats(&ms)+ heapAt10Pct = ms.HeapAlloc+ }+ }+ elapsed := time.Since(start)++ finalGoroutines := settleGoroutines()+ finalFDs := fdCount()++ runtime.GC()+ var ms runtime.MemStats+ runtime.ReadMemStats(&ms)++ GinkgoWriter.Printf("soak: cycles=%d elapsed=%s goroutines(baseline=%d final=%d) heap(10%%-mark=%d final=%d) fds(baseline=%d final=%d)\n",+ soakCycles, elapsed, baselineGoroutines, finalGoroutines, heapAt10Pct, ms.HeapAlloc, baselineFDs, finalFDs)++ Expect(finalGoroutines).To(BeNumerically("<=", baselineGoroutines), "goroutine count grew: baseline=%d final=%d", baselineGoroutines, finalGoroutines)+ if heapAt10Pct > 0 {+ Expect(ms.HeapAlloc).To(BeNumerically("<=", 2*heapAt10Pct), "heap did not plateau: 10%%-mark=%d final=%d (final > 2x 10%%-mark)", heapAt10Pct, ms.HeapAlloc)+ }+ if runtime.GOOS == "linux" && baselineFDs >= 0 {+ Expect(finalFDs).To(BeNumerically("<=", baselineFDs), "fd count grew: baseline=%d final=%d", baselineFDs, finalFDs)+ }+ })+})diff --git a/core/artwork/worker_test.go b/core/artwork/worker_test.gonew file mode 100644index 000000000..1f3b52840--- /dev/null+++ b/core/artwork/worker_test.go@@ -0,0 +1,813 @@+package artwork++import (+ "context"+ "errors"+ "fmt"+ "io"+ "net/http"+ "os"+ "slices"+ "sync"+ "time"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/server/events"+ "github.com/navidrome/navidrome/tests"+ "github.com/navidrome/navidrome/utils/cache"+ "github.com/navidrome/navidrome/utils/slice"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+ "go.uber.org/goleak"+)++type recordingCache struct {+ cache.FileCache+ mu sync.Mutex+ keys []string+ disabled bool+}++func (c *recordingCache) Disabled(ctx context.Context) bool {+ return c.disabled || c.FileCache.Disabled(ctx)+}++func (c *recordingCache) Get(ctx context.Context, arg cache.Item) (*cache.CachedStream, error) {+ c.mu.Lock()+ c.keys = append(c.keys, arg.Key())+ c.mu.Unlock()+ return c.FileCache.Get(ctx, arg)+}++func (c *recordingCache) getKeys() []string {+ c.mu.Lock()+ defer c.mu.Unlock()+ return slices.Clone(c.keys)+}++// Simulates a concurrent Enqueue between DequeueBatch and the worker's delete, so+// DeleteIfUnchanged on the dequeued value no-ops.+type reenqueueOnDequeue struct {+ *tests.MockArtworkQueueRepo+ done bool+}++func (r *reenqueueOnDequeue) DequeueBatch(n int, kinds ...string) ([]model.ArtworkQueueItem, error) {+ items, err := r.MockArtworkQueueRepo.DequeueBatch(n, kinds...)+ if !r.done && len(items) > 0 {+ r.done = true+ for k, it := range r.Data {+ if it.ItemKind == items[0].ItemKind && it.ItemID == items[0].ItemID {+ it.RetryAt = items[0].RetryAt.Add(time.Minute)+ r.Data[k] = it+ }+ }+ }+ return items, err+}++type fakeEventBroker struct {+ http.Handler+ mu sync.Mutex+ events []events.Event+}++func (f *fakeEventBroker) SendMessage(_ context.Context, event events.Event) {+ f.mu.Lock()+ defer f.mu.Unlock()+ f.events = append(f.events, event)+}++func (f *fakeEventBroker) SendBroadcastMessage(_ context.Context, event events.Event) {+ f.mu.Lock()+ defer f.mu.Unlock()+ f.events = append(f.events, event)+}++func (f *fakeEventBroker) getEvents() []events.Event {+ f.mu.Lock()+ defer f.mu.Unlock()+ return slices.Clone(f.events)+}++var _ events.Broker = (*fakeEventBroker)(nil)++func findQueued(q *tests.MockArtworkQueueRepo, kind, id string) *model.ArtworkQueueItem {+ for _, it := range q.Data {+ if it.ItemKind == kind && it.ItemID == id {+ return &it+ }+ }+ return nil+}++var _ = Describe("Worker", func() {+ var (+ ctx context.Context+ ds *tests.MockDataStore+ folderRepo *fakeFolderRepo+ libRepo *tests.MockLibraryRepo+ ffm *tests.MockFFmpeg+ ag *agents.Agents+ store *ImageStore+ artRepo *tests.MockArtworkRepo+ queueRepo *tests.MockArtworkQueueRepo+ broker *fakeEventBroker+ imgCache *recordingCache+ repoRoot string+ w *Worker+ )++ BeforeEach(func() {+ DeferCleanup(configtest.SetupConfig())+ ctx = context.Background()+ var err error+ repoRoot, err = os.Getwd()+ Expect(err).ToNot(HaveOccurred())+ conf.Server.CacheFolder = conf.NewDir(GinkgoT().TempDir())++ folderRepo = &fakeFolderRepo{}+ libRepo = &tests.MockLibraryRepo{}+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})+ ffm = tests.NewMockFFmpeg("")+ ag = agents.GetAgents(&tests.MockDataStore{}, nil)+ artRepo = tests.CreateMockArtworkRepo()+ queueRepo = tests.CreateMockArtworkQueueRepo()+ ds = &tests.MockDataStore{+ MockedFolder: folderRepo,+ MockedLibrary: libRepo,+ MockedArtwork: artRepo,+ MockedArtworkQueue: queueRepo,+ }+ ds.MockedAlbum = tests.CreateMockAlbumRepo()+ store = NewImageStore(GinkgoT().TempDir())+ conf.Server.CoverArtPriority = "cover.jpg, embedded"+ conf.Server.DevArtworkExternalMaxRPS = 1000 // keep the limiter out of the way of behavior tests+ broker = &fakeEventBroker{}+ imgCache = &recordingCache{FileCache: cache.NewFileCache("WorkerTest", "100MB", "images", 0,+ func(ctx context.Context, arg cache.Item) (io.Reader, error) {+ return arg.(artworkReader).Reader(ctx)+ })}+ Eventually(func() bool { return imgCache.Available(ctx) }).Should(BeTrue())+ w = NewWorker(ds, store, ag, ffm, broker, imgCache)+ })++ Describe("drain", func() {+ It("processes a seeded queue item and removes it from the queue", func() {+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al1", Name: "Album", FolderIDs: []string{"f1"}},+ })+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{+ ItemKind: "al", ItemID: "al1", Priority: model.ArtworkPriorityScan,+ })).To(Succeed())++ n, err := w.drain(ctx, 2)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("folder"))++ count, err := queueRepo.Count()+ Expect(err).ToNot(HaveOccurred())+ Expect(count).To(BeZero(), "a found item must be deleted from the queue")+ })++ It("processes an mf queue item, writing state and storing embedded bytes", func() {+ conf.Server.EnableMediaFileCoverArt = true+ ds.MockedMediaFile = tests.CreateMockMediaFileRepo()+ ds.MockedMediaFile.(*tests.MockMediaFileRepo).SetData(model.MediaFiles{+ {ID: "mf1", LibraryID: 0, Path: "tests/fixtures/artist/an-album/test.mp3", HasCoverArt: true},+ })+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{+ ItemKind: "mf", ItemID: "mf1", Priority: model.ArtworkPriorityBump,+ })).To(Succeed())++ n, err := w.drain(ctx, 2)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ ia, err := artRepo.GetItemArtwork(model.KindMediaFileArtwork, "mf1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("embedded"))+ Expect(ia.Hash).ToNot(BeEmpty())++ art, err := artRepo.GetImage(ia.Hash)+ Expect(err).ToNot(HaveOccurred())+ r, err := store.Open(ia.Hash, art.Mime)+ Expect(err).ToNot(HaveOccurred())+ defer r.Close()+ data, err := io.ReadAll(r)+ Expect(err).ToNot(HaveOccurred())+ Expect(data).ToNot(BeEmpty(), "embedded bytes must be written to the store")++ count, err := queueRepo.Count()+ Expect(err).ToNot(HaveOccurred())+ Expect(count).To(BeZero())+ })++ It("reschedules a failed item via MarkFailed with a backed-off retry_at", func() {+ conf.Server.CoverArtPriority = "external"+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "al4", Name: "Album"}})+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al4"})).To(Succeed())++ n, err := w.drain(ctx, 2)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ it := findQueued(queueRepo, "al", "al4")+ Expect(it).ToNot(BeNil())+ Expect(it.Attempts).To(Equal(1))+ Expect(it.RetryAt).To(BeTemporally(">", time.Now()))++ _, err = artRepo.GetItemArtwork(model.KindAlbumArtwork, "al4", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound), "a timeout must never settle on absent")+ })++ It("reschedules a found-stale item via MarkFailed while keeping its served state", func() {+ conf.Server.CoverArtPriority = "external, cover.jpg"+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "alstale", Name: "Album", FolderIDs: []string{"f1"}},+ })+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "alstale"})).To(Succeed())++ n, err := w.drain(ctx, 2)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ it := findQueued(queueRepo, "al", "alstale")+ Expect(it).ToNot(BeNil(), "a found-stale row must survive for a higher-priority retry")+ Expect(it.Attempts).To(Equal(1))+ Expect(it.RetryAt).To(BeTemporally(">", time.Now()))++ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alstale", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("folder"), "the fallback art is served meanwhile")++ evts := broker.getEvents()+ Expect(evts).To(HaveLen(1), "the served fallback art must live-refresh the UI")+ Expect(evts[0].(*events.RefreshResource).Data(evts[0])).To(ContainSubstring("alstale"))+ })++ It("keeps a row re-enqueued between dequeue and delete", func() {+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al7", Name: "Album", FolderIDs: []string{"f1"}},+ })+ racing := &reenqueueOnDequeue{MockArtworkQueueRepo: queueRepo}+ ds.MockedArtworkQueue = racing+ w = NewWorker(ds, store, ag, ffm, broker, imgCache)+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{+ ItemKind: "al", ItemID: "al7", Priority: model.ArtworkPriorityScan,+ })).To(Succeed())++ n, err := w.drain(ctx, 1)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ // The concurrent re-enqueue changed retry_at, so the found-path delete was a no-op.+ Expect(findQueued(queueRepo, "al", "al7")).ToNot(BeNil())+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al7", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("folder"))+ })++ It("keeps a fresh re-enqueue ahead of a stale failure backoff", func() {+ conf.Server.CoverArtPriority = "external"+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "al8", Name: "Album"}})+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})+ racing := &reenqueueOnDequeue{MockArtworkQueueRepo: queueRepo}+ ds.MockedArtworkQueue = racing+ w = NewWorker(ds, store, ag, ffm, broker, imgCache)+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al8"})).To(Succeed())+ dequeued := findQueued(queueRepo, "al", "al8").RetryAt++ n, err := w.drain(ctx, 1)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ // The re-enqueue reset retry_at; the failure path must not stomp it nor bump attempts.+ it := findQueued(queueRepo, "al", "al8")+ Expect(it).ToNot(BeNil())+ Expect(it.Attempts).To(BeZero())+ Expect(it.RetryAt).To(BeTemporally("==", dequeued.Add(time.Minute)))+ })++ It("gives up and settles absent once the retry budget is exhausted", func() {+ conf.Server.CoverArtPriority = "external"+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "al9", Name: "Album"}})+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})+ w = NewWorker(ds, store, ag, ffm, broker, imgCache)+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al9"})).To(Succeed())+ // Age the row past the retry budget.+ for k, v := range queueRepo.Data {+ if v.ItemID == "al9" {+ v.EnqueuedAt = time.Now().Add(-(giveUpAfter + time.Hour))+ queueRepo.Data[k] = v+ }+ }++ n, err := w.drain(ctx, 1)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ Expect(findQueued(queueRepo, "al", "al9")).To(BeNil())+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al9", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Hash).To(BeEmpty())+ })++ It("keeps already-served art when the retry budget is exhausted", func() {+ conf.Server.CoverArtPriority = "external"+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "al10", Name: "Album"}})+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{+ ItemKind: "al", ItemID: "al10", ImageType: model.ImageTypePrimary,+ Hash: "cafebabe", Source: "external:lastfm",+ })).To(Succeed())+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})+ w = NewWorker(ds, store, ag, ffm, broker, imgCache)+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al10"})).To(Succeed())+ for k, v := range queueRepo.Data {+ if v.ItemID == "al10" {+ v.EnqueuedAt = time.Now().Add(-(giveUpAfter + time.Hour))+ queueRepo.Data[k] = v+ }+ }++ n, err := w.drain(ctx, 1)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ Expect(findQueued(queueRepo, "al", "al10")).To(BeNil())+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al10", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Hash).To(Equal("cafebabe"), "a persistent outage must not discard served art")+ })++ // Media files are excluded from recheckKinds, so an absent row here would never be+ // revisited: a transient read error would look permanent.+ It("does not settle absent on exhaustion for a kind with no recheck path", func() {+ conf.Server.EnableMediaFileCoverArt = true+ ds.MockedMediaFile = tests.CreateMockMediaFileRepo()+ ds.MockedMediaFile.(*tests.MockMediaFileRepo).SetData(model.MediaFiles{+ {ID: "mfX", LibraryID: 0, Path: "tests/fixtures/artist/an-album/gone.mp3", HasCoverArt: true},+ })+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "mf", ItemID: "mfX"})).To(Succeed())+ for k, v := range queueRepo.Data {+ if v.ItemID == "mfX" {+ v.EnqueuedAt = time.Now().Add(-(giveUpAfter + time.Hour))+ queueRepo.Data[k] = v+ }+ }++ n, err := w.drain(ctx, 1)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ Expect(findQueued(queueRepo, "mf", "mfX")).To(BeNil(), "the row must stop retrying")+ _, err = artRepo.GetItemArtwork(model.KindMediaFileArtwork, "mfX", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound),+ "no row leaves the track unresolved, so a later view can still recover it")+ })++ It("resolves a private playlist under an admin context instead of failing forever", func() {+ ds.MockedUser = adminUserRepo()+ vds := &visibilityPlaylistDS{+ MockDataStore: ds,+ private: model.Playlist{ID: "plPriv", OwnerID: "admin"},+ tracks: &tests.MockPlaylistTrackRepo{},+ }+ w = NewWorker(vds, store, ag, ffm, broker, imgCache)+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "pl", ItemID: "plPriv"})).To(Succeed())++ n, err := w.drain(ctx, 1)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ Expect(findQueued(queueRepo, "pl", "plPriv")).To(BeNil())+ ia, err := artRepo.GetItemArtwork(model.KindPlaylistArtwork, "plPriv", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Hash).To(BeEmpty())+ })++ It("returns zero when the queue is empty", func() {+ n, err := w.drain(ctx, 2)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(BeZero())+ })++ It("broadcasts a single refresh event for the found items in a batch", func() {+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "al1", Name: "Album 1", FolderIDs: []string{"f1"}},+ {ID: "al2", Name: "Album 2", FolderIDs: []string{"f1"}},+ })+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al1", Priority: model.ArtworkPriorityScan})).To(Succeed())+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al2", Priority: model.ArtworkPriorityScan})).To(Succeed())+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar1", Priority: model.ArtworkPriorityScan})).To(Succeed())++ n, err := w.drain(ctx, 3)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(3))++ evts := broker.getEvents()+ Expect(evts).To(HaveLen(1), "exactly one coalesced event per drain batch")+ rr, ok := evts[0].(*events.RefreshResource)+ Expect(ok).To(BeTrue())+ data := rr.Data(rr)+ Expect(data).To(ContainSubstring(`"album"`))+ Expect(data).To(ContainSubstring("al1"))+ Expect(data).To(ContainSubstring("al2"))+ Expect(data).ToNot(ContainSubstring("artist"), "a failed (unresolved) artist must not be refreshed")+ Expect(data).ToNot(ContainSubstring("ar1"))+ })++ DescribeTable("only lists the kinds it actually resolved",+ func(kinds []string, wantSong bool) {+ items := slice.Map(kinds, func(k string) model.ArtworkQueueItem {+ return model.ArtworkQueueItem{ItemKind: k, ItemID: k + "1"}+ })+ w.broadcastRefresh(ctx, items)++ evts := broker.getEvents()+ Expect(evts).To(HaveLen(1))+ data := evts[0].(*events.RefreshResource).Data(evts[0])+ if wantSong {+ Expect(data).To(ContainSubstring(`"song"`))+ } else {+ Expect(data).ToNot(ContainSubstring(`"song"`))+ }+ },+ // An album's tracks inherit its art, but the dependent ids are unbounded: the client+ // fans an album refresh out to the tracks it has loaded.+ Entry("album alone does not name songs", []string{"al"}, false),+ Entry("artist alone does not", []string{"ar"}, false),+ Entry("playlist alone does not", []string{"pl"}, false),+ Entry("album mixed with others still does not", []string{"ar", "al"}, false),+ Entry("songs resolving on their own are listed by id", []string{"mf"}, true),+ )++ It("broadcasts a refresh when an item resolves to absent (removed cover)", func() {+ conf.Server.CoverArtPriority = "cover.*" // local-only; no folder image → absent+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "al3", Name: "Artless"}})+ folderRepo.result = nil+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al3", Priority: model.ArtworkPriorityScan})).To(Succeed())++ n, err := w.drain(ctx, 2)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ evts := broker.getEvents()+ Expect(evts).To(HaveLen(1), "a removed cover must live-refresh clients so they drop it")+ Expect(evts[0].(*events.RefreshResource).Data(evts[0])).To(ContainSubstring("al3"))++ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al3", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Hash).To(BeEmpty(), "the outcome was absent, not found")+ })++ It("does not broadcast when no item is found", func() {+ conf.Server.CoverArtPriority = "external"+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "alx", Name: "Album"}})+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "alx"})).To(Succeed())++ n, err := w.drain(ctx, 2)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ Expect(broker.getEvents()).To(BeEmpty(), "a drain with no found items sends no event")+ })+ })++ Describe("gate/breaker", func() {+ It("opens after 5 consecutive external errors and short-circuits the step", func() {+ var calls int+ failing := func() (io.ReadCloser, string, error) {+ calls+++ return nil, "", errors.New("boom")+ }+ for range 5 {+ _, _, err := w.gate("A", failing)+ Expect(err).To(HaveOccurred())+ }+ Expect(calls).To(Equal(5))++ _, _, err := w.gate("A", failing)+ Expect(err).To(MatchError(errBreakerOpen))+ Expect(calls).To(Equal(5), "an open breaker must not call the external step")+ })++ It("resets the failure count on a successful call", func() {+ failing := func() (io.ReadCloser, string, error) { return nil, "", errors.New("boom") }+ ok := func() (io.ReadCloser, string, error) { return io.NopCloser(nil), "p", nil }+ for range 4 {+ _, _, _ = w.gate("A", failing)+ }+ _, _, err := w.gate("A", ok)+ Expect(err).ToNot(HaveOccurred())++ var calls int+ counting := func() (io.ReadCloser, string, error) {+ calls+++ return nil, "", errors.New("boom")+ }+ for range 5 {+ _, _, _ = w.gate("A", counting)+ }+ Expect(calls).To(Equal(5), "the breaker should have re-closed after the success")+ })++ It("does not open the breaker on a run of agent not-found misses", func() {+ // agents.ErrNotFound is a definitive miss, not a fault: artless items must not+ // trip the breaker, or they would loop in retry instead of settling absent.+ notFound := func() (io.ReadCloser, string, error) { return nil, "", agents.ErrNotFound }+ for range breakerThreshold + 3 {+ _, _, err := w.gate("A", notFound)+ Expect(err).To(MatchError(agents.ErrNotFound), "a miss passes through, never errBreakerOpen")+ }++ var calls int+ counting := func() (io.ReadCloser, string, error) {+ calls+++ return nil, "", errors.New("boom")+ }+ _, _, _ = w.gate("A", counting)+ Expect(calls).To(Equal(1), "the breaker stayed closed, so the step still runs")+ })++ It("isolates each agent's breaker: one open gate does not block another", func() {+ failing := func() (io.ReadCloser, string, error) { return nil, "", errors.New("boom") }+ for range breakerThreshold {+ _, _, _ = w.gate("A", failing)+ }+ _, _, err := w.gate("A", failing)+ Expect(err).To(MatchError(errBreakerOpen), "agent A's breaker is open")++ var bCalls int+ bStep := func() (io.ReadCloser, string, error) {+ bCalls+++ return io.NopCloser(nil), "p", nil+ }+ for range breakerThreshold + 2 {+ _, _, err := w.gate("B", bStep)+ Expect(err).ToNot(HaveOccurred(), "agent B keeps being called while A is open")+ }+ Expect(bCalls).To(Equal(breakerThreshold + 2))+ })+ })++ Describe("precache", func() {+ BeforeEach(func() {+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{+ {ID: "alpc", Name: "Album", FolderIDs: []string{"f1"}},+ })+ conf.Server.UICoverArtSize = 300+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{+ ItemKind: "al", ItemID: "alpc", Priority: model.ArtworkPriorityScan,+ })).To(Succeed())+ })++ It("warms the resize cache at the UI cover size after a found acquisition", func() {+ conf.Server.EnableArtworkPrecache = true++ n, err := w.drain(ctx, 1)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ // The list surfaces request square covers, so warming any other key is wasted work.+ Expect(imgCache.getKeys()).To(ContainElement(ContainSubstring(".300.true.")))+ })++ It("skips warming when precache is disabled", func() {+ conf.Server.EnableArtworkPrecache = false++ n, err := w.drain(ctx, 1)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(1))++ Expect(imgCache.getKeys()).To(BeEmpty())+ })++ // It warms from the bytes acquisition already held, so no state row or store file is needed.+ It("warms from the acquired bytes without reading them back", func() {+ conf.Server.EnableArtworkPrecache = true+ ia := &model.ItemArtwork{+ ItemKind: "al", ItemID: "unpersisted", ImageType: model.ImageTypePrimary,+ Hash: "abcdef0123456789", UpdatedAt: time.Now(),+ }++ data, err := os.ReadFile("tests/fixtures/artist/an-album/cover.jpg")+ Expect(err).ToNot(HaveOccurred())++ w.precache(ctx, &acquired{ia: ia, mime: "image/jpeg", data: data})++ // Nothing backs that hash on disk, so a hit can only come from the bytes handed in;+ // the probe refuses to open, proving nothing is re-read.+ probe := &resizedItem{+ hash: ia.Hash, size: 300, square: true, ffmpeg: ffm,+ open: func() (io.ReadCloser, error) { return nil, errors.New("precache must not re-read the source") },+ }+ stream, err := imgCache.Get(ctx, probe)+ Expect(err).ToNot(HaveOccurred())+ defer stream.Close()+ Expect(io.ReadAll(stream)).ToNot(BeEmpty())+ })+ })++ Describe("drain pools", func() {+ // A kind in neither pool is never dequeued, with nothing to catch it at compile time.+ It("covers every kind the worker can process, exactly once", func() {+ var pooled []string+ for _, p := range newDrainPools() {+ pooled = append(pooled, p.kinds...)+ }+ for kind := range artworkKindToResource {+ Expect(pooled).To(ContainElement(kind.Prefix()), "kind %q belongs to no drain pool", kind.Prefix())+ }+ Expect(pooled).To(HaveLen(len(artworkKindToResource)), "a kind is claimed by more than one pool")+ })++ // Artists resolve through a rate-limited agent that holds its slot while waiting, so one+ // shared pool would park every album behind them.+ It("resolves albums while artists are stuck on a slow agent", func() {+ conf.Server.CoverArtPriority = "cover.jpg"+ conf.Server.ArtistArtPriority = "external"+ folderRepo.result = []model.Folder{{+ Path: "tests/fixtures/artist/an-album",+ ImageFiles: []string{"cover.jpg"},+ }}+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "alx", Name: "Album", FolderIDs: []string{"f1"}}})+ ds.MockedArtist = tests.CreateMockArtistRepo()++ // Every artist lookup blocks until released, standing in for the rate limiter.+ block := make(chan struct{})+ artists := model.Artists{}+ for i := range 8 {+ artists = append(artists, model.Artist{ID: fmt.Sprintf("arx%d", i), Name: "A"})+ }+ ds.MockedArtist.(*tests.MockArtistRepo).SetData(artists)+ imageAgents(&fakeImageAgent{name: "slowAgent", block: block})++ // Artists first, exactly as Backfill orders them.+ for _, a := range artists {+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{+ ItemKind: "ar", ItemID: a.ID, Priority: model.ArtworkPriorityBackfill,+ })).To(Succeed())+ }+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{+ ItemKind: "al", ItemID: "alx", Priority: model.ArtworkPriorityBackfill,+ })).To(Succeed())++ runCtx, cancel := context.WithCancel(ctx)+ done := make(chan struct{})+ go func() { defer close(done); _ = w.Run(runCtx) }()+ // Join Run: a leaked pool goroutine would race the config snapshot Ginkgo restores.+ DeferCleanup(func() {+ cancel()+ close(block) // unpark the blocked lookups so the pools can unwind+ <-done+ })++ Eventually(func() bool {+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alx", model.ImageTypePrimary)+ return err == nil && ia.Hash != ""+ }, 5*time.Second, 50*time.Millisecond).Should(BeTrue(),+ "a blocked external pool must not hold up local artwork")++ _, err := artRepo.GetItemArtwork(model.KindArtistArtwork, "arx0", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound), "artists are still blocked, as intended")+ })+ })++ Describe("batching", func() {+ It("leaves undispatched items queued when cancelled mid-batch", func() {+ for i := range 8 {+ id := fmt.Sprintf("alc%d", i)+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: id, Name: "Album"}})+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{+ ItemKind: "al", ItemID: id, Priority: model.ArtworkPriorityScan,+ })).To(Succeed())+ }+ cancelledCtx, cancel := context.WithCancel(ctx)+ cancel()++ _, err := w.drain(cancelledCtx, 1)+ Expect(err).ToNot(HaveOccurred())++ for i := range 8 {+ id := fmt.Sprintf("alc%d", i)+ Expect(findQueued(queueRepo, "al", id)).ToNot(BeNil(), "row "+id+" must survive a cancelled drain")+ }+ })++ It("dequeues past the worker pool so one drain covers many items", func() {+ for i := range 16 {+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: fmt.Sprintf("alb%d", i), Name: "Album"}})+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{+ ItemKind: "al", ItemID: fmt.Sprintf("alb%d", i), Priority: model.ArtworkPriorityScan,+ })).To(Succeed())+ }++ n, err := w.drain(ctx, 2)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(16), "a batch sized to the pool would have stopped at 4")+ })+ })++ Describe("RunPrune", func() {+ It("runs a prune under the worker mutex", func() {+ Expect(w.RunPrune(ctx)).To(Succeed())+ })+ })++ Describe("Run", func() {+ It("exits cleanly when the context is cancelled", func() {+ runCtx, cancel := context.WithCancel(ctx)+ done := make(chan error, 1)+ go func() { done <- w.Run(runCtx) }()++ cancel()+ Eventually(done, time.Second).Should(Receive(BeNil()))+ })++ It("does not leak goroutines after Run exits", func() {+ DeferCleanup(configtest.SetupConfig())++ ignore := goleak.IgnoreCurrent()+ DeferCleanup(func() { goleak.VerifyNone(GinkgoT(), ignore) })++ localDS := &tests.MockDataStore{MockedArtworkQueue: tests.CreateMockArtworkQueueRepo()}+ lw := NewWorker(localDS, NewImageStore(GinkgoT().TempDir()), agents.GetAgents(localDS, nil), tests.NewMockFFmpeg(""), &fakeEventBroker{}, imgCache)++ runCtx, cancel := context.WithCancel(ctx)+ done := make(chan error, 1)+ go func() { done <- lw.Run(runCtx) }()++ time.Sleep(20 * time.Millisecond) // let the loop settle on the idle select+ cancel()+ Eventually(done, 2*time.Second).Should(Receive(BeNil()))+ })+ })+})++var _ = Describe("backoff", func() {+ It("returns the expected schedule with no jitter", func() {+ for _, c := range []struct {+ attempts int+ want time.Duration+ }{+ {0, 5 * time.Second},+ {1, 20 * time.Second},+ {2, 80 * time.Second},+ {3, 320 * time.Second},+ {4, 1280 * time.Second},+ {5, 5120 * time.Second},+ {6, 20480 * time.Second},+ {7, 12 * time.Hour},+ {8, 12 * time.Hour},+ } {+ Expect(backoffFor(c.attempts, 0)).To(Equal(c.want), "attempt %d", c.attempts)+ }+ })++ It("applies jitter proportionally", func() {+ base := backoffFor(2, 0)+ Expect(backoffFor(2, 0.2)).To(Equal(time.Duration(float64(base) * 1.2)))+ Expect(backoffFor(2, -0.2)).To(Equal(time.Duration(float64(base) * 0.8)))+ })++ It("keeps random jitter within +/-40%", func() {+ lo := time.Duration(float64(320*time.Second) * 0.6)+ hi := time.Duration(float64(320*time.Second) * 1.4)+ for range 200 {+ d := backoff(3)+ Expect(d).To(BeNumerically(">=", lo))+ Expect(d).To(BeNumerically("<=", hi))+ }+ })+})diff --git a/core/artwork/worker_timing_test.go b/core/artwork/worker_timing_test.gonew file mode 100644index 000000000..f7315b20a--- /dev/null+++ b/core/artwork/worker_timing_test.go@@ -0,0 +1,76 @@+package artwork++import (+ "errors"+ "io"+ "testing"+ "testing/synctest"+ "time"++ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/gomega"+)++// Drives the real breaker state machine with the fake clock. Plain test: testing/synctest+// needs a *testing.T, which Ginkgo doesn't give.+func TestArtworkBreakerHalfOpen(t *testing.T) {+ synctest.Test(t, func(t *testing.T) {+ g := NewWithT(t)+ b := newBreaker()++ for range breakerThreshold {+ b.record("agentA", errors.New("boom"))+ }+ g.Expect(b.allow()).To(BeFalse(), "breaker opens after consecutive errors")++ time.Sleep(breakerProbeAfter - time.Nanosecond)+ g.Expect(b.allow()).To(BeFalse(), "still open before the probe interval")++ time.Sleep(time.Nanosecond)+ g.Expect(b.allow()).To(BeTrue(), "half-open: one probe is granted")+ g.Expect(b.allow()).To(BeFalse(), "only a single probe per interval")++ b.record("agentA", errors.New("boom")) // probe fails -> stay open+ time.Sleep(breakerProbeAfter)+ g.Expect(b.allow()).To(BeTrue(), "another probe after the next interval")++ b.record("agentA", nil) // probe succeeds -> close+ g.Expect(b.allow()).To(BeTrue(), "closed breaker admits freely")+ g.Expect(b.allow()).To(BeTrue())+ })+}++func TestArtworkGatePerAgentBreakerIsolation(t *testing.T) {+ synctest.Test(t, func(t *testing.T) {+ g := NewWithT(t)+ w := NewWorker(&tests.MockDataStore{}, NewImageStore(t.TempDir()),+ agents.GetAgents(&tests.MockDataStore{}, nil), tests.NewMockFFmpeg(""), &fakeEventBroker{}, nil)++ fail := func() (io.ReadCloser, string, error) { return nil, "", errors.New("boom") }+ for range breakerThreshold {+ _, _, _ = w.gate("A", fail)+ }+ _, _, err := w.gate("A", fail)+ g.Expect(err).To(MatchError(errBreakerOpen), "A opens after consecutive errors")++ // B has its own breaker, untouched by A being open.+ var bCalls int+ bStep := func() (io.ReadCloser, string, error) { bCalls++; return nil, "", errors.New("boom") }+ for range breakerThreshold - 1 {+ _, _, err := w.gate("B", bStep)+ g.Expect(err).To(MatchError("boom"))+ }+ g.Expect(bCalls).To(Equal(breakerThreshold-1), "B keeps being called while A is open")++ // After the probe window, A admits exactly one probe again.+ time.Sleep(breakerProbeAfter)+ var aCalls int+ aFail := func() (io.ReadCloser, string, error) { aCalls++; return nil, "", errors.New("boom") }+ _, _, _ = w.gate("A", aFail)+ g.Expect(aCalls).To(Equal(1), "A grants a single probe after the interval")+ _, _, err = w.gate("A", aFail)+ g.Expect(err).To(MatchError(errBreakerOpen), "the probe failed, so A stays open")+ g.Expect(aCalls).To(Equal(1))+ })+}diff --git a/core/external/provider.go b/core/external/provider.goindex 869841e06..efd061c0c 100644--- a/core/external/provider.go+++ b/core/external/provider.go@@ -4,7 +4,6 @@ import ("context""errors""fmt"- "net/url""sort""strings""time"@@ -35,8 +34,6 @@ type Provider interface {UpdateArtistInfo(ctx context.Context, id string, count int, includeNotPresent bool) (*model.Artist, error)SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error)TopSongs(ctx context.Context, artist, artistId string, count int) (model.MediaFiles, error)- ArtistImage(ctx context.Context, id string) (*url.URL, error)- AlbumImage(ctx context.Context, id string) (*url.URL, error)}type provider struct {@@ -258,7 +255,7 @@ func (e *provider) populateArtistInfo(ctx context.Context, artist auxArtist) (au// Call all registered agents and collect informationg := errgroup.Group{}g.SetLimit(2)- g.Go(func() error { e.callGetImage(ctx, e.ag, &artist); return nil })+ g.Go(func() error { _ = e.callGetImage(ctx, e.ag, &artist); return nil })g.Go(func() error { e.callGetBiography(ctx, e.ag, &artist); return nil })g.Go(func() error { e.callGetURL(ctx, e.ag, &artist); return nil })g.Go(func() error { e.callGetSimilarArtists(ctx, e.ag, &artist, maxSimilarArtists, true); return nil })@@ -370,76 +367,6 @@ func (e *provider) similarSongsFallback(ctx context.Context, id string, count inreturn similarSongs, nil}-func (e *provider) ArtistImage(ctx context.Context, id string) (*url.URL, error) {- artist, err := e.getArtist(ctx, id)- if err != nil {- return nil, err- }-- imageUrl := artist.ArtistImageUrl()- if imageUrl == "" {- // No cached URL — must fetch from external source synchronously- e.callGetImage(ctx, e.ag, &artist)- if utils.IsCtxDone(ctx) {- log.Warn(ctx, "ArtistImage call canceled", ctx.Err())- return nil, ctx.Err()- }- imageUrl = artist.ArtistImageUrl()- } else {- // If cached info is expired, enqueue a background refresh so that config changes- // (e.g. disabling an agent) take effect without waiting for a full artist info refresh.- updatedAt := V(artist.ExternalInfoUpdatedAt)- if !updatedAt.IsZero() && time.Since(updatedAt) > conf.Server.DevArtistInfoTimeToLive {- log.Debug(ctx, "Artist image info expired, enqueuing background refresh", "artist", artist.Name(), "updatedAt", updatedAt)- e.artistQueue.enqueue(&artist)- }- }-- if imageUrl == "" {- return nil, model.ErrNotFound- }- return url.Parse(imageUrl)-}--func (e *provider) AlbumImage(ctx context.Context, id string) (*url.URL, error) {- album, err := e.getAlbum(ctx, id)- if err != nil {- return nil, err- }-- albumName := album.Name()- images, err := e.ag.GetAlbumImages(ctx, albumName, album.AlbumArtist, album.MbzAlbumID)- if err != nil {- switch {- case errors.Is(err, agents.ErrNotFound):- log.Trace(ctx, "Album not found in agent", "albumID", id, "name", albumName, "artist", album.AlbumArtist)- return nil, model.ErrNotFound- case errors.Is(err, context.Canceled):- log.Debug(ctx, "GetAlbumImages call canceled", err)- default:- log.Warn(ctx, "Error getting album images from agent", "albumID", id, "name", albumName, "artist", album.AlbumArtist, err)- }- return nil, err- }-- if len(images) == 0 {- log.Warn(ctx, "Agent returned no images without error", "albumID", id, "name", albumName, "artist", album.AlbumArtist)- return nil, model.ErrNotFound- }-- // Return the biggest image- var img agents.ExternalImage- for _, i := range images {- if img.Size <= i.Size {- img = i- }- }- if img.URL == "" {- return nil, model.ErrNotFound- }- return url.Parse(img.URL)-}-func (e *provider) TopSongs(ctx context.Context, artistName, id string, count int) (model.MediaFiles, error) {artist, err := e.findArtist(ctx, artistName, id)if err != nil {@@ -524,10 +451,15 @@ func (e *provider) callGetBiography(ctx context.Context, agent agents.ArtistBiogartist.Biography = strings.ReplaceAll(bio, "<a ", "<a target='_blank' ")}-func (e *provider) callGetImage(ctx context.Context, agent agents.ArtistImageRetriever, artist *auxArtist) {+// callGetImage populates artist's image URLs. A transient agent failure is+// returned as-is; a definitive "no image" is normalized to model.ErrNotFound.+func (e *provider) callGetImage(ctx context.Context, agent agents.ArtistImageRetriever, artist *auxArtist) error {images, err := agent.GetArtistImages(ctx, artist.ID, artist.Name(), artist.MbzArtistID)if err != nil {- return+ if errors.Is(err, agents.ErrNotFound) {+ return model.ErrNotFound+ }+ return err}sort.Slice(images, func(i, j int) bool { return images[i].Size > images[j].Size })@@ -540,6 +472,7 @@ func (e *provider) callGetImage(ctx context.Context, agent agents.ArtistImageRetif len(images) >= 3 {artist.SmallImageUrl = images[2].URL}+ return nil}func (e *provider) callGetSimilarArtists(ctx context.Context, agent agents.ArtistSimilarRetriever, artist *auxArtist,diff --git a/core/external/provider_albumimage_test.go b/core/external/provider_albumimage_test.godeleted file mode 100644index e801b7cce..000000000--- a/core/external/provider_albumimage_test.go+++ /dev/null@@ -1,365 +0,0 @@-package external_test--import (- "context"- "errors"- "net/url"-- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/conf/configtest"- "github.com/navidrome/navidrome/core/agents"- . "github.com/navidrome/navidrome/core/external"- "github.com/navidrome/navidrome/core/matcher"- "github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/tests"- . "github.com/onsi/ginkgo/v2"- . "github.com/onsi/gomega"- "github.com/stretchr/testify/mock"-)--var _ = Describe("Provider - AlbumImage", func() {- var ds *tests.MockDataStore- var provider Provider- var mockArtistRepo *mockArtistRepo- var mockAlbumRepo *mockAlbumRepo- var mockMediaFileRepo *mockMediaFileRepo- var mockAlbumAgent *mockAlbumInfoAgent- var ctx context.Context-- BeforeEach(func() {- ctx = GinkgoT().Context()- DeferCleanup(configtest.SetupConfig())- conf.Server.Agents = "mockAlbum" // Configure mock agent-- mockArtistRepo = newMockArtistRepo()- mockAlbumRepo = newMockAlbumRepo()- mockMediaFileRepo = newMockMediaFileRepo()-- ds = &tests.MockDataStore{- MockedArtist: mockArtistRepo,- MockedAlbum: mockAlbumRepo,- MockedMediaFile: mockMediaFileRepo,- }-- mockAlbumAgent = newMockAlbumInfoAgent()-- agentsCombined := &mockAgents{albumInfoAgent: mockAlbumAgent}- provider = NewProvider(ds, agentsCombined, matcher.New(ds))-- // Default mocks- // Mocks for GetEntityByID sequence (initial failed lookups)- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()- mockArtistRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()- mockAlbumRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()-- // Default mock for non-existent entities - Use Maybe() for flexibility- mockArtistRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()- mockAlbumRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()- mockMediaFileRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()- })-- It("returns the largest image URL when successful", func() {- // Arrange- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()- // Explicitly mock agent call for this test- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").- Return([]agents.ExternalImage{- {URL: "http://example.com/large.jpg", Size: 1000},- {URL: "http://example.com/medium.jpg", Size: 500},- {URL: "http://example.com/small.jpg", Size: 200},- }, nil).Once()-- expectedURL, _ := url.Parse("http://example.com/large.jpg")- imgURL, err := provider.AlbumImage(ctx, "album-1")-- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1") // From GetEntityByID- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")- mockArtistRepo.AssertNotCalled(GinkgoT(), "Get", "artist-1") // Artist lookup no longer happens in getAlbum- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist name- })-- It("returns ErrNotFound if the album is not found in the DB", func() {- // Arrange: Explicitly expect the full GetEntityByID sequence for "not-found"- mockArtistRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()- mockAlbumRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()- mockMediaFileRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()-- imgURL, err := provider.AlbumImage(ctx, "not-found")-- Expect(err).To(MatchError("data not found"))- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "not-found")- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "not-found")- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "not-found")- mockAlbumAgent.AssertNotCalled(GinkgoT(), "GetAlbumImages", mock.Anything, mock.Anything, mock.Anything)- })-- It("returns the agent error if the agent fails", func() {- // Arrange- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()-- agentErr := errors.New("agent failure")- // Explicitly mock agent call for this test- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").Return(nil, agentErr).Once() // Expect empty artist-- imgURL, err := provider.AlbumImage(ctx, "album-1")-- Expect(err).To(MatchError("agent failure"))- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")- mockArtistRepo.AssertNotCalled(GinkgoT(), "Get", "artist-1")- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist- })-- It("returns ErrNotFound if the agent returns ErrNotFound", func() {- // Arrange- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()-- // Explicitly mock agent call for this test- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").Return(nil, agents.ErrNotFound).Once() // Expect empty artist-- imgURL, err := provider.AlbumImage(ctx, "album-1")-- Expect(err).To(MatchError("data not found"))- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist- })-- It("returns ErrNotFound if the agent returns no images", func() {- // Arrange- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()-- // Explicitly mock agent call for this test- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").- Return([]agents.ExternalImage{}, nil).Once() // Expect empty artist-- imgURL, err := provider.AlbumImage(ctx, "album-1")-- Expect(err).To(MatchError("data not found"))- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist- })-- It("returns context error if context is canceled", func() {- // Arrange- cctx, cancelCtx := context.WithCancel(ctx)- // Mock the necessary DB calls *before* canceling the context- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()- // Expect the agent call even if context is cancelled, returning the context error- mockAlbumAgent.On("GetAlbumImages", cctx, "Album One", "", "").Return(nil, context.Canceled).Once()- // Cancel the context *before* calling the function under test- cancelCtx()-- imgURL, err := provider.AlbumImage(cctx, "album-1")-- Expect(err).To(MatchError("context canceled"))- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")- // Agent should now be called, verify this expectation- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", cctx, "Album One", "", "")- })-- It("derives album ID from MediaFile ID", func() {- // Arrange: Mock full GetEntityByID for "mf-1" and recursive "album-1"- mockArtistRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()- mockAlbumRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()- mockMediaFileRepo.On("Get", "mf-1").Return(&model.MediaFile{ID: "mf-1", Title: "Track One", ArtistID: "artist-1", AlbumID: "album-1"}, nil).Once()- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()-- // Explicitly mock agent call for this test- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").- Return([]agents.ExternalImage{- {URL: "http://example.com/large.jpg", Size: 1000},- {URL: "http://example.com/medium.jpg", Size: 500},- {URL: "http://example.com/small.jpg", Size: 200},- }, nil).Once()-- expectedURL, _ := url.Parse("http://example.com/large.jpg")- imgURL, err := provider.AlbumImage(ctx, "mf-1")-- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "mf-1")- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "mf-1")- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "mf-1")- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")- mockArtistRepo.AssertNotCalled(GinkgoT(), "Get", "artist-1")- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "")- })-- It("handles different image orders from agent", func() {- // Arrange- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()- // Explicitly mock agent call for this test- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").- Return([]agents.ExternalImage{- {URL: "http://example.com/small.jpg", Size: 200},- {URL: "http://example.com/large.jpg", Size: 1000},- {URL: "http://example.com/medium.jpg", Size: 500},- }, nil).Once()-- expectedURL, _ := url.Parse("http://example.com/large.jpg")- imgURL, err := provider.AlbumImage(ctx, "album-1")-- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL)) // Should still pick the largest- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "")- })-- It("handles agent returning only one image", func() {- // Arrange- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()- // Explicitly mock agent call for this test- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").- Return([]agents.ExternalImage{- {URL: "http://example.com/single.jpg", Size: 700},- }, nil).Once()-- expectedURL, _ := url.Parse("http://example.com/single.jpg")- imgURL, err := provider.AlbumImage(ctx, "album-1")-- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "")- })-- It("returns ErrNotFound if deriving album ID fails", func() {- // Arrange: Mock full GetEntityByID for "mf-no-album" and recursive "not-found"- mockArtistRepo.On("Get", "mf-no-album").Return(nil, model.ErrNotFound).Once()- mockAlbumRepo.On("Get", "mf-no-album").Return(nil, model.ErrNotFound).Once()- mockMediaFileRepo.On("Get", "mf-no-album").Return(&model.MediaFile{ID: "mf-no-album", Title: "Track No Album", ArtistID: "artist-1", AlbumID: "not-found"}, nil).Once()- mockArtistRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()- mockAlbumRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()- mockMediaFileRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()-- imgURL, err := provider.AlbumImage(ctx, "mf-no-album")-- Expect(err).To(MatchError("data not found"))- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "mf-no-album")- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "mf-no-album")- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "mf-no-album")- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "not-found")- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "not-found")- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "not-found")- mockAlbumAgent.AssertNotCalled(GinkgoT(), "GetAlbumImages", mock.Anything, mock.Anything, mock.Anything)- })-- Context("Unicode handling in album names", func() {- var albumWithEnDash *model.Album- var expectedURL *url.URL-- const (- originalAlbumName = "Raising Hell–Deluxe" // Album name with en dash- normalizedAlbumName = "Raising Hell-Deluxe" // Normalized version with hyphen- )-- BeforeEach(func() {- // Test with en dash (–) in album name- albumWithEnDash = &model.Album{ID: "album-endash", Name: originalAlbumName, AlbumArtistID: "artist-1"}- mockArtistRepo.Mock = mock.Mock{} // Reset default expectations- mockAlbumRepo.Mock = mock.Mock{} // Reset default expectations- mockArtistRepo.On("Get", "album-endash").Return(nil, model.ErrNotFound).Once()- mockAlbumRepo.On("Get", "album-endash").Return(albumWithEnDash, nil).Once()-- expectedURL, _ = url.Parse("http://example.com/album.jpg")-- // Mock the album agent to return an image for the album- mockAlbumAgent.On("GetAlbumImages", ctx, mock.AnythingOfType("string"), "", "").- Return([]agents.ExternalImage{- {URL: "http://example.com/album.jpg", Size: 1000},- }, nil).Once()- })-- When("DevPreserveUnicodeInExternalCalls is true", func() {- BeforeEach(func() {- conf.Server.DevPreserveUnicodeInExternalCalls = true- })-- It("preserves Unicode characters in album names", func() {- // Act- imgURL, err := provider.AlbumImage(ctx, "album-endash")-- // Assert- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-endash")- // This is the key assertion: ensure the original Unicode name is used- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, originalAlbumName, "", "")- })- })-- When("DevPreserveUnicodeInExternalCalls is false", func() {- BeforeEach(func() {- conf.Server.DevPreserveUnicodeInExternalCalls = false- })-- It("normalizes Unicode characters", func() {- // Act- imgURL, err := provider.AlbumImage(ctx, "album-endash")-- // Assert- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-endash")- // This assertion ensures the normalized name is used (en dash → hyphen)- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, normalizedAlbumName, "", "")- })- })- })-})--// mockAlbumInfoAgent implementation-type mockAlbumInfoAgent struct {- mock.Mock- agents.AlbumInfoRetriever- agents.AlbumImageRetriever-}--func newMockAlbumInfoAgent() *mockAlbumInfoAgent {- m := new(mockAlbumInfoAgent)- m.On("AgentName").Return("mockAlbum").Maybe()- return m-}--func (m *mockAlbumInfoAgent) AgentName() string {- args := m.Called()- return args.String(0)-}--func (m *mockAlbumInfoAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*agents.AlbumInfo, error) {- args := m.Called(ctx, name, artist, mbid)- if args.Get(0) == nil {- return nil, args.Error(1)- }- return args.Get(0).(*agents.AlbumInfo), args.Error(1)-}--func (m *mockAlbumInfoAgent) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]agents.ExternalImage, error) {- args := m.Called(ctx, name, artist, mbid)- if args.Get(0) == nil {- return nil, args.Error(1)- }- return args.Get(0).([]agents.ExternalImage), args.Error(1)-}--// Ensure mockAgent implements the interfaces-var _ agents.AlbumInfoRetriever = (*mockAlbumInfoAgent)(nil)-var _ agents.AlbumImageRetriever = (*mockAlbumInfoAgent)(nil)diff --git a/core/external/provider_artistimage_test.go b/core/external/provider_artistimage_test.godeleted file mode 100644index 79612d651..000000000--- a/core/external/provider_artistimage_test.go+++ /dev/null@@ -1,426 +0,0 @@-package external_test--import (- "bytes"- "context"- "errors"- "net/url"- "time"-- "github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/conf/configtest"- "github.com/navidrome/navidrome/core/agents"- . "github.com/navidrome/navidrome/core/external"- "github.com/navidrome/navidrome/core/matcher"- "github.com/navidrome/navidrome/log"- "github.com/navidrome/navidrome/model"- "github.com/navidrome/navidrome/tests"- . "github.com/onsi/ginkgo/v2"- . "github.com/onsi/gomega"- "github.com/stretchr/testify/mock"-)--var _ = Describe("Provider - ArtistImage", func() {- var ds *tests.MockDataStore- var provider Provider- var mockArtistRepo *mockArtistRepo- var mockAlbumRepo *mockAlbumRepo- var mockMediaFileRepo *mockMediaFileRepo- var mockImageAgent *mockArtistImageAgent- var agentsCombined *mockAgents- var ctx context.Context-- BeforeEach(func() {- DeferCleanup(configtest.SetupConfig())- conf.Server.Agents = "mockImage" // Configure only the mock agent- ctx = GinkgoT().Context()-- mockArtistRepo = newMockArtistRepo()- mockAlbumRepo = newMockAlbumRepo()- mockMediaFileRepo = newMockMediaFileRepo()-- ds = &tests.MockDataStore{- MockedArtist: mockArtistRepo,- MockedAlbum: mockAlbumRepo,- MockedMediaFile: mockMediaFileRepo,- }-- mockImageAgent = newMockArtistImageAgent()-- // Use the mockAgents from helper, setting the specific agent- agentsCombined = &mockAgents{- imageAgent: mockImageAgent,- }-- provider = NewProvider(ds, agentsCombined, matcher.New(ds))-- // Default mocks for successful Get calls- mockArtistRepo.On("Get", "artist-1").Return(&model.Artist{ID: "artist-1", Name: "Artist One"}, nil).Maybe()- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Maybe()- mockMediaFileRepo.On("Get", "mf-1").Return(&model.MediaFile{ID: "mf-1", Title: "Track One", ArtistID: "artist-1"}, nil).Maybe()- // Default mock for non-existent entities- mockArtistRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()- mockAlbumRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()- mockMediaFileRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()-- // Default successful image agent response- mockImageAgent.On("GetArtistImages", mock.Anything, "artist-1", "Artist One", "").- Return([]agents.ExternalImage{- {URL: "http://example.com/large.jpg", Size: 1000},- {URL: "http://example.com/medium.jpg", Size: 500},- {URL: "http://example.com/small.jpg", Size: 200},- }, nil).Maybe()- })-- AfterEach(func() {- mockArtistRepo.AssertExpectations(GinkgoT())- mockAlbumRepo.AssertExpectations(GinkgoT())- mockMediaFileRepo.AssertExpectations(GinkgoT())- mockImageAgent.AssertExpectations(GinkgoT())- })-- It("returns the largest image URL when successful", func() {- // Arrange- expectedURL, _ := url.Parse("http://example.com/large.jpg")-- // Act- imgURL, err := provider.ArtistImage(ctx, "artist-1")-- // Assert- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")- })-- It("returns ErrNotFound if the artist is not found in the DB", func() {- // Arrange-- // Act- imgURL, err := provider.ArtistImage(ctx, "not-found")-- // Assert- Expect(err).To(MatchError(model.ErrNotFound))- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "not-found")- mockImageAgent.AssertNotCalled(GinkgoT(), "GetArtistImages", mock.Anything, mock.Anything, mock.Anything, mock.Anything)- })-- It("returns the agent error if the agent fails", func() {- // Arrange- agentErr := errors.New("agent failure")- mockImageAgent.Mock = mock.Mock{} // Reset default expectation- mockImageAgent.On("GetArtistImages", ctx, "artist-1", "Artist One", "").Return(nil, agentErr).Once()-- // Act- imgURL, err := provider.ArtistImage(ctx, "artist-1")-- // Assert- Expect(err).To(MatchError(model.ErrNotFound)) // Corrected Expectation: The provider maps agent errors (other than canceled) to ErrNotFound if no image was found/populated- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")- })-- It("returns ErrNotFound if the agent returns ErrNotFound", func() {- // Arrange- mockImageAgent.Mock = mock.Mock{} // Reset default expectation- mockImageAgent.On("GetArtistImages", ctx, "artist-1", "Artist One", "").Return(nil, agents.ErrNotFound).Once()-- // Act- imgURL, err := provider.ArtistImage(ctx, "artist-1")-- // Assert- Expect(err).To(MatchError(model.ErrNotFound))- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")- })-- It("returns ErrNotFound if the agent returns no images", func() {- // Arrange- mockImageAgent.Mock = mock.Mock{} // Reset default expectation- mockImageAgent.On("GetArtistImages", ctx, "artist-1", "Artist One", "").Return([]agents.ExternalImage{}, nil).Once()-- // Act- imgURL, err := provider.ArtistImage(ctx, "artist-1")-- // Assert- Expect(err).To(MatchError(model.ErrNotFound)) // Implementation maps empty result to ErrNotFound- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")- })-- It("returns context error if context is canceled before agent call", func() {- // Arrange- cctx, cancelCtx := context.WithCancel(context.Background())- mockArtistRepo.Mock = mock.Mock{} // Reset default expectation for artist repo as well- mockArtistRepo.On("Get", "artist-1").Return(&model.Artist{ID: "artist-1", Name: "Artist One"}, nil).Run(func(args mock.Arguments) {- cancelCtx() // Cancel context *during* the DB call simulation- }).Once()-- // Act- imgURL, err := provider.ArtistImage(cctx, "artist-1")-- // Assert- Expect(err).To(MatchError(context.Canceled))- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")- })-- It("derives artist ID from MediaFile ID", func() {- // Arrange: Add mocks for the initial GetEntityByID lookups- mockArtistRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()- mockAlbumRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()- // Default mocks for MediaFileRepo.Get("mf-1") and ArtistRepo.Get("artist-1") handle the rest- expectedURL, _ := url.Parse("http://example.com/large.jpg")-- // Act- imgURL, err := provider.ArtistImage(ctx, "mf-1")-- // Assert- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "mf-1") // GetEntityByID sequence- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "mf-1") // GetEntityByID sequence- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "mf-1")- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1") // Should be called after getting MF- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")- })-- It("derives artist ID from Album ID", func() {- // Arrange: Add mock for the initial GetEntityByID lookup- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()- // Default mocks for AlbumRepo.Get("album-1") and ArtistRepo.Get("artist-1") handle the rest- expectedURL, _ := url.Parse("http://example.com/large.jpg")-- // Act- imgURL, err := provider.ArtistImage(ctx, "album-1")-- // Assert- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1") // GetEntityByID sequence- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1") // Should be called after getting Album- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")- })-- It("returns ErrNotFound if derived artist is not found", func() {- // Arrange- // Add mocks for the initial GetEntityByID lookups- mockArtistRepo.On("Get", "mf-bad-artist").Return(nil, model.ErrNotFound).Once()- mockAlbumRepo.On("Get", "mf-bad-artist").Return(nil, model.ErrNotFound).Once()- mockMediaFileRepo.On("Get", "mf-bad-artist").Return(&model.MediaFile{ID: "mf-bad-artist", ArtistID: "not-found"}, nil).Once()- // Add expectation for the recursive GetEntityByID call for the MediaFileRepo- mockMediaFileRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()- // The default mocks for ArtistRepo/AlbumRepo handle the final "not-found" lookups-- // Act- imgURL, err := provider.ArtistImage(ctx, "mf-bad-artist")-- // Assert- Expect(err).To(MatchError(model.ErrNotFound))- Expect(imgURL).To(BeNil())- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "mf-bad-artist") // GetEntityByID sequence- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "mf-bad-artist") // GetEntityByID sequence- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "mf-bad-artist")- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "not-found")- mockImageAgent.AssertNotCalled(GinkgoT(), "GetArtistImages", mock.Anything, mock.Anything, mock.Anything, mock.Anything)- })-- It("handles different image orders from agent", func() {- // Arrange- mockImageAgent.Mock = mock.Mock{} // Reset default expectation- mockImageAgent.On("GetArtistImages", ctx, "artist-1", "Artist One", "").- Return([]agents.ExternalImage{- {URL: "http://example.com/small.jpg", Size: 200},- {URL: "http://example.com/large.jpg", Size: 1000},- {URL: "http://example.com/medium.jpg", Size: 500},- }, nil).Once()- expectedURL, _ := url.Parse("http://example.com/large.jpg")-- // Act- imgURL, err := provider.ArtistImage(ctx, "artist-1")-- // Assert- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL)) // Still picks the largest- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")- })-- It("handles agent returning only one image", func() {- // Arrange- mockImageAgent.Mock = mock.Mock{} // Reset default expectation- mockImageAgent.On("GetArtistImages", ctx, "artist-1", "Artist One", "").- Return([]agents.ExternalImage{- {URL: "http://example.com/medium.jpg", Size: 500},- }, nil).Once()- expectedURL, _ := url.Parse("http://example.com/medium.jpg")-- // Act- imgURL, err := provider.ArtistImage(ctx, "artist-1")-- // Assert- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")- })-- It("returns cached URL and does not call agent when info is not expired", func() {- // Arrange: artist has a cached image URL with recent ExternalInfoUpdatedAt- cachedArtist := &model.Artist{- ID: "artist-cached",- Name: "Cached Artist",- LargeImageUrl: "http://example.com/cached-large.jpg",- ExternalInfoUpdatedAt: new(time.Now().Add(-1 * time.Minute)),- }- mockArtistRepo.On("Get", "artist-cached").Return(cachedArtist, nil).Maybe()- expectedURL, _ := url.Parse("http://example.com/cached-large.jpg")-- // Capture log output- var logBuf bytes.Buffer- log.SetOutput(&logBuf)- defer log.SetOutput(GinkgoWriter)- log.SetLevel(log.LevelDebug)-- // Act- imgURL, err := provider.ArtistImage(ctx, "artist-cached")-- // Assert- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockImageAgent.AssertNotCalled(GinkgoT(), "GetArtistImages", mock.Anything, "artist-cached", mock.Anything, mock.Anything)-- // Assert: background refresh was NOT enqueued- Expect(logBuf.String()).ToNot(ContainSubstring("Artist image info expired, enqueuing background refresh"))-- })-- It("returns stale URL and enqueues refresh when info is expired", func() {- // Arrange- conf.Server.DevArtistInfoTimeToLive = 1 * time.Nanosecond- staleArtist := &model.Artist{- ID: "artist-expired",- Name: "Expired Artist",- LargeImageUrl: "http://example.com/expired-large.jpg",- ExternalInfoUpdatedAt: new(time.Now().Add(-1 * time.Hour)),- }- mockArtistRepo.On("Get", "artist-expired").Return(staleArtist, nil).Maybe()- expectedURL, _ := url.Parse("http://example.com/expired-large.jpg")-- // Capture log output- var logBuf bytes.Buffer- log.SetOutput(&logBuf)- defer log.SetOutput(GinkgoWriter)- log.SetLevel(log.LevelDebug)-- // Act- imgURL, err := provider.ArtistImage(ctx, "artist-expired")-- // Assert: returns stale URL immediately, no agent call- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockImageAgent.AssertNotCalled(GinkgoT(), "GetArtistImages", mock.Anything, "artist-expired", mock.Anything, mock.Anything)-- // Assert: background refresh was enqueued- Expect(logBuf.String()).To(ContainSubstring("Artist image info expired, enqueuing background refresh"))- })-- Context("Unicode handling in artist names", func() {- var artistWithEnDash *model.Artist- var expectedURL *url.URL-- const (- originalArtistName = "Run–D.M.C." // Artist name with en dash- normalizedArtistName = "Run-D.M.C." // Normalized version with hyphen- )-- BeforeEach(func() {- // Test with en dash (–) in artist name like "Run–D.M.C."- artistWithEnDash = &model.Artist{ID: "artist-endash", Name: originalArtistName}- mockArtistRepo.Mock = mock.Mock{} // Reset default expectations- mockArtistRepo.On("Get", "artist-endash").Return(artistWithEnDash, nil).Once()-- expectedURL, _ = url.Parse("http://example.com/rundmc.jpg")-- // Mock the image agent to return an image for the artist- mockImageAgent.On("GetArtistImages", ctx, "artist-endash", mock.AnythingOfType("string"), "").- Return([]agents.ExternalImage{- {URL: "http://example.com/rundmc.jpg", Size: 1000},- }, nil).Once()-- })-- When("DevPreserveUnicodeInExternalCalls is true", func() {- BeforeEach(func() {- conf.Server.DevPreserveUnicodeInExternalCalls = true- })- It("preserves Unicode characters in artist names", func() {- // Act- imgURL, err := provider.ArtistImage(ctx, "artist-endash")-- // Assert- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-endash")- // This is the key assertion: ensure the original Unicode name is used- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-endash", originalArtistName, "")- })- })-- When("DevPreserveUnicodeInExternalCalls is false", func() {- BeforeEach(func() {- conf.Server.DevPreserveUnicodeInExternalCalls = false- })-- It("normalizes Unicode characters", func() {- // Act- imgURL, err := provider.ArtistImage(ctx, "artist-endash")-- // Assert- Expect(err).ToNot(HaveOccurred())- Expect(imgURL).To(Equal(expectedURL))- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-endash")- // This assertion ensures the normalized name is used (en dash → hyphen)- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-endash", normalizedArtistName, "")- })- })- })-})--// mockArtistImageAgent implementation using testify/mock-// This remains local as it's specific to testing the ArtistImage functionality-type mockArtistImageAgent struct {- mock.Mock- agents.ArtistImageRetriever // Embed interface-}--// Constructor for the mock agent-func newMockArtistImageAgent() *mockArtistImageAgent {- mock := new(mockArtistImageAgent)- // Set default AgentName if needed, although usually called via mockAgents- mock.On("AgentName").Return("mockImage").Maybe()- return mock-}--func (m *mockArtistImageAgent) AgentName() string {- args := m.Called()- return args.String(0)-}--func (m *mockArtistImageAgent) GetArtistImages(ctx context.Context, id, artistName, mbid string) ([]agents.ExternalImage, error) {- args := m.Called(ctx, id, artistName, mbid)- // Need careful type assertion for potentially nil slice- var res []agents.ExternalImage- if args.Get(0) != nil {- res = args.Get(0).([]agents.ExternalImage)- }- return res, args.Error(1)-}--// Ensure mockAgent implements the interface-var _ agents.ArtistImageRetriever = (*mockArtistImageAgent)(nil)diff --git a/core/playlists/import_test.go b/core/playlists/import_test.goindex f2866fb60..2a84d56b2 100644--- a/core/playlists/import_test.go+++ b/core/playlists/import_test.go@@ -11,7 +11,7 @@ import ("github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/conf/configtest"- "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/playlists""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/criteria"@@ -43,7 +43,7 @@ var _ = Describe("Playlists - Import", func() {var folder *model.FolderBeforeEach(func() {DeferCleanup(configtest.SetupConfig())- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))ds.MockedMediaFile = &mockedMediaFileRepo{}libPath, _ := os.Getwd()// Set up library with the actual library path that matches the folder@@ -118,7 +118,7 @@ var _ = Describe("Playlists - Import", func() {mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3", "test.ogg"}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")@@ -136,7 +136,7 @@ var _ = Describe("Playlists - Import", func() {mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")@@ -155,7 +155,7 @@ var _ = Describe("Playlists - Import", func() {mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")@@ -174,7 +174,7 @@ var _ = Describe("Playlists - Import", func() {mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")@@ -192,7 +192,7 @@ var _ = Describe("Playlists - Import", func() {mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")@@ -209,7 +209,7 @@ var _ = Describe("Playlists - Import", func() {mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")@@ -226,7 +226,7 @@ var _ = Describe("Playlists - Import", func() {mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")@@ -244,7 +244,7 @@ var _ = Describe("Playlists - Import", func() {mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")@@ -258,7 +258,7 @@ var _ = Describe("Playlists - Import", func() {tmpDir := GinkgoT().TempDir()mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))m3u := "#EXTALBUMARTURL:https://example.com/new-cover.jpg\ntest.mp3\n"plsFile := filepath.Join(tmpDir, "test.m3u")@@ -285,7 +285,7 @@ var _ = Describe("Playlists - Import", func() {tmpDir := GinkgoT().TempDir()mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFile := filepath.Join(tmpDir, "test.m3u")Expect(os.WriteFile(plsFile, []byte("test.mp3\n"), 0600)).To(Succeed())@@ -311,7 +311,7 @@ var _ = Describe("Playlists - Import", func() {tmpDir := GinkgoT().TempDir()mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))m3u := "test.mp3\n"plsFile := filepath.Join(tmpDir, "test.m3u")@@ -388,7 +388,7 @@ var _ = Describe("Playlists - Import", func() {tmpDir := GinkgoT().TempDir()mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{}}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))// Create the playlist file on disk with the filesystem's normalization formplsFile := tmpDir + "/" + filesystemName + ".m3u"@@ -448,7 +448,7 @@ var _ = Describe("Playlists - Import", func() {"def.mp3", // This is playlists/def.mp3 relative to plsDir},}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))})It("handles relative paths that reference files in other libraries", func() {@@ -604,7 +604,7 @@ var _ = Describe("Playlists - Import", func() {},}// Recreate playlists service to pick up new mock- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))// Create playlist in music library that references both tracksplsContent := "#PLAYLIST:Same Path Test\nalbum/track.mp3\n../classical/album/track.mp3"@@ -662,7 +662,7 @@ var _ = Describe("Playlists - Import", func() {},}ds.MockedFolder = mockFolderRepo- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsContent := "#PLAYLIST:My Playlist\ntest.mp3\ntest.ogg\n"plsFile := filepath.Join(tmpDir, "my-playlist.m3u")@@ -681,7 +681,7 @@ var _ = Describe("Playlists - Import", func() {libDir := filepath.Join(tmpDir, "music")Expect(os.Mkdir(libDir, 0755)).To(Succeed())mockLibRepo.SetData([]model.Library{{ID: 1, Path: libDir}})- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsContent := "#PLAYLIST:External Playlist\n" + libDir + "/test.mp3\n"plsFile := filepath.Join(tmpDir, "external.m3u")@@ -704,7 +704,7 @@ var _ = Describe("Playlists - Import", func() {},}ds.MockedFolder = mockFolderRepo- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFile := filepath.Join(tmpDir, "test.m3u")Expect(os.WriteFile(plsFile, []byte("test.mp3\n"), 0600)).To(Succeed())@@ -724,7 +724,7 @@ var _ = Describe("Playlists - Import", func() {},}ds.MockedFolder = mockFolderRepo- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFile := filepath.Join(tmpDir, "test.m3u")Expect(os.WriteFile(plsFile, []byte("test.mp3\n"), 0600)).To(Succeed())@@ -744,7 +744,7 @@ var _ = Describe("Playlists - Import", func() {},}ds.MockedFolder = mockFolderRepo- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))plsFile := filepath.Join(tmpDir, "test.m3u")Expect(os.WriteFile(plsFile, []byte("test.mp3\n"), 0600)).To(Succeed())@@ -767,7 +767,7 @@ var _ = Describe("Playlists - Import", func() {BeforeEach(func() {repo = &mockedMediaFileFromListRepo{}ds.MockedMediaFile = repo- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))mockLibRepo.SetData([]model.Library{{ID: 1, Path: "/music"}, {ID: 2, Path: "/new"}})ctx = request.WithUser(ctx, model.User{ID: "123"})})diff --git a/core/playlists/playlists.go b/core/playlists/playlists.goindex 1ef083bbb..656bde05e 100644--- a/core/playlists/playlists.go+++ b/core/playlists/playlists.go@@ -52,11 +52,12 @@ type Playlists interface {TracksRepository(ctx context.Context, playlistId string, refreshSmartPlaylist bool) rest.Repository}-// ImageUploadService is a local interface satisfied by core.ImageUploadService.-// Defined here to avoid an import cycle between core and core/playlists.+// ImageUploadService is a local interface satisfied by artwork.Uploader.+// Defined here to avoid an import cycle between core/artwork and core/playlists.type ImageUploadService interface {SetImage(ctx context.Context, entityType string, entityID string, name string, oldPath string, reader io.Reader, ext string) (filename string, err error)RemoveImage(ctx context.Context, path string) error+ EnqueueArtwork(ctx context.Context, entityType, entityID string)}type playlists struct {@@ -320,7 +321,11 @@ func (s *playlists) SetImage(ctx context.Context, playlistID string, reader io.R}pls.UploadedImage = filename- return s.ds.Playlist(ctx).Put(pls)+ if err := s.ds.Playlist(ctx).Put(pls); err != nil {+ return err+ }+ s.imgUpload.EnqueueArtwork(ctx, consts.EntityPlaylist, pls.ID)+ return nil}func (s *playlists) RemoveImage(ctx context.Context, playlistID string) error {@@ -334,5 +339,9 @@ func (s *playlists) RemoveImage(ctx context.Context, playlistID string) error {}pls.UploadedImage = ""- return s.ds.Playlist(ctx).Put(pls)+ if err := s.ds.Playlist(ctx).Put(pls); err != nil {+ return err+ }+ s.imgUpload.EnqueueArtwork(ctx, consts.EntityPlaylist, pls.ID)+ return nil}diff --git a/core/playlists/playlists_test.go b/core/playlists/playlists_test.goindex 0c9674bed..e8134b2ef 100644--- a/core/playlists/playlists_test.go+++ b/core/playlists/playlists_test.go@@ -8,7 +8,7 @@ import ("github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/conf/configtest"- "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/playlists""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/criteria"@@ -42,7 +42,7 @@ var _ = Describe("Playlists", func() {"pls-1": {ID: "pls-1", Name: "My Playlist", OwnerID: "user-1"},}mockPlsRepo.TracksRepo = mockTracks- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))})It("allows owner to delete their playlist", func() {@@ -82,7 +82,7 @@ var _ = Describe("Playlists", func() {"pls-1": {ID: "pls-1", Name: "My Playlist", OwnerID: "user-1"},}mockPlsRepo.TracksRepo = mockTracks- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))})It("returns the playlist's track repository", func() {@@ -103,7 +103,7 @@ var _ = Describe("Playlists", func() {"pls-smart": {ID: "pls-smart", Name: "Smart", OwnerID: "user-1",Rules: &criteria.Criteria{Expression: criteria.Contains{"title": "test"}}},}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))})It("creates a new playlist with owner set from context", func() {@@ -161,7 +161,7 @@ var _ = Describe("Playlists", func() {Rules: &criteria.Criteria{Expression: criteria.Contains{"title": "test"}}},}mockPlsRepo.TracksRepo = mockTracks- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))})It("allows owner to update their playlist", func() {@@ -219,7 +219,7 @@ var _ = Describe("Playlists", func() {"pls-other": {ID: "pls-other", Name: "Other's", OwnerID: "other-user"},}mockPlsRepo.TracksRepo = mockTracks- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))})It("allows owner to add tracks", func() {@@ -267,7 +267,7 @@ var _ = Describe("Playlists", func() {Rules: &criteria.Criteria{Expression: criteria.Contains{"title": "test"}}},}mockPlsRepo.TracksRepo = mockTracks- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))})It("allows owner to remove tracks", func() {@@ -301,7 +301,7 @@ var _ = Describe("Playlists", func() {Rules: &criteria.Criteria{Expression: criteria.Contains{"title": "test"}}},}mockPlsRepo.TracksRepo = mockTracks- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))})It("allows owner to reorder", func() {@@ -330,7 +330,7 @@ var _ = Describe("Playlists", func() {"pls-1": {ID: "pls-1", Name: "My Playlist", OwnerID: "user-1"},"pls-other": {ID: "pls-other", Name: "Other's", OwnerID: "other-user"},}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))})It("saves image file and updates UploadedImage", func() {@@ -400,7 +400,7 @@ var _ = Describe("Playlists", func() {"pls-empty": {ID: "pls-empty", Name: "No Cover", OwnerID: "user-1"},"pls-other": {ID: "pls-other", Name: "Other's", OwnerID: "other-user"},}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))})It("removes file and clears UploadedImage", func() {@@ -420,6 +420,24 @@ var _ = Describe("Playlists", func() {Expect(mockPlsRepo.Last.UploadedImage).To(BeEmpty())})+ It("clears the resolved artwork state and re-queues after removing an upload", func() {+ ctx = request.WithUser(ctx, model.User{ID: "user-1", IsAdmin: false})+ Expect(ds.Artwork(ctx).PutItemArtwork(&model.ItemArtwork{+ ItemKind: "pl", ItemID: "pls-1", Hash: "oldhash", Source: "upload",+ })).To(Succeed())++ Expect(ps.RemoveImage(ctx, "pls-1")).To(Succeed())++ _, err := ds.Artwork(ctx).GetItemArtwork(model.KindPlaylistArtwork, "pls-1", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ queued, _ := ds.ArtworkQueue(ctx).DequeueBatch(100)+ Expect(queued).To(ContainElement(SatisfyAll(+ HaveField("ItemKind", "pl"),+ HaveField("ItemID", "pls-1"),+ HaveField("Priority", model.ArtworkPriorityBump),+ )))+ })+It("denies non-owner", func() {ctx = request.WithUser(ctx, model.User{ID: "other-user", IsAdmin: false})err := ps.RemoveImage(ctx, "pls-1")diff --git a/core/playlists/rest_adapter_test.go b/core/playlists/rest_adapter_test.goindex 58a327bde..7ae376b07 100644--- a/core/playlists/rest_adapter_test.go+++ b/core/playlists/rest_adapter_test.go@@ -5,7 +5,7 @@ import ("time""github.com/deluan/rest"- "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/playlists""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/criteria"@@ -37,7 +37,7 @@ var _ = Describe("REST Adapter", func() {mockPlsRepo.Data = map[string]*model.Playlist{"pls-1": {ID: "pls-1", Name: "My Playlist", OwnerID: "user-1"},}- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))})Describe("Save", func() {diff --git a/core/wire_providers.go b/core/wire_providers.goindex a2fffa34f..a09fcc108 100644--- a/core/wire_providers.go+++ b/core/wire_providers.go@@ -24,8 +24,6 @@ var Set = wire.NewSet(NewLibrary,NewUser,NewMaintenance,- NewImageUploadService,- wire.Bind(new(playlists.ImageUploadService), new(ImageUploadService)),stream.NewTranscodeDecider,agents.GetAgents,external.NewProvider,diff --git a/db/db.go b/db/db.goindex 4ca996fe5..11a05b456 100644--- a/db/db.go+++ b/db/db.go@@ -4,6 +4,7 @@ import ("context""database/sql""embed"+ "errors""fmt""time"@@ -106,6 +107,17 @@ func Init(ctx context.Context) func() {}}+// ErrorCodes reports the SQLite result code and extended result code carried by err.+// The extended code is what distinguishes errors that share a message: "database is locked"+// is both SQLITE_BUSY, which busy_timeout retries, and SQLITE_BUSY_SNAPSHOT, which it never can.+func ErrorCodes(err error) (code, extended int, ok bool) {+ var se sqlite3.Error+ if !errors.As(err, &se) {+ return 0, 0, false+ }+ return int(se.Code), int(se.ExtendedCode), true+}+type statusLogger struct{ numPending int }func (*statusLogger) Fatalf(format string, v ...any) { log.Fatal(fmt.Sprintf(format, v...)) }diff --git a/db/migrations/20260722023032_add_artwork_tables.sql b/db/migrations/20260722023032_add_artwork_tables.sqlnew file mode 100644index 000000000..e307d13e8--- /dev/null+++ b/db/migrations/20260722023032_add_artwork_tables.sql@@ -0,0 +1,46 @@+-- +goose Up+CREATE TABLE artwork (+ hash TEXT PRIMARY KEY,+ mime TEXT NOT NULL,+ width INTEGER NOT NULL DEFAULT 0,+ height INTEGER NOT NULL DEFAULT 0,+ size_bytes INTEGER NOT NULL DEFAULT 0,+ blur_hash TEXT NOT NULL DEFAULT '',+ thumb_hash TEXT NOT NULL DEFAULT '',+ dominant_color TEXT NOT NULL DEFAULT '',+ created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP+);++CREATE TABLE item_artwork (+ item_kind TEXT NOT NULL,+ item_id TEXT NOT NULL,+ image_type TEXT NOT NULL DEFAULT 'primary',+ hash TEXT NOT NULL DEFAULT '',+ source TEXT NOT NULL DEFAULT '',+ source_path TEXT NOT NULL DEFAULT '',+ ref_mtime INTEGER NOT NULL DEFAULT 0,+ attempted_at TIMESTAMP,+ updated_at TIMESTAMP,+ PRIMARY KEY (item_kind, item_id, image_type)+) WITHOUT ROWID;+CREATE INDEX ix_item_artwork_hash ON item_artwork(hash);++CREATE TABLE artwork_queue (+ item_kind TEXT NOT NULL,+ item_id TEXT NOT NULL,+ image_type TEXT NOT NULL DEFAULT 'primary',+ priority INTEGER NOT NULL DEFAULT 0,+ attempts INTEGER NOT NULL DEFAULT 0,+ retry_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,+ enqueued_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,+ PRIMARY KEY (item_kind, item_id, image_type)+) WITHOUT ROWID;+-- Ordered to match DequeueBatch (priority DESC, enqueued_at) so drains stop after n rows; retry_at makes it covering.+-- item_kind leads: each drain pool dequeues only its own kinds, so it must seek straight to+-- them rather than scan past another pool's backlog.+CREATE INDEX ix_artwork_queue_drain ON artwork_queue(item_kind, priority DESC, enqueued_at, retry_at);++-- +goose Down+DROP TABLE artwork_queue;+DROP TABLE item_artwork;+DROP TABLE artwork;diff --git a/go.mod b/go.modindex 5488b41e4..b72f4035c 100644--- a/go.mod+++ b/go.mod@@ -57,6 +57,7 @@ require (github.com/tetratelabs/wazero v1.12.0github.com/unrolled/secure v1.17.0github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342+ github.com/zeebo/xxh3 v1.1.0go.senan.xyz/taglib v0.11.1go.uber.org/goleak v1.3.0golang.org/x/image v0.44.0@@ -128,7 +129,6 @@ require (github.com/subosito/gotenv v1.6.0 // indirectgithub.com/tetratelabs/wabin v0.0.0-20230304001439-f6f874872834 // indirectgithub.com/valyala/fastjson v1.6.10 // indirect- github.com/zeebo/xxh3 v1.1.0 // indirectgo.opentelemetry.io/proto/otlp v1.10.0 // indirectgo.uber.org/multierr v1.11.0 // indirectgo.yaml.in/yaml/v2 v2.4.3 // indirectdiff --git a/log/formatters.go b/log/formatters.goindex 0b27f3a43..5d864dae4 100644--- a/log/formatters.go+++ b/log/formatters.go@@ -26,8 +26,15 @@ func ShortDur(d time.Duration) string {default:s = d.String()}- s = strings.TrimSuffix(s, "0s")- return strings.TrimSuffix(s, "0m")+ // Drop whole zero-valued trailing components ("4h0m0s" -> "4h"). The suffix has to include+ // the preceding unit, or a value that merely ends in a zero digit loses it: "10s" -> "1".+ if strings.HasSuffix(s, "m0s") {+ s = strings.TrimSuffix(s, "0s")+ }+ if strings.HasSuffix(s, "h0m") {+ s = strings.TrimSuffix(s, "0m")+ }+ return s}func StringerValue(s fmt.Stringer) string {diff --git a/log/formatters_test.go b/log/formatters_test.goindex 6ed43a094..64d72bdbd 100644--- a/log/formatters_test.go+++ b/log/formatters_test.go@@ -25,6 +25,12 @@ var _ = DescribeTable("ShortDur",Entry("4m3s", 4*time.Minute+3*time.Second, "4m3s"),Entry("4h", 4*time.Hour, "4h"),Entry("4h", 4*time.Hour+2*time.Second, "4h"),+ // A trailing zero digit is significant: only a whole zero-valued component may be dropped.+ Entry("zero", time.Duration(0), "0s"),+ Entry("10s", 10*time.Second, "10s"),+ Entry("20s", 20*time.Second, "20s"),+ Entry("1m30s", time.Minute+30*time.Second, "1m30s"),+ Entry("2h30m", 2*time.Hour+30*time.Minute, "2h30m"),Entry("4h2m", 4*time.Hour+2*time.Minute+5*time.Second+200*time.Millisecond, "4h2m"),)diff --git a/model/album.go b/model/album.goindex 55df8c63c..f27ca12c0 100644--- a/model/album.go+++ b/model/album.go@@ -13,6 +13,7 @@ import (type Album struct {Annotations `structs:"-" hash:"ignore"`+ ItemImage `structs:"-" hash:"ignore"`ID string `structs:"id" json:"id"`LibraryID int `structs:"library_id" json:"libraryId"`@@ -142,6 +143,7 @@ type AlbumRepository interface {UpdateExternalInfo(*Album) errorGet(id string) (*Album, error)GetAll(...QueryOptions) (Albums, error)+ GetAllIDs(...QueryOptions) ([]string, error)GetCursor(...QueryOptions) (AlbumCursor, error)GetYears(libraryIDs ...int) ([]int, error)diff --git a/model/artist.go b/model/artist.goindex f9c4bffd5..f3704b669 100644--- a/model/artist.go+++ b/model/artist.go@@ -11,6 +11,7 @@ import (type Artist struct {Annotations `structs:"-"`+ ItemImage `structs:"-"`ID string `structs:"id" json:"id"`@@ -89,6 +90,7 @@ type ArtistRepository interface {UpdateExternalInfo(a *Artist) errorGet(id string) (*Artist, error)GetAll(options ...QueryOptions) (Artists, error)+ GetAllIDs(options ...QueryOptions) ([]string, error)GetCursor(options ...QueryOptions) (ArtistCursor, error)GetIndex(includeMissing bool, libraryIds []int, roles ...Role) (ArtistIndexes, error)diff --git a/model/artwork.go b/model/artwork.gonew file mode 100644index 000000000..87b424f33--- /dev/null+++ b/model/artwork.go@@ -0,0 +1,144 @@+package model++import "time"++// Artwork is one unique image, identified by the XXH3-64 hash of its bytes.+type Artwork struct {+ Hash string `structs:"hash"`+ Mime string `structs:"mime"`+ Width int `structs:"width"`+ Height int `structs:"height"`+ SizeBytes int64 `structs:"size_bytes"`+ BlurHash string `structs:"blur_hash"`+ ThumbHash string `structs:"thumb_hash"`+ // DominantColor is "#rrggbb": a flat placeholder clients can paint before any decode.+ DominantColor string `structs:"dominant_color"`+ CreatedAt time.Time `structs:"created_at"`+}++const ImageTypePrimary = "primary"++// ItemImage is per-entity artwork state hydrated at query time; never persisted.+type ItemImage struct {+ ImageHash string `structs:"-" json:"imageHash,omitempty"`+ ImageAbsent bool `structs:"-" json:"imageAbsent,omitempty"`+ // BlurHash is Jellyfin's; its mappers read this field directly, so it stays off native JSON.+ BlurHash string `structs:"-" json:"-"`+ ThumbHash string `structs:"-" json:"thumbHash,omitempty"`+ // DominantColor is the only placeholder needing no decode, so it can paint on the first frame.+ DominantColor string `structs:"-" json:"dominantColor,omitempty"`+ // A thumbhash's own aspect is quantised, so clients need these to shape the placeholder exactly.+ ImageWidth int `structs:"-" json:"imageWidth,omitempty"`+ ImageHeight int `structs:"-" json:"imageHeight,omitempty"`+}++// AspectRatio is the image's width/height, or nil when the image or its dimensions are unknown.+func (i ItemImage) AspectRatio() *float64 {+ if i.ImageAbsent || i.ImageWidth <= 0 || i.ImageHeight <= 0 {+ return nil+ }+ return new(float64(i.ImageWidth) / float64(i.ImageHeight))+}++// ItemArtwork is an entity's resolved artwork state. Hash=="" means known absent.+type ItemArtwork struct {+ ItemKind string `structs:"item_kind"`+ ItemID string `structs:"item_id"`+ ImageType string `structs:"image_type"`+ Hash string `structs:"hash"`+ Source string `structs:"source"`+ // SourcePath is the backing file (folder/upload: the image; embedded: the audio file); "" otherwise.+ SourcePath string `structs:"source_path"`+ // RefMtime is SourcePath's mtime (unix-nanoseconds) at resolution; 0 when there is no SourcePath.+ RefMtime int64 `structs:"ref_mtime"`+ // Nullable in the schema, but every insert must set them: these non-pointer fields cannot scan NULL.+ AttemptedAt time.Time `structs:"attempted_at"`+ UpdatedAt time.Time `structs:"updated_at"`+}++// ItemArtworkInfo is the list-hydration projection (item_artwork joined with artwork).+type ItemArtworkInfo struct {+ ItemID string+ Hash string+ BlurHash string+ ThumbHash string+ DominantColor string+ Width int+ Height int+}++// Absent reports a known-absent artwork state (resolved, no image).+func (i ItemArtworkInfo) Absent() bool { return i.Hash == "" }++// Image projects the hydration entry onto the entity-facing struct.+func (i ItemArtworkInfo) Image() ItemImage {+ return ItemImage{+ ImageHash: i.Hash,+ ImageAbsent: i.Absent(),+ BlurHash: i.BlurHash,+ ThumbHash: i.ThumbHash,+ DominantColor: i.DominantColor,+ ImageWidth: i.Width,+ ImageHeight: i.Height,+ }+}++type ArtworkQueueItem struct {+ ItemKind string `structs:"item_kind"`+ ItemID string `structs:"item_id"`+ ImageType string `structs:"image_type"`+ Priority int `structs:"priority"`+ Attempts int `structs:"attempts"`+ RetryAt time.Time `structs:"retry_at"`+ EnqueuedAt time.Time `structs:"enqueued_at"`+}++// Queue priorities: higher drains first.+const (+ ArtworkPriorityRecheck = 0+ ArtworkPriorityBackfill = 10+ ArtworkPriorityScan = 50+ ArtworkPriorityBump = 100+)++// Delete* takes the rows to remove; Purge* finds them itself and reports how many went.+type ArtworkRepository interface {+ GetImage(hash string) (*Artwork, error)+ PutImage(a *Artwork) error+ // PurgeOrphans deletes rows referenced by no item_artwork row and older than cutoff.+ PurgeOrphans(createdBefore time.Time) (int64, error)+ GetItemArtwork(kind Kind, id, imageType string) (*ItemArtwork, error)+ PutItemArtwork(ia *ItemArtwork) error+ DeleteForItems(kind Kind, ids []string) error+ // GetInfoForItems hydrates a page in one batched query.+ GetInfoForItems(kind Kind, ids []string) (map[string]ItemArtworkInfo, error)+ // GetMimeByHash returns hash -> current mime for every stored artwork.+ GetMimeByHash() (map[string]string, error)+ // PurgeDanglingItems removes state rows whose entity no longer exists.+ PurgeDanglingItems() (int64, error)+}++type ArtworkQueueRepository interface {+ // Enqueue upserts; an existing row keeps the higher priority and has its retry_at reset.+ Enqueue(items ...ArtworkQueueItem) error+ // EnqueuePreservingBackoff upserts like Enqueue but preserves an existing row's retry_at, so a+ // request-triggered read-through never resets a failed resolution's backoff.+ EnqueuePreservingBackoff(items ...ArtworkQueueItem) error+ // EnqueueStaleAbsent inserts queue rows (priority Recheck) for absent states older than cutoff.+ EnqueueStaleAbsent(kind Kind, attemptedBefore time.Time) (int64, error)+ // EnqueueAllMissing inserts queue rows for all entities with no item_artwork row, at the given priority.+ EnqueueAllMissing(kind Kind, priority int) (int64, error)+ // EnqueueIfMissing inserts only for items with no item_artwork row yet.+ EnqueueIfMissing(items ...ArtworkQueueItem) error+ // DequeueBatch returns up to n items with retry_at <= now, priority desc, enqueued_at asc.+ // Restricted to the given kinds when any are passed, so one kind cannot block another's drain.+ DequeueBatch(n int, kinds ...string) ([]ArtworkQueueItem, error)+ // MarkFailedIfUnchanged applies the failure backoff only while retry_at still matches+ // seenRetryAt, so a concurrent re-enqueue keeps its fresh eligibility.+ MarkFailedIfUnchanged(kind, id, imageType string, seenRetryAt, retryAt time.Time) error+ // DeleteIfUnchanged deletes only while retry_at still matches, sparing a concurrent re-enqueue.+ DeleteIfUnchanged(kind, id, imageType string, retryAt time.Time) error+ Count() (int64, error)+ // PurgeDangling removes queue rows whose entity no longer exists.+ PurgeDangling() (int64, error)+}diff --git a/model/artwork_id.go b/model/artwork_id.goindex 1bd146c1f..634a6442f 100644--- a/model/artwork_id.go+++ b/model/artwork_id.go@@ -17,6 +17,11 @@ func (k Kind) String() string {return k.name}+// Prefix is the short token used in artwork ids and the item_artwork.item_kind column.+func (k Kind) Prefix() string {+ return k.prefix+}+var (KindMediaFileArtwork = Kind{"mf", "media_file"}KindArtistArtwork = Kind{"ar", "artist"}@@ -35,10 +40,18 @@ var artworkKindMap = map[string]Kind{KindRadioArtwork.prefix: KindRadioArtwork,}+// ParseKind resolves an item_kind prefix (e.g. "al") to its Kind, reporting whether it was known.+// Use it at string boundaries — URL params, the item_kind column — to enter the typed Kind domain.+func ParseKind(prefix string) (Kind, bool) {+ k, ok := artworkKindMap[prefix]+ return k, ok+}+type ArtworkID struct {Kind KindID string- LastUpdate time.Time+ Hash string // content-hash suffix; "" = unknown/none+ LastUpdate time.Time // legacy: populated only when parsing old _<hexTimestamp> tokens}func (id ArtworkID) String() string {@@ -46,14 +59,14 @@ func (id ArtworkID) String() string {return ""}s := fmt.Sprintf("%s-%s", id.Kind.prefix, id.ID)- if lu := id.LastUpdate.Unix(); lu > 0 {- return fmt.Sprintf("%s_%x", s, lu)+ if id.Hash != "" {+ return s + "_" + id.Hash}- return s + "_0"+ return s}func NewArtworkID(kind Kind, id string, lastUpdate *time.Time) ArtworkID {- artID := ArtworkID{kind, id, time.Time{}}+ artID := ArtworkID{Kind: kind, ID: id}if lastUpdate != nil {artID.LastUpdate = *lastUpdate}@@ -75,18 +88,34 @@ func ParseArtworkID(id string) (ArtworkID, error) {}parts = strings.SplitN(parts[1], "_", 2)if len(parts) == 2 {- if parts[1] != "0" {- lastUpdate, err := strconv.ParseInt(parts[1], 16, 64)- if err != nil {- return ArtworkID{}, err+ parsedID.ID = parts[0]+ suffix := parts[1]+ switch {+ // Hash detection must come first: a 16-hex value with the high bit set overflows int64.+ case isImageHash(suffix):+ parsedID.Hash = suffix+ case suffix != "0":+ if lastUpdate, err := strconv.ParseInt(suffix, 16, 64); err == nil {+ parsedID.LastUpdate = time.Unix(lastUpdate, 0)}- parsedID.LastUpdate = time.Unix(lastUpdate, 0)}- parsedID.ID = parts[0]}return parsedID, nil}+// isImageHash reports whether s is a 16-char lowercase-hex XXH3-64 content hash.+func isImageHash(s string) bool {+ if len(s) != 16 {+ return false+ }+ for _, c := range s {+ if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {+ return false+ }+ }+ return true+}+func MustParseArtworkID(id string) ArtworkID {artID, err := ParseArtworkID(id)if err != nil {@@ -112,40 +141,21 @@ func ParseDiscArtworkID(id string) (albumID string, discNumber int, err error) {}func artworkIDFromAlbum(al Album) ArtworkID {- return ArtworkID{- Kind: KindAlbumArtwork,- ID: al.ID,- LastUpdate: al.UpdatedAt,- }+ return ArtworkID{Kind: KindAlbumArtwork, ID: al.ID, Hash: al.ImageHash}}func artworkIDFromMediaFile(mf MediaFile) ArtworkID {- return ArtworkID{- Kind: KindMediaFileArtwork,- ID: mf.ID,- LastUpdate: mf.UpdatedAt,- }+ return ArtworkID{Kind: KindMediaFileArtwork, ID: mf.ID, Hash: mf.ImageHash}}func artworkIDFromPlaylist(pls Playlist) ArtworkID {- return ArtworkID{- Kind: KindPlaylistArtwork,- ID: pls.ID,- LastUpdate: pls.UpdatedAt,- }+ return ArtworkID{Kind: KindPlaylistArtwork, ID: pls.ID, Hash: pls.ImageHash}}func artworkIDFromArtist(ar Artist) ArtworkID {- return ArtworkID{- Kind: KindArtistArtwork,- ID: ar.ID,- }+ return ArtworkID{Kind: KindArtistArtwork, ID: ar.ID, Hash: ar.ImageHash}}func artworkIDFromRadio(r Radio) ArtworkID {- return ArtworkID{- Kind: KindRadioArtwork,- ID: r.ID,- LastUpdate: r.UpdatedAt,- }+ return ArtworkID{Kind: KindRadioArtwork, ID: r.ID, Hash: r.ImageHash}}diff --git a/model/artwork_id_test.go b/model/artwork_id_test.goindex ad66f7bb5..af6a12ffb 100644--- a/model/artwork_id_test.go+++ b/model/artwork_id_test.go@@ -9,14 +9,31 @@ import ()var _ = Describe("ArtworkID", func() {+ Describe("String()", func() {+ It("returns a bare id when there is no hash", func() {+ id := model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1234"}+ Expect(id.String()).To(Equal("al-1234"))+ })+ It("appends the hash suffix when set", func() {+ id := model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1234", Hash: "abcdef0123456789"}+ Expect(id.String()).To(Equal("al-1234_abcdef0123456789"))+ })+ It("never emits a legacy timestamp/_0 suffix", func() {+ id := model.NewArtworkID(model.KindAlbumArtwork, "1234", new(time.Now()))+ Expect(id.String()).To(Equal("al-1234"))+ })+ It("returns empty string for an empty id", func() {+ Expect(model.ArtworkID{Kind: model.KindAlbumArtwork}.String()).To(BeEmpty())+ })+ })+Describe("NewArtworkID()", func() {- It("creates a valid parseable ArtworkID", func() {+ It("round-trips Kind and ID through String()", func() {id := model.NewArtworkID(model.KindAlbumArtwork, "1234", new(time.Now()))parsedId, err := model.ParseArtworkID(id.String())Expect(err).ToNot(HaveOccurred())Expect(parsedId.Kind).To(Equal(id.Kind))Expect(parsedId.ID).To(Equal(id.ID))- Expect(parsedId.LastUpdate.Unix()).To(Equal(id.LastUpdate.Unix()))})It("creates a valid ArtworkID without lastUpdate info", func() {id := model.NewArtworkID(model.KindPlaylistArtwork, "1234", nil)@@ -24,18 +41,16 @@ var _ = Describe("ArtworkID", func() {Expect(err).ToNot(HaveOccurred())Expect(parsedId.Kind).To(Equal(id.Kind))Expect(parsedId.ID).To(Equal(id.ID))- Expect(parsedId.LastUpdate.Unix()).To(Equal(id.LastUpdate.Unix()))})})+Describe("ParseArtworkID - disc kind", func() {It("parses a disc artwork ID with dc prefix", func() {- now := time.Now()- id := model.NewArtworkID(model.KindDiscArtwork, "albumid123:2", &now)+ id := model.NewArtworkID(model.KindDiscArtwork, "albumid123:2", nil)parsedId, err := model.ParseArtworkID(id.String())Expect(err).ToNot(HaveOccurred())Expect(parsedId.Kind).To(Equal(model.KindDiscArtwork))Expect(parsedId.ID).To(Equal("albumid123:2"))- Expect(parsedId.LastUpdate.Unix()).To(Equal(now.Unix()))})})@@ -67,6 +82,7 @@ var _ = Describe("ArtworkID", func() {Expect(err).ToNot(HaveOccurred())Expect(id.Kind).To(Equal(model.KindAlbumArtwork))Expect(id.ID).To(Equal("1234"))+ Expect(id.Hash).To(BeEmpty())})It("parses media file artwork ids", func() {id, err := model.ParseArtworkID("mf-a6f8d2b1")@@ -74,12 +90,45 @@ var _ = Describe("ArtworkID", func() {Expect(id.Kind).To(Equal(model.KindMediaFileArtwork))Expect(id.ID).To(Equal("a6f8d2b1"))})- It("parses playlists artwork ids", func() {+ It("parses playlist artwork ids with dashed UUID", func() {id, err := model.ParseArtworkID("pl-18690de0-151b-4d86-81cb-f418a907315a")Expect(err).ToNot(HaveOccurred())Expect(id.Kind).To(Equal(model.KindPlaylistArtwork))Expect(id.ID).To(Equal("18690de0-151b-4d86-81cb-f418a907315a"))})+ It("captures a 16-hex suffix as Hash", func() {+ id, err := model.ParseArtworkID("al-1234_abcdef0123456789")+ Expect(err).ToNot(HaveOccurred())+ Expect(id.ID).To(Equal("1234"))+ Expect(id.Hash).To(Equal("abcdef0123456789"))+ Expect(id.LastUpdate.IsZero()).To(BeTrue())+ })+ It("captures a high-bit 16-hex suffix as Hash without error", func() {+ id, err := model.ParseArtworkID("al-1234_ffffffffffffffff")+ Expect(err).ToNot(HaveOccurred())+ Expect(id.ID).To(Equal("1234"))+ Expect(id.Hash).To(Equal("ffffffffffffffff"))+ })+ It("parses a legacy hex-timestamp suffix as LastUpdate", func() {+ id, err := model.ParseArtworkID("al-123_688a1b2c")+ Expect(err).ToNot(HaveOccurred())+ Expect(id.ID).To(Equal("123"))+ Expect(id.Hash).To(BeEmpty())+ Expect(id.LastUpdate.Unix()).To(Equal(int64(0x688a1b2c)))+ })+ It("parses a legacy _0 suffix", func() {+ id, err := model.ParseArtworkID("al-123_0")+ Expect(err).ToNot(HaveOccurred())+ Expect(id.ID).To(Equal("123"))+ Expect(id.Hash).To(BeEmpty())+ Expect(id.LastUpdate.IsZero()).To(BeTrue())+ })+ It("silently drops a garbage suffix", func() {+ id, err := model.ParseArtworkID("al-123_zz")+ Expect(err).ToNot(HaveOccurred())+ Expect(id.ID).To(Equal("123"))+ Expect(id.Hash).To(BeEmpty())+ })It("fails to parse malformed ids", func() {_, err := model.ParseArtworkID("a6f8d2b1")Expect(err).To(MatchError("invalid artwork id"))diff --git a/model/artwork_test.go b/model/artwork_test.gonew file mode 100644index 000000000..baf741e68--- /dev/null+++ b/model/artwork_test.go@@ -0,0 +1,73 @@+package model_test++import (+ "encoding/json"++ "github.com/navidrome/navidrome/model"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++func jsonOf(v any) map[string]any {+ GinkgoHelper()+ data, err := json.Marshal(v)+ Expect(err).ToNot(HaveOccurred())+ var out map[string]any+ Expect(json.Unmarshal(data, &out)).To(Succeed())+ return out+}++var _ = Describe("ItemImage JSON", func() {+ It("exposes the artwork state a client needs to render a placeholder", func() {+ al := model.Album{ID: "al-1", Name: "Album"}+ al.ImageHash = "0123456789abcdef"+ al.ThumbHash = "1QcSHQRn"+ al.ImageWidth, al.ImageHeight = 1200, 800++ Expect(jsonOf(al)).To(SatisfyAll(+ HaveKeyWithValue("imageHash", "0123456789abcdef"),+ HaveKeyWithValue("thumbHash", "1QcSHQRn"),+ HaveKeyWithValue("imageWidth", BeNumerically("==", 1200)),+ HaveKeyWithValue("imageHeight", BeNumerically("==", 800)),+ ))+ })++ It("keeps the blurhash off the native API, where nothing consumes it", func() {+ al := model.Album{ID: "al-1", Name: "Album"}+ al.BlurHash = "LEHV6nWB2yk8"+ Expect(jsonOf(al)).ToNot(HaveKey("blurHash"))+ })++ It("omits every artwork field when the entity has none", func() {+ out := jsonOf(model.Album{ID: "al-2", Name: "Album"})+ for _, key := range []string{+ "imageHash", "blurHash", "thumbHash", "imageAbsent", "imageWidth", "imageHeight",+ } {+ Expect(out).ToNot(HaveKey(key))+ }+ })++ It("exposes known-absent artwork so clients can skip the request", func() {+ ar := model.Artist{ID: "ar-1", Name: "Artist"}+ ar.ImageAbsent = true+ Expect(jsonOf(ar)).To(HaveKeyWithValue("imageAbsent", true))+ })++ Describe("AspectRatio", func() {+ It("returns width/height", func() {+ img := model.ItemImage{ImageHash: "abc", ImageWidth: 1200, ImageHeight: 800}+ Expect(*img.AspectRatio()).To(BeNumerically("~", 1.5, 0.0001))+ })++ It("returns nil when a dimension is missing, so callers never guess a ratio", func() {+ Expect(model.ItemImage{ImageHash: "abc"}.AspectRatio()).To(BeNil())+ Expect(model.ItemImage{ImageHash: "abc", ImageWidth: 1200}.AspectRatio()).To(BeNil())+ Expect(model.ItemImage{ImageHash: "abc", ImageHeight: 800}.AspectRatio()).To(BeNil())+ })++ It("returns nil for a known-absent image, whatever the dimensions say", func() {+ img := model.ItemImage{ImageAbsent: true, ImageWidth: 1200, ImageHeight: 800}+ Expect(img.AspectRatio()).To(BeNil())+ })+ })+})diff --git a/model/datastore.go b/model/datastore.goindex 94c3c3622..273ca714b 100644--- a/model/datastore.go+++ b/model/datastore.go@@ -40,6 +40,8 @@ type DataStore interface {ScrobbleBuffer(ctx context.Context) ScrobbleBufferRepositoryScrobble(ctx context.Context) ScrobbleRepositoryPlugin(ctx context.Context) PluginRepository+ Artwork(ctx context.Context) ArtworkRepository+ ArtworkQueue(ctx context.Context) ArtworkQueueRepositoryResource(ctx context.Context, model any) ResourceRepositorydiff --git a/model/mediafile.go b/model/mediafile.goindex 22ab7fbbe..ac1fad67b 100644--- a/model/mediafile.go+++ b/model/mediafile.go@@ -24,6 +24,11 @@ import (type MediaFile struct {Annotations `structs:"-" hash:"ignore"`Bookmarkable `structs:"-" hash:"ignore"`+ ItemImage `structs:"-" hash:"ignore"`++ // AlbumImage is the parent album's artwork state, hydrated alongside the track's own so a+ // song's Jellyfin album-art tag can be pixel-versioned without a second query.+ AlbumImage ItemImage `structs:"-" json:"-" hash:"ignore"`ID string `structs:"id" json:"id" hash:"ignore"`PID string `structs:"pid" json:"-" hash:"ignore"`@@ -139,13 +144,15 @@ func (mf MediaFile) CoverArtID() ArtworkID {// otherwise it returns the album artwork ID.func (mf MediaFile) DiscCoverArtID() ArtworkID {if mf.DiscNumber > 0 {- return NewArtworkID(KindDiscArtwork, DiscArtworkID(mf.AlbumID, mf.DiscNumber), nil)+ return ArtworkID{Kind: KindDiscArtwork, ID: DiscArtworkID(mf.AlbumID, mf.DiscNumber), Hash: mf.ImageHash}}return mf.AlbumCoverArtID()}+// AlbumCoverArtID uses AlbumImage, not the track's own ItemImage: an album id must carry the+// album's content hash even when the track resolved art of its own.func (mf MediaFile) AlbumCoverArtID() ArtworkID {- return artworkIDFromAlbum(Album{ID: mf.AlbumID})+ return artworkIDFromAlbum(Album{ID: mf.AlbumID, ItemImage: mf.AlbumImage})}func (mf MediaFile) StructuredLyrics() (LyricList, error) {@@ -542,6 +549,11 @@ type MediaFileRepository interface {GetRandom(options ...QueryOptions) (MediaFiles, error)GetAllByTags(tag TagName, values []string, options ...QueryOptions) (MediaFiles, error)GetCursor(options ...QueryOptions) (MediaFileCursor, error)+ // GetAllIDs returns just the media_file IDs for the same row set as GetAll.+ GetAllIDs(options ...QueryOptions) ([]string, error)+ // GetCursorWithArtwork streams like GetCursor, hydrated, so callers that render images don't+ // pay the scanner's per-row cost; it uses the same id pre-pass as the other cursors.+ GetCursorWithArtwork(options ...QueryOptions) (MediaFileCursor, error)Delete(id string) errorDeleteMissing(ids []string) errorDeleteAllMissing() (int64, error)diff --git a/model/playlist.go b/model/playlist.goindex 185f6f942..9aa54bf13 100644--- a/model/playlist.go+++ b/model/playlist.go@@ -13,6 +13,7 @@ import (type Playlist struct {Annotations `structs:"-"`+ ItemImage `structs:"-"`ID string `structs:"id" json:"id"`Name string `structs:"name" json:"name"`@@ -143,6 +144,7 @@ type PlaylistRepository interface {Get(id string) (*Playlist, error)GetWithTracks(id string, refreshSmartPlaylist, includeMissing bool) (*Playlist, error)GetAll(options ...QueryOptions) (Playlists, error)+ GetAllIDs(options ...QueryOptions) ([]string, error)GetCursor(options ...QueryOptions) (PlaylistCursor, error)FindByPath(path string) (*Playlist, error)Delete(id string) errordiff --git a/model/radio.go b/model/radio.goindex 86f27c24c..466ff48b0 100644--- a/model/radio.go+++ b/model/radio.go@@ -7,6 +7,8 @@ import ()type Radio struct {+ ItemImage `structs:"-"`+ID string `structs:"id" json:"id"`StreamUrl string `structs:"stream_url" json:"streamUrl"`Name string `structs:"name" json:"name"`@@ -30,7 +32,9 @@ type RadioRepository interface {ResourceRepositoryCountAll(options ...QueryOptions) (int64, error)Delete(id string) error+ Exists(id string) (bool, error)Get(id string) (*Radio, error)GetAll(options ...QueryOptions) (Radios, error)+ GetAllIDs(options ...QueryOptions) ([]string, error)Put(u *Radio, colsToUpdate ...string) error}diff --git a/model/radio_test.go b/model/radio_test.goindex 860331f17..6ae74c3f4 100644--- a/model/radio_test.go+++ b/model/radio_test.go@@ -14,12 +14,11 @@ import (var _ = Describe("Radio", func() {Describe("CoverArtID", func() {It("returns a radio artwork ID", func() {- now := time.Now()- r := model.Radio{ID: "rd-1", UpdatedAt: now}+ r := model.Radio{ID: "rd-1", UpdatedAt: time.Now()}artID := r.CoverArtID()Expect(artID.Kind).To(Equal(model.KindRadioArtwork))Expect(artID.ID).To(Equal("rd-1"))- Expect(artID.LastUpdate).To(Equal(now))+ Expect(artID.LastUpdate.IsZero()).To(BeTrue())})})diff --git a/persistence/album_repository.go b/persistence/album_repository.goindex 2bb541003..1ebb09751 100644--- a/persistence/album_repository.go+++ b/persistence/album_repository.go@@ -202,7 +202,9 @@ func (r *albumRepository) CountAll(options ...model.QueryOptions) (int64, error)}func (r *albumRepository) Exists(id string) (bool, error) {- return r.exists(Eq{"album.id": id})+ // The exists() helper applies no library filter, so it would report rows the caller cannot see.+ c, err := r.count(r.applyLibraryFilter(r.newSelect().Where(Eq{"album.id": id})))+ return c > 0, err}func (r *albumRepository) Put(al *model.Album) error {@@ -251,16 +253,36 @@ func (r *albumRepository) GetAll(options ...model.QueryOptions) (model.Albums, eif err != nil {return nil, err}- return res.toModels(), nil+ albums := res.toModels()+ r.hydrateArtwork(albums)+ return albums, nil+}++func (r *albumRepository) hydrateArtwork(albums model.Albums) {+ hydrateItems(r.ctx, r.db, model.KindAlbumArtwork, albums,+ func(a *model.Album) (string, *model.ItemImage) { return a.ID, &a.ItemImage })+}++// GetAllIDs returns the IDs of GetAll's row set, skipping its column projection and JSON decoding.+func (r *albumRepository) GetAllIDs(options ...model.QueryOptions) ([]string, error) {+ sq := r.applyLibraryFilter(r.newSelect(options...).Columns("album.id"))+ if filtersNeedAnnotation(sq) {+ sq = r.withAnnotation(sq, "album.id")+ }+ ids := []string{}+ err := r.queryAllSlice(sq, &ids)+ return ids, err}func (r *albumRepository) GetCursor(options ...model.QueryOptions) (model.AlbumCursor, error) {- sq := r.selectAlbum(options...)- cursor, err := queryWithStableResults[dbAlbum](r.sqlRepository, sq)+ ids, err := r.GetAllIDs(options...)if err != nil {return nil, err}- return wrapAlbumCursor(cursor), nil+ opts := chunkOptions(options, "album.id")+ return model.AlbumCursor(streamByIDs(ids, func(chunk []string) (model.Albums, error) {+ return r.GetAll(opts(chunk))+ })), nil}func (r *albumRepository) GetYears(libraryIDs ...int) ([]int, error) {@@ -405,7 +427,9 @@ func (r *albumRepository) Search(q string, options ...model.QueryOptions) (modelif err != nil {return nil, fmt.Errorf("searching album %q: %w", q, err)}- return res.toModels(), nil+ albums := res.toModels()+ r.hydrateArtwork(albums)+ return albums, nil}func (r *albumRepository) Count(options ...rest.QueryOptions) (int64, error) {diff --git a/persistence/album_repository_test.go b/persistence/album_repository_test.goindex 465617b10..1ead89529 100644--- a/persistence/album_repository_test.go+++ b/persistence/album_repository_test.go@@ -13,6 +13,7 @@ import ("github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/id""github.com/navidrome/navidrome/model/request"+ "github.com/navidrome/navidrome/utils/slice". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega")@@ -84,6 +85,17 @@ var _ = Describe("AlbumRepository", func() {})})+ Describe("GetAllIDs", func() {+ It("returns the same id set as GetAll", func() {+ want, err := albumRepo.GetAll()+ Expect(err).ToNot(HaveOccurred())+ Expect(want).ToNot(BeEmpty())+ ids, err := albumRepo.GetAllIDs()+ Expect(err).ToNot(HaveOccurred())+ Expect(ids).To(ConsistOf(slice.Map(want, func(a model.Album) string { return a.ID })))+ })+ })+Describe("GetAll", func() {var GetAll = func(opts ...model.QueryOptions) (model.Albums, error) {albums, err := albumRepo.GetAll(opts...)@@ -977,6 +989,22 @@ var _ = Describe("AlbumRepository", func() {Expect(got.RGAlbumPeak).To(BeNil())})})++ // Exists must apply the same library filter as Get/GetAll/CountAll.+ Describe("Exists library visibility", func() {+ It("hides an album the user has no library access to", func() {+ Expect(albumRepo.Put(&model.Album{ID: "vis-album", Name: "Vis", LibraryID: 1})).To(Succeed())+ DeferCleanup(func() {+ _, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": "vis-album"}))+ })++ Expect(albumRepo.Exists("vis-album")).To(BeTrue(), "admin sees it")++ restricted := model.User{ID: "restricted_album_user", UserName: "ra", Name: "RA", Email: "[email protected]"}+ rctx := request.WithUser(GinkgoT().Context(), restricted)+ Expect(NewAlbumRepository(rctx, GetDBXBuilder()).Exists("vis-album")).To(BeFalse())+ })+ })})func _p(id, name string, sortName ...string) model.Participant {diff --git a/persistence/artist_repository.go b/persistence/artist_repository.goindex b542dedb4..67d0df448 100644--- a/persistence/artist_repository.go+++ b/persistence/artist_repository.go@@ -6,7 +6,6 @@ import ("encoding/json""errors""fmt"- "iter""os""slices""strings"@@ -250,6 +249,7 @@ func (r *artistRepository) Get(id string) (*model.Artist, error) {return nil, model.ErrNotFound}res := dba.toModels()+ r.hydrateArtwork(res)return &res[0], nil}@@ -261,20 +261,37 @@ func (r *artistRepository) GetAll(options ...model.QueryOptions) (model.Artists,return nil, err}res := dba.toModels()+ r.hydrateArtwork(res)return res, err}+// GetAllIDs returns just the artist IDs for the same row set as GetAll, skipping the+// heavy stats columns and JSON post-processing.+func (r *artistRepository) GetAllIDs(options ...model.QueryOptions) ([]string, error) {+ sq := r.applyLibraryFilterToArtistQuery(r.newSelect(options...).Columns("artist.id")).GroupBy("artist.id")+ if filtersNeedAnnotation(sq) {+ sq = r.withAnnotation(sq, "artist.id")+ }+ ids := []string{}+ err := r.queryAllSlice(sq, &ids)+ return ids, err+}++// hydrateArtwork fills each artist's ImageHash/ImageAbsent from one batched item_artwork lookup.+func (r *artistRepository) hydrateArtwork(artists model.Artists) {+ hydrateItems(r.ctx, r.db, model.KindArtistArtwork, artists,+ func(a *model.Artist) (string, *model.ItemImage) { return a.ID, &a.ItemImage })+}+func (r *artistRepository) GetCursor(options ...model.QueryOptions) (model.ArtistCursor, error) {- sel := r.selectArtist(options...)- cursor, err := queryWithStableResults[dbArtist](r.sqlRepository, sel)+ ids, err := r.GetAllIDs(options...)if err != nil {return nil, err}- return wrapArtistCursor(cursor), nil-}--func wrapArtistCursor(cursor iter.Seq2[dbArtist, error]) model.ArtistCursor {- return model.ArtistCursor(wrapCursor(cursor, func(a dbArtist) *model.Artist { return a.Artist }))+ opts := chunkOptions(options, "artist.id")+ return model.ArtistCursor(streamByIDs(ids, func(chunk []string) (model.Artists, error) {+ return r.GetAll(opts(chunk))+ })), nil}func (r *artistRepository) getIndexKey(a model.Artist) string {@@ -635,7 +652,9 @@ func (r *artistRepository) Search(q string, options ...model.QueryOptions) (modeif err != nil {return nil, fmt.Errorf("searching artist %q: %w", q, err)}- return res.toModels(), nil+ artists := res.toModels()+ r.hydrateArtwork(artists)+ return artists, nil}// searchScope returns the library IDs the search must be restricted to, or nil to skip the filterdiff --git a/persistence/artist_repository_test.go b/persistence/artist_repository_test.goindex dc11ede36..25472ffe1 100644--- a/persistence/artist_repository_test.go+++ b/persistence/artist_repository_test.go@@ -15,6 +15,7 @@ import ("github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/request""github.com/navidrome/navidrome/utils"+ "github.com/navidrome/navidrome/utils/slice". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega")@@ -284,6 +285,17 @@ var _ = Describe("ArtistRepository", func() {})})+ Describe("GetAllIDs", func() {+ It("returns the same id set as GetAll", func() {+ want, err := repo.GetAll()+ Expect(err).ToNot(HaveOccurred())+ Expect(want).ToNot(BeEmpty())+ ids, err := repo.GetAllIDs()+ Expect(err).ToNot(HaveOccurred())+ Expect(ids).To(ConsistOf(slice.Map(want, func(a model.Artist) string { return a.ID })))+ })+ })+Describe("Basic Operations", func() {Describe("Count", func() {It("returns the number of artists in the DB", func() {diff --git a/persistence/artwork_hydration.go b/persistence/artwork_hydration.gonew file mode 100644index 000000000..fa9920f27--- /dev/null+++ b/persistence/artwork_hydration.go@@ -0,0 +1,181 @@+package persistence++import (+ "context"+ "iter"+ "slices"++ . "github.com/Masterminds/squirrel"+ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+ "github.com/pocketbase/dbx"+)++// Keeps the id IN-list under SQLite's bound-parameter limit; a whole multiple of artworkBatchSize+// so a page re-chunks into even hydration batches.+const artworkChunkSize = artworkBatchSize * 3++// streamByIDs yields rows in id chunks through the caller's hydrating fetch. Resolving ids first+// keeps OFFSET out of the joined query.+func streamByIDs[S ~[]T, T any](ids []string, fetch func(chunk []string) (S, error)) iter.Seq2[T, error] {+ return func(yield func(T, error) bool) {+ for chunk := range slices.Chunk(ids, artworkChunkSize) {+ rows, err := fetch(chunk)+ if err != nil {+ var zero T+ yield(zero, err)+ return+ }+ for _, row := range rows {+ if !yield(row, nil) {+ return+ }+ }+ }+ }+}++// chunkOptions narrows options to a chunk of ids, dropping Max/Offset (the id pre-pass already+// consumed them) and reusing Sort, which may be a seeded random expression by now.+func chunkOptions(options []model.QueryOptions, idField string) func([]string) model.QueryOptions {+ var base model.QueryOptions+ if len(options) > 0 {+ base = model.QueryOptions{Sort: options[0].Sort, Order: options[0].Order, Filters: options[0].Filters}+ }+ return func(chunk []string) model.QueryOptions {+ opts := base+ opts.Filters = Eq{idField: chunk}+ if base.Filters != nil {+ opts.Filters = And{base.Filters, opts.Filters}+ }+ return opts+ }+}++// hydrateItemImages returns per-item artwork info in one batched query per kind. On error it logs+// and returns an empty map, so the page still renders.+func hydrateItemImages(ctx context.Context, db dbx.Builder, kind model.Kind, ids []string) map[string]model.ItemArtworkInfo {+ if len(ids) == 0 {+ return map[string]model.ItemArtworkInfo{}+ }+ infos, err := NewArtworkRepository(ctx, db).GetInfoForItems(kind, ids)+ if err != nil {+ log.Error(ctx, "Failed to hydrate artwork info onto page", "kind", kind, err)+ return map[string]model.ItemArtworkInfo{}+ }+ return infos+}++// applyItemImage copies a hydration entry onto img; a missing entry leaves it zero (unresolved).+func applyItemImage(infos map[string]model.ItemArtworkInfo, id string, img *model.ItemImage) {+ if info, ok := infos[id]; ok {+ *img = info.Image()+ }+}++// hydrateItems fills every item's embedded ItemImage from one batched lookup. ref yields an+// item's id and the ItemImage to fill, which is all that differs between the entity kinds.+func hydrateItems[T any](ctx context.Context, db dbx.Builder, kind model.Kind, items []T,+ ref func(*T) (string, *model.ItemImage)) {+ ids := make([]string, len(items))+ for i := range items {+ ids[i], _ = ref(&items[i])+ }+ infos := hydrateItemImages(ctx, db, kind, ids)+ for i := range items {+ id, img := ref(&items[i])+ applyItemImage(infos, id, img)+ }+}++// hydrateMediaFileArtwork mirrors MediaFile.CoverArtID: an embedded-eligible file with resolved own+// art uses it, else it falls back to the album's.+func hydrateMediaFileArtwork(ctx context.Context, db dbx.Builder, mfs model.MediaFiles) {+ if len(mfs) == 0 {+ return+ }+ albumIDs := make([]string, len(mfs))+ var eligibleIDs []string+ for i := range mfs {+ albumIDs[i] = mfs[i].AlbumID+ if mfs[i].HasCoverArt && conf.Server.EnableMediaFileCoverArt {+ eligibleIDs = append(eligibleIDs, mfs[i].ID)+ }+ }+ albumInfos := hydrateItemImages(ctx, db, model.KindAlbumArtwork, albumIDs)+ mfInfos := hydrateItemImages(ctx, db, model.KindMediaFileArtwork, eligibleIDs)+ for i := range mfs {+ mf := &mfs[i]+ applyItemImage(albumInfos, mf.AlbumID, &mf.AlbumImage)+ eligible := mf.HasCoverArt && conf.Server.EnableMediaFileCoverArt+ ownInfo, ownResolved := mfInfos[mf.ID]+ if eligible && ownResolved && !ownInfo.Absent() {+ mf.ItemImage = ownInfo.Image()+ continue+ }+ ownWontResolve := !eligible || (ownResolved && ownInfo.Absent())+ // Inherit the album hash only when serving returns those exact bytes: a multi-disc track is+ // served disc art, and an eligible-but-unresolved one still extracts its own embedded image.+ if album, ok := albumInfos[mf.AlbumID]; ok && !album.Absent() {+ if mf.DiscNumber == 0 && ownWontResolve {+ mf.ItemImage = album.Image()+ }+ continue+ }+ // Mark absent only when serving would definitively yield a placeholder; disc art and+ // still-extractable embedded art both keep a track requestable.+ if mf.DiscNumber > 0 {+ continue+ }+ if album, ok := albumInfos[mf.AlbumID]; ok && album.Absent() && ownWontResolve {+ mf.ImageAbsent = true+ }+ }+}++// hydrateCursor hydrates a streamed cursor in batches, avoiding a per-row query.+func hydrateCursor[T any](cursor iter.Seq2[T, error], hydrate func([]T)) iter.Seq2[T, error] {+ return func(yield func(T, error) bool) {+ buf := make([]T, 0, artworkBatchSize)+ flush := func() bool {+ hydrate(buf)+ for i := range buf {+ if !yield(buf[i], nil) {+ return false+ }+ }+ buf = buf[:0]+ return true+ }+ for row, err := range cursor {+ if err != nil {+ var zero T+ yield(zero, err)+ return+ }+ buf = append(buf, row)+ if len(buf) == artworkBatchSize && !flush() {+ return+ }+ }+ if len(buf) > 0 {+ flush()+ }+ }+}++// hydratePlaylistTrackArtwork hydrates the MediaFile embedded in each playlist track.+func hydratePlaylistTrackArtwork(ctx context.Context, db dbx.Builder, tracks model.PlaylistTracks) {+ if len(tracks) == 0 {+ return+ }+ mfs := make(model.MediaFiles, len(tracks))+ for i := range tracks {+ mfs[i] = tracks[i].MediaFile+ }+ hydrateMediaFileArtwork(ctx, db, mfs)+ for i := range tracks {+ tracks[i].MediaFile = mfs[i]+ }+}diff --git a/persistence/artwork_hydration_test.go b/persistence/artwork_hydration_test.gonew file mode 100644index 000000000..2b52d7d82--- /dev/null+++ b/persistence/artwork_hydration_test.go@@ -0,0 +1,773 @@+package persistence++import (+ "context"+ "errors"+ "fmt"+ "time"++ "github.com/Masterminds/squirrel"+ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest"+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/model/request"+ "github.com/navidrome/navidrome/utils/slice"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+ "github.com/pocketbase/dbx"+)++// seedAnnotations gives each id distinct annotation values, writing them directly so that+// SetRating's average_rating update does not outlive the cleanup.+func seedAnnotations(itemType string, ids ...string) {+ GinkgoHelper()+ when := time.Date(2024, 3, 1, 12, 0, 0, 0, time.UTC)+ for i, id := range ids {+ _, err := GetDBXBuilder().NewQuery(`insert or replace into annotation+ (user_id, item_id, item_type, play_count, play_date, rating, rated_at, starred, starred_at)+ values ({:u}, {:id}, {:t}, {:pc}, {:d}, {:r}, {:d}, 1, {:d})`).+ Bind(dbx.Params{"u": adminUser.ID, "id": id, "t": itemType,+ "pc": i + 1, "r": 4 + i, "d": when.Add(time.Duration(i) * time.Hour)}).Execute()+ Expect(err).ToNot(HaveOccurred())+ }+ DeferCleanup(func() {+ for _, id := range ids {+ _, err := GetDBXBuilder().NewQuery("delete from annotation where user_id={:u} and item_type={:t} and item_id={:id}").+ Bind(dbx.Params{"u": adminUser.ID, "t": itemType, "id": id}).Execute()+ Expect(err).ToNot(HaveOccurred())+ }+ })+}++var _ = Describe("Artwork hydration", func() {+ var ctx context.Context+ var aw model.ArtworkRepository++ putInfo := func(kind, id, hash string) {+ Expect(aw.PutItemArtwork(&model.ItemArtwork{+ ItemKind: kind, ItemID: id, ImageType: model.ImageTypePrimary, Hash: hash,+ })).To(Succeed())+ }++ BeforeEach(func() {+ clearArtworkTables()+ DeferCleanup(clearArtworkTables)+ ctx = request.WithUser(log.NewContext(context.Background()), adminUser)+ aw = NewArtworkRepository(ctx, GetDBXBuilder())+ })++ Describe("albums", func() {+ var repo model.AlbumRepository+ BeforeEach(func() { repo = NewAlbumRepository(ctx, GetDBXBuilder()) })++ It("hydrates the found / known-absent / unresolved states", func() {+ putInfo("al", albumSgtPeppers.ID, "althash11111111")+ putInfo("al", albumAbbeyRoad.ID, "")+ // albumRadioactivity: no row -> unresolved++ all, err := repo.GetAll()+ Expect(err).ToNot(HaveOccurred())+ byID := slice.ToMap(all, func(a model.Album) (string, model.Album) { return a.ID, a })++ Expect(byID[albumSgtPeppers.ID].ImageHash).To(Equal("althash11111111"))+ Expect(byID[albumSgtPeppers.ID].ImageAbsent).To(BeFalse())+ Expect(byID[albumAbbeyRoad.ID].ImageHash).To(BeEmpty())+ Expect(byID[albumAbbeyRoad.ID].ImageAbsent).To(BeTrue())+ Expect(byID[albumRadioactivity.ID].ImageHash).To(BeEmpty())+ Expect(byID[albumRadioactivity.ID].ImageAbsent).To(BeFalse())+ })++ It("hydrates Get", func() {+ putInfo("al", albumSgtPeppers.ID, "gethash22222222")+ got, err := repo.Get(albumSgtPeppers.ID)+ Expect(err).ToNot(HaveOccurred())+ Expect(got.ImageHash).To(Equal("gethash22222222"))+ })++ It("hydrates Search", func() {+ putInfo("al", albumSgtPeppers.ID, "srchash33333333")+ res, err := repo.Search("Peppers", model.QueryOptions{})+ Expect(err).ToNot(HaveOccurred())+ Expect(res).ToNot(BeEmpty())+ Expect(res[0].ImageHash).To(Equal("srchash33333333"))+ })++ It("does not persist ImageHash/ImageAbsent on Put", func() {+ al := albumSgtPeppers+ al.ImageHash = "shouldnotpersist"+ al.ImageAbsent = true+ Expect(repo.(*albumRepository).Put(&al)).To(Succeed())++ got, err := repo.Get(al.ID)+ Expect(err).ToNot(HaveOccurred())+ Expect(got.ImageHash).To(BeEmpty())+ Expect(got.ImageAbsent).To(BeFalse())+ })+ })++ Describe("artists", func() {+ var repo model.ArtistRepository+ BeforeEach(func() { repo = NewArtistRepository(ctx, GetDBXBuilder()) })++ It("hydrates the found / known-absent / unresolved states", func() {+ putInfo("ar", artistBeatles.ID, "arhash444444444")+ putInfo("ar", artistKraftwerk.ID, "")+ // artistCJK: no row -> unresolved++ all, err := repo.GetAll()+ Expect(err).ToNot(HaveOccurred())+ byID := slice.ToMap(all, func(a model.Artist) (string, model.Artist) { return a.ID, a })++ Expect(byID[artistBeatles.ID].ImageHash).To(Equal("arhash444444444"))+ Expect(byID[artistBeatles.ID].ImageAbsent).To(BeFalse())+ Expect(byID[artistKraftwerk.ID].ImageHash).To(BeEmpty())+ Expect(byID[artistKraftwerk.ID].ImageAbsent).To(BeTrue())+ Expect(byID[artistCJK.ID].ImageHash).To(BeEmpty())+ Expect(byID[artistCJK.ID].ImageAbsent).To(BeFalse())+ })++ It("hydrates Get", func() {+ putInfo("ar", artistBeatles.ID, "arget5555555555")+ got, err := repo.Get(artistBeatles.ID)+ Expect(err).ToNot(HaveOccurred())+ Expect(got.ImageHash).To(Equal("arget5555555555"))+ })++ It("hydrates Search", func() {+ putInfo("ar", artistBeatles.ID, "arsrch666666666")+ res, err := repo.Search("Beatles", model.QueryOptions{})+ Expect(err).ToNot(HaveOccurred())+ Expect(res).ToNot(BeEmpty())+ Expect(res[0].ImageHash).To(Equal("arsrch666666666"))+ })+ })++ Describe("playlists", func() {+ var repo model.PlaylistRepository+ BeforeEach(func() { repo = NewPlaylistRepository(ctx, GetDBXBuilder()) })++ It("hydrates the found / known-absent states", func() {+ putInfo("pl", plsBest.ID, "plhash777777777")+ putInfo("pl", plsCool.ID, "")++ all, err := repo.GetAll()+ Expect(err).ToNot(HaveOccurred())+ byID := slice.ToMap(all, func(p model.Playlist) (string, model.Playlist) { return p.ID, p })++ Expect(byID[plsBest.ID].ImageHash).To(Equal("plhash777777777"))+ Expect(byID[plsBest.ID].ImageAbsent).To(BeFalse())+ Expect(byID[plsCool.ID].ImageHash).To(BeEmpty())+ Expect(byID[plsCool.ID].ImageAbsent).To(BeTrue())+ })++ It("hydrates Get", func() {+ putInfo("pl", plsBest.ID, "plget8888888888")+ got, err := repo.Get(plsBest.ID)+ Expect(err).ToNot(HaveOccurred())+ Expect(got.ImageHash).To(Equal("plget8888888888"))+ })++ It("hydrates the tracks reached through a playlist", func() {+ Expect(aw.PutImage(&model.Artwork{Hash: "pltrackhash1234", Mime: "image/jpeg", BlurHash: "LPLBLURhash"})).To(Succeed())+ putInfo("al", songDayInALife.AlbumID, "pltrackhash1234")++ pls, err := repo.GetWithTracks(plsBest.ID, true, false)+ Expect(err).ToNot(HaveOccurred())+ tracks := pls.Tracks+ Expect(tracks).ToNot(BeEmpty())+ byID := slice.ToMap(tracks, func(t model.PlaylistTrack) (string, model.PlaylistTrack) { return t.MediaFile.ID, t })+ Expect(byID).To(HaveKey(songDayInALife.ID))+ Expect(byID[songDayInALife.ID].AlbumImage.ImageHash).To(Equal("pltrackhash1234"))+ Expect(byID[songDayInALife.ID].BlurHash).To(Equal("LPLBLURhash"))++ cursor, err := repo.Tracks(plsBest.ID, true).GetCursor()+ Expect(err).ToNot(HaveOccurred())+ var streamed *model.PlaylistTrack+ for t, err := range cursor {+ Expect(err).ToNot(HaveOccurred())+ if t.MediaFile.ID == songDayInALife.ID {+ streamed = &t+ }+ }+ Expect(streamed).ToNot(BeNil())+ Expect(streamed.AlbumImage.ImageHash).To(Equal("pltrackhash1234"),+ "the streamed cursor Jellyfin uses must hydrate too")+ })+ })++ Describe("radios", func() {+ var repo model.RadioRepository+ BeforeEach(func() { repo = NewRadioRepository(ctx, GetDBXBuilder()) })++ It("hydrates the found / known-absent states", func() {+ putInfo("ra", radioWithHomePage.ID, "rahash999999999")+ putInfo("ra", radioWithoutHomePage.ID, "")++ all, err := repo.GetAll()+ Expect(err).ToNot(HaveOccurred())+ byID := slice.ToMap(all, func(rd model.Radio) (string, model.Radio) { return rd.ID, rd })++ Expect(byID[radioWithHomePage.ID].ImageHash).To(Equal("rahash999999999"))+ Expect(byID[radioWithHomePage.ID].ImageAbsent).To(BeFalse())+ Expect(byID[radioWithoutHomePage.ID].ImageHash).To(BeEmpty())+ Expect(byID[radioWithoutHomePage.ID].ImageAbsent).To(BeTrue())+ })++ It("hydrates Get", func() {+ putInfo("ra", radioWithHomePage.ID, "ragetaaaaaaaaaa")+ got, err := repo.Get(radioWithHomePage.ID)+ Expect(err).ToNot(HaveOccurred())+ Expect(got.ImageHash).To(Equal("ragetaaaaaaaaaa"))+ })+ })++ Describe("mediafiles", func() {+ var repo model.MediaFileRepository++ setCover := func(id string, v bool) {+ _, err := GetDBXBuilder().NewQuery("UPDATE media_file SET has_cover_art={:v} WHERE id={:id}").+ Bind(dbx.Params{"v": v, "id": id}).Execute()+ Expect(err).ToNot(HaveOccurred())+ }++ getByID := func() map[string]model.MediaFile {+ all, err := repo.GetAll()+ Expect(err).ToNot(HaveOccurred())+ return slice.ToMap(all, func(mf model.MediaFile) (string, model.MediaFile) { return mf.ID, mf })+ }++ BeforeEach(func() {+ repo = NewMediaFileRepository(ctx, GetDBXBuilder())+ DeferCleanup(configtest.SetupConfig())+ conf.Server.EnableMediaFileCoverArt = true+ })++ It("resolves the embedded-eligible fallback matrix", func() {+ setCover("1001", true) // eligible, own hash+ setCover("1002", true) // eligible, but embedded art absent -> album+ DeferCleanup(func() { setCover("1001", false); setCover("1002", false) })++ putInfo("al", "101", "alh101xxxxxxxxxx") // song 1001's album (found)+ putInfo("al", "102", "alh102xxxxxxxxxx") // song 1002's album (found)+ putInfo("al", "103", "") // songs 1003/1004 album known-absent+ putInfo("mf", "1001", "mfh1001xxxxxxxx")+ putInfo("mf", "1002", "") // embedded resolved absent++ byID := getByID()++ Expect(byID["1001"].ImageHash).To(Equal("mfh1001xxxxxxxx"))+ Expect(byID["1001"].ImageAbsent).To(BeFalse())+ Expect(byID["1002"].ImageHash).To(Equal("alh102xxxxxxxxxx"))+ Expect(byID["1002"].ImageAbsent).To(BeFalse())+ Expect(byID["1003"].ImageHash).To(BeEmpty())+ Expect(byID["1003"].ImageAbsent).To(BeTrue())+ // 2002: not eligible, and its album has no row at all -> unresolved+ Expect(byID["2002"].ImageHash).To(BeEmpty())+ Expect(byID["2002"].ImageAbsent).To(BeFalse())+ })++ It("populates AlbumImage from hydrateArtwork regardless of which continue branch a track takes", func() {+ setCover("1001", true) // eligible, resolves its own art -> own-art-wins continue+ DeferCleanup(func() { setCover("1001", false) })++ putInfo("al", "101", "alh101albimgxxxx") // 1001's album: own-art-wins branch+ putInfo("al", "102", "alh102albimgxxxx") // 1002's album: single-disc inheritance branch+ putInfo("al", "104", "") // 2002's album: known-absent, multi-disc branch+ putInfo("mf", "1001", "mfh1001albimgxxx")++ byID := getByID()++ Expect(byID["1001"].ImageHash).To(Equal("mfh1001albimgxxx"))+ Expect(byID["1001"].AlbumImage.ImageHash).To(Equal("alh101albimgxxxx"))++ Expect(byID["1002"].ImageHash).To(Equal("alh102albimgxxxx"))+ Expect(byID["1002"].AlbumImage.ImageHash).To(Equal("alh102albimgxxxx"))++ Expect(byID["2002"].ImageHash).To(BeEmpty())+ Expect(byID["2002"].ImageAbsent).To(BeFalse())+ Expect(byID["2002"].AlbumImage.ImageAbsent).To(BeTrue())+ })++ It("carries both hashes and the dimensions alongside the hash in the own-art and inherited branches", func() {+ setCover("1001", true) // eligible, resolves its own art -> own-art-wins branch+ DeferCleanup(func() { setCover("1001", false) })++ Expect(aw.PutImage(&model.Artwork{Hash: "mfh1001blurxxxxx", Mime: "image/jpeg", BlurHash: "LTRACKblur", ThumbHash: "THtrack", Width: 640, Height: 480})).To(Succeed())+ Expect(aw.PutImage(&model.Artwork{Hash: "alh102blurxxxxxx", Mime: "image/jpeg", BlurHash: "LALBUMblur", ThumbHash: "THalbum", Width: 1200, Height: 800})).To(Succeed())+ putInfo("mf", "1001", "mfh1001blurxxxxx")+ putInfo("al", "102", "alh102blurxxxxxx") // 1002's album: single-disc inheritance branch++ byID := getByID()++ Expect(byID["1001"].ImageHash).To(Equal("mfh1001blurxxxxx"))+ Expect(byID["1001"].BlurHash).To(Equal("LTRACKblur"))+ Expect(byID["1001"].ThumbHash).To(Equal("THtrack"))+ Expect(byID["1001"].ImageWidth).To(Equal(640))+ Expect(byID["1001"].ImageHeight).To(Equal(480))++ Expect(byID["1002"].ImageHash).To(Equal("alh102blurxxxxxx"))+ Expect(byID["1002"].BlurHash).To(Equal("LALBUMblur"))+ Expect(byID["1002"].ThumbHash).To(Equal("THalbum"))+ Expect(byID["1002"].ImageWidth).To(Equal(1200))+ Expect(byID["1002"].ImageHeight).To(Equal(800))+ })++ It("keeps an eligible file optimistic when its own art is unresolved, even if the album is absent", func() {+ setCover("1004", true)+ DeferCleanup(func() { setCover("1004", false) })+ putInfo("al", "103", "") // album known-absent++ byID := getByID()++ // 1004's own embedded art is still unresolved, so coverArt must stay requestable.+ Expect(byID["1004"].ImageAbsent).To(BeFalse())+ Expect(byID["1004"].ImageHash).To(BeEmpty())+ // 1003 is not eligible, so it still inherits the album's absence.+ Expect(byID["1003"].ImageAbsent).To(BeTrue())+ })++ It("does not stamp a found album hash onto a multi-disc track (its dc- id is disc-served)", func() {+ putInfo("al", "104", "alh104foundxxxxx") // songs 2002/2004 album is found++ byID := getByID()++ Expect(byID["2002"].ImageHash).To(BeEmpty())+ Expect(byID["2002"].ImageAbsent).To(BeFalse())+ })++ It("keeps a multi-disc track requestable when its album is absent (disc art may resolve)", func() {+ putInfo("al", "104", "") // songs 2002/2004 album known-absent++ byID := getByID()++ Expect(byID["2002"].ImageAbsent).To(BeFalse())+ Expect(byID["2002"].ImageHash).To(BeEmpty())+ })++ // serveMediaFile serves this track's own embedded art, so the album's hash would+ // advertise a content-version for bytes nobody will serve.+ It("leaves the hash bare for an eligible file whose own art is unresolved", func() {+ setCover("1004", true)+ DeferCleanup(func() { setCover("1004", false) })+ putInfo("al", "103", "alh103found11111")++ byID := getByID()+ Expect(byID["1004"].ImageAbsent).To(BeFalse())+ Expect(byID["1004"].ImageHash).To(BeEmpty())+ Expect(byID["1004"].AlbumImage.ImageHash).To(Equal("alh103found11111"),+ "the album's own hash still hydrates, for AlbumCoverArtID")+ })++ It("uses album info for an eligible file when EnableMediaFileCoverArt is off", func() {+ conf.Server.EnableMediaFileCoverArt = false+ setCover("1001", true)+ DeferCleanup(func() { setCover("1001", false) })++ putInfo("al", "101", "alh101offxxxxxxx")+ putInfo("mf", "1001", "mfh1001offxxxxx")++ byID := getByID()+ Expect(byID["1001"].ImageHash).To(Equal("alh101offxxxxxxx"))+ Expect(byID["1001"].ImageAbsent).To(BeFalse())+ })++ It("hydrates Search", func() {+ putInfo("al", "101", "alsrchhhhhhhhhhh")+ res, err := repo.Search("A Day In A Life", model.QueryOptions{})+ Expect(err).ToNot(HaveOccurred())+ Expect(res).ToNot(BeEmpty())+ Expect(res[0].ImageHash).To(Equal("alsrchhhhhhhhhhh"))+ })+ })++ Describe("GetCursor", func() {+ var albumRepo model.AlbumRepository+ var artistRepo model.ArtistRepository+ var playlistRepo model.PlaylistRepository+ var onlyAlbums, onlyArtists, onlyPlaylists squirrel.Eq++ scoped := func(opts model.QueryOptions, only squirrel.Eq) model.QueryOptions {+ if opts.Filters == nil {+ opts.Filters = only+ } else {+ opts.Filters = squirrel.And{only, opts.Filters}+ }+ return opts+ }++ BeforeEach(func() {+ albumRepo = NewAlbumRepository(ctx, GetDBXBuilder())+ artistRepo = NewArtistRepository(ctx, GetDBXBuilder())+ playlistRepo = NewPlaylistRepository(ctx, GetDBXBuilder())+ // Other specs leave rows behind, so scope every cursor spec to the fixtures.+ onlyAlbums = squirrel.Eq{"album.id": []string{albumSgtPeppers.ID, albumAbbeyRoad.ID,+ albumRadioactivity.ID, albumMultiDisc.ID, albumCJK.ID, albumPunctuation.ID}}+ onlyArtists = squirrel.Eq{"artist.id": []string{artistKraftwerk.ID, artistBeatles.ID,+ artistCJK.ID, artistPunctuation.ID}}+ // Both fixture playlists share an owner, leaving the owner_name sort a single value to+ // order by; this one is also private, which the non-admin visibility spec needs.+ foreign := model.Playlist{Name: "Foreign", OwnerID: thirdUser.ID, OwnerName: thirdUser.UserName}+ Expect(playlistRepo.Put(&foreign)).To(Succeed())+ DeferCleanup(func() { Expect(playlistRepo.Delete(foreign.ID)).To(Succeed()) })+ onlyPlaylists = squirrel.Eq{"playlist.id": []string{plsBest.ID, plsCool.ID, foreign.ID}}++ // The suite annotates a single album and artist, leaving the annotation-backed sorts+ // nothing to order.+ seedAnnotations("album", albumSgtPeppers.ID, albumAbbeyRoad.ID)+ seedAnnotations("artist", artistKraftwerk.ID, artistCJK.ID)++ Expect(aw.PutImage(&model.Artwork{+ Hash: "curhash11111111", Mime: "image/jpeg", BlurHash: "LEHV6nWB2yk8",+ })).To(Succeed())+ putInfo("al", albumSgtPeppers.ID, "curhash11111111")+ putInfo("al", albumAbbeyRoad.ID, "")+ putInfo("ar", artistBeatles.ID, "curhash11111111")+ putInfo("pl", plsBest.ID, "curhash11111111")+ })++ It("hydrates every streamed album, like GetAll", func() {+ opts := model.QueryOptions{Sort: "name", Filters: onlyAlbums}+ want, err := albumRepo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())++ got := collectCursor(albumRepo.GetCursor(opts))++ Expect(got).To(ConsistOf(want))+ byID := map[string]model.Album{}+ for _, al := range got {+ byID[al.ID] = al+ }+ Expect(byID[albumSgtPeppers.ID].ImageHash).To(Equal("curhash11111111"))+ Expect(byID[albumSgtPeppers.ID].BlurHash).To(Equal("LEHV6nWB2yk8"))+ Expect(byID[albumAbbeyRoad.ID].ImageAbsent).To(BeTrue())+ Expect(byID[albumRadioactivity.ID].ImageHash).To(BeEmpty())+ Expect(byID[albumRadioactivity.ID].ImageAbsent).To(BeFalse())+ })++ It("hydrates every streamed artist, like GetAll", func() {+ opts := model.QueryOptions{Sort: "name", Filters: onlyArtists}+ want, err := artistRepo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())++ got := collectCursor(artistRepo.GetCursor(opts))++ Expect(got).To(ConsistOf(want))+ Expect(slice.Map(got, func(a model.Artist) string { return a.ImageHash })).+ To(ContainElement("curhash11111111"))+ })++ It("hydrates every streamed playlist, like GetAll", func() {+ opts := model.QueryOptions{Sort: "name", Filters: onlyPlaylists}+ want, err := playlistRepo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())++ got := collectCursor(playlistRepo.GetCursor(opts))++ Expect(got).To(ConsistOf(want))+ Expect(slice.Map(got, func(p model.Playlist) string { return p.ImageHash })).+ To(ContainElement("curhash11111111"))+ })++ It("honors Max and Offset exactly once", func() {+ opts := model.QueryOptions{Sort: "name", Filters: onlyAlbums, Max: 2, Offset: 1}+ want, err := albumRepo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())+ Expect(want).To(HaveLen(2))++ got := collectCursor(albumRepo.GetCursor(opts))++ Expect(slice.Map(got, func(a model.Album) string { return a.ID })).+ To(Equal(slice.Map(want, func(a model.Album) string { return a.ID })))+ })++ // The sorts the Jellyfin list endpoints issue; comparing sort keys, not ids, keeps ties out.+ DescribeTable("orders albums like GetAll",+ func(opts model.QueryOptions, key func(model.Album) string) {+ opts = scoped(opts, onlyAlbums)+ want, err := albumRepo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())+ Expect(want).ToNot(BeEmpty())++ got := collectCursor(albumRepo.GetCursor(opts))++ Expect(slice.Map(got, key)).To(Equal(slice.Map(want, key)))+ Expect(slice.Map(got, func(a model.Album) string { return a.ID })).+ To(ConsistOf(slice.Map(want, func(a model.Album) string { return a.ID })))+ },+ Entry("by name", model.QueryOptions{Sort: "name"},+ func(a model.Album) string { return a.OrderAlbumName }),+ Entry("by artist", model.QueryOptions{Sort: "artist"},+ func(a model.Album) string { return a.OrderAlbumArtistName }),+ Entry("by recently added", model.QueryOptions{Sort: "recently_added", Order: "desc"},+ func(a model.Album) string { return fmt.Sprint(a.CreatedAt) }),+ Entry("by year", model.QueryOptions{Sort: "max_year"},+ func(a model.Album) string { return fmt.Sprint(a.MaxYear) }),+ Entry("by play count", model.QueryOptions{Sort: "play_count", Order: "desc"},+ func(a model.Album) string { return fmt.Sprint(a.PlayCount) }),+ Entry("by last played", model.QueryOptions{Sort: "play_date", Order: "desc"},+ func(a model.Album) string { return fmt.Sprint(a.PlayDate) }),+ Entry("by rating", model.QueryOptions{Sort: "rating", Order: "desc"},+ func(a model.Album) string { return fmt.Sprint(a.Rating) }),+ Entry("starred only", model.QueryOptions{Sort: "starred_at", Order: "desc",+ Filters: squirrel.Eq{"starred": true}},+ func(a model.Album) string { return fmt.Sprint(a.StarredAt) }),+ )++ DescribeTable("orders artists like GetAll",+ func(opts model.QueryOptions, key func(model.Artist) string) {+ opts = scoped(opts, onlyArtists)+ want, err := artistRepo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())+ Expect(want).ToNot(BeEmpty())++ got := collectCursor(artistRepo.GetCursor(opts))++ Expect(slice.Map(got, key)).To(Equal(slice.Map(want, key)))+ Expect(slice.Map(got, func(a model.Artist) string { return a.ID })).+ To(ConsistOf(slice.Map(want, func(a model.Artist) string { return a.ID })))+ },+ Entry("by name", model.QueryOptions{Sort: "name"},+ func(a model.Artist) string { return a.OrderArtistName }),+ Entry("by album count", model.QueryOptions{Sort: "album_count", Order: "desc"},+ func(a model.Artist) string { return fmt.Sprint(a.AlbumCount) }),+ Entry("by song count", model.QueryOptions{Sort: "song_count", Order: "desc"},+ func(a model.Artist) string { return fmt.Sprint(a.SongCount) }),+ Entry("by play count", model.QueryOptions{Sort: "play_count", Order: "desc"},+ func(a model.Artist) string { return fmt.Sprint(a.PlayCount) }),+ Entry("starred only", model.QueryOptions{Sort: "starred_at", Order: "desc",+ Filters: squirrel.Eq{"starred": true}},+ func(a model.Artist) string { return fmt.Sprint(a.StarredAt) }),+ )++ DescribeTable("orders playlists like GetAll",+ func(opts model.QueryOptions, key func(model.Playlist) string) {+ opts = scoped(opts, onlyPlaylists)+ want, err := playlistRepo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())+ Expect(want).ToNot(BeEmpty())++ got := collectCursor(playlistRepo.GetCursor(opts))++ Expect(slice.Map(got, key)).To(Equal(slice.Map(want, key)))+ Expect(slice.Map(got, func(p model.Playlist) string { return p.ID })).+ To(ConsistOf(slice.Map(want, func(p model.Playlist) string { return p.ID })))+ },+ Entry("by name", model.QueryOptions{Sort: "name"},+ func(p model.Playlist) string { return p.Name }),+ Entry("by creation date", model.QueryOptions{Sort: "created_at", Order: "desc"},+ func(p model.Playlist) string { return fmt.Sprint(p.CreatedAt) }),+ Entry("by owner", model.QueryOptions{Sort: "owner_name"},+ func(p model.Playlist) string { return p.OwnerName }),+ )++ It("streams every album exactly once when sorted randomly", func() {+ opts := model.QueryOptions{Sort: "random", Filters: onlyAlbums}+ want, err := albumRepo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())++ got := collectCursor(albumRepo.GetCursor(opts))++ Expect(slice.Map(got, func(a model.Album) string { return a.ID })).+ To(ConsistOf(slice.Map(want, func(a model.Album) string { return a.ID })))+ })++ It("keeps a non-admin from streaming another user's private playlists", func() {+ otherCtx := request.WithUser(log.NewContext(context.Background()), regularUser)+ repo := NewPlaylistRepository(otherCtx, GetDBXBuilder())+ opts := model.QueryOptions{Sort: "name", Filters: onlyPlaylists}++ // Both phases must filter on their own: the id pre-pass and the chunk fetch.+ Expect(repo.GetAllIDs(opts)).To(ConsistOf(plsBest.ID))+ all, err := repo.GetAll(model.QueryOptions{Filters: onlyPlaylists})+ Expect(err).ToNot(HaveOccurred())+ Expect(slice.Map(all, func(p model.Playlist) string { return p.ID })).To(ConsistOf(plsBest.ID))++ got := collectCursor(repo.GetCursor(opts))++ Expect(slice.Map(got, func(p model.Playlist) string { return p.Name })).+ To(ConsistOf(plsBest.Name))+ })+ })++ Describe("GetCursorWithArtwork", func() {+ var mfRepo model.MediaFileRepository+ var onlySongs squirrel.Eq++ BeforeEach(func() {+ mfRepo = NewMediaFileRepository(ctx, GetDBXBuilder())+ putInfo("al", albumSgtPeppers.ID, "curhash11111111")+ // Distinct titles only: other fixture songs share titles (e.g. "Antenna" x3), which+ // would make the positional comparisons against GetAll pass by tie-order coincidence.+ onlySongs = squirrel.Eq{"media_file.id": []string{songDayInALife.ID, songComeTogether.ID,+ songRadioactivity.ID, songAntenna.ID, songDisc1Track01.ID, songCJK.ID, songPunctuation.ID}}+ })++ It("hydrates artwork onto every streamed track, unlike GetCursor", func() {+ opts := model.QueryOptions{Sort: "title", Filters: onlySongs}+ want, err := mfRepo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())+ Expect(want).ToNot(BeEmpty())++ cursor, err := mfRepo.GetCursorWithArtwork(opts)+ Expect(err).ToNot(HaveOccurred())+ var got model.MediaFiles+ cursor(func(mf model.MediaFile, err error) bool {+ Expect(err).ToNot(HaveOccurred())+ got = append(got, mf)+ return true+ })++ Expect(got).To(HaveLen(len(want)))+ for i := range want {+ Expect(got[i].ID).To(Equal(want[i].ID))+ Expect(got[i].ImageHash).To(Equal(want[i].ImageHash))+ Expect(got[i].ImageAbsent).To(Equal(want[i].ImageAbsent))+ Expect(got[i].AlbumImage.ImageHash).To(Equal(want[i].AlbumImage.ImageHash))+ Expect(got[i].AlbumImage.BlurHash).To(Equal(want[i].AlbumImage.BlurHash))+ }+ Expect(want).To(ContainElement(HaveField("AlbumImage.ImageHash", Not(BeEmpty()))),+ "fixture must include at least one track with album artwork, or this proves nothing")+ })++ It("leaves the scanner's GetCursor unhydrated", func() {+ cursor, err := mfRepo.GetCursor(model.QueryOptions{Sort: "title"})+ Expect(err).ToNot(HaveOccurred())+ var seen int+ cursor(func(mf model.MediaFile, err error) bool {+ Expect(err).ToNot(HaveOccurred())+ Expect(mf.AlbumImage.ImageHash).To(BeEmpty(), "GetCursor must stay unhydrated for the scanner")+ seen+++ return true+ })+ Expect(seen).To(BeNumerically(">", 0))+ })++ It("streams the same ids in the same order as GetAll", func() {+ opts := model.QueryOptions{Sort: "title", Filters: onlySongs}+ want, err := mfRepo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())+ Expect(want).ToNot(BeEmpty())++ got := collectCursor(mfRepo.GetCursorWithArtwork(opts))++ Expect(slice.Map(got, func(mf model.MediaFile) string { return mf.ID })).+ To(Equal(slice.Map(want, func(mf model.MediaFile) string { return mf.ID })))+ })++ It("honors Max and Offset exactly once", func() {+ opts := model.QueryOptions{Sort: "title", Filters: onlySongs, Max: 2, Offset: 1}+ want, err := mfRepo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())+ Expect(want).To(HaveLen(2))++ got := collectCursor(mfRepo.GetCursorWithArtwork(opts))++ Expect(slice.Map(got, func(mf model.MediaFile) string { return mf.ID })).+ To(Equal(slice.Map(want, func(mf model.MediaFile) string { return mf.ID })))+ })+ })++ Describe("chunkOptions", func() {+ It("carries Sort, Order and the caller's filters, but never Max/Offset", func() {+ base := model.QueryOptions{Sort: "name", Order: "desc", Max: 10, Offset: 20,+ Filters: squirrel.Eq{"missing": false}}++ got := chunkOptions([]model.QueryOptions{base}, "album.id")([]string{"al-1", "al-2"})++ Expect(got.Max).To(BeZero())+ Expect(got.Offset).To(BeZero())+ Expect(got.Sort).To(Equal("name"))+ Expect(got.Order).To(Equal("desc"))+ Expect(got.Filters).To(Equal(squirrel.And{+ base.Filters, squirrel.Eq{"album.id": []string{"al-1", "al-2"}},+ }))+ })++ It("filters by ids alone when the caller passed no filters", func() {+ got := chunkOptions(nil, "artist.id")([]string{"ar-1"})+ Expect(got.Filters).To(Equal(squirrel.Eq{"artist.id": []string{"ar-1"}}))+ })+ })++ Describe("streamByIDs", func() {+ It("fetches in chunks and yields every row in order", func() {+ ids := make([]string, artworkChunkSize+3)+ for i := range ids {+ ids[i] = fmt.Sprintf("id-%d", i)+ }+ var chunks [][]string+ got := collectCursor(streamByIDs(ids, func(chunk []string) ([]string, error) {+ chunks = append(chunks, chunk)+ return chunk, nil+ }), nil)++ Expect(chunks).To(HaveLen(2))+ Expect(chunks[0]).To(HaveLen(artworkChunkSize))+ Expect(chunks[1]).To(HaveLen(3))+ Expect(got).To(Equal(ids))+ })++ It("yields the fetch error and stops", func() {+ ids := make([]string, artworkChunkSize+1)+ calls := 0+ var errs []error+ for _, err := range streamByIDs(ids, func(chunk []string) ([]string, error) {+ calls+++ return nil, errors.New("boom")+ }) {+ errs = append(errs, err)+ }++ Expect(calls).To(Equal(1))+ Expect(errs).To(HaveLen(1))+ Expect(errs[0]).To(MatchError("boom"))+ })++ It("stops fetching when the consumer breaks", func() {+ ids := make([]string, artworkChunkSize+1)+ calls := 0+ for range streamByIDs(ids, func(chunk []string) ([]string, error) {+ calls+++ return chunk, nil+ }) {+ break+ }++ Expect(calls).To(Equal(1))+ })+ })++ Describe("applyItemImage", func() {+ It("copies hash, absence, blurhash and dimensions onto the item", func() {+ infos := map[string]model.ItemArtworkInfo{+ "al-1": {ItemID: "al-1", Hash: "0123456789abcdef", BlurHash: "LEHV6nWB2yk8", ThumbHash: "1QcSHQRn", Width: 1200, Height: 800},+ }+ var img model.ItemImage+ applyItemImage(infos, "al-1", &img)+ Expect(img.ImageHash).To(Equal("0123456789abcdef"))+ Expect(img.ImageAbsent).To(BeFalse())+ Expect(img.BlurHash).To(Equal("LEHV6nWB2yk8"))+ Expect(img.ThumbHash).To(Equal("1QcSHQRn"))+ Expect(img.ImageWidth).To(Equal(1200))+ Expect(img.ImageHeight).To(Equal(800))+ })++ It("marks a hashless entry absent and carries no blurhash", func() {+ infos := map[string]model.ItemArtworkInfo{"al-2": {ItemID: "al-2"}}+ var img model.ItemImage+ applyItemImage(infos, "al-2", &img)+ Expect(img.ImageAbsent).To(BeTrue())+ Expect(img.BlurHash).To(BeEmpty())+ Expect(img.ThumbHash).To(BeEmpty())+ })++ It("leaves an unresolved item zero-valued", func() {+ var img model.ItemImage+ applyItemImage(map[string]model.ItemArtworkInfo{}, "al-3", &img)+ Expect(img.ImageHash).To(BeEmpty())+ Expect(img.ImageAbsent).To(BeFalse())+ Expect(img.BlurHash).To(BeEmpty())+ })+ })+})diff --git a/persistence/artwork_queue_repository.go b/persistence/artwork_queue_repository.gonew file mode 100644index 000000000..e5469fbea--- /dev/null+++ b/persistence/artwork_queue_repository.go@@ -0,0 +1,149 @@+package persistence++import (+ "cmp"+ "context"+ "fmt"+ "slices"+ "strings"+ "time"++ . "github.com/Masterminds/squirrel"+ "github.com/navidrome/navidrome/model"+ "github.com/pocketbase/dbx"+)++// Keeps each multi-row insert under SQLite's bind-variable limit (at most 7 vars per row).+const enqueueChunkSize = 100++// Every insert writes these, in this order; the INSERT..SELECT forms must project them to match.+var enqueueColumns = []string{"item_kind", "item_id", "image_type", "priority", "attempts", "retry_at", "enqueued_at"}++type artworkQueueRepository struct {+ sqlRepository+}++func NewArtworkQueueRepository(ctx context.Context, db dbx.Builder) model.ArtworkQueueRepository {+ r := &artworkQueueRepository{}+ r.ctx = ctx+ r.db = db+ r.tableName = "artwork_queue"+ return r+}++// Enqueue also resets enqueued_at, so a fresh request does not inherit an old row's spent retry budget.+func (r *artworkQueueRepository) Enqueue(items ...model.ArtworkQueueItem) error {+ return r.enqueue(`ON CONFLICT (item_kind, item_id, image_type) DO UPDATE SET+ priority = MAX(priority, excluded.priority), retry_at = excluded.retry_at,+ attempts = 0, enqueued_at = excluded.enqueued_at`, items)+}++func (r *artworkQueueRepository) EnqueuePreservingBackoff(items ...model.ArtworkQueueItem) error {+ return r.enqueue(`ON CONFLICT (item_kind, item_id, image_type) DO UPDATE SET+ priority = MAX(priority, excluded.priority)`, items)+}++func (r *artworkQueueRepository) EnqueueStaleAbsent(kind model.Kind, attemptedBefore time.Time) (int64, error) {+ now := time.Now()+ return r.insertIfNotQueued("", `SELECT item_kind, item_id, image_type, ?, 0, ?, ?+ FROM `+itemArtworkTable+` WHERE item_kind = ? AND hash = '' AND attempted_at < ?`,+ model.ArtworkPriorityRecheck, now, now, kind.Prefix(), attemptedBefore)+}++func (r *artworkQueueRepository) EnqueueAllMissing(kind model.Kind, priority int) (int64, error) {+ entityTable, ok := artworkOwnerTables[kind]+ if !ok {+ return 0, fmt.Errorf("artwork queue: no entity table for kind %q", kind.Prefix())+ }+ now := time.Now()+ return r.insertIfNotQueued("", `SELECT ?, id, ?, ?, 0, ?, ?+ FROM `+entityTable+`+ WHERE id NOT IN (SELECT item_id FROM `+itemArtworkTable+` WHERE item_kind = ?)`,+ kind.Prefix(), model.ImageTypePrimary, priority, now, now, kind.Prefix())+}++func (r *artworkQueueRepository) EnqueueIfMissing(items ...model.ArtworkQueueItem) error {+ now := time.Now()+ for chunk := range slices.Chunk(items, enqueueChunkSize) {+ rows := make([]string, 0, len(chunk))+ args := make([]any, 0, len(chunk)*4+2)+ for _, it := range chunk {+ rows = append(rows, "(?,?,?,?)")+ args = append(args, it.ItemKind, it.ItemID, cmp.Or(it.ImageType, model.ImageTypePrimary), it.Priority)+ }+ args = append(args, now, now)+ _, err := r.insertIfNotQueued(+ `WITH new_items(item_kind, item_id, image_type, priority) AS (VALUES `+strings.Join(rows, ",")+`) `,+ `SELECT n.item_kind, n.item_id, n.image_type, n.priority, 0, ?, ?+ FROM new_items n+ WHERE NOT EXISTS (+ SELECT 1 FROM `+itemArtworkTable+` ia+ WHERE ia.item_kind = n.item_kind AND ia.item_id = n.item_id AND ia.image_type = n.image_type)`,+ args...)+ if err != nil {+ return err+ }+ }+ return nil+}++// insertIfNotQueued inserts the rows selected by the given SQL, optionally prefixed by a CTE. DO NOTHING is+// deliberate: a recheck must not bump the priority or retry_at of an already-queued item.+func (r *artworkQueueRepository) insertIfNotQueued(with, sql string, args ...any) (int64, error) {+ return r.executeSQL(Expr(with+`INSERT INTO `+r.tableName++ ` (`+strings.Join(enqueueColumns, ", ")+`) `+sql++ ` ON CONFLICT (item_kind, item_id, image_type) DO NOTHING`, args...))+}++func (r *artworkQueueRepository) enqueue(conflict string, items []model.ArtworkQueueItem) error {+ now := time.Now()+ for chunk := range slices.Chunk(items, enqueueChunkSize) {+ ins := Insert(r.tableName).Columns(enqueueColumns...)+ for _, it := range chunk {+ ins = ins.Values(it.ItemKind, it.ItemID, cmp.Or(it.ImageType, model.ImageTypePrimary), it.Priority, 0, now, now)+ }+ ins = ins.Suffix(conflict)+ if _, err := r.executeSQL(ins); err != nil {+ return err+ }+ }+ return nil+}++func (r *artworkQueueRepository) DequeueBatch(n int, kinds ...string) ([]model.ArtworkQueueItem, error) {+ sel := Select("*").From(r.tableName).+ Where(LtOrEq{"retry_at": time.Now()}).+ OrderBy("priority DESC", "enqueued_at ASC").+ Limit(uint64(n))+ if len(kinds) > 0 {+ sel = sel.Where(Eq{"item_kind": kinds})+ }+ var res []model.ArtworkQueueItem+ err := r.queryAll(sel, &res)+ return res, err+}++func (r *artworkQueueRepository) MarkFailedIfUnchanged(kind, id, imageType string, seenRetryAt, retryAt time.Time) error {+ upd := Update(r.tableName).+ Set("attempts", Expr("attempts + 1")).+ Set("retry_at", retryAt).+ Where(Eq{"item_kind": kind, "item_id": id, "image_type": imageType, "retry_at": seenRetryAt})+ _, err := r.executeSQL(upd)+ return err+}++func (r *artworkQueueRepository) DeleteIfUnchanged(kind, id, imageType string, retryAt time.Time) error {+ return r.delete(Eq{"item_kind": kind, "item_id": id, "image_type": imageType, "retry_at": retryAt})+}++func (r *artworkQueueRepository) PurgeDangling() (int64, error) {+ return purgeDangling(r.sqlRepository)+}++func (r *artworkQueueRepository) Count() (int64, error) {+ var res struct{ Count int64 }+ err := r.queryOne(Select("count(*) as count").From(r.tableName), &res)+ return res.Count, err+}++var _ model.ArtworkQueueRepository = (*artworkQueueRepository)(nil)diff --git a/persistence/artwork_queue_repository_test.go b/persistence/artwork_queue_repository_test.gonew file mode 100644index 000000000..6638a204e--- /dev/null+++ b/persistence/artwork_queue_repository_test.go@@ -0,0 +1,284 @@+package persistence++import (+ "context"+ "time"++ "github.com/Masterminds/squirrel"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/utils/slice"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+ "github.com/pocketbase/dbx"+)++var _ = Describe("ArtworkQueueRepository", func() {+ var repo model.ArtworkQueueRepository++ item := func(kind, id string, prio int) model.ArtworkQueueItem {+ return model.ArtworkQueueItem{ItemKind: kind, ItemID: id,+ ImageType: model.ImageTypePrimary, Priority: prio}+ }++ // Writes the post-failure state directly: the production path, MarkFailedIfUnchanged, needs+ // a retry_at only a dequeue can hand it.+ backOff := func(kind, id string, retryAt time.Time) {+ GinkgoHelper()+ r := repo.(*artworkQueueRepository)+ _, err := r.executeSQL(squirrel.Update(r.tableName).+ Set("attempts", squirrel.Expr("attempts + 1")).+ Set("retry_at", retryAt).+ Where(squirrel.Eq{"item_kind": kind, "item_id": id, "image_type": model.ImageTypePrimary}))+ Expect(err).ToNot(HaveOccurred())+ }++ remove := func(kind, id string) {+ GinkgoHelper()+ r := repo.(*artworkQueueRepository)+ Expect(r.delete(squirrel.Eq{"item_kind": kind, "item_id": id, "image_type": model.ImageTypePrimary})).To(Succeed())+ }++ BeforeEach(func() {+ clearArtworkTables()+ DeferCleanup(clearArtworkTables)+ repo = NewArtworkQueueRepository(context.Background(), GetDBXBuilder())+ })++ It("enqueues and dequeues by priority then FIFO", func() {+ Expect(repo.Enqueue(item("al", "low", model.ArtworkPriorityBackfill))).To(Succeed())+ Expect(repo.Enqueue(item("ar", "high", model.ArtworkPriorityBump))).To(Succeed())++ got, err := repo.DequeueBatch(10)+ Expect(err).ToNot(HaveOccurred())+ Expect(got).To(HaveLen(2))+ Expect(got[0].ItemID).To(Equal("high"))+ })++ It("keeps the higher priority on duplicate enqueue", func() {+ Expect(repo.Enqueue(item("al", "a1", model.ArtworkPriorityBump))).To(Succeed())+ Expect(repo.Enqueue(item("al", "a1", model.ArtworkPriorityBackfill))).To(Succeed())+ got, _ := repo.DequeueBatch(10)+ Expect(got).To(HaveLen(1))+ Expect(got[0].Priority).To(Equal(model.ArtworkPriorityBump))+ })++ It("EnqueuePreservingBackoff raises priority without resetting a backing-off row's retry_at", func() {+ Expect(repo.Enqueue(item("al", "b1", model.ArtworkPriorityScan))).To(Succeed())+ backOff("al", "b1", time.Now().Add(time.Hour))+ Expect(repo.DequeueBatch(10)).To(BeEmpty())++ Expect(repo.EnqueuePreservingBackoff(item("al", "b1", model.ArtworkPriorityBump))).To(Succeed())+ Expect(repo.DequeueBatch(10)).To(BeEmpty(), "bump must not reset retry_at")++ // Enqueue (scan/manual), by contrast, resets retry_at and makes it eligible now.+ Expect(repo.Enqueue(item("al", "b1", model.ArtworkPriorityScan))).To(Succeed())+ got, _ := repo.DequeueBatch(10)+ Expect(got).To(HaveLen(1))+ Expect(got[0].Priority).To(Equal(model.ArtworkPriorityBump), "bump's higher priority is preserved")+ })++ It("EnqueuePreservingBackoff inserts a brand-new row eligible immediately", func() {+ Expect(repo.EnqueuePreservingBackoff(item("ar", "n1", model.ArtworkPriorityBump))).To(Succeed())+ got, _ := repo.DequeueBatch(10)+ Expect(got).To(HaveLen(1))+ Expect(got[0].ItemID).To(Equal("n1"))+ })++ It("hides failed items until retry_at", func() {+ Expect(repo.Enqueue(item("al", "f1", model.ArtworkPriorityScan))).To(Succeed())+ backOff("al", "f1", time.Now().Add(time.Hour))++ got, err := repo.DequeueBatch(10)+ Expect(err).ToNot(HaveOccurred())+ Expect(got).To(BeEmpty())++ backOff("al", "f1", time.Now().Add(-time.Minute))+ got, _ = repo.DequeueBatch(10)+ Expect(got).To(HaveLen(1))+ Expect(got[0].Attempts).To(Equal(2))+ })++ It("MarkFailedIfUnchanged applies backoff only while retry_at is unchanged", func() {+ Expect(repo.Enqueue(item("al", "m1", model.ArtworkPriorityScan))).To(Succeed())+ // Anchor retry_at in the past so it can never collide with the re-enqueue's now.+ backOff("al", "m1", time.Now().Add(-time.Hour))+ got, err := repo.DequeueBatch(10)+ Expect(err).ToNot(HaveOccurred())+ Expect(got).To(HaveLen(1))+ original := got[0].RetryAt++ // A concurrent scan re-enqueues, resetting retry_at to now.+ Expect(repo.Enqueue(item("al", "m1", model.ArtworkPriorityScan))).To(Succeed())++ future := time.Now().Add(48 * time.Hour)+ Expect(repo.MarkFailedIfUnchanged("al", "m1", model.ImageTypePrimary, original, future)).To(Succeed())+ got, _ = repo.DequeueBatch(10)+ Expect(got).To(HaveLen(1), "the fresh re-enqueue stays immediately eligible")+ Expect(got[0].Attempts).To(BeZero(), "re-enqueue clears attempts, and the stale failure must not bump them")+ current := got[0].RetryAt++ Expect(repo.MarkFailedIfUnchanged("al", "m1", model.ImageTypePrimary, current, future)).To(Succeed())+ got, _ = repo.DequeueBatch(10)+ Expect(got).To(BeEmpty(), "backed-off row is hidden until the future retry_at")+ all, _ := repo.Count()+ Expect(all).To(Equal(int64(1)))+ })++ It("Enqueue restarts the retry budget an existing row had spent", func() {+ Expect(repo.Enqueue(item("al", "e1", model.ArtworkPriorityScan))).To(Succeed())+ backOff("al", "e1", time.Now().Add(-time.Hour))+ stale := time.Now().Add(-48 * time.Hour)+ _, err := GetDBXBuilder().NewQuery("UPDATE artwork_queue SET enqueued_at = {:t} WHERE item_id = 'e1'").+ Bind(dbx.Params{"t": stale}).Execute()+ Expect(err).ToNot(HaveOccurred())++ Expect(repo.Enqueue(item("al", "e1", model.ArtworkPriorityScan))).To(Succeed())++ got, err := repo.DequeueBatch(10)+ Expect(err).ToNot(HaveOccurred())+ Expect(got).To(HaveLen(1))+ Expect(got[0].EnqueuedAt).To(BeTemporally("~", time.Now(), time.Minute),+ "a re-request must not inherit a spent 12h window and give up on its first attempt")+ Expect(got[0].Attempts).To(BeZero())+ })++ It("deletes on completion and counts", func() {+ Expect(repo.Enqueue(item("al", "c1", 0))).To(Succeed())+ n, _ := repo.Count()+ Expect(n).To(Equal(int64(1)))+ remove("al", "c1")+ n, _ = repo.Count()+ Expect(n).To(BeZero())+ })++ It("DeleteIfUnchanged deletes only while retry_at is unchanged", func() {+ Expect(repo.Enqueue(item("al", "d1", model.ArtworkPriorityScan))).To(Succeed())+ // Anchor retry_at in the past so it can never collide with the re-enqueue's now.+ backOff("al", "d1", time.Now().Add(-time.Hour))+ got, err := repo.DequeueBatch(10)+ Expect(err).ToNot(HaveOccurred())+ Expect(got).To(HaveLen(1))+ original := got[0].RetryAt++ // A concurrent scan re-enqueues, resetting retry_at to now.+ Expect(repo.Enqueue(item("al", "d1", model.ArtworkPriorityScan))).To(Succeed())++ // Deleting with the stale retry_at is a no-op: the re-enqueued row survives.+ Expect(repo.DeleteIfUnchanged("al", "d1", model.ImageTypePrimary, original)).To(Succeed())+ n, _ := repo.Count()+ Expect(n).To(Equal(int64(1)))++ got, _ = repo.DequeueBatch(10)+ Expect(got).To(HaveLen(1))+ Expect(repo.DeleteIfUnchanged("al", "d1", model.ImageTypePrimary, got[0].RetryAt)).To(Succeed())+ n, _ = repo.Count()+ Expect(n).To(BeZero())+ })++ It("purges queue rows whose entity no longer exists, per kind", func() {+ Expect(repo.Enqueue(+ item("al", albumSgtPeppers.ID, model.ArtworkPriorityScan),+ item("al", "no-such-album", model.ArtworkPriorityScan),+ item("ar", artistKraftwerk.ID, model.ArtworkPriorityScan),+ item("ar", "no-such-artist", model.ArtworkPriorityScan),+ item("pl", plsBest.ID, model.ArtworkPriorityScan),+ item("pl", "no-such-playlist", model.ArtworkPriorityScan),+ item("ra", radioWithHomePage.ID, model.ArtworkPriorityScan),+ item("ra", "no-such-radio", model.ArtworkPriorityScan),+ item("mf", songDayInALife.ID, model.ArtworkPriorityScan),+ item("mf", "no-such-mediafile", model.ArtworkPriorityScan),+ )).To(Succeed())++ purged, err := repo.PurgeDangling()+ Expect(err).ToNot(HaveOccurred())+ Expect(purged).To(Equal(int64(5)))++ got, _ := repo.DequeueBatch(100)+ ids := slice.Map(got, func(it model.ArtworkQueueItem) string { return it.ItemID })+ Expect(ids).To(ConsistOf(albumSgtPeppers.ID, artistKraftwerk.ID, plsBest.ID, radioWithHomePage.ID, songDayInALife.ID))+ })++ It("enqueues stale absent states for recheck", func() {+ awRepo := NewArtworkRepository(context.Background(), GetDBXBuilder())+ old := time.Now().Add(-48 * time.Hour)+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "stale1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: old})).To(Succeed())+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "fresh1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: time.Now()})).To(Succeed())+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "found1", ImageType: model.ImageTypePrimary, Hash: "hX", AttemptedAt: old})).To(Succeed())++ n, err := repo.EnqueueStaleAbsent(model.KindArtistArtwork, time.Now().Add(-24*time.Hour))+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(Equal(int64(1)))++ items, err := repo.DequeueBatch(10)+ Expect(err).ToNot(HaveOccurred())+ Expect(items).To(HaveLen(1))+ Expect(items[0].ItemID).To(Equal("stale1"))+ Expect(items[0].Priority).To(Equal(model.ArtworkPriorityRecheck))+ })++ It("enqueues entities that have no item_artwork row at all", func() {+ awRepo := NewArtworkRepository(context.Background(), GetDBXBuilder())+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: albumSgtPeppers.ID, ImageType: model.ImageTypePrimary, Hash: "hX", AttemptedAt: time.Now()})).To(Succeed())+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: albumAbbeyRoad.ID, ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: time.Now()})).To(Succeed())++ n, err := repo.EnqueueAllMissing(model.KindAlbumArtwork, model.ArtworkPriorityRecheck)+ Expect(err).ToNot(HaveOccurred())+ Expect(n).To(BeNumerically(">=", 1))++ got, err := repo.DequeueBatch(1000)+ Expect(err).ToNot(HaveOccurred())+ ids := make([]string, 0, len(got))+ for _, it := range got {+ Expect(it.ItemKind).To(Equal("al"))+ Expect(it.Priority).To(Equal(model.ArtworkPriorityRecheck))+ ids = append(ids, it.ItemID)+ }+ Expect(ids).To(ContainElement(albumRadioactivity.ID), "an album with no row must be enqueued")+ Expect(ids).ToNot(ContainElement(albumSgtPeppers.ID), "a resolved album must not be re-enqueued")+ Expect(ids).ToNot(ContainElement(albumAbbeyRoad.ID), "an absent-state album must not be enqueued as missing")+ })++ It("EnqueueIfMissing skips items that already have an item_artwork row", func() {+ awRepo := NewArtworkRepository(context.Background(), GetDBXBuilder())+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "resolved", ImageType: model.ImageTypePrimary, Hash: "hX", AttemptedAt: time.Now()})).To(Succeed())+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "absent", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: time.Now()})).To(Succeed())++ Expect(repo.EnqueueIfMissing(+ item("al", "resolved", model.ArtworkPriorityScan),+ item("al", "absent", model.ArtworkPriorityScan),+ item("al", "brandnew", model.ArtworkPriorityScan),+ )).To(Succeed())++ got, err := repo.DequeueBatch(100)+ Expect(err).ToNot(HaveOccurred())+ ids := slice.Map(got, func(it model.ArtworkQueueItem) string { return it.ItemID })+ Expect(ids).To(ConsistOf("brandnew"), "only an item with no state row may be enqueued")+ })++ It("EnqueueIfMissing leaves an already-queued row untouched", func() {+ Expect(repo.Enqueue(item("al", "queued", model.ArtworkPriorityBump))).To(Succeed())++ Expect(repo.EnqueueIfMissing(item("al", "queued", model.ArtworkPriorityScan))).To(Succeed())++ got, _ := repo.DequeueBatch(100)+ Expect(got).To(HaveLen(1))+ Expect(got[0].Priority).To(Equal(model.ArtworkPriorityBump), "the existing priority must survive")+ })++ It("does not disturb an already-queued entity when enqueueing missing rows", func() {+ Expect(repo.Enqueue(item("al", albumRadioactivity.ID, model.ArtworkPriorityBump))).To(Succeed())++ _, err := repo.EnqueueAllMissing(model.KindAlbumArtwork, model.ArtworkPriorityRecheck)+ Expect(err).ToNot(HaveOccurred())++ got, _ := repo.DequeueBatch(1000)+ var count int+ for _, it := range got {+ if it.ItemID == albumRadioactivity.ID {+ count+++ Expect(it.Priority).To(Equal(model.ArtworkPriorityBump), "existing bump priority must survive")+ }+ }+ Expect(count).To(Equal(1), "the already-queued row must not be duplicated")+ })+})diff --git a/persistence/artwork_repository.go b/persistence/artwork_repository.gonew file mode 100644index 000000000..22662b575--- /dev/null+++ b/persistence/artwork_repository.go@@ -0,0 +1,176 @@+package persistence++import (+ "cmp"+ "context"+ "slices"+ "time"++ . "github.com/Masterminds/squirrel"+ "github.com/navidrome/navidrome/model"+ "github.com/pocketbase/dbx"+)++const (+ itemArtworkTable = "item_artwork"+ artworkBatchSize = 200+)++type artworkRepository struct {+ sqlRepository+ items sqlRepository+}++func NewArtworkRepository(ctx context.Context, db dbx.Builder) model.ArtworkRepository {+ r := &artworkRepository{}+ r.ctx = ctx+ r.db = db+ r.tableName = "artwork"+ r.items.ctx = ctx+ r.items.db = db+ r.items.tableName = itemArtworkTable+ return r+}++func (r *artworkRepository) GetImage(hash string) (*model.Artwork, error) {+ sel := Select("*").From(r.tableName).Where(Eq{"hash": hash})+ var res model.Artwork+ if err := r.queryOne(sel, &res); err != nil {+ return nil, err+ }+ return &res, nil+}++func (r *artworkRepository) PutImage(a *model.Artwork) error {+ // created_at is the last-acquisition-write time the prune grace window keys on.+ a.CreatedAt = time.Now()+ values, err := toSQLArgs(*a)+ if err != nil {+ return err+ }+ // created_at=excluded.created_at: reacquiring an orphan must reset the prune grace window.+ ins := Insert(r.tableName).SetMap(values).Suffix(`ON CONFLICT (hash) DO UPDATE SET mime=excluded.mime, width=excluded.width,+ height=excluded.height, size_bytes=excluded.size_bytes, blur_hash=excluded.blur_hash,+ thumb_hash=excluded.thumb_hash, dominant_color=excluded.dominant_color,+ created_at=excluded.created_at`)+ _, err = r.executeSQL(ins)+ return err+}++func (r *artworkRepository) GetMimeByHash() (map[string]string, error) {+ sel := Select("hash", "mime").From(r.tableName)+ var rows []struct {+ Hash string+ Mime string+ }+ if err := r.queryAll(sel, &rows); err != nil {+ return nil, err+ }+ res := make(map[string]string, len(rows))+ for _, row := range rows {+ res[row.Hash] = row.Mime+ }+ return res, nil+}++func (r *artworkRepository) PurgeOrphans(createdBefore time.Time) (int64, error) {+ del := Delete(r.tableName).Where(And{+ Lt{"created_at": createdBefore},+ Expr("hash NOT IN (SELECT hash FROM " + itemArtworkTable + " WHERE hash <> '')"),+ })+ return r.executeSQL(del)+}++// artworkOwnerTables maps an artwork kind to the table that owns the entity.+var artworkOwnerTables = map[model.Kind]string{+ model.KindAlbumArtwork: "album",+ model.KindArtistArtwork: "artist",+ model.KindPlaylistArtwork: "playlist",+ model.KindRadioArtwork: "radio",+ model.KindMediaFileArtwork: "media_file",+}++// purgeDangling deletes rows in r's table whose owning entity is gone, one statement per kind.+func purgeDangling(r sqlRepository) (int64, error) {+ var total int64+ for kind, entityTable := range artworkOwnerTables {+ del := Delete(r.tableName).Where(And{+ Eq{"item_kind": kind.Prefix()},+ Expr("item_id NOT IN (SELECT id FROM " + entityTable + ")"),+ })+ c, err := r.executeSQL(del)+ if err != nil {+ return total, err+ }+ total += c+ }+ return total, nil+}++func (r *artworkRepository) PurgeDanglingItems() (int64, error) {+ return purgeDangling(r.items)+}++func (r *artworkRepository) GetItemArtwork(kind model.Kind, id, imageType string) (*model.ItemArtwork, error) {+ sel := Select("*").From(itemArtworkTable).+ Where(Eq{"item_kind": kind.Prefix(), "item_id": id, "image_type": imageType})+ var res model.ItemArtwork+ if err := r.items.queryOne(sel, &res); err != nil {+ return nil, err+ }+ return &res, nil+}++func (r *artworkRepository) PutItemArtwork(ia *model.ItemArtwork) error {+ ia.ImageType = cmp.Or(ia.ImageType, model.ImageTypePrimary)+ ia.UpdatedAt = time.Now()+ // PutItemArtwork records the outcome of an attempt, so an unset attempted_at is now.+ if ia.AttemptedAt.IsZero() {+ ia.AttemptedAt = ia.UpdatedAt+ }+ values, err := toSQLArgs(*ia)+ if err != nil {+ return err+ }+ ins := Insert(itemArtworkTable).SetMap(values).Suffix(`ON CONFLICT (item_kind, item_id, image_type) DO UPDATE SET+ hash=excluded.hash, source=excluded.source, source_path=excluded.source_path, ref_mtime=excluded.ref_mtime,+ attempted_at=excluded.attempted_at, updated_at=excluded.updated_at`)+ _, err = r.items.executeSQL(ins)+ return err+}++func (r *artworkRepository) DeleteForItems(kind model.Kind, ids []string) error {+ for chunk := range slices.Chunk(ids, artworkBatchSize) {+ if err := r.items.delete(Eq{"item_kind": kind.Prefix(), "item_id": chunk}); err != nil {+ return err+ }+ }+ return nil+}++func (r *artworkRepository) GetInfoForItems(kind model.Kind, ids []string) (map[string]model.ItemArtworkInfo, error) {+ res := map[string]model.ItemArtworkInfo{}+ for chunk := range slices.Chunk(ids, artworkBatchSize) {+ sel := Select("ia.item_id", "ia.hash", "COALESCE(a.blur_hash, '') as blur_hash",+ "COALESCE(a.thumb_hash, '') as thumb_hash",+ "COALESCE(a.dominant_color, '') as dominant_color",+ "COALESCE(a.width, 0) as width", "COALESCE(a.height, 0) as height").+ From(itemArtworkTable + " ia").+ LeftJoin("artwork a ON a.hash = ia.hash").+ Where(And{+ Eq{"ia.item_kind": kind.Prefix()},+ Eq{"ia.image_type": model.ImageTypePrimary},+ Eq{"ia.item_id": chunk},+ })+ var rows []model.ItemArtworkInfo+ if err := r.items.queryAll(sel, &rows); err != nil {+ return nil, err+ }+ for _, row := range rows {+ res[row.ItemID] = row+ }+ }+ return res, nil+}++var _ model.ArtworkRepository = (*artworkRepository)(nil)diff --git a/persistence/artwork_repository_test.go b/persistence/artwork_repository_test.gonew file mode 100644index 000000000..683dc2d0f--- /dev/null+++ b/persistence/artwork_repository_test.go@@ -0,0 +1,248 @@+package persistence++import (+ "context"+ "fmt"+ "time"++ "github.com/navidrome/navidrome/model"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+ "github.com/pocketbase/dbx"+)++func clearArtworkTables() {+ db := GetDBXBuilder()+ for _, t := range []string{"artwork_queue", "item_artwork", "artwork"} {+ _, err := db.NewQuery("DELETE FROM " + t).Execute()+ Expect(err).ToNot(HaveOccurred())+ }+}++var _ = Describe("ArtworkRepository", func() {+ var repo model.ArtworkRepository++ BeforeEach(func() {+ clearArtworkTables()+ DeferCleanup(clearArtworkTables)+ repo = NewArtworkRepository(context.Background(), GetDBXBuilder())+ })++ Context("image identity", func() {+ It("stores and retrieves an artwork by hash", func() {+ a := &model.Artwork{Hash: "abc123", Mime: "image/jpeg", Width: 500, Height: 500, SizeBytes: 1234, BlurHash: "LKO2?U%2Tw=w"}+ Expect(repo.PutImage(a)).To(Succeed())++ got, err := repo.GetImage("abc123")+ Expect(err).ToNot(HaveOccurred())+ Expect(got.Mime).To(Equal("image/jpeg"))+ Expect(got.BlurHash).To(Equal("LKO2?U%2Tw=w"))+ Expect(got.CreatedAt).ToNot(BeZero())+ })++ It("round-trips the thumbhash alongside the blurhash", func() {+ a := &model.Artwork{Hash: "both1", Mime: "image/jpeg", BlurHash: "LKO2?U%2Tw=w",+ ThumbHash: "1QcSHQRnh493V4dIh4eXh1h4kJUI", DominantColor: "#336699"}+ Expect(repo.PutImage(a)).To(Succeed())++ got, err := repo.GetImage("both1")+ Expect(err).ToNot(HaveOccurred())+ Expect(got.BlurHash).To(Equal("LKO2?U%2Tw=w"))+ Expect(got.ThumbHash).To(Equal("1QcSHQRnh493V4dIh4eXh1h4kJUI"))+ Expect(got.DominantColor).To(Equal("#336699"))+ })++ It("overwrites the thumbhash on re-acquisition", func() {+ Expect(repo.PutImage(&model.Artwork{Hash: "th2", Mime: "image/png", ThumbHash: "first", DominantColor: "#111111"})).To(Succeed())+ Expect(repo.PutImage(&model.Artwork{Hash: "th2", Mime: "image/png", ThumbHash: "second", DominantColor: "#222222"})).To(Succeed())++ got, err := repo.GetImage("th2")+ Expect(err).ToNot(HaveOccurred())+ Expect(got.ThumbHash).To(Equal("second"))+ Expect(got.DominantColor).To(Equal("#222222"))+ })++ It("is idempotent on Put (upsert by hash)", func() {+ a := &model.Artwork{Hash: "dup1", Mime: "image/png"}+ Expect(repo.PutImage(a)).To(Succeed())+ a.BlurHash = "XYZ"+ Expect(repo.PutImage(a)).To(Succeed())+ got, _ := repo.GetImage("dup1")+ Expect(got.BlurHash).To(Equal("XYZ"))+ })++ It("refreshes created_at when reacquiring an existing hash", func() {+ Expect(repo.PutImage(&model.Artwork{Hash: "reacq", Mime: "image/jpeg"})).To(Succeed())+ _, err := GetDBXBuilder().NewQuery("UPDATE artwork SET created_at={:t} WHERE hash='reacq'").+ Bind(dbx.Params{"t": "2000-01-01 00:00:00"}).Execute()+ Expect(err).ToNot(HaveOccurred())++ Expect(repo.PutImage(&model.Artwork{Hash: "reacq", Mime: "image/png"})).To(Succeed())++ got, err := repo.GetImage("reacq")+ Expect(err).ToNot(HaveOccurred())+ Expect(got.CreatedAt).To(BeTemporally(">", time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)))+ })++ It("returns ErrNotFound for a missing hash", func() {+ _, err := repo.GetImage("nope")+ Expect(err).To(MatchError(model.ErrNotFound))+ })++ It("returns every stored hash with its current mime", func() {+ Expect(repo.PutImage(&model.Artwork{Hash: "all1", Mime: "image/jpeg"})).To(Succeed())+ Expect(repo.PutImage(&model.Artwork{Hash: "all2", Mime: "image/png"})).To(Succeed())+ mimes, err := repo.GetMimeByHash()+ Expect(err).ToNot(HaveOccurred())+ Expect(mimes).To(HaveKeyWithValue("all1", "image/jpeg"))+ Expect(mimes).To(HaveKeyWithValue("all2", "image/png"))+ })++ It("deletes only unreferenced rows older than the cutoff, reporting the count", func() {+ Expect(repo.PutImage(&model.Artwork{Hash: "d1", Mime: "image/jpeg"})).To(Succeed())+ Expect(repo.PutImage(&model.Artwork{Hash: "dref", Mime: "image/jpeg"})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "a1",+ ImageType: model.ImageTypePrimary, Hash: "dref", Source: "folder"})).To(Succeed())++ Expect(repo.PurgeOrphans(time.Now().Add(time.Minute))).To(BeNumerically("==", 1))++ _, err := repo.GetImage("d1")+ Expect(err).To(MatchError(model.ErrNotFound))+ _, err = repo.GetImage("dref")+ Expect(err).ToNot(HaveOccurred())+ })++ It("spares an unreferenced row younger than the cutoff", func() {+ Expect(repo.PutImage(&model.Artwork{Hash: "young", Mime: "image/jpeg"})).To(Succeed())+ Expect(repo.PurgeOrphans(time.Now().Add(-time.Hour))).To(BeNumerically("==", 0))+ _, err := repo.GetImage("young")+ Expect(err).ToNot(HaveOccurred())+ })+ })++ Context("dangling state cleanup", func() {+ It("purges item_artwork rows per kind whose entity no longer exists, summing counts", func() {+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: albumSgtPeppers.ID, ImageType: model.ImageTypePrimary, Hash: "keepAl"})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "no-such-album", ImageType: model.ImageTypePrimary, Hash: "danglingAl"})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: artistKraftwerk.ID, ImageType: model.ImageTypePrimary, Hash: "keepAr"})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "no-such-artist", ImageType: model.ImageTypePrimary, Hash: "danglingAr"})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "pl", ItemID: plsBest.ID, ImageType: model.ImageTypePrimary, Hash: "keepPl"})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "pl", ItemID: "no-such-playlist", ImageType: model.ImageTypePrimary, Hash: "danglingPl"})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ra", ItemID: radioWithHomePage.ID, ImageType: model.ImageTypePrimary, Hash: "keepRa"})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ra", ItemID: "no-such-radio", ImageType: model.ImageTypePrimary, Hash: "danglingRa"})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "mf", ItemID: songDayInALife.ID, ImageType: model.ImageTypePrimary, Hash: "keepMf"})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "mf", ItemID: "no-such-mediafile", ImageType: model.ImageTypePrimary, Hash: "danglingMf"})).To(Succeed())++ purged, err := repo.PurgeDanglingItems()+ Expect(err).ToNot(HaveOccurred())+ Expect(purged).To(Equal(int64(5)))++ for _, kept := range []model.ItemArtwork{+ {ItemKind: "al", ItemID: albumSgtPeppers.ID},+ {ItemKind: "ar", ItemID: artistKraftwerk.ID},+ {ItemKind: "pl", ItemID: plsBest.ID},+ {ItemKind: "ra", ItemID: radioWithHomePage.ID},+ {ItemKind: "mf", ItemID: songDayInALife.ID},+ } {+ k, _ := model.ParseKind(kept.ItemKind)+ _, err := repo.GetItemArtwork(k, kept.ItemID, model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ }+ for _, gone := range []model.ItemArtwork{+ {ItemKind: "al", ItemID: "no-such-album"},+ {ItemKind: "ar", ItemID: "no-such-artist"},+ {ItemKind: "pl", ItemID: "no-such-playlist"},+ {ItemKind: "ra", ItemID: "no-such-radio"},+ {ItemKind: "mf", ItemID: "no-such-mediafile"},+ } {+ k, _ := model.ParseKind(gone.ItemKind)+ _, err := repo.GetItemArtwork(k, gone.ItemID, model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ }+ })+ })++ Context("item state", func() {+ It("upserts and reads state, including per-item provenance", func() {+ ia := &model.ItemArtwork{ItemKind: "al", ItemID: "al1", ImageType: model.ImageTypePrimary,+ Hash: "h1", Source: "folder", SourcePath: "/music/a/cover.jpg", RefMtime: 111, AttemptedAt: time.Now()}+ Expect(repo.PutItemArtwork(ia)).To(Succeed())+ ia.Source = "embedded"+ ia.SourcePath = "/music/a/track.mp3"+ ia.RefMtime = 222+ Expect(repo.PutItemArtwork(ia)).To(Succeed())++ got, err := repo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(got.Source).To(Equal("embedded"))+ Expect(got.SourcePath).To(Equal("/music/a/track.mp3"))+ Expect(got.RefMtime).To(Equal(int64(222)))+ Expect(got.UpdatedAt).ToNot(BeZero())+ })++ It("defaults attempted_at to now when unset", func() {+ before := time.Now().Add(-time.Second)+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "noattempt",+ ImageType: model.ImageTypePrimary, Hash: ""})).To(Succeed())+ got, err := repo.GetItemArtwork(model.KindArtistArtwork, "noattempt", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(got.AttemptedAt).To(BeTemporally(">", before))+ })++ It("represents known-absent as empty hash", func() {+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "ar1",+ ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: time.Now()})).To(Succeed())+ got, err := repo.GetItemArtwork(model.KindArtistArtwork, "ar1", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(got.Hash).To(BeEmpty())+ })++ It("hydrates a page in one batch, including blurhash, dimensions and absence", func() {+ Expect(repo.PutImage(&model.Artwork{Hash: "h9", Mime: "image/jpeg", BlurHash: "BH9",+ DominantColor: "#abcdef", Width: 1200, Height: 800})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "x1", ImageType: model.ImageTypePrimary, Hash: "h9", Source: "folder"})).To(Succeed())+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "x2", ImageType: model.ImageTypePrimary, Hash: "", Source: ""})).To(Succeed())++ info, err := repo.GetInfoForItems(model.KindAlbumArtwork, []string{"x1", "x2", "x3"})+ Expect(err).ToNot(HaveOccurred())+ Expect(info).To(HaveLen(2))+ Expect(info["x1"].Hash).To(Equal("h9"))+ Expect(info["x1"].BlurHash).To(Equal("BH9"))+ Expect(info["x1"].DominantColor).To(Equal("#abcdef"))+ Expect(info["x1"].Width).To(Equal(1200))+ Expect(info["x1"].Height).To(Equal(800))+ Expect(info["x1"].Absent()).To(BeFalse())+ Expect(info["x2"].Absent()).To(BeTrue())+ _, unresolved := info["x3"]+ Expect(unresolved).To(BeFalse())+ })++ It("deletes all rows for a single item", func() {+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "pl", ItemID: "p1", ImageType: model.ImageTypePrimary, Hash: "h1"})).To(Succeed())+ Expect(repo.DeleteForItems(model.KindPlaylistArtwork, []string{"p1"})).To(Succeed())+ _, err := repo.GetItemArtwork(model.KindPlaylistArtwork, "p1", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ })++ It("deletes rows for many items in chunks, leaving others untouched", func() {+ const n = artworkBatchSize + 5+ ids := make([]string, n)+ for i := range n {+ id := fmt.Sprintf("mf-%d", i)+ ids[i] = id+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "mf", ItemID: id, ImageType: model.ImageTypePrimary, Hash: "h1"})).To(Succeed())+ }+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "mf", ItemID: "keep", ImageType: model.ImageTypePrimary, Hash: "h1"})).To(Succeed())++ Expect(repo.DeleteForItems(model.KindMediaFileArtwork, ids)).To(Succeed())++ for _, id := range ids {+ _, err := repo.GetItemArtwork(model.KindMediaFileArtwork, id, model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ }+ kept, err := repo.GetItemArtwork(model.KindMediaFileArtwork, "keep", model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(kept.ItemID).To(Equal("keep"))+ })+ })+})diff --git a/persistence/e2e/e2e_suite_test.go b/persistence/e2e/e2e_suite_test.goindex 1ff2139e6..2b617f5b0 100644--- a/persistence/e2e/e2e_suite_test.go+++ b/persistence/e2e/e2e_suite_test.go@@ -13,7 +13,6 @@ import ("github.com/Masterminds/squirrel""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/conf/configtest"- "github.com/navidrome/navidrome/core""github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/metrics""github.com/navidrome/navidrome/core/playlists"@@ -275,8 +274,8 @@ var _ = BeforeSuite(func() {ctx = request.WithUser(GinkgoT().Context(), adminUser)buildTestFS()- s := scanner.New(ctx, initDS, artwork.NoopCacheWarmer(), events.NoopBroker(),- playlists.NewPlaylists(initDS, core.NewImageUploadService()), metrics.NewNoopInstance())+ s := scanner.New(ctx, initDS, events.NoopBroker(),+ playlists.NewPlaylists(initDS, artwork.NewUploader(initDS)), metrics.NewNoopInstance())_, err = s.ScanAll(ctx, true)Expect(err).ToNot(HaveOccurred())diff --git a/persistence/mediafile_repository.go b/persistence/mediafile_repository.goindex ace61610c..df1472c2a 100644--- a/persistence/mediafile_repository.go+++ b/persistence/mediafile_repository.go@@ -163,7 +163,9 @@ func (r *mediaFileRepository) CountBySuffix(options ...model.QueryOptions) (map[}func (r *mediaFileRepository) Exists(id string) (bool, error) {- return r.exists(Eq{"media_file.id": id})+ // The exists() helper applies no library filter, so it would report rows the caller cannot see.+ c, err := r.count(r.applyLibraryFilter(r.newSelect().Where(Eq{"media_file.id": id})))+ return c > 0, err}func (r *mediaFileRepository) Put(m *model.MediaFile) error {@@ -218,7 +220,13 @@ func (r *mediaFileRepository) GetAll(options ...model.QueryOptions) (model.Mediaif err != nil {return nil, err}- return res.toModels(), nil+ mfs := res.toModels()+ r.hydrateArtwork(mfs)+ return mfs, nil+}++func (r *mediaFileRepository) hydrateArtwork(mfs model.MediaFiles) {+ hydrateMediaFileArtwork(r.ctx, r.db, mfs)}// GetRandom uses two passes so the random sort runs over a narrow rowid index instead of the@@ -252,7 +260,9 @@ func (r *mediaFileRepository) GetRandom(options ...model.QueryOptions) (model.Meif err := r.queryAll(sq, &res); err != nil {return nil, err}- return res.toModels(), nil+ mfs := res.toModels()+ r.hydrateArtwork(mfs)+ return mfs, nil}func (r *mediaFileRepository) GetAllByTags(tag model.TagName, values []string, options ...model.QueryOptions) (model.MediaFiles, error) {@@ -289,6 +299,29 @@ func (r *mediaFileRepository) GetCursor(options ...model.QueryOptions) (model.Mereturn wrapMediaFileCursor(cursor), nil}+// GetAllIDs returns the IDs of GetAll's row set, skipping its wide column projection.+func (r *mediaFileRepository) GetAllIDs(options ...model.QueryOptions) ([]string, error) {+ sq := r.applyLibraryFilter(r.newSelect(options...).Columns("media_file.id"))+ if filtersNeedAnnotation(sq) {+ sq = r.withAnnotation(sq, "media_file.id")+ }+ ids := []string{}+ err := r.queryAllSlice(sq, &ids)+ return ids, err+}++// GetCursorWithArtwork streams the same rows as GetCursor, hydrated, via an id pre-pass.+func (r *mediaFileRepository) GetCursorWithArtwork(options ...model.QueryOptions) (model.MediaFileCursor, error) {+ ids, err := r.GetAllIDs(options...)+ if err != nil {+ return nil, err+ }+ opts := chunkOptions(options, "media_file.id")+ return model.MediaFileCursor(streamByIDs(ids, func(chunk []string) (model.MediaFiles, error) {+ return r.GetAll(opts(chunk))+ })), nil+}+// FindByPaths finds media files by their paths.// The paths can be library-qualified (format: "libraryID:path") or unqualified ("path").// Library-qualified paths search within the specified library, while unqualified paths@@ -487,7 +520,9 @@ func (r *mediaFileRepository) Search(q string, options ...model.QueryOptions) (mif err != nil {return nil, fmt.Errorf("searching media_file %q: %w", q, err)}- return res.toModels(), nil+ mfs := res.toModels()+ r.hydrateArtwork(mfs)+ return mfs, nil}func (r *mediaFileRepository) Count(options ...rest.QueryOptions) (int64, error) {diff --git a/persistence/mediafile_repository_test.go b/persistence/mediafile_repository_test.goindex f6a744d8d..b9cba03ff 100644--- a/persistence/mediafile_repository_test.go+++ b/persistence/mediafile_repository_test.go@@ -1093,4 +1093,40 @@ var _ = Describe("MediaRepository", func() {_ = mr.Delete(newID)})})++ Describe("AlbumImage hydration", func() {+ It("carries the parent album's artwork state onto each track", func() {+ mfs := model.MediaFiles{{ID: "mf-1", AlbumID: "al-1"}}+ infos := map[string]model.ItemArtworkInfo{+ "al-1": {ItemID: "al-1", Hash: "0123456789abcdef", BlurHash: "LEHV6nWB2yk8"},+ }+ applyItemImage(infos, mfs[0].AlbumID, &mfs[0].AlbumImage)++ Expect(mfs[0].AlbumImage.ImageHash).To(Equal("0123456789abcdef"))+ Expect(mfs[0].AlbumImage.BlurHash).To(Equal("LEHV6nWB2yk8"))+ Expect(mfs[0].AlbumImage.ImageAbsent).To(BeFalse())+ })++ It("keeps the album state independent of the track's own art", func() {+ mf := model.MediaFile{ID: "mf-2", AlbumID: "al-2"}+ mf.ImageHash = "aaaaaaaaaaaaaaaa" // the track's own art+ applyItemImage(+ map[string]model.ItemArtworkInfo{"al-2": {ItemID: "al-2", Hash: "bbbbbbbbbbbbbbbb"}},+ mf.AlbumID, &mf.AlbumImage,+ )+ Expect(mf.ImageHash).To(Equal("aaaaaaaaaaaaaaaa"))+ Expect(mf.AlbumImage.ImageHash).To(Equal("bbbbbbbbbbbbbbbb"))+ })+ })++ // Exists must apply the same library filter as Get/GetAll/CountAll.+ Describe("Exists library visibility", func() {+ It("hides a track the user has no library access to", func() {+ restricted := model.User{ID: "restricted_mf_user", UserName: "rm", Name: "RM", Email: "[email protected]"}+ rctx := request.WithUser(GinkgoT().Context(), restricted)++ Expect(mr.Exists(songAntenna.ID)).To(BeTrue(), "admin sees it")+ Expect(NewMediaFileRepository(rctx, GetDBXBuilder()).Exists(songAntenna.ID)).To(BeFalse())+ })+ })})diff --git a/persistence/persistence.go b/persistence/persistence.goindex 93f0e3e71..9d3a33cfc 100644--- a/persistence/persistence.go+++ b/persistence/persistence.go@@ -97,6 +97,14 @@ func (s *SQLStore) Plugin(ctx context.Context) model.PluginRepository {return NewPluginRepository(ctx, s.getDBXBuilder())}+func (s *SQLStore) Artwork(ctx context.Context) model.ArtworkRepository {+ return NewArtworkRepository(ctx, s.getDBXBuilder())+}++func (s *SQLStore) ArtworkQueue(ctx context.Context) model.ArtworkQueueRepository {+ return NewArtworkQueueRepository(ctx, s.getDBXBuilder())+}+func (s *SQLStore) Resource(ctx context.Context, m any) model.ResourceRepository {switch m.(type) {case model.User:diff --git a/persistence/playlist_repository.go b/persistence/playlist_repository.goindex c78e0df1e..081dab3fa 100644--- a/persistence/playlist_repository.go+++ b/persistence/playlist_repository.go@@ -6,7 +6,6 @@ import ("encoding/json""errors""fmt"- "iter""slices""time"@@ -112,7 +111,8 @@ func (r *playlistRepository) Put(p *model.Playlist, cols ...string) error {_, err := r.put(pls.ID, pls, cols...)return err}- if pls.ID == "" {+ isNew := pls.ID == ""+ if isNew {pls.CreatedAt = time.Now()}pls.UpdatedAt = time.Now()@@ -131,6 +131,12 @@ func (r *playlistRepository) Put(p *model.Playlist, cols ...string) error {if len(pls.Tracks) > 0 {return r.updateTracks(id, p.MediaFiles())}+ pls.ID = id // r.put assigns the generated id to p, not to this copy+ if isNew {+ // Even a trackless new playlist has art to find (an imported m3u can carry an+ // ExternalImageURL); an update landing here changed only metadata, so leave its cover be.+ r.enqueueCoverRebuild(id)+ }return r.refreshCounters(&pls.Playlist)}@@ -172,7 +178,14 @@ func (r *playlistRepository) findBy(sql Sqlizer) (*model.Playlist, error) {return nil, model.ErrNotFound}- return &pls[0].Playlist, nil+ list := model.Playlists{pls[0].Playlist}+ r.hydrateArtwork(list)+ return &list[0], nil+}++func (r *playlistRepository) hydrateArtwork(playlists model.Playlists) {+ hydrateItems(r.ctx, r.db, model.KindPlaylistArtwork, playlists,+ func(p *model.Playlist) (string, *model.ItemImage) { return p.ID, &p.ItemImage })}func (r *playlistRepository) GetAll(options ...model.QueryOptions) (model.Playlists, error) {@@ -186,22 +199,34 @@ func (r *playlistRepository) GetAll(options ...model.QueryOptions) (model.Playlifor i, p := range res {playlists[i] = p.Playlist}+ r.hydrateArtwork(playlists)return playlists, err}+// GetAllIDs returns the IDs of GetAll's row set, skipping its per-row processing.+func (r *playlistRepository) GetAllIDs(options ...model.QueryOptions) ([]string, error) {+ // Joins a projection of user, not the table: its name/created_at columns would make an ORDER BY+ // on the playlist's own ambiguous.+ sq := r.newSelect(options...).Columns("playlist.id", "user.user_name as owner_name").+ Join("(select id, user_name from user) user on user.id = owner_id").Where(r.userFilter())+ if filtersNeedAnnotation(sq) {+ sq = r.withAnnotation(sq, "playlist.id")+ }+ ids := []string{}+ err := r.queryAllSlice(sq, &ids)+ return ids, err+}+func (r *playlistRepository) GetCursor(options ...model.QueryOptions) (model.PlaylistCursor, error) {- // Same userFilter as GetAll: a cursor must not widen visibility beyond public/owned playlists.- sel := r.selectPlaylist(options...).Where(r.userFilter())- cursor, err := queryWithStableResults[dbPlaylist](r.sqlRepository, sel)+ // Both passes apply userFilter, so a visibility change between them cannot widen the cursor.+ ids, err := r.GetAllIDs(options...)if err != nil {return nil, err}- return wrapPlaylistCursor(cursor), nil-}--// dbPlaylist embeds a value, not a pointer, so its model is never nil.-func wrapPlaylistCursor(cursor iter.Seq2[dbPlaylist, error]) model.PlaylistCursor {- return model.PlaylistCursor(wrapCursor(cursor, func(p dbPlaylist) *model.Playlist { return &p.Playlist }))+ opts := chunkOptions(options, "playlist.id")+ return model.PlaylistCursor(streamByIDs(ids, func(chunk []string) (model.Playlists, error) {+ return r.GetAll(opts(chunk))+ })), nil}func (r *playlistRepository) GetPlaylists(mediaFileId string) (model.Playlists, error) {@@ -220,6 +245,7 @@ func (r *playlistRepository) GetPlaylists(mediaFileId string) (model.Playlists,for i, p := range res {playlists[i] = p.Playlist}+ r.hydrateArtwork(playlists)return playlists, nil}@@ -264,6 +290,7 @@ func (r *playlistRepository) addTracks(playlistId string, startingPos int, media}}+ r.enqueueCoverRebuild(playlistId)return r.refreshCounters(&model.Playlist{ID: playlistId})}@@ -300,6 +327,16 @@ func (r *playlistRepository) refreshCounters(pls *model.Playlist) error {return nil}+// enqueueCoverRebuild re-resolves the generated 2x2 grid. Call it only when the track set changes:+// the grid samples albums at random, so rebuilding after a mere rename would change the cover.+func (r *playlistRepository) enqueueCoverRebuild(id string) {+ item := model.ArtworkQueueItem{ItemKind: model.KindPlaylistArtwork.Prefix(), ItemID: id,+ ImageType: model.ImageTypePrimary, Priority: model.ArtworkPriorityScan}+ if err := NewArtworkQueueRepository(r.ctx, r.db).Enqueue(item); err != nil {+ log.Warn(r.ctx, "could not enqueue playlist artwork after content change", "id", id, err)+ }+}+// tracksQuery is shared by loadTracks and GetCursor, so both hydrate rows identically.func (r *playlistRepository) tracksQuery(query SelectBuilder, id string) SelectBuilder {query = r.applyLibraryFilter(query, "f")@@ -332,7 +369,9 @@ func (r *playlistRepository) loadTracks(query SelectBuilder, id string) (model.Pif err != nil {return nil, err}- return tracks.toModels(), err+ res := tracks.toModels()+ hydratePlaylistTrackArtwork(r.ctx, r.db, res)+ return res, err}func (r *playlistRepository) Count(options ...rest.QueryOptions) (int64, error) {@@ -433,6 +472,7 @@ func (r *playlistRepository) renumber(id string) error {if err != nil {return err}+ r.enqueueCoverRebuild(id)return r.refreshCounters(&model.Playlist{ID: id})}diff --git a/persistence/playlist_repository_test.go b/persistence/playlist_repository_test.goindex 00d4ff9f2..fc2d4ae3f 100644--- a/persistence/playlist_repository_test.go+++ b/persistence/playlist_repository_test.go@@ -8,6 +8,7 @@ import ("github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/request"+ "github.com/navidrome/navidrome/utils/slice". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega""github.com/pocketbase/dbx"@@ -37,6 +38,17 @@ var _ = Describe("PlaylistRepository", func() {})})+ Describe("GetAllIDs", func() {+ It("returns the same id set as GetAll", func() {+ want, err := repo.GetAll()+ Expect(err).ToNot(HaveOccurred())+ Expect(want).ToNot(BeEmpty())+ ids, err := repo.GetAllIDs()+ Expect(err).ToNot(HaveOccurred())+ Expect(ids).To(ConsistOf(slice.Map(want, func(p model.Playlist) string { return p.ID })))+ })+ })+Describe("Exists", func() {It("returns true for an existing playlist", func() {Expect(repo.Exists(plsCool.ID)).To(BeTrue())@@ -245,6 +257,59 @@ var _ = Describe("PlaylistRepository", func() {Expect(repo.Exists(newPls.ID)).To(BeFalse())})+ It("enqueues a new empty playlist's artwork under its generated id, not an empty id", func() {+ ctx := request.WithUser(log.NewContext(GinkgoT().Context()), model.User{ID: "userid", UserName: "userid", IsAdmin: true})+ newPls := model.Playlist{Name: "Empty PL", OwnerID: "userid"} // no tracks → refreshCounters path+ Expect(repo.Put(&newPls)).To(Succeed())+ Expect(newPls.ID).ToNot(BeEmpty())+ DeferCleanup(func() { _ = repo.Delete(newPls.ID) })++ queued, err := NewArtworkQueueRepository(ctx, GetDBXBuilder()).DequeueBatch(1000)+ Expect(err).ToNot(HaveOccurred())+ Expect(queued).To(ContainElement(SatisfyAll(HaveField("ItemKind", "pl"), HaveField("ItemID", newPls.ID))))+ Expect(queued).ToNot(ContainElement(HaveField("ItemID", "")), "must not enqueue an empty playlist id")+ })++ // The grid samples albums at random, so re-resolving after a rename would change the cover.+ It("does not enqueue artwork when only metadata changes", func() {+ ctx := request.WithUser(log.NewContext(GinkgoT().Context()), model.User{ID: "userid", UserName: "userid", IsAdmin: true})+ newPls := model.Playlist{Name: "Rename Me", OwnerID: "userid"}+ Expect(repo.Put(&newPls)).To(Succeed())+ DeferCleanup(func() { _ = repo.Delete(newPls.ID) })+ // Clear the row creation just enqueued, so anything present afterwards came from the update.+ queueRepo := NewArtworkQueueRepository(ctx, GetDBXBuilder())+ queued, err := queueRepo.DequeueBatch(1000)+ Expect(err).ToNot(HaveOccurred())+ for _, q := range queued {+ if q.ItemID == newPls.ID {+ Expect(queueRepo.DeleteIfUnchanged(q.ItemKind, q.ItemID, q.ImageType, q.RetryAt)).To(Succeed())+ }+ }++ newPls.Name = "Renamed"+ newPls.Comment = "edited"+ Expect(repo.Put(&newPls)).To(Succeed())++ queued, err = queueRepo.DequeueBatch(1000)+ Expect(err).ToNot(HaveOccurred())+ Expect(queued).ToNot(ContainElement(HaveField("ItemID", newPls.ID)))+ })++ It("enqueues the playlist's artwork when its track set changes", func() {+ ctx := request.WithUser(log.NewContext(GinkgoT().Context()), model.User{ID: "userid", UserName: "userid", IsAdmin: true})+ newPls := model.Playlist{Name: "Grid PL", OwnerID: "userid"}+ newPls.AddMediaFilesByID([]string{"1001", "1002"})+ Expect(repo.Put(&newPls)).To(Succeed())+ DeferCleanup(func() { _ = repo.Delete(newPls.ID) })++ queued, err := NewArtworkQueueRepository(ctx, GetDBXBuilder()).DequeueBatch(1000)+ Expect(err).ToNot(HaveOccurred())+ Expect(queued).To(ContainElement(SatisfyAll(+ HaveField("ItemKind", "pl"),+ HaveField("ItemID", newPls.ID),+ )))+ })+Describe("GetAll", func() {It("returns all playlists from DB", func() {all, err := repo.GetAll()@@ -341,4 +406,27 @@ var _ = Describe("PlaylistRepository", func() {Expect(mediaFileIDs).To(Equal([]string{"1001", "1002"}))})})++ // Exists is ctx-sensitive through userFilter, so callers that only want "does it still exist"+ // -- the public image route serving a share -- must elevate, or a private playlist looks gone.+ Describe("Exists visibility", func() {+ It("hides a private playlist from an unauthenticated context", func() {+ // "userid" is the fixture user; playlist.owner_id has a FK to user(id).+ owner := model.User{ID: "userid", UserName: "userid"}+ octx := request.WithUser(GinkgoT().Context(), owner)+ ownerRepo := NewPlaylistRepository(octx, GetDBXBuilder())+ pls := model.Playlist{Name: "Private One", OwnerID: owner.ID, Public: false}+ Expect(ownerRepo.Put(&pls)).To(Succeed())+ DeferCleanup(func() { _ = ownerRepo.Delete(pls.ID) })++ Expect(ownerRepo.Exists(pls.ID)).To(BeTrue(), "the owner sees it")++ anon := NewPlaylistRepository(GinkgoT().Context(), GetDBXBuilder())+ Expect(anon.Exists(pls.ID)).To(BeFalse(), "no user: userFilter hides it")++ admin := request.WithUser(GinkgoT().Context(), model.User{ID: "userid", IsAdmin: true})+ Expect(NewPlaylistRepository(admin, GetDBXBuilder()).Exists(pls.ID)).To(BeTrue(),+ "elevating is what the public image route relies on")+ })+ })})diff --git a/persistence/playlist_track_repository.go b/persistence/playlist_track_repository.goindex e51ff8ea6..1a64efa20 100644--- a/persistence/playlist_track_repository.go+++ b/persistence/playlist_track_repository.go@@ -130,8 +130,11 @@ func (r *playlistTrackRepository) GetCursor(options ...model.QueryOptions) (modeif err != nil {return nil, err}- return model.PlaylistTrackCursor(wrapCursor(cursor, func(t dbPlaylistTrack) *model.PlaylistTrack {+ tracks := wrapCursor(cursor, func(t dbPlaylistTrack) *model.PlaylistTrack {return t.PlaylistTrack+ })+ return model.PlaylistTrackCursor(hydrateCursor(tracks, func(batch []model.PlaylistTrack) {+ hydratePlaylistTrackArtwork(r.ctx, r.db, batch)})), nil}diff --git a/persistence/radio_repository.go b/persistence/radio_repository.goindex a073643db..b73487e40 100644--- a/persistence/radio_repository.go+++ b/persistence/radio_repository.go@@ -7,6 +7,7 @@ import (. "github.com/Masterminds/squirrel""github.com/deluan/rest"+ "github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/id""github.com/pocketbase/dbx"@@ -36,6 +37,11 @@ func (r *radioRepository) CountAll(options ...model.QueryOptions) (int64, error)return r.count(sql, options...)}+// Exists needs no library or ownership filter: radios are visible to every user.+func (r *radioRepository) Exists(id string) (bool, error) {+ return r.exists(Eq{"id": id})+}+func (r *radioRepository) Delete(id string) error {if !r.isPermitted() {return rest.ErrPermissionDenied@@ -48,14 +54,37 @@ func (r *radioRepository) Get(id string) (*model.Radio, error) {sel := r.newSelect().Where(Eq{"id": id}).Columns("*")res := model.Radio{}err := r.queryOne(sel, &res)- return &res, err+ if err != nil {+ return &res, err+ }+ list := model.Radios{res}+ r.hydrateArtwork(list)+ return &list[0], nil}func (r *radioRepository) GetAll(options ...model.QueryOptions) (model.Radios, error) {sel := r.newSelect(options...).Columns("*")res := model.Radios{}err := r.queryAll(sel, &res)- return res, err+ if err != nil {+ return res, err+ }+ r.hydrateArtwork(res)+ return res, nil+}++// hydrateArtwork fills each radio's ImageHash/ImageAbsent from one batched item_artwork lookup.+func (r *radioRepository) hydrateArtwork(radios model.Radios) {+ hydrateItems(r.ctx, r.db, model.KindRadioArtwork, radios,+ func(rd *model.Radio) (string, *model.ItemImage) { return rd.ID, &rd.ItemImage })+}++// GetAllIDs returns just the radio IDs. Used by bulk enumeration (artwork backfill).+func (r *radioRepository) GetAllIDs(options ...model.QueryOptions) ([]string, error) {+ sel := r.newSelect(options...).Columns("id")+ ids := []string{}+ err := r.queryAllSlice(sel, &ids)+ return ids, err}func (r *radioRepository) Put(radio *model.Radio, colsToUpdate ...string) error {@@ -72,7 +101,17 @@ func (r *radioRepository) Put(radio *model.Radio, colsToUpdate ...string) errorcolsToUpdate = append(colsToUpdate, "UpdatedAt")}_, err := r.put(radio.ID, radio, colsToUpdate...)- return err+ if err != nil {+ return err+ }+ // Enqueue artwork resolution for the created/updated radio at Bump priority so a new+ // radio's cover resolves proactively. Never fails the save.+ item := model.ArtworkQueueItem{ItemKind: model.KindRadioArtwork.Prefix(), ItemID: radio.ID, ImageType: model.ImageTypePrimary,+ Priority: model.ArtworkPriorityBump}+ if err := NewArtworkQueueRepository(r.ctx, r.db).Enqueue(item); err != nil {+ log.Warn(r.ctx, "could not enqueue radio artwork", "id", radio.ID, err)+ }+ return nil}func (r *radioRepository) Count(options ...rest.QueryOptions) (int64, error) {diff --git a/persistence/radio_repository_test.go b/persistence/radio_repository_test.goindex 05628ca41..e2564455d 100644--- a/persistence/radio_repository_test.go+++ b/persistence/radio_repository_test.go@@ -7,6 +7,7 @@ import ("github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/request"+ "github.com/navidrome/navidrome/utils/slice". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega")@@ -78,6 +79,17 @@ var _ = Describe("RadioRepository", func() {})})+ Describe("GetAllIDs", func() {+ It("returns the same id set as GetAll", func() {+ want, err := repo.GetAll()+ Expect(err).To(BeNil())+ Expect(want).ToNot(BeEmpty())+ ids, err := repo.GetAllIDs()+ Expect(err).To(BeNil())+ Expect(ids).To(ConsistOf(slice.Map(want, func(r model.Radio) string { return r.ID })))+ })+ })+Describe("Put", func() {It("successfully updates item", func() {err := repo.Put(&model.Radio{@@ -107,6 +119,27 @@ var _ = Describe("RadioRepository", func() {Expect(err).To(BeNil())Expect(all[2].StreamUrl).To(Equal("https://example.com:4533/app"))})++ It("enqueues artwork resolution for the saved radio", func() {+ err := repo.Put(&model.Radio{+ Name: "Artwork radio",+ StreamUrl: "https://example.com:4533/artwork",+ })+ Expect(err).To(BeNil())++ all, err := repo.GetAll()+ Expect(err).To(BeNil())+ created := all[len(all)-1]++ queueRepo := NewArtworkQueueRepository(context.Background(), GetDBXBuilder())+ queued, err := queueRepo.DequeueBatch(1000)+ Expect(err).To(BeNil())+ Expect(queued).To(ContainElement(SatisfyAll(+ HaveField("ItemKind", "ra"),+ HaveField("ItemID", created.ID),+ HaveField("Priority", model.ArtworkPriorityBump),+ )))+ })})})diff --git a/persistence/sql_base_repository.go b/persistence/sql_base_repository.goindex d0cbb2946..33450fe9f 100644--- a/persistence/sql_base_repository.go+++ b/persistence/sql_base_repository.go@@ -15,6 +15,7 @@ import (. "github.com/Masterminds/squirrel""github.com/deluan/rest""github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/db""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model"id2 "github.com/navidrome/navidrome/model/id"@@ -597,9 +598,15 @@ func (r sqlRepository) delete(cond Sqlizer) error {func (r sqlRepository) logSQL(sql string, args dbx.Params, err error, rowsAffected int64, start time.Time) {elapsed := time.Since(start)+ fields := []any{r.ctx, "SQL: `" + sql + "`", "args", args, "rowsAffected", rowsAffected, "elapsedTime", elapsed}if err == nil || errors.Is(err, context.Canceled) {- log.Trace(r.ctx, "SQL: `"+sql+"`", "args", args, "rowsAffected", rowsAffected, "elapsedTime", elapsed, err)- } else {- log.Error(r.ctx, "SQL: `"+sql+"`", "args", args, "rowsAffected", rowsAffected, "elapsedTime", elapsed, err)+ log.Trace(append(fields, err)...)+ return+ }+ // The result codes separate errors that share a message, notably SQLITE_BUSY from+ // SQLITE_BUSY_SNAPSHOT, which no busy_timeout can retry.+ if code, extended, ok := db.ErrorCodes(err); ok {+ fields = append(fields, "sqliteCode", code, "sqliteExtended", extended)}+ log.Error(append(fields, err)...)}diff --git a/scanner/controller.go b/scanner/controller.goindex 463718ba3..df5aeb6f9 100644--- a/scanner/controller.go+++ b/scanner/controller.go@@ -11,7 +11,6 @@ import ("github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/auth""github.com/navidrome/navidrome/core/metrics""github.com/navidrome/navidrome/core/playlists"@@ -28,12 +27,11 @@ var (ErrAlreadyScanning = errors.New("already scanning"))-func New(rootCtx context.Context, ds model.DataStore, cw artwork.CacheWarmer, broker events.Broker,+func New(rootCtx context.Context, ds model.DataStore, broker events.Broker,pls playlists.Playlists, m metrics.Metrics) model.Scanner {c := &controller{rootCtx: rootCtx,ds: ds,- cw: cw,broker: broker,pls: pls,metrics: m,@@ -49,7 +47,7 @@ func (s *controller) getScanner() scanner {if s.devExternalScanner {return &scannerExternal{}}- return &scannerImpl{ds: s.ds, cw: s.cw, pls: s.pls}+ return &scannerImpl{ds: s.ds, pls: s.pls}}// CallScan starts an in-process scan of specific library/folder pairs.@@ -66,7 +64,7 @@ func CallScan(ctx context.Context, ds model.DataStore, pls playlists.Playlists,progress := make(chan *ProgressInfo, 100)go func() {defer close(progress)- scanner := &scannerImpl{ds: ds, cw: artwork.NoopCacheWarmer(), pls: pls}+ scanner := &scannerImpl{ds: ds, pls: pls}scanner.scanFolders(ctx, fullScan, targets, progress)}()return progress, nil@@ -97,7 +95,6 @@ type scanner interface {type controller struct {rootCtx context.Contextds model.DataStore- cw artwork.CacheWarmerbroker events.Brokermetrics metrics.Metricspls playlists.Playlistsdiff --git a/scanner/controller_test.go b/scanner/controller_test.goindex e4814da64..7ffdd69d4 100644--- a/scanner/controller_test.go+++ b/scanner/controller_test.go@@ -5,7 +5,6 @@ import ("github.com/navidrome/navidrome/conf/configtest""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core""github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/metrics""github.com/navidrome/navidrome/core/playlists"@@ -32,7 +31,7 @@ var _ = Describe("Controller", func() {DeferCleanup(configtest.SetupConfig())ds = &tests.MockDataStore{RealDS: persistence.New(db.Db())}ds.MockedProperty = &tests.MockedPropertyRepo{}- ctrl = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(), playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())+ ctrl = scanner.New(ctx, ds, events.NoopBroker(), playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())})It("includes last scan error", func() {diff --git a/scanner/phase_1_folders.go b/scanner/phase_1_folders.goindex 5e898590b..e853948e6 100644--- a/scanner/phase_1_folders.go+++ b/scanner/phase_1_folders.go@@ -16,7 +16,6 @@ import (ppl "github.com/google/go-pipeline/pkg/pipeline""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/storage""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model"@@ -26,7 +25,7 @@ import ("github.com/navidrome/navidrome/utils/slice")-func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStore, cw artwork.CacheWarmer) *phaseFolders {+func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStore) *phaseFolders {var jobs []*scanJob// Create scan jobs for all libraries@@ -37,7 +36,7 @@ func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStortargetFolders = state.targets[lib.ID]}- job, err := newScanJob(ctx, ds, cw, lib, state.fullScan, targetFolders)+ job, err := newScanJob(ctx, ds, lib, state.fullScan, targetFolders)if err != nil {log.Error(ctx, "Scanner: Error creating scan context", "lib", lib.Name, err)state.sendError(err)@@ -52,14 +51,13 @@ func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStortype scanJob struct {lib model.Libraryfs storage.MusicFS- cw artwork.CacheWarmerlastUpdates map[string]model.FolderUpdateInfo // Holds last update info for all (DB) folders in this librarytargetFolders []string // Specific folders to scan (including all descendants)lock sync.MutexnumFolders atomic.Int64}-func newScanJob(ctx context.Context, ds model.DataStore, cw artwork.CacheWarmer, lib model.Library, fullScan bool, targetFolders []string) (*scanJob, error) {+func newScanJob(ctx context.Context, ds model.DataStore, lib model.Library, fullScan bool, targetFolders []string) (*scanJob, error) {// Get folder updates, optionally filtered to specific target folderslastUpdates, err := ds.Folder(ctx).GetFolderUpdateInfo(lib, targetFolders...)if err != nil {@@ -85,7 +83,6 @@ func newScanJob(ctx context.Context, ds model.DataStore, cw artwork.CacheWarmer,return &scanJob{lib: lib,fs: fsys,- cw: cw,lastUpdates: lastUpdates,targetFolders: targetFolders,}, nil@@ -330,8 +327,8 @@ func (p *phaseFolders) persistChanges(entry *folderEntry) (*folderEntry, error)defer p.measure(entry)()p.state.changesDetected.Store(true)- // Collect artwork IDs to pre-cache after the transaction commits- var artworkIDs []model.ArtworkID+ // Collect artwork queue items for changed albums/artists, enqueued in the same transaction+ var queueItems []model.ArtworkQueueItemerr := p.ds.WithTx(func(tx model.DataStore) error {// Instantiate all repositories just once per folder@@ -371,7 +368,10 @@ func (p *phaseFolders) persistChanges(entry *folderEntry) (*folderEntry, error)return err}if entry.artists[i].Name != consts.UnknownArtist && entry.artists[i].Name != consts.VariousArtists {- artworkIDs = append(artworkIDs, entry.artists[i].CoverArtID())+ queueItems = append(queueItems, model.ArtworkQueueItem{+ ItemKind: model.KindArtistArtwork.Prefix(), ItemID: entry.artists[i].ID, ImageType: model.ImageTypePrimary,+ Priority: model.ArtworkPriorityScan,+ })}}@@ -383,7 +383,10 @@ func (p *phaseFolders) persistChanges(entry *folderEntry) (*folderEntry, error)return err}if entry.albums[i].Name != consts.UnknownAlbum {- artworkIDs = append(artworkIDs, entry.albums[i].CoverArtID())+ queueItems = append(queueItems, model.ArtworkQueueItem{+ ItemKind: model.KindAlbumArtwork.Prefix(), ItemID: entry.albums[i].ID, ImageType: model.ImageTypePrimary,+ Priority: model.ArtworkPriorityScan,+ })}}@@ -396,6 +399,14 @@ func (p *phaseFolders) persistChanges(entry *folderEntry) (*folderEntry, error)}}+ // A re-imported track returns to unresolved so new embedded art is picked up lazily.+ if len(entry.tracks) > 0 {+ trackIDs := slice.Map(entry.tracks, func(t model.MediaFile) string { return t.ID })+ if err := tx.Artwork(p.ctx).DeleteForItems(model.KindMediaFileArtwork, trackIDs); err != nil {+ log.Warn(p.ctx, "Scanner: could not invalidate media_file artwork", "folder", entry.path, err)+ }+ }+// Mark all missing tracks as not availableif len(entry.missingTracks) > 0 {err = mfRepo.MarkMissing(true, entry.missingTracks...)@@ -415,19 +426,25 @@ func (p *phaseFolders) persistChanges(entry *folderEntry) (*folderEntry, error)return err}}++ // Enqueue artwork resolution for changed albums/artists. Never fails the scan.+ // A full scan re-imports every track, so a re-import is no evidence the art changed.+ if len(queueItems) > 0 {+ queue := tx.ArtworkQueue(p.ctx)+ enqueue := queue.Enqueue+ if p.state.fullScan {+ enqueue = queue.EnqueueIfMissing+ }+ if err := enqueue(queueItems...); err != nil {+ log.Warn(p.ctx, "Scanner: could not enqueue artwork resolution", "folder", entry.path, err)+ }+ }return nil}, "scanner: persist changes")if err != nil {log.Error(p.ctx, "Scanner: Error persisting changes to DB", "folder", entry.path, err)}- // Pre-cache artwork after the transaction commits successfully- if err == nil {- for _, artID := range artworkIDs {- entry.job.cw.PreCache(artID)- }- }-return entry, err}diff --git a/scanner/phase_4_playlists.go b/scanner/phase_4_playlists.goindex 8ba014235..baa8b749a 100644--- a/scanner/phase_4_playlists.go+++ b/scanner/phase_4_playlists.go@@ -12,7 +12,6 @@ import (ppl "github.com/google/go-pipeline/pkg/pipeline""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/playlists""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model"@@ -24,18 +23,16 @@ type phasePlaylists struct {scanState *scanStateds model.DataStorepls playlists.Playlists- cw artwork.CacheWarmerrefreshed atomic.Uint32pendingImport bool}-func createPhasePlaylists(ctx context.Context, scanState *scanState, ds model.DataStore, pls playlists.Playlists, cw artwork.CacheWarmer) *phasePlaylists {+func createPhasePlaylists(ctx context.Context, scanState *scanState, ds model.DataStore, pls playlists.Playlists) *phasePlaylists {return &phasePlaylists{ctx: ctx,scanState: scanState,ds: ds,pls: pls,- cw: cw,}}@@ -148,7 +145,11 @@ func (p *phasePlaylists) processPlaylistsInFolder(folder *model.Folder) (*model.} else {log.Debug("Scanner: Imported playlist", "name", pls.Name, "lastUpdated", pls.UpdatedAt, "path", pls.Path, "numTracks", len(pls.Tracks), "elapsed", time.Since(started))}- p.cw.PreCache(pls.CoverArtID())+ item := model.ArtworkQueueItem{ItemKind: model.KindPlaylistArtwork.Prefix(), ItemID: pls.ID, ImageType: model.ImageTypePrimary,+ Priority: model.ArtworkPriorityScan}+ if err := p.ds.ArtworkQueue(p.ctx).Enqueue(item); err != nil {+ log.Warn(p.ctx, "Scanner: could not enqueue playlist artwork", "id", pls.ID, err)+ }p.refreshed.Add(1)}return folder, nildiff --git a/scanner/phase_4_playlists_test.go b/scanner/phase_4_playlists_test.goindex 49ffc7fb7..93ec1a36d 100644--- a/scanner/phase_4_playlists_test.go+++ b/scanner/phase_4_playlists_test.go@@ -10,7 +10,6 @@ import ("github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/conf/configtest""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/playlists""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/tests"@@ -27,7 +26,6 @@ var _ = Describe("phasePlaylists", func() {folderRepo *mockFolderRepositoryds *tests.MockDataStorepls *mockPlaylists- cw artwork.CacheWarmer)var userRepo *tests.MockedUserRepo@@ -48,9 +46,8 @@ var _ = Describe("phasePlaylists", func() {MockedProperty: propRepo,}pls = &mockPlaylists{}- cw = artwork.NoopCacheWarmer()state = &scanState{}- phase = createPhasePlaylists(ctx, state, ds, pls, cw)+ phase = createPhasePlaylists(ctx, state, ds, pls)})Describe("description", func() {@@ -193,6 +190,29 @@ var _ = Describe("phasePlaylists", func() {Expect(phase.refreshed.Load()).To(Equal(uint32(2)))})+ It("enqueues artwork resolution for the imported playlist", func() {+ libPath := GinkgoT().TempDir()+ folder := &model.Folder{LibraryPath: libPath, Path: "path/to", Name: "folder"}+ _ = os.MkdirAll(folder.AbsolutePath(), 0755)++ file1 := filepath.Join(folder.AbsolutePath(), "playlist1.m3u")+ _ = os.WriteFile(file1, []byte{}, 0600)++ pls.On("ImportFromFolder", mock.Anything, folder, "playlist1.m3u").+ Return(&model.Playlist{ID: "pl1"}, nil)++ _, err := phase.processPlaylistsInFolder(folder)+ Expect(err).ToNot(HaveOccurred())++ queued, err := ds.ArtworkQueue(ctx).DequeueBatch(10)+ Expect(err).ToNot(HaveOccurred())+ Expect(queued).To(ContainElement(SatisfyAll(+ HaveField("ItemKind", "pl"),+ HaveField("ItemID", "pl1"),+ HaveField("Priority", model.ArtworkPriorityScan),+ )))+ })+It("reports an error if there is an error reading files", func() {tests.SkipOnWindows("relies on Unix /etc filesystem")progress := make(chan *ProgressInfo)diff --git a/scanner/scanner.go b/scanner/scanner.goindex 27e2b19d2..29a1f9b4e 100644--- a/scanner/scanner.go+++ b/scanner/scanner.go@@ -11,7 +11,6 @@ import (ppl "github.com/google/go-pipeline/pkg/pipeline""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/playlists""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model"@@ -21,7 +20,6 @@ import (type scannerImpl struct {ds model.DataStore- cw artwork.CacheWarmerpls playlists.Playlists}@@ -136,7 +134,7 @@ func (s *scannerImpl) scanFolders(ctx context.Context, fullScan bool, targets []err = run.Sequentially(// Phase 1: Scan all libraries and import new/updated files- runPhase[*folderEntry](ctx, 1, createPhaseFolders(ctx, &state, s.ds, s.cw)),+ runPhase[*folderEntry](ctx, 1, createPhaseFolders(ctx, &state, s.ds)),// Phase 2: Process missing files, checking for movesrunPhase[*missingTracks](ctx, 2, createPhaseMissingTracks(ctx, &state, s.ds)),@@ -147,7 +145,7 @@ func (s *scannerImpl) scanFolders(ctx context.Context, fullScan bool, targets []runPhase[*model.Album](ctx, 3, createPhaseRefreshAlbums(ctx, &state, s.ds)),// Phase 4: Import/update playlists- runPhase[*model.Folder](ctx, 4, createPhasePlaylists(ctx, &state, s.ds, s.pls, s.cw)),+ runPhase[*model.Folder](ctx, 4, createPhasePlaylists(ctx, &state, s.ds, s.pls)),),// Final Steps (cannot be parallelized):@@ -155,6 +153,9 @@ func (s *scannerImpl) scanFolders(ctx context.Context, fullScan bool, targets []// Run GC if there were any changes (Remove dangling tracks, empty albums and artists, and orphan annotations)s.runGC(ctx, &state),+ // Queue artwork for entities that never resolved (after GC, so nothing dangling is queued)+ s.runEnqueueMissingArtwork(ctx, &state),+// Refresh artist and tags statss.runRefreshStats(ctx, &state),@@ -251,6 +252,29 @@ func (s *scannerImpl) runGC(ctx context.Context, state *scanState) func() error}}+// runEnqueueMissingArtwork is the safety net for entities phase 1 never enqueued.+func (s *scannerImpl) runEnqueueMissingArtwork(ctx context.Context, state *scanState) func() error {+ return func() error {+ if !state.changesDetected.Load() {+ log.Debug(ctx, "Scanner: No changes detected, skipping artwork enqueue")+ return nil+ }+ start := time.Now()+ queue := s.ds.ArtworkQueue(ctx)+ var total int64+ for _, kind := range []model.Kind{model.KindAlbumArtwork, model.KindArtistArtwork} {+ n, err := queue.EnqueueAllMissing(kind, model.ArtworkPriorityScan)+ if err != nil {+ log.Error(ctx, "Scanner: Error enqueueing missing artwork", "kind", kind, err)+ return fmt.Errorf("enqueueing missing artwork: %w", err)+ }+ total += n+ }+ log.Debug(ctx, "Scanner: Enqueued missing artwork", "items", total, "elapsed", time.Since(start))+ return nil+ }+}+func (s *scannerImpl) runRefreshStats(ctx context.Context, state *scanState) func() error {return func() error {if !state.changesDetected.Load() {diff --git a/scanner/scanner_benchmark_test.go b/scanner/scanner_benchmark_test.goindex 8f0dcd340..ca1064631 100644--- a/scanner/scanner_benchmark_test.go+++ b/scanner/scanner_benchmark_test.go@@ -12,7 +12,6 @@ import ("github.com/dustin/go-humanize""github.com/google/uuid""github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/core""github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/metrics""github.com/navidrome/navidrome/core/playlists"@@ -40,8 +39,8 @@ func BenchmarkScan(b *testing.B) {ds := persistence.New(db.Db())conf.Server.DevExternalScanner = false- s := scanner.New(context.Background(), ds, artwork.NoopCacheWarmer(), events.NoopBroker(),- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())+ s := scanner.New(context.Background(), ds, events.NoopBroker(),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())fs := storagetest.FakeFS{}storagetest.Register("fake", &fs)diff --git a/scanner/scanner_multilibrary_test.go b/scanner/scanner_multilibrary_test.goindex 3ae50933c..c0d5d4ece 100644--- a/scanner/scanner_multilibrary_test.go+++ b/scanner/scanner_multilibrary_test.go@@ -11,7 +11,6 @@ import ("github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/conf/configtest""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core""github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/metrics""github.com/navidrome/navidrome/core/playlists"@@ -78,8 +77,8 @@ var _ = Describe("Scanner - Multi-Library", Ordered, func() {}Expect(ds.User(ctx).Put(&adminUser)).To(Succeed())- s = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())+ s = scanner.New(ctx, ds, events.NoopBroker(),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())// Create two test libraries (let DB auto-assign IDs)lib1 = model.Library{Name: "Rock Collection", Path: "rock:///music"}diff --git a/scanner/scanner_selective_test.go b/scanner/scanner_selective_test.goindex 17772bf9d..acaa8f850 100644--- a/scanner/scanner_selective_test.go+++ b/scanner/scanner_selective_test.go@@ -10,7 +10,6 @@ import ("github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/conf/configtest""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core""github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/metrics""github.com/navidrome/navidrome/core/playlists"@@ -66,8 +65,8 @@ var _ = Describe("ScanFolders", Ordered, func() {}Expect(ds.User(ctx).Put(&adminUser)).To(Succeed())- s = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())+ s = scanner.New(ctx, ds, events.NoopBroker(),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())lib = model.Library{ID: 1, Name: "Fake Library", Path: "fake:///music"}Expect(ds.Library(ctx).Put(&lib)).To(Succeed())diff --git a/scanner/scanner_test.go b/scanner/scanner_test.goindex cc3720717..6098cbd66 100644--- a/scanner/scanner_test.go+++ b/scanner/scanner_test.go@@ -13,7 +13,6 @@ import ("github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/conf/configtest""github.com/navidrome/navidrome/consts"- "github.com/navidrome/navidrome/core""github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/metrics""github.com/navidrome/navidrome/core/playlists"@@ -86,8 +85,8 @@ var _ = Describe("Scanner", Ordered, func() {}Expect(ds.User(ctx).Put(&adminUser)).To(Succeed())- s = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())+ s = scanner.New(ctx, ds, events.NoopBroker(),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())lib = model.Library{ID: 1, Name: "Fake Library", Path: "fake:///music"}Expect(ds.Library(ctx).Put(&lib)).To(Succeed())@@ -98,6 +97,22 @@ var _ = Describe("Scanner", Ordered, func() {return err}+ // Stands in for the artwork worker: drains the queue and records every item as resolved,+ // so a later scan can only queue genuine reprocessing.+ resolveQueuedArtwork := func() []model.ArtworkQueueItem {+ GinkgoHelper()+ queued, err := ds.ArtworkQueue(ctx).DequeueBatch(1000)+ Expect(err).ToNot(HaveOccurred())+ for _, it := range queued {+ Expect(ds.Artwork(ctx).PutItemArtwork(&model.ItemArtwork{+ ItemKind: it.ItemKind, ItemID: it.ItemID, ImageType: it.ImageType,+ Hash: "resolved", Source: "embedded", UpdatedAt: time.Now(),+ })).To(Succeed())+ Expect(ds.ArtworkQueue(ctx).DeleteIfUnchanged(it.ItemKind, it.ItemID, it.ImageType, it.RetryAt)).To(Succeed())+ }+ return queued+ }+Context("Simple library, 'artis/album/track - title.mp3'", func() {var help, revolver func(...map[string]any) *fstest.MapFilevar fsys storagetest.FakeFS@@ -152,6 +167,40 @@ var _ = Describe("Scanner", Ordered, func() {HaveField("SongCount", Equal(4)),))})+ It("should enqueue artwork resolution for the scanned albums and artists", func() {+ Expect(runScanner(ctx, true)).To(Succeed())++ albums, _ := ds.Album(ctx).GetAll()+ artists, _ := ds.Artist(ctx).GetAll(model.QueryOptions{Filters: squirrel.NotEq{"name": consts.UnknownArtist}})+ queued, err := ds.ArtworkQueue(ctx).DequeueBatch(1000)+ Expect(err).ToNot(HaveOccurred())++ for _, al := range albums {+ Expect(queued).To(ContainElement(SatisfyAll(+ HaveField("ItemKind", "al"),+ HaveField("ItemID", al.ID),+ HaveField("Priority", model.ArtworkPriorityScan),+ )))+ }+ for _, ar := range artists {+ Expect(queued).To(ContainElement(SatisfyAll(+ HaveField("ItemKind", "ar"),+ HaveField("ItemID", ar.ID),+ HaveField("Priority", model.ArtworkPriorityScan),+ )))+ }+ })+ It("should not re-enqueue already resolved artwork on a repeat full scan", func() {+ Expect(runScanner(ctx, true)).To(Succeed())++ Expect(resolveQueuedArtwork()).ToNot(BeEmpty())++ Expect(runScanner(ctx, true)).To(Succeed())++ requeued, err := ds.ArtworkQueue(ctx).DequeueBatch(1000)+ Expect(err).ToNot(HaveOccurred())+ Expect(requeued).To(BeEmpty())+ })})When("a file was changed", func() {It("should update the media_file", func() {@@ -169,6 +218,25 @@ var _ = Describe("Scanner", Ordered, func() {Expect(mf[0].Tags).To(HaveKeyWithValue(model.TagName("barcode"), []string{"123"}))})+ It("should re-enqueue the album artwork even though it already resolved", func() {+ tests.SkipOnWindows("path separator bug (#TBD-path-sep-scanner)")+ Expect(runScanner(ctx, true)).To(Succeed())++ resolveQueuedArtwork()++ fsys.UpdateTags("The Beatles/Help!/01 - Help!.mp3", _t{"producer": "George Martin"})+ Expect(runScanner(ctx, false)).To(Succeed())++ albums, err := ds.Album(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"album.name": "Help!"}})+ Expect(err).ToNot(HaveOccurred())+ requeued, err := ds.ArtworkQueue(ctx).DequeueBatch(1000)+ Expect(err).ToNot(HaveOccurred())+ Expect(requeued).To(ContainElement(SatisfyAll(+ HaveField("ItemKind", "al"),+ HaveField("ItemID", albums[0].ID),+ )))+ })+It("should update the album", func() {tests.SkipOnWindows("path separator bug (#TBD-path-sep-scanner)")Expect(runScanner(ctx, true)).To(Succeed())@@ -187,6 +255,26 @@ var _ = Describe("Scanner", Ordered, func() {Expect(albums[0].Participants.First(model.RoleProducer).Name).To(Equal("George Martin"))Expect(albums[0].SongCount).To(Equal(3))})++ It("invalidates the media_file artwork state so new embedded art is picked up lazily", func() {+ Expect(runScanner(ctx, true)).To(Succeed())++ mf, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"title": "Help!"}})+ Expect(err).ToNot(HaveOccurred())+ Expect(mf).ToNot(BeEmpty())+ trackID := mf[0].ID++ Expect(ds.Artwork(ctx).PutItemArtwork(&model.ItemArtwork{+ ItemKind: "mf", ItemID: trackID, ImageType: model.ImageTypePrimary,+ Source: "embedded", Hash: "stalehash",+ })).To(Succeed())++ fsys.UpdateTags("The Beatles/Help!/01 - Help!.mp3", _t{"comment": "reimport"})+ Expect(runScanner(ctx, true)).To(Succeed())++ _, err = ds.Artwork(ctx).GetItemArtwork(model.KindMediaFileArtwork, trackID, model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))+ })})})diff --git a/server/imghttp/headers.go b/server/imghttp/headers.gonew file mode 100644index 000000000..9308bcdab--- /dev/null+++ b/server/imghttp/headers.go@@ -0,0 +1,67 @@+// Package imghttp holds the HTTP caching contract shared by the subsonic, public, and jellyfin+// image handlers, so they apply identical headers without importing each other.+package imghttp++import (+ "net/http"+ "strings"++ "github.com/navidrome/navidrome/core/artwork"+)++// WriteImageHeaders applies the artwork caching contract and reports whether a 304 was written+// (the caller must then not write a body). requestedHash is the hash the client asserted, or "".+func WriteImageHeaders(w http.ResponseWriter, r *http.Request, img *artwork.Image, requestedHash string) (wrote304 bool) {+ h := w.Header()+ // Placeholders are transient stand-ins for unresolved art: never cached, no validators.+ if img.Placeholder {+ h.Set("Cache-Control", "no-store")+ return false+ }++ // The ETag versions the served representation, so a re-encoding config change invalidates a+ // revalidating client's cache; full-size originals are their own pixel hash.+ etag := img.ETag+ if etag == "" {+ etag = img.Hash+ }+ // An empty validator would be shared by every such response, 304ing clients that echo it back.+ if etag != "" {+ h.Set("ETag", `"`+etag+`"`)+ }+ if !img.LastUpdated.IsZero() {+ h.Set("Last-Modified", img.LastUpdated.UTC().Format(http.TimeFormat))+ }+ // Immutable only when the client asked for the current pixel hash; anything else revalidates,+ // so art that gets re-resolved is never pinned.+ if requestedHash != "" && requestedHash == img.Hash {+ h.Set("Cache-Control", "public, max-age=31536000, immutable")+ } else {+ h.Set("Cache-Control", "public, no-cache")+ }++ if etag != "" && ifNoneMatch(r.Header.Get("If-None-Match"), etag) {+ w.WriteHeader(http.StatusNotModified)+ return true+ }+ return false+}++// ifNoneMatch reports whether If-None-Match asserts hash, using RFC 9110 weak comparison.+func ifNoneMatch(header, hash string) bool {+ header = strings.TrimSpace(header)+ if header == "" {+ return false+ }+ if header == "*" {+ return true+ }+ for tag := range strings.SplitSeq(header, ",") {+ tag = strings.TrimSpace(tag)+ tag = strings.TrimPrefix(tag, "W/")+ if strings.Trim(tag, `"`) == hash {+ return true+ }+ }+ return false+}diff --git a/server/imghttp/headers_test.go b/server/imghttp/headers_test.gonew file mode 100644index 000000000..2e8313faf--- /dev/null+++ b/server/imghttp/headers_test.go@@ -0,0 +1,117 @@+package imghttp_test++import (+ "io"+ "net/http"+ "net/http/httptest"+ "strings"+ "time"++ "github.com/navidrome/navidrome/core/artwork"+ "github.com/navidrome/navidrome/server/imghttp"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++const testHash = "0123456789abcdef"+const testRepTag = testHash + ".300.false.q75"++var lastMod = time.Date(2024, 1, 2, 3, 4, 5, 0, time.UTC)++func found() *artwork.Image {+ return &artwork.Image{+ ReadCloser: io.NopCloser(strings.NewReader("IMG")),+ Hash: testHash,+ LastUpdated: lastMod,+ }+}++func placeholder() *artwork.Image {+ return &artwork.Image{ReadCloser: io.NopCloser(strings.NewReader("PH")), Placeholder: true}+}++// A re-encoded response carries a representation ETag distinct from the pixel hash, so the+// validator versions with the encode settings.+func resized() *artwork.Image {+ return &artwork.Image{+ ReadCloser: io.NopCloser(strings.NewReader("IMG")),+ Hash: testHash,+ ETag: testRepTag,+ LastUpdated: lastMod,+ }+}++func unvalidated() *artwork.Image {+ return &artwork.Image{ReadCloser: io.NopCloser(strings.NewReader("IMG")), LastUpdated: lastMod}+}++var _ = Describe("WriteImageHeaders", func() {+ type testCase struct {+ img *artwork.Image+ requestedHash string+ ifNoneMatch string+ want304 bool+ wantCache string+ wantETag string+ wantLastMod bool+ }++ DescribeTable("applies the artwork caching contract",+ func(c testCase) {+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/img", nil)+ if c.ifNoneMatch != "" {+ r.Header.Set("If-None-Match", c.ifNoneMatch)+ }++ Expect(imghttp.WriteImageHeaders(w, r, c.img, c.requestedHash)).To(Equal(c.want304))++ h := w.Header()+ Expect(h.Get("Cache-Control")).To(Equal(c.wantCache))+ Expect(h.Get("ETag")).To(Equal(c.wantETag))+ if c.img.Placeholder {+ Expect(h.Get("ETag")).To(BeEmpty(), "placeholder must not set an ETag")+ Expect(h.Get("Last-Modified")).To(BeEmpty(), "placeholder must not set Last-Modified")+ }+ Expect(h.Get("Last-Modified") != "").To(Equal(c.wantLastMod))+ if c.want304 {+ Expect(w.Code).To(Equal(http.StatusNotModified))+ Expect(w.Body.Len()).To(BeZero(), "a 304 must have an empty body")+ }+ },+ Entry("placeholder is never cached and carries no validators",+ testCase{img: placeholder(), wantCache: "no-store"}),+ Entry("found with matching requested hash is immutable",+ testCase{img: found(), requestedHash: testHash, wantCache: "public, max-age=31536000, immutable", wantETag: `"` + testHash + `"`, wantLastMod: true}),+ Entry("found with bare id revalidates via no-cache",+ testCase{img: found(), wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),+ Entry("found with mismatched requested hash revalidates",+ testCase{img: found(), requestedHash: "ffffffffffffffff", wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),+ Entry("resized keeps pixel-hash immutable but serves the representation ETag",+ testCase{img: resized(), requestedHash: testHash, wantCache: "public, max-age=31536000, immutable", wantETag: `"` + testRepTag + `"`, wantLastMod: true}),+ Entry("resized 304s on the representation ETag, not the pixel hash",+ testCase{img: resized(), ifNoneMatch: `"` + testRepTag + `"`, want304: true, wantCache: "public, no-cache", wantETag: `"` + testRepTag + `"`, wantLastMod: true}),+ Entry("resized does not 304 on a stale pixel-hash validator (config changed)",+ testCase{img: resized(), ifNoneMatch: `"` + testHash + `"`, want304: false, wantCache: "public, no-cache", wantETag: `"` + testRepTag + `"`, wantLastMod: true}),+ Entry("If-None-Match matching the hash yields 304",+ testCase{img: found(), requestedHash: testHash, ifNoneMatch: `"` + testHash + `"`, want304: true, wantCache: "public, max-age=31536000, immutable", wantETag: `"` + testHash + `"`, wantLastMod: true}),+ Entry("weak If-None-Match matches (weak comparison)",+ testCase{img: found(), ifNoneMatch: `W/"` + testHash + `"`, want304: true, wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),+ Entry("If-None-Match with multiple values matches one",+ testCase{img: found(), ifNoneMatch: `"deadbeefdeadbeef", W/"` + testHash + `", "cafecafecafecafe"`, want304: true, wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),+ Entry("If-None-Match star matches any current representation",+ testCase{img: found(), ifNoneMatch: "*", want304: true, wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),+ Entry("non-matching If-None-Match serves body",+ testCase{img: found(), ifNoneMatch: `"deadbeefdeadbeef"`, want304: false, wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),+ Entry("placeholder ignores If-None-Match and never 304s",+ testCase{img: placeholder(), ifNoneMatch: "*", want304: false, wantCache: "no-store"}),++ // With no validator, an emitted ETag would be the same empty tag on every such response,+ // and matching it would 304 changed bytes.+ Entry("omits the ETag entirely when there is no validator",+ testCase{img: unvalidated(), wantCache: "public, no-cache", wantLastMod: true}),+ Entry("never 304s an empty validator echoed back by the client",+ testCase{img: unvalidated(), ifNoneMatch: `""`, want304: false,+ wantCache: "public, no-cache", wantLastMod: true}),+ )+})diff --git a/server/imghttp/imghttp_suite_test.go b/server/imghttp/imghttp_suite_test.gonew file mode 100644index 000000000..7a747db5b--- /dev/null+++ b/server/imghttp/imghttp_suite_test.go@@ -0,0 +1,17 @@+package imghttp_test++import (+ "testing"++ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++func TestImgHTTP(t *testing.T) {+ tests.Init(t, false)+ log.SetLevel(log.LevelFatal)+ RegisterFailHandler(Fail)+ RunSpecs(t, "ImgHTTP Suite")+}diff --git a/server/jellyfin/dto/blurhash.go b/server/jellyfin/dto/blurhash.godeleted file mode 100644index aaf6ff2af..000000000--- a/server/jellyfin/dto/blurhash.go+++ /dev/null@@ -1,36 +0,0 @@-package dto--import "hash/fnv"--// base83Alphabet is the blurhash spec's base83 encoding alphabet; order is part of the spec.-const base83Alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~"--// base83 encodes value as a fixed-width, big-endian base83 string of the given length.-func base83(value, length int) string {- b := make([]byte, length)- for i := 1; i <= length; i++ {- digit := (value / pow83(length-i)) % 83- b[i-1] = base83Alphabet[digit]- }- return string(b)-}--func pow83(n int) int {- result := 1- for range n {- result *= 83- }- return result-}--// blurHash returns a valid 6-char blurhash for a solid color derived from seed. Finamp only needs a-// well-formed, per-tag-stable value (it uses this as a download de-dup key and blur placeholder), so-// a solid color unique to the tag satisfies both without decoding cover art.-func blurHash(seed string) string {- h := fnv.New32a()- _, _ = h.Write([]byte(seed))- sum := h.Sum(nil)- r, g, b := int(sum[0]), int(sum[1]), int(sum[2])- dc := (r << 16) | (g << 8) | b- return "00" + base83(dc, 4)-}diff --git a/server/jellyfin/dto/blurhash_test.go b/server/jellyfin/dto/blurhash_test.godeleted file mode 100644index a6e36131d..000000000--- a/server/jellyfin/dto/blurhash_test.go+++ /dev/null@@ -1,27 +0,0 @@-package dto--import (- "strings"-- . "github.com/onsi/ginkgo/v2"- . "github.com/onsi/gomega"-)--var _ = Describe("blurHash", func() {- It("returns a 6-char valid blurhash starting with the 1x1 component prefix", func() {- h := blurHash("x")- Expect(h).To(HaveLen(6))- Expect(h).To(HavePrefix("00"))- for _, c := range h {- Expect(strings.ContainsRune(base83Alphabet, c)).To(BeTrue(), "unexpected char %q", c)- }- })-- It("is deterministic for the same seed", func() {- Expect(blurHash("cover-tag-1")).To(Equal(blurHash("cover-tag-1")))- })-- It("differs for different seeds", func() {- Expect(blurHash("cover-tag-1")).ToNot(Equal(blurHash("cover-tag-2")))- })-})diff --git a/server/jellyfin/dto/dto.go b/server/jellyfin/dto/dto.goindex 9b2c35c69..5a2a4c2b1 100644--- a/server/jellyfin/dto/dto.go+++ b/server/jellyfin/dto/dto.go@@ -81,12 +81,15 @@ type BaseItemDto struct {// ImageBlurHashes is keyed by image type (e.g. "Primary") then image tag. Finamp uses it as a// de-dup key for image downloads (and a placeholder); absent, it warns the server isn't// calculating blurhashes.- ImageBlurHashes map[string]map[string]string `json:"ImageBlurHashes,omitempty"`- BackdropImageTags []string `json:"BackdropImageTags"`- UserData *UserItemDataDto `json:"UserData,omitempty"`- MediaSources []MediaSourceInfo `json:"MediaSources,omitempty"`- Container string `json:"Container,omitempty"`- CanDownload bool `json:"CanDownload"`+ ImageBlurHashes map[string]map[string]string `json:"ImageBlurHashes,omitempty"`+ // PrimaryImageAspectRatio is width/height of the Primary image, attached only when the request's+ // Fields asks for it; omitted rather than guessed, since a wrong ratio mis-shapes a placeholder.+ PrimaryImageAspectRatio *float64 `json:"PrimaryImageAspectRatio,omitempty"`+ BackdropImageTags []string `json:"BackdropImageTags"`+ UserData *UserItemDataDto `json:"UserData,omitempty"`+ MediaSources []MediaSourceInfo `json:"MediaSources,omitempty"`+ Container string `json:"Container,omitempty"`+ CanDownload bool `json:"CanDownload"`}// PlaylistUserPermissions is the response shape for GET /Playlists/{id}/Users(/{userId}), whichdiff --git a/server/jellyfin/dto/mappers.go b/server/jellyfin/dto/mappers.goindex 444a25cac..352fce11d 100644--- a/server/jellyfin/dto/mappers.go+++ b/server/jellyfin/dto/mappers.go@@ -5,6 +5,7 @@ import ("fmt""time"+ "github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/utils/slice")@@ -192,31 +193,68 @@ func SongToBaseItem(mf model.MediaFile, fields Fields) BaseItemDto {} else if mf.Genre != "" {item.Genres = []string{mf.Genre}}- // Finamp resolves song art via AlbumId + a non-empty AlbumPrimaryImageTag.- if mf.AlbumID != "" {- item.AlbumPrimaryImageTag = mf.AlbumID- item.ImageBlurHashes = map[string]map[string]string{"Primary": {mf.AlbumID: blurHash(mf.AlbumID)}}+ // Clients prefer ImageTags.Primary over AlbumId, so a track's own cover must win here.+ if mf.ImageHash != "" && mf.ImageHash != mf.AlbumImage.ImageHash {+ tag, blurs, ratio := primaryImage(mf.ItemImage, mf.ID, fields)+ item.ImageTags = map[string]string{"Primary": tag}+ item.ImageBlurHashes = blurs+ item.PrimaryImageAspectRatio = ratio+ } else if embeddedArtPending(mf) {+ // Nothing enqueues media files: advertising the id is what makes a client ask, and that+ // request is what extracts the embedded art and queues the track.+ item.ImageTags = map[string]string{"Primary": mf.ID}+ } else if mf.AlbumID != "" {+ if tag, blurs, ratio := primaryImage(mf.AlbumImage, mf.AlbumID, fields); tag != "" {+ item.AlbumPrimaryImageTag = tag+ item.ImageBlurHashes = blurs+ item.PrimaryImageAspectRatio = ratio+ }}return item}+func embeddedArtPending(mf model.MediaFile) bool {+ return mf.HasCoverArt && conf.Server.EnableMediaFileCoverArt &&+ mf.ImageHash == "" && !mf.ItemImage.ImageAbsent+}++// primaryImage never fakes a blurhash: clients key their cover cache on the value, which would+// pin a stale cover forever.+func primaryImage(img model.ItemImage, fallback string, fields Fields) (tag string, blurs map[string]map[string]string, ratio *float64) {+ if img.ImageAbsent {+ return "", nil, nil+ }+ tag = cmp.Or(img.ImageHash, fallback)+ if img.BlurHash != "" {+ blurs = map[string]map[string]string{"Primary": {tag: img.BlurHash}}+ }+ if fields.Has("PrimaryImageAspectRatio") {+ ratio = img.AspectRatio()+ }+ return tag, blurs, ratio+}+func AlbumToBaseItem(al model.Album, fields Fields) BaseItemDto {+ tag, blurs, ratio := primaryImage(al.ItemImage, al.ID, fields)item := BaseItemDto{- Name: al.Name,- Id: EncodeID(al.ID),- Type: "MusicAlbum",- IsFolder: true,- ParentId: EncodeID(al.AlbumArtistID),- AlbumArtist: al.AlbumArtist,- Album: al.Name,- ChildCount: new(al.SongCount),- SongCount: new(al.SongCount),- RunTimeTicks: TicksFromSeconds(al.Duration),- DateCreated: jellyfinDate(&al.CreatedAt),- ImageTags: map[string]string{"Primary": al.ID},- ImageBlurHashes: map[string]map[string]string{"Primary": {al.ID: blurHash(al.ID)}},- BackdropImageTags: []string{},- UserData: UserData(al.Annotations, al.ID),+ Name: al.Name,+ Id: EncodeID(al.ID),+ Type: "MusicAlbum",+ IsFolder: true,+ ParentId: EncodeID(al.AlbumArtistID),+ AlbumArtist: al.AlbumArtist,+ Album: al.Name,+ ChildCount: new(al.SongCount),+ SongCount: new(al.SongCount),+ RunTimeTicks: TicksFromSeconds(al.Duration),+ DateCreated: jellyfinDate(&al.CreatedAt),+ ImageBlurHashes: blurs,+ PrimaryImageAspectRatio: ratio,+ BackdropImageTags: []string{},+ UserData: UserData(al.Annotations, al.ID),+ }+ if tag != "" {+ item.ImageTags = map[string]string{"Primary": tag}}if al.AlbumArtistID != "" {item.AlbumArtists = []NameGuidPair{{Name: al.AlbumArtist, Id: EncodeID(al.AlbumArtistID)}}@@ -246,20 +284,25 @@ func AlbumToBaseItem(al model.Album, fields Fields) BaseItemDto {return item}-func ArtistToBaseItem(ar model.Artist) BaseItemDto {- return BaseItemDto{- Name: ar.Name,- Id: EncodeID(ar.ID),- Type: "MusicArtist",- IsFolder: true,- AlbumCount: new(ar.AlbumCount),- SongCount: new(ar.SongCount),- DateCreated: jellyfinDate(ar.CreatedAt),- ImageTags: map[string]string{"Primary": ar.ID},- ImageBlurHashes: map[string]map[string]string{"Primary": {ar.ID: blurHash(ar.ID)}},- BackdropImageTags: []string{},- UserData: UserData(ar.Annotations, ar.ID),+func ArtistToBaseItem(ar model.Artist, fields Fields) BaseItemDto {+ tag, blurs, ratio := primaryImage(ar.ItemImage, ar.ID, fields)+ item := BaseItemDto{+ Name: ar.Name,+ Id: EncodeID(ar.ID),+ Type: "MusicArtist",+ IsFolder: true,+ AlbumCount: new(ar.AlbumCount),+ SongCount: new(ar.SongCount),+ DateCreated: jellyfinDate(ar.CreatedAt),+ ImageBlurHashes: blurs,+ PrimaryImageAspectRatio: ratio,+ BackdropImageTags: []string{},+ UserData: UserData(ar.Annotations, ar.ID),}+ if tag != "" {+ item.ImageTags = map[string]string{"Primary": tag}+ }+ return item}func GenreToBaseItem(g model.Genre) BaseItemDto {@@ -282,26 +325,28 @@ func StudioToBaseItem(t model.Tag) BaseItemDto {}// PlaylistToBaseItem maps a playlist to a Playlist BaseItemDto.-func PlaylistToBaseItem(p model.Playlist) BaseItemDto {- // Finamp caches covers keyed by blurHash, so the tag (and blurhash) must change with the cover.- // UpdatedAt versions it (Put bumps it on upload); over-invalidation only costs a refetch.- tag := fmt.Sprintf("%s-%x", p.ID, p.UpdatedAt.UnixMilli())- return BaseItemDto{+func PlaylistToBaseItem(p model.Playlist, fields Fields) BaseItemDto {+ tag, blurs, ratio := primaryImage(p.ItemImage, p.ID, fields)+ item := BaseItemDto{Name: p.Name,Id: EncodeID(p.ID),Type: "Playlist",// Synthetic path: Jellify only surfaces playlists whose Path contains "data" (real Jellyfin// stores them under its data folder), so without this its Playlists tab hides them all.- Path: "/data/playlists/" + p.ID,- IsFolder: true,- MediaType: "Audio",- ChildCount: new(p.SongCount),- RunTimeTicks: TicksFromSeconds(p.Duration),- ImageTags: map[string]string{"Primary": tag},- ImageBlurHashes: map[string]map[string]string{"Primary": {tag: blurHash(tag)}},- BackdropImageTags: []string{},- UserData: UserData(p.Annotations, p.ID),+ Path: "/data/playlists/" + p.ID,+ IsFolder: true,+ MediaType: "Audio",+ ChildCount: new(p.SongCount),+ RunTimeTicks: TicksFromSeconds(p.Duration),+ ImageBlurHashes: blurs,+ PrimaryImageAspectRatio: ratio,+ BackdropImageTags: []string{},+ UserData: UserData(p.Annotations, p.ID),+ }+ if tag != "" {+ item.ImageTags = map[string]string{"Primary": tag}}+ return item}// LyricDtoFromLyrics maps one lyric track to Jellyfin's LyricDto. Clients infer synced-vs-plaindiff --git a/server/jellyfin/dto/mappers_test.go b/server/jellyfin/dto/mappers_test.goindex c11f38eaf..a7b381c5c 100644--- a/server/jellyfin/dto/mappers_test.go+++ b/server/jellyfin/dto/mappers_test.go@@ -4,6 +4,8 @@ import ("encoding/json""time"+ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest""github.com/navidrome/navidrome/model". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega"@@ -34,8 +36,8 @@ var _ = Describe("mappers", func() {Expect(item.UserData.Played).To(BeTrue())Expect(item.UserData.Key).To(Equal(EncodeID("song-1")))Expect(item.UserData.ItemId).To(Equal(EncodeID("song-1")))- Expect(item.ImageBlurHashes["Primary"]).To(HaveKey(item.AlbumPrimaryImageTag))- Expect(item.ImageBlurHashes["Primary"][item.AlbumPrimaryImageTag]).To(HaveLen(6))+ Expect(item.AlbumPrimaryImageTag).To(Equal("alb-1"))+ Expect(item.ImageBlurHashes).To(BeNil())Expect(item.Genres).To(Equal([]string{"genre 1", "genre 2"}))Expect(item.GenreItems).To(Equal([]NameGuidPair{{Id: EncodeID("1"), Name: "genre 1"}, {Id: EncodeID("2"), Name: "genre 2"}}))})@@ -254,8 +256,8 @@ var _ = Describe("mappers", func() {Expect(item.ArtistItems).To(Equal(item.AlbumArtists))Expect(*item.ProductionYear).To(Equal(1999))Expect(*item.ChildCount).To(Equal(10))- Expect(item.ImageBlurHashes["Primary"]).To(HaveKey(item.ImageTags["Primary"]))- Expect(item.ImageBlurHashes["Primary"][item.ImageTags["Primary"]]).To(HaveLen(6))+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "alb-1"))+ Expect(item.ImageBlurHashes).To(BeNil())Expect(item.Genres).To(Equal([]string{"genre 1", "genre 2"}))Expect(item.GenreItems).To(Equal([]NameGuidPair{{Id: EncodeID("1"), Name: "genre 1"}, {Id: EncodeID("2"), Name: "genre 2"}}))})@@ -288,9 +290,74 @@ var _ = Describe("mappers", func() {Expect(string(b)).ToNot(ContainSubstring("NormalizationGain"))})+ Describe("PrimaryImageAspectRatio", func() {+ nonSquare := func() model.Album {+ al := model.Album{ID: "al1", Name: "Album"}+ al.ImageHash, al.ImageWidth, al.ImageHeight = "abc", 1200, 800+ return al+ }++ It("is omitted unless the request asks for it", func() {+ Expect(AlbumToBaseItem(nonSquare(), nil).PrimaryImageAspectRatio).To(BeNil())+ b, err := json.Marshal(AlbumToBaseItem(nonSquare(), nil))+ Expect(err).ToNot(HaveOccurred())+ Expect(string(b)).ToNot(ContainSubstring("PrimaryImageAspectRatio"))+ })++ It("carries the real ratio when asked", func() {+ item := AlbumToBaseItem(nonSquare(), ParseFields("PrimaryImageAspectRatio"))+ Expect(*item.PrimaryImageAspectRatio).To(BeNumerically("~", 1.5, 0.0001))+ })++ It("is omitted when the dimensions are unknown, rather than guessing square", func() {+ al := model.Album{ID: "al1", Name: "Album"}+ al.ImageHash = "abc"+ item := AlbumToBaseItem(al, ParseFields("PrimaryImageAspectRatio"))+ Expect(item.PrimaryImageAspectRatio).To(BeNil())+ })++ It("is omitted when the item has no image at all", func() {+ al := model.Album{ID: "al1", Name: "Album"}+ al.ImageAbsent = true+ al.ImageWidth, al.ImageHeight = 1200, 800+ item := AlbumToBaseItem(al, ParseFields("PrimaryImageAspectRatio"))+ Expect(item.PrimaryImageAspectRatio).To(BeNil())+ })++ It("carries the ratio for an artist", func() {+ ar := model.Artist{ID: "ar1", Name: "Artist"}+ ar.ImageHash, ar.ImageWidth, ar.ImageHeight = "abc", 1000, 500+ Expect(*ArtistToBaseItem(ar, ParseFields("PrimaryImageAspectRatio")).PrimaryImageAspectRatio).+ To(BeNumerically("~", 2.0, 0.0001))+ })++ It("carries the ratio for a playlist", func() {+ pl := model.Playlist{ID: "pl1", Name: "Playlist"}+ pl.ImageHash, pl.ImageWidth, pl.ImageHeight = "abc", 400, 800+ Expect(*PlaylistToBaseItem(pl, ParseFields("PrimaryImageAspectRatio")).PrimaryImageAspectRatio).+ To(BeNumerically("~", 0.5, 0.0001))+ })++ It("carries the ratio for a song with its own art", func() {+ mf := model.MediaFile{ID: "mf1", Title: "Song"}+ mf.ImageHash, mf.ImageWidth, mf.ImageHeight = "abc", 300, 600+ Expect(*SongToBaseItem(mf, ParseFields("PrimaryImageAspectRatio")).PrimaryImageAspectRatio).+ To(BeNumerically("~", 0.5, 0.0001))+ })++ // A track without its own art shows the album's, so the ratio has to describe that image.+ It("uses the album's dimensions for a track falling back to album art", func() {+ mf := model.MediaFile{ID: "mf1", Title: "Song", AlbumID: "al1"}+ mf.AlbumImage.ImageHash, mf.AlbumImage.ImageWidth, mf.AlbumImage.ImageHeight = "abc", 1200, 800+ item := SongToBaseItem(mf, ParseFields("PrimaryImageAspectRatio"))+ Expect(item.AlbumPrimaryImageTag).To(Equal("abc"))+ Expect(*item.PrimaryImageAspectRatio).To(BeNumerically("~", 1.5, 0.0001))+ })+ })+It("maps an artist to a MusicArtist folder item", func() {ar := model.Artist{ID: "art-1", Name: "AA", AlbumCount: 2, SongCount: 20}- item := ArtistToBaseItem(ar)+ item := ArtistToBaseItem(ar, nil)Expect(item.Type).To(Equal("MusicArtist"))Expect(item.IsFolder).To(BeTrue())Expect(item.Id).To(Equal(EncodeID("art-1")))@@ -352,7 +419,7 @@ var _ = Describe("mappers", func() {ID: "pl-1", Name: "Chill", SongCount: 7, Duration: 120,Annotations: model.Annotations{Starred: true, Rating: 4, PlayCount: 2},}- item := PlaylistToBaseItem(p)+ item := PlaylistToBaseItem(p, nil)Expect(item.Type).To(Equal("Playlist"))Expect(item.IsFolder).To(BeTrue())Expect(item.Id).To(Equal(EncodeID("pl-1")))@@ -363,26 +430,202 @@ var _ = Describe("mappers", func() {Expect(item.UserData.IsFavorite).To(BeTrue())Expect(item.UserData.PlayCount).To(Equal(2))Expect(*item.UserData.Rating).To(Equal(8.0))- tag := item.ImageTags["Primary"]- Expect(tag).ToNot(BeEmpty())- Expect(item.ImageBlurHashes["Primary"]).To(HaveKey(tag))- Expect(item.ImageBlurHashes["Primary"][tag]).To(HaveLen(6))+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "pl-1"))+ Expect(item.ImageBlurHashes).To(BeNil())})- It("changes the playlist image tag and blurhash when the playlist is updated (cover upload)", func() {- p := model.Playlist{ID: "pl-1", Name: "Chill", UpdatedAt: time.Date(2026, 7, 1, 0, 0, 0, 0, time.UTC)}- before := PlaylistToBaseItem(p)- p.UpdatedAt = time.Date(2026, 7, 2, 0, 0, 0, 0, time.UTC)- after := PlaylistToBaseItem(p)+ It("changes the playlist image tag when the cover content changes", func() {+ p := model.Playlist{ID: "pl-1", Name: "Chill"}+ p.ImageHash = "1111111111111111"+ before := PlaylistToBaseItem(p, nil)+ p.ImageHash = "2222222222222222"+ after := PlaylistToBaseItem(p, nil)- // Finamp caches covers keyed by blurHash, so tag and blurhash must change with the cover.- Expect(after.ImageTags["Primary"]).ToNot(Equal(before.ImageTags["Primary"]))- Expect(after.ImageBlurHashes["Primary"]).ToNot(Equal(before.ImageBlurHashes["Primary"]))+ Expect(before.ImageTags["Primary"]).To(Equal("1111111111111111"))+ Expect(after.ImageTags["Primary"]).To(Equal("2222222222222222"))})- It("keeps the playlist image tag stable when nothing changed", func() {+ It("keeps the playlist image tag stable across a metadata-only edit", func() {p := model.Playlist{ID: "pl-1", UpdatedAt: time.Date(2026, 7, 1, 0, 0, 0, 0, time.UTC)}- Expect(PlaylistToBaseItem(p).ImageTags).To(Equal(PlaylistToBaseItem(p).ImageTags))+ p.ImageHash = "1111111111111111"+ before := PlaylistToBaseItem(p, nil)+ p.UpdatedAt = time.Date(2026, 7, 2, 0, 0, 0, 0, time.UTC)+ after := PlaylistToBaseItem(p, nil)++ Expect(after.ImageTags["Primary"]).To(Equal(before.ImageTags["Primary"]))+ })++ // Nothing enqueues media files, so a track's own art only resolves when a client requests it;+ // advertising just the album image would leave that cover unreachable.+ Describe("unresolved embedded art", func() {+ BeforeEach(func() {+ DeferCleanup(configtest.SetupConfig())+ conf.Server.EnableMediaFileCoverArt = true+ })++ It("advertises the track id so the client triggers the read-through", func() {+ mf := model.MediaFile{ID: "mf-1", AlbumID: "alb-1", HasCoverArt: true}+ mf.AlbumImage.ImageHash = "0123456789abcdef"++ item := SongToBaseItem(mf, nil)+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "mf-1"))+ Expect(item.ImageBlurHashes).To(BeNil(), "no resolved image means no blurhash to send")+ Expect(item.AlbumPrimaryImageTag).To(BeEmpty())+ })++ It("falls back to the album when the track has no art of its own", func() {+ mf := model.MediaFile{ID: "mf-2", AlbumID: "alb-1", HasCoverArt: false}+ mf.AlbumImage.ImageHash = "0123456789abcdef"++ item := SongToBaseItem(mf, nil)+ Expect(item.ImageTags).To(BeEmpty())+ Expect(item.AlbumPrimaryImageTag).To(Equal("0123456789abcdef"))+ })++ It("falls back to the album once the track's art is known absent", func() {+ mf := model.MediaFile{ID: "mf-3", AlbumID: "alb-1", HasCoverArt: true}+ mf.ItemImage.ImageAbsent = true+ mf.AlbumImage.ImageHash = "0123456789abcdef"++ item := SongToBaseItem(mf, nil)+ Expect(item.ImageTags).To(BeEmpty())+ Expect(item.AlbumPrimaryImageTag).To(Equal("0123456789abcdef"))+ })++ It("falls back to the album when per-track art is disabled", func() {+ conf.Server.EnableMediaFileCoverArt = false+ mf := model.MediaFile{ID: "mf-4", AlbumID: "alb-1", HasCoverArt: true}+ mf.AlbumImage.ImageHash = "0123456789abcdef"++ item := SongToBaseItem(mf, nil)+ Expect(item.ImageTags).To(BeEmpty())+ Expect(item.AlbumPrimaryImageTag).To(Equal("0123456789abcdef"))+ })+ })++ Describe("primary image tags", func() {+ It("uses the content hash as the tag and emits the real blurhash", func() {+ al := model.Album{ID: "alb-1", Name: "Album"}+ al.ImageHash = "0123456789abcdef"+ al.BlurHash = "LEHV6nWB2yk8"++ item := AlbumToBaseItem(al, nil)+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "0123456789abcdef"))+ Expect(item.ImageBlurHashes["Primary"]).To(HaveKeyWithValue("0123456789abcdef", "LEHV6nWB2yk8"))+ })++ It("omits the blurhash entirely when none was computed", func() {+ al := model.Album{ID: "alb-2", Name: "Album"}+ al.ImageHash = "0123456789abcdef"++ item := AlbumToBaseItem(al, nil)+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "0123456789abcdef"))+ Expect(item.ImageBlurHashes).To(BeNil(), "a synthesized blurhash pins stale covers in Finamp")+ })++ It("omits tags for known-absent artwork", func() {+ al := model.Album{ID: "alb-3", Name: "Album"}+ al.ImageAbsent = true++ item := AlbumToBaseItem(al, nil)+ Expect(item.ImageTags).To(BeEmpty())+ Expect(item.ImageBlurHashes).To(BeNil())+ })++ It("falls back to the entity id while artwork is still unresolved", func() {+ item := AlbumToBaseItem(model.Album{ID: "alb-4", Name: "Album"}, nil)+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "alb-4"))+ Expect(item.ImageBlurHashes).To(BeNil())+ })++ It("versions an artist's tag by content hash", func() {+ ar := model.Artist{ID: "art-1", Name: "Artist"}+ ar.ImageHash = "fedcba9876543210"+ ar.BlurHash = "L6PZfSi_.AyE"++ item := ArtistToBaseItem(ar, nil)+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "fedcba9876543210"))+ Expect(item.ImageBlurHashes["Primary"]).To(HaveKeyWithValue("fedcba9876543210", "L6PZfSi_.AyE"))+ })+ })++ Describe("song and playlist image tags", func() {+ It("versions a song's album tag by the album's content hash", func() {+ mf := model.MediaFile{ID: "song-1", Title: "Song", AlbumID: "alb-1"}+ mf.AlbumImage.ImageHash = "0123456789abcdef"+ mf.AlbumImage.BlurHash = "LEHV6nWB2yk8"++ item := SongToBaseItem(mf, nil)+ Expect(item.AlbumPrimaryImageTag).To(Equal("0123456789abcdef"))+ Expect(item.ImageBlurHashes["Primary"]).To(HaveKeyWithValue("0123456789abcdef", "LEHV6nWB2yk8"))+ })++ It("never synthesizes a song blurhash when the album has none", func() {+ mf := model.MediaFile{ID: "song-2", Title: "Song", AlbumID: "alb-2"}+ mf.AlbumImage.ImageHash = "0123456789abcdef"++ item := SongToBaseItem(mf, nil)+ Expect(item.AlbumPrimaryImageTag).To(Equal("0123456789abcdef"))+ Expect(item.ImageBlurHashes).To(BeNil())+ })++ It("omits a song's album tag when the album art is known absent", func() {+ mf := model.MediaFile{ID: "song-3", Title: "Song", AlbumID: "alb-3"}+ mf.AlbumImage.ImageAbsent = true++ item := SongToBaseItem(mf, nil)+ Expect(item.AlbumPrimaryImageTag).To(BeEmpty())+ Expect(item.ImageBlurHashes).To(BeNil())+ })++ It("versions a playlist tag by content hash instead of UpdatedAt", func() {+ pl := model.Playlist{ID: "pl-1", Name: "Playlist"}+ pl.ImageHash = "abcdef0123456789"++ item := PlaylistToBaseItem(pl, nil)+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "abcdef0123456789"))+ })+ })++ Describe("per-song artwork", func() {+ It("emits the track's own Primary tag when it has distinct art", func() {+ mf := model.MediaFile{ID: "song-own", Title: "Song", AlbumID: "alb-1"}+ mf.ImageHash = "aaaaaaaaaaaaaaaa"+ mf.BlurHash = "LTRACKblur"+ mf.AlbumImage.ImageHash = "bbbbbbbbbbbbbbbb"+ mf.AlbumImage.BlurHash = "LALBUMblur"++ item := SongToBaseItem(mf, nil)+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "aaaaaaaaaaaaaaaa"))+ Expect(item.ImageBlurHashes["Primary"]).To(HaveLen(1),+ "exactly one Primary entry: Go sorts map keys, so a second entry could pair the wrong blurhash with imageId")+ Expect(item.ImageBlurHashes["Primary"]).To(HaveKeyWithValue("aaaaaaaaaaaaaaaa", "LTRACKblur"))+ })++ It("falls back to the album tag when the track has no distinct art", func() {+ mf := model.MediaFile{ID: "song-inherit", Title: "Song", AlbumID: "alb-1"}+ mf.ImageHash = "bbbbbbbbbbbbbbbb"+ mf.BlurHash = "LALBUMblur"+ mf.AlbumImage.ImageHash = "bbbbbbbbbbbbbbbb"+ mf.AlbumImage.BlurHash = "LALBUMblur"++ item := SongToBaseItem(mf, nil)+ Expect(item.ImageTags).To(BeEmpty(), "an inherited cover is the album's image, not the track's")+ Expect(item.AlbumPrimaryImageTag).To(Equal("bbbbbbbbbbbbbbbb"))+ Expect(item.ImageBlurHashes["Primary"]).To(HaveLen(1))+ Expect(item.ImageBlurHashes["Primary"]).To(HaveKeyWithValue("bbbbbbbbbbbbbbbb", "LALBUMblur"))+ })++ It("omits the track tag when its own art is known absent", func() {+ mf := model.MediaFile{ID: "song-absent", Title: "Song", AlbumID: "alb-1"}+ mf.ImageAbsent = true+ mf.AlbumImage.ImageAbsent = true++ item := SongToBaseItem(mf, nil)+ Expect(item.ImageTags).To(BeEmpty())+ Expect(item.AlbumPrimaryImageTag).To(BeEmpty())+ Expect(item.ImageBlurHashes).To(BeNil())+ })})})diff --git a/server/jellyfin/e2e/e2e_suite_test.go b/server/jellyfin/e2e/e2e_suite_test.goindex 31d98d1d9..ca1308e9e 100644--- a/server/jellyfin/e2e/e2e_suite_test.go+++ b/server/jellyfin/e2e/e2e_suite_test.go@@ -33,7 +33,6 @@ import ("strings""testing""testing/fstest"- "time""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/conf/configtest"@@ -327,7 +326,7 @@ func setupTestDB() {decider,core.NewPlayers(ds),scrobbler.NewPlayTracker(ds, events.NoopBroker(), nil),- playlists.NewPlaylists(ds, core.NewImageUploadService()),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)),providerFake,sonicSvc,lyrics.NewLyrics(ds, nil),@@ -406,18 +405,18 @@ type spyArtwork struct {data []byte}-func (s *spyArtwork) Get(context.Context, model.ArtworkID, int, bool) (io.ReadCloser, time.Time, error) {- return nil, time.Time{}, model.ErrNotFound+func (s *spyArtwork) Get(context.Context, model.ArtworkID, int, bool) (*artwork.Image, error) {+ return nil, model.ErrNotFound}-func (s *spyArtwork) GetOrPlaceholder(c context.Context, id string, _ int, _ bool) (io.ReadCloser, time.Time, error) {+func (s *spyArtwork) GetOrPlaceholder(c context.Context, id string, _ int, _ bool) (*artwork.Image, error) {s.lastID = ids.lastCtx = cd := s.dataif d == nil {d = []byte("IMG")}- return io.NopCloser(bytes.NewReader(d)), time.Time{}, nil+ return &artwork.Image{ReadCloser: io.NopCloser(bytes.NewReader(d))}, nil}var _ artwork.Artwork = &spyArtwork{}diff --git a/server/jellyfin/e2e/playlists_test.go b/server/jellyfin/e2e/playlists_test.goindex d2ff49db9..08d6f4f6f 100644--- a/server/jellyfin/e2e/playlists_test.go+++ b/server/jellyfin/e2e/playlists_test.go@@ -6,8 +6,8 @@ import (jpeglib "image/jpeg""net/http""os"- "time"+ "github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/server/jellyfin/dto". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega"@@ -215,26 +215,26 @@ var _ = Describe("Playlists", func() {To(Equal(http.StatusNotImplemented))})- // Guards the whole chain: SetImage must go through a full Put (which bumps UpdatedAt), and the- // tag must be versioned by it, or clients keep their blurhash-keyed cover cache forever.- It("rotates the playlist's image tag and blurhash after a cover upload", func() {+ // An upload must clear the resolved artwork state, or clients keep serving the stale cover+ // from their tag-keyed cache until the next scan.+ It("clears the resolved image tag after a cover upload", func() {plID := createPlaylist("Cover Tag", nil)+ Expect(ds.Artwork(ctx).PutItemArtwork(&model.ItemArtwork{+ ItemKind: model.KindPlaylistArtwork.Prefix(), ItemID: plID, Hash: "1111111111111111",+ })).To(Succeed())+imageTag := func() string {q := queryResult(get("/Items?ids=" + enc(plID)))Expect(q.Items).To(HaveLen(1))return q.Items[0].ImageTags["Primary"]}- before := imageTag()- Expect(before).ToNot(BeEmpty())+ Expect(imageTag()).To(Equal("1111111111111111"))- time.Sleep(2 * time.Millisecond) // UpdatedAt has millisecond resolution in the tagExpect(upload(adminUser, "/Items/"+enc(plID)+"/Images/Primary", "image/jpeg", jpeg).Code).To(Equal(http.StatusNoContent))- after := imageTag()- Expect(after).ToNot(Equal(before))- q := queryResult(get("/Items?ids=" + enc(plID)))- Expect(q.Items[0].ImageBlurHashes["Primary"]).To(HaveKey(after))+ // The upload re-queues resolution instead of resolving inline, so the tag goes bare.+ Expect(imageTag()).ToNot(Equal("1111111111111111"))})})diff --git a/server/jellyfin/images.go b/server/jellyfin/images.goindex 0ec34f491..b844e7c74 100644--- a/server/jellyfin/images.go+++ b/server/jellyfin/images.go@@ -16,10 +16,11 @@ import ("github.com/dustin/go-humanize""github.com/go-chi/chi/v5""github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/request"+ "github.com/navidrome/navidrome/server/imghttp""github.com/navidrome/navidrome/server/jellyfin/dto"_ "golang.org/x/image/webp")@@ -32,7 +33,7 @@ func (api *Router) getItemImage(w http.ResponseWriter, r *http.Request) {size, _ := strconv.Atoi(r.URL.Query().Get("maxwidth"))artID := api.resolveArtworkID(ctx, itemId)- reader, _, err := api.artwork.GetOrPlaceholder(ctx, artID, size, false)+ img, err := api.artwork.GetOrPlaceholder(ctx, artID, size, false)switch {case errors.Is(err, context.Canceled):return@@ -41,9 +42,27 @@ func (api *Router) getItemImage(w http.ResponseWriter, r *http.Request) {http.Error(w, "Not Found", http.StatusNotFound)return}- defer reader.Close()+ defer img.Close()+ if imghttp.WriteImageHeaders(w, r, img, hashFromTag(r)) {+ return+ }// Leave Content-Type unset so net/http sniffs it (covers may be PNG/WebP/JPEG).- _, _ = io.Copy(w, reader)+ _, _ = io.Copy(w, img)+}++// hashFromTag returns the ?tag query param when it is exactly a 16-char lowercase-hex content+// hash (what Finamp/Jellyfin clients append), so a matching request can be served immutable.+func hashFromTag(r *http.Request) string {+ tag := r.URL.Query().Get("tag")+ if len(tag) != 16 {+ return ""+ }+ for _, c := range tag {+ if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {+ return ""+ }+ }+ return tag}// resolveArtworkID maps a Jellyfin item id to a Navidrome ArtworkID, probing@@ -79,7 +98,7 @@ func (api *Router) postItemImage(w http.ResponseWriter, r *http.Request) {}// The limit caps the decoded image (native endpoint semantics); Jellyfin clients base64-encode// the wire body (4/3 bigger), so the read cap allows for inflation.- limit := core.MaxImageUploadSize()+ limit := artwork.MaxImageUploadSize()body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, limit*4/3+4))if err != nil {log.Warn(ctx, "Jellyfin API: cover upload rejected: body exceeds MaxImageUploadSize",diff --git a/server/jellyfin/images_test.go b/server/jellyfin/images_test.goindex e435b99fd..bdd47e956 100644--- a/server/jellyfin/images_test.go+++ b/server/jellyfin/images_test.go@@ -33,16 +33,21 @@ type fakeArtwork struct {recvId stringrecvCtx context.Contextdata []byte+ hash string}-func (f *fakeArtwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (io.ReadCloser, time.Time, error) {+func (f *fakeArtwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (*artwork.Image, error) {f.recvId = idf.recvCtx = ctxdata := f.dataif data == nil {data = []byte("IMG")}- return io.NopCloser(bytes.NewReader(data)), time.Now(), nil+ return &artwork.Image{+ ReadCloser: io.NopCloser(bytes.NewReader(data)),+ Hash: f.hash,+ LastUpdated: time.Now(),+ }, nil}func newImageRequest(itemId string) (*httptest.ResponseRecorder, *http.Request) {@@ -70,6 +75,19 @@ var _ = Describe("Images", func() {Expect(fa.recvId).To(ContainSubstring("a1"))})+ // resolveArtworkID probes the entity tables, so a deleted item yields no artwork id at all.+ It("asks for no artwork once the item is deleted, rather than its lingering state", func() {+ ds := &tests.MockDataStore{} // no albums/artists/tracks/playlists at all+ fa := &fakeArtwork{}+ api := &Router{ds: ds, artwork: fa}++ w, r := newImageRequest(dto.EncodeID("deleted-item"))+ api.getItemImage(w, r)++ Expect(fa.recvId).To(BeEmpty(), "an empty artwork id can only yield a placeholder")+ Expect(w.Body.String()).ToNot(ContainSubstring("deleted-item"))+ })+It("sniffs the Content-Type instead of hardcoding it", func() {ds := &tests.MockDataStore{}ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})@@ -115,6 +133,38 @@ var _ = Describe("Images", func() {Expect(ok).To(BeTrue())Expect(u.IsAdmin).To(BeTrue())})++ It("serves immutable when the tag param asserts the current hash", func() {+ const hash = "0123456789abcdef"+ ds := &tests.MockDataStore{}+ ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})+ fa := &fakeArtwork{hash: hash}+ api := &Router{ds: ds, artwork: fa}++ w, r := newImageRequest(dto.EncodeID("a1"))+ q := r.URL.Query()+ q.Set("tag", hash)+ r.URL.RawQuery = q.Encode()+ api.getItemImage(w, r)++ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, max-age=31536000, immutable"))+ Expect(w.Header().Get("ETag")).To(Equal(`"` + hash + `"`))+ })++ It("revalidates via no-cache when no tag is provided", func() {+ const hash = "0123456789abcdef"+ ds := &tests.MockDataStore{}+ ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})+ fa := &fakeArtwork{hash: hash}+ api := &Router{ds: ds, artwork: fa}++ w, r := newImageRequest(dto.EncodeID("a1"))+ api.getItemImage(w, r)++ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, no-cache"))+ })})// Real image fixtures: postItemImage validates uploads by decoding them.diff --git a/server/jellyfin/items.go b/server/jellyfin/items.goindex 7cf2a17ba..631530b6d 100644--- a/server/jellyfin/items.go+++ b/server/jellyfin/items.go@@ -588,7 +588,7 @@ func (api *Router) listSongs(ctx context.Context, opts model.QueryOptions, q ite// A full-library request (Finamp's sync, with MediaSources) is tens of thousands of fat rows.total, _ := repo.CountAll(model.QueryOptions{Filters: opts.Filters})open := streamCursor(func() (func(func(model.MediaFile, error) bool), error) {- return repo.GetCursor(opts)+ return repo.GetCursorWithArtwork(opts)}, toItem)return streamed(open, int(total), opts.Offset), nil}@@ -598,6 +598,7 @@ func (api *Router) listSongs(ctx context.Context, opts model.QueryOptions, q ite// genreIds isn't applied to search — a name lookup, like role (see below).func (api *Router) listArtists(ctx context.Context, opts model.QueryOptions, q itemsQuery, role model.Role) (itemsResult, error) {repo := api.ds.Artist(ctx)+ toItem := func(ar model.Artist) dto.BaseItemDto { return dto.ArtistToBaseItem(ar, q.fields) }// Artist Search does its own library scoping: it consumes a sole Eq{"library_id": ...} filter as a// search scope (artists have no library_id column). A compound or join-based filter@@ -613,7 +614,7 @@ func (api *Router) listArtists(ctx context.Context, opts model.QueryOptions, q iif err != nil {return itemsResult{}, err}- return materialized(result(slice.Map(artists, dto.ArtistToBaseItem), total, opts.Offset)), nil+ return materialized(result(slice.Map(artists, toItem), total, opts.Offset)), nil}if q.favOnly {@@ -629,7 +630,7 @@ func (api *Router) listArtists(ctx context.Context, opts model.QueryOptions, q itotal, _ := repo.CountAll(model.QueryOptions{Filters: opts.Filters})open := streamCursor(func() (func(func(model.Artist, error) bool), error) {return repo.GetCursor(opts)- }, dto.ArtistToBaseItem)+ }, toItem)return streamed(open, int(total), opts.Offset), nil}@@ -663,7 +664,7 @@ func (api *Router) listPlaylists(ctx context.Context, opts model.QueryOptions, q}open := streamCursor(func() (func(func(model.Playlist, error) bool), error) {return repo.GetCursor(opts)- }, dto.PlaylistToBaseItem)+ }, func(p model.Playlist) dto.BaseItemDto { return dto.PlaylistToBaseItem(p, q.fields) })return streamed(open, int(total), opts.Offset), nil}@@ -698,7 +699,7 @@ func (api *Router) resolveItemByID(ctx context.Context, id string, fields dto.Fiif ar, err := api.ds.Artist(ctx).Get(id); err == nil {// TODO: an artist spans multiple libraries (library_artist), so there's no single// LibraryID to gate here; artist access relies on list-time scoping and persistence.- return dto.ArtistToBaseItem(*ar), true+ return dto.ArtistToBaseItem(*ar, fields), true}if mf, err := api.ds.MediaFile(ctx).Get(id); err == nil {if !u.HasLibraryAccess(mf.LibraryID) {@@ -708,7 +709,7 @@ func (api *Router) resolveItemByID(ctx context.Context, id string, fields dto.Fi}// api.playlists.Get enforces ownership/visibility, so a non-owned or missing id falls through.if pl, err := api.playlists.Get(ctx, id); err == nil {- return dto.PlaylistToBaseItem(*pl), true+ return dto.PlaylistToBaseItem(*pl, fields), true}return dto.BaseItemDto{}, false}diff --git a/server/jellyfin/similar.go b/server/jellyfin/similar.goindex 661fb95cc..2698073bf 100644--- a/server/jellyfin/similar.go+++ b/server/jellyfin/similar.go@@ -138,7 +138,7 @@ func (api *Router) similarArtists(ctx context.Context, id string, limit int) dtoreturn result(nil, 0, 0)}present := slice.Filter(artist.SimilarArtists, func(a model.Artist) bool { return a.ID != "" })- items := slice.Map(present, dto.ArtistToBaseItem)+ items := slice.Map(present, func(a model.Artist) dto.BaseItemDto { return dto.ArtistToBaseItem(a, nil) })return result(items, len(items), 0)}diff --git a/server/nativeapi/artists.go b/server/nativeapi/artists.goindex daa918d00..193f88eda 100644--- a/server/nativeapi/artists.go+++ b/server/nativeapi/artists.go@@ -46,7 +46,11 @@ func (api *Router) uploadArtistImage() http.HandlerFunc {}ar.UploadedImage = filenamear.UpdatedAt = new(time.Now())- return api.ds.Artist(ctx).Put(ar, "uploaded_image", "updated_at")+ if err := api.ds.Artist(ctx).Put(ar, "uploaded_image", "updated_at"); err != nil {+ return err+ }+ api.imgUpload.EnqueueArtwork(ctx, consts.EntityArtist, ar.ID)+ return nil})}@@ -65,6 +69,10 @@ func (api *Router) deleteArtistImage() http.HandlerFunc {}ar.UploadedImage = ""ar.UpdatedAt = new(time.Now())- return api.ds.Artist(ctx).Put(ar, "uploaded_image", "updated_at")+ if err := api.ds.Artist(ctx).Put(ar, "uploaded_image", "updated_at"); err != nil {+ return err+ }+ api.imgUpload.EnqueueArtwork(ctx, consts.EntityArtist, ar.ID)+ return nil})}diff --git a/server/nativeapi/artwork.go b/server/nativeapi/artwork.gonew file mode 100644index 000000000..3583c2db7--- /dev/null+++ b/server/nativeapi/artwork.go@@ -0,0 +1,42 @@+package nativeapi++import (+ "net/http"+ "slices"++ "github.com/go-chi/chi/v5"+ "github.com/navidrome/navidrome/core/artwork"+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+)++var refreshableArtworkKinds = []model.Kind{+ model.KindAlbumArtwork,+ model.KindArtistArtwork,+ model.KindPlaylistArtwork,+ model.KindRadioArtwork,+ model.KindMediaFileArtwork,+}++func (api *Router) addArtworkRoute(r chi.Router) {+ r.Post("/artwork/{kind}/{id}/refresh", api.refreshArtwork())+}++// State is deliberately cleared so a wrong pick disappears immediately (placeholder until re-resolved).+func (api *Router) refreshArtwork() http.HandlerFunc {+ return func(w http.ResponseWriter, r *http.Request) {+ ctx := r.Context()+ kind, _ := model.ParseKind(chi.URLParam(r, "kind"))+ id := chi.URLParam(r, "id")+ if !slices.Contains(refreshableArtworkKinds, kind) {+ http.Error(w, "invalid artwork kind", http.StatusBadRequest)+ return+ }+ if err := artwork.Refresh(ctx, api.ds, kind, id); err != nil {+ log.Error(ctx, "Error refreshing artwork", "kind", kind, "id", id, err)+ http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)+ return+ }+ w.WriteHeader(http.StatusNoContent)+ }+}diff --git a/server/nativeapi/artwork_test.go b/server/nativeapi/artwork_test.gonew file mode 100644index 000000000..b26a94e6a--- /dev/null+++ b/server/nativeapi/artwork_test.go@@ -0,0 +1,95 @@+package nativeapi++import (+ "context"+ "net/http"+ "net/http/httptest"++ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest"+ "github.com/navidrome/navidrome/core/auth"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/server"+ "github.com/navidrome/navidrome/tests"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++var _ = Describe("Artwork API", func() {+ var ds *tests.MockDataStore+ var artRepo *tests.MockArtworkRepo+ var queueRepo *tests.MockArtworkQueueRepo+ var router http.Handler+ var adminToken, userToken string++ BeforeEach(func() {+ DeferCleanup(configtest.SetupConfig())+ conf.Server.EnableSharing = false+ artRepo = tests.CreateMockArtworkRepo()+ queueRepo = tests.CreateMockArtworkQueueRepo()+ ds = &tests.MockDataStore{MockedArtwork: artRepo, MockedArtworkQueue: queueRepo}+ auth.Init(ds)+ nativeRouter := New(ds, nil, nil, nil, tests.NewMockLibraryService(), tests.NewMockUserService(), nil, nil, nil)+ router = server.JWTVerifier(nativeRouter)++ adminUser := model.User{ID: "admin-1", UserName: "admin", IsAdmin: true, NewPassword: "adminpass"}+ regularUser := model.User{ID: "user-1", UserName: "regular", IsAdmin: false, NewPassword: "userpass"}+ Expect(ds.User(context.TODO()).Put(&adminUser)).To(Succeed())+ Expect(ds.User(context.TODO()).Put(®ularUser)).To(Succeed())++ var err error+ adminToken, err = auth.CreateToken(&adminUser)+ Expect(err).ToNot(HaveOccurred())+ userToken, err = auth.CreateToken(®ularUser)+ Expect(err).ToNot(HaveOccurred())+ })++ Describe("POST /api/artwork/{kind}/{id}/refresh", func() {+ It("clears state and enqueues a Bump for admins", func() {+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{+ ItemKind: "al", ItemID: "al-1", Hash: "oldhash", Source: "external",+ })).To(Succeed())++ req := createAuthenticatedRequest("POST", "/artwork/al/al-1/refresh", nil, adminToken)+ w := httptest.NewRecorder()+ router.ServeHTTP(w, req)++ Expect(w.Code).To(Equal(http.StatusNoContent))++ _, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al-1", model.ImageTypePrimary)+ Expect(err).To(MatchError(model.ErrNotFound))++ queued, err := queueRepo.DequeueBatch(1000)+ Expect(err).ToNot(HaveOccurred())+ Expect(queued).To(ContainElement(SatisfyAll(+ HaveField("ItemKind", "al"),+ HaveField("ItemID", "al-1"),+ HaveField("Priority", model.ArtworkPriorityBump),+ )))+ })++ It("returns 400 for an invalid kind", func() {+ req := createAuthenticatedRequest("POST", "/artwork/xx/id-1/refresh", nil, adminToken)+ w := httptest.NewRecorder()+ router.ServeHTTP(w, req)++ Expect(w.Code).To(Equal(http.StatusBadRequest))+ })++ It("denies access to regular users", func() {+ req := createAuthenticatedRequest("POST", "/artwork/al/al-1/refresh", nil, userToken)+ w := httptest.NewRecorder()+ router.ServeHTTP(w, req)++ Expect(w.Code).To(Equal(http.StatusForbidden))+ })++ It("denies access without authentication", func() {+ req := createUnauthenticatedRequest("POST", "/artwork/al/al-1/refresh", nil)+ w := httptest.NewRecorder()+ router.ServeHTTP(w, req)++ Expect(w.Code).To(Equal(http.StatusUnauthorized))+ })+ })+})diff --git a/server/nativeapi/image_upload.go b/server/nativeapi/image_upload.goindex 077eac35e..c4ff62e42 100644--- a/server/nativeapi/image_upload.go+++ b/server/nativeapi/image_upload.go@@ -14,7 +14,7 @@ import ("strings""github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/request"@@ -31,7 +31,7 @@ func checkImageUploadPermission(w http.ResponseWriter, r *http.Request) bool {}func handleImageUpload(saveFn func(ctx context.Context, reader io.Reader, ext string) error) http.HandlerFunc {- maxImageSize := core.MaxImageUploadSize()+ maxImageSize := artwork.MaxImageUploadSize()return func(w http.ResponseWriter, r *http.Request) {ctx := r.Context()if !checkImageUploadPermission(w, r) {diff --git a/server/nativeapi/native_api.go b/server/nativeapi/native_api.goindex 5a7023eb6..f97bd26b2 100644--- a/server/nativeapi/native_api.go+++ b/server/nativeapi/native_api.go@@ -13,6 +13,7 @@ import ("github.com/go-chi/chi/v5/middleware""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/metrics"playlistsvc "github.com/navidrome/navidrome/core/playlists""github.com/navidrome/navidrome/log"@@ -44,10 +45,10 @@ type Router struct {users core.Usermaintenance core.MaintenancepluginManager PluginManager- imgUpload core.ImageUploadService+ imgUpload artwork.Uploader}-func New(ds model.DataStore, share core.Share, playlists playlistsvc.Playlists, insights metrics.Insights, libraryService core.Library, userService core.User, maintenance core.Maintenance, pluginManager PluginManager, imgUpload core.ImageUploadService) *Router {+func New(ds model.DataStore, share core.Share, playlists playlistsvc.Playlists, insights metrics.Insights, libraryService core.Library, userService core.User, maintenance core.Maintenance, pluginManager PluginManager, imgUpload artwork.Uploader) *Router {r := &Router{ds: ds, share: share, playlists: playlists, insights: insights, libs: libraryService, users: userService, maintenance: maintenance, pluginManager: pluginManager, imgUpload: imgUpload}r.Handler = r.routes()return r@@ -91,6 +92,7 @@ func (api *Router) routes() http.Handler {api.addConfigRoute(r)api.addUserLibraryRoute(r)api.addPluginRoute(r)+ api.addArtworkRoute(r)api.RX(r, "/library", api.libs.NewRepository, true)})})diff --git a/server/nativeapi/radios.go b/server/nativeapi/radios.goindex 701c6c926..3e88af287 100644--- a/server/nativeapi/radios.go+++ b/server/nativeapi/radios.go@@ -47,7 +47,11 @@ func (api *Router) uploadRadioImage() http.HandlerFunc {return err}radio.UploadedImage = filename- return api.ds.Radio(ctx).Put(radio, "UploadedImage")+ if err := api.ds.Radio(ctx).Put(radio, "UploadedImage"); err != nil {+ return err+ }+ api.imgUpload.EnqueueArtwork(ctx, consts.EntityRadio, radio.ID)+ return nil})}@@ -65,6 +69,10 @@ func (api *Router) deleteRadioImage() http.HandlerFunc {return err}radio.UploadedImage = ""- return api.ds.Radio(ctx).Put(radio, "UploadedImage")+ if err := api.ds.Radio(ctx).Put(radio, "UploadedImage"); err != nil {+ return err+ }+ api.imgUpload.EnqueueArtwork(ctx, consts.EntityRadio, radio.ID)+ return nil})}diff --git a/server/public/handle_images.go b/server/public/handle_images.goindex 633665e0f..6416190bd 100644--- a/server/public/handle_images.go+++ b/server/public/handle_images.go@@ -11,6 +11,8 @@ import ("github.com/navidrome/navidrome/core/auth""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/model/request"+ "github.com/navidrome/navidrome/server/imghttp""github.com/navidrome/navidrome/utils/req")@@ -37,10 +39,13 @@ func (pub *Router) handleImages(w http.ResponseWriter, r *http.Request) {http.Error(w, "invalid request", http.StatusBadRequest)return}+ // The token is the authorization, so the entity check must ask "is it still there", not+ // "may this user see it" -- the latter would hide a shared private playlist.+ ctx = request.WithUser(ctx, model.User{IsAdmin: true})size := p.IntOr("size", 0)square := p.BoolOr("square", false)- imgReader, lastUpdate, err := pub.artwork.Get(ctx, artId, size, square)+ img, err := pub.artwork.Get(ctx, artId, size, square)switch {case errors.Is(err, context.Canceled):return@@ -58,10 +63,11 @@ func (pub *Router) handleImages(w http.ResponseWriter, r *http.Request) {return}- defer imgReader.Close()- w.Header().Set("Cache-Control", "public, max-age=315360000")- w.Header().Set("Last-Modified", lastUpdate.Format(http.TimeFormat))- cnt, err := io.Copy(w, imgReader)+ defer img.Close()+ if imghttp.WriteImageHeaders(w, r, img, artId.Hash) {+ return+ }+ cnt, err := io.Copy(w, img)if err != nil {log.Warn(ctx, "Error sending image", "count", cnt, err)}diff --git a/server/public/handle_images_test.go b/server/public/handle_images_test.goindex 669f879a6..d77b6f427 100644--- a/server/public/handle_images_test.go+++ b/server/public/handle_images_test.go@@ -1,8 +1,18 @@package publicimport (+ "bytes"+ "context"+ "io"+ "net/http"+ "net/http/httptest"+ "net/url"+"github.com/go-chi/jwtauth/v5"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/auth"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/tests". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega")@@ -23,3 +33,56 @@ var _ = Describe("decodeArtworkID", func() {Expect(err).To(HaveOccurred())})})++type fakeArtwork struct {+ artwork.Artwork+ img *artwork.Image+ err error+}++func (f *fakeArtwork) Get(context.Context, model.ArtworkID, int, bool) (*artwork.Image, error) {+ return f.img, f.err+}++var _ = Describe("handleImages", func() {+ var w *httptest.ResponseRecorder++ newImageRequest := func(claimID string) *http.Request {+ auth.PublicTokenAuth = jwtauth.New("HS256", []byte("super secret"), nil)+ token, _ := auth.CreatePublicToken(auth.Claims{ID: claimID})+ return httptest.NewRequest("GET", "/img?:id="+url.QueryEscape(token), nil)+ }++ // The handler re-checks that the entity behind the token still exists, so "1" must be live.+ var ds *tests.MockDataStore++ BeforeEach(func() {+ w = httptest.NewRecorder()+ albumRepo := tests.CreateMockAlbumRepo()+ albumRepo.SetData(model.Albums{{ID: "1"}})+ ds = &tests.MockDataStore{MockedAlbum: albumRepo}+ })++ It("returns 404 when the artwork is unavailable", func() {+ pub := &Router{ds: ds, artwork: &fakeArtwork{err: artwork.ErrUnavailable}}+ pub.handleImages(w, newImageRequest("al-1"))+ Expect(w.Code).To(Equal(http.StatusNotFound))+ })++ It("returns 404 when the artwork is not found", func() {+ pub := &Router{ds: ds, artwork: &fakeArtwork{err: model.ErrNotFound}}+ pub.handleImages(w, newImageRequest("al-1"))+ Expect(w.Code).To(Equal(http.StatusNotFound))+ })++ It("serves the image immutable when the token asserts the current hash", func() {+ const hash = "0123456789abcdef"+ img := &artwork.Image{ReadCloser: io.NopCloser(bytes.NewReader([]byte("IMG"))), Hash: hash}+ pub := &Router{ds: ds, artwork: &fakeArtwork{img: img}}+ pub.handleImages(w, newImageRequest("al-1_"+hash))+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, max-age=31536000, immutable"))+ Expect(w.Header().Get("ETag")).To(Equal(`"` + hash + `"`))+ })++})diff --git a/server/subsonic/browsing.go b/server/subsonic/browsing.goindex 59d267321..d32a5c857 100644--- a/server/subsonic/browsing.go+++ b/server/subsonic/browsing.go@@ -230,9 +230,11 @@ func (api *Router) GetAlbumInfo(r *http.Request) (*responses.Subsonic, error) {response := newResponse()response.AlbumInfo = &responses.AlbumInfo{}response.AlbumInfo.Notes = album.Description- response.AlbumInfo.SmallImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 300)- response.AlbumInfo.MediumImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 600)- response.AlbumInfo.LargeImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 1200)+ if !album.ImageAbsent {+ response.AlbumInfo.SmallImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 300)+ response.AlbumInfo.MediumImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 600)+ response.AlbumInfo.LargeImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 1200)+ }response.AlbumInfo.LastFmUrl = album.ExternalUrlresponse.AlbumInfo.MusicBrainzID = album.MbzAlbumID@@ -295,9 +297,11 @@ func (api *Router) getArtistInfo(r *http.Request) (*responses.ArtistInfoBase, *mbase := responses.ArtistInfoBase{}base.Biography = artist.Biography- base.SmallImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 300)- base.MediumImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 600)- base.LargeImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 1200)+ if !artist.ImageAbsent {+ base.SmallImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 300)+ base.MediumImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 600)+ base.LargeImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 1200)+ }base.LastFmUrl = artist.ExternalUrlbase.MusicBrainzID = artist.MbzArtistID@@ -454,7 +458,7 @@ func (api *Router) buildAlbumDirectory(ctx context.Context, album *model.Album)dir.AverageRating = album.AverageRating}dir.SongCount = int32(album.SongCount)- dir.CoverArt = album.CoverArtID().String()+ dir.CoverArt = coverArtOrEmpty(album.CoverArtID(), album.ImageAbsent)if album.Starred {dir.Starred = album.StarredAt}diff --git a/server/subsonic/browsing_test.go b/server/subsonic/browsing_test.goindex b8f510aed..d34da2f37 100644--- a/server/subsonic/browsing_test.go+++ b/server/subsonic/browsing_test.go@@ -6,6 +6,7 @@ import ("net/http/httptest""github.com/navidrome/navidrome/core/auth"+ "github.com/navidrome/navidrome/core/external""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/request""github.com/navidrome/navidrome/tests"@@ -157,4 +158,57 @@ var _ = Describe("Browsing", func() {Expect(response.Artist).ToNot(BeNil())})})++ Describe("GetAlbumInfo", func() {+ It("emits image URLs when the album artwork is unresolved", func() {+ api.provider = &fakeInfoProvider{album: &model.Album{ID: "al-1"}}+ r := httptest.NewRequest("GET", "/rest/getAlbumInfo?id=al-1", nil)+ resp, err := api.GetAlbumInfo(r)+ Expect(err).ToNot(HaveOccurred())+ Expect(resp.AlbumInfo.SmallImageUrl).ToNot(BeEmpty())+ Expect(resp.AlbumInfo.LargeImageUrl).ToNot(BeEmpty())+ })+ It("omits image URLs when the album artwork is known absent", func() {+ api.provider = &fakeInfoProvider{album: &model.Album{ID: "al-1", ItemImage: model.ItemImage{ImageAbsent: true}}}+ r := httptest.NewRequest("GET", "/rest/getAlbumInfo?id=al-1", nil)+ resp, err := api.GetAlbumInfo(r)+ Expect(err).ToNot(HaveOccurred())+ Expect(resp.AlbumInfo.SmallImageUrl).To(BeEmpty())+ Expect(resp.AlbumInfo.MediumImageUrl).To(BeEmpty())+ Expect(resp.AlbumInfo.LargeImageUrl).To(BeEmpty())+ })+ })++ Describe("GetArtistInfo", func() {+ It("emits image URLs when the artist artwork is unresolved", func() {+ api.provider = &fakeInfoProvider{artist: &model.Artist{ID: "ar-1"}}+ r := httptest.NewRequest("GET", "/rest/getArtistInfo?id=ar-1", nil)+ resp, err := api.GetArtistInfo(r)+ Expect(err).ToNot(HaveOccurred())+ Expect(resp.ArtistInfo.SmallImageUrl).ToNot(BeEmpty())+ })+ It("omits image URLs when the artist artwork is known absent", func() {+ api.provider = &fakeInfoProvider{artist: &model.Artist{ID: "ar-1", ItemImage: model.ItemImage{ImageAbsent: true}}}+ r := httptest.NewRequest("GET", "/rest/getArtistInfo?id=ar-1", nil)+ resp, err := api.GetArtistInfo(r)+ Expect(err).ToNot(HaveOccurred())+ Expect(resp.ArtistInfo.SmallImageUrl).To(BeEmpty())+ Expect(resp.ArtistInfo.MediumImageUrl).To(BeEmpty())+ Expect(resp.ArtistInfo.LargeImageUrl).To(BeEmpty())+ })+ })})++type fakeInfoProvider struct {+ external.Provider+ album *model.Album+ artist *model.Artist+}++func (f *fakeInfoProvider) UpdateAlbumInfo(context.Context, string) (*model.Album, error) {+ return f.album, nil+}++func (f *fakeInfoProvider) UpdateArtistInfo(context.Context, string, int, bool) (*model.Artist, error) {+ return f.artist, nil+}diff --git a/server/subsonic/e2e/e2e_suite_test.go b/server/subsonic/e2e/e2e_suite_test.goindex 97d7fb40a..8998731a4 100644--- a/server/subsonic/e2e/e2e_suite_test.go+++ b/server/subsonic/e2e/e2e_suite_test.go@@ -311,12 +311,12 @@ func parseJSONResponse(w *httptest.ResponseRecorder) *responses.Subsonic {// noopArtwork implements artwork.Artworktype noopArtwork struct{}-func (n noopArtwork) Get(context.Context, model.ArtworkID, int, bool) (io.ReadCloser, time.Time, error) {- return nil, time.Time{}, model.ErrNotFound+func (n noopArtwork) Get(context.Context, model.ArtworkID, int, bool) (*artwork.Image, error) {+ return nil, model.ErrNotFound}-func (n noopArtwork) GetOrPlaceholder(_ context.Context, _ string, _ int, _ bool) (io.ReadCloser, time.Time, error) {- return io.NopCloser(io.LimitReader(nil, 0)), time.Time{}, nil+func (n noopArtwork) GetOrPlaceholder(_ context.Context, _ string, _ int, _ bool) (*artwork.Image, error) {+ return &artwork.Image{ReadCloser: io.NopCloser(io.LimitReader(nil, 0))}, nil}// noopArchiver implements core.Archiver@@ -357,14 +357,6 @@ func (n noopProvider) TopSongs(context.Context, string, string, int) (model.Medireturn nil, nil}-func (n noopProvider) ArtistImage(context.Context, string) (*url.URL, error) {- return nil, model.ErrNotFound-}--func (n noopProvider) AlbumImage(context.Context, string) (*url.URL, error) {- return nil, model.ErrNotFound-}-// Compile-time interface checksvar (_ artwork.Artwork = noopArtwork{}@@ -416,8 +408,8 @@ func setupTestDB() {// Create the Subsonic Router with real DS, streamer spy, and real DeciderstreamerSpy = &harness.SpyStreamer{}decider := stream.NewTranscodeDecider(ds, harness.NoopFFmpeg{})- s := scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())+ s := scanner.New(ctx, ds, events.NoopBroker(),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())router = subsonic.New(ds,noopArtwork{},@@ -427,7 +419,7 @@ func setupTestDB() {noopProvider{},s,events.NoopBroker(),- playlists.NewPlaylists(ds, core.NewImageUploadService()),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)),scrobbler.NewPlayTracker(ds, events.NoopBroker(), nil),core.NewShare(ds),playback.PlaybackServer(nil),diff --git a/server/subsonic/e2e/subsonic_artwork_test.go b/server/subsonic/e2e/subsonic_artwork_test.gonew file mode 100644index 000000000..619619810--- /dev/null+++ b/server/subsonic/e2e/subsonic_artwork_test.go@@ -0,0 +1,328 @@+package e2e++import (+ "context"+ "errors"+ "io"+ "net/http"+ "net/http/httptest"+ "os"+ "path/filepath"+ "time"++ "github.com/Masterminds/squirrel"+ _ "github.com/navidrome/navidrome/adapters/gotaglib" // registers the "taglib" local-storage extractor+ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/conf/configtest"+ "github.com/navidrome/navidrome/consts"+ "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/core/artwork"+ "github.com/navidrome/navidrome/core/auth"+ "github.com/navidrome/navidrome/core/lyrics"+ "github.com/navidrome/navidrome/core/metrics"+ "github.com/navidrome/navidrome/core/playback"+ "github.com/navidrome/navidrome/core/playlists"+ "github.com/navidrome/navidrome/core/scrobbler"+ _ "github.com/navidrome/navidrome/core/storage/local" // registers the "file" storage scheme+ "github.com/navidrome/navidrome/core/stream"+ "github.com/navidrome/navidrome/db"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/model/request"+ "github.com/navidrome/navidrome/persistence"+ "github.com/navidrome/navidrome/resources"+ "github.com/navidrome/navidrome/scanner"+ "github.com/navidrome/navidrome/server/events"+ "github.com/navidrome/navidrome/server/public"+ "github.com/navidrome/navidrome/server/subsonic"+ "github.com/navidrome/navidrome/tests"+ "github.com/navidrome/navidrome/tests/harness"+ "github.com/navidrome/navidrome/utils/cache"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+ "go.senan.xyz/taglib"+)++// The serving path streams folder-backed originals via os.Open, which a fake FS cannot back, so+// this suite scans a small REAL on-disk library and drives the real worker and artwork.Artwork.+var _ = Describe("Artwork Serving", Ordered, func() {+ var (+ artRouter *subsonic.Router+ pubRouter *public.Router+ artSvc artwork.Artwork+ worker *artwork.Worker+ artfulID string+ artlessID string+ artfulHash string+ placeholder []byte+ )++ albumCoverInList := func(albumID string) string {+ GinkgoHelper()+ resp := doReq("getAlbumList2", "type", "alphabeticalByName", "size", "500")+ Expect(resp.AlbumList2).ToNot(BeNil())+ for _, al := range resp.AlbumList2.Album {+ if al.Id == albumID {+ return al.CoverArt+ }+ }+ Fail("album " + albumID + " not found in getAlbumList2")+ return ""+ }++ getCover := func(params ...string) *httptest.ResponseRecorder {+ GinkgoHelper()+ w := httptest.NewRecorder()+ r := buildReq(adminUser, "getCoverArt", params...)+ artRouter.ServeHTTP(w, r)+ return w+ }++ BeforeAll(func() {+ DeferCleanup(configtest.SetupConfig())+ DeferCleanup(func() { Eventually(scanner.IsScanning).Should(BeFalse()) })+ ctx = request.WithUser(GinkgoT().Context(), adminUser)++ musicDir := GinkgoT().TempDir()+ writeArtworkTrack(musicDir, "Artful Artist", "Artful Album", "01 - Come Together", true)+ writeArtworkTrack(musicDir, "Artless Artist", "Artless Album", "01 - Lonely", false)++ conf.Server.MusicFolder = musicDir+ conf.Server.DevExternalScanner = false+ conf.Server.DevEnableMediaFileProbe = false+ conf.Server.CoverArtPriority = "cover.jpg"+ conf.Server.ArtistArtPriority = "artist.png" // offline: artists resolve absent, out of scope here+ conf.Server.EnableMediaFileCoverArt = false+ conf.Server.DevArtworkWorkerConcurrency = 1+ conf.Server.CacheFolder = conf.NewDir(GinkgoT().TempDir())+ conf.Server.EnableSharing = true+ conf.Server.DevArtworkMaxRequests = 100+ conf.Server.DevArtworkThrottleBacklogLimit = 100+ conf.Server.DevArtworkThrottleBacklogTimeout = time.Minute++ goldenDB.Restore()+ ds = &tests.MockDataStore{RealDS: persistence.New(db.Db())}+ auth.Init(ds)++ // Re-scanning already-populated data deadlocks the parallel album-refresh phase at the+ // harness's MaxOpenConns=1, so wipe the golden content and import this library fresh.+ wipeScannedContent()+ artLib := model.Library{Name: "Artwork Library", Path: musicDir}+ Expect(ds.Library(ctx).Put(&artLib)).To(Succeed())+ Expect(ds.User(ctx).SetUserLibraries(adminUser.ID, []int{artLib.ID})).To(Succeed())++ s := scanner.New(ctx, ds, events.NoopBroker(),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())+ _, err := s.ScanAll(ctx, true)+ Expect(err).ToNot(HaveOccurred())++ // Focus the worker on the entities under test.+ _, err = db.Db().Exec("DELETE FROM artwork_queue")+ Expect(err).ToNot(HaveOccurred())++ artfulID = albumIDByName("Artful Album")+ artlessID = albumIDByName("Artless Album")++ ph, err := resources.FS().Open(consts.PlaceholderAlbumArt)+ Expect(err).ToNot(HaveOccurred())+ placeholder, err = io.ReadAll(ph)+ Expect(err).ToNot(HaveOccurred())+ _ = ph.Close()++ store := artwork.NewImageStore(GinkgoT().TempDir())+ imgCache := newDummyImageCache(ctx)+ ffm := harness.NoopFFmpeg{}+ artSvc = artwork.NewArtwork(ds, imgCache, store, ffm)+ worker = artwork.NewWorker(ds, store, agents.GetAgents(ds, nil), ffm, events.NoopBroker(), imgCache)++ artRouter = buildArtworkRouter(artSvc)+ router = artRouter // so the shared doReq/doRawReq helpers hit the artwork-wired router+ pubRouter = public.New(ds, artSvc, streamerSpy, core.NewShare(ds), noopArchiver{})+ })++ It("emits a bare optimistic coverArt id before the queue is drained", func() {+ Expect(albumCoverInList(artfulID)).To(Equal("al-" + artfulID))+ Expect(albumCoverInList(artlessID)).To(Equal("al-" + artlessID))+ })++ It("drains the queue: folder art is acquired, the artless album settles absent", func() {+ // Enqueues the way the serving paths do, so the drain is driven by a plain queue row.+ for _, id := range []string{artfulID, artlessID} {+ Expect(ds.ArtworkQueue(ctx).EnqueuePreservingBackoff(model.ArtworkQueueItem{+ ItemKind: model.KindAlbumArtwork.Prefix(), ItemID: id,+ ImageType: model.ImageTypePrimary, Priority: model.ArtworkPriorityBump,+ })).To(Succeed())+ }+ runWorkerUntil(ctx, worker, func() bool {+ found, err := ds.Artwork(ctx).GetItemArtwork(model.KindAlbumArtwork, artfulID, model.ImageTypePrimary)+ if err != nil || found.Hash == "" {+ return false+ }+ absent, err := ds.Artwork(ctx).GetItemArtwork(model.KindAlbumArtwork, artlessID, model.ImageTypePrimary)+ return err == nil && absent.Hash == ""+ })+ ia, err := ds.Artwork(ctx).GetItemArtwork(model.KindAlbumArtwork, artfulID, model.ImageTypePrimary)+ Expect(err).ToNot(HaveOccurred())+ Expect(ia.Source).To(Equal("folder"))+ artfulHash = ia.Hash+ Expect(artfulHash).ToNot(BeEmpty())+ })++ It("promotes the list id to the hash suffix and omits the absent album's coverArt", func() {+ Expect(albumCoverInList(artfulID)).To(Equal("al-" + artfulID + "_" + artfulHash))+ Expect(albumCoverInList(artlessID)).To(BeEmpty())+ })++ It("serves the found album's bytes with revalidation headers for a bare id", func() {+ w := getCover("id", "al-"+artfulID)+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(w.Body.Bytes()).To(Equal(readArtworkFixture("cover.jpg")))+ Expect(w.Header().Get("ETag")).To(Equal(`"` + artfulHash + `"`))+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, no-cache"))+ })++ It("serves the found album immutably when the exact hash is requested", func() {+ w := getCover("id", "al-"+artfulID+"_"+artfulHash)+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(w.Body.Bytes()).To(Equal(readArtworkFixture("cover.jpg")))+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, max-age=31536000, immutable"))+ })++ It("returns 304 with an empty body when the client already holds the hash", func() {+ w := httptest.NewRecorder()+ r := buildReq(adminUser, "getCoverArt", "id", "al-"+artfulID)+ r.Header.Set("If-None-Match", `"`+artfulHash+`"`)+ artRouter.ServeHTTP(w, r)+ Expect(w.Code).To(Equal(http.StatusNotModified))+ Expect(w.Body.Bytes()).To(BeEmpty())+ })++ It("serves the placeholder with no-store for an absent album", func() {+ w := getCover("id", "al-"+artlessID)+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(w.Body.Bytes()).To(Equal(placeholder))+ Expect(w.Header().Get("Cache-Control")).To(Equal("no-store"))+ })++ // Only adminUser was granted this library, so regularUser must get the placeholder even+ // though the artwork state and bytes are perfectly servable by id.+ It("serves the placeholder for an album in a library the caller cannot see", func() {+ w := httptest.NewRecorder()+ artRouter.ServeHTTP(w, buildReq(regularUser, "getCoverArt", "id", "al-"+artfulID))++ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(w.Body.Bytes()).To(Equal(placeholder), "must not leak the real cover")+ Expect(w.Header().Get("Cache-Control")).To(Equal("no-store"))++ Expect(getCover("id", "al-"+artfulID).Body.Bytes()).ToNot(Equal(placeholder))+ })++ // An id naming no entity is a different answer from an album with no art: no placeholder.+ It("answers error 70 for an id that matches no entity", func() {+ w := getCover("id", "al-nosuchalbum")+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(w.Body.String()).To(ContainSubstring(`"code":70`))+ Expect(w.Body.Bytes()).ToNot(Equal(placeholder))+ })++ It("serves /share/img immutably for a JWT whose payload carries the hash", func() {+ token, err := auth.CreateExpiringPublicToken(time.Now().Add(time.Hour),+ auth.Claims{ID: "al-" + artfulID + "_" + artfulHash})+ Expect(err).ToNot(HaveOccurred())++ w := httptest.NewRecorder()+ pubRouter.ServeHTTP(w, httptest.NewRequest("GET", "/img/"+token, nil))+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(w.Body.Bytes()).To(Equal(readArtworkFixture("cover.jpg")))+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, max-age=31536000, immutable"))+ })++ It("returns 404 from /share/img for an absent entity", func() {+ token, err := auth.CreateExpiringPublicToken(time.Now().Add(time.Hour),+ auth.Claims{ID: "al-" + artlessID})+ Expect(err).ToNot(HaveOccurred())++ w := httptest.NewRecorder()+ pubRouter.ServeHTTP(w, httptest.NewRequest("GET", "/img/"+token, nil))+ Expect(w.Code).To(Equal(http.StatusNotFound))+ })+})++// buildArtworkRouter mirrors setupTestDB's Subsonic wiring but with the real artwork.Artwork.+func buildArtworkRouter(art artwork.Artwork) *subsonic.Router {+ decider := stream.NewTranscodeDecider(ds, harness.NoopFFmpeg{})+ s := scanner.New(ctx, ds, events.NoopBroker(),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())+ return subsonic.New(+ ds, art, streamerSpy, noopArchiver{}, core.NewPlayers(ds), noopProvider{}, s,+ events.NoopBroker(), playlists.NewPlaylists(ds, artwork.NewUploader(ds)),+ scrobbler.NewPlayTracker(ds, events.NoopBroker(), nil), core.NewShare(ds),+ playback.PlaybackServer(nil), metrics.NewNoopInstance(), lyrics.NewLyrics(ds, nil), decider, nil,+ )+}++// wipeScannedContent clears all scanned content so the next scan is a clean import. FKs are+// disabled for the bulk delete, mirroring harness.Restore.+func wipeScannedContent() {+ GinkgoHelper()+ _, err := db.Db().Exec("PRAGMA foreign_keys = OFF")+ Expect(err).ToNot(HaveOccurred())+ for _, t := range []string{"media_file", "album", "artist", "folder", "item_artwork", "artwork_queue", "artwork", "library"} {+ _, err = db.Db().Exec(`DELETE FROM "` + t + `"`)+ Expect(err).ToNot(HaveOccurred(), "wiping %s", t)+ }+ _, err = db.Db().Exec("PRAGMA foreign_keys = ON")+ Expect(err).ToNot(HaveOccurred())+}++func albumIDByName(name string) string {+ GinkgoHelper()+ albums, err := ds.Album(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"album.name": name}})+ Expect(err).ToNot(HaveOccurred())+ Expect(albums).To(HaveLen(1), "expected exactly one album named %q", name)+ return albums[0].ID+}++// Distinct ALBUM/ALBUMARTIST tags keep the generated albums from merging into one.+func writeArtworkTrack(root, artist, album, title string, withCover bool) {+ GinkgoHelper()+ dir := filepath.Join(root, artist, album)+ Expect(os.MkdirAll(dir, 0o755)).To(Succeed())+ mp3 := filepath.Join(dir, title+".mp3")+ Expect(os.WriteFile(mp3, readArtworkFixture("test.mp3"), 0o600)).To(Succeed())+ Expect(taglib.WriteTags(mp3, map[string][]string{+ "ALBUM": {album}, "ALBUMARTIST": {artist}, "ARTIST": {artist}, "TITLE": {title},+ }, taglib.Clear)).To(Succeed())+ if withCover {+ Expect(os.WriteFile(filepath.Join(dir, "cover.jpg"), readArtworkFixture("cover.jpg"), 0o600)).To(Succeed())+ }+}++func readArtworkFixture(name string) []byte {+ GinkgoHelper()+ data, err := os.ReadFile(filepath.Join("tests", "fixtures", "artist", "an-album", name))+ Expect(err).ToNot(HaveOccurred())+ return data+}++// size=0 requests stream originals and never invoke the reader, so this resize cache only has+// to satisfy the constructor.+func newDummyImageCache(ctx context.Context) cache.FileCache {+ GinkgoHelper()+ c := cache.NewFileCache("SubsonicArtworkE2E", "100MB", "images", 0,+ func(context.Context, cache.Item) (io.Reader, error) {+ return nil, errors.New("resize not exercised in subsonic artwork e2e")+ })+ Eventually(func() bool { return c.Available(ctx) }).Should(BeTrue())+ return c+}++func runWorkerUntil(ctx context.Context, worker *artwork.Worker, until func() bool) {+ GinkgoHelper()+ runCtx, cancel := context.WithCancel(ctx)+ done := make(chan error, 1)+ go func() { done <- worker.Run(runCtx) }()+ Eventually(until, 10*time.Second, 20*time.Millisecond).Should(BeTrue())+ cancel()+ Eventually(done, 2*time.Second).Should(Receive(BeNil()))+}diff --git a/server/subsonic/e2e/subsonic_multilibrary_test.go b/server/subsonic/e2e/subsonic_multilibrary_test.goindex e652cf492..98f87ca17 100644--- a/server/subsonic/e2e/subsonic_multilibrary_test.go+++ b/server/subsonic/e2e/subsonic_multilibrary_test.go@@ -6,7 +6,6 @@ import ("github.com/Masterminds/squirrel""github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/core""github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/metrics""github.com/navidrome/navidrome/core/playlists"@@ -53,8 +52,8 @@ var _ = Describe("Multi-Library Support", Ordered, func() {adminWithLibs = *loadedAdmin// Run incremental scan to import lib2 content (lib1 files unchanged → skipped)- s := scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())+ s := scanner.New(ctx, ds, events.NoopBroker(),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())_, err = s.ScanAll(ctx, false)Expect(err).ToNot(HaveOccurred())diff --git a/server/subsonic/e2e/subsonic_sonic_similarity_test.go b/server/subsonic/e2e/subsonic_sonic_similarity_test.goindex 775fefe89..c0cb1d359 100644--- a/server/subsonic/e2e/subsonic_sonic_similarity_test.go+++ b/server/subsonic/e2e/subsonic_sonic_similarity_test.go@@ -9,6 +9,7 @@ import ("github.com/Masterminds/squirrel""github.com/navidrome/navidrome/core""github.com/navidrome/navidrome/core/agents"+ "github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/lyrics""github.com/navidrome/navidrome/core/matcher""github.com/navidrome/navidrome/core/metrics"@@ -43,7 +44,7 @@ func buildSonicRouter(provider sonic.Provider) *subsonic.Router {noopProvider{},nil, // scannerevents.NoopBroker(),- playlists.NewPlaylists(ds, core.NewImageUploadService()),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)),scrobbler.NewPlayTracker(ds, events.NoopBroker(), nil),core.NewShare(ds),playback.PlaybackServer(nil),diff --git a/server/subsonic/helpers.go b/server/subsonic/helpers.goindex b986200ae..e367cdee5 100644--- a/server/subsonic/helpers.go+++ b/server/subsonic/helpers.go@@ -95,13 +95,24 @@ func getArtistAlbumCount(a *model.Artist) int32 {}}+// coverArtOrEmpty stamps the (hash-suffixed) coverArt id, or omits it (empty+// string + the field's omitempty tag) when artwork is known absent.+func coverArtOrEmpty(id model.ArtworkID, absent bool) string {+ if absent {+ return ""+ }+ return id.String()+}+func toArtist(r *http.Request, a model.Artist) responses.Artist {artist := responses.Artist{- Id: a.ID,- Name: a.Name,- UserRating: int32(a.Rating),- CoverArt: a.CoverArtID().String(),- ArtistImageUrl: publicurl.ImageURL(r, a.CoverArtID(), 600),+ Id: a.ID,+ Name: a.Name,+ UserRating: int32(a.Rating),+ CoverArt: coverArtOrEmpty(a.CoverArtID(), a.ImageAbsent),+ }+ if !a.ImageAbsent {+ artist.ArtistImageUrl = publicurl.ImageURL(r, a.CoverArtID(), 600)}if conf.Server.Subsonic.EnableAverageRating {artist.AverageRating = a.AverageRating@@ -114,12 +125,14 @@ func toArtist(r *http.Request, a model.Artist) responses.Artist {func toArtistID3(r *http.Request, a model.Artist) responses.ArtistID3 {artist := responses.ArtistID3{- Id: a.ID,- Name: a.Name,- AlbumCount: getArtistAlbumCount(&a),- CoverArt: a.CoverArtID().String(),- ArtistImageUrl: publicurl.ImageURL(r, a.CoverArtID(), 600),- UserRating: int32(a.Rating),+ Id: a.ID,+ Name: a.Name,+ AlbumCount: getArtistAlbumCount(&a),+ CoverArt: coverArtOrEmpty(a.CoverArtID(), a.ImageAbsent),+ UserRating: int32(a.Rating),+ }+ if !a.ImageAbsent {+ artist.ArtistImageUrl = publicurl.ImageURL(r, a.CoverArtID(), 600)}if conf.Server.Subsonic.EnableAverageRating {artist.AverageRating = a.AverageRating@@ -208,7 +221,7 @@ func childFromMediaFile(ctx context.Context, mf model.MediaFile) responses.Childchild.Size = mf.Sizechild.Suffix = mf.Suffixchild.BitRate = int32(mf.BitRate)- child.CoverArt = mf.CoverArtID().String()+ child.CoverArt = coverArtOrEmpty(mf.CoverArtID(), mf.ImageAbsent)child.ContentType = mf.ContentType()if ok && player.ReportRealPath {@@ -369,7 +382,7 @@ func childFromAlbum(ctx context.Context, al model.Album) responses.Child {child.Artist = al.AlbumArtistchild.Year = int32(cmp.Or(al.MaxOriginalYear, al.MaxYear))child.Genre = al.Genre- child.CoverArt = al.CoverArtID().String()+ child.CoverArt = coverArtOrEmpty(al.CoverArtID(), al.ImageAbsent)child.Created = new(albumCreatedAt(al))child.Parent = al.AlbumArtistIDchild.ArtistId = al.AlbumArtistID@@ -460,7 +473,7 @@ func buildAlbumID3(ctx context.Context, album model.Album) responses.AlbumID3 {dir.Name = album.FullName()dir.Artist = album.AlbumArtistdir.ArtistId = album.AlbumArtistID- dir.CoverArt = album.CoverArtID().String()+ dir.CoverArt = coverArtOrEmpty(album.CoverArtID(), album.ImageAbsent)dir.SongCount = int32(album.SongCount)dir.Duration = int32(album.Duration)dir.PlayCount = album.PlayCountdiff --git a/server/subsonic/helpers_test.go b/server/subsonic/helpers_test.goindex 8db624649..69fda4681 100644--- a/server/subsonic/helpers_test.go+++ b/server/subsonic/helpers_test.go@@ -321,6 +321,82 @@ var _ = Describe("helpers", func() {})})+ Describe("artwork coverArt emission", func() {+ const hash = "0123456789abcdef"+ ctx := context.Background()++ DescribeTable("coverArtOrEmpty",+ func(id model.ArtworkID, absent bool, expected string) {+ Expect(coverArtOrEmpty(id, absent)).To(Equal(expected))+ },+ Entry("emits the bare id when unresolved", model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1"}, false, "al-1"),+ Entry("emits the hash-suffixed id when resolved", model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1", Hash: hash}, false, "al-1_"+hash),+ Entry("omits (empty) when known absent", model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1", Hash: hash}, true, ""),+ )++ Describe("childFromAlbum", func() {+ It("suffixes coverArt with the content hash when resolved", func() {+ al := model.Album{ID: "al-1", ItemImage: model.ItemImage{ImageHash: hash}}+ Expect(childFromAlbum(ctx, al).CoverArt).To(Equal("al-al-1_" + hash))+ })+ It("omits coverArt when known absent", func() {+ al := model.Album{ID: "al-1", ItemImage: model.ItemImage{ImageAbsent: true}}+ Expect(childFromAlbum(ctx, al).CoverArt).To(BeEmpty())+ })+ It("emits the bare id when unresolved", func() {+ al := model.Album{ID: "al-1"}+ Expect(childFromAlbum(ctx, al).CoverArt).To(Equal("al-al-1"))+ })+ })++ Describe("childFromMediaFile", func() {+ // An al- id must carry the album's hash (AlbumImage), never the track's own.+ It("suffixes coverArt with the album's content hash when resolved", func() {+ mf := model.MediaFile{ID: "mf-1", AlbumID: "al-1", AlbumImage: model.ItemImage{ImageHash: hash}}+ Expect(childFromMediaFile(ctx, mf).CoverArt).To(Equal("al-al-1_" + hash))+ })++ It("does not stamp a track's own art hash onto the album id", func() {+ mf := model.MediaFile{ID: "mf-1", AlbumID: "al-1",+ ItemImage: model.ItemImage{ImageHash: "0000ownarthash00"},+ AlbumImage: model.ItemImage{ImageHash: hash}}+ Expect(childFromMediaFile(ctx, mf).CoverArt).To(Equal("al-al-1_" + hash))+ })+ It("omits coverArt when known absent", func() {+ mf := model.MediaFile{ID: "mf-1", AlbumID: "al-1", ItemImage: model.ItemImage{ImageAbsent: true}}+ Expect(childFromMediaFile(ctx, mf).CoverArt).To(BeEmpty())+ })+ It("emits the bare id when unresolved", func() {+ mf := model.MediaFile{ID: "mf-1", AlbumID: "al-1"}+ Expect(childFromMediaFile(ctx, mf).CoverArt).To(Equal("al-al-1"))+ })+ })++ Describe("toArtist / toArtistID3", func() {+ r := httptest.NewRequest("GET", "/test", nil)+ It("emits both coverArt and imageUrl when resolved", func() {+ a := model.Artist{ID: "ar-1", ItemImage: model.ItemImage{ImageHash: hash}}+ artist := toArtist(r, a)+ Expect(artist.CoverArt).To(Equal("ar-ar-1_" + hash))+ Expect(artist.ArtistImageUrl).ToNot(BeEmpty())+ })+ It("omits coverArt and imageUrl when known absent", func() {+ a := model.Artist{ID: "ar-1", ItemImage: model.ItemImage{ImageAbsent: true}}+ artist := toArtist(r, a)+ Expect(artist.CoverArt).To(BeEmpty())+ Expect(artist.ArtistImageUrl).To(BeEmpty())++ id3 := toArtistID3(r, a)+ Expect(id3.CoverArt).To(BeEmpty())+ Expect(id3.ArtistImageUrl).To(BeEmpty())+ })+ It("emits an imageUrl when unresolved", func() {+ a := model.Artist{ID: "ar-1"}+ Expect(toArtist(r, a).ArtistImageUrl).ToNot(BeEmpty())+ })+ })+ })+Describe("osChildFromMediaFile", func() {var mf model.MediaFilevar ctx context.Contextdiff --git a/server/subsonic/media_retrieval.go b/server/subsonic/media_retrieval.goindex 089a1fdda..8a5152a9d 100644--- a/server/subsonic/media_retrieval.go+++ b/server/subsonic/media_retrieval.go@@ -13,6 +13,7 @@ import ("github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/resources"+ "github.com/navidrome/navidrome/server/imghttp""github.com/navidrome/navidrome/server/subsonic/responses""github.com/navidrome/navidrome/utils/gravatar""github.com/navidrome/navidrome/utils/req"@@ -66,7 +67,7 @@ func (api *Router) GetCoverArt(w http.ResponseWriter, r *http.Request) (*responssize := p.IntOr("size", 0)square := p.BoolOr("square", false)- imgReader, lastUpdate, err := api.artwork.GetOrPlaceholder(ctx, id, size, square)+ img, err := api.artwork.GetOrPlaceholder(ctx, id, size, square)switch {case errors.Is(err, context.Canceled):return nil, nil@@ -78,11 +79,13 @@ func (api *Router) GetCoverArt(w http.ResponseWriter, r *http.Request) (*responsreturn nil, err}- defer imgReader.Close()- w.Header().Set("cache-control", "public, max-age=315360000")- w.Header().Set("last-modified", lastUpdate.Format(http.TimeFormat))+ defer img.Close()- cnt, err := io.Copy(w, imgReader)+ artID, _ := model.ParseArtworkID(id)+ if imghttp.WriteImageHeaders(w, r, img, artID.Hash) {+ return nil, nil+ }+ cnt, err := io.Copy(w, img)if err != nil {log.Warn(ctx, "Error sending image", "count", cnt, err)}diff --git a/server/subsonic/media_retrieval_test.go b/server/subsonic/media_retrieval_test.goindex 9331dfbe4..7610c866a 100644--- a/server/subsonic/media_retrieval_test.go+++ b/server/subsonic/media_retrieval_test.go@@ -17,6 +17,7 @@ import ("github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/lyrics""github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/model/request""github.com/navidrome/navidrome/tests". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega"@@ -30,8 +31,14 @@ var _ = Describe("MediaRetrievalController", func() {var w *httptest.ResponseRecorderBeforeEach(func() {+ albumRepo := &tests.MockAlbumRepo{}+ albumRepo.SetData(model.Albums{{ID: "34"}}) // the id the specs request, made accessible+ radioRepo := tests.CreateMockedRadioRepo()+ Expect(radioRepo.Put(&model.Radio{ID: "rd1", Name: "Radio"})).To(Succeed())ds = &tests.MockDataStore{MockedMediaFile: mockRepo,+ MockedAlbum: albumRepo,+ MockedRadio: radioRepo,}artwork = &fakeArtwork{data: "image data"}router = New(ds, artwork, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, lyrics.NewLyrics(ds, nil), nil, nil)@@ -60,6 +67,22 @@ var _ = Describe("MediaRetrievalController", func() {Expect(w.Body.String()).To(Equal(artwork.data))})+ // The service applies the library filter from the caller's context, so elevating here+ // would bypass it.+ It("passes the caller's context to the service rather than elevating", func() {+ r := newGetRequest("id=al-34")+ usr := model.User{ID: "u1", UserName: "u1"}+ r = r.WithContext(request.WithUser(r.Context(), usr))++ _, err := router.GetCoverArt(w, r)++ Expect(err).ToNot(HaveOccurred())+ got, ok := request.UserFrom(artwork.recvCtx)+ Expect(ok).To(BeTrue(), "the service must see who is asking")+ Expect(got.ID).To(Equal("u1"))+ Expect(got.IsAdmin).To(BeFalse(), "the handler must not elevate")+ })+It("should fail when the file is not found", func() {artwork.err = model.ErrNotFoundr := newGetRequest("id=34", "size=128", "square=true")@@ -108,6 +131,53 @@ var _ = Describe("MediaRetrievalController", func() {Expect(w.Body.String()).To(BeEmpty())})})++ Describe("caching headers", func() {+ const hash = "0123456789abcdef"++ It("sets an ETag and no-cache for a bare id", func() {+ artwork.hash = hash+ r := newGetRequest("id=al-34")+ _, err := router.GetCoverArt(w, r)++ Expect(err).ToNot(HaveOccurred())+ Expect(w.Header().Get("ETag")).To(Equal(`"` + hash + `"`))+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, no-cache"))+ Expect(w.Body.String()).To(Equal(artwork.data))+ })++ It("marks the response immutable when the id asserts the current hash", func() {+ artwork.hash = hash+ r := newGetRequest("id=al-34_" + hash)+ _, err := router.GetCoverArt(w, r)++ Expect(err).ToNot(HaveOccurred())+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, max-age=31536000, immutable"))+ })++ It("returns 304 with no body when If-None-Match matches", func() {+ artwork.hash = hash+ r := newGetRequest("id=al-34")+ r.Header.Set("If-None-Match", `"`+hash+`"`)+ _, err := router.GetCoverArt(w, r)++ Expect(err).ToNot(HaveOccurred())+ Expect(w.Code).To(Equal(304))+ Expect(w.Body.Len()).To(BeZero())+ })++ It("never caches a placeholder", func() {+ artwork.placeholder = true+ r := newGetRequest("id=al-missing")+ _, err := router.GetCoverArt(w, r)++ Expect(err).ToNot(HaveOccurred())+ Expect(w.Code).To(Equal(200))+ Expect(w.Header().Get("Cache-Control")).To(Equal("no-store"))+ Expect(w.Header().Get("ETag")).To(BeEmpty())+ Expect(w.Body.String()).To(Equal(artwork.data))+ })+ })})Describe("GetLyrics", func() {@@ -188,25 +258,35 @@ var _ = Describe("MediaRetrievalController", func() {type fakeArtwork struct {artwork.Artworkdata string+ hash string+ lastUpdated time.Time+ placeholder boolerr errorctxCancelFunc func()recvId stringrecvSize intrecvSquare bool+ recvCtx context.Context}-func (c *fakeArtwork) GetOrPlaceholder(_ context.Context, id string, size int, square bool) (io.ReadCloser, time.Time, error) {+func (c *fakeArtwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (*artwork.Image, error) {+ c.recvCtx = ctxif c.err != nil {- return nil, time.Time{}, c.err+ return nil, c.err}c.recvId = idc.recvSize = sizec.recvSquare = squareif c.ctxCancelFunc != nil {c.ctxCancelFunc()- return nil, time.Time{}, context.Canceled+ return nil, context.Canceled}- return io.NopCloser(bytes.NewReader([]byte(c.data))), time.Time{}, nil+ return &artwork.Image{+ ReadCloser: io.NopCloser(bytes.NewReader([]byte(c.data))),+ Hash: c.hash,+ LastUpdated: c.lastUpdated,+ Placeholder: c.placeholder,+ }, nil}type mockedMediaFile struct {diff --git a/server/subsonic/playlists.go b/server/subsonic/playlists.goindex 17ba1b2c9..bd53528d9 100644--- a/server/subsonic/playlists.go+++ b/server/subsonic/playlists.go@@ -151,7 +151,7 @@ func (api *Router) buildPlaylist(ctx context.Context, p model.Playlist) responsepls.Comment = p.Commentpls.Owner = p.OwnerNamepls.Public = p.Public- pls.CoverArt = p.CoverArtID().String()+ pls.CoverArt = coverArtOrEmpty(p.CoverArtID(), p.ImageAbsent)pls.OpenSubsonicPlaylist = buildOSPlaylist(ctx, p)return plsdiff --git a/server/subsonic/playlists_test.go b/server/subsonic/playlists_test.goindex f0a2f8ac5..a7c9e2ec7 100644--- a/server/subsonic/playlists_test.go+++ b/server/subsonic/playlists_test.go@@ -129,6 +129,19 @@ var _ = Describe("buildPlaylist", func() {})})+ Context("artwork emission", func() {+ It("suffixes coverArt with the content hash when resolved", func() {+ playlist.ImageHash = "0123456789abcdef"+ result := router.buildPlaylist(ctx, playlist)+ Expect(result.CoverArt).To(Equal("pl-pls-1_0123456789abcdef"))+ })+ It("omits coverArt when known absent", func() {+ playlist.ImageAbsent = true+ result := router.buildPlaylist(ctx, playlist)+ Expect(result.CoverArt).To(BeEmpty())+ })+ })+Context("with legacy client", func() {BeforeEach(func() {conf.Server.Subsonic.LegacyClients = "legacy-client"diff --git a/server/subsonic/radio.go b/server/subsonic/radio.goindex 4fbd6a53d..1fb266f1d 100644--- a/server/subsonic/radio.go+++ b/server/subsonic/radio.go@@ -74,10 +74,10 @@ func (api *Router) GetInternetRadios(r *http.Request) (*responses.Subsonic, erroif strings.Contains(conf.Server.Subsonic.LegacyClients, player.Client) {continue}- // Add coverArt if not legacy client+ // Add coverArt if not legacy client; only radios have an uploaded image as their sole art sourcevar coverArt stringif g.UploadedImage != "" {- coverArt = g.CoverArtID().String()+ coverArt = coverArtOrEmpty(g.CoverArtID(), g.ImageAbsent)}res[i].OpenSubsonicRadio = &responses.OpenSubsonicRadio{CoverArt: coverArt,diff --git a/server/subsonic/radio_test.go b/server/subsonic/radio_test.goindex e959ebe29..aa805abbf 100644--- a/server/subsonic/radio_test.go+++ b/server/subsonic/radio_test.go@@ -71,10 +71,25 @@ var _ = Describe("Radio", func() {Expect(err).ToNot(HaveOccurred())Expect(response.InternetRadioStations.Radios).To(HaveLen(2))Expect(response.InternetRadioStations.Radios[0].OpenSubsonicRadio).ToNot(BeNil())- Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1_0"))+ Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1"))Expect(response.InternetRadioStations.Radios[1].OpenSubsonicRadio).ToNot(BeNil())Expect(response.InternetRadioStations.Radios[1].CoverArt).To(BeEmpty())})++ It("suffixes coverArt with the content hash when resolved and omits it when known absent", func() {+ radioRepo.All = model.Radios{+ {ID: "rd-1", Name: "Radio 1", UploadedImage: "rd-1_cover.jpg", ItemImage: model.ItemImage{ImageHash: "0123456789abcdef"}},+ {ID: "rd-2", Name: "Radio 2", UploadedImage: "rd-2_cover.jpg", ItemImage: model.ItemImage{ImageAbsent: true}},+ }+ r := httptest.NewRequest("GET", "/rest/getInternetRadios", nil)+ r = r.WithContext(ctx)++ response, err := api.GetInternetRadios(r)++ Expect(err).ToNot(HaveOccurred())+ Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1_0123456789abcdef"))+ Expect(response.InternetRadioStations.Radios[1].CoverArt).To(BeEmpty())+ })})Context("with a legacy client", func() {@@ -129,7 +144,7 @@ var _ = Describe("Radio", func() {Expect(err).ToNot(HaveOccurred())Expect(response.InternetRadioStations.Radios[0].OpenSubsonicRadio).ToNot(BeNil())- Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1_0"))+ Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1"))})})diff --git a/server/subsonic/searching.go b/server/subsonic/searching.goindex 5d4989ae5..cc787f041 100644--- a/server/subsonic/searching.go+++ b/server/subsonic/searching.go@@ -110,11 +110,13 @@ func (api *Router) Search2(r *http.Request) (*responses.Subsonic, error) {searchResult2 := &responses.SearchResult2{}searchResult2.Artist = slice.Map(as, func(artist model.Artist) responses.Artist {a := responses.Artist{- Id: artist.ID,- Name: artist.Name,- UserRating: int32(artist.Rating),- CoverArt: artist.CoverArtID().String(),- ArtistImageUrl: publicurl.ImageURL(r, artist.CoverArtID(), 600),+ Id: artist.ID,+ Name: artist.Name,+ UserRating: int32(artist.Rating),+ CoverArt: coverArtOrEmpty(artist.CoverArtID(), artist.ImageAbsent),+ }+ if !artist.ImageAbsent {+ a.ArtistImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 600)}if artist.Starred {a.Starred = artist.StarredAtdiff --git a/server/subsonic/searching_test.go b/server/subsonic/searching_test.goindex 4e72bd2e6..d31a50cfa 100644--- a/server/subsonic/searching_test.go+++ b/server/subsonic/searching_test.go@@ -1,6 +1,8 @@package subsonicimport (+ "net/http"+"github.com/Masterminds/squirrel""github.com/navidrome/navidrome/core/auth""github.com/navidrome/navidrome/model"@@ -209,4 +211,32 @@ var _ = Describe("Search", func() {})})})++ Describe("artwork emission", func() {+ newSearchRequest := func() *http.Request {+ r := newGetRequest("query=test")+ ctx := request.WithUser(r.Context(), model.User{ID: "user1", Libraries: []model.Library{{ID: 1}}})+ return r.WithContext(ctx)+ }++ It("omits coverArt and imageUrl for a known-absent artist", func() {+ mockArtistRepo.SetData(model.Artists{+ {ID: "ar-1", Name: "Absent Artist", ItemImage: model.ItemImage{ImageAbsent: true}},+ })+ resp, err := router.Search2(newSearchRequest())+ Expect(err).ToNot(HaveOccurred())+ Expect(resp.SearchResult2.Artist).To(HaveLen(1))+ Expect(resp.SearchResult2.Artist[0].CoverArt).To(BeEmpty())+ Expect(resp.SearchResult2.Artist[0].ArtistImageUrl).To(BeEmpty())+ })++ It("emits coverArt and imageUrl for an unresolved artist", func() {+ mockArtistRepo.SetData(model.Artists{{ID: "ar-1", Name: "Unresolved Artist"}})+ resp, err := router.Search2(newSearchRequest())+ Expect(err).ToNot(HaveOccurred())+ Expect(resp.SearchResult2.Artist).To(HaveLen(1))+ Expect(resp.SearchResult2.Artist[0].CoverArt).To(Equal("ar-ar-1"))+ Expect(resp.SearchResult2.Artist[0].ArtistImageUrl).ToNot(BeEmpty())+ })+ })})diff --git a/tests/harness/harness.go b/tests/harness/harness.goindex ff5ce8919..5949c4fae 100644--- a/tests/harness/harness.go+++ b/tests/harness/harness.go@@ -13,7 +13,6 @@ import ("testing/fstest""github.com/navidrome/navidrome/conf"- "github.com/navidrome/navidrome/core""github.com/navidrome/navidrome/core/artwork""github.com/navidrome/navidrome/core/auth""github.com/navidrome/navidrome/core/ffmpeg"@@ -74,8 +73,8 @@ func SetupDB(ctx context.Context, users ...*model.User) *DB {u.Libraries = loaded.Libraries}- s := scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())+ s := scanner.New(ctx, ds, events.NoopBroker(),+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())_, err := s.ScanAll(ctx, true)Expect(err).ToNot(HaveOccurred())@@ -87,17 +86,12 @@ func SetupDB(ctx context.Context, users ...*model.User) *DB {return h}-// Restore reloads every table from the golden snapshot via ATTACH DATABASE — much faster than a-// rescan. FTS shadow tables are skipped; they are kept in sync by their content tables' triggers.-func (h *DB) Restore() {- sqlDB := db.Db()- _, err := sqlDB.Exec("PRAGMA foreign_keys = OFF")- Expect(err).ToNot(HaveOccurred())- _, err = sqlDB.Exec("ATTACH DATABASE ? AS snapshot", h.SnapshotPath)- Expect(err).ToNot(HaveOccurred())-- rows, err := sqlDB.Query("SELECT name FROM main.sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_fts' AND name NOT LIKE '%_fts_%'")+// ResettableTables lists the tables a per-spec reset may write. FTS shadow tables are excluded:+// their content tables' triggers keep them in sync, and writing them directly corrupts the index.+func ResettableTables() []string {+ rows, err := db.Db().Query("SELECT name FROM main.sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_fts' AND name NOT LIKE '%_fts_%'")Expect(err).ToNot(HaveOccurred())+ defer rows.Close()var tables []stringfor rows.Next() {var name string@@ -105,12 +99,37 @@ func (h *DB) Restore() {tables = append(tables, name)}Expect(rows.Err()).ToNot(HaveOccurred())- rows.Close()+ return tables+}++// TruncateDB empties every resettable table, leaving the migrated schema in place — for suites+// whose specs each build their own library, so the schema is not re-migrated per spec.+func TruncateDB(tables []string) {+ sqlDB := db.Db()+ _, err := sqlDB.Exec("PRAGMA foreign_keys = OFF")+ Expect(err).ToNot(HaveOccurred())+ defer func() { _, _ = sqlDB.Exec("PRAGMA foreign_keys = ON") }()for _, table := range tables {// Table names come from sqlite_master, not user input._, err = sqlDB.Exec(`DELETE FROM main."` + table + `"`) //nolint:gosecExpect(err).ToNot(HaveOccurred())+ }+}++// Restore reloads every table from the golden snapshot via ATTACH DATABASE — much faster than a+// rescan.+func (h *DB) Restore() {+ sqlDB := db.Db()+ _, err := sqlDB.Exec("PRAGMA foreign_keys = OFF")+ Expect(err).ToNot(HaveOccurred())+ _, err = sqlDB.Exec("ATTACH DATABASE ? AS snapshot", h.SnapshotPath)+ Expect(err).ToNot(HaveOccurred())++ for _, table := range ResettableTables() {+ // Table names come from sqlite_master, not user input.+ _, err = sqlDB.Exec(`DELETE FROM main."` + table + `"`) //nolint:gosec+ Expect(err).ToNot(HaveOccurred())_, err = sqlDB.Exec(`INSERT INTO main."` + table + `" SELECT * FROM snapshot."` + table + `"`) //nolint:gosecExpect(err).ToNot(HaveOccurred())}diff --git a/tests/mock_album_repo.go b/tests/mock_album_repo.goindex cc7d66b4d..ff6f9cff6 100644--- a/tests/mock_album_repo.go+++ b/tests/mock_album_repo.go@@ -2,10 +2,12 @@ package testsimport ("errors"+ "sync""time""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/id"+ "github.com/navidrome/navidrome/utils/slice")func CreateMockAlbumRepo() *MockAlbumRepo {@@ -20,6 +22,7 @@ type MockAlbumRepo struct {All model.AlbumsErr boolOptions model.QueryOptions+ optionsMu sync.MutexSearchQuery string // last query passed to SearchReassignAnnotationCalls map[string]string // prevID -> newIDCopyAttributesCalls map[string]string // fromID -> toID@@ -68,7 +71,10 @@ func (m *MockAlbumRepo) Put(al *model.Album) error {func (m *MockAlbumRepo) GetAll(qo ...model.QueryOptions) (model.Albums, error) {if len(qo) > 0 {+ // Recording the last options is a read-path write, and callers resolve concurrently.+ m.optionsMu.Lock()m.Options = qo[0]+ m.optionsMu.Unlock()}if m.Err {return nil, errors.New("unexpected error")@@ -76,6 +82,14 @@ func (m *MockAlbumRepo) GetAll(qo ...model.QueryOptions) (model.Albums, error) {return m.All, nil}+func (m *MockAlbumRepo) GetAllIDs(qo ...model.QueryOptions) ([]string, error) {+ all, err := m.GetAll(qo...)+ if err != nil {+ return nil, err+ }+ return slice.Map(all, func(a model.Album) string { return a.ID }), nil+}+func (m *MockAlbumRepo) GetCursor(qo ...model.QueryOptions) (model.AlbumCursor, error) {res, err := m.GetAll(qo...)if err != nil {diff --git a/tests/mock_artist_repo.go b/tests/mock_artist_repo.goindex e6ea7aea4..9691a6584 100644--- a/tests/mock_artist_repo.go+++ b/tests/mock_artist_repo.go@@ -6,6 +6,7 @@ import ("github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/id"+ "github.com/navidrome/navidrome/utils/slice")func CreateMockArtistRepo() *MockArtistRepo {@@ -113,6 +114,14 @@ func (m *MockArtistRepo) GetAll(options ...model.QueryOptions) (model.Artists, ereturn allArtists, nil}+func (m *MockArtistRepo) GetAllIDs(options ...model.QueryOptions) ([]string, error) {+ all, err := m.GetAll(options...)+ if err != nil {+ return nil, err+ }+ return slice.Map(all, func(a model.Artist) string { return a.ID }), nil+}+func (m *MockArtistRepo) GetCursor(options ...model.QueryOptions) (model.ArtistCursor, error) {res, err := m.GetAll(options...)if err != nil {diff --git a/tests/mock_artwork_queue_repo.go b/tests/mock_artwork_queue_repo.gonew file mode 100644index 000000000..1b097ca32--- /dev/null+++ b/tests/mock_artwork_queue_repo.go@@ -0,0 +1,258 @@+package tests++import (+ "cmp"+ "slices"+ "sync"+ "time"++ "github.com/navidrome/navidrome/model"+)++type MockArtworkQueueRepo struct {+ model.ArtworkQueueRepository+ // mu guards Data: the worker drains this mock concurrently.+ mu sync.Mutex+ Data map[string]model.ArtworkQueueItem // keyed by iaKey(kind, id, imageType)+ Err error+ // ItemArtworkSource, when set, backs EnqueueStaleAbsent with real item_artwork state.+ ItemArtworkSource *MockArtworkRepo+ // ExistingIDs is keyed by item_kind; a nil per-kind map means PurgeDangling keeps that kind.+ ExistingIDs map[string]map[string]bool+}++func CreateMockArtworkQueueRepo() *MockArtworkQueueRepo {+ return &MockArtworkQueueRepo{Data: map[string]model.ArtworkQueueItem{}}+}++func (m *MockArtworkQueueRepo) Enqueue(items ...model.ArtworkQueueItem) error {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return m.Err+ }+ m.enqueueLocked(items)+ return nil+}++func (m *MockArtworkQueueRepo) enqueueLocked(items []model.ArtworkQueueItem) {+ now := time.Now()+ for _, it := range items {+ if it.ImageType == "" {+ it.ImageType = model.ImageTypePrimary+ }+ k := iaKey(it.ItemKind, it.ItemID, it.ImageType)+ // Mirror the SQL: retry_at/enqueued_at are server-set, never taken from the caller.+ if prev, ok := m.Data[k]; ok {+ prev.Priority = max(prev.Priority, it.Priority)+ prev.RetryAt = now+ prev.Attempts = 0+ prev.EnqueuedAt = now+ m.Data[k] = prev+ continue+ }+ it.Attempts = 0+ it.RetryAt = now+ it.EnqueuedAt = now+ m.Data[k] = it+ }+}++// EnqueueIfMissing mirrors the SQL anti-join: skip anything that already has an item_artwork row.+func (m *MockArtworkQueueRepo) EnqueueIfMissing(items ...model.ArtworkQueueItem) error {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return m.Err+ }+ var fresh []model.ArtworkQueueItem+ for _, it := range items {+ k := iaKey(it.ItemKind, it.ItemID, cmp.Or(it.ImageType, model.ImageTypePrimary))+ if m.ItemArtworkSource != nil {+ if _, ok := m.ItemArtworkSource.ItemData[k]; ok {+ continue+ }+ }+ if _, ok := m.Data[k]; ok { // DO NOTHING+ continue+ }+ fresh = append(fresh, it)+ }+ m.enqueueLocked(fresh)+ return nil+}++func (m *MockArtworkQueueRepo) DequeueBatch(n int, kinds ...string) ([]model.ArtworkQueueItem, error) {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return nil, m.Err+ }+ var res []model.ArtworkQueueItem+ now := time.Now()+ for _, it := range m.Data {+ if !it.RetryAt.After(now) && (len(kinds) == 0 || slices.Contains(kinds, it.ItemKind)) {+ res = append(res, it)+ }+ }+ slices.SortFunc(res, func(a, b model.ArtworkQueueItem) int {+ return cmp.Or(cmp.Compare(b.Priority, a.Priority), a.EnqueuedAt.Compare(b.EnqueuedAt))+ })+ if len(res) > n {+ res = res[:n]+ }+ return res, nil+}++func (m *MockArtworkQueueRepo) MarkFailedIfUnchanged(kind, id, imageType string, seenRetryAt, retryAt time.Time) error {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return m.Err+ }+ k := iaKey(kind, id, imageType)+ if it, ok := m.Data[k]; ok && it.RetryAt.Equal(seenRetryAt) {+ it.Attempts+++ it.RetryAt = retryAt+ m.Data[k] = it+ }+ return nil+}++func (m *MockArtworkQueueRepo) DeleteIfUnchanged(kind, id, imageType string, retryAt time.Time) error {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return m.Err+ }+ k := iaKey(kind, id, imageType)+ if it, ok := m.Data[k]; ok && it.RetryAt.Equal(retryAt) {+ delete(m.Data, k)+ }+ return nil+}++func (m *MockArtworkQueueRepo) PurgeDangling() (int64, error) {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return 0, m.Err+ }+ var purged int64+ for k, it := range m.Data {+ existing := m.ExistingIDs[it.ItemKind]+ if existing == nil {+ continue+ }+ if !existing[it.ItemID] {+ delete(m.Data, k)+ purged+++ }+ }+ return purged, nil+}++func (m *MockArtworkQueueRepo) Count() (int64, error) {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return 0, m.Err+ }+ return int64(len(m.Data)), nil+}++func (m *MockArtworkQueueRepo) EnqueuePreservingBackoff(items ...model.ArtworkQueueItem) error {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return m.Err+ }+ now := time.Now()+ for _, it := range items {+ if it.ImageType == "" {+ it.ImageType = model.ImageTypePrimary+ }+ k := iaKey(it.ItemKind, it.ItemID, it.ImageType)+ // Preserve an existing row's retry_at: a bump raises priority without resetting backoff.+ if prev, ok := m.Data[k]; ok {+ prev.Priority = max(prev.Priority, it.Priority)+ m.Data[k] = prev+ continue+ }+ it.Attempts = 0+ it.RetryAt = now+ it.EnqueuedAt = now+ m.Data[k] = it+ }+ return nil+}++func (m *MockArtworkQueueRepo) EnqueueStaleAbsent(kind model.Kind, attemptedBefore time.Time) (int64, error) {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil || m.ItemArtworkSource == nil {+ return 0, m.Err+ }+ now := time.Now()+ var inserted int64+ for _, ia := range m.ItemArtworkSource.ItemData {+ if ia.ItemKind != kind.Prefix() || ia.Hash != "" || !ia.AttemptedAt.Before(attemptedBefore) {+ continue+ }+ k := iaKey(ia.ItemKind, ia.ItemID, ia.ImageType)+ if _, ok := m.Data[k]; ok { // DO NOTHING: never touch existing queue rows+ continue+ }+ m.Data[k] = model.ArtworkQueueItem{+ ItemKind: ia.ItemKind,+ ItemID: ia.ItemID,+ ImageType: ia.ImageType,+ Priority: model.ArtworkPriorityRecheck,+ RetryAt: now,+ EnqueuedAt: now,+ }+ inserted+++ }+ return inserted, nil+}++// EnqueueMissing mirrors the SQL set-difference insert: ExistingIDs[kind] minus ItemArtworkSource.+func (m *MockArtworkQueueRepo) EnqueueAllMissing(kind model.Kind, priority int) (int64, error) {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return 0, m.Err+ }+ hasRow := func(id string) bool {+ if m.ItemArtworkSource == nil {+ return false+ }+ for _, ia := range m.ItemArtworkSource.ItemData {+ if ia.ItemKind == kind.Prefix() && ia.ItemID == id {+ return true+ }+ }+ return false+ }+ now := time.Now()+ var inserted int64+ for id := range m.ExistingIDs[kind.Prefix()] {+ if hasRow(id) {+ continue+ }+ k := iaKey(kind.Prefix(), id, model.ImageTypePrimary)+ if _, ok := m.Data[k]; ok { // DO NOTHING: never touch existing queue rows+ continue+ }+ m.Data[k] = model.ArtworkQueueItem{+ ItemKind: kind.Prefix(),+ ItemID: id,+ ImageType: model.ImageTypePrimary,+ Priority: priority,+ RetryAt: now,+ EnqueuedAt: now,+ }+ inserted+++ }+ return inserted, nil+}diff --git a/tests/mock_artwork_repo.go b/tests/mock_artwork_repo.gonew file mode 100644index 000000000..2ace0daba--- /dev/null+++ b/tests/mock_artwork_repo.go@@ -0,0 +1,175 @@+package tests++import (+ "maps"+ "sync"+ "time"++ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/utils/slice"+)++type MockArtworkRepo struct {+ model.ArtworkRepository+ // mu guards the maps so the worker's concurrent drain can hit this mock race-free.+ mu sync.Mutex+ Data map[string]model.Artwork+ ItemData map[string]model.ItemArtwork // keyed by iaKey(kind, id, imageType)+ Err error+ // ExistingIDs, keyed by item_kind, backs PurgeDanglingItems; nil map keeps everything.+ ExistingIDs map[string]map[string]bool+}++func CreateMockArtworkRepo() *MockArtworkRepo {+ return &MockArtworkRepo{Data: map[string]model.Artwork{}, ItemData: map[string]model.ItemArtwork{}}+}++func iaKey(kind, id, imageType string) string { return kind + "|" + id + "|" + imageType }++func (m *MockArtworkRepo) GetImage(hash string) (*model.Artwork, error) {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return nil, m.Err+ }+ if a, ok := m.Data[hash]; ok {+ return &a, nil+ }+ return nil, model.ErrNotFound+}++func (m *MockArtworkRepo) PutImage(a *model.Artwork) error {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return m.Err+ }+ // Mirrors the SQL repository: every upsert refreshes created_at. Age fixtures via Data directly.+ a.CreatedAt = time.Now()+ m.Data[a.Hash] = *a+ return nil+}++func (m *MockArtworkRepo) GetMimeByHash() (map[string]string, error) {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return nil, m.Err+ }+ mimes := make(map[string]string, len(m.Data))+ for h, a := range m.Data {+ mimes[h] = a.Mime+ }+ return mimes, nil+}++func (m *MockArtworkRepo) PurgeDanglingItems() (int64, error) {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return 0, m.Err+ }+ var purged int64+ for k, ia := range m.ItemData {+ // A nil per-kind map means that kind isn't tracked by the test, so keep it.+ existing := m.ExistingIDs[ia.ItemKind]+ if existing == nil {+ continue+ }+ if !existing[ia.ItemID] {+ delete(m.ItemData, k)+ purged+++ }+ }+ return purged, nil+}++func (m *MockArtworkRepo) PurgeOrphans(createdBefore time.Time) (int64, error) {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return 0, m.Err+ }+ var deleted int64+ for h, a := range m.Data {+ if m.referenced(h) || !a.CreatedAt.Before(createdBefore) {+ continue+ }+ delete(m.Data, h)+ deleted+++ }+ return deleted, nil+}++func (m *MockArtworkRepo) referenced(hash string) bool {+ for _, ia := range m.ItemData {+ if ia.Hash == hash {+ return true+ }+ }+ return false+}++func (m *MockArtworkRepo) GetItemArtwork(kind model.Kind, id, imageType string) (*model.ItemArtwork, error) {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return nil, m.Err+ }+ if ia, ok := m.ItemData[iaKey(kind.Prefix(), id, imageType)]; ok {+ return &ia, nil+ }+ return nil, model.ErrNotFound+}++func (m *MockArtworkRepo) PutItemArtwork(ia *model.ItemArtwork) error {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return m.Err+ }+ if ia.ImageType == "" {+ ia.ImageType = model.ImageTypePrimary+ }+ ia.UpdatedAt = time.Now()+ if ia.AttemptedAt.IsZero() {+ ia.AttemptedAt = ia.UpdatedAt+ }+ m.ItemData[iaKey(ia.ItemKind, ia.ItemID, ia.ImageType)] = *ia+ return nil+}++func (m *MockArtworkRepo) DeleteForItems(kind model.Kind, ids []string) error {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return m.Err+ }+ idSet := slice.ToSet(ids)+ maps.DeleteFunc(m.ItemData, func(_ string, ia model.ItemArtwork) bool {+ _, ok := idSet[ia.ItemID]+ return ok && ia.ItemKind == kind.Prefix()+ })+ return nil+}++func (m *MockArtworkRepo) GetInfoForItems(kind model.Kind, ids []string) (map[string]model.ItemArtworkInfo, error) {+ m.mu.Lock()+ defer m.mu.Unlock()+ if m.Err != nil {+ return nil, m.Err+ }+ res := map[string]model.ItemArtworkInfo{}+ for _, id := range ids {+ if ia, ok := m.ItemData[iaKey(kind.Prefix(), id, model.ImageTypePrimary)]; ok {+ info := model.ItemArtworkInfo{ItemID: id, Hash: ia.Hash}+ if a, ok := m.Data[ia.Hash]; ok {+ info.BlurHash, info.ThumbHash = a.BlurHash, a.ThumbHash+ info.DominantColor = a.DominantColor+ info.Width, info.Height = a.Width, a.Height+ }+ res[id] = info+ }+ }+ return res, nil+}diff --git a/tests/mock_data_store.go b/tests/mock_data_store.goindex e016a28de..32f56a4f0 100644--- a/tests/mock_data_store.go+++ b/tests/mock_data_store.go@@ -28,6 +28,8 @@ type MockDataStore struct {MockedScrobble model.ScrobbleRepositoryMockedRadio model.RadioRepositoryMockedPlugin model.PluginRepository+ MockedArtwork model.ArtworkRepository+ MockedArtworkQueue model.ArtworkQueueRepositoryscrobbleBufferMu sync.MutexrepoMu sync.Mutex@@ -37,6 +39,8 @@ type MockDataStore struct {}func (db *MockDataStore) Library(ctx context.Context) model.LibraryRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedLibrary != nil {return db.MockedLibrary}@@ -48,6 +52,8 @@ func (db *MockDataStore) Library(ctx context.Context) model.LibraryRepository {}func (db *MockDataStore) Folder(ctx context.Context) model.FolderRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedFolder != nil {return db.MockedFolder}@@ -59,6 +65,8 @@ func (db *MockDataStore) Folder(ctx context.Context) model.FolderRepository {}func (db *MockDataStore) Tag(ctx context.Context) model.TagRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedTag != nil {return db.MockedTag}@@ -70,6 +78,8 @@ func (db *MockDataStore) Tag(ctx context.Context) model.TagRepository {}func (db *MockDataStore) Album(ctx context.Context) model.AlbumRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedAlbum != nil {return db.MockedAlbum}@@ -81,6 +91,8 @@ func (db *MockDataStore) Album(ctx context.Context) model.AlbumRepository {}func (db *MockDataStore) Artist(ctx context.Context) model.ArtistRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedArtist != nil {return db.MockedArtist}@@ -92,11 +104,11 @@ func (db *MockDataStore) Artist(ctx context.Context) model.ArtistRepository {}func (db *MockDataStore) MediaFile(ctx context.Context) model.MediaFileRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.RealDS != nil && db.MockedMediaFile == nil {return db.RealDS.MediaFile(ctx)}- db.repoMu.Lock()- defer db.repoMu.Unlock()if db.MockedMediaFile == nil {db.MockedMediaFile = CreateMockMediaFileRepo()}@@ -104,6 +116,8 @@ func (db *MockDataStore) MediaFile(ctx context.Context) model.MediaFileRepositor}func (db *MockDataStore) Genre(ctx context.Context) model.GenreRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedGenre != nil {return db.MockedGenre}@@ -115,6 +129,8 @@ func (db *MockDataStore) Genre(ctx context.Context) model.GenreRepository {}func (db *MockDataStore) Playlist(ctx context.Context) model.PlaylistRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedPlaylist != nil {return db.MockedPlaylist}@@ -126,6 +142,8 @@ func (db *MockDataStore) Playlist(ctx context.Context) model.PlaylistRepository}func (db *MockDataStore) PlayQueue(ctx context.Context) model.PlayQueueRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedPlayQueue != nil {return db.MockedPlayQueue}@@ -137,6 +155,8 @@ func (db *MockDataStore) PlayQueue(ctx context.Context) model.PlayQueueRepositor}func (db *MockDataStore) UserProps(ctx context.Context) model.UserPropsRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedUserProps != nil {return db.MockedUserProps}@@ -148,6 +168,8 @@ func (db *MockDataStore) UserProps(ctx context.Context) model.UserPropsRepositor}func (db *MockDataStore) Property(ctx context.Context) model.PropertyRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedProperty != nil {return db.MockedProperty}@@ -159,6 +181,8 @@ func (db *MockDataStore) Property(ctx context.Context) model.PropertyRepository}func (db *MockDataStore) Share(ctx context.Context) model.ShareRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedShare != nil {return db.MockedShare}@@ -170,6 +194,8 @@ func (db *MockDataStore) Share(ctx context.Context) model.ShareRepository {}func (db *MockDataStore) User(ctx context.Context) model.UserRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedUser != nil {return db.MockedUser}@@ -181,6 +207,8 @@ func (db *MockDataStore) User(ctx context.Context) model.UserRepository {}func (db *MockDataStore) Transcoding(ctx context.Context) model.TranscodingRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedTranscoding != nil {return db.MockedTranscoding}@@ -192,6 +220,8 @@ func (db *MockDataStore) Transcoding(ctx context.Context) model.TranscodingRepos}func (db *MockDataStore) Player(ctx context.Context) model.PlayerRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedPlayer != nil {return db.MockedPlayer}@@ -203,6 +233,8 @@ func (db *MockDataStore) Player(ctx context.Context) model.PlayerRepository {}func (db *MockDataStore) ScrobbleBuffer(ctx context.Context) model.ScrobbleBufferRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.RealDS != nil && db.MockedScrobbleBuffer == nil {return db.RealDS.ScrobbleBuffer(ctx)}@@ -215,6 +247,8 @@ func (db *MockDataStore) ScrobbleBuffer(ctx context.Context) model.ScrobbleBuffe}func (db *MockDataStore) Scrobble(ctx context.Context) model.ScrobbleRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedScrobble != nil {return db.MockedScrobble}@@ -226,6 +260,8 @@ func (db *MockDataStore) Scrobble(ctx context.Context) model.ScrobbleRepository}func (db *MockDataStore) Radio(ctx context.Context) model.RadioRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedRadio != nil {return db.MockedRadio}@@ -237,6 +273,8 @@ func (db *MockDataStore) Radio(ctx context.Context) model.RadioRepository {}func (db *MockDataStore) Plugin(ctx context.Context) model.PluginRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()if db.MockedPlugin != nil {return db.MockedPlugin}@@ -247,6 +285,42 @@ func (db *MockDataStore) Plugin(ctx context.Context) model.PluginRepository {return db.MockedPlugin}+func (db *MockDataStore) Artwork(ctx context.Context) model.ArtworkRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()+ return db.artworkLocked(ctx)+}++// artworkLocked is the body of Artwork for callers already holding repoMu; repoMu is a plain+// Mutex, so re-entering through the exported method would deadlock.+func (db *MockDataStore) artworkLocked(ctx context.Context) model.ArtworkRepository {+ if db.MockedArtwork != nil {+ return db.MockedArtwork+ }+ if db.RealDS != nil {+ return db.RealDS.Artwork(ctx)+ }+ db.MockedArtwork = CreateMockArtworkRepo()+ return db.MockedArtwork+}++func (db *MockDataStore) ArtworkQueue(ctx context.Context) model.ArtworkQueueRepository {+ db.repoMu.Lock()+ defer db.repoMu.Unlock()+ if db.MockedArtworkQueue != nil {+ return db.MockedArtworkQueue+ }+ if db.RealDS != nil {+ return db.RealDS.ArtworkQueue(ctx)+ }+ q := CreateMockArtworkQueueRepo()+ if aw, ok := db.artworkLocked(ctx).(*MockArtworkRepo); ok {+ q.ItemArtworkSource = aw+ }+ db.MockedArtworkQueue = q+ return db.MockedArtworkQueue+}+func (db *MockDataStore) WithTx(block func(tx model.DataStore) error, label ...string) error {return block(db)}diff --git a/tests/mock_mediafile_repo.go b/tests/mock_mediafile_repo.goindex 990b91d7c..d993af1a8 100644--- a/tests/mock_mediafile_repo.go+++ b/tests/mock_mediafile_repo.go@@ -123,6 +123,18 @@ func (m *MockMediaFileRepo) GetCursor(qo ...model.QueryOptions) (model.MediaFile}, nil}+func (m *MockMediaFileRepo) GetCursorWithArtwork(qo ...model.QueryOptions) (model.MediaFileCursor, error) {+ return m.GetCursor(qo...)+}++func (m *MockMediaFileRepo) GetAllIDs(qo ...model.QueryOptions) ([]string, error) {+ all, err := m.GetAll(qo...)+ if err != nil {+ return nil, err+ }+ return slice.Map(all, func(mf model.MediaFile) string { return mf.ID }), nil+}+func (m *MockMediaFileRepo) Put(mf *model.MediaFile) error {if m.Err {return errors.New("error")diff --git a/tests/mock_playlist_repo.go b/tests/mock_playlist_repo.goindex 8f8842c8e..ee645e984 100644--- a/tests/mock_playlist_repo.go+++ b/tests/mock_playlist_repo.go@@ -7,6 +7,7 @@ import ("github.com/deluan/rest""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/id"+ "github.com/navidrome/navidrome/utils/slice")func CreateMockPlaylistRepo() *MockPlaylistRepo {@@ -52,6 +53,14 @@ func (m *MockPlaylistRepo) GetAll(options ...model.QueryOptions) (model.Playlistreturn m.All, nil}+func (m *MockPlaylistRepo) GetAllIDs(options ...model.QueryOptions) ([]string, error) {+ all, err := m.GetAll(options...)+ if err != nil {+ return nil, err+ }+ return slice.Map(all, func(p model.Playlist) string { return p.ID }), nil+}+func (m *MockPlaylistRepo) GetCursor(options ...model.QueryOptions) (model.PlaylistCursor, error) {res, err := m.GetAll(options...)if err != nil {diff --git a/tests/mock_playlist_track_repo.go b/tests/mock_playlist_track_repo.goindex 2835baadd..83751bb28 100644--- a/tests/mock_playlist_track_repo.go+++ b/tests/mock_playlist_track_repo.go@@ -14,6 +14,7 @@ type MockPlaylistTrackRepo struct {Reordered boolAddCount intErr error+ AlbumIDs []string // stubbed result for GetAlbumIDs, ignoring options}func (m *MockPlaylistTrackRepo) SetData(tracks model.PlaylistTracks) {@@ -66,6 +67,13 @@ func (m *MockPlaylistTrackRepo) GetCursor(options ...model.QueryOptions) (model.}, nil}+func (m *MockPlaylistTrackRepo) GetAlbumIDs(...model.QueryOptions) ([]string, error) {+ if m.Err != nil {+ return nil, m.Err+ }+ return m.AlbumIDs, nil+}+func (m *MockPlaylistTrackRepo) GetMediaFileIDs(options ...model.QueryOptions) ([]string, error) {if m.Err != nil {return nil, m.Errdiff --git a/tests/mock_radio_repository.go b/tests/mock_radio_repository.goindex c50a529e5..2baeadc5c 100644--- a/tests/mock_radio_repository.go+++ b/tests/mock_radio_repository.go@@ -5,6 +5,7 @@ import ("github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/id"+ "github.com/navidrome/navidrome/utils/slice")type MockedRadioRepo struct {@@ -16,7 +17,7 @@ type MockedRadioRepo struct {}func CreateMockedRadioRepo() *MockedRadioRepo {- return &MockedRadioRepo{}+ return &MockedRadioRepo{Data: map[string]*model.Radio{}}}func (m *MockedRadioRepo) SetError(err bool) {@@ -73,6 +74,14 @@ func (m *MockedRadioRepo) GetAll(qo ...model.QueryOptions) (model.Radios, error)return m.All, nil}+func (m *MockedRadioRepo) GetAllIDs(qo ...model.QueryOptions) ([]string, error) {+ all, err := m.GetAll(qo...)+ if err != nil {+ return nil, err+ }+ return slice.Map(all, func(r model.Radio) string { return r.ID }), nil+}+func (m *MockedRadioRepo) Put(radio *model.Radio, _ ...string) error {if m.Err {return errors.New("error")diff --git a/ui/src/album/AlbumDetails.jsx b/ui/src/album/AlbumDetails.jsxindex cec66eb8b..f55d94ffc 100644--- a/ui/src/album/AlbumDetails.jsx+++ b/ui/src/album/AlbumDetails.jsx@@ -2,7 +2,6 @@ import { useEffect, useState } from 'react'import {Card,CardContent,- CardMedia,Collapse,makeStyles,Typography,@@ -21,6 +20,7 @@ import Lightbox from 'react-image-lightbox'import config from '../config'import 'react-image-lightbox/style.css'import subsonic from '../subsonic'+import { Artwork } from '../common/Artwork'import {ArtistLinkField,CollapsibleComment,@@ -30,7 +30,6 @@ import {RatingField,SizeField,useAlbumsPerPage,- useImageLoadingState,} from '../common'import { formatFullDate, intersperse } from '../utils'import AlbumExternalLinks from './AlbumExternalLinks'@@ -88,9 +87,6 @@ const useStyles = makeStyles(backgroundColor: 'transparent',transition: 'opacity 0.3s ease-in-out',},- coverLoading: {- opacity: 0.5,- },loveButton: {top: theme.spacing(-0.2),left: theme.spacing(0.5),@@ -223,15 +219,7 @@ const AlbumDetails = (props) => {const classes = useStyles()const [expanded, setExpanded] = useState(false)const [albumInfo, setAlbumInfo] = useState()- const {- imageLoading,- imageError,- isLightboxOpen,- handleImageLoad,- handleImageError,- handleOpenLightbox,- handleCloseLightbox,- } = useImageLoadingState(record.id)+ const [isLightboxOpen, setLightboxOpen] = useState(false)let notes = albumInfo?.notes || record.notes@@ -254,27 +242,18 @@ const AlbumDetails = (props) => {})}, [record])- const imageUrl = subsonic.getCoverArtUrl(record, config.uiCoverArtSize)const fullImageUrl = subsonic.getCoverArtUrl(record)return (<Card className={classes.root}><div className={classes.cardContents}><div className={classes.coverParent}>- <CardMedia- key={record.id}- component={'img'}- src={imageUrl}- width="400"- height="400"- className={`${classes.cover} ${imageLoading ? classes.coverLoading : ''}`}- onClick={handleOpenLightbox}- onLoad={handleImageLoad}- onError={handleImageError}+ <Artwork+ record={record}+ fit="contain"+ className={classes.cover}title={record.name}- style={{- cursor: imageError ? 'default' : 'pointer',- }}+ onClick={() => setLightboxOpen(true)}/></div><div className={classes.details}>@@ -363,13 +342,13 @@ const AlbumDetails = (props) => {</Collapse></div>)}- {isLightboxOpen && !imageError && (+ {isLightboxOpen && (<LightboximagePadding={50}animationDuration={200}imageTitle={record.name}mainSrc={fullImageUrl}- onCloseRequest={handleCloseLightbox}+ onCloseRequest={() => setLightboxOpen(false)}/>)}</Card>diff --git a/ui/src/album/AlbumGridView.jsx b/ui/src/album/AlbumGridView.jsxindex 33db9e40f..2e4cb10ba 100644--- a/ui/src/album/AlbumGridView.jsx+++ b/ui/src/album/AlbumGridView.jsx@@ -1,4 +1,4 @@-import React from 'react'+import React, { useRef } from 'react'import {GridList,GridListTile,@@ -11,19 +11,18 @@ import withWidth from '@material-ui/core/withWidth'import { Link } from 'react-router-dom'import { linkToRecord, useListContext, Loading } from 'react-admin'import { withContentRect } from 'react-measure'+import { useRollChanged } from './useRollChanged'import { useDrag } from 'react-dnd'-import subsonic from '../subsonic'import {AlbumContextMenu,PlayButton,ArtistLinkField,OverflowTooltip,- useImageUrl,} from '../common'-import config from '../config'import { DraggableTypes } from '../consts'import clsx from 'clsx'import { AlbumDatesField } from './AlbumDatesField.jsx'+import { Artwork } from '../common/Artwork'const useStyles = makeStyles((theme) => ({@@ -105,12 +104,12 @@ const useCoverStyles = makeStyles({display: 'inline-block',width: '100%',objectFit: 'contain',+ // The image fills this box absolutely, so it lends no height: a remount that has not been+ // re-measured yet would collapse the tile and blank the cover for a frame.+ aspectRatio: '1',height: (props) => props.height,transition: 'opacity 0.3s ease-in-out',},- coverLoading: {- opacity: 0,- },})const getColsForWidth = (width) => {@@ -138,16 +137,14 @@ const Cover = withContentRect('bounds')(({[record],)- const url = subsonic.getCoverArtUrl(record, config.uiCoverArtSize, true)- const { imgUrl, loading: imageLoading } = useImageUrl(url)-return (<div ref={measureRef} className={classes.coverContainer}><div ref={dragAlbumRef}>- <img- src={imgUrl || undefined}- alt={record.name}- className={`${classes.cover} ${imageLoading ? classes.coverLoading : ''}`}+ <Artwork+ record={record}+ square+ className={classes.cover}+ title={record.name}/></div></div>@@ -237,9 +234,21 @@ const LoadedAlbumGrid = ({ ids, data, basePath, width }) => {)}-const AlbumGridView = ({ albumListType, loaded, loading, ...props }) => {- const hide =- (loading && albumListType === 'random') || !props.data || !props.ids+const AlbumGridView = ({+ albumListType,+ loaded,+ loading,+ seed,+ shownSeed,+ ...props+}) => {+ // ArtistShow renders this grid too, with no roll to track, so own a ref when none is passed.+ const ownSeed = useRef(null)+ // A re-roll replaces every album, so the previous roll must not linger while it loads.+ const rerolling =+ useRollChanged(shownSeed ?? ownSeed, seed, loading) &&+ albumListType === 'random'+ const hide = rerolling || !props.data || !props.idsreturn hide ? <Loading /> : <LoadedAlbumGrid {...props} />}diff --git a/ui/src/album/AlbumGridView.test.jsx b/ui/src/album/AlbumGridView.test.jsxnew file mode 100644index 000000000..1f06c3fd7--- /dev/null+++ b/ui/src/album/AlbumGridView.test.jsx@@ -0,0 +1,18 @@+import { render } from '@testing-library/react'+import { describe, it, expect, vi } from 'vitest'+import AlbumGridView from './AlbumGridView'++// react-admin's Link/useListContext need a router and a store; the grid body is not under test here.+vi.mock('react-admin', () => ({+ linkToRecord: () => '/album/1',+ useListContext: () => ({}),+ Loading: () => <div data-testid="loading" />,+}))+describe('AlbumGridView', () => {+ // ArtistShow renders the grid through ReferenceManyField, which passes no seed tracking.+ it('renders without a shownSeed ref', () => {+ expect(() =>+ render(<AlbumGridView data={{}} ids={[]} basePath="/album" width="md" />),+ ).not.toThrow()+ })+})diff --git a/ui/src/album/AlbumList.jsx b/ui/src/album/AlbumList.jsxindex cd73fa0c3..3cb8a648e 100644--- a/ui/src/album/AlbumList.jsx+++ b/ui/src/album/AlbumList.jsx@@ -1,4 +1,4 @@-import { cloneElement } from 'react'+import { cloneElement, useRef } from 'react'import { useSelector } from 'react-redux'import { Redirect, useLocation } from 'react-router-dom'import {@@ -30,6 +30,7 @@ import {import AlbumListActions from './AlbumListActions'import AlbumTableView from './AlbumTableView'import AlbumGridView from './AlbumGridView'+import { useRollChanged } from './useRollChanged'import albumLists from './albumLists'import {getStoredDefaultView,@@ -186,9 +187,10 @@ const AlbumListTitle = ({ albumListType }) => {return <Title subTitle={title} args={{ smart_count: 2 }} />}-const AlbumListPagination = ({ albumListType, ...rest }) => {+const AlbumListPagination = ({ albumListType, seed, shownSeed, ...rest }) => {const { loading } = useListContext()- if (loading && albumListType === 'random') {+ const rerolling = useRollChanged(shownSeed, seed, loading)+ if (rerolling && albumListType === 'random') {return null}return <Pagination {...rest} />@@ -198,6 +200,7 @@ const randomStartingSeed = Math.random().toString()const AlbumList = (props) => {const { width } = props+ const shownSeed = useRef(null)const albumView = useSelector((state) => state.albumView)const [perPage, perPageOptions] = useAlbumsPerPage(width)const location = useLocation()@@ -260,13 +263,20 @@ const AlbumList = (props) => {<AlbumListPaginationrowsPerPageOptions={perPageOptions}albumListType={albumListType}+ seed={seed}+ shownSeed={shownSeed}/>}title={<AlbumListTitle albumListType={albumListType} />}><ScrollRestorer>{albumView.grid ? (- <AlbumGridView albumListType={albumListType} {...props} />+ <AlbumGridView+ albumListType={albumListType}+ seed={seed}+ shownSeed={shownSeed}+ {...props}+ />) : (<AlbumTableView {...props} />)}diff --git a/ui/src/album/AlbumTableView.jsx b/ui/src/album/AlbumTableView.jsxindex d1a89d512..051d5988e 100644--- a/ui/src/album/AlbumTableView.jsx+++ b/ui/src/album/AlbumTableView.jsx@@ -14,7 +14,7 @@ import { makeStyles } from '@material-ui/core/styles'import { useDrag } from 'react-dnd'import {ArtistLinkField,- CoverArtAvatar,+ ArtworkAvatar,DurationField,RangeField,SimpleList,@@ -164,7 +164,7 @@ const AlbumTableView = ({)}leftIcon={(r) => (<span style={{ marginRight: '8px' }}>- <CoverArtAvatar record={r} variant="square" />+ <ArtworkAvatar record={r} variant="square" /></span>)}linkType={'show'}@@ -173,7 +173,7 @@ const AlbumTableView = ({/>) : (<AlbumDatagrid rowClick={'show'} classes={{ row: classes.row }} {...rest}>- <CoverArtAvatar source="id" variant="square" />+ <ArtworkAvatar source="id" variant="square" /><TextField source="name" />{columns}<AlbumContextMenudiff --git a/ui/src/album/useRollChanged.jsx b/ui/src/album/useRollChanged.jsxnew file mode 100644index 000000000..b364bdc6b--- /dev/null+++ b/ui/src/album/useRollChanged.jsx@@ -0,0 +1,13 @@+import { useRef } from 'react'++// Reports that the albums on screen belong to a different roll than the one loading: only a seed+// change is a re-roll. `shown` is owned above the grid, which a refresh remounts under the new seed.+export const useRollChanged = (shown, seed, loading) => {+ const wasLoading = useRef(loading)++ if (!loading && (shown.current === null || wasLoading.current)) {+ shown.current = seed+ }+ wasLoading.current = loading+ return shown.current !== seed+}diff --git a/ui/src/album/useRollChanged.test.jsx b/ui/src/album/useRollChanged.test.jsxnew file mode 100644index 000000000..0745efb08--- /dev/null+++ b/ui/src/album/useRollChanged.test.jsx@@ -0,0 +1,73 @@+import { renderHook } from '@testing-library/react-hooks'+import { describe, it, expect } from 'vitest'+import { useRollChanged } from './useRollChanged'++describe('useRollChanged', () => {+ // Passing `shown` in mimics AlbumList owning it across a remount.+ const setup = (props, shown = { current: null }) => ({+ shown,+ ...renderHook(({ seed, loading }) => useRollChanged(shown, seed, loading), {+ initialProps: props,+ }),+ })++ it('reports a change while a load is in flight on a fresh mount', () => {+ const { result } = setup({ seed: 's1', loading: true })+ expect(result.current).toBe(true)+ })++ it('reports no change when mounted with data already in hand', () => {+ const { result } = setup({ seed: 's1', loading: false })+ expect(result.current).toBe(false)+ })++ it('stays false while loading a filter change on the same roll', () => {+ const { result, rerender } = setup({ seed: 's1', loading: false })+ rerender({ seed: 's1', loading: true })+ expect(result.current).toBe(false)+ })++ it('goes true while loading after the seed changes', () => {+ const { result, rerender } = setup({ seed: 's1', loading: false })+ rerender({ seed: 's2', loading: true })+ expect(result.current).toBe(true)+ })++ it('clears once the new roll has loaded', () => {+ const { result, rerender } = setup({ seed: 's1', loading: false })+ rerender({ seed: 's2', loading: true })+ expect(result.current).toBe(true)+ rerender({ seed: 's2', loading: false })+ expect(result.current).toBe(false)+ })++ // The seed can land a render before loading flips; the new roll must not be recorded as shown.+ it('still reports a change when the seed arrives before loading starts', () => {+ const { result, rerender } = setup({ seed: 's1', loading: false })+ rerender({ seed: 's2', loading: false })+ expect(result.current).toBe(true)+ })++ // Refresh remounts the grid under the new seed a render before the refetch starts.+ it('reports a change when a refresh remounts the grid before loading starts', () => {+ const { shown, unmount } = setup({ seed: 's1', loading: false })+ expect(shown.current).toBe('s1')+ unmount()++ const remounted = setup({ seed: 's2', loading: false }, shown)+ expect(remounted.result.current).toBe(true)++ remounted.rerender({ seed: 's2', loading: true })+ expect(remounted.result.current).toBe(true)+ remounted.rerender({ seed: 's2', loading: false })+ expect(remounted.result.current).toBe(false)+ })++ it('reports no change when a remount keeps the same roll', () => {+ const { shown, unmount } = setup({ seed: 's1', loading: false })+ unmount()++ const remounted = setup({ seed: 's1', loading: false }, shown)+ expect(remounted.result.current).toBe(false)+ })+})diff --git a/ui/src/artist/ArtistList.jsx b/ui/src/artist/ArtistList.jsxindex 4559aa8e6..f4147221e 100644--- a/ui/src/artist/ArtistList.jsx+++ b/ui/src/artist/ArtistList.jsx@@ -22,7 +22,7 @@ import { useDrag } from 'react-dnd'import clsx from 'clsx'import {ArtistContextMenu,- CoverArtAvatar,+ ArtworkAvatar,List,useGetHandleArtistClick,RatingField,@@ -173,7 +173,7 @@ const ArtistListView = ({ hasShow, hasEdit, hasList, width, ...rest }) => {/>) : (<ArtistDatagrid rowClick={handleArtistLink} classes={{ row: classes.row }}>- <CoverArtAvatar source="id" />+ <ArtworkAvatar source="id" /><TextField source="name" /><FunctionFieldsource="albumCount"diff --git a/ui/src/artist/ArtistSimpleList.jsx b/ui/src/artist/ArtistSimpleList.jsxindex 55b6b1a0b..9dcae0470 100644--- a/ui/src/artist/ArtistSimpleList.jsx+++ b/ui/src/artist/ArtistSimpleList.jsx@@ -8,7 +8,7 @@ import ListItemSecondaryAction from '@material-ui/core/ListItemSecondaryAction'import ListItemText from '@material-ui/core/ListItemText'import { makeStyles } from '@material-ui/core/styles'import { sanitizeListRestProps } from 'react-admin'-import { ArtistContextMenu, CoverArtAvatar, RatingField } from '../common'+import { ArtistContextMenu, ArtworkAvatar, RatingField } from '../common'import config from '../config'const useStyles = makeStyles(@@ -49,7 +49,7 @@ const ArtistSimpleList = ({<span key={id} onClick={() => linkType(id)}><ListItem className={classes.listItem} button={true}><ListItemAvatar>- <CoverArtAvatar record={data[id]} />+ <ArtworkAvatar record={data[id]} /></ListItemAvatar><ListItemTextstyle={{ marginLeft: '8px' }}diff --git a/ui/src/artist/DesktopArtistDetails.jsx b/ui/src/artist/DesktopArtistDetails.jsxindex dda761097..9269dc8d7 100644--- a/ui/src/artist/DesktopArtistDetails.jsx+++ b/ui/src/artist/DesktopArtistDetails.jsx@@ -3,20 +3,15 @@ import { Typography, Collapse } from '@material-ui/core'import { makeStyles } from '@material-ui/core'import Card from '@material-ui/core/Card'import CardContent from '@material-ui/core/CardContent'-import CardMedia from '@material-ui/core/CardMedia'import ArtistExternalLinks from './ArtistExternalLink'import config from '../config'-import {- LoveButton,- RatingField,- ImageUploadOverlay,- useImageLoadingState,-} from '../common'+import { LoveButton, RatingField, ImageUploadOverlay } from '../common'import Lightbox from 'react-image-lightbox'import ExpandInfoDialog from '../dialogs/ExpandInfoDialog'import AlbumInfo from '../album/AlbumInfo'import subsonic from '../subsonic'import { SafeHTML } from '../common/SafeHTML'+import { Artwork } from '../common/Artwork'const useStyles = makeStyles((theme) => ({@@ -49,9 +44,6 @@ const useStyles = makeStyles(transition: 'opacity 0.3s ease-in-out',objectFit: 'cover',},- coverLoading: {- opacity: 0.5,- },artistImage: {maxHeight: '12rem',minHeight: '12rem',@@ -91,35 +83,18 @@ const DesktopArtistDetails = ({ artistInfo, record, biography }) => {const [expanded, setExpanded] = useState(false)const classes = useStyles()const title = record.name- const {- imageLoading,- imageError,- isLightboxOpen,- handleImageLoad,- handleImageError,- handleOpenLightbox,- handleCloseLightbox,- } = useImageLoadingState(record.id)+ const [isLightboxOpen, setLightboxOpen] = useState(false)return (<div className={classes.root}><Card className={classes.artistDetail}><Card className={classes.artistImage}>- {artistInfo && (- <CardMedia- key={record.id}- component="img"- src={subsonic.getCoverArtUrl(record, config.uiCoverArtSize)}- className={`${classes.cover} ${imageLoading ? classes.coverLoading : ''}`}- onClick={handleOpenLightbox}- onLoad={handleImageLoad}- onError={handleImageError}- title={title}- style={{- cursor: imageError ? 'default' : 'pointer',- }}- />- )}+ <Artwork+ record={record}+ className={classes.cover}+ title={title}+ onClick={() => setLightboxOpen(true)}+ /><ImageUploadOverlayentityType="artist"entityId={record.id}@@ -175,13 +150,13 @@ const DesktopArtistDetails = ({ artistInfo, record, biography }) => {)}</Typography></div>- {isLightboxOpen && !imageError && (+ {isLightboxOpen && (<LightboximagePadding={50}animationDuration={200}imageTitle={record.name}mainSrc={subsonic.getCoverArtUrl(record)}- onCloseRequest={handleCloseLightbox}+ onCloseRequest={() => setLightboxOpen(false)}/>)}</Card>diff --git a/ui/src/artist/MobileArtistDetails.jsx b/ui/src/artist/MobileArtistDetails.jsxindex e82d4c28a..0925b6f10 100644--- a/ui/src/artist/MobileArtistDetails.jsx+++ b/ui/src/artist/MobileArtistDetails.jsx@@ -2,17 +2,12 @@ import React, { useState } from 'react'import { Typography, Collapse } from '@material-ui/core'import { makeStyles } from '@material-ui/core/styles'import Card from '@material-ui/core/Card'-import CardMedia from '@material-ui/core/CardMedia'import config from '../config'-import {- LoveButton,- RatingField,- ImageUploadOverlay,- useImageLoadingState,-} from '../common'+import { LoveButton, RatingField, ImageUploadOverlay } from '../common'import Lightbox from 'react-image-lightbox'import subsonic from '../subsonic'import { SafeHTML } from '../common/SafeHTML'+import { Artwork } from '../common/Artwork'const useStyles = makeStyles((theme) => ({@@ -60,9 +55,6 @@ const useStyles = makeStyles(transition: 'opacity 0.3s ease-in-out',objectFit: 'cover',},- coverLoading: {- opacity: 0.5,- },artistImage: {marginLeft: '1em',maxHeight: '7rem',@@ -88,41 +80,24 @@ const useStyles = makeStyles({ name: 'NDMobileArtistDetails' },)-const MobileArtistDetails = ({ artistInfo, biography, record }) => {+const MobileArtistDetails = ({ biography, record }) => {const img = subsonic.getCoverArtUrl(record, 800)const [expanded, setExpanded] = useState(false)const classes = useStyles({ img, expanded })const title = record.name- const {- imageLoading,- imageError,- isLightboxOpen,- handleImageLoad,- handleImageError,- handleOpenLightbox,- handleCloseLightbox,- } = useImageLoadingState(record.id)+ const [isLightboxOpen, setLightboxOpen] = useState(false)return (<><div className={classes.root}><div className={classes.bgContainer}><Card className={classes.artistImage}>- {artistInfo && (- <CardMedia- key={record.id}- component="img"- src={subsonic.getCoverArtUrl(record, config.uiCoverArtSize)}- className={`${classes.cover} ${imageLoading ? classes.coverLoading : ''}`}- onClick={handleOpenLightbox}- onLoad={handleImageLoad}- onError={handleImageError}- title={title}- style={{- cursor: imageError ? 'default' : 'pointer',- }}- />- )}+ <Artwork+ record={record}+ className={classes.cover}+ title={title}+ onClick={() => setLightboxOpen(true)}+ /><ImageUploadOverlayentityType="artist"entityId={record.id}@@ -165,13 +140,13 @@ const MobileArtistDetails = ({ artistInfo, biography, record }) => {</Typography></Collapse></div>- {isLightboxOpen && !imageError && (+ {isLightboxOpen && (<LightboximagePadding={50}animationDuration={200}imageTitle={record.name}mainSrc={img}- onCloseRequest={handleCloseLightbox}+ onCloseRequest={() => setLightboxOpen(false)}/>)}</>diff --git a/ui/src/common/Artwork.jsx b/ui/src/common/Artwork.jsxnew file mode 100644index 000000000..21ac5e07b--- /dev/null+++ b/ui/src/common/Artwork.jsx@@ -0,0 +1,127 @@+import { useEffect, useRef, useState } from 'react'+import PropTypes from 'prop-types'+import clsx from 'clsx'+import { makeStyles } from '@material-ui/core/styles'+import config from '../config'+import subsonic from '../subsonic'+import { useImageUrl } from './useImageUrl'+import { ThumbHashCanvas } from './ThumbHashCanvas'++// Drives both the CSS transition and the timer that retires the placeholder, so they cannot drift.+const fadeMs = 150++const useStyles = makeStyles({+ // className supplies the size and shape; overflow:hidden clips the fills to it.+ root: {+ position: 'relative',+ display: 'inline-flex',+ overflow: 'hidden',+ },+ fill: {+ position: 'absolute',+ top: 0,+ left: 0,+ width: '100%',+ height: '100%',+ },+ img: {+ opacity: 0,+ transition: `opacity ${fadeMs}ms ease-out`,+ '@media (prefers-reduced-motion: reduce)': { transition: 'none' },+ },+ imgVisible: { opacity: 1 },+ // Already-decoded blobs appear at once: fading them in would re-animate on every remount.+ imgInstant: { opacity: 1, transition: 'none' },+})++// Renders a cover through the shared useImageUrl blob cache, so it survives remounts without+// re-fetching. The image mounts only once its blob is ready, so it never renders broken.+export const Artwork = ({+ record,+ size = config.uiCoverArtSize,+ square = false,+ fit = 'cover',+ className,+ title,+ onClick,+}) => {+ const classes = useStyles()+ const url = record ? subsonic.getCoverArtUrl(record, size, square) : ''+ const { imgUrl, fromCache } = useImageUrl(url)++ const [decoded, setDecoded] = useState(false)+ const [faded, setFaded] = useState(false)+ const frame = useRef(0)+ useEffect(() => {+ setDecoded(false)+ setFaded(false)+ return () => cancelAnimationFrame(frame.current)+ }, [url])++ // Two frames: a blob decodes from memory, so onLoad can beat the first paint of opacity 0,+ // leaving the transition no start value and popping some tiles in while others fade.+ const handleLoad = () => {+ frame.current = requestAnimationFrame(() => {+ frame.current = requestAnimationFrame(() => setDecoded(true))+ })+ }++ // Timer, not transitionend: under prefers-reduced-motion there is no transition to end.+ useEffect(() => {+ if (!decoded || faded) return undefined+ const timer = setTimeout(() => setFaded(true), fadeMs)+ return () => clearTimeout(timer)+ }, [decoded, faded])++ if (!record) return null++ // A blob already cached paints on the first frame, so it skips the fade.+ const instant = fromCache+ // Kept mounted until the fade ends; swapping on blob arrival would flash an empty container.+ const showPlaceholder = !!record.thumbHash && !instant && !faded+ // A square request is padded, not cropped, so `contain` keeps placeholder and image aligned.+ const effectiveFit = square ? 'contain' : fit+ const ratio = record.imageWidth / record.imageHeight+ const handleClick = imgUrl && onClick ? onClick : undefined+ return (+ <div+ className={clsx(classes.root, className)}+ onClick={handleClick}+ style={{ cursor: handleClick ? 'pointer' : 'default' }}+ >+ {showPlaceholder && (+ <ThumbHashCanvas+ hash={record.thumbHash}+ ratio={ratio}+ fit={effectiveFit}+ className={classes.fill}+ />+ )}+ {imgUrl && (+ <img+ src={imgUrl}+ alt={title}+ title={title}+ className={clsx(+ classes.fill,+ classes.img,+ instant && classes.imgInstant,+ decoded && classes.imgVisible,+ )}+ style={{ objectFit: effectiveFit }}+ onLoad={handleLoad}+ />+ )}+ </div>+ )+}++Artwork.propTypes = {+ record: PropTypes.object,+ size: PropTypes.number,+ square: PropTypes.bool,+ fit: PropTypes.oneOf(['cover', 'contain']),+ className: PropTypes.string,+ title: PropTypes.string,+ onClick: PropTypes.func,+}diff --git a/ui/src/common/Artwork.test.jsx b/ui/src/common/Artwork.test.jsxnew file mode 100644index 000000000..18b3c916f--- /dev/null+++ b/ui/src/common/Artwork.test.jsx@@ -0,0 +1,232 @@+import { render, fireEvent, act } from '@testing-library/react'+import { describe, it, expect, vi, beforeEach } from 'vitest'++vi.mock('./useImageUrl', () => ({ useImageUrl: vi.fn() }))+vi.mock('../subsonic', () => ({+ default: {+ // Mirrors the real hash suffix, so a refreshed record yields a different URL.+ getCoverArtUrl: (record) =>+ '/rest/getCoverArt?id=al-1' ++ (record.imageHash ? `_${record.imageHash}` : ''),+ },+}))+vi.mock('../config', () => ({ default: { uiCoverArtSize: 300 } }))++import { useImageUrl } from './useImageUrl'+import { Artwork } from './Artwork'++const withArt = {+ id: 'al-1',+ name: 'Album',+ thumbHash: 'H/gNBxpwh4dwd3eIiHd3iHeHeJ+dcH8I',+}++describe('Artwork', () => {+ beforeEach(() => {+ vi.clearAllMocks()+ // jsdom has no 2D context; stub it so ThumbHashCanvas bails cleanly without console noise+ HTMLCanvasElement.prototype.getContext = vi.fn(() => null)+ })++ it('renders nothing without a record', () => {+ useImageUrl.mockReturnValue({ imgUrl: null, loading: false })+ const { container } = render(<Artwork record={null} />)+ expect(container.firstChild).toBeNull()+ })++ it('shows the placeholder and no <img> while loading', () => {+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })+ const { container } = render(<Artwork record={withArt} title="Album" />)+ expect(container.querySelector('canvas')).not.toBeNull()+ expect(container.querySelector('img')).toBeNull()+ })++ it('shows neither a broken <img> nor a canvas while loading a record with no thumbhash', () => {+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })+ const { container } = render(<Artwork record={{ id: 'al-2', name: 'X' }} />)+ expect(container.querySelector('img')).toBeNull()+ expect(container.querySelector('canvas')).toBeNull()+ })++ // The placeholder has to land exactly where the image will, or it jumps when the image swaps in.+ it('shapes the placeholder like the artwork and fits it like the image', () => {+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })+ const nonSquare = { ...withArt, imageWidth: 1200, imageHeight: 800 }+ const { container } = render(+ <Artwork record={nonSquare} fit="contain" title="Album" />,+ )+ const canvas = container.querySelector('canvas')+ expect(canvas.width).toBe(32)+ expect(canvas.height).toBe(21)+ expect(canvas.style.objectFit).toBe('contain')+ })++ // A square request is padded, not cropped, so the placeholder has to letterbox with it.+ it('letterboxes the placeholder when the server pads a non-square image to a square', () => {+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })+ const nonSquare = { ...withArt, imageWidth: 1200, imageHeight: 800 }+ const { container } = render(<Artwork record={nonSquare} square />)+ const canvas = container.querySelector('canvas')+ expect(canvas.width).toBe(32)+ expect(canvas.height).toBe(21)+ expect(canvas.style.objectFit).toBe('contain')+ })++ // The padded square is aspect-fit, so `square` overrides fit="cover" as it does for the canvas.+ it('fits the image itself with contain when the server padded to a square', () => {+ useImageUrl.mockReturnValue({+ imgUrl: 'blob:abc',+ loading: false,+ fromCache: true,+ })+ const { container } = render(+ <Artwork record={withArt} square fit="cover" title="Album" />,+ )+ expect(container.querySelector('img').style.objectFit).toBe('contain')+ })++ it('fills the box for square artwork, the overwhelmingly common case', () => {+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })+ const sq = { ...withArt, imageWidth: 600, imageHeight: 600 }+ const { container } = render(<Artwork record={sq} square />)+ const canvas = container.querySelector('canvas')+ expect(canvas.width).toBe(32)+ expect(canvas.height).toBe(32)+ })++ // Without dimensions the placeholder falls back to the aspect the hash itself carries.+ it('falls back to the hash own aspect when the record has no dimensions', () => {+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })+ const { container } = render(<Artwork record={withArt} />)+ const canvas = container.querySelector('canvas')+ expect(canvas.width).toBe(32)+ expect(canvas.height).toBe(32)+ })++ it('mounts the image only once its blob is ready', () => {+ useImageUrl.mockReturnValue({+ imgUrl: 'blob:abc',+ loading: false,+ fromCache: true,+ })+ const { container } = render(<Artwork record={withArt} title="Album" />)+ const img = container.querySelector('img')+ expect(img).not.toBeNull()+ expect(img.getAttribute('src')).toBe('blob:abc')+ })++ it('keeps the placeholder under the image until the fade ends', () => {+ vi.useFakeTimers()+ try {+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })+ const { container, rerender } = render(<Artwork record={withArt} />)++ useImageUrl.mockReturnValue({+ imgUrl: 'blob:abc',+ loading: false,+ fromCache: false,+ })+ rerender(<Artwork record={withArt} />)+ const img = container.querySelector('img')+ expect(img).not.toBeNull()+ expect(container.querySelector('canvas')).not.toBeNull()++ // The clock ends the fade, not transitionend, which never fires under reduced-motion.+ act(() => {+ fireEvent.load(img)+ })+ expect(container.querySelector('canvas')).not.toBeNull()+ act(() => {+ fireEvent.transitionEnd(img)+ })+ expect(container.querySelector('canvas')).not.toBeNull()+ // Two frames pass before the fade starts, so opacity 0 gets painted first.+ act(() => {+ vi.advanceTimersByTime(32)+ })+ expect(container.querySelector('canvas')).not.toBeNull()+ act(() => {+ vi.advanceTimersByTime(150)+ })+ expect(container.querySelector('canvas')).toBeNull()+ } finally {+ vi.useRealTimers()+ }+ })++ it('does not fade an image that was already cached on mount', () => {+ useImageUrl.mockReturnValue({+ imgUrl: 'blob:abc',+ loading: false,+ fromCache: true,+ })+ const { container } = render(<Artwork record={withArt} />)+ expect(container.querySelector('canvas')).toBeNull()+ expect(container.querySelector('img').className).toContain('imgInstant')+ })++ it('keeps the placeholder visible when the image never decodes', () => {+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })+ const { container, rerender } = render(<Artwork record={withArt} />)+ useImageUrl.mockReturnValue({+ imgUrl: 'blob:abc',+ loading: false,+ fromCache: false,+ })+ rerender(<Artwork record={withArt} />)++ expect(container.querySelector('canvas')).not.toBeNull()+ })++ it('fires onClick only when the image is loaded', () => {+ const onClick = vi.fn()+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })+ const { container, rerender } = render(+ <Artwork record={withArt} onClick={onClick} />,+ )+ container.firstChild.click()+ expect(onClick).not.toHaveBeenCalled()++ useImageUrl.mockReturnValue({+ imgUrl: 'blob:abc',+ loading: false,+ fromCache: false,+ })+ rerender(<Artwork record={withArt} onClick={onClick} />)+ container.firstChild.click()+ expect(onClick).toHaveBeenCalledTimes(1)+ })++ it('shows the placeholder for a cached fetch failure, which has no blob', () => {+ useImageUrl.mockReturnValue({+ imgUrl: null,+ loading: false,+ error: true,+ fromCache: false,+ })+ const { container } = render(<Artwork record={withArt} />)+ expect(container.querySelector('img')).toBeNull()+ expect(container.querySelector('canvas')).not.toBeNull()+ })++ it('falls back to the placeholder when a refresh swaps in an uncached hash', () => {+ useImageUrl.mockReturnValue({+ imgUrl: 'blob:old',+ loading: false,+ fromCache: true,+ })+ const cached = { ...withArt, imageHash: 'aaaa' }+ const { container, rerender } = render(<Artwork record={cached} />)+ expect(container.querySelector('canvas')).toBeNull()++ useImageUrl.mockReturnValue({+ imgUrl: null,+ loading: true,+ fromCache: false,+ })+ rerender(<Artwork record={{ ...withArt, imageHash: 'bbbb' }} />)++ expect(container.querySelector('img')).toBeNull()+ expect(container.querySelector('canvas')).not.toBeNull()+ })+})diff --git a/ui/src/common/ArtworkAvatar.jsx b/ui/src/common/ArtworkAvatar.jsxnew file mode 100644index 000000000..7691050c6--- /dev/null+++ b/ui/src/common/ArtworkAvatar.jsx@@ -0,0 +1,40 @@+import { useRecordContext } from 'react-admin'+import { makeStyles } from '@material-ui/core/styles'+import clsx from 'clsx'+import config from '../config'+import { Artwork } from './Artwork'++const useStyles = makeStyles({+ avatar: {+ width: '55px',+ height: '55px',+ },+ square: {+ borderRadius: '4px',+ },+ circular: {+ borderRadius: '50%',+ },+})++export const ArtworkAvatar = ({ record: recordProp, variant = 'circular' }) => {+ const classes = useStyles()+ const recordContext = useRecordContext()+ const record = recordProp || recordContext+ if (!record) return null+ const square = variant !== 'circular'+ return (+ <Artwork+ record={record}+ size={config.uiCoverArtSize}+ square={square}+ className={clsx(+ classes.avatar,+ square ? classes.square : classes.circular,+ )}+ title={record.name}+ />+ )+}++ArtworkAvatar.defaultProps = { label: '', sortable: false }diff --git a/ui/src/common/CoverArtAvatar.jsx b/ui/src/common/CoverArtAvatar.jsxdeleted file mode 100644index f70403774..000000000--- a/ui/src/common/CoverArtAvatar.jsx+++ /dev/null@@ -1,52 +0,0 @@-import { useRecordContext } from 'react-admin'-import { Avatar } from '@material-ui/core'-import { makeStyles } from '@material-ui/core/styles'-import clsx from 'clsx'-import config from '../config'-import subsonic from '../subsonic'-import { useImageUrl } from './useImageUrl'--const useStyles = makeStyles({- avatar: {- width: '55px',- height: '55px',- },- avatarEmpty: {- backgroundColor: 'transparent',- },- square: {- borderRadius: '4px',- },-})--export const CoverArtAvatar = ({- record: recordProp,- variant = 'circular',-}) => {- const classes = useStyles()- const recordContext = useRecordContext()- const record = recordProp || recordContext- const square = variant !== 'circular'- const url = record- ? subsonic.getCoverArtUrl(record, config.uiCoverArtSize, square)- : null- const { imgUrl } = useImageUrl(url)- if (!record) return null- return (- <Avatar- src={imgUrl || undefined}- variant={variant}- className={clsx(- classes.avatar,- square && classes.square,- !imgUrl && classes.avatarEmpty,- )}- alt={record.name}- >- {/* Empty child prevents default person icon while loading */}- {!imgUrl && <span />}- </Avatar>- )-}--CoverArtAvatar.defaultProps = { label: '', sortable: false }diff --git a/ui/src/common/ThumbHashCanvas.jsx b/ui/src/common/ThumbHashCanvas.jsxnew file mode 100644index 000000000..03d349313--- /dev/null+++ b/ui/src/common/ThumbHashCanvas.jsx@@ -0,0 +1,75 @@+import { useEffect, useRef } from 'react'+import PropTypes from 'prop-types'+import { decode, naturalSize } from '../utils/thumbhash'++// A thumbhash carries no detail beyond a few dozen pixels; CSS upscales the canvas.+const DECODE_SIZE = 32++// bitmapSize prefers the artwork's true ratio, falling back to the aspect the hash itself carries,+// which is quantised to a ratio of small integers and so only approximates the image.+const bitmapSize = (hash, ratio) => {+ if (!(ratio > 0) || !Number.isFinite(ratio)) {+ try {+ return naturalSize(hash)+ } catch {+ return { width: DECODE_SIZE, height: DECODE_SIZE }+ }+ }+ return ratio >= 1+ ? {+ width: DECODE_SIZE,+ height: Math.max(1, Math.round(DECODE_SIZE / ratio)),+ }+ : {+ width: Math.max(1, Math.round(DECODE_SIZE * ratio)),+ height: DECODE_SIZE,+ }+}++export const ThumbHashCanvas = ({ hash, ratio, fit, className, style }) => {+ const canvasRef = useRef(null)+ const { width, height } = bitmapSize(hash, ratio)++ useEffect(() => {+ if (!hash || !canvasRef.current) {+ return+ }+ const ctx = canvasRef.current.getContext('2d')+ if (!ctx) {+ return+ }+ // Clear first so a hash change that fails to decode never leaves a stale frame.+ ctx.clearRect(0, 0, width, height)+ try {+ const pixels = decode(hash, width, height)+ const imageData = ctx.createImageData(width, height)+ imageData.data.set(pixels)+ ctx.putImageData(imageData, 0, 0)+ } catch {+ // A malformed hash simply leaves the canvas blank.+ }+ }, [hash, width, height])++ if (!hash) {+ return null+ }+ return (+ <canvas+ ref={canvasRef}+ width={width}+ height={height}+ className={className}+ style={{ ...style, objectFit: fit }}+ aria-hidden="true"+ />+ )+}++ThumbHashCanvas.propTypes = {+ hash: PropTypes.string,+ // Aspect ratio (width / height) of the image this stands in for; the hash's own when omitted.+ ratio: PropTypes.number,+ fit: PropTypes.oneOf(['cover', 'contain']),+ className: PropTypes.string,+ style: PropTypes.object,+}diff --git a/ui/src/common/ThumbHashCanvas.test.jsx b/ui/src/common/ThumbHashCanvas.test.jsxnew file mode 100644index 000000000..b1f53fe5c--- /dev/null+++ b/ui/src/common/ThumbHashCanvas.test.jsx@@ -0,0 +1,95 @@+import { render } from '@testing-library/react'+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'+import { ThumbHashCanvas } from './ThumbHashCanvas'++// Golden hashes from core/artwork/thumbhash/testdata/golden.json.+const SQUARE = 'H/gNBxpwh4dwd3eIiHd3iHeHeJ+dcH8I'+const LANDSCAPE = '3wcOFJpwh4eBh3d4iIePgAj3hw=='++describe('ThumbHashCanvas', () => {+ // jsdom has no real 2D context; stub it (tracked) so specs can assert the draw path ran.+ let ctxMock+ let getContextSpy+ beforeEach(() => {+ ctxMock = {+ clearRect: vi.fn(),+ createImageData: vi.fn((w, h) => ({+ data: new Uint8ClampedArray(w * h * 4),+ })),+ putImageData: vi.fn(),+ }+ getContextSpy = vi+ .spyOn(HTMLCanvasElement.prototype, 'getContext')+ .mockReturnValue(ctxMock)+ })+ afterEach(() => {+ getContextSpy.mockRestore()+ })++ it('renders nothing without a hash', () => {+ const { container } = render(<ThumbHashCanvas hash="" />)+ expect(container.querySelector('canvas')).toBeNull()+ })++ it('decodes a valid hash and draws non-trivial pixel data', () => {+ const { container } = render(<ThumbHashCanvas hash={SQUARE} />)+ expect(container.querySelector('canvas')).not.toBeNull()+ expect(ctxMock.putImageData).toHaveBeenCalledTimes(1)+ const [imageData] = ctxMock.putImageData.mock.calls[0]+ expect(imageData.data.some((byte) => byte !== 0)).toBe(true)+ })++ it('decodes into a bitmap shaped like the image, so the blur is not distorted', () => {+ const { container } = render(+ <ThumbHashCanvas hash={SQUARE} ratio={1200 / 800} />,+ )+ expect(ctxMock.createImageData).toHaveBeenCalledWith(32, 21)+ const canvas = container.querySelector('canvas')+ expect(canvas.width).toBe(32)+ expect(canvas.height).toBe(21)+ })++ it('shapes a portrait ratio the other way round', () => {+ render(<ThumbHashCanvas hash={SQUARE} ratio={0.5} />)+ expect(ctxMock.createImageData).toHaveBeenCalledWith(16, 32)+ })++ it('never collapses an extreme ratio to a zero-sized bitmap', () => {+ render(<ThumbHashCanvas hash={SQUARE} ratio={200} />)+ expect(ctxMock.createImageData).toHaveBeenCalledWith(32, 1)+ })++ // Unlike a blurhash, a thumbhash carries its own approximate aspect, so an unknown ratio+ // falls back to that rather than to a square.+ it('falls back to the hash own aspect when the ratio is unknown', () => {+ render(<ThumbHashCanvas hash={LANDSCAPE} ratio={0} />)+ expect(ctxMock.createImageData).toHaveBeenCalledWith(32, 18)+ })++ it('applies the object-fit it is given, so it lands where the image will', () => {+ const { container } = render(+ <ThumbHashCanvas hash={SQUARE} ratio={1.5} fit="contain" />,+ )+ expect(container.querySelector('canvas').style.objectFit).toBe('contain')+ })++ it('renders a canvas without throwing on a malformed hash, and draws nothing', () => {+ const spy = vi.spyOn(console, 'error').mockImplementation(() => {})+ const { container } = render(+ <ThumbHashCanvas hash="!!!not-a-thumbhash!!!" />,+ )+ expect(container.querySelector('canvas')).not.toBeNull()+ expect(ctxMock.putImageData).not.toHaveBeenCalled()+ spy.mockRestore()+ })++ it('clears the canvas when a hash change fails to decode', () => {+ const { rerender } = render(<ThumbHashCanvas hash={SQUARE} />)+ expect(ctxMock.putImageData).toHaveBeenCalledTimes(1)++ rerender(<ThumbHashCanvas hash="!!!not-a-thumbhash!!!" />)++ expect(ctxMock.clearRect).toHaveBeenCalledTimes(2)+ expect(ctxMock.putImageData).toHaveBeenCalledTimes(1)+ })+})diff --git a/ui/src/common/index.js b/ui/src/common/index.jsindex c88ea3e9c..7b5b376f3 100644--- a/ui/src/common/index.js+++ b/ui/src/common/index.js@@ -46,6 +46,6 @@ export * from './ParticipantsInfo'export * from './OverflowTooltip'export * from './useSearchRefocus'export * from './ImageUploadOverlay'-export * from './CoverArtAvatar'+export * from './ArtworkAvatar'export * from './useImageLoadingState'export * from './useImageUrl'diff --git a/ui/src/common/useImageUrl.js b/ui/src/common/useImageUrl.jsindex 9bcc70d74..8a7f2bcc7 100644--- a/ui/src/common/useImageUrl.js+++ b/ui/src/common/useImageUrl.js@@ -43,6 +43,18 @@ export const useImageUrl = (url) => {const [error, setError] = useState(cached?.error || false)const abortedRef = useRef(false)+ // Resync during render: otherwise imgUrl holds the previous url's blob for one render, so only+ // fromCache can answer "already cached" - and a remembered failure has no blob to paint.+ const [fromCache, setFromCache] = useState(!!cached?.blobUrl)+ const [trackedUrl, setTrackedUrl] = useState(url)+ if (trackedUrl !== url) {+ setTrackedUrl(url)+ setImgUrl(cached?.blobUrl || null)+ setLoading(!!url && !cached)+ setError(cached?.error || false)+ setFromCache(!!cached?.blobUrl)+ }+useEffect(() => {abortedRef.current = false@@ -140,5 +152,5 @@ export const useImageUrl = (url) => {}}, [url])- return { imgUrl, loading, error }+ return { imgUrl, loading, error, fromCache }}diff --git a/ui/src/common/useImageUrl.test.js b/ui/src/common/useImageUrl.test.jsindex 976317105..818732d06 100644--- a/ui/src/common/useImageUrl.test.js+++ b/ui/src/common/useImageUrl.test.js@@ -200,6 +200,7 @@ describe('useImageUrl', () => {expect(global.fetch).toHaveBeenCalledTimes(1)expect(result2.current.imgUrl).toBe('blob:mock-url')expect(result2.current.loading).toBe(false)+ expect(result2.current.fromCache).toBe(true)})it('should cache errors and not re-fetch broken URLs', async () => {@@ -230,5 +231,7 @@ describe('useImageUrl', () => {expect(result2.current.error).toBe(true)expect(result2.current.imgUrl).toBeNull()expect(result2.current.loading).toBe(false)+ // A remembered failure has no blob, so callers must not treat it as instantly painted.+ expect(result2.current.fromCache).toBe(false)})})diff --git a/ui/src/common/useResourceRefresh.jsx b/ui/src/common/useResourceRefresh.jsxindex eabff6f92..b59ae8e88 100644--- a/ui/src/common/useResourceRefresh.jsx+++ b/ui/src/common/useResourceRefresh.jsx@@ -63,6 +63,9 @@ import { useRefresh, useDataProvider } from 'react-admin'* - Global refresh: { '*': '*' } or { someResource: ['*'] }* - Specific resources: { album: ['id1', 'id2'], song: ['id3'] }*/+// Resources whose records are media files, and so inherit their album's artwork.+const trackResources = ['song', 'playlistTrack']+export const useResourceRefresh = (...visibleResources) => {const [lastTime, setLastTime] = useState(Date.now())const refresh = useRefresh()@@ -70,6 +73,7 @@ export const useResourceRefresh = (...visibleResources) => {const refreshData = useSelector((state) => state.activity?.refresh || { lastReceived: lastTime },)+ const loadedResources = useSelector((state) => state.admin?.resources)const { resources, lastReceived } = refreshDataif (lastReceived <= lastTime) {@@ -77,21 +81,49 @@ export const useResourceRefresh = (...visibleResources) => {}setLastTime(lastReceived)- if (+ const isWatched = (r) =>+ visibleResources.length === 0 || visibleResources.includes(r)+ // A wildcard on a resource this component does not show is somebody else's business: reloading+ // the page for it throws away the list the user is looking at.+ const hasWildcard =resources &&(resources['*'] === '*' ||- Object.values(resources).find((v) => v.find((v2) => v2 === '*')))- ) {+ Object.entries(resources).some(+ ([r, ids]) => isWatched(r) && ids.includes?.('*'),+ ))++ if (hasWildcard) {refresh()return}- if (resources) {- Object.keys(resources).forEach((r) => {- if (visibleResources.length === 0 || visibleResources?.includes(r)) {- if (resources[r]?.length > 0) {- dataProvider.getMany(r, { ids: resources[r] })+ if (!resources) {+ return+ }+ Object.keys(resources).forEach((r) => {+ if (isWatched(r)) {+ if (resources[r]?.length > 0) {+ // Only refetch records already in the store; ones the UI never loaded will+ // arrive fresh (with the new artwork) when navigated to, so fetching them is wasteful.+ const loaded = loadedResources?.[r]?.data || {}+ const ids = resources[r].filter((id) => loaded[id] !== undefined)+ if (ids.length > 0) {+ dataProvider.getMany(r, { ids })}}+ }+ })++ // A track with no art of its own is served its album's, so an album's new coverArt id moves its+ // tracks' too. The dependent ids are unbounded server-side, but the store knows which are loaded.+ if (resources.album?.length > 0) {+ const albumIds = new Set(resources.album)+ trackResources.filter(isWatched).forEach((r) => {+ const ids = Object.values(loadedResources?.[r]?.data || {})+ .filter((t) => albumIds.has(t?.albumId))+ .map((t) => t.id)+ if (ids.length > 0) {+ dataProvider.getMany(r, { ids })+ }})}}diff --git a/ui/src/common/useResourceRefresh.test.js b/ui/src/common/useResourceRefresh.test.jsindex eabd478db..ccd729836 100644--- a/ui/src/common/useResourceRefresh.test.js+++ b/ui/src/common/useResourceRefresh.test.js@@ -38,6 +38,27 @@ describe('useResourceRefresh', () => {const useDataProviderMock = () => ({ getMany })let lastTime+ // Applies each real selector against a constructed store, so both useSelector+ // calls in the hook (refresh payload + loaded records) resolve correctly.+ const mockStore = ({ refresh: refreshPayload, loaded = {} }) => {+ const state = {+ activity: { refresh: refreshPayload },+ admin: { resources: loaded },+ }+ vi.spyOn(Redux, 'useSelector').mockImplementation((selector) =>+ selector(state),+ )+ }++ // Turns id lists into the react-admin store shape: { album: { data: { 'al-1': {...} } } }+ const asStore = (byResource) =>+ Object.fromEntries(+ Object.entries(byResource).map(([r, ids]) => [+ r,+ { data: Object.fromEntries(ids.map((id) => [id, { id }])) },+ ]),+ )+beforeEach(() => {vi.spyOn(React, 'useState').mockImplementation(useStateMock)vi.spyOn(RA, 'useRefresh').mockImplementation(useRefreshMock)@@ -50,8 +71,7 @@ describe('useResourceRefresh', () => {})it('stores last time checked, to avoid redundant runs', () => {- const useSelectorMock = () => ({ lastReceived: lastTime })- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)+ mockStore({ refresh: { lastReceived: lastTime } })useResourceRefresh()@@ -60,8 +80,7 @@ describe('useResourceRefresh', () => {it("does not run again if lastTime didn't change", () => {vi.spyOn(React, 'useState').mockImplementation(() => [lastTime, setState])- const useSelectorMock = () => ({ lastReceived: lastTime })- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)+ mockStore({ refresh: { lastReceived: lastTime } })useResourceRefresh()@@ -70,11 +89,9 @@ describe('useResourceRefresh', () => {describe('No visible resources specified', () => {it('triggers a UI refresh when received a "any" resource refresh', () => {- const useSelectorMock = () => ({- lastReceived: lastTime,- resources: { '*': '*' },+ mockStore({+ refresh: { lastReceived: lastTime, resources: { '*': '*' } },})- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)useResourceRefresh()@@ -83,11 +100,9 @@ describe('useResourceRefresh', () => {})it('triggers a UI refresh when received an "any" id', () => {- const useSelectorMock = () => ({- lastReceived: lastTime,- resources: { album: ['*'] },+ mockStore({+ refresh: { lastReceived: lastTime, resources: { album: ['*'] } },})- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)useResourceRefresh()@@ -95,12 +110,14 @@ describe('useResourceRefresh', () => {expect(getMany).not.toHaveBeenCalled()})- it('triggers a refetch of the resources received', () => {- const useSelectorMock = () => ({- lastReceived: lastTime,- resources: { album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] },+ it('refetches only the received resources already loaded in the store', () => {+ mockStore({+ refresh: {+ lastReceived: lastTime,+ resources: { album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] },+ },+ loaded: asStore({ album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] }),})- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)useResourceRefresh()@@ -109,15 +126,42 @@ describe('useResourceRefresh', () => {expect(getMany).toHaveBeenCalledWith('album', { ids: ['al-1', 'al-2'] })expect(getMany).toHaveBeenCalledWith('song', { ids: ['sg-1', 'sg-2'] })})++ it('skips ids that are not loaded in the store', () => {+ mockStore({+ refresh: {+ lastReceived: lastTime,+ resources: { album: ['al-1', 'al-2', 'al-3'] },+ },+ loaded: asStore({ album: ['al-2'] }),+ })++ useResourceRefresh()++ expect(getMany).toHaveBeenCalledTimes(1)+ expect(getMany).toHaveBeenCalledWith('album', { ids: ['al-2'] })+ })++ it('does not fetch when none of the received ids are loaded', () => {+ mockStore({+ refresh: {+ lastReceived: lastTime,+ resources: { artist: ['ar-1', 'ar-2'] },+ },+ loaded: asStore({ artist: ['ar-9'] }),+ })++ useResourceRefresh()++ expect(getMany).not.toHaveBeenCalled()+ })})describe('Visible resources specified', () => {it('triggers a UI refresh when received a "any" resource refresh', () => {- const useSelectorMock = () => ({- lastReceived: lastTime,- resources: { '*': '*' },+ mockStore({+ refresh: { lastReceived: lastTime, resources: { '*': '*' } },})- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)useResourceRefresh('album')@@ -125,12 +169,101 @@ describe('useResourceRefresh', () => {expect(getMany).not.toHaveBeenCalled()})- it('triggers a refetch of the resources received if they are visible', () => {- const useSelectorMock = () => ({- lastReceived: lastTime,- resources: { album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] },+ it('does not refresh the page when the wildcard is on a resource it does not watch', () => {+ // Guards other senders: a wildcard on an unwatched resource must not reload this list.+ mockStore({+ refresh: {+ lastReceived: lastTime,+ resources: { album: ['al-1', 'al-2'], song: ['*'] },+ },+ loaded: asStore({ album: ['al-1', 'al-2'] }),+ })++ useResourceRefresh('album')++ expect(refresh).not.toHaveBeenCalled()+ expect(getMany).toHaveBeenCalledWith('album', { ids: ['al-1', 'al-2'] })+ })++ it('refetches the loaded songs of a refreshed album', () => {+ // A track with no art of its own is served its album's, so its coverArt id moves with the+ // album's. The backend cannot know which tracks are loaded; the store can.+ mockStore({+ refresh: { lastReceived: lastTime, resources: { album: ['al-1'] } },+ loaded: {+ album: { data: { 'al-1': { id: 'al-1' } } },+ song: {+ data: {+ 'sg-1': { id: 'sg-1', albumId: 'al-1' },+ 'sg-2': { id: 'sg-2', albumId: 'al-2' },+ },+ },+ },+ })++ useResourceRefresh('song')++ expect(refresh).not.toHaveBeenCalled()+ expect(getMany).toHaveBeenCalledWith('song', { ids: ['sg-1'] })+ })++ it('fans an album refresh out to loaded playlist tracks, which have their own ids', () => {+ mockStore({+ refresh: { lastReceived: lastTime, resources: { album: ['al-1'] } },+ loaded: {+ playlistTrack: {+ data: {+ 'pt-1': { id: 'pt-1', albumId: 'al-1' },+ 'pt-2': { id: 'pt-2', albumId: 'al-2' },+ },+ },+ },+ })++ useResourceRefresh('playlistTrack', 'song', 'playlist')++ expect(refresh).not.toHaveBeenCalled()+ expect(getMany).toHaveBeenCalledWith('playlistTrack', { ids: ['pt-1'] })+ })++ it('does not fan out to track resources the component does not show', () => {+ mockStore({+ refresh: { lastReceived: lastTime, resources: { album: ['al-1'] } },+ loaded: {+ album: { data: { 'al-1': { id: 'al-1' } } },+ song: { data: { 'sg-1': { id: 'sg-1', albumId: 'al-1' } } },+ },+ })++ useResourceRefresh('album')++ expect(refresh).not.toHaveBeenCalled()+ expect(getMany).toHaveBeenCalledTimes(1)+ expect(getMany).toHaveBeenCalledWith('album', { ids: ['al-1'] })+ })++ it('does not refetch songs when no loaded song belongs to the refreshed album', () => {+ mockStore({+ refresh: { lastReceived: lastTime, resources: { album: ['al-9'] } },+ loaded: {+ song: { data: { 'sg-1': { id: 'sg-1', albumId: 'al-1' } } },+ },+ })++ useResourceRefresh('song')++ expect(refresh).not.toHaveBeenCalled()+ expect(getMany).not.toHaveBeenCalled()+ })++ it('refetches the received resources if they are visible and loaded', () => {+ mockStore({+ refresh: {+ lastReceived: lastTime,+ resources: { album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] },+ },+ loaded: asStore({ album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] }),})- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)useResourceRefresh('song')diff --git a/ui/src/playlist/PlaylistDetails.jsx b/ui/src/playlist/PlaylistDetails.jsxindex 894809ce0..5d0f6631e 100644--- a/ui/src/playlist/PlaylistDetails.jsx+++ b/ui/src/playlist/PlaylistDetails.jsx@@ -1,10 +1,5 @@-import {- Card,- CardContent,- CardMedia,- Typography,- useMediaQuery,-} from '@material-ui/core'+import { useState } from 'react'+import { Card, CardContent, Typography, useMediaQuery } from '@material-ui/core'import { makeStyles } from '@material-ui/core/styles'import { useTranslate } from 'react-admin'import Lightbox from 'react-image-lightbox'@@ -17,10 +12,9 @@ import {SizeField,isWritable,OverflowTooltip,- useImageLoadingState,} from '../common'-import config from '../config'import subsonic from '../subsonic'+import { Artwork } from '../common/Artwork'const useStyles = makeStyles((theme) => ({@@ -75,9 +69,6 @@ const useStyles = makeStyles(backgroundColor: 'transparent',transition: 'opacity 0.3s ease-in-out',},- coverLoading: {- opacity: 0.5,- },title: {overflow: 'hidden',textOverflow: 'ellipsis',@@ -107,37 +98,21 @@ const PlaylistDetails = (props) => {const translate = useTranslate()const classes = useStyles()const isDesktop = useMediaQuery((theme) => theme.breakpoints.up('lg'))- const {- imageLoading,- imageError,- isLightboxOpen,- handleImageLoad,- handleImageError,- handleOpenLightbox,- handleCloseLightbox,- } = useImageLoadingState(record.id)+ const [isLightboxOpen, setLightboxOpen] = useState(false)- const imageUrl = subsonic.getCoverArtUrl(record, config.uiCoverArtSize, true)const fullImageUrl = subsonic.getCoverArtUrl(record)return (<Card className={classes.root}><div className={classes.cardContents}><div className={classes.coverParent}>- <CardMedia- key={record.id} // Force re-render when playlist changes- component={'img'}- src={imageUrl}- width="400"- height="400"- className={`${classes.cover} ${imageLoading ? classes.coverLoading : ''}`}- onClick={handleOpenLightbox}- onLoad={handleImageLoad}- onError={handleImageError}+ <Artwork+ record={record}+ square+ fit="contain"+ className={classes.cover}title={record.name}- style={{- cursor: imageError ? 'default' : 'pointer',- }}+ onClick={() => setLightboxOpen(true)}/>{isWritable(record.ownerId) && (<ImageUploadOverlay@@ -187,13 +162,13 @@ const PlaylistDetails = (props) => {</CardContent></div></div>- {isLightboxOpen && !imageError && (+ {isLightboxOpen && (<LightboximagePadding={50}animationDuration={200}imageTitle={record.name}mainSrc={fullImageUrl}- onCloseRequest={handleCloseLightbox}+ onCloseRequest={() => setLightboxOpen(false)}/>)}</Card>diff --git a/ui/src/playlist/PlaylistList.jsx b/ui/src/playlist/PlaylistList.jsxindex 642d90dd5..d2b17b108 100644--- a/ui/src/playlist/PlaylistList.jsx+++ b/ui/src/playlist/PlaylistList.jsx@@ -20,7 +20,7 @@ import Switch from '@material-ui/core/Switch'import { makeStyles } from '@material-ui/core/styles'import { useMediaQuery } from '@material-ui/core'import {- CoverArtAvatar,+ ArtworkAvatar,DurationField,List,LoveButton,@@ -197,7 +197,7 @@ const PlaylistList = (props) => {bulkActionButtons={!isXsmall && <PlaylistListBulkActions />}><Datagrid rowClick="show" isRowSelectable={(r) => isWritable(r?.ownerId)}>- <CoverArtAvatar source="id" variant="square" />+ <ArtworkAvatar source="id" variant="square" /><TextField source="name" />{columns}<Writable>diff --git a/ui/src/playlist/PlaylistShow.jsx b/ui/src/playlist/PlaylistShow.jsxindex 4e269be18..4c2fea315 100644--- a/ui/src/playlist/PlaylistShow.jsx+++ b/ui/src/playlist/PlaylistShow.jsx@@ -35,7 +35,7 @@ const PlaylistShowLayout = (props) => {const { loading, ...context } = useShowContext(props)const { record } = contextconst classes = useStyles()- useResourceRefresh('song')+ useResourceRefresh('playlistTrack', 'song')return (<>diff --git a/ui/src/playlist/PlaylistSongs.jsx b/ui/src/playlist/PlaylistSongs.jsxindex bbe38b4d5..4718a7cf4 100644--- a/ui/src/playlist/PlaylistSongs.jsx+++ b/ui/src/playlist/PlaylistSongs.jsx@@ -100,7 +100,8 @@ const PlaylistSongs = ({ playlistId, readOnly, actions, ...props }) => {const dataProvider = useDataProvider()const notify = useNotify()const version = useVersion()- useResourceRefresh('song', 'playlist')+ // The rows are stored as playlistTrack, not song: their ids are playlist entries.+ useResourceRefresh('playlistTrack', 'song', 'playlist')useEffect(() => {setPage(1)diff --git a/ui/src/radio/RadioList.jsx b/ui/src/radio/RadioList.jsxindex ccdb9f1ef..0cfb2cd68 100644--- a/ui/src/radio/RadioList.jsx+++ b/ui/src/radio/RadioList.jsx@@ -18,11 +18,10 @@ import {List,defaultRowsPerPageOptions,getStoredPerPage,- useImageUrl,ToggleFieldsMenu,useSelectedFields,} from '../common'-import subsonic from '../subsonic'+import { Artwork } from '../common/Artwork'import { StreamField } from './StreamField'import { setTrack } from '../actions'import { songFromRadio } from './helper'@@ -83,15 +82,32 @@ const RadioListActions = ({const avatarStyle = { width: 40, height: 40 }+const useCoverStyles = makeStyles({+ cover: { width: 40, height: 40, borderRadius: '4px' },+})+const CoverArtField = ({ record }) => {- const directUrl = record?.uploadedImage- ? subsonic.getCoverArtUrl(record, 40, true)- : null- const { imgUrl } = useImageUrl(directUrl)+ const classes = useCoverStyles()if (!record) return null- const src = imgUrl || RADIO_PLACEHOLDER_IMAGE+ // Radios resolve art only from an uploaded image; otherwise show the generic radio icon.+ if (record.uploadedImage) {+ return (+ <Artwork+ record={record}+ size={40}+ square+ className={classes.cover}+ title={record.name}+ />+ )+ }return (- <Avatar src={src} variant="rounded" style={avatarStyle} alt={record.name} />+ <Avatar+ src={RADIO_PLACEHOLDER_IMAGE}+ variant="rounded"+ style={avatarStyle}+ alt={record.name}+ />)}CoverArtField.defaultProps = { label: '' }diff --git a/ui/src/subsonic/index.js b/ui/src/subsonic/index.jsindex 7d93972e0..9f0ad28d7 100644--- a/ui/src/subsonic/index.js+++ b/ui/src/subsonic/index.js@@ -81,25 +81,27 @@ const getAvatarUrl = (username, size) =>)const getCoverArtUrl = (record, size, square) => {+ const suffix = record.imageHash ? '_' + record.imageHash : ''const options = {- ...(record.updatedAt && { _: record.updatedAt }),+ // A hash-suffixed url is already pixel-versioned; the buster would defeat immutable caching.+ ...(!record.imageHash && record.updatedAt && { _: record.updatedAt }),...(size && { size }),...(square && { square }),}// TODO Move this logic to serverif (record.album) {- return baseUrl(url('getCoverArt', 'mf-' + record.id, options))+ return baseUrl(url('getCoverArt', 'mf-' + record.id + suffix, options))} else if (record.albumArtist) {- return baseUrl(url('getCoverArt', 'al-' + record.id, options))+ return baseUrl(url('getCoverArt', 'al-' + record.id + suffix, options))} else if (record.sync !== undefined) {// This is a playlist- return baseUrl(url('getCoverArt', 'pl-' + record.id, options))+ return baseUrl(url('getCoverArt', 'pl-' + record.id + suffix, options))} else if (record.streamUrl !== undefined) {// This is a radio station- return baseUrl(url('getCoverArt', 'ra-' + record.id, options))+ return baseUrl(url('getCoverArt', 'ra-' + record.id + suffix, options))} else {- return baseUrl(url('getCoverArt', 'ar-' + record.id, options))+ return baseUrl(url('getCoverArt', 'ar-' + record.id + suffix, options))}}diff --git a/ui/src/subsonic/index.test.js b/ui/src/subsonic/index.test.jsindex ad4764c24..32c699a41 100644--- a/ui/src/subsonic/index.test.js+++ b/ui/src/subsonic/index.test.js@@ -120,6 +120,47 @@ describe('getCoverArtUrl', () => {expect(url).toContain('ar-test-123')expect(url).not.toContain('_=')})++ it('appends the content hash to the artwork id', () => {+ const url = subsonic.getCoverArtUrl({+ id: 'album-123',+ albumArtist: 'AA',+ imageHash: '0123456789abcdef',+ })+ expect(url).toContain('al-album-123_0123456789abcdef')+ })++ it('drops the updatedAt buster once the url is hash-versioned', () => {+ const url = subsonic.getCoverArtUrl({+ id: 'album-123',+ albumArtist: 'AA',+ updatedAt: '2023-01-01T00:00:00Z',+ imageHash: '0123456789abcdef',+ })+ expect(url).toContain('al-album-123_0123456789abcdef')+ expect(url).not.toContain('_=')+ })++ it('keeps the updatedAt buster while artwork is unresolved', () => {+ const url = subsonic.getCoverArtUrl({+ id: 'album-123',+ albumArtist: 'AA',+ updatedAt: '2023-01-01T00:00:00Z',+ })+ expect(url).toContain('al-album-123')+ expect(url).toContain('_=')+ })++ it('still builds a url for known-absent artwork so the server placeholder renders', () => {+ // Returning '' here made <img src=undefined> render as a broken icon; the server serves a+ // proper placeholder for absent art, so the client must still request it.+ const url = subsonic.getCoverArtUrl({+ id: 'album-123',+ albumArtist: 'AA',+ imageAbsent: true,+ })+ expect(url).toContain('al-album-123')+ })})describe('getDiscCoverArtUrl', () => {diff --git a/ui/src/utils/thumbhash.js b/ui/src/utils/thumbhash.jsnew file mode 100644index 000000000..f4ec673d2--- /dev/null+++ b/ui/src/utils/thumbhash.js@@ -0,0 +1,138 @@+// ThumbHash decoder (https://github.com/evanw/thumbhash), kept byte-compatible with the reference:+// core/artwork/thumbhash/testdata/thumbhash.js pins the pixels the specs assert on.++const toBytes = (hash) => {+ if (typeof hash !== 'string' || hash === '') {+ throw new Error('thumbhash: empty hash')+ }+ const binary = atob(hash)+ const bytes = new Uint8Array(binary.length)+ for (let i = 0; i < binary.length; i++) {+ bytes[i] = binary.charCodeAt(i)+ }+ if (bytes.length < 5) {+ throw new Error('thumbhash: hash too short')+ }+ return bytes+}++// header unpacks the fixed 5-byte prefix plus the optional alpha byte.+const header = (bytes) => {+ const header24 = bytes[0] | (bytes[1] << 8) | (bytes[2] << 16)+ const header16 = bytes[3] | (bytes[4] << 8)+ const hasAlpha = header24 >> 23 !== 0+ if (hasAlpha && bytes.length < 6) {+ throw new Error('thumbhash: hash too short for alpha')+ }+ const isLandscape = header16 >> 15 !== 0+ const alphaLimit = hasAlpha ? 5 : 7+ return {+ lDC: (header24 & 63) / 63,+ pDC: ((header24 >> 6) & 63) / 31.5 - 1,+ qDC: ((header24 >> 12) & 63) / 31.5 - 1,+ lScale: ((header24 >> 18) & 31) / 31,+ hasAlpha,+ pScale: ((header16 >> 3) & 63) / 63,+ qScale: ((header16 >> 9) & 63) / 63,+ lx: Math.max(3, isLandscape ? alphaLimit : header16 & 7),+ ly: Math.max(3, isLandscape ? header16 & 7 : alphaLimit),+ aDC: hasAlpha ? (bytes[5] & 15) / 15 : 1,+ aScale: hasAlpha ? (bytes[5] >> 4) / 15 : 0,+ }+}++// naturalSize is the reference decoder's own output size: 32 on the long edge, at the aspect the+// hash approximates. Callers with the true dimensions should decode at those instead.+export const naturalSize = (hash) => {+ const { lx, ly } = header(toBytes(hash))+ const ratio = lx / ly+ return ratio > 1+ ? { width: 32, height: Math.round(32 / ratio) }+ : { width: Math.round(32 * ratio), height: 32 }+}++const cosTable = (n, size) => {+ const table = new Float64Array(n * size)+ for (let c = 0; c < n; c++) {+ for (let i = 0; i < size; i++) {+ table[c * size + i] = Math.cos((Math.PI / size) * (i + 0.5) * c)+ }+ }+ return table+}++export const decode = (hash, width, height) => {+ const bytes = toBytes(hash)+ const h = header(bytes)+ if (!(width > 0) || !(height > 0)) {+ throw new Error('thumbhash: width and height must be positive')+ }++ const acStart = h.hasAlpha ? 6 : 5+ let acIndex = 0+ const channel = (nx, ny, scale) => {+ const ac = []+ for (let cy = 0; cy < ny; cy++) {+ for (let cx = cy ? 0 : 1; cx * ny < nx * (ny - cy); cx++) {+ const byte = bytes[acStart + (acIndex >> 1)] ?? 0+ ac.push((((byte >> ((acIndex++ & 1) << 2)) & 15) / 7.5 - 1) * scale)+ }+ }+ return ac+ }+ // The 1.25x chroma boost is the reference's quantisation compensation, not a free parameter.+ const lAC = channel(h.lx, h.ly, h.lScale)+ const pAC = channel(3, 3, h.pScale * 1.25)+ const qAC = channel(3, 3, h.qScale * 1.25)+ const aAC = h.hasAlpha ? channel(5, 5, h.aScale) : []++ const nx = Math.max(h.lx, h.hasAlpha ? 5 : 3)+ const ny = Math.max(h.ly, h.hasAlpha ? 5 : 3)+ const fx = cosTable(nx, width)+ const fy = cosTable(ny, height)++ const pixels = new Uint8ClampedArray(width * height * 4)+ for (let y = 0; y < height; y++) {+ for (let x = 0; x < width; x++) {+ let l = h.lDC+ let p = h.pDC+ let q = h.qDC+ let a = h.aDC++ for (let cy = 0, j = 0; cy < h.ly; cy++) {+ const fy2 = fy[cy * height + y] * 2+ for (let cx = cy ? 0 : 1; cx * h.ly < h.lx * (h.ly - cy); cx++, j++) {+ l += lAC[j] * fx[cx * width + x] * fy2+ }+ }+ for (let cy = 0, j = 0; cy < 3; cy++) {+ const fy2 = fy[cy * height + y] * 2+ for (let cx = cy ? 0 : 1; cx < 3 - cy; cx++, j++) {+ const f = fx[cx * width + x] * fy2+ p += pAC[j] * f+ q += qAC[j] * f+ }+ }+ if (h.hasAlpha) {+ for (let cy = 0, j = 0; cy < 5; cy++) {+ const fy2 = fy[cy * height + y] * 2+ for (let cx = cy ? 0 : 1; cx < 5 - cy; cx++, j++) {+ a += aAC[j] * fx[cx * width + x] * fy2+ }+ }+ }++ const b = l - (2 / 3) * p+ const r = (3 * l - b + q) / 2+ const g = r - q+ const idx = 4 * x + y * width * 4+ // Explicit floor: the reference writes into a Uint8Array, which truncates, while the+ // Uint8ClampedArray that createImageData needs would round.+ pixels[idx] = Math.floor(Math.max(0, 255 * Math.min(1, r)))+ pixels[idx + 1] = Math.floor(Math.max(0, 255 * Math.min(1, g)))+ pixels[idx + 2] = Math.floor(Math.max(0, 255 * Math.min(1, b)))+ pixels[idx + 3] = Math.floor(Math.max(0, 255 * Math.min(1, a)))+ }+ }+ return pixels+}diff --git a/ui/src/utils/thumbhash.test.js b/ui/src/utils/thumbhash.test.jsnew file mode 100644index 000000000..6abb4d7e4--- /dev/null+++ b/ui/src/utils/thumbhash.test.js@@ -0,0 +1,66 @@+import { describe, it, expect } from 'vitest'+import { decode, naturalSize } from './thumbhash'++// Digests pinned from evanw/thumbhash's reference decoder (vendored at+// core/artwork/thumbhash/testdata/thumbhash.js), so any drift from it fails here.+const fnv = (bytes) => {+ let h = 2166136261 >>> 0+ for (const b of bytes) {+ h ^= b+ h = Math.imul(h, 16777619) >>> 0+ }+ return h.toString(16)+}++const REFERENCE = [+ ['alpha', 'JOiFBQ4nkIexh3p4iA8uB+lYhIeAh3d4dw==', 32, 32, '500141bc'],+ ['landscape', '3wcOFJpwh4eBh3d4iIePgAj3hw==', 32, 18, '18465aed'],+ ['portrait', '3/cNFBqBB4iId4d3d4iAjwj4hw==', 18, 32, '56500cc1'],+ ['solid', 'HoUBBwB4eHeHd3hweId3h3h4B2+Ih4gA', 32, 32, '39cc5c5'],+ ['square', 'H/gNBxpwh4dwd3eIiHd3iHeHeJ+dcH8I', 32, 32, '740d8afc'],+ ['tiny', 'HoU9tx4I9wiIh4hwj3CI+AiIcH/494cP', 32, 32, 'f2555987'],+]++describe('thumbhash decode', () => {+ it.each(REFERENCE)(+ 'reproduces the reference pixels for %s',+ (_name, hash, w, h, digest) => {+ expect(fnv(decode(hash, w, h))).toEqual(digest)+ },+ )++ it.each(REFERENCE)(+ 'reports the reference natural size for %s',+ (_name, hash, w, h) => {+ expect(naturalSize(hash)).toEqual({ width: w, height: h })+ },+ )++ it('decodes to any requested grid, not just the natural one', () => {+ const [, hash] = REFERENCE[4]+ const pixels = decode(hash, 8, 5)+ expect(pixels).toHaveLength(8 * 5 * 4)+ // Opaque hash: every alpha byte is saturated.+ for (let i = 3; i < pixels.length; i += 4) {+ expect(pixels[i]).toBe(255)+ }+ })++ it('carries alpha through for a hash that has it', () => {+ const [, hash, w, h] = REFERENCE[0]+ const pixels = decode(hash, w, h)+ const alphas = new Set()+ for (let i = 3; i < pixels.length; i += 4) {+ alphas.add(pixels[i])+ }+ expect(alphas.size).toBeGreaterThan(1)+ })++ it.each([+ ['empty', ''],+ ['too short to hold a header', 'AAAA'],+ ['not base64', '!!!not-a-thumbhash!!!'],+ ])('throws on a hash that is %s', (_name, hash) => {+ expect(() => decode(hash, 32, 32)).toThrow()+ })+})diff --git a/utils/cache/file_caches.go b/utils/cache/file_caches.goindex ed2374696..33fa046df 100644--- a/utils/cache/file_caches.go+++ b/utils/cache/file_caches.go@@ -2,8 +2,10 @@ package cacheimport ("context"+ "errors""fmt""io"+ "io/fs""path/filepath""sync""sync/atomic"@@ -158,6 +160,13 @@ func (fc *fileCache) Get(ctx context.Context, arg Item) (*CachedStream, error) {key := arg.Key()r, w, err := fc.cache.Get(key)+ if errors.Is(err, fs.ErrNotExist) {+ // The entry outlived its data file. Drop it and retry, or every future Get+ // for this key fails for the rest of the process's life.+ log.Debug(ctx, "Cache entry lost its data file. Re-fetching", "cache", fc.name, "key", key)+ _ = fc.invalidate(ctx, key)+ r, w, err = fc.cache.Get(key)+ }if err != nil {return nil, err}diff --git a/utils/cache/file_caches_test.go b/utils/cache/file_caches_test.goindex edcfbc6b9..7ce1b0393 100644--- a/utils/cache/file_caches_test.go+++ b/utils/cache/file_caches_test.go@@ -7,6 +7,7 @@ import ("os""path/filepath""strings"+ "sync/atomic""github.com/navidrome/navidrome/conf""github.com/navidrome/navidrome/conf/configtest"@@ -278,6 +279,92 @@ var _ = Describe("File Caches", func() {}).Should(BeTrue())})})++ Context("entry outliving its data file", func() {+ It("re-fetches when the data file vanished behind the cache's back", func() {+ var calls atomic.Int32+ fc := callNewFileCache("test", "10MB", "test", 0, func(ctx context.Context, arg Item) (io.Reader, error) {+ calls.Add(1)+ return strings.NewReader("payload"), nil+ })++ s, err := fc.Get(context.Background(), &testArg{"vanish"})+ Expect(err).To(BeNil())+ Expect(io.ReadAll(s)).To(Equal([]byte("payload")))+ Expect(s.Close()).To(Succeed())++ dataPath := fcSpreadFS(fc).KeyMapper((&testArg{"vanish"}).Key())+ Eventually(func() error { _, e := os.Stat(dataPath); return e }).Should(Succeed())+ Expect(os.Remove(dataPath)).To(Succeed())++ s2, err := fc.Get(context.Background(), &testArg{"vanish"})+ Expect(err).ToNot(HaveOccurred())+ Expect(io.ReadAll(s2)).To(Equal([]byte("payload")))+ _ = s2.Close()+ Expect(calls.Load()).To(BeNumerically("==", 2))+ })++ It("survives an invalidated entry's deferred file removal", func() {+ // invalidate() drops the map entry but defers the unlink until readers close;+ // a Get in that window re-creates the file, which the deferred unlink then eats.+ var n atomic.Int32+ fc := callNewFileCache("test", "10MB", "test", 0, func(ctx context.Context, arg Item) (io.Reader, error) {+ if n.Add(1) == 1 {+ return &partialThenErrReader{data: []byte("PARTIAL"), err: errors.New("died")}, nil+ }+ return strings.NewReader("GOOD"), nil+ })++ key := (&testArg{"deferred"}).Key()+ s1, err := fc.Get(context.Background(), &testArg{"deferred"})+ Expect(err).To(BeNil())++ // The failed write invalidates the entry; the removal now waits on s1.+ Eventually(func() bool { return fc.cache.Exists(key) }).Should(BeFalse())++ s2, err := fc.Get(context.Background(), &testArg{"deferred"})+ Expect(err).To(BeNil())+ Expect(io.ReadAll(s2)).To(Equal([]byte("GOOD")))+ Expect(s2.Close()).To(Succeed())++ Expect(s1.Close()).To(Succeed())++ dataPath := fcSpreadFS(fc).KeyMapper(key)+ Eventually(func() bool {+ _, e := os.Stat(dataPath)+ return os.IsNotExist(e)+ }).Should(BeTrue(), "expected the deferred removal to take the re-created file")++ s3, err := fc.Get(context.Background(), &testArg{"deferred"})+ Expect(err).ToNot(HaveOccurred())+ Expect(io.ReadAll(s3)).To(Equal([]byte("GOOD")))+ _ = s3.Close()+ })++ It("re-fetches when an adopted entry's data file vanished", func() {+ // Entries adopted on startup take a different code path than in-process ones.+ var calls atomic.Int32+ fc := callNewFileCache("test", "10MB", "test", 0, func(ctx context.Context, arg Item) (io.Reader, error) {+ calls.Add(1)+ return strings.NewReader("payload"), nil+ })+ dataPath := fcSpreadFS(fc).KeyMapper((&testArg{"adopted"}).Key())+ Expect(os.MkdirAll(filepath.Dir(dataPath), 0755)).To(Succeed())+ Expect(os.WriteFile(dataPath, []byte("payload"), 0600)).To(Succeed())+ Expect(fcSpreadFS(fc).MarkComplete(dataPath)).To(Succeed())++ adopted := callNewFileCache("test2", "10MB", "test", 0, func(ctx context.Context, arg Item) (io.Reader, error) {+ calls.Add(1)+ return strings.NewReader("payload"), nil+ })+ Expect(os.Remove(dataPath)).To(Succeed())++ s, err := adopted.Get(context.Background(), &testArg{"adopted"})+ Expect(err).ToNot(HaveOccurred())+ Expect(io.ReadAll(s)).To(Equal([]byte("payload")))+ _ = s.Close()+ })+ })})})diff --git a/utils/cache/spread_fs.go b/utils/cache/spread_fs.goindex 647439790..11801b324 100644--- a/utils/cache/spread_fs.go+++ b/utils/cache/spread_fs.go@@ -128,7 +128,7 @@ func (sfs *spreadFS) Create(name string) (stream.File, error) {if err != nil {return nil, err}- return os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)+ return createDataFile(name)}func (sfs *spreadFS) Open(name string) (stream.File, error) {diff --git a/utils/cache/spread_fs_test.go b/utils/cache/spread_fs_test.goindex 0f88d3a58..d0b54567d 100644--- a/utils/cache/spread_fs_test.go+++ b/utils/cache/spread_fs_test.go@@ -1,10 +1,13 @@package cacheimport (+ "io""os""path/filepath"+ "runtime""strings"+ "github.com/djherbis/stream". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega")@@ -39,6 +42,39 @@ var _ = Describe("Spread FS", func() {})})+ Describe("Create", func() {+ It("leaves an already-open reader's bytes intact", func() {+ // Shrinking a file an older stream still serves spins its reader at a premature EOF.+ if runtime.GOOS == "windows" {+ Skip("Windows cannot unlink a file with open handles, so Create reuses the inode")+ }+ name := filepath.Join(rootDir, "aa", "bb", "data")+ s, err := stream.NewStream(name, fs)+ Expect(err).To(BeNil())+ _, err = s.Write([]byte("PARTIAL"))+ Expect(err).To(BeNil())+ r, err := s.NextReader()+ Expect(err).To(BeNil())+ Expect(s.Close()).To(Succeed())++ f, err := fs.Create(name)+ Expect(err).To(BeNil())+ _, err = f.Write([]byte("GOOD"))+ Expect(err).To(BeNil())+ Expect(f.Close()).To(Succeed())++ done := make(chan []byte, 1)+ go func() {+ b, _ := io.ReadAll(r)+ done <- b+ }()+ Eventually(done).Should(Receive(Equal([]byte("PARTIAL"))))+ Expect(r.Close()).To(Succeed())++ Expect(os.ReadFile(name)).To(Equal([]byte("GOOD")))+ })+ })+Describe("MarkComplete / Remove markers", func() {It("creates a .complete marker for a data file", func() {data := fs.KeyMapper("song1")diff --git a/utils/cache/spread_fs_unix.go b/utils/cache/spread_fs_unix.gonew file mode 100644index 000000000..c7cb19cf8--- /dev/null+++ b/utils/cache/spread_fs_unix.go@@ -0,0 +1,18 @@+//go:build !windows++package cache++import (+ "os"++ "github.com/djherbis/stream"+)++// createDataFile unlinks instead of truncating, so a re-created entry gets a fresh+// inode and readers still holding the old one see its full contents.+func createDataFile(name string) (stream.File, error) {+ if err := os.Remove(name); err != nil && !os.IsNotExist(err) {+ return nil, err+ }+ return os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)+}diff --git a/utils/cache/spread_fs_windows.go b/utils/cache/spread_fs_windows.gonew file mode 100644index 000000000..ca4186d65--- /dev/null+++ b/utils/cache/spread_fs_windows.go@@ -0,0 +1,15 @@+//go:build windows++package cache++import (+ "os"++ "github.com/djherbis/stream"+)++// createDataFile truncates in place: Windows refuses to unlink a file another handle+// has open, and failing the create would break every miss on a path with a live reader.+func createDataFile(name string) (stream.File, error) {+ return os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)+}