Refactor cache.HTTPClient

utils/cache/cached_http_client.go

@@ -0,0 +1,107 @@
+package cache
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/jellydator/ttlcache/v2"
+	"github.com/navidrome/navidrome/log"
+)
+
+const cacheSizeLimit = 100
+
+type HTTPClient struct {
+	cache *ttlcache.Cache
+	hc    httpDoer
+}
+
+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}
+	c.cache = ttlcache.NewCache()
+	c.cache.SetCacheSizeLimit(cacheSizeLimit)
+	c.cache.SkipTTLExtensionOnHit(true)
+	c.cache.SetLoaderFunction(func(key string) (interface{}, time.Duration, error) {
+		req, err := c.deserializeReq(key)
+		if err != nil {
+			return nil, 0, err
+		}
+		resp, err := c.hc.Do(req)
+		if err != nil {
+			return nil, 0, err
+		}
+		defer resp.Body.Close()
+		return c.serializeResponse(resp), ttl, nil
+	})
+	c.cache.SetNewItemCallback(func(key string, value interface{}) {
+		log.Trace("New request cached", "req", key, "resp", value)
+	})
+	return c
+}
+
+func (c *HTTPClient) Do(req *http.Request) (*http.Response, error) {
+	key := c.serializeReq(req)
+	respStr, err := c.cache.Get(key)
+	if err != nil {
+		return nil, err
+	}
+	return c.deserializeResponse(req, respStr.(string))
+}
+
+func (c *HTTPClient) serializeReq(req *http.Request) string {
+	data := requestData{
+		Method: req.Method,
+		Header: req.Header,
+		URL:    req.URL.String(),
+	}
+	if req.Body != nil {
+		bodyData, _ := io.ReadAll(req.Body)
+		bodyStr := base64.StdEncoding.EncodeToString(bodyData)
+		data.Body = &bodyStr
+	}
+	j, _ := json.Marshal(&data)
+	return string(j)
+}
+
+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)
+}