refactor(http): implement shared transport and clients (#1288)

* fix(http): flip to a shared transport and clients

* nice threads

* that is terrible

* fake uri for magnet

* lazy locking

* why bother with r's

* flip magic params to struct

* refactor(http-clients): use separate clients with shared transport

* refactor(http-clients): add missing license header

* refactor(http-clients): defer and fix errors

---------

Co-authored-by: ze0s <ze0s@riseup.net>

pkg/red/red.go

@@ -15,38 +15,49 @@ import (
 
 	"github.com/autobrr/autobrr/internal/domain"
 	"github.com/autobrr/autobrr/pkg/errors"
+	"github.com/autobrr/autobrr/pkg/sharedhttp"
 
 	"golang.org/x/time/rate"
 )
 
+const DefaultURL = "https://redacted.ch/ajax.php"
+
 type ApiClient interface {
 	GetTorrentByID(ctx context.Context, torrentID string) (*domain.TorrentBasic, error)
 	TestAPI(ctx context.Context) (bool, error)
-	UseURL(url string)
 }
 
 type Client struct {
-	Url         string
+	url         string
 	client      *http.Client
-	RateLimiter *rate.Limiter
+	rateLimiter *rate.Limiter
 	APIKey      string
 }
 
-func NewClient(apiKey string) ApiClient {
+type OptFunc func(*Client)
+
+func WithUrl(url string) OptFunc {
+	return func(c *Client) {
+		c.url = url
+	}
+}
+
+func NewClient(apiKey string, opts ...OptFunc) ApiClient {
 	c := &Client{
-		Url: "https://redacted.ch/ajax.php",
+		url: DefaultURL,
 		client: &http.Client{
-			Timeout: time.Second * 30,
+			Timeout:   time.Second * 30,
+			Transport: sharedhttp.Transport,
 		},
-		RateLimiter: rate.NewLimiter(rate.Every(10*time.Second), 10),
+		rateLimiter: rate.NewLimiter(rate.Every(10*time.Second), 10),
 		APIKey:      apiKey,
 	}
 
-	return c
-}
+	for _, opt := range opts {
+		opt(c)
+	}
 
-func (c *Client) UseURL(url string) {
-	c.Url = url
+	return c
 }
 
 type ErrorResponse struct {
@@ -126,13 +137,13 @@ type Torrent struct {
 
 func (c *Client) Do(req *http.Request) (*http.Response, error) {
 	//ctx := context.Background()
-	err := c.RateLimiter.Wait(req.Context()) // This is a blocking call. Honors the rate limit
+	err := c.rateLimiter.Wait(req.Context()) // This is a blocking call. Honors the rate limit
 	if err != nil {
 		return nil, err
 	}
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, err
+		return resp, err
 	}
 	return resp, nil
 }
@@ -152,7 +163,7 @@ func (c *Client) get(ctx context.Context, url string) (*http.Response, error) {
 
 	res, err := c.Do(req)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not make request: %+v", req)
+		return res, errors.Wrap(err, "could not make request: %+v", req)
 	}
 
 	// return early if not OK
@@ -161,16 +172,16 @@ func (c *Client) get(ctx context.Context, url string) (*http.Response, error) {
 
 		body, readErr := io.ReadAll(res.Body)
 		if readErr != nil {
-			return nil, errors.Wrap(readErr, "could not read body")
+			return res, errors.Wrap(readErr, "could not read body")
 		}
 
 		if err = json.Unmarshal(body, &r); err != nil {
-			return nil, errors.Wrap(readErr, "could not unmarshal body")
+			return res, errors.Wrap(readErr, "could not unmarshal body")
 		}
 
 		res.Body.Close()
 
-		return nil, errors.New("status code: %d status: %s error: %s", res.StatusCode, r.Status, r.Error)
+		return res, errors.New("status code: %d status: %s error: %s", res.StatusCode, r.Status, r.Error)
 	}
 
 	return res, nil
@@ -187,7 +198,7 @@ func (c *Client) GetTorrentByID(ctx context.Context, torrentID string) (*domain.
 	v.Add("id", torrentID)
 	params := v.Encode()
 
-	reqUrl := fmt.Sprintf("%s?action=torrent&%s", c.Url, params)
+	reqUrl := fmt.Sprintf("%s?action=torrent&%s", c.url, params)
 
 	resp, err := c.get(ctx, reqUrl)
 	if err != nil {
@@ -215,7 +226,7 @@ func (c *Client) GetTorrentByID(ctx context.Context, torrentID string) (*domain.
 
 // TestAPI try api access against torrents page
 func (c *Client) TestAPI(ctx context.Context) (bool, error) {
-	resp, err := c.get(ctx, c.Url+"?action=index")
+	resp, err := c.get(ctx, c.url+"?action=index")
 	if err != nil {
 		return false, errors.Wrap(err, "test api error")
 	}

pkg/red/red_test.go

@@ -1,6 +1,8 @@
 // Copyright (c) 2021 - 2023, Ludvig Lundgren and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+//go:build integration
+
 package red
 
 import (
@@ -12,6 +14,7 @@ import (
 	"testing"
 
 	"github.com/autobrr/autobrr/internal/domain"
+
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 )
@@ -98,8 +101,7 @@ func TestREDClient_GetTorrentByID(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := NewClient(tt.fields.APIKey)
-			c.UseURL(tt.fields.Url)
+			c := NewClient(tt.fields.APIKey, WithUrl(ts.URL))
 
 			got, err := c.GetTorrentByID(context.Background(), tt.args.torrentID)
 			if tt.wantErr != "" && assert.Error(t, err) {