refactor(agent): nice client

Author: srg-bnd

internal/agent/client/client.go

@@ -1,132 +1,81 @@
-// HTTP Client
+// Client for working with the server
 package client
 
 import (
-	"bytes"
-	"compress/flate"
-	"compress/gzip"
 	"encoding/json"
 	"errors"
-	"fmt"
-	"reflect"
 	"strings"
-	"time"
 
 	"github.com/go-resty/resty/v2"
 	"github.com/srg-bnd/observator/internal/agent/models"
 	"github.com/srg-bnd/observator/internal/server/logger"
+	"github.com/srg-bnd/observator/internal/shared/services"
 	"go.uber.org/zap"
 )
 
-var ErrBadHashSum = errors.New("bad hashSHA256")
+var ErrBadHashSum = errors.New("bad hash")
 
+// TODO: uses `ChecksumBehaviour` instead of `services.Checksum`
 type ChecksumBehaviour interface {
 	Sum(string) (string, error)
 }
 
 // Client
 type Client struct {
-	client          *resty.Client
-	baseURL         string
-	checksumService ChecksumBehaviour
+	httpClient      *resty.Client
+	checksumService *services.Checksum
 }
 
 // Returns a new client
-func NewClient(baseURL string, checksumService ChecksumBehaviour) *Client {
+func NewClient(baseURL string, checksumService *services.Checksum) *Client {
 	return &Client{
-		client: resty.New(),
-		// HACK
-		baseURL:         "http://" + baseURL,
+		httpClient:      newHttpClient(baseURL),
 		checksumService: checksumService,
 	}
 }
 
-// Sends batch of metrics to the server
+// Sends batch of metrics
 func (c *Client) SendMetrics(metrics []models.Metrics) error {
 	data, err := json.Marshal(&metrics)
 	if err != nil {
 		return err
 	}
 
-	// Compress data
 	compressedData, err := compress(data)
 	if err != nil {
 		return err
 	}
 
-	// Retriable errors
-	repetitionIntervals := [3]int{1, 3, 5}
-	currentRepetitionInterval := -1
-
-	// Init client
-	c.client.
-		SetRetryCount(len(repetitionIntervals)).
-		SetRetryAfter(func(c *resty.Client, r *resty.Response) (time.Duration, error) {
-			currentRepetitionInterval++
-			return time.Duration(repetitionIntervals[currentRepetitionInterval]) * time.Second, nil
-		}).
-		SetRetryMaxWaitTime(5 * time.Second)
-
-	// Execute a request
-	request := c.client.R().SetBody(compressedData).
-		SetHeader("Content-Type", "application/json").
-		SetHeader("Accept-Encoding", "gzip").
-		SetHeader("Content-Encoding", "gzip")
-
-	if reflect.ValueOf(c.checksumService).Kind() == reflect.Ptr && !reflect.ValueOf(c.checksumService).IsNil() {
-		hash, err := c.checksumService.Sum(string(data))
-		if err != nil {
-			logger.Log.Warn("bad hash (SHA256)", zap.Error(ErrBadHashSum))
-			return err
-		} else {
-			request = request.SetHeader("HashSHA256", string(hash))
-		}
+	request := c.httpClient.R().SetBody(compressedData)
+	request, err = c.withChecksum(request, data)
+	if err != nil {
+		return err
 	}
 
-	res, err := request.Post(c.baseURL + "/updates")
+	response, err := request.Post("/updates")
 	if err != nil {
 		return err
 	}
 
-	// Decompress response
-	if strings.Contains(res.Header().Get("Accept-Encoding"), "gzip") {
-		decompress(res.Body())
+	if strings.Contains(response.Header().Get("Accept-Encoding"), "gzip") {
+		// TODO: use the results
+		decompress(response.Body())
 	}
 
 	return nil
 }
 
-// Helpers
-
-// Compress data
-func compress(data []byte) ([]byte, error) {
-	var b bytes.Buffer
-
-	w := gzip.NewWriter(&b)
-
-	_, err := w.Write(data)
-	if err != nil {
-		return nil, fmt.Errorf("failed write data to compress temporary buffer: %v", err)
-	}
-
-	err = w.Close()
-	if err != nil {
-		return nil, fmt.Errorf("failed compress data: %v", err)
+// Sets a checksum if need
+func (c *Client) withChecksum(request *resty.Request, data []byte) (*resty.Request, error) {
+	if c.checksumService != nil {
+		return request, nil
 	}
 
-	return b.Bytes(), nil
-}
-
-// Decompress data
-func decompress(compressedData []byte) ([]byte, error) {
-	r := flate.NewReader(bytes.NewReader(compressedData))
-	defer r.Close()
-
-	var b bytes.Buffer
-	_, err := b.ReadFrom(r)
+	hash, err := c.checksumService.Sum(string(data))
 	if err != nil {
-		return nil, fmt.Errorf("failed decompress data: %v", err)
+		logger.Log.Warn(ErrBadHashSum.Error(), zap.Error(ErrBadHashSum))
+		return request, nil
 	}
 
-	return b.Bytes(), nil
+	return request.SetHeader("HashSHA256", string(hash)), nil
 }

internal/agent/client/helpers.go

@@ -0,0 +1,63 @@
+package client
+
+import (
+	"bytes"
+	"compress/flate"
+	"compress/gzip"
+	"fmt"
+	"time"
+
+	"github.com/go-resty/resty/v2"
+)
+
+// Returns a new http client (resty)
+func newHttpClient(baseURL string) *resty.Client {
+	// Retriable errors
+	repetitionIntervals := [3]int{1, 3, 5}
+	currentRepetitionInterval := -1
+
+	return resty.New().
+		SetBaseURL("http://"+baseURL).
+		SetRetryCount(len(repetitionIntervals)).
+		SetRetryAfter(func(c *resty.Client, r *resty.Response) (time.Duration, error) {
+			currentRepetitionInterval++
+			return time.Duration(repetitionIntervals[currentRepetitionInterval]) * time.Second, nil
+		}).
+		SetRetryMaxWaitTime(5*time.Second).
+		SetHeader("Content-Type", "application/json").
+		SetHeader("Accept-Encoding", "gzip").
+		SetHeader("Content-Encoding", "gzip")
+}
+
+// Compress data
+func compress(data []byte) ([]byte, error) {
+	var b bytes.Buffer
+
+	w := gzip.NewWriter(&b)
+
+	_, err := w.Write(data)
+	if err != nil {
+		return nil, fmt.Errorf("failed write data to compress temporary buffer: %v", err)
+	}
+
+	err = w.Close()
+	if err != nil {
+		return nil, fmt.Errorf("failed compress data: %v", err)
+	}
+
+	return b.Bytes(), nil
+}
+
+// Decompress data
+func decompress(compressedData []byte) ([]byte, error) {
+	r := flate.NewReader(bytes.NewReader(compressedData))
+	defer r.Close()
+
+	var b bytes.Buffer
+	_, err := b.ReadFrom(r)
+	if err != nil {
+		return nil, fmt.Errorf("failed decompress data: %v", err)
+	}
+
+	return b.Bytes(), nil
+}