🎧 Your Personal Streaming Service
Go airsonicmadsonicmedia-servermusicmusic-servernavidromeopensubsonicraspberry-piself-hostedstreamerstreaming-apistreaming-audiosubsonicsubsonic-server
fix(transcoding): cap concurrent transcodes to prevent ffmpeg DoS (#5522)
Deluan Quintão945d0ba1e2dd
diff --git a/conf/configuration.go b/conf/configuration.goindex 6fff1641a..b4c43f135 100644--- a/conf/configuration.go+++ b/conf/configuration.go@@ -113,6 +113,7 @@ type configOptions struct {PID pidOptions `json:",omitzero"`Inspect inspectOptions `json:",omitzero"`Subsonic subsonicOptions `json:",omitzero"`+ Transcoding transcodingOptions `json:",omitzero"`LastFM lastfmOptions `json:",omitzero"`Deezer deezerOptions `json:",omitzero"`ListenBrainz listenBrainzOptions `json:",omitzero"`@@ -165,6 +166,11 @@ type scannerOptions struct {PurgeMissing string // Values: "never", "always", "full"}+type transcodingOptions struct {+ MaxConcurrent int+ MaxConcurrentPerUser int+}+type subsonicOptions struct {AppendSubtitle boolAppendAlbumVersion bool@@ -822,6 +828,8 @@ func setViperDefaults() {viper.SetDefault("subsonic.enableaveragerating", true)viper.SetDefault("subsonic.legacyclients", "DSub")viper.SetDefault("subsonic.minimalclients", "SubMusic")+ viper.SetDefault("transcoding.maxconcurrent", 0)+ viper.SetDefault("transcoding.maxconcurrentperuser", 0)viper.SetDefault("agents", "deezer,lastfm,listenbrainz")viper.SetDefault("lastfm.enabled", true)viper.SetDefault("lastfm.language", consts.DefaultInfoLanguage)diff --git a/core/archiver.go b/core/archiver.goindex 96cc2c31e..5d1c090cd 100644--- a/core/archiver.go+++ b/core/archiver.go@@ -3,6 +3,7 @@ package coreimport ("archive/zip""context"+ "errors""fmt""io""os"@@ -60,7 +61,15 @@ func (a *archiver) zipAlbums(ctx context.Context, id string, format string, bitr"format", format, "bitrate", bitrate, "isMultiDisc", isMultiDisc, "numTracks", len(album))for _, mf := range album {file := a.albumFilename(mf, format, isMultiDisc)- _ = a.addFileToZip(ctx, z, mf, format, bitrate, file)+ if addErr := a.addFileToZip(ctx, z, mf, format, bitrate, file); errors.Is(addErr, stream.ErrTooManyTranscodes) {+ // Stop iterating: continuing would just rack up more+ // rejections from the limiter. Close finalises whatever+ // tracks were already written; the rejected one is not+ // present in the archive (addFileToZip aborts before+ // writing its entry header).+ _ = z.Close()+ return addErr+ }}}err = z.Close()@@ -120,7 +129,12 @@ func (a *archiver) zipMediaFiles(ctx context.Context, id, name string, format stzippedMfs := make(model.MediaFiles, len(mfs))for idx, mf := range mfs {file := a.playlistFilename(mf, format, idx)- _ = a.addFileToZip(ctx, z, mf, format, bitrate, file)+ if addErr := a.addFileToZip(ctx, z, mf, format, bitrate, file); errors.Is(addErr, stream.ErrTooManyTranscodes) {+ // Abort the whole archive: continuing would silently emit+ // empty zip entries since the headers are already written.+ _ = z.Close()+ return addErr+ }mf.Path = filezippedMfs[idx] = mf}@@ -162,17 +176,12 @@ func (a *archiver) playlistFilename(mf model.MediaFile, format string, idx int)func (a *archiver) addFileToZip(ctx context.Context, z *zip.Writer, mf model.MediaFile, format string, bitrate int, filename string) error {path := mf.AbsolutePath()- w, err := z.CreateHeader(&zip.FileHeader{- Name: filename,- Modified: mf.UpdatedAt,- Method: zip.Store,- })- if err != nil {- log.Error(ctx, "Error creating zip entry", "file", path, err)- return err- }+ // Open the source before writing the zip entry header so a rejection+ // (limiter, missing file, etc.) does not leave an empty entry in the+ // archive.var r io.ReadCloser+ var err errorif format != "raw" && format != "" {r, err = a.ms.NewStream(ctx, &mf, stream.Request{Format: format, BitRate: bitrate})} else {@@ -182,13 +191,22 @@ func (a *archiver) addFileToZip(ctx context.Context, z *zip.Writer, mf model.Medlog.Error(ctx, "Error opening file for zipping", "file", path, "format", format, err)return err}-defer func() {if err := r.Close(); err != nil && log.IsGreaterOrEqualTo(log.LevelDebug) {log.Error(ctx, "Error closing stream", "id", mf.ID, "file", path, err)}}()+ w, err := z.CreateHeader(&zip.FileHeader{+ Name: filename,+ Modified: mf.UpdatedAt,+ Method: zip.Store,+ })+ if err != nil {+ log.Error(ctx, "Error creating zip entry", "file", path, err)+ return err+ }+_, err = io.Copy(w, r)if err != nil {log.Error(ctx, "Error zipping file", "file", path, err)diff --git a/core/archiver_test.go b/core/archiver_test.goindex 4f7aed278..f432139d8 100644--- a/core/archiver_test.go+++ b/core/archiver_test.go@@ -89,6 +89,32 @@ var _ = Describe("Archiver", func() {})})+ Context("when the transcode limiter rejects a file", func() {+ It("aborts the archive instead of continuing with empty entries", func() {+ mfs := model.MediaFiles{+ {Path: "test_data/01 - track1.mp3", Suffix: "mp3", AlbumID: "1", Album: "Album", DiscNumber: 1},+ {Path: "test_data/02 - track2.mp3", Suffix: "mp3", AlbumID: "1", Album: "Album", DiscNumber: 1},+ }++ mfRepo := &mockMediaFileRepository{}+ mfRepo.On("GetAll", []model.QueryOptions{{+ Filters: squirrel.Eq{"album_id": "1"},+ Sort: "album",+ }}).Return(mfs, nil)+ ds.On("MediaFile", mock.Anything).Return(mfRepo)++ ms.On("NewStream", mock.Anything, mock.Anything, stream.Request{Format: "mp3", BitRate: 128}).+ Return(nil, stream.ErrTooManyTranscodes).Once()++ out := new(bytes.Buffer)+ err := arch.ZipAlbum(context.Background(), "1", "mp3", 128, out)+ Expect(err).To(MatchError(stream.ErrTooManyTranscodes))+ // NewStream should only have been called once: the loop must bail+ // out on the rejection instead of trying every remaining track.+ ms.AssertNumberOfCalls(GinkgoT(), "NewStream", 1)+ })+ })+Context("ZipShare", func() {It("zips a share correctly", func() {mfs := model.MediaFiles{diff --git a/core/stream/limiter.go b/core/stream/limiter.gonew file mode 100644index 000000000..622fe21cc--- /dev/null+++ b/core/stream/limiter.go@@ -0,0 +1,135 @@+package stream++import (+ "context"+ "errors"+ "io"+ "sync"+ "sync/atomic"+)++// ErrTooManyTranscodes is returned by TranscodeLimiter.Acquire when the+// configured concurrency cap has been reached. Callers should translate this+// into an HTTP 429 response so well-behaved clients back off and retry.+var ErrTooManyTranscodes = errors.New("too many concurrent transcodes")++// RetryAfterSeconds is the value returned in the HTTP Retry-After header when+// a request is rejected with ErrTooManyTranscodes. Most transcodes finish well+// within this window, so retrying after this delay typically succeeds.+const RetryAfterSeconds = 5++// TranscodeLimiter gates the number of concurrent ffmpeg transcodes. It enforces+// both a global cap (to protect the host from process exhaustion) and an optional+// per-user cap (to keep one client from starving the others). Acquire never+// blocks: it either reserves a slot or returns ErrTooManyTranscodes immediately.+type TranscodeLimiter interface {+ // Acquire reserves a slot for the given user. On success it returns a release+ // function that must be called exactly once when the transcode is done.+ // Calling release more than once is safe and idempotent.+ Acquire(ctx context.Context, user string) (release func(), err error)++ // Enabled reports whether the limiter actually enforces any cap. Callers+ // can use it to decide whether to bind ffmpeg's lifetime to the request+ // context so disconnects free slots quickly, rather than letting the+ // process drain to completion in the background.+ Enabled() bool+}++// NewTranscodeLimiter returns a limiter enforcing the given caps. Each cap is+// independent: a value of zero or less disables that cap. When both caps are+// disabled the limiter is a no-op.+func NewTranscodeLimiter(maxConcurrent, maxPerUser int) TranscodeLimiter {+ if maxConcurrent <= 0 && maxPerUser <= 0 {+ return noopLimiter{}+ }+ l := &transcodeLimiter{maxPerUser: maxPerUser}+ if maxConcurrent > 0 {+ l.global = make(chan struct{}, maxConcurrent)+ }+ if maxPerUser > 0 {+ l.perUser = make(map[string]int)+ }+ return l+}++// releasingReadCloser wraps an io.ReadCloser so that closing it also releases+// the limiter slot exactly once. release must be the function returned by+// TranscodeLimiter.Acquire; its own idempotency makes double-Close safe too.+type releasingReadCloser struct {+ io.ReadCloser+ release func()+}++func (r *releasingReadCloser) Close() error {+ err := r.ReadCloser.Close()+ r.release()+ return err+}++type noopLimiter struct{}++func (noopLimiter) Acquire(context.Context, string) (func(), error) {+ return func() {}, nil+}++func (noopLimiter) Enabled() bool { return false }++type transcodeLimiter struct {+ maxPerUser int+ global chan struct{}++ mu sync.Mutex+ perUser map[string]int+}++func (*transcodeLimiter) Enabled() bool { return true }++func (l *transcodeLimiter) Acquire(_ context.Context, user string) (func(), error) {+ // Reserve a per-user slot first so a noisy user can't burn through+ // global slots only to be rejected later. An empty user key means+ // "anonymous" (e.g. public share viewers); we skip the per-user cap+ // entirely so unrelated anonymous clients do not share a bucket.+ perUserActive := l.maxPerUser > 0 && user != ""+ if perUserActive {+ l.mu.Lock()+ if l.perUser[user] >= l.maxPerUser {+ l.mu.Unlock()+ return nil, ErrTooManyTranscodes+ }+ l.perUser[user]+++ l.mu.Unlock()+ }++ if l.global != nil {+ select {+ case l.global <- struct{}{}:+ default:+ if perUserActive {+ l.releasePerUser(user)+ }+ return nil, ErrTooManyTranscodes+ }+ }++ var released atomic.Bool+ return func() {+ if !released.CompareAndSwap(false, true) {+ return+ }+ if l.global != nil {+ <-l.global+ }+ if perUserActive {+ l.releasePerUser(user)+ }+ }, nil+}++func (l *transcodeLimiter) releasePerUser(user string) {+ l.mu.Lock()+ defer l.mu.Unlock()+ l.perUser[user]--+ if l.perUser[user] <= 0 {+ delete(l.perUser, user)+ }+}diff --git a/core/stream/limiter_test.go b/core/stream/limiter_test.gonew file mode 100644index 000000000..d278d47c8--- /dev/null+++ b/core/stream/limiter_test.go@@ -0,0 +1,186 @@+package stream_test++import (+ "context"+ "errors"+ "sync"++ "github.com/navidrome/navidrome/core/stream"+ "github.com/navidrome/navidrome/log"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++var _ = Describe("TranscodeLimiter", func() {+ ctx := log.NewContext(context.TODO())++ Describe("Disabled (both caps <= 0)", func() {+ It("never blocks and never returns ErrTooManyTranscodes", func() {+ lim := stream.NewTranscodeLimiter(0, 0)+ for range 100 {+ rel, err := lim.Acquire(ctx, "alice")+ Expect(err).ToNot(HaveOccurred())+ Expect(rel).ToNot(BeNil())+ }+ })+ })++ Describe("Per-user cap only (no global cap)", func() {+ It("still enforces the per-user limit when MaxConcurrent is disabled", func() {+ lim := stream.NewTranscodeLimiter(0, 2)++ rel1, err := lim.Acquire(ctx, "alice")+ Expect(err).ToNot(HaveOccurred())+ rel2, err := lim.Acquire(ctx, "alice")+ Expect(err).ToNot(HaveOccurred())++ _, err = lim.Acquire(ctx, "alice")+ Expect(errors.Is(err, stream.ErrTooManyTranscodes)).To(BeTrue())++ // Other users have their own buckets.+ rel3, err := lim.Acquire(ctx, "bob")+ Expect(err).ToNot(HaveOccurred())++ rel1()+ _, err = lim.Acquire(ctx, "alice")+ Expect(err).ToNot(HaveOccurred())++ rel2()+ rel3()+ })+ })++ Describe("Global cap", func() {+ It("rejects requests beyond MaxConcurrent with ErrTooManyTranscodes", func() {+ lim := stream.NewTranscodeLimiter(2, 0)++ rel1, err := lim.Acquire(ctx, "alice")+ Expect(err).ToNot(HaveOccurred())+ rel2, err := lim.Acquire(ctx, "bob")+ Expect(err).ToNot(HaveOccurred())++ _, err = lim.Acquire(ctx, "carol")+ Expect(errors.Is(err, stream.ErrTooManyTranscodes)).To(BeTrue())++ rel1()+ _, err = lim.Acquire(ctx, "carol")+ Expect(err).ToNot(HaveOccurred())++ rel2()+ })++ It("releases a slot only once even if release is called multiple times", func() {+ lim := stream.NewTranscodeLimiter(1, 0)++ rel, err := lim.Acquire(ctx, "alice")+ Expect(err).ToNot(HaveOccurred())++ rel()+ rel()+ rel()++ // After releases, exactly one slot should be available.+ _, err = lim.Acquire(ctx, "alice")+ Expect(err).ToNot(HaveOccurred())+ _, err = lim.Acquire(ctx, "alice")+ Expect(errors.Is(err, stream.ErrTooManyTranscodes)).To(BeTrue())+ })+ })++ Describe("Per-user cap", func() {+ It("rejects a user beyond MaxConcurrentPerUser even if global slots remain", func() {+ lim := stream.NewTranscodeLimiter(10, 2)++ rel1, err := lim.Acquire(ctx, "alice")+ Expect(err).ToNot(HaveOccurred())+ rel2, err := lim.Acquire(ctx, "alice")+ Expect(err).ToNot(HaveOccurred())++ _, err = lim.Acquire(ctx, "alice")+ Expect(errors.Is(err, stream.ErrTooManyTranscodes)).To(BeTrue())++ // A different user is unaffected.+ rel3, err := lim.Acquire(ctx, "bob")+ Expect(err).ToNot(HaveOccurred())++ rel1()+ _, err = lim.Acquire(ctx, "alice")+ Expect(err).ToNot(HaveOccurred())++ rel2()+ rel3()+ })++ It("skips the per-user cap for anonymous users (empty key)", func() {+ // Anonymous requests (e.g. public share viewers) deliberately+ // bypass the per-user cap so unrelated anonymous clients are not+ // collapsed into a single shared bucket. The global cap remains+ // the only ceiling on anonymous traffic.+ lim := stream.NewTranscodeLimiter(10, 1)++ rels := make([]func(), 0, 5)+ for range 5 {+ rel, err := lim.Acquire(ctx, "")+ Expect(err).ToNot(HaveOccurred())+ rels = append(rels, rel)+ }+ for _, rel := range rels {+ rel()+ }+ })++ It("still applies the global cap to anonymous users", func() {+ lim := stream.NewTranscodeLimiter(2, 1)++ rel1, err := lim.Acquire(ctx, "")+ Expect(err).ToNot(HaveOccurred())+ rel2, err := lim.Acquire(ctx, "")+ Expect(err).ToNot(HaveOccurred())++ _, err = lim.Acquire(ctx, "")+ Expect(errors.Is(err, stream.ErrTooManyTranscodes)).To(BeTrue())++ rel1()+ rel2()+ })+ })++ Describe("Concurrent safety", func() {+ It("survives parallel Acquire/release with consistent counts", func() {+ lim := stream.NewTranscodeLimiter(5, 0)++ var wg sync.WaitGroup+ var acquired int64+ var rejected int64+ var mu sync.Mutex++ for i := range 50 {+ wg.Add(1)+ go func(i int) {+ defer wg.Done()+ rel, err := lim.Acquire(ctx, "alice")+ mu.Lock()+ if err == nil {+ acquired+++ mu.Unlock()+ rel()+ } else {+ rejected+++ mu.Unlock()+ }+ _ = i+ }(i)+ }+ wg.Wait()++ Expect(acquired + rejected).To(Equal(int64(50)))+ // After all releases, all 5 slots should be free again.+ for range 5 {+ _, err := lim.Acquire(ctx, "alice")+ Expect(err).ToNot(HaveOccurred())+ }+ _, err := lim.Acquire(ctx, "alice")+ Expect(errors.Is(err, stream.ErrTooManyTranscodes)).To(BeTrue())+ })+ })+})diff --git a/core/stream/media_streamer.go b/core/stream/media_streamer.goindex de03b4d2f..f898e066e 100644--- a/core/stream/media_streamer.go+++ b/core/stream/media_streamer.go@@ -2,6 +2,7 @@ package streamimport ("context"+ "errors""fmt""io""mime"@@ -28,13 +29,19 @@ type MediaStreamer interface {type TranscodingCache cache.FileCachefunc NewMediaStreamer(ds model.DataStore, t ffmpeg.FFmpeg, cache TranscodingCache) MediaStreamer {- return &mediaStreamer{ds: ds, transcoder: t, cache: cache}+ return &mediaStreamer{+ ds: ds,+ transcoder: t,+ cache: cache,+ limiter: NewTranscodeLimiter(conf.Server.Transcoding.MaxConcurrent, conf.Server.Transcoding.MaxConcurrentPerUser),+ }}type mediaStreamer struct {ds model.DataStoretranscoder ffmpeg.FFmpegcache cache.FileCache+ limiter TranscodeLimiter}type streamJob struct {@@ -104,7 +111,12 @@ func (ms *mediaStreamer) NewStream(ctx context.Context, mf *model.MediaFile, req}r, err := ms.cache.Get(ctx, job)if err != nil {- log.Error(ctx, "Error accessing transcoding cache", "id", mf.ID, err)+ // Rate-limit rejections are already logged at warn level by the+ // producer; treating them as cache failures here would both+ // double-log and mask actual cache problems.+ if !errors.Is(err, ErrTooManyTranscodes) {+ log.Error(ctx, "Error accessing transcoding cache", "id", mf.ID, err)+ }return nil, err}cached = r.Cached@@ -217,15 +229,31 @@ func NewTranscodingCache() TranscodingCache {return nil, os.ErrInvalid}- // Choose the appropriate context based on EnableTranscodingCancellation configuration.- // This is where we decide whether transcoding processes should be cancellable or not.+ release, err := job.ms.limiter.Acquire(ctx, limiterKey(ctx))+ if err != nil {+ log.Warn(ctx, "Refusing transcode: concurrent transcode limit reached",+ "id", job.mf.ID, "user", userName(ctx),+ "maxConcurrent", conf.Server.Transcoding.MaxConcurrent,+ "maxPerUser", conf.Server.Transcoding.MaxConcurrentPerUser)+ return nil, err+ }++ // Choose the context that drives the ffmpeg process.+ //+ // When the limiter is enabled, force the request context so a+ // client disconnect cancels ffmpeg and frees the slot promptly.+ // Otherwise a client could open many transcodes, disconnect+ // immediately, and still leave the configured cap's worth of+ // ffmpeg processes draining in the background — which is exactly+ // the DoS the limiter is meant to prevent.+ //+ // When the limiter is disabled, preserve the legacy behavior+ // governed by EnableTranscodingCancellation so this PR does not+ // change observable behavior for operators who have not opted in.var transcodingCtx context.Context- if conf.Server.EnableTranscodingCancellation {- // Use the request context directly, allowing cancellation when client disconnects+ if job.ms.limiter.Enabled() || conf.Server.EnableTranscodingCancellation {transcodingCtx = ctx} else {- // Use background context with request values preserved.- // This prevents cancellation but maintains request metadata (user, client, etc.)transcodingCtx = request.AddValues(context.Background(), ctx)}@@ -240,10 +268,14 @@ func NewTranscodingCache() TranscodingCache {Offset: job.offset,})if err != nil {+ release()log.Error(ctx, "Error starting transcoder", "id", job.mf.ID, err)return nil, os.ErrInvalid}- return out, nil+ // Tie the slot to the ffmpeg process: copyAndClose calls Close+ // on this reader after io.Copy returns, which is exactly when+ // ffmpeg has exited (either EOF or context cancellation).+ return &releasingReadCloser{ReadCloser: out, release: release}, nil})}@@ -255,3 +287,16 @@ func userName(ctx context.Context) string {return user.UserName}}++// limiterKey returns the per-user bucket key used by the transcode limiter.+// For anonymous requests (e.g. public shares) it returns the empty string,+// which signals the limiter to skip the per-user cap entirely — otherwise+// every anonymous viewer of a public share would collide on the same key+// and starve each other within MaxConcurrentPerUser slots. The global cap+// still applies and remains the protection against runaway anonymous load.+func limiterKey(ctx context.Context) string {+ if user, ok := request.UserFrom(ctx); ok {+ return user.UserName+ }+ return ""+}diff --git a/core/stream/media_streamer_test.go b/core/stream/media_streamer_test.goindex 1bbf868fa..676e8d6f8 100644--- a/core/stream/media_streamer_test.go+++ b/core/stream/media_streamer_test.go@@ -2,6 +2,7 @@ package stream_testimport ("context"+ "errors""io""os"@@ -10,6 +11,7 @@ import ("github.com/navidrome/navidrome/core/stream""github.com/navidrome/navidrome/log""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"@@ -61,6 +63,58 @@ var _ = Describe("MediaStreamer", func() {Expect(s.Seekable()).To(BeFalse())Expect(s.Duration()).To(Equal(float32(257.0)))})+ It("rejects transcode requests beyond MaxConcurrent with ErrTooManyTranscodes", func() {+ // Rebuild the streamer with a tight cap. The first request will hold the+ // ffmpeg reader open (we don't read/close it), saturating the single slot.+ conf.Server.Transcoding.MaxConcurrent = 1+ conf.Server.Transcoding.MaxConcurrentPerUser = 0+ tightStreamer := stream.NewMediaStreamer(ds, ffmpeg, stream.NewTranscodingCache())++ userCtx := request.WithUsername(ctx, "alice")+ s1, err := tightStreamer.NewStream(userCtx, mf, stream.Request{Format: "mp3", BitRate: 64})+ Expect(err).ToNot(HaveOccurred())+ defer s1.Close()++ // Different cache key so it doesn't dedupe with the first request.+ _, err = tightStreamer.NewStream(userCtx, mf, stream.Request{Format: "mp3", BitRate: 96})+ Expect(errors.Is(err, stream.ErrTooManyTranscodes)).To(BeTrue())+ })++ It("releases the slot once the stream is closed", func() {+ conf.Server.Transcoding.MaxConcurrent = 1+ conf.Server.Transcoding.MaxConcurrentPerUser = 0+ tightStreamer := stream.NewMediaStreamer(ds, ffmpeg, stream.NewTranscodingCache())++ userCtx := request.WithUsername(ctx, "alice")+ s1, err := tightStreamer.NewStream(userCtx, mf, stream.Request{Format: "mp3", BitRate: 64})+ Expect(err).ToNot(HaveOccurred())+ _, _ = io.ReadAll(s1)+ _ = s1.Close()+ Eventually(func() bool { return ffmpeg.IsClosed() }, "3s").Should(BeTrue())++ // Slot should now be free for a different transcode.+ s2, err := tightStreamer.NewStream(userCtx, mf, stream.Request{Format: "mp3", BitRate: 96})+ Expect(err).ToNot(HaveOccurred())+ defer s2.Close()+ })++ It("does not consume a slot for raw streams", func() {+ conf.Server.Transcoding.MaxConcurrent = 1+ conf.Server.Transcoding.MaxConcurrentPerUser = 0+ tightStreamer := stream.NewMediaStreamer(ds, ffmpeg, stream.NewTranscodingCache())++ userCtx := request.WithUsername(ctx, "alice")+ // First, saturate the single transcode slot.+ s1, err := tightStreamer.NewStream(userCtx, mf, stream.Request{Format: "mp3", BitRate: 64})+ Expect(err).ToNot(HaveOccurred())+ defer s1.Close()++ // Raw stream must still succeed.+ s2, err := tightStreamer.NewStream(userCtx, mf, stream.Request{Format: "raw"})+ Expect(err).ToNot(HaveOccurred())+ defer s2.Close()+ })+It("returns a seekable stream if the file is complete in the cache", func() {s, err := streamer.NewStream(ctx, mf, stream.Request{Format: "mp3", BitRate: 32})Expect(err).To(BeNil())diff --git a/server/public/handle_streams.go b/server/public/handle_streams.goindex 7d5a836b3..c7b8a4d4f 100644--- a/server/public/handle_streams.go+++ b/server/public/handle_streams.go@@ -7,7 +7,7 @@ import ("time""github.com/navidrome/navidrome/core/auth"- "github.com/navidrome/navidrome/core/stream"+ streampkg "github.com/navidrome/navidrome/core/stream""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model". "github.com/navidrome/navidrome/utils/gg"@@ -48,10 +48,15 @@ func (pub *Router) handleStream(w http.ResponseWriter, r *http.Request) {return}- stream, err := pub.streamer.NewStream(ctx, mf, stream.Request{+ stream, err := pub.streamer.NewStream(ctx, mf, streampkg.Request{Format: info.format, BitRate: info.bitrate,})if err != nil {+ if errors.Is(err, streampkg.ErrTooManyTranscodes) {+ w.Header().Set("Retry-After", strconv.Itoa(streampkg.RetryAfterSeconds))+ http.Error(w, "too many concurrent transcodes, please retry shortly", http.StatusTooManyRequests)+ return+ }log.Error(ctx, "Error starting shared stream", err)http.Error(w, "invalid request", http.StatusInternalServerError)returndiff --git a/server/subsonic/api.go b/server/subsonic/api.goindex 7d15125b6..f39dec009 100644--- a/server/subsonic/api.go+++ b/server/subsonic/api.go@@ -7,6 +7,7 @@ import ("fmt""net/http""regexp"+ "strconv""github.com/go-chi/chi/v5""github.com/navidrome/navidrome/conf"@@ -304,6 +305,8 @@ func mapToSubsonicError(err error) subError {err = newError(responses.ErrorDataNotFound, "data not found")case errors.Is(err, model.ErrNotAuthorized):err = newError(responses.ErrorAuthorizationFail)+ case errors.Is(err, stream.ErrTooManyTranscodes):+ err = newError(responses.ErrorGeneric, "too many concurrent transcodes, please retry shortly")default:err = newError(responses.ErrorGeneric, fmt.Sprintf("Internal Server Error: %s", err))}@@ -313,15 +316,31 @@ func mapToSubsonicError(err error) subError {}func sendError(w http.ResponseWriter, r *http.Request, err error) {+ if errors.Is(err, stream.ErrTooManyTranscodes) {+ w.Header().Set("Retry-After", strconv.Itoa(stream.RetryAfterSeconds))+ sendResponseWithStatus(w, r, errorResponse(err), http.StatusTooManyRequests)+ return+ }+ sendResponse(w, r, errorResponse(err))+}++func errorResponse(err error) *responses.Subsonic {subErr := mapToSubsonicError(err)response := newResponse()response.Status = responses.StatusFailedresponse.Error = &responses.Error{Code: subErr.code, Message: subErr.Error()}-- sendResponse(w, r, response)+ return response}func sendResponse(w http.ResponseWriter, r *http.Request, payload *responses.Subsonic) {+ sendResponseWithStatus(w, r, payload, 0)+}++// sendResponseWithStatus writes the response body in the format requested by+// the client. When status is non-zero, WriteHeader is called with that code+// before the body is written; callers that need to set additional headers+// (e.g. Retry-After) must set them before calling.+func sendResponseWithStatus(w http.ResponseWriter, r *http.Request, payload *responses.Subsonic, status int) {p := req.Params(r)f, _ := p.String("f")var response []byte@@ -356,6 +375,9 @@ func sendResponse(w http.ResponseWriter, r *http.Request, payload *responses.SubsendError(w, r, err)return}+ if status != 0 {+ w.WriteHeader(status)+ }if payload.Status == responses.StatusOK {if log.IsGreaterOrEqualTo(log.LevelTrace) {diff --git a/server/subsonic/api_test.go b/server/subsonic/api_test.goindex a2db4a0af..a1b66925a 100644--- a/server/subsonic/api_test.go+++ b/server/subsonic/api_test.go@@ -3,11 +3,13 @@ package subsonicimport ("encoding/json""encoding/xml"+ "fmt""math""net/http""net/http/httptest""strings"+ "github.com/navidrome/navidrome/core/stream""github.com/navidrome/navidrome/server/subsonic/responses". "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega"@@ -152,6 +154,24 @@ var _ = Describe("sendResponse", func() {})})+ It("responds with HTTP 429 and Retry-After when the transcode limiter rejects", func() {+ w = httptest.NewRecorder()+ r = httptest.NewRequest("GET", "/rest/stream", nil)++ sendError(w, r, fmt.Errorf("rejected: %w", stream.ErrTooManyTranscodes))++ Expect(w.Code).To(Equal(http.StatusTooManyRequests))+ Expect(w.Header().Get("Retry-After")).ToNot(BeEmpty())++ var subsonicResponse responses.Subsonic+ err := xml.Unmarshal(w.Body.Bytes(), &subsonicResponse)+ Expect(err).NotTo(HaveOccurred())+ Expect(subsonicResponse.Status).To(Equal(responses.StatusFailed))+ Expect(subsonicResponse.Error).ToNot(BeNil())+ Expect(subsonicResponse.Error.Code).To(Equal(responses.ErrorGeneric))+ Expect(subsonicResponse.Error.Message).To(ContainSubstring("transcode"))+ })+It("updates status pointer when an error occurs", func() {pointer := int32(0)diff --git a/server/subsonic/stream.go b/server/subsonic/stream.goindex b49af2b24..28b4585f0 100644--- a/server/subsonic/stream.go+++ b/server/subsonic/stream.go@@ -1,12 +1,15 @@package subsonicimport (+ "context"+ "errors""fmt""net/http""strconv""strings""github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/core/stream""github.com/navidrome/navidrome/log""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/request"@@ -119,14 +122,28 @@ func (api *Router) Download(w http.ResponseWriter, r *http.Request) (*responses.return nil, errcase *model.Album:setHeaders(v.Name)- return nil, api.archiver.ZipAlbum(ctx, id, format, maxBitRate, w)+ return nil, handleArchiveErr(ctx, id, api.archiver.ZipAlbum(ctx, id, format, maxBitRate, w))case *model.Artist:setHeaders(v.Name)- return nil, api.archiver.ZipArtist(ctx, id, format, maxBitRate, w)+ return nil, handleArchiveErr(ctx, id, api.archiver.ZipArtist(ctx, id, format, maxBitRate, w))case *model.Playlist:setHeaders(v.Name)- return nil, api.archiver.ZipPlaylist(ctx, id, format, maxBitRate, w)+ return nil, handleArchiveErr(ctx, id, api.archiver.ZipPlaylist(ctx, id, format, maxBitRate, w))default:return nil, model.ErrNotFound}}++// handleArchiveErr swallows ErrTooManyTranscodes from archive downloads so the+// outer error handler does not try to write a 429 onto a response whose status+// and Content-Disposition have already been flushed. The archive ends up with+// the tracks that were written before the rejection (the rejected track and+// any following ones are omitted); the server-side log is the unambiguous+// signal operators can act on.+func handleArchiveErr(ctx context.Context, id string, err error) error {+ if errors.Is(err, stream.ErrTooManyTranscodes) {+ log.Warn(ctx, "Archive download finalized early: transcode cap reached", "id", id, err)+ return nil+ }+ return err+}