diff --git a/model/errors.go b/model/errors.go index b3f07565f..7e1837e03 100644 --- a/model/errors.go +++ b/model/errors.go @@ -14,4 +14,5 @@ var ( ErrNotAvailable = errors.New("functionality not available") ErrValidation = errors.New("validation error") ErrPlaylistNotEditable = errors.New("playlist tracks are not editable") + ErrIncompleteQueue = errors.New("could not load all play queue tracks") ) diff --git a/persistence/playqueue_repository.go b/persistence/playqueue_repository.go index bd73461d2..c26adfad3 100644 --- a/persistence/playqueue_repository.go +++ b/persistence/playqueue_repository.go @@ -3,6 +3,7 @@ package persistence import ( "context" "errors" + "fmt" "strings" "time" @@ -83,6 +84,9 @@ func (r *playQueueRepository) RetrieveWithMediaFiles(ctx context.Context, userId stored := q.Items var loadErr error q.Items, loadErr = r.loadTracks(ctx, stored) + if loadErr != nil && err == nil { + err = fmt.Errorf("%w: %w", model.ErrIncompleteQueue, loadErr) + } if loadErr == nil && len(q.Items) < len(stored) { q.Current, q.Position = remapCurrent(stored, q.Items, q.Current, q.Position) } diff --git a/persistence/playqueue_repository_test.go b/persistence/playqueue_repository_test.go index ce64cd7ac..3d27290d1 100644 --- a/persistence/playqueue_repository_test.go +++ b/persistence/playqueue_repository_test.go @@ -309,6 +309,21 @@ var _ = Describe("PlayQueueRepository", func() { AssertPlayQueue(expected, actual) }) + It("returns ErrIncompleteQueue with the queue as stored when the tracks fail to load", func() { + Expect(repo.Store(ctx, aPlayQueue("userid", 1, 45, songComeTogether, songDayInALife))).To(Succeed()) + tx, err := GetDBXBuilder().Begin() + Expect(err).ToNot(HaveOccurred()) + DeferCleanup(func() { _ = tx.Rollback() }) + _, err = tx.NewQuery("ALTER TABLE media_file RENAME TO media_file_unavailable").Execute() + Expect(err).ToNot(HaveOccurred()) + + actual, err := NewPlayQueueRepository(tx).RetrieveWithMediaFiles(ctx, "userid") + Expect(err).To(MatchError(model.ErrIncompleteQueue)) + Expect(actual.Items).To(BeEmpty()) + Expect(actual.Current).To(Equal(1)) + Expect(actual.Position).To(Equal(int64(45))) + }) + Context("when tracks are no longer in the library", func() { var mfRepo model.MediaFileRepository gone := songRadioactivity diff --git a/server/nativeapi/queue.go b/server/nativeapi/queue.go index 2c716ed0d..cf1bd2977 100644 --- a/server/nativeapi/queue.go +++ b/server/nativeapi/queue.go @@ -86,7 +86,7 @@ func getQueue(ds model.DataStore) http.HandlerFunc { user, _ := request.UserFrom(ctx) repo := ds.PlayQueue() pq, err := repo.RetrieveWithMediaFiles(ctx, user.ID) - if err != nil && !errors.Is(err, model.ErrNotFound) { + if err != nil && !errors.Is(err, model.ErrNotFound) && !errors.Is(err, model.ErrIncompleteQueue) { log.Error(ctx, "Error retrieving queue", err) http.Error(w, err.Error(), http.StatusInternalServerError) return diff --git a/server/nativeapi/queue_test.go b/server/nativeapi/queue_test.go index cc89b2963..30f14582f 100644 --- a/server/nativeapi/queue_test.go +++ b/server/nativeapi/queue_test.go @@ -3,6 +3,7 @@ package nativeapi import ( "bytes" "encoding/json" + "fmt" "net/http" "net/http/httptest" @@ -151,6 +152,20 @@ var _ = Describe("Queue Endpoints", func() { Expect(resp.Position).To(Equal(int64(0))) }) + It("returns the loaded tracks when some of them fail to load", func() { + repo.Queue = &model.PlayQueue{UserID: user.ID, Items: model.MediaFiles{{ID: "track1"}}} + repo.WithMediaFilesErr = fmt.Errorf("%w: chunk failed", model.ErrIncompleteQueue) + req := httptest.NewRequest("GET", "/queue", nil) + req = req.WithContext(request.WithUser(req.Context(), user)) + w := httptest.NewRecorder() + + getQueue(ds)(w, req) + Expect(w.Code).To(Equal(http.StatusOK)) + var resp model.PlayQueue + Expect(json.Unmarshal(w.Body.Bytes(), &resp)).To(Succeed()) + Expect(resp.Items).To(HaveLen(1)) + }) + It("returns internal server error when retrieve fails", func() { repo.Err = true req := httptest.NewRequest("GET", "/queue", nil) @@ -223,6 +238,13 @@ var _ = Describe("Queue Endpoints", func() { Expect(put(updateQueuePayload{Current: new(2)})).To(Equal(http.StatusBadRequest)) }) + It("refuses to update current when the tracks fail to load", func() { + repo.WithMediaFilesErr = fmt.Errorf("%w: chunk failed", model.ErrIncompleteQueue) + Expect(put(updateQueuePayload{Current: new(0)})).To(Equal(http.StatusInternalServerError)) + Expect(repo.LastCols).To(BeNil()) + Expect(repo.Queue.Current).To(Equal(2)) + }) + It("keeps the current track and position the client saw when only ids change", func() { Expect(put(updateQueuePayload{Ids: new([]string{"s1", "s2", "s3"})})).To(Equal(http.StatusNoContent)) Expect(repo.Queue.Current).To(Equal(1)) diff --git a/server/subsonic/bookmarks.go b/server/subsonic/bookmarks.go index 6a4c4962d..2d93e5688 100644 --- a/server/subsonic/bookmarks.go +++ b/server/subsonic/bookmarks.go @@ -82,7 +82,7 @@ func (api *Router) GetPlayQueue(r *http.Request) (*responses.Subsonic, error) { repo := api.ds.PlayQueue() pq, err := repo.RetrieveWithMediaFiles(r.Context(), user.ID) - if err != nil && !errors.Is(err, model.ErrNotFound) { + if err != nil && !errors.Is(err, model.ErrNotFound) && !errors.Is(err, model.ErrIncompleteQueue) { return nil, err } if pq == nil || len(pq.Items) == 0 { @@ -153,7 +153,7 @@ func (api *Router) GetPlayQueueByIndex(r *http.Request) (*responses.Subsonic, er repo := api.ds.PlayQueue() pq, err := repo.RetrieveWithMediaFiles(r.Context(), user.ID) - if err != nil && !errors.Is(err, model.ErrNotFound) { + if err != nil && !errors.Is(err, model.ErrNotFound) && !errors.Is(err, model.ErrIncompleteQueue) { return nil, err } if pq == nil || len(pq.Items) == 0 { diff --git a/server/subsonic/bookmarks_test.go b/server/subsonic/bookmarks_test.go index 387ba6ab2..a5c989692 100644 --- a/server/subsonic/bookmarks_test.go +++ b/server/subsonic/bookmarks_test.go @@ -2,6 +2,7 @@ package subsonic import ( "context" + "fmt" "github.com/navidrome/navidrome/model" "github.com/navidrome/navidrome/model/request" @@ -45,4 +46,27 @@ var _ = Describe("Bookmarks", func() { Expect(mfRepo.BookmarksAdded).To(ConsistOf("visible")) }) }) + + Context("when some queued tracks fail to load", func() { + BeforeEach(func() { + ds.MockedPlayQueue = &tests.MockPlayQueueRepo{ + Queue: &model.PlayQueue{UserID: "u1", Items: model.MediaFiles{{ID: "visible"}}}, + WithMediaFilesErr: fmt.Errorf("%w: chunk failed", model.ErrIncompleteQueue), + } + }) + + It("getPlayQueue returns the loaded tracks", func() { + resp, err := router.GetPlayQueue(newGetRequest().WithContext(ctx)) + + Expect(err).ToNot(HaveOccurred()) + Expect(resp.PlayQueue.Entry).To(HaveLen(1)) + }) + + It("getPlayQueueByIndex returns the loaded tracks", func() { + resp, err := router.GetPlayQueueByIndex(newGetRequest().WithContext(ctx)) + + Expect(err).ToNot(HaveOccurred()) + Expect(resp.PlayQueueByIndex.Entry).To(HaveLen(1)) + }) + }) }) diff --git a/tests/mock_playqueue_repo.go b/tests/mock_playqueue_repo.go index 22dd31516..ea44509b5 100644 --- a/tests/mock_playqueue_repo.go +++ b/tests/mock_playqueue_repo.go @@ -12,8 +12,10 @@ type MockPlayQueueRepo struct { Queue *model.PlayQueue // QueueWithMediaFiles, when set, is what RetrieveWithMediaFiles returns, to simulate tracks the user can't see QueueWithMediaFiles *model.PlayQueue - Err bool - LastCols []string + // WithMediaFilesErr is returned by RetrieveWithMediaFiles together with the queue + WithMediaFilesErr error + Err bool + LastCols []string } func (m *MockPlayQueueRepo) Store(_ context.Context, q *model.PlayQueue, cols ...string) error { @@ -44,7 +46,7 @@ func (m *MockPlayQueueRepo) RetrieveWithMediaFiles(_ context.Context, userId str copy(copyItems, src.Items) qCopy := *src qCopy.Items = copyItems - return &qCopy, nil + return &qCopy, m.WithMediaFilesErr } func (m *MockPlayQueueRepo) Retrieve(_ context.Context, userId string) (*model.PlayQueue, error) {