Files
navidrome/utils/cache/cached_http_client.go
T
Deluan Quintão 986000db44 chore(lint): enable errchkjson (#6486)
errchkjson flags json.Marshal/MarshalIndent/Encoder.Encode calls whose error is discarded.
Fixed all 27 sites by hand: errors are returned where the caller already returns one, logged
in HTTP handlers and string-returning helpers, and asserted in tests.
check-error-free-encoding stays off so every encode error is handled, even for safe types.
report-no-exported is on, to catch structs that would silently encode as {}.
2026-11-16 23:18:26 -05:00

117 lines
2.7 KiB
Go

package cache
import (
"bufio"
"bytes"
"encoding/base64"
"encoding/json"
"fmt"
"io"
"net/http"
"strings"
"time"
"github.com/navidrome/navidrome/log"
)
const cacheSizeLimit = 100
type HTTPClient struct {
cache SimpleCache[string, string]
hc httpDoer
ttl time.Duration
}
type httpDoer interface {
Do(req *http.Request) (*http.Response, error)
}
type requestData struct {
Method string
Header http.Header
URL string
Body *string
}
func NewHTTPClient(wrapped httpDoer, ttl time.Duration) *HTTPClient {
c := &HTTPClient{hc: wrapped, ttl: ttl}
c.cache = NewSimpleCache[string, string](Options{
SizeLimit: cacheSizeLimit,
DefaultTTL: ttl,
})
return c
}
func (c *HTTPClient) Do(req *http.Request) (*http.Response, error) {
key, err := c.serializeReq(req)
if err != nil {
return nil, err
}
cached := true
start := time.Now()
respStr, err := c.cache.GetWithLoader(key, func(key string) (string, time.Duration, error) {
cached = false
req, err := c.deserializeReq(key)
if err != nil {
log.Trace(req.Context(), "CachedHTTPClient.Do", "key", key, err)
return "", 0, err
}
resp, err := c.hc.Do(req)
if err != nil {
log.Trace(req.Context(), "CachedHTTPClient.Do", "req", req, err)
return "", 0, err
}
defer resp.Body.Close()
return c.serializeResponse(resp), c.ttl, nil
})
log.Trace(req.Context(), "CachedHTTPClient.Do", "key", key, "cached", cached, "elapsed", time.Since(start), err)
if err != nil {
return nil, err
}
return c.deserializeResponse(req, respStr)
}
func (c *HTTPClient) serializeReq(req *http.Request) (string, error) {
data := requestData{
Method: req.Method,
Header: req.Header,
URL: req.URL.String(),
}
if req.Body != nil {
bodyData, _ := io.ReadAll(req.Body)
data.Body = new(base64.StdEncoding.EncodeToString(bodyData))
}
j, err := json.Marshal(&data)
if err != nil {
return "", fmt.Errorf("encoding request cache key: %w", err)
}
return string(j), nil
}
func (c *HTTPClient) deserializeReq(reqStr string) (*http.Request, error) {
var data requestData
_ = json.Unmarshal([]byte(reqStr), &data)
var body io.Reader
if data.Body != nil {
bodyStr, _ := base64.StdEncoding.DecodeString(*data.Body)
body = strings.NewReader(string(bodyStr))
}
req, err := http.NewRequest(data.Method, data.URL, body)
if err != nil {
return nil, err
}
req.Header = data.Header
return req, nil
}
func (c *HTTPClient) serializeResponse(resp *http.Response) string {
var b = &bytes.Buffer{}
_ = resp.Write(b)
return b.String()
}
func (c *HTTPClient) deserializeResponse(req *http.Request, respStr string) (*http.Response, error) {
r := bufio.NewReader(strings.NewReader(respStr))
return http.ReadResponse(r, req)
}