mirror of
https://github.com/navidrome/navidrome.git
synced 2026-08-01 07:21:17 +00:00
c9c363523b
The prune read-lock wrapped all of processItem, including external fetches under their own timeout. Since a pending RWMutex writer blocks new readers, one prune arriving behind a slow provider stalled every subsequent item in both drain pools. Extract persist() so the lock covers only the window it protects: store placement plus the two row writes. The in-flight set guarded against a queue row appearing twice in one batch, but artwork_queue's primary key makes that impossible, drains are serial per pool, and the pools' kind lists are disjoint. Removing it also retires the cancellation unwind loop that existed only to release those claims.
464 lines
19 KiB
Go
464 lines
19 KiB
Go
package artwork
|
||
|
||
import (
|
||
"context"
|
||
"encoding/binary"
|
||
"errors"
|
||
"hash/crc32"
|
||
"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"
|
||
)
|
||
|
||
// pngHeaderWithDims builds just a PNG signature + IHDR chunk declaring w×h. DecodeConfig
|
||
// reads the header without touching pixel data, so the body 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("processItem", 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
|
||
deps *workerDeps
|
||
)
|
||
|
||
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())
|
||
deps = &workerDeps{ds: ds, store: store, agents: ag, ffmpeg: ffm}
|
||
|
||
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, _ := processItem(ctx, deps, 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())
|
||
_, 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{}
|
||
deps.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, _ := processItem(ctx, deps, 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 processItem returns")
|
||
})
|
||
|
||
// Resolution can reach the network under its own timeout, 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, _ := processItem(ctx, deps, 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, _ := processItem(ctx, deps, 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, _ := processItem(ctx, deps, 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 healthy library whose folder listing names a cover the FS will not hand over —
|
||
// what a stale mount looks like from here.
|
||
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, _ := processItem(ctx, deps, 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 other source, so an unreadable one must neither settle absent
|
||
// nor let a lower-priority image take its place.
|
||
It("failed-on-unreadable-upload: an upload that will not open never records absent", func() {
|
||
if runtime.GOOS == "windows" {
|
||
// os.Chmod cannot revoke read access there, so the file would open and the spec
|
||
// would pass on the decode error instead of the unreadable source.
|
||
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, _ := processItem(ctx, deps, 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, _ := processItem(ctx, deps, 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, _ := processItem(ctx, deps, 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, _ := processItem(ctx, deps, 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())
|
||
|
||
// External art is content-addressed into the store, not file-backed.
|
||
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, _ := processItem(ctx, deps, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al5"})
|
||
Expect(out1).To(Equal(outcomeFound))
|
||
ia1, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al5", model.ImageTypePrimary)
|
||
Expect(err).ToNot(HaveOccurred())
|
||
|
||
// Poison the stored blurhash: if the second item re-decodes instead of
|
||
// deduping on hash, this sentinel gets overwritten by a real computed value.
|
||
poisoned := artRepo.Data[ia1.Hash]
|
||
poisoned.BlurHash = "SENTINEL"
|
||
artRepo.Data[ia1.Hash] = poisoned
|
||
|
||
out2, _ := processItem(ctx, deps, 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() {
|
||
// Two distinct library files with byte-identical content resolve to the same
|
||
// hash. Provenance is per-item, so neither file's path may overwrite the other.
|
||
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, _ := processItem(ctx, deps, 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()))
|
||
|
||
// Poison the shared row's blurhash: the second item must dedup on hash, not re-decode.
|
||
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, _ = processItem(ctx, deps, 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()))
|
||
|
||
// The first item's provenance survives the second item processing identical bytes.
|
||
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()))
|
||
|
||
// One shared artwork row, and dedup preserved it untouched.
|
||
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, _ := processItem(ctx, deps, 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, _ := processItem(ctx, deps, 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 it cannot be slipped by dimensions whose product
|
||
// would overflow. No supported format can declare such dimensions today — image/png caps
|
||
// them at 2^30-1 and the rest are 16-bit — 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())
|
||
deps.store = NewImageStore(blockedRoot)
|
||
|
||
out, _ := processItem(ctx, deps, 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))
|
||
})
|
||
})
|
||
|
||
// countingLocker stands in for the worker's prune read-lock, recording how often and how long
|
||
// processItem holds it.
|
||
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 }
|