103 lines
3.0 KiB
Go
103 lines
3.0 KiB
Go
package coverart
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// ErrNotFound indicates the upstream responded with 404 — the album has no
|
|
// front cover on MBCAA. Caller should record cover_art_source = 'none'.
|
|
var ErrNotFound = errors.New("coverart: not found")
|
|
|
|
// ErrTransient indicates a temporary failure (5xx, network, timeout). Caller
|
|
// should leave cover_art_source NULL so the next pass can retry.
|
|
var ErrTransient = errors.New("coverart: transient error")
|
|
|
|
// FetcherConfig assembles the operator-tunable knobs for the MBCAA client.
|
|
type FetcherConfig struct {
|
|
BaseURL string // e.g. "https://coverartarchive.org"
|
|
UserAgent string // e.g. "Minstrel/<version> (<contact>)"
|
|
MinPeriod time.Duration // minimum delay between calls (1s default per MBCAA etiquette)
|
|
HTTPClient *http.Client // optional override for tests; default below
|
|
}
|
|
|
|
// Fetcher pulls album front covers from MBCAA. Safe for concurrent use; the
|
|
// internal mutex serialises requests so the rate limit is respected.
|
|
type Fetcher struct {
|
|
cfg FetcherConfig
|
|
mu sync.Mutex
|
|
lastCall time.Time
|
|
client *http.Client
|
|
}
|
|
|
|
// NewFetcher builds a Fetcher with sensible defaults.
|
|
func NewFetcher(cfg FetcherConfig) *Fetcher {
|
|
if cfg.BaseURL == "" {
|
|
cfg.BaseURL = "https://coverartarchive.org"
|
|
}
|
|
client := cfg.HTTPClient
|
|
if client == nil {
|
|
client = &http.Client{Timeout: 30 * time.Second}
|
|
}
|
|
return &Fetcher{cfg: cfg, client: client}
|
|
}
|
|
|
|
// Fetch retrieves the 500px front cover for the given release MBID. Returns
|
|
// ErrNotFound on 404 (record as 'none') or ErrTransient otherwise (retry later).
|
|
func (f *Fetcher) Fetch(ctx context.Context, mbid string) ([]byte, error) {
|
|
if mbid == "" {
|
|
return nil, fmt.Errorf("coverart: empty mbid")
|
|
}
|
|
|
|
// Rate limit: serialise + wait until MinPeriod has elapsed since the last call.
|
|
f.mu.Lock()
|
|
if f.cfg.MinPeriod > 0 {
|
|
wait := time.Until(f.lastCall.Add(f.cfg.MinPeriod))
|
|
if wait > 0 {
|
|
timer := time.NewTimer(wait)
|
|
f.mu.Unlock()
|
|
select {
|
|
case <-ctx.Done():
|
|
timer.Stop()
|
|
return nil, ctx.Err()
|
|
case <-timer.C:
|
|
}
|
|
f.mu.Lock()
|
|
}
|
|
}
|
|
f.lastCall = time.Now()
|
|
f.mu.Unlock()
|
|
|
|
url := fmt.Sprintf("%s/release/%s/front-500", f.cfg.BaseURL, mbid)
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("coverart: build request: %w", err)
|
|
}
|
|
req.Header.Set("User-Agent", f.cfg.UserAgent)
|
|
req.Header.Set("Accept", "image/*")
|
|
|
|
resp, err := f.client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%w: %v", ErrTransient, err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
|
|
switch {
|
|
case resp.StatusCode == http.StatusNotFound:
|
|
return nil, ErrNotFound
|
|
case resp.StatusCode != http.StatusOK:
|
|
return nil, fmt.Errorf("%w: status %d", ErrTransient, resp.StatusCode)
|
|
}
|
|
|
|
body, err := io.ReadAll(io.LimitReader(resp.Body, 5*1024*1024)) // 5MB cap
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%w: read body: %v", ErrTransient, err)
|
|
}
|
|
return body, nil
|
|
}
|