mirror of
https://git.sr.ht/~joren/streamrip-go
synced 2026-10-16 13:57:25 +02:00
JorenandClaude Opus 5
da4add57fe
Two related changes: a 68-track Qobuz album was gated by the API throttle
rather than the network, and Qobuz lyrics are now supported, which is what the
faster album path had to be designed around.
--- perf ---
ratelimit: token bucket instead of fixed spacing
The limiter spaced every request exactly interval apart with no burst, so at
the default 60 requests/minute it allowed exactly one request per second no
matter how many workers ran. Measured: 8 requests took 7s with 1 worker and
7s with 6, i.e. max_connections had no effect on anything touching the API.
Since a track needs its metadata and stream URL before downloading, workers
could only start a track every two seconds, which is why an album looked
serial even at 57 MiB/s per track.
New() now takes a burst (providers pass max_connections), idle time accrues
budget up to that burst, and burst is clamped to one minute's worth of
requests so a large max_connections cannot bypass a small configured rate.
app: reuse the track objects already in the album payload
ripAlbum fetched the album, kept only the track ids, then asked the provider
for every track again, doubling the request count. Providers opt in via
AlbumTracksAreComplete(); only Qobuz does, because it is only verified there
and because Tidal does extra work in its track lookup.
Verified against the live Qobuz API on a 68-track release: the embedded track
objects already carry title, version, track_number, media_number,
parental_warning, isrc, copyright, performer, performers, composer, duration,
audio_info, maximum_bit_depth, maximum_sampling_rate and
release_date_original. The only field a per-track lookup adds that this app
reads is the nested album object, so albumTrackMetadata attaches the parent
album with its own track list stripped, or a 68-track album would hold 68
copies of itself. trackMetaUsable refetches anyway when title or track number
is missing, so a thin payload cannot produce a wrongly named file.
Measured end-to-end through the real app and limiter at the shipped defaults,
68 tracks: 137 API calls / 2m11s before, 69 calls / 1m3s after.
--- qobuz lyrics ---
Qobuz's main API does not serve lyrics: has_lyrics is only a flag, extra=lyrics
adds nothing, and track/getLyrics does not exist. Its apps use a two-step flow
instead, confirmed live:
GET track/lyricsUrl?track_id=&app_id=&request_ts=&request_sig=
-> {"track_id","album_id","lyrics_url"} (signed CloudFront URL)
GET <lyrics_url>
-> {"original":{"type","lang","lines":[{"line","start","end"}]},
"translation_langs":[...],"writers","publishers":[...]}
type is plain, lsync or wsync; start/end are milliseconds; the line text is
under "line". Passing a language returns a translation instead of the original,
and only for languages that exist for the track (en 403s on an English song),
so the language parameter is deliberately omitted. A 403 on the signed URL is
how Qobuz represents "no lyrics", so it is not treated as an error.
Lyrics are exposed through a TrackLyrics method rather than inside GetMetadata,
because album rips skip the per-track metadata call. That keeps the fast path:
with lyrics on, an album costs the same two provider calls per track it always
did, and the lyrics document itself comes from a CDN that does not consume the
provider's request budget. With metadata.exclude = ["lyrics"] it drops to one
call per track and the full speedup applies.
Existing behaviour is preserved: Tidal and Deezer already attach lyrics in
their metadata, so attachLyrics leaves them alone, and a lyrics failure is
logged and ignored rather than failing a download.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
90 lines
2.4 KiB
Go
90 lines
2.4 KiB
Go
// Package ratelimit provides the API request throttle shared by the provider
|
|
// clients.
|
|
package ratelimit
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// Limiter is a token bucket: it enforces a sustained rate of
|
|
// requestsPerMinute while allowing up to burst requests to proceed
|
|
// immediately when budget has accrued.
|
|
//
|
|
// It used to space every request exactly interval apart, with no burst. That
|
|
// made max_connections meaningless for anything that goes through the API:
|
|
// with the default 60 requests/minute, six download workers each needing a
|
|
// metadata call and a stream-URL call could only start one track per two
|
|
// seconds, so an album appeared to download serially even though the transfers
|
|
// themselves were fast.
|
|
type Limiter struct {
|
|
interval time.Duration
|
|
burst int
|
|
|
|
mu sync.Mutex
|
|
// next is the time the next token becomes available. It is allowed to
|
|
// trail now by up to (burst-1)*interval, which is what accrues burst
|
|
// budget while no requests are being made.
|
|
next time.Time
|
|
}
|
|
|
|
// New returns a limiter allowing requestsPerMinute sustained, with burst
|
|
// requests permitted back-to-back. A non-positive requestsPerMinute disables
|
|
// throttling entirely.
|
|
//
|
|
// burst is clamped to at least 1 and to at most one minute's worth of
|
|
// requests, so a very low rate cannot be bypassed by a large burst.
|
|
func New(requestsPerMinute int, burst int) *Limiter {
|
|
if requestsPerMinute <= 0 {
|
|
return &Limiter{}
|
|
}
|
|
if burst < 1 {
|
|
burst = 1
|
|
}
|
|
if burst > requestsPerMinute {
|
|
burst = requestsPerMinute
|
|
}
|
|
return &Limiter{
|
|
interval: time.Minute / time.Duration(requestsPerMinute),
|
|
burst: burst,
|
|
}
|
|
}
|
|
|
|
// Wait blocks until the caller may issue a request, or until ctx is done.
|
|
//
|
|
// Budget is reserved at call time, so a cancelled Wait still consumes its
|
|
// slot. That keeps the sustained rate honest under cancellation, at the cost
|
|
// of briefly under-using the budget.
|
|
func (l *Limiter) Wait(ctx context.Context) error {
|
|
if l.interval <= 0 {
|
|
return nil
|
|
}
|
|
|
|
l.mu.Lock()
|
|
now := time.Now()
|
|
// Accrue budget for idle time, capped at burst tokens.
|
|
earliest := now.Add(-time.Duration(l.burst-1) * l.interval)
|
|
if l.next.Before(earliest) {
|
|
l.next = earliest
|
|
}
|
|
wake := l.next
|
|
l.next = l.next.Add(l.interval)
|
|
l.mu.Unlock()
|
|
|
|
delay := time.Until(wake)
|
|
if delay <= 0 {
|
|
return nil
|
|
}
|
|
|
|
timer := time.NewTimer(delay)
|
|
defer timer.Stop()
|
|
|
|
select {
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
case <-timer.C:
|
|
return nil
|
|
}
|
|
}
|