diff --git a/client.go b/client.go
index 0273d4565..57737701e 100644
--- a/client.go
+++ b/client.go
@@ -3,6 +3,9 @@ package linodego
import (
"bytes"
"context"
+ "crypto/tls"
+ "crypto/x509"
+ _ "embed"
"encoding/json"
"fmt"
"io"
@@ -14,13 +17,13 @@ import (
"path/filepath"
"reflect"
"regexp"
+ "runtime"
+ "sort"
"strconv"
"strings"
"sync"
"text/template"
"time"
-
- "github.com/go-resty/resty/v2"
)
const (
@@ -50,20 +53,35 @@ const (
APIDefaultCacheExpiration = time.Minute * 15
)
-//nolint:unused
+// Embed the log template files
+//
+//go:embed request_log_template.tmpl
+var requestTemplateStr string
+
+//go:embed response_log_template.tmpl
+var responseTemplateStr string
+
var (
- reqLogTemplate = template.Must(template.New("request").Parse(`Sending request:
-Method: {{.Method}}
-URL: {{.URL}}
-Headers: {{.Headers}}
-Body: {{.Body}}`))
-
- respLogTemplate = template.Must(template.New("response").Parse(`Received response:
-Status: {{.Status}}
-Headers: {{.Headers}}
-Body: {{.Body}}`))
+ reqLogTemplate = template.Must(template.New("request").Parse(requestTemplateStr))
+ respLogTemplate = template.Must(template.New("response").Parse(responseTemplateStr))
)
+type RequestLog struct {
+ Request string
+ Host string
+ Headers http.Header
+ Body string
+}
+
+type ResponseLog struct {
+ Status string
+ Proto string
+ ReceivedAt string
+ TimeDuration string
+ Headers http.Header
+ Body string
+}
+
var envDebug = false
// redactHeadersMap is a map of headers that should be redacted in logs,
@@ -72,18 +90,19 @@ var redactHeadersMap = map[string]string{
"Authorization": "Bearer *******************************",
}
-// Client is a wrapper around the Resty client
+// Client is a wrapper around the http client
type Client struct {
- resty *resty.Client
- userAgent string
- debug bool
- retryConditionals []RetryConditional
+ httpClient *http.Client
+ userAgent string
+ debug bool
pollInterval time.Duration
baseURL string
apiVersion string
apiProto string
+ hostURL string
+ header http.Header
selectedProfile string
loadedProfile string
@@ -94,6 +113,16 @@ type Client struct {
cacheExpiration time.Duration
cachedEntries map[string]clientCacheEntry
cachedEntryLock *sync.RWMutex
+ logger Logger
+ requestLog func(*RequestLog) error
+ onBeforeRequest []func(*http.Request) error
+ onAfterResponse []func(*http.Response) error
+
+ retryConditionals []RetryConditional
+ retryMaxWaitTime time.Duration
+ retryMinWaitTime time.Duration
+ retryAfter RetryAfter
+ retryCount int
}
type EnvDefaults struct {
@@ -110,13 +139,11 @@ type clientCacheEntry struct {
}
type (
- Request = resty.Request
- Response = resty.Response
- Logger = resty.Logger
+ Request = http.Request
+ Response = http.Response
)
func init() {
- // Whether we will enable Resty debugging output
if apiDebug, ok := os.LookupEnv("LINODE_DEBUG"); ok {
if parsed, err := strconv.ParseBool(apiDebug); err == nil {
envDebug = parsed
@@ -128,22 +155,37 @@ func init() {
}
// NewClient factory to create new Client struct
+// nolint:funlen
func NewClient(hc *http.Client) (client Client) {
if hc != nil {
- client.resty = resty.NewWithClient(hc)
+ client.httpClient = hc
} else {
- client.resty = resty.New()
+ client.httpClient = &http.Client{}
+ }
+
+ // Ensure that the Header map is not nil
+ if client.httpClient.Transport == nil {
+ client.httpClient.Transport = &http.Transport{}
}
client.shouldCache = true
client.cacheExpiration = APIDefaultCacheExpiration
client.cachedEntries = make(map[string]clientCacheEntry)
client.cachedEntryLock = &sync.RWMutex{}
+ client.configProfiles = make(map[string]ConfigProfile)
+
+ const (
+ retryMinWaitDuration = 100 * time.Millisecond
+ retryMaxWaitDuration = 2 * time.Second
+ )
+
+ client.retryMinWaitTime = retryMinWaitDuration
+ client.retryMaxWaitTime = retryMaxWaitDuration
client.SetUserAgent(DefaultUserAgent)
+ client.SetLogger(createLogger())
baseURL, baseURLExists := os.LookupEnv(APIHostVar)
-
if baseURLExists {
client.SetBaseURL(baseURL)
}
@@ -156,17 +198,11 @@ func NewClient(hc *http.Client) (client Client) {
}
certPath, certPathExists := os.LookupEnv(APIHostCert)
-
- if certPathExists && !hasCustomTransport(hc) {
- cert, err := os.ReadFile(filepath.Clean(certPath))
- if err != nil {
- log.Fatalf("[ERROR] Error when reading cert at %s: %s\n", certPath, err.Error())
- }
-
+ if certPathExists {
client.SetRootCertificate(certPath)
if envDebug {
- log.Printf("[DEBUG] Set API root certificate to %s with contents %s\n", certPath, cert)
+ log.Printf("[DEBUG] Set API root certificate to %s\n", certPath)
}
}
@@ -174,6 +210,7 @@ func NewClient(hc *http.Client) (client Client) {
SetRetryWaitTime(APISecondsPerPoll * time.Second).
SetPollDelay(APISecondsPerPoll * time.Second).
SetRetries().
+ SetLogger(createLogger()).
SetDebug(envDebug).
enableLogSanitization()
@@ -213,8 +250,8 @@ func NewClientFromEnv(hc *http.Client) (*Client, error) {
client.selectedProfile = configProfile
// We should only load the config if the config file exists
- if _, err = os.Stat(configPath); err != nil {
- return nil, fmt.Errorf("error loading config file %s: %w", configPath, err)
+ if _, statErr := os.Stat(configPath); statErr != nil {
+ return nil, fmt.Errorf("error loading config file %s: %w", configPath, statErr)
}
err = client.preLoadConfig(configPath)
@@ -225,42 +262,284 @@ func NewClientFromEnv(hc *http.Client) (*Client, error) {
// SetUserAgent sets a custom user-agent for HTTP requests
func (c *Client) SetUserAgent(ua string) *Client {
c.userAgent = ua
- c.resty.SetHeader("User-Agent", c.userAgent)
+ c.SetHeader("User-Agent", c.userAgent)
return c
}
-type RequestParams struct {
- Body any
+type requestParams struct {
+ Body *bytes.Reader
Response any
+ // Headers are per-request headers that will be applied only to
+ // the individual request, not stored on the shared client state.
+ Headers http.Header
+}
+
+func (c *Client) ErrorAndLogf(format string, args ...any) error {
+ if c.debug && c.logger != nil {
+ c.logger.Errorf(format, args...)
+ }
+
+ return fmt.Errorf(format, args...)
+}
+
+// SetRootCertificate adds a root certificate to the underlying TLS client config
+func (c *Client) SetRootCertificate(certPath string) *Client {
+ config, err := c.tlsConfig()
+ if err != nil {
+ log.Println("[WARN] Custom transport is not allowed with a custom root CA")
+ return c
+ }
+
+ if config.RootCAs == nil {
+ config.RootCAs = x509.NewCertPool()
+ }
+
+ pem, err := os.ReadFile(filepath.Clean(certPath))
+ if err != nil {
+ log.Printf("[ERROR] Failed to read root certificate at %s: %s\n", certPath, err.Error())
+ return c
+ }
+
+ config.RootCAs.AppendCertsFromPEM(pem)
+
+ return c
+}
+
+// SetToken sets the API token for all requests from this client
+// Only necessary if you haven't already provided the http client to NewClient() configured with the token.
+func (c *Client) SetToken(token string) *Client {
+ c.SetHeader("Authorization", fmt.Sprintf("Bearer %s", token))
+ return c
+}
+
+// SetRetries adds retry conditions for "Linode Busy." errors and 429s.
+func (c *Client) SetRetries() *Client {
+ c.
+ AddRetryCondition(LinodeBusyRetryCondition).
+ AddRetryCondition(TooManyRequestsRetryCondition).
+ AddRetryCondition(ServiceUnavailableRetryCondition).
+ AddRetryCondition(RequestTimeoutRetryCondition).
+ AddRetryCondition(RequestGOAWAYRetryCondition).
+ AddRetryCondition(RequestNGINXRetryCondition).
+ SetRetryMaxWaitTime(APIRetryMaxWaitTime)
+ ConfigureRetries(c)
+
+ return c
+}
+
+// AddRetryCondition adds a RetryConditional function to the Client
+func (c *Client) AddRetryCondition(retryCondition RetryConditional) *Client {
+ c.retryConditionals = append(c.retryConditionals, retryCondition)
+
+ return c
+}
+
+func (c *Client) SetDebug(debug bool) *Client {
+ c.debug = debug
+
+ return c
+}
+
+func (c *Client) SetLogger(logger Logger) *Client {
+ c.logger = logger
+
+ return c
+}
+
+func (c *Client) OnBeforeRequest(m func(*http.Request) error) {
+ c.onBeforeRequest = append(c.onBeforeRequest, m)
+}
+
+func (c *Client) OnAfterResponse(m func(*http.Response) error) {
+ c.onAfterResponse = append(c.onAfterResponse, m)
+}
+
+// UseURL parses the individual components of the given API URL and configures the client
+// accordingly. For example, a valid URL.
+// For example:
+//
+// client.UseURL("https://api.test.linode.com/v4beta")
+func (c *Client) UseURL(apiURL string) (*Client, error) {
+ parsedURL, err := url.Parse(apiURL)
+ if err != nil {
+ return nil, fmt.Errorf("failed to parse URL: %w", err)
+ }
+
+ if parsedURL.Scheme == "" || parsedURL.Host == "" {
+ return nil, fmt.Errorf("need both scheme and host in API URL, got %q", apiURL)
+ }
+
+ // Create a new URL excluding the path to use as the base URL
+ baseURL := &url.URL{
+ Host: parsedURL.Host,
+ Scheme: parsedURL.Scheme,
+ }
+
+ c.SetBaseURL(baseURL.String())
+
+ versionMatches := regexp.MustCompile(`/v[a-zA-Z0-9]+`).FindAllString(parsedURL.Path, -1)
+
+ // Only set the version if a version is found in the URL, else use the default
+ if len(versionMatches) > 0 {
+ c.SetAPIVersion(
+ strings.Trim(versionMatches[len(versionMatches)-1], "/"),
+ )
+ }
+
+ return c, nil
+}
+
+func (c *Client) SetBaseURL(baseURL string) *Client {
+ baseURLPath, _ := url.Parse(baseURL)
+
+ c.baseURL = path.Join(baseURLPath.Host, baseURLPath.Path)
+ c.apiProto = baseURLPath.Scheme
+
+ c.updateHostURL()
+
+ return c
+}
+
+// SetAPIVersion sets the version of the API to interface with
+func (c *Client) SetAPIVersion(apiVersion string) *Client {
+ c.apiVersion = apiVersion
+
+ c.updateHostURL()
+
+ return c
+}
+
+// InvalidateCache clears all cached responses for all endpoints.
+func (c *Client) InvalidateCache() {
+ c.cachedEntryLock.Lock()
+ defer c.cachedEntryLock.Unlock()
+
+ // GC will handle the old map
+ c.cachedEntries = make(map[string]clientCacheEntry)
+}
+
+// InvalidateCacheEndpoint invalidates a single cached endpoint.
+func (c *Client) InvalidateCacheEndpoint(endpoint string) error {
+ u, err := url.Parse(endpoint)
+ if err != nil {
+ return fmt.Errorf("failed to parse URL for caching: %w", err)
+ }
+
+ c.cachedEntryLock.Lock()
+ defer c.cachedEntryLock.Unlock()
+
+ delete(c.cachedEntries, u.Path)
+
+ return nil
+}
+
+// SetGlobalCacheExpiration sets the desired time for any cached response
+// to be valid for.
+func (c *Client) SetGlobalCacheExpiration(expiryTime time.Duration) {
+ c.cacheExpiration = expiryTime
+}
+
+// UseCache sets whether response caching should be used
+func (c *Client) UseCache(value bool) {
+ c.shouldCache = value
+}
+
+// SetRetryMaxWaitTime sets the maximum delay before retrying a request.
+func (c *Client) SetRetryMaxWaitTime(maxWaitTime time.Duration) *Client {
+ c.retryMaxWaitTime = maxWaitTime
+ return c
+}
+
+// SetRetryWaitTime sets the default (minimum) delay before retrying a request.
+func (c *Client) SetRetryWaitTime(minWaitTime time.Duration) *Client {
+ c.retryMinWaitTime = minWaitTime
+ return c
+}
+
+// SetRetryAfter sets the callback function to be invoked with a failed request
+// to determine wben it should be retried.
+func (c *Client) SetRetryAfter(callback RetryAfter) *Client {
+ c.retryAfter = callback
+ return c
+}
+
+// SetRetryCount sets the maximum retry attempts before aborting.
+func (c *Client) SetRetryCount(count int) *Client {
+ c.retryCount = count
+ return c
+}
+
+// SetPollDelay sets the number of milliseconds to wait between events or status polls.
+// Affects all WaitFor* functions and retries.
+func (c *Client) SetPollDelay(delay time.Duration) *Client {
+ c.pollInterval = delay
+ return c
+}
+
+// GetPollDelay gets the number of milliseconds to wait between events or status polls.
+// Affects all WaitFor* functions and retries.
+func (c *Client) GetPollDelay() time.Duration {
+ return c.pollInterval
+}
+
+// SetHeader sets a custom header to be used in all API requests made with the current
+// client.
+// NOTE: Some headers may be overridden by the individual request functions.
+func (c *Client) SetHeader(name, value string) {
+ if c.header == nil {
+ c.header = make(http.Header) // Initialize header if nil
+ }
+
+ c.header.Set(name, value)
+}
+
+func (c *Client) Transport() (*http.Transport, error) {
+ if transport, ok := c.httpClient.Transport.(*http.Transport); ok {
+ return transport, nil
+ }
+
+ return nil, fmt.Errorf("current transport is not an *http.Transport instance")
}
// Generic helper to execute HTTP requests using the net/http package
//
-// nolint:unused, funlen, gocognit
-func (c *httpClient) doRequest(ctx context.Context, method, url string, params RequestParams) error {
+// nolint:funlen, gocognit, nestif
+func (c *Client) doRequest(ctx context.Context, method, endpoint string, params requestParams, paginationMutator *func(*http.Request) error) error {
var (
- req *http.Request
- bodyBuffer *bytes.Buffer
- resp *http.Response
- err error
+ req *http.Request
+ resp *http.Response
+ err error
)
- for range httpDefaultRetryCount {
- req, bodyBuffer, err = c.createRequest(ctx, method, url, params)
+ for range c.retryCount {
+ // Reset the body to the start for each retry if it's not nil
+ if params.Body != nil {
+ if _, seekErr := params.Body.Seek(0, io.SeekStart); seekErr != nil {
+ return c.ErrorAndLogf("failed to seek to the start of the body: %v", seekErr.Error())
+ }
+ }
+
+ req, err = c.createRequest(ctx, method, endpoint, params)
if err != nil {
return err
}
+ if paginationMutator != nil {
+ if mutErr := (*paginationMutator)(req); mutErr != nil {
+ return c.ErrorAndLogf("failed to mutate before request: %v", mutErr.Error())
+ }
+ }
+
if err = c.applyBeforeRequest(req); err != nil {
return err
}
if c.debug && c.logger != nil {
- c.logRequest(req, method, url, bodyBuffer)
+ req = c.logRequest(req)
}
- processResponse := func() error {
+ processResponse := func(start, end time.Time) error {
defer func() {
closeErr := resp.Body.Close()
if closeErr != nil && err == nil {
@@ -273,12 +552,7 @@ func (c *httpClient) doRequest(ctx context.Context, method, url string, params R
}
if c.debug && c.logger != nil {
- var logErr error
-
- resp, logErr = c.logResponse(resp)
- if logErr != nil {
- return logErr
- }
+ resp = c.logResponse(resp, start, end)
}
if params.Response != nil {
@@ -295,9 +569,12 @@ func (c *httpClient) doRequest(ctx context.Context, method, url string, params R
return nil
}
+ startTime := time.Now()
resp, err = c.sendRequest(req)
+ endTime := time.Now()
+
if err == nil {
- if err = processResponse(); err == nil {
+ if err = processResponse(startTime, endTime); err == nil {
return nil
}
}
@@ -311,19 +588,33 @@ func (c *httpClient) doRequest(ctx context.Context, method, url string, params R
return retryErr
}
- // Sleep for the specified duration before retrying.
- // If retryAfter is 0 (i.e., Retry-After header is not found),
- // no delay is applied.
- time.Sleep(retryAfter)
+ // Determine wait time before retrying.
+ // If the server provided a Retry-After duration, use it (clamped to bounds).
+ // Otherwise, fall back to the configured minimum wait time.
+ waitTime := c.retryMinWaitTime
+
+ if retryAfter > 0 {
+ waitTime = retryAfter
+ }
+
+ // Ensure the wait time is within the defined bounds
+ if waitTime < c.retryMinWaitTime {
+ waitTime = c.retryMinWaitTime
+ } else if waitTime > c.retryMaxWaitTime {
+ waitTime = c.retryMaxWaitTime
+ }
+
+ // Sleep for the calculated duration before retrying
+ time.Sleep(waitTime)
}
return err
}
-// nolint:unused
-func (c *httpClient) shouldRetry(resp *http.Response, err error) bool {
+func (c *Client) shouldRetry(resp *http.Response, err error) bool {
for _, retryConditional := range c.retryConditionals {
if retryConditional(resp, err) {
+ log.Printf("[INFO] Received error %v - Retrying", err)
return true
}
}
@@ -331,35 +622,26 @@ func (c *httpClient) shouldRetry(resp *http.Response, err error) bool {
return false
}
-// nolint:unused
-func (c *httpClient) createRequest(ctx context.Context, method, url string, params RequestParams) (*http.Request, *bytes.Buffer, error) {
- var (
- bodyReader io.Reader
- bodyBuffer *bytes.Buffer
- )
+func (c *Client) createRequest(ctx context.Context, method, endpoint string, params requestParams) (*http.Request, error) {
+ var bodyReader io.Reader
if params.Body != nil {
- bodyBuffer = new(bytes.Buffer)
- if err := json.NewEncoder(bodyBuffer).Encode(params.Body); err != nil {
- if c.debug && c.logger != nil {
- c.logger.Errorf("failed to encode body: %v", err)
- }
-
- return nil, nil, fmt.Errorf("failed to encode body: %w", err)
+ // Reset the body position to the start before using it
+ _, err := params.Body.Seek(0, io.SeekStart)
+ if err != nil {
+ return nil, c.ErrorAndLogf("failed to seek to the start of the body: %v", err.Error())
}
- bodyReader = bodyBuffer
+ bodyReader = params.Body
}
- req, err := http.NewRequestWithContext(ctx, method, url, bodyReader)
+ req, err := http.NewRequestWithContext(ctx, method, fmt.Sprintf("%s/%s", strings.TrimRight(c.hostURL, "/"),
+ strings.TrimLeft(endpoint, "/")), bodyReader)
if err != nil {
- if c.debug && c.logger != nil {
- c.logger.Errorf("failed to create request: %v", err)
- }
-
- return nil, nil, fmt.Errorf("failed to create request: %w", err)
+ return nil, c.ErrorAndLogf("failed to create request: %v", err.Error())
}
+ // Set the default headers
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Accept", "application/json")
@@ -367,40 +649,43 @@ func (c *httpClient) createRequest(ctx context.Context, method, url string, para
req.Header.Set("User-Agent", c.userAgent)
}
- return req, bodyBuffer, nil
+ // Set additional headers added to the client
+ for name, values := range c.header {
+ for _, value := range values {
+ req.Header.Set(name, value)
+ }
+ }
+
+ // Apply per-request headers (these take priority over client headers)
+ for name, values := range params.Headers {
+ for _, value := range values {
+ req.Header.Set(name, value)
+ }
+ }
+
+ return req, nil
}
-// nolint:unused
-func (c *httpClient) applyBeforeRequest(req *http.Request) error {
+func (c *Client) applyBeforeRequest(req *http.Request) error {
for _, mutate := range c.onBeforeRequest {
if err := mutate(req); err != nil {
- if c.debug && c.logger != nil {
- c.logger.Errorf("failed to mutate before request: %v", err)
- }
-
- return fmt.Errorf("failed to mutate before request: %w", err)
+ return c.ErrorAndLogf("failed to mutate before request: %v", err.Error())
}
}
return nil
}
-// nolint:unused
-func (c *httpClient) applyAfterResponse(resp *http.Response) error {
+func (c *Client) applyAfterResponse(resp *http.Response) error {
for _, mutate := range c.onAfterResponse {
if err := mutate(resp); err != nil {
- if c.debug && c.logger != nil {
- c.logger.Errorf("failed to mutate after response: %v", err)
- }
-
- return fmt.Errorf("failed to mutate after response: %w", err)
+ return c.ErrorAndLogf("failed to mutate after response: %v", err.Error())
}
}
return nil
}
-// nolint:unused
func redactHeaders(headers http.Header) http.Header {
redacted := headers.Clone()
@@ -413,333 +698,224 @@ func redactHeaders(headers http.Header) http.Header {
return redacted
}
-// nolint:unused
-func (c *httpClient) logRequest(req *http.Request, method, url string, bodyBuffer *bytes.Buffer) {
- var reqBody string
- if bodyBuffer != nil {
- reqBody = bodyBuffer.String()
- } else {
- reqBody = "nil"
- }
-
- var logBuf bytes.Buffer
+func (c *Client) logRequest(req *http.Request) *http.Request {
+ var reqBody bytes.Buffer
+ if req.Body != nil {
+ if _, err := io.Copy(&reqBody, req.Body); err != nil {
+ c.logger.Errorf("failed to read request body: %v", err)
+ }
- err := reqLogTemplate.Execute(&logBuf, map[string]any{
- "Method": method,
- "URL": url,
- "Headers": redactHeaders(req.Header),
- "Body": reqBody,
- })
- if err == nil {
- c.logger.Debugf(logBuf.String())
+ req.Body = io.NopCloser(bytes.NewReader(reqBody.Bytes()))
}
-}
-// nolint:unused
-func (c *httpClient) sendRequest(req *http.Request) (*http.Response, error) {
- // #nosec G704
- resp, err := c.httpClient.Do(req)
- if err != nil {
- if c.debug && c.logger != nil {
- c.logger.Errorf("failed to send request: %v", err)
- }
+ reqLog := &RequestLog{
+ Request: strings.Join([]string{req.Method, req.URL.Path, req.Proto}, " "),
+ Host: req.Host,
+ Headers: redactHeaders(req.Header.Clone()),
+ Body: reqBody.String(),
+ }
- return nil, fmt.Errorf("failed to send request: %w", err)
+ e := c.requestLog(reqLog)
+ if e != nil {
+ _ = c.ErrorAndLogf("failed to log request: %v", e.Error())
}
- return resp, nil
-}
+ sanitizedBody := sanitizeLogValue(reqLog.Body)
-// nolint:unused
-func (c *httpClient) checkHTTPError(resp *http.Response) error {
- _, err := coupleAPIErrorsHTTP(resp, nil)
- if err != nil {
+ body, jsonErr := formatBody(sanitizedBody)
+ if jsonErr != nil {
if c.debug && c.logger != nil {
- c.logger.Errorf("received HTTP error: %v", err)
+ c.logger.Errorf("%v", jsonErr)
}
-
- return err
- }
-
- return nil
-}
-
-// nolint:unused
-func (c *httpClient) logResponse(resp *http.Response) (*http.Response, error) {
- var respBody bytes.Buffer
- if _, err := io.Copy(&respBody, resp.Body); err != nil {
- c.logger.Errorf("failed to read response body: %v", err)
}
var logBuf bytes.Buffer
- err := respLogTemplate.Execute(&logBuf, map[string]any{
- "Status": resp.Status,
- "Headers": redactHeaders(resp.Header),
- "Body": respBody.String(),
+ err := reqLogTemplate.Execute(&logBuf, map[string]any{
+ "Request": reqLog.Request,
+ "Host": reqLog.Host,
+ "Headers": formatHeaders(reqLog.Headers),
+ "Body": body,
})
if err == nil {
- c.logger.Debugf(logBuf.String())
+ c.logger.Debugf(sanitizeLogValue(logBuf.String()))
}
- resp.Body = io.NopCloser(bytes.NewReader(respBody.Bytes()))
-
- return resp, nil
+ return req
}
-// nolint:unused
-func (c *httpClient) decodeResponseBody(resp *http.Response, response any) error {
- if err := json.NewDecoder(resp.Body).Decode(response); err != nil {
- if c.debug && c.logger != nil {
- c.logger.Errorf("failed to decode response: %v", err)
- }
+func formatHeaders(headers map[string][]string) string {
+ var builder strings.Builder
+ builder.WriteString("\n")
- return fmt.Errorf("failed to decode response: %w", err)
+ keys := make([]string, 0, len(headers))
+ for key := range headers {
+ keys = append(keys, key)
}
- return nil
-}
+ sort.Strings(keys)
-// R wraps resty's R method
-func (c *Client) R(ctx context.Context) *resty.Request {
- return c.resty.R().
- ExpectContentType("application/json").
- SetHeader("Content-Type", "application/json").
- SetContext(ctx).
- SetError(APIError{})
-}
-
-// SetDebug sets the debug on resty's client
-func (c *Client) SetDebug(debug bool) *Client {
- c.debug = debug
- c.resty.SetDebug(debug)
+ for _, key := range keys {
+ builder.WriteString(fmt.Sprintf(" %s: %s\n", key, strings.Join(headers[key], ", ")))
+ }
- return c
+ return strings.TrimSuffix(builder.String(), "\n")
}
-// SetLogger allows the user to override the output
-// logger for debug logs.
-func (c *Client) SetLogger(logger Logger) *Client {
- c.resty.SetLogger(logger)
+// sanitizeLogValue removes or escapes control characters that could
+// enable log injection (e.g., \r, \n) from a string before it is written
+// to a log entry. Uses strings.ReplaceAll so static-analysis tools
+// (e.g., CodeQL) can recognize the sanitization.
+func sanitizeLogValue(s string) string {
+ s = strings.ReplaceAll(s, "\r\n", "\\n")
+ s = strings.ReplaceAll(s, "\r", "\\n")
+ s = strings.ReplaceAll(s, "\n", "\\n")
- return c
+ return s
}
-//nolint:unused
-func (c *httpClient) httpSetDebug(debug bool) *httpClient {
- c.debug = debug
+func formatBody(body string) (string, error) {
+ body = strings.TrimSpace(body)
+ if body == "null" || body == "nil" || body == "" {
+ return "", nil
+ }
- return c
-}
+ var jsonData any
-//nolint:unused
-func (c *httpClient) httpSetLogger(logger httpLogger) *httpClient {
- c.logger = logger
+ err := json.Unmarshal([]byte(body), &jsonData)
+ if err != nil {
+ return "", fmt.Errorf("error unmarshalling JSON: %w", err)
+ }
- return c
-}
+ prettyJSON, err := json.MarshalIndent(jsonData, "", " ")
+ if err != nil {
+ return "", fmt.Errorf("error marshalling JSON: %w", err)
+ }
-// OnBeforeRequest adds a handler to the request body to run before the request is sent
-func (c *Client) OnBeforeRequest(m func(request *Request) error) {
- c.resty.OnBeforeRequest(func(_ *resty.Client, req *resty.Request) error {
- return m(req)
- })
+ return "\n" + string(prettyJSON), nil
}
-// OnAfterResponse adds a handler to the request body to run before the request is sent
-func (c *Client) OnAfterResponse(m func(response *Response) error) {
- c.resty.OnAfterResponse(func(_ *resty.Client, req *resty.Response) error {
- return m(req)
- })
-}
+func formatDate(dateStr string) (string, error) {
+ parsedTime, err := time.Parse(time.RFC1123, dateStr)
+ if err != nil {
+ return "", fmt.Errorf("error parsing date: %v", err)
+ }
-// nolint:unused
-func (c *httpClient) httpOnBeforeRequest(m func(*http.Request) error) *httpClient {
- c.onBeforeRequest = append(c.onBeforeRequest, m)
+ formattedDate := parsedTime.In(time.Local).Format("2006-01-02T15:04:05-07:00") // nolint:gosmopolitan
- return c
+ return formattedDate, nil
}
-// nolint:unused
-func (c *httpClient) httpOnAfterResponse(m func(*http.Response) error) *httpClient {
- c.onAfterResponse = append(c.onAfterResponse, m)
+func (c *Client) sendRequest(req *http.Request) (*http.Response, error) {
+ resp, err := c.httpClient.Do(req) //#nosec G704 // URL is constructed from client-configured base URL + endpoint
+ if err != nil {
+ return nil, c.ErrorAndLogf("failed to send request: %w", err)
+ }
- return c
+ return resp, nil
}
-// UseURL parses the individual components of the given API URL and configures the client
-// accordingly. For example, a valid URL.
-// For example:
-//
-// client.UseURL("https://api.test.linode.com/v4beta")
-func (c *Client) UseURL(apiURL string) (*Client, error) {
- parsedURL, err := url.Parse(apiURL)
+func (c *Client) checkHTTPError(resp *http.Response) error {
+ _, err := coupleAPIErrors(resp, nil)
if err != nil {
- return nil, fmt.Errorf("failed to parse URL: %w", err)
+ _ = c.ErrorAndLogf("received HTTP error: %v", err.Error())
+ return err
}
- if parsedURL.Scheme == "" || parsedURL.Host == "" {
- return nil, fmt.Errorf("need both scheme and host in API URL, got %q", apiURL)
- }
+ return nil
+}
- // Create a new URL excluding the path to use as the base URL
- baseURL := &url.URL{
- Host: parsedURL.Host,
- Scheme: parsedURL.Scheme,
+func (c *Client) logResponse(resp *http.Response, start, end time.Time) *http.Response {
+ var respBody bytes.Buffer
+ if _, err := io.Copy(&respBody, resp.Body); err != nil {
+ c.logger.Errorf("failed to read response body: %v", err)
}
- c.SetBaseURL(baseURL.String())
-
- versionMatches := regexp.MustCompile(`/v[a-zA-Z0-9]+`).FindAllString(parsedURL.Path, -1)
-
- // Only set the version if a version is found in the URL, else use the default
- if len(versionMatches) > 0 {
- c.SetAPIVersion(
- strings.Trim(versionMatches[len(versionMatches)-1], "/"),
- )
+ receivedAt, dateErr := formatDate(resp.Header.Get("Date"))
+ if dateErr != nil {
+ if c.debug && c.logger != nil {
+ c.logger.Errorf("failed to format date: %v", dateErr)
+ }
}
- return c, nil
-}
-
-// SetBaseURL sets the base URL of the Linode v4 API (https://api.linode.com/v4)
-func (c *Client) SetBaseURL(baseURL string) *Client {
- baseURLPath, _ := url.Parse(baseURL)
-
- c.baseURL = path.Join(baseURLPath.Host, baseURLPath.Path)
- c.apiProto = baseURLPath.Scheme
-
- c.updateHostURL()
-
- return c
-}
-
-// SetAPIVersion sets the version of the API to interface with
-func (c *Client) SetAPIVersion(apiVersion string) *Client {
- c.apiVersion = apiVersion
+ duration := end.Sub(start).String()
- c.updateHostURL()
-
- return c
-}
-
-// SetRootCertificate adds a root certificate to the underlying TLS client config
-func (c *Client) SetRootCertificate(path string) *Client {
- c.resty.SetRootCertificate(path)
- return c
-}
-
-// SetToken sets the API token for all requests from this client
-// Only necessary if you haven't already provided the http client to NewClient() configured with the token.
-func (c *Client) SetToken(token string) *Client {
- c.resty.SetHeader("Authorization", fmt.Sprintf("Bearer %s", token))
- return c
-}
+ respLog := &ResponseLog{
+ Status: resp.Status,
+ Proto: resp.Proto,
+ ReceivedAt: receivedAt,
+ TimeDuration: duration,
+ Headers: resp.Header,
+ Body: respBody.String(),
+ }
-// SetRetries adds retry conditions for "Linode Busy." errors and 429s.
-func (c *Client) SetRetries() *Client {
- c.
- addRetryConditional(linodeBusyRetryCondition).
- addRetryConditional(tooManyRequestsRetryCondition).
- addRetryConditional(serviceUnavailableRetryCondition).
- addRetryConditional(requestTimeoutRetryCondition).
- addRetryConditional(requestGOAWAYRetryCondition).
- addRetryConditional(requestNGINXRetryCondition).
- SetRetryMaxWaitTime(APIRetryMaxWaitTime)
- configureRetries(c)
+ body, jsonErr := formatBody(sanitizeLogValue(respLog.Body))
+ if jsonErr != nil {
+ if c.debug && c.logger != nil {
+ c.logger.Errorf("%v", jsonErr)
+ }
+ }
- return c
-}
+ var logBuf bytes.Buffer
-// AddRetryCondition adds a RetryConditional function to the Client
-func (c *Client) AddRetryCondition(retryCondition RetryConditional) *Client {
- c.resty.AddRetryCondition(resty.RetryConditionFunc(retryCondition))
- return c
-}
+ err := respLogTemplate.Execute(&logBuf, map[string]any{
+ "Status": respLog.Status,
+ "Proto": respLog.Proto,
+ "ReceivedAt": respLog.ReceivedAt,
+ "TimeDuration": respLog.TimeDuration,
+ "Headers": formatHeaders(redactHeaders(respLog.Headers)),
+ "Body": body,
+ })
+ if err == nil {
+ c.logger.Debugf(sanitizeLogValue(logBuf.String()))
+ }
-// InvalidateCache clears all cached responses for all endpoints.
-func (c *Client) InvalidateCache() {
- c.cachedEntryLock.Lock()
- defer c.cachedEntryLock.Unlock()
+ resp.Body = io.NopCloser(bytes.NewReader(respBody.Bytes()))
- // GC will handle the old map
- c.cachedEntries = make(map[string]clientCacheEntry)
+ return resp
}
-// InvalidateCacheEndpoint invalidates a single cached endpoint.
-func (c *Client) InvalidateCacheEndpoint(endpoint string) error {
- u, err := url.Parse(endpoint)
- if err != nil {
- return fmt.Errorf("failed to parse URL for caching: %w", err)
+func (c *Client) decodeResponseBody(resp *http.Response, response any) error {
+ if err := json.NewDecoder(resp.Body).Decode(response); err != nil {
+ return c.ErrorAndLogf("failed to decode response: %v", err.Error())
}
- c.cachedEntryLock.Lock()
- defer c.cachedEntryLock.Unlock()
-
- delete(c.cachedEntries, u.Path)
-
return nil
}
-// SetGlobalCacheExpiration sets the desired time for any cached response
-// to be valid for.
-func (c *Client) SetGlobalCacheExpiration(expiryTime time.Duration) {
- c.cacheExpiration = expiryTime
-}
-
-// UseCache sets whether response caching should be used
-func (c *Client) UseCache(value bool) {
- c.shouldCache = value
-}
-
-// SetRetryMaxWaitTime sets the maximum delay before retrying a request.
-func (c *Client) SetRetryMaxWaitTime(maxWaitTime time.Duration) *Client {
- c.resty.SetRetryMaxWaitTime(maxWaitTime)
- return c
-}
+func (c *Client) updateHostURL() {
+ apiProto := APIProto
+ baseURL := APIHost
+ apiVersion := APIVersion
-// SetRetryWaitTime sets the default (minimum) delay before retrying a request.
-func (c *Client) SetRetryWaitTime(minWaitTime time.Duration) *Client {
- c.resty.SetRetryWaitTime(minWaitTime)
- return c
-}
+ if c.baseURL != "" {
+ baseURL = c.baseURL
+ }
-// SetRetryAfter sets the callback function to be invoked with a failed request
-// to determine wben it should be retried.
-func (c *Client) SetRetryAfter(callback RetryAfter) *Client {
- c.resty.SetRetryAfter(resty.RetryAfterFunc(callback))
- return c
-}
+ if c.apiVersion != "" {
+ apiVersion = c.apiVersion
+ }
-// SetRetryCount sets the maximum retry attempts before aborting.
-func (c *Client) SetRetryCount(count int) *Client {
- c.resty.SetRetryCount(count)
- return c
-}
+ if c.apiProto != "" {
+ apiProto = c.apiProto
+ }
-// SetPollDelay sets the number of milliseconds to wait between events or status polls.
-// Affects all WaitFor* functions and retries.
-func (c *Client) SetPollDelay(delay time.Duration) *Client {
- c.pollInterval = delay
- return c
+ c.hostURL = strings.TrimRight(fmt.Sprintf("%s://%s/%s", apiProto, baseURL, url.PathEscape(apiVersion)), "/")
}
-// GetPollDelay gets the number of milliseconds to wait between events or status polls.
-// Affects all WaitFor* functions and retries.
-func (c *Client) GetPollDelay() time.Duration {
- return c.pollInterval
-}
+func (c *Client) tlsConfig() (*tls.Config, error) {
+ transport, err := c.Transport()
+ if err != nil {
+ return nil, err
+ }
-// SetHeader sets a custom header to be used in all API requests made with the current
-// client.
-// NOTE: Some headers may be overridden by the individual request functions.
-func (c *Client) SetHeader(name, value string) {
- c.resty.SetHeader(name, value)
-}
+ if transport.TLSClientConfig == nil {
+ transport.TLSClientConfig = &tls.Config{
+ MinVersion: tls.VersionTLS12,
+ }
+ }
-func (c *Client) addRetryConditional(retryConditional RetryConditional) *Client {
- c.retryConditionals = append(c.retryConditionals, retryConditional)
- return c
+ return transport.TLSClientConfig, nil
}
func (c *Client) addCachedResponse(endpoint string, response any, expiry *time.Duration) {
@@ -819,49 +995,25 @@ func (c *Client) getCachedResponse(endpoint string) any {
return c.cachedEntries[endpoint].Data
}
-func (c *Client) updateHostURL() {
- apiProto := APIProto
- baseURL := APIHost
- apiVersion := APIVersion
-
- if c.baseURL != "" {
- baseURL = c.baseURL
+func (c *Client) onRequestLog(rl func(*RequestLog) error) *Client {
+ if c.requestLog != nil {
+ c.logger.Warnf("Overwriting an existing on-request-log callback from=%s to=%s",
+ functionName(c.requestLog), functionName(rl))
}
- if c.apiVersion != "" {
- apiVersion = c.apiVersion
- }
+ c.requestLog = rl
- if c.apiProto != "" {
- apiProto = c.apiProto
- }
-
- c.resty.SetBaseURL(
- fmt.Sprintf(
- "%s://%s/%s",
- apiProto,
- baseURL,
- url.PathEscape(apiVersion),
- ),
- )
+ return c
}
-func redactLogHeaders(header http.Header) {
- for h, redactedValue := range redactHeadersMap {
- if header.Get(h) != "" {
- header.Set(h, redactedValue)
- }
- }
+func functionName(i any) string {
+ return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
}
func (c *Client) enableLogSanitization() *Client {
- c.resty.OnRequestLog(func(r *resty.RequestLog) error {
- redactLogHeaders(r.Header)
- return nil
- })
-
- c.resty.OnResponseLog(func(r *resty.ResponseLog) error {
- redactLogHeaders(r.Header)
+ c.onRequestLog(func(r *RequestLog) error {
+ // masking authorization header
+ r.Headers.Set("Authorization", "Bearer *******************************")
return nil
})
@@ -958,16 +1110,3 @@ func generateListCacheURL(endpoint string, opts *ListOptions) (string, error) {
return fmt.Sprintf("%s:%s", endpoint, hashedOpts), nil
}
-
-func hasCustomTransport(hc *http.Client) bool {
- if hc == nil || hc.Transport == nil {
- return false
- }
-
- if _, ok := hc.Transport.(*http.Transport); !ok {
- log.Println("[WARN] Custom transport is not allowed with a custom root CA.")
- return true
- }
-
- return false
-}
diff --git a/client_http.go b/client_http.go
deleted file mode 100644
index 7f16362c5..000000000
--- a/client_http.go
+++ /dev/null
@@ -1,56 +0,0 @@
-package linodego
-
-import (
- "net/http"
- "sync"
- "time"
-)
-
-// Client is a wrapper around the Resty client
-//
-//nolint:unused
-type httpClient struct {
- //nolint:unused
- httpClient *http.Client
- //nolint:unused
- userAgent string
- //nolint:unused
- debug bool
- //nolint:unused
- retryConditionals []httpRetryConditional
- //nolint:unused
- retryAfter httpRetryAfter
-
- //nolint:unused
- pollInterval time.Duration
-
- //nolint:unused
- baseURL string
- //nolint:unused
- apiVersion string
- //nolint:unused
- apiProto string
- //nolint:unused
- selectedProfile string
- //nolint:unused
- loadedProfile string
-
- //nolint:unused
- configProfiles map[string]ConfigProfile
-
- // Fields for caching endpoint responses
- //nolint:unused
- shouldCache bool
- //nolint:unused
- cacheExpiration time.Duration
- //nolint:unused
- cachedEntries map[string]clientCacheEntry
- //nolint:unused
- cachedEntryLock *sync.RWMutex
- //nolint:unused
- logger httpLogger
- //nolint:unused
- onBeforeRequest []func(*http.Request) error
- //nolint:unused
- onAfterResponse []func(*http.Response) error
-}
diff --git a/client_monitor.go b/client_monitor.go
index b54dc8284..3cb959854 100644
--- a/client_monitor.go
+++ b/client_monitor.go
@@ -2,13 +2,17 @@ package linodego
import (
"context"
+ "crypto/tls"
+ "crypto/x509"
+ "encoding/json"
"fmt"
+ "io"
"net/http"
"net/url"
"os"
"path"
-
- "github.com/go-resty/resty/v2"
+ "path/filepath"
+ "strings"
)
const (
@@ -24,25 +28,36 @@ const (
MonitorAPIEnvVar = "MONITOR_API_TOKEN"
)
-// MonitorClient is a wrapper around the Resty client
+// MonitorClient is a wrapper around the http client
type MonitorClient struct {
- resty *resty.Client
+ httpClient *http.Client
debug bool
apiBaseURL string
apiProtocol string
apiVersion string
+ hostURL string
userAgent string
+ header http.Header
+ logger Logger
}
// NewMonitorClient is the entry point for user to create a new MonitorClient
// It utilizes default values and looks for environment variables to initialize a MonitorClient.
func NewMonitorClient(hc *http.Client) (mClient MonitorClient) {
if hc != nil {
- mClient.resty = resty.NewWithClient(hc)
+ mClient.httpClient = hc
} else {
- mClient.resty = resty.New()
+ mClient.httpClient = &http.Client{}
+ }
+
+ // Ensure transport is initialized so SetRootCertificate can configure TLS
+ if mClient.httpClient.Transport == nil {
+ mClient.httpClient.Transport = &http.Transport{}
}
+ mClient.header = make(http.Header)
+ mClient.logger = createLogger()
+
mClient.SetUserAgent(DefaultUserAgent)
baseURL, baseURLExists := os.LookupEnv(MonitorAPIHostVar)
@@ -72,24 +87,14 @@ func NewMonitorClient(hc *http.Client) (mClient MonitorClient) {
// SetUserAgent sets a custom user-agent for HTTP requests
func (mc *MonitorClient) SetUserAgent(ua string) *MonitorClient {
mc.userAgent = ua
- mc.resty.SetHeader("User-Agent", mc.userAgent)
+ mc.header.Set("User-Agent", ua)
return mc
}
-// R wraps resty's R method
-func (mc *MonitorClient) R(ctx context.Context) *resty.Request {
- return mc.resty.R().
- ExpectContentType("application/json").
- SetHeader("Content-Type", "application/json").
- SetContext(ctx).
- SetError(APIError{})
-}
-
-// SetDebug sets the debug on resty's client
+// SetDebug sets the debug on the client
func (mc *MonitorClient) SetDebug(debug bool) *MonitorClient {
mc.debug = debug
- mc.resty.SetDebug(debug)
return mc
}
@@ -97,7 +102,7 @@ func (mc *MonitorClient) SetDebug(debug bool) *MonitorClient {
// SetLogger allows the user to override the output
// logger for debug logs.
func (mc *MonitorClient) SetLogger(logger Logger) *MonitorClient {
- mc.resty.SetLogger(logger)
+ mc.logger = logger
return mc
}
@@ -124,21 +129,44 @@ func (mc *MonitorClient) SetAPIVersion(apiVersion string) *MonitorClient {
}
// SetRootCertificate adds a root certificate to the underlying TLS client config
-func (mc *MonitorClient) SetRootCertificate(path string) *MonitorClient {
- mc.resty.SetRootCertificate(path)
+func (mc *MonitorClient) SetRootCertificate(certPath string) *MonitorClient {
+ transport, ok := mc.httpClient.Transport.(*http.Transport)
+ if !ok {
+ mc.logger.Errorf("current transport is not an *http.Transport instance")
+ return mc
+ }
+
+ if transport.TLSClientConfig == nil {
+ transport.TLSClientConfig = &tls.Config{
+ MinVersion: tls.VersionTLS12,
+ }
+ }
+
+ if transport.TLSClientConfig.RootCAs == nil {
+ transport.TLSClientConfig.RootCAs = x509.NewCertPool()
+ }
+
+ pem, err := os.ReadFile(filepath.Clean(certPath))
+ if err != nil {
+ mc.logger.Errorf("Failed to read root certificate at %s: %s", certPath, err.Error())
+ return mc
+ }
+
+ transport.TLSClientConfig.RootCAs.AppendCertsFromPEM(pem)
+
return mc
}
// SetToken sets the API token for all requests from this client
func (mc *MonitorClient) SetToken(token string) *MonitorClient {
- mc.resty.SetHeader("Authorization", fmt.Sprintf("Bearer %s", token))
+ mc.header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
return mc
}
// SetHeader sets a custom header to be used in all API requests made with the current client.
// NOTE: Some headers may be overridden by the individual request functions.
func (mc *MonitorClient) SetHeader(name, value string) {
- mc.resty.SetHeader(name, value)
+ mc.header.Set(name, value)
}
func (mc *MonitorClient) updateMonitorHostURL() {
@@ -158,12 +186,66 @@ func (mc *MonitorClient) updateMonitorHostURL() {
apiProto = mc.apiProtocol
}
- mc.resty.SetBaseURL(
- fmt.Sprintf(
- "%s://%s/%s",
- apiProto,
- baseURL,
- url.PathEscape(apiVersion),
- ),
+ mc.hostURL = fmt.Sprintf(
+ "%s://%s/%s",
+ apiProto,
+ baseURL,
+ url.PathEscape(apiVersion),
)
}
+
+// doRequest is a generic helper to execute HTTP requests for the MonitorClient
+func (mc *MonitorClient) doRequest(ctx context.Context, method, endpoint string, params requestParams) error {
+ var bodyReader io.Reader
+
+ if params.Body != nil {
+ if _, err := params.Body.Seek(0, io.SeekStart); err != nil {
+ return fmt.Errorf("failed to seek body: %w", err)
+ }
+
+ bodyReader = params.Body
+ }
+
+ reqURL := fmt.Sprintf("%s/%s", strings.TrimRight(mc.hostURL, "/"), strings.TrimLeft(endpoint, "/"))
+
+ req, err := http.NewRequestWithContext(ctx, method, reqURL, bodyReader)
+ if err != nil {
+ return fmt.Errorf("failed to create request: %w", err)
+ }
+
+ req.Header.Set("Content-Type", "application/json")
+ req.Header.Set("Accept", "application/json")
+
+ for name, values := range mc.header {
+ for _, value := range values {
+ req.Header.Set(name, value)
+ }
+ }
+
+ if mc.debug && mc.logger != nil {
+ mc.logger.Debugf("Sending request: %s %s", method, reqURL)
+ }
+
+ resp, err := mc.httpClient.Do(req)
+ if err != nil {
+ return fmt.Errorf("failed to send request: %w", err)
+ }
+ defer resp.Body.Close()
+
+ _, err = coupleAPIErrors(resp, nil)
+ if err != nil {
+ return err
+ }
+
+ if mc.debug && mc.logger != nil {
+ mc.logger.Debugf("Received response: %s", resp.Status)
+ }
+
+ if params.Response != nil {
+ if err := json.NewDecoder(resp.Body).Decode(params.Response); err != nil {
+ return fmt.Errorf("failed to decode response: %w", err)
+ }
+ }
+
+ return nil
+}
diff --git a/client_test.go b/client_test.go
index f925f3678..da4997c17 100644
--- a/client_test.go
+++ b/client_test.go
@@ -37,39 +37,39 @@ func TestClient_SetAPIVersion(t *testing.T) {
client := NewClient(nil)
- if client.resty.BaseURL != defaultURL {
- t.Fatal(cmp.Diff(client.resty.BaseURL, defaultURL))
+ if client.hostURL != defaultURL {
+ t.Fatal(cmp.Diff(client.hostURL, defaultURL))
}
client.SetBaseURL(baseURL)
client.SetAPIVersion(apiVersion)
- if client.resty.BaseURL != expectedHost {
- t.Fatal(cmp.Diff(client.resty.BaseURL, expectedHost))
+ if client.hostURL != expectedHost {
+ t.Fatal(cmp.Diff(client.hostURL, expectedHost))
}
// Ensure setting twice does not cause conflicts
client.SetBaseURL(updatedBaseURL)
client.SetAPIVersion(updatedAPIVersion)
- if client.resty.BaseURL != updatedExpectedHost {
- t.Fatal(cmp.Diff(client.resty.BaseURL, updatedExpectedHost))
+ if client.hostURL != updatedExpectedHost {
+ t.Fatal(cmp.Diff(client.hostURL, updatedExpectedHost))
}
// Revert
client.SetBaseURL(baseURL)
client.SetAPIVersion(apiVersion)
- if client.resty.BaseURL != expectedHost {
- t.Fatal(cmp.Diff(client.resty.BaseURL, expectedHost))
+ if client.hostURL != expectedHost {
+ t.Fatal(cmp.Diff(client.hostURL, expectedHost))
}
// Custom protocol
client.SetBaseURL(protocolBaseURL)
client.SetAPIVersion(protocolAPIVersion)
- if client.resty.BaseURL != protocolExpectedHost {
- t.Fatal(cmp.Diff(client.resty.BaseURL, expectedHost))
+ if client.hostURL != protocolExpectedHost {
+ t.Fatal(cmp.Diff(client.hostURL, expectedHost))
}
}
@@ -111,7 +111,7 @@ func TestClient_NewFromEnvToken(t *testing.T) {
t.Fatal(err)
}
- if client.resty.Header.Get("Authorization") != "Bearer blah" {
+ if client.header.Get("Authorization") != "Bearer blah" {
t.Fatal("token not found in auth header: blah")
}
}
@@ -171,8 +171,8 @@ func TestClient_UseURL(t *testing.T) {
t.Fatalf("unexpected error: %v", err)
}
- if client.resty.BaseURL != tt.wantBaseURL {
- t.Fatalf("mismatched base url: got %s, want %s", client.resty.BaseURL, tt.wantBaseURL)
+ if client.hostURL != tt.wantBaseURL {
+ t.Fatalf("mismatched base url: got %s, want %s", client.hostURL, tt.wantBaseURL)
}
})
}
@@ -209,12 +209,12 @@ func TestDebugLogSanitization(t *testing.T) {
logger.L.SetOutput(&lgr)
mockClient.SetDebug(true)
- if !mockClient.resty.Debug {
+ if !mockClient.debug {
t.Fatal("debug should be enabled")
}
mockClient.SetHeader("Authorization", fmt.Sprintf("Bearer %s", plainTextToken))
- if mockClient.resty.Header.Get("Authorization") != fmt.Sprintf("Bearer %s", plainTextToken) {
+ if mockClient.header.Get("Authorization") != fmt.Sprintf("Bearer %s", plainTextToken) {
t.Fatal("token not found in auth header")
}
@@ -242,22 +242,25 @@ func TestDebugLogSanitization(t *testing.T) {
func TestDoRequest_Success(t *testing.T) {
handler := func(w http.ResponseWriter, r *http.Request) {
- w.WriteHeader(http.StatusOK)
- w.Header().Set("Content-Type", "application/json")
- _, _ = w.Write([]byte(`{"message":"success"}`))
+ if r.URL.Path == "/v4/foo/bar" {
+ w.WriteHeader(http.StatusOK)
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write([]byte(`{"message":"success"}`))
+ } else {
+ http.NotFound(w, r)
+ }
}
server := httptest.NewServer(http.HandlerFunc(handler))
defer server.Close()
- client := &httpClient{
- httpClient: server.Client(),
- }
+ client := NewClient(server.Client())
+ client.SetBaseURL(server.URL)
- params := RequestParams{
+ params := requestParams{
Response: &map[string]string{},
}
- err := client.doRequest(context.Background(), http.MethodGet, server.URL, params)
+ err := client.doRequest(context.Background(), http.MethodGet, "/foo/bar", params, nil) // Pass only the endpoint
if err != nil {
t.Fatal(cmp.Diff(nil, err))
}
@@ -269,31 +272,11 @@ func TestDoRequest_Success(t *testing.T) {
}
}
-func TestDoRequest_FailedEncodeBody(t *testing.T) {
- client := &httpClient{
- httpClient: http.DefaultClient,
- }
-
- params := RequestParams{
- Body: map[string]interface{}{
- "invalid": func() {},
- },
- }
-
- err := client.doRequest(context.Background(), http.MethodPost, "http://example.com", params)
- expectedErr := "failed to encode body"
- if err == nil || !strings.Contains(err.Error(), expectedErr) {
- t.Fatalf("expected error %q, got: %v", expectedErr, err)
- }
-}
-
func TestDoRequest_FailedCreateRequest(t *testing.T) {
- client := &httpClient{
- httpClient: http.DefaultClient,
- }
+ client := NewClient(nil)
- // Create a request with an invalid URL to simulate a request creation failure
- err := client.doRequest(context.Background(), http.MethodGet, "http://invalid url", RequestParams{})
+ // Create a request with an invalid method to simulate a request creation failure
+ err := client.doRequest(context.Background(), "bad method", "/foo/bar", requestParams{}, nil)
expectedErr := "failed to create request"
if err == nil || !strings.Contains(err.Error(), expectedErr) {
t.Fatalf("expected error %q, got: %v", expectedErr, err)
@@ -302,26 +285,28 @@ func TestDoRequest_FailedCreateRequest(t *testing.T) {
func TestDoRequest_Non2xxStatusCode(t *testing.T) {
handler := func(w http.ResponseWriter, r *http.Request) {
- http.Error(w, "error", http.StatusInternalServerError)
+ http.Error(w, "error", http.StatusInternalServerError) // Simulate a 500 Internal Server Error
}
server := httptest.NewServer(http.HandlerFunc(handler))
defer server.Close()
- client := &httpClient{
- httpClient: server.Client(),
- }
+ client := NewClient(server.Client())
+ client.SetBaseURL(server.URL)
- err := client.doRequest(context.Background(), http.MethodGet, server.URL, RequestParams{})
+ err := client.doRequest(context.Background(), http.MethodGet, "/foo/bar", requestParams{}, nil)
if err == nil {
t.Fatal("expected error, got nil")
}
- httpError, ok := err.(Error)
+
+ httpError, ok := err.(*Error)
if !ok {
t.Fatalf("expected error to be of type Error, got %T", err)
}
+
if httpError.Code != http.StatusInternalServerError {
t.Fatalf("expected status code %d, got %d", http.StatusInternalServerError, httpError.Code)
}
+
if !strings.Contains(httpError.Message, "error") {
t.Fatalf("expected error message to contain %q, got %v", "error", httpError.Message)
}
@@ -331,21 +316,21 @@ func TestDoRequest_FailedDecodeResponse(t *testing.T) {
handler := func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.Header().Set("Content-Type", "application/json")
- _, _ = w.Write([]byte(`invalid json`))
+ _, _ = w.Write([]byte(`invalid json`)) // Simulate invalid JSON
}
server := httptest.NewServer(http.HandlerFunc(handler))
defer server.Close()
- client := &httpClient{
- httpClient: server.Client(),
- }
+ client := NewClient(server.Client())
+ client.SetBaseURL(server.URL)
- params := RequestParams{
+ params := requestParams{
Response: &map[string]string{},
}
- err := client.doRequest(context.Background(), http.MethodGet, server.URL, params)
+ err := client.doRequest(context.Background(), http.MethodGet, "/foo/bar", params, nil)
expectedErr := "failed to decode response"
+
if err == nil || !strings.Contains(err.Error(), expectedErr) {
t.Fatalf("expected error %q, got: %v", expectedErr, err)
}
@@ -363,24 +348,21 @@ func TestDoRequest_BeforeRequestSuccess(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(handler))
defer server.Close()
- client := &httpClient{
- httpClient: server.Client(),
- }
+ client := NewClient(server.Client())
+ client.SetBaseURL(server.URL)
- // Define a mutator that successfully modifies the request
mutator := func(req *http.Request) error {
req.Header.Set("X-Custom-Header", "CustomValue")
return nil
}
- client.httpOnBeforeRequest(mutator)
+ client.OnBeforeRequest(mutator)
- err := client.doRequest(context.Background(), http.MethodGet, server.URL, RequestParams{})
+ err := client.doRequest(context.Background(), http.MethodGet, "/foo/bar", requestParams{}, nil)
if err != nil {
t.Fatalf("expected no error, got: %v", err)
}
- // Check if the header was successfully added to the captured request
if reqHeader := capturedRequest.Header.Get("X-Custom-Header"); reqHeader != "CustomValue" {
t.Fatalf("expected X-Custom-Header to be set to CustomValue, got: %v", reqHeader)
}
@@ -395,18 +377,18 @@ func TestDoRequest_BeforeRequestError(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(handler))
defer server.Close()
- client := &httpClient{
- httpClient: server.Client(),
- }
+ client := NewClient(server.Client())
+ client.SetBaseURL(server.URL)
mutator := func(req *http.Request) error {
return errors.New("mutator error")
}
- client.httpOnBeforeRequest(mutator)
+ client.OnBeforeRequest(mutator)
- err := client.doRequest(context.Background(), http.MethodGet, server.URL, RequestParams{})
+ err := client.doRequest(context.Background(), http.MethodGet, "/foo/bar", requestParams{}, nil)
expectedErr := "failed to mutate before request"
+
if err == nil || !strings.Contains(err.Error(), expectedErr) {
t.Fatalf("expected error %q, got: %v", expectedErr, err)
}
@@ -425,23 +407,21 @@ func TestDoRequest_AfterResponseSuccess(t *testing.T) {
tr := &testRoundTripper{
Transport: server.Client().Transport,
}
- client := &httpClient{
- httpClient: &http.Client{Transport: tr},
- }
+ client := NewClient(&http.Client{Transport: tr})
+ client.SetBaseURL(server.URL)
mutator := func(resp *http.Response) error {
resp.Header.Set("X-Modified-Header", "ModifiedValue")
return nil
}
- client.httpOnAfterResponse(mutator)
+ client.OnAfterResponse(mutator)
- err := client.doRequest(context.Background(), http.MethodGet, server.URL, RequestParams{})
+ err := client.doRequest(context.Background(), http.MethodGet, "/foo/bar", requestParams{}, nil)
if err != nil {
t.Fatalf("expected no error, got: %v", err)
}
- // Check if the header was successfully added to the response
if respHeader := tr.Response.Header.Get("X-Modified-Header"); respHeader != "ModifiedValue" {
t.Fatalf("expected X-Modified-Header to be set to ModifiedValue, got: %v", respHeader)
}
@@ -456,17 +436,16 @@ func TestDoRequest_AfterResponseError(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(handler))
defer server.Close()
- client := &httpClient{
- httpClient: server.Client(),
- }
+ client := NewClient(server.Client())
+ client.SetBaseURL(server.URL)
mutator := func(resp *http.Response) error {
return errors.New("mutator error")
}
- client.httpOnAfterResponse(mutator)
+ client.OnAfterResponse(mutator)
- err := client.doRequest(context.Background(), http.MethodGet, server.URL, RequestParams{})
+ err := client.doRequest(context.Background(), http.MethodGet, "/foo/bar", requestParams{}, nil)
expectedErr := "failed to mutate after response"
if err == nil || !strings.Contains(err.Error(), expectedErr) {
t.Fatalf("expected error %q, got: %v", expectedErr, err)
@@ -478,11 +457,9 @@ func TestDoRequestLogging_Success(t *testing.T) {
logger := createLogger()
logger.l.SetOutput(&logBuffer) // Redirect log output to buffer
- client := &httpClient{
- httpClient: http.DefaultClient,
- debug: true,
- logger: logger,
- }
+ client := NewClient(nil)
+ client.SetDebug(true)
+ client.SetLogger(logger)
handler := func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
@@ -490,29 +467,46 @@ func TestDoRequestLogging_Success(t *testing.T) {
_, _ = w.Write([]byte(`{"message":"success"}`))
}
server := httptest.NewServer(http.HandlerFunc(handler))
+ client.SetBaseURL(server.URL)
defer server.Close()
- params := RequestParams{
+ params := requestParams{
Response: &map[string]string{},
}
+ endpoint := "/foo/bar"
- err := client.doRequest(context.Background(), http.MethodGet, server.URL, params)
+ err := client.doRequest(context.Background(), http.MethodGet, endpoint, params, nil)
if err != nil {
t.Fatal(cmp.Diff(nil, err))
}
logInfo := logBuffer.String()
- logInfoWithoutTimestamps := removeTimestamps(logInfo)
- // Expected logs with templates filled in
- expectedRequestLog := "DEBUG RESTY Sending request:\nMethod: GET\nURL: " + server.URL + "\nHeaders: map[Accept:[application/json] Content-Type:[application/json]]\nBody: "
- expectedResponseLog := "DEBUG RESTY Received response:\nStatus: 200 OK\nHeaders: map[Content-Length:[21] Content-Type:[text/plain; charset=utf-8]]\nBody: {\"message\":\"success\"}"
+ expectedRequestParts := []string{
+ "GET /v4/foo/bar HTTP/1.1",
+ "Accept: application/json",
+ "Authorization: Bearer *******************************",
+ "Content-Type: application/json",
+ "User-Agent: linodego/dev https://github.com/linode/linodego",
+ }
- if !strings.Contains(logInfo, expectedRequestLog) {
- t.Fatalf("expected log %q not found in logs", expectedRequestLog)
+ expectedResponseParts := []string{
+ "STATUS: 200 OK",
+ "PROTO: HTTP/1.1",
+ "Content-Length: 21",
+ "Content-Type: application/json",
+ `"message": "success"`,
}
- if !strings.Contains(logInfoWithoutTimestamps, expectedResponseLog) {
- t.Fatalf("expected log %q not found in logs", expectedResponseLog)
+
+ for _, part := range expectedRequestParts {
+ if !strings.Contains(logInfo, part) {
+ t.Fatalf("expected request part %q not found in logs", part)
+ }
+ }
+ for _, part := range expectedResponseParts {
+ if !strings.Contains(logInfo, part) {
+ t.Fatalf("expected response part %q not found in logs", part)
+ }
}
}
@@ -521,26 +515,19 @@ func TestDoRequestLogging_Error(t *testing.T) {
logger := createLogger()
logger.l.SetOutput(&logBuffer) // Redirect log output to buffer
- client := &httpClient{
- httpClient: http.DefaultClient,
- debug: true,
- logger: logger,
- }
-
- params := RequestParams{
- Body: map[string]interface{}{
- "invalid": func() {},
- },
- }
+ client := NewClient(nil)
+ client.SetDebug(true)
+ client.SetLogger(logger)
- err := client.doRequest(context.Background(), http.MethodPost, "http://example.com", params)
- expectedErr := "failed to encode body"
+ // Create a request with an invalid method to simulate a request creation failure
+ err := client.doRequest(context.Background(), "bad method", "/foo/bar", requestParams{}, nil)
+ expectedErr := "failed to create request"
if err == nil || !strings.Contains(err.Error(), expectedErr) {
t.Fatalf("expected error %q, got: %v", expectedErr, err)
}
logInfo := logBuffer.String()
- expectedLog := "ERROR RESTY failed to encode body"
+ expectedLog := "ERROR failed to create request"
if !strings.Contains(logInfo, expectedLog) {
t.Fatalf("expected log %q not found in logs", expectedLog)
@@ -638,9 +625,9 @@ func TestClient_CustomRootCAWithoutCustomRoundTripper(t *testing.T) {
}
client := NewClient(test.httpClient)
- transport, err := client.resty.Transport()
- if err != nil {
- t.Fatal(err)
+ transport, ok := client.httpClient.Transport.(*http.Transport)
+ if !ok {
+ t.Fatal("expected *http.Transport")
}
if test.setCA && (transport.TLSClientConfig == nil || transport.TLSClientConfig.RootCAs == nil) {
t.Error("expected root CAs to be set")
@@ -669,39 +656,39 @@ func TestMonitorClient_SetAPIBasics(t *testing.T) {
client := NewMonitorClient(nil)
- if client.resty.BaseURL != defaultURL {
- t.Fatal(cmp.Diff(client.resty.BaseURL, defaultURL))
+ if client.hostURL != defaultURL {
+ t.Fatal(cmp.Diff(client.hostURL, defaultURL))
}
client.SetBaseURL(baseURL)
client.SetAPIVersion(apiVersion)
- if client.resty.BaseURL != expectedHost {
- t.Fatal(cmp.Diff(client.resty.BaseURL, expectedHost))
+ if client.hostURL != expectedHost {
+ t.Fatal(cmp.Diff(client.hostURL, expectedHost))
}
// Ensure setting twice does not cause conflicts
client.SetBaseURL(updatedBaseURL)
client.SetAPIVersion(updatedAPIVersion)
- if client.resty.BaseURL != updatedExpectedHost {
- t.Fatal(cmp.Diff(client.resty.BaseURL, updatedExpectedHost))
+ if client.hostURL != updatedExpectedHost {
+ t.Fatal(cmp.Diff(client.hostURL, updatedExpectedHost))
}
// Revert
client.SetBaseURL(baseURL)
client.SetAPIVersion(apiVersion)
- if client.resty.BaseURL != expectedHost {
- t.Fatal(cmp.Diff(client.resty.BaseURL, expectedHost))
+ if client.hostURL != expectedHost {
+ t.Fatal(cmp.Diff(client.hostURL, expectedHost))
}
// Custom protocol
client.SetBaseURL(protocolBaseURL)
client.SetAPIVersion(protocolAPIVersion)
- if client.resty.BaseURL != protocolExpectedHost {
- t.Fatal(cmp.Diff(client.resty.BaseURL, expectedHost))
+ if client.hostURL != protocolExpectedHost {
+ t.Fatal(cmp.Diff(client.hostURL, expectedHost))
}
}
@@ -787,7 +774,7 @@ func TestEnableLogSanitization(t *testing.T) {
"Authorization": []string{"Bearer " + plainTextToken},
}))
- _, err := mockClient.resty.R().Get("https://api.linode.com/v4/test")
+ err := mockClient.doRequest(context.Background(), http.MethodGet, "/test", requestParams{}, nil)
require.NoError(t, err)
logOutput := logBuf.String()
diff --git a/config_test.go b/config_test.go
index b4b3db418..628cc1415 100644
--- a/config_test.go
+++ b/config_test.go
@@ -42,11 +42,11 @@ func TestConfig_LoadWithDefaults(t *testing.T) {
expectedURL := "https://api.cool.linode.com/v4beta"
- if client.resty.BaseURL != expectedURL {
- t.Fatalf("mismatched host url: %s != %s", client.resty.BaseURL, expectedURL)
+ if client.hostURL != expectedURL {
+ t.Fatalf("mismatched host url: %s != %s", client.hostURL, expectedURL)
}
- if client.resty.Header.Get("Authorization") != "Bearer "+p.APIToken {
+ if client.header.Get("Authorization") != "Bearer "+p.APIToken {
t.Fatalf("token not found in auth header: %s", p.APIToken)
}
}
@@ -88,11 +88,11 @@ func TestConfig_OverrideDefaults(t *testing.T) {
expectedURL := "https://api.cool.linode.com/v4"
- if client.resty.BaseURL != expectedURL {
- t.Fatalf("mismatched host url: %s != %s", client.resty.BaseURL, expectedURL)
+ if client.hostURL != expectedURL {
+ t.Fatalf("mismatched host url: %s != %s", client.hostURL, expectedURL)
}
- if client.resty.Header.Get("Authorization") != "Bearer "+p.APIToken {
+ if client.header.Get("Authorization") != "Bearer "+p.APIToken {
t.Fatalf("token not found in auth header: %s", p.APIToken)
}
}
@@ -124,7 +124,7 @@ func TestConfig_NoDefaults(t *testing.T) {
t.Fatalf("mismatched api token: %s != %s", p.APIToken, "mytoken")
}
- if client.resty.Header.Get("Authorization") != "Bearer "+p.APIToken {
+ if client.header.Get("Authorization") != "Bearer "+p.APIToken {
t.Fatalf("token not found in auth header: %s", p.APIToken)
}
}
diff --git a/errors.go b/errors.go
index 873b40450..db7fc2a34 100644
--- a/errors.go
+++ b/errors.go
@@ -1,7 +1,7 @@
package linodego
import (
- "encoding/json"
+ "bytes"
"errors"
"fmt"
"io"
@@ -9,8 +9,6 @@ import (
"reflect"
"slices"
"strings"
-
- "github.com/go-resty/resty/v2"
)
const (
@@ -49,74 +47,43 @@ type APIError struct {
Errors []APIErrorReason `json:"errors"`
}
-// String returns the error reason in a formatted string
-func (r APIErrorReason) String() string {
- return fmt.Sprintf("[%s] %s", r.Field, r.Reason)
-}
-
-func coupleAPIErrors(r *resty.Response, err error) (*resty.Response, error) {
+//nolint:nestif,unparam
+func coupleAPIErrors(resp *http.Response, err error) (*http.Response, error) {
if err != nil {
- // an error was raised in go code, no need to check the resty Response
return nil, NewError(err)
}
- if r.Error() == nil {
- // no error in the resty Response
- return r, nil
- }
-
- // handle the resty Response errors
-
- // Check that response is of the correct content-type before unmarshalling
- expectedContentType := r.Request.Header.Get("Accept")
- responseContentType := r.Header().Get("Content-Type")
-
- // If the upstream Linode API server being fronted fails to respond to the request,
- // the http server will respond with a default "Bad Gateway" page with Content-Type
- // "text/html".
- if r.StatusCode() == http.StatusBadGateway && responseContentType == "text/html" { //nolint:goconst
- return nil, Error{Code: http.StatusBadGateway, Message: http.StatusText(http.StatusBadGateway)}
- }
-
- if responseContentType != expectedContentType {
- msg := fmt.Sprintf(
- "Unexpected Content-Type: Expected: %v, Received: %v\nResponse body: %s",
- expectedContentType,
- responseContentType,
- string(r.Body()),
- )
-
- return nil, Error{Code: r.StatusCode(), Message: msg}
- }
-
- apiError, ok := r.Error().(*APIError)
- if !ok || (ok && len(apiError.Errors) == 0) {
- return r, nil
+ if resp == nil {
+ return nil, NewError(fmt.Errorf("response is nil"))
}
- return nil, NewError(r)
-}
-
-//nolint:unused
-func coupleAPIErrorsHTTP(resp *http.Response, err error) (*http.Response, error) {
- if err != nil {
- // an error was raised in go code, no need to check the http.Response
- return nil, NewError(err)
- }
-
- if resp == nil || resp.StatusCode < 200 || resp.StatusCode >= 300 {
+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {
// Check that response is of the correct content-type before unmarshalling
- expectedContentType := resp.Request.Header.Get("Accept")
+ expectedContentType := ""
+ if resp.Request != nil && resp.Request.Header != nil {
+ expectedContentType = resp.Request.Header.Get("Accept")
+ }
+
responseContentType := resp.Header.Get("Content-Type")
// If the upstream server fails to respond to the request,
- // the http server will respond with a default error page with Content-Type "text/html".
- if resp.StatusCode == http.StatusBadGateway && responseContentType == "text/html" { //nolint:goconst
- return nil, Error{Code: http.StatusBadGateway, Message: http.StatusText(http.StatusBadGateway)}
+ // the HTTP server will respond with a default error page with Content-Type "text/html".
+ if resp.StatusCode == http.StatusBadGateway && responseContentType == "text/html" {
+ return nil, &Error{Code: http.StatusBadGateway, Message: http.StatusText(http.StatusBadGateway), Response: resp}
}
if responseContentType != expectedContentType {
- bodyBytes, _ := io.ReadAll(resp.Body)
+ if resp.Body == nil {
+ return nil, NewError(fmt.Errorf("response body is nil"))
+ }
+
+ bodyBytes, readErr := io.ReadAll(resp.Body)
+ if readErr != nil {
+ return nil, NewError(fmt.Errorf("failed to read response body: %w", readErr))
+ }
+
+ resp.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+
msg := fmt.Sprintf(
"Unexpected Content-Type: Expected: %v, Received: %v\nResponse body: %s",
expectedContentType,
@@ -124,22 +91,22 @@ func coupleAPIErrorsHTTP(resp *http.Response, err error) (*http.Response, error)
string(bodyBytes),
)
- return nil, Error{Code: resp.StatusCode, Message: msg}
+ return nil, &Error{Code: resp.StatusCode, Message: msg, Response: resp}
}
- var apiError APIError
- if err := json.NewDecoder(resp.Body).Decode(&apiError); err != nil {
- return nil, NewError(fmt.Errorf("failed to decode response body: %w", err))
+ // Must check if there is no list of reasons in the error before making a call to NewError
+ apiError, ok := getAPIError(resp)
+ if !ok {
+ return nil, NewError(fmt.Errorf("failed to decode response body"))
}
if len(apiError.Errors) == 0 {
return resp, nil
}
- return nil, Error{Code: resp.StatusCode, Message: apiError.Errors[0].String()}
+ return nil, NewError(resp)
}
- // no error in the http.Response
return resp, nil
}
@@ -156,7 +123,7 @@ func (e APIError) Error() string {
// - ErrorFromString (1) from a string
// - ErrorFromError (2) for an error
// - ErrorFromStringer (3) for a Stringer
-// - HTTP Status Codes (100-600) for a resty.Response object
+// - HTTP Status Codes (100-600) for a http.Response object
func NewError(err any) *Error {
if err == nil {
return nil
@@ -165,17 +132,17 @@ func NewError(err any) *Error {
switch e := err.(type) {
case *Error:
return e
- case *resty.Response:
- apiError, ok := e.Error().(*APIError)
+ case *http.Response:
+ apiError, ok := getAPIError(e)
if !ok {
- return &Error{Code: ErrorUnsupported, Message: "Unexpected Resty Error Response, no error"}
+ return &Error{Code: ErrorUnsupported, Message: "Unexpected HTTP Error Response, no error"}
}
return &Error{
- Code: e.RawResponse.StatusCode,
+ Code: e.StatusCode,
Message: apiError.Error(),
- Response: e.RawResponse,
+ Response: e,
}
case error:
return &Error{Code: ErrorFromError, Message: e.Error()}
diff --git a/errors_test.go b/errors_test.go
index 68428fcd6..4a182c36e 100644
--- a/errors_test.go
+++ b/errors_test.go
@@ -9,9 +9,10 @@ import (
"io"
"net/http"
"net/http/httptest"
+ "strconv"
+ "strings"
"testing"
- "github.com/go-resty/resty/v2"
"github.com/google/go-cmp/cmp"
)
@@ -27,10 +28,10 @@ func (e testError) Error() string {
return string(e)
}
-func restyError(reason, field string) *resty.Response {
+func httpError(reason, field string) *http.Response {
var reasons []APIErrorReason
- // allow for an empty reasons
+ // Allow for an empty reasons
if reason != "" && field != "" {
reasons = append(reasons, APIErrorReason{
Reason: reason,
@@ -38,15 +39,18 @@ func restyError(reason, field string) *resty.Response {
})
}
- return &resty.Response{
- RawResponse: &http.Response{
- StatusCode: 500,
- },
- Request: &resty.Request{
- Error: &APIError{
- Errors: reasons,
- },
- },
+ apiError := &APIError{
+ Errors: reasons,
+ }
+
+ body, err := json.Marshal(apiError)
+ if err != nil {
+ panic("Failed to marshal APIError")
+ }
+
+ return &http.Response{
+ StatusCode: 500,
+ Body: io.NopCloser(bytes.NewReader(body)),
}
}
@@ -73,12 +77,12 @@ func TestNewError(t *testing.T) {
t.Error("Error should be itself")
}
- if err := NewError(&resty.Response{Request: &resty.Request{}}); err.Message != "Unexpected Resty Error Response, no error" {
- t.Error("Unexpected Resty Error Response, no error")
+ if err := NewError(&http.Response{Request: &http.Request{}}); err.Message != "Unexpected HTTP Error Response, no error" {
+ t.Error("Unexpected HTTP Error Response, no error")
}
- if err := NewError(restyError("testreason", "testfield")); err.Message != "[testfield] testreason" {
- t.Error("rest response error should should be set")
+ if err := NewError(httpError("testreason", "testfield")); err.Message != "[testfield] testreason" {
+ t.Error("http response error should should be set")
}
if err := NewError("stringerror"); err.Message != "stringerror" || err.Code != ErrorFromString {
@@ -119,98 +123,6 @@ func TestCoupleAPIErrors(t *testing.T) {
}
})
- t.Run("resty 500 response error with reasons", func(t *testing.T) {
- if _, err := coupleAPIErrors(restyError("testreason", "testfield"), nil); err.Error() != "[500] [testfield] testreason" {
- t.Error("resty error should return with proper format [code] [field] reason")
- }
- })
-
- t.Run("resty 500 response error without reasons", func(t *testing.T) {
- if _, err := coupleAPIErrors(restyError("", ""), nil); err != nil {
- t.Error("resty error with no reasons should return no error")
- }
- })
-
- t.Run("resty response with nil error", func(t *testing.T) {
- emptyErr := &resty.Response{
- RawResponse: &http.Response{
- StatusCode: 500,
- },
- Request: &resty.Request{
- Error: nil,
- },
- }
- if _, err := coupleAPIErrors(emptyErr, nil); err != nil {
- t.Error("resty error with no reasons should return no error")
- }
- })
-
- t.Run("generic html error", func(t *testing.T) {
- rawResponse := `
-500 Internal Server Error
-
-500 Internal Server Error
-
nginx
-
-`
- route := "/v4/linode/instances/123"
- ts, client := createTestServer(http.MethodGet, route, "text/html", rawResponse, http.StatusInternalServerError)
- // client.SetDebug(true)
- defer ts.Close()
-
- expectedError := Error{
- Code: http.StatusInternalServerError,
- Message: "Unexpected Content-Type: Expected: application/json, Received: text/html\nResponse body: " + rawResponse,
- }
-
- _, err := coupleAPIErrors(client.R(context.Background()).SetResult(&Instance{}).Get(ts.URL + route))
- if diff := cmp.Diff(expectedError, err); diff != "" {
- t.Errorf("expected error to match but got diff:\n%s", diff)
- }
- })
-
- t.Run("bad gateway error", func(t *testing.T) {
- rawResponse := []byte(`
-502 Bad Gateway
-
-502 Bad Gateway
-
nginx
-
-`)
- buf := io.NopCloser(bytes.NewBuffer(rawResponse))
-
- resp := &resty.Response{
- Request: &resty.Request{
- Error: errors.New("Bad Gateway"),
- },
- RawResponse: &http.Response{
- Header: http.Header{
- "Content-Type": []string{"text/html"},
- },
- StatusCode: http.StatusBadGateway,
- Body: buf,
- },
- }
-
- expectedError := Error{
- Code: http.StatusBadGateway,
- Message: http.StatusText(http.StatusBadGateway),
- }
-
- if _, err := coupleAPIErrors(resp, nil); !cmp.Equal(err, expectedError) {
- t.Errorf("expected error %#v to match error %#v", err, expectedError)
- }
- })
-}
-
-func TestCoupleAPIErrorsHTTP(t *testing.T) {
- t.Run("not nil error generates error", func(t *testing.T) {
- err := errors.New("test")
- if _, err := coupleAPIErrorsHTTP(nil, err); !cmp.Equal(err, NewError(err)) {
- t.Errorf("expect a not nil error to be returned as an Error")
- }
- })
-
t.Run("http 500 response error with reasons", func(t *testing.T) {
// Create the simulated HTTP response with a 500 status and a JSON body containing the error details
apiError := APIError{
@@ -228,7 +140,7 @@ func TestCoupleAPIErrorsHTTP(t *testing.T) {
Request: &http.Request{Header: http.Header{"Accept": []string{"application/json"}}},
}
- _, err := coupleAPIErrorsHTTP(resp, nil)
+ _, err := coupleAPIErrors(resp, nil)
expectedMessage := "[500] [testfield] testreason"
if err == nil || err.Error() != expectedMessage {
t.Errorf("expected error message %q, got: %v", expectedMessage, err)
@@ -250,7 +162,7 @@ func TestCoupleAPIErrorsHTTP(t *testing.T) {
Request: &http.Request{Header: http.Header{"Accept": []string{"application/json"}}},
}
- _, err := coupleAPIErrorsHTTP(resp, nil)
+ _, err := coupleAPIErrors(resp, nil)
if err != nil {
t.Error("http error with no reasons should return no error")
}
@@ -265,7 +177,7 @@ func TestCoupleAPIErrorsHTTP(t *testing.T) {
Request: &http.Request{Header: http.Header{"Accept": []string{"application/json"}}},
}
- _, err := coupleAPIErrorsHTTP(resp, nil)
+ _, err := coupleAPIErrors(resp, nil)
if err != nil {
t.Error("http error with no reasons should return no error")
}
@@ -288,15 +200,10 @@ func TestCoupleAPIErrorsHTTP(t *testing.T) {
}))
defer ts.Close()
- client := &httpClient{
+ client := &Client{
httpClient: ts.Client(),
}
- expectedError := Error{
- Code: http.StatusInternalServerError,
- Message: "Unexpected Content-Type: Expected: application/json, Received: text/html\nResponse body: " + rawResponse,
- }
-
req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, ts.URL+route, nil)
if err != nil {
t.Fatalf("failed to create request: %v", err)
@@ -308,11 +215,23 @@ func TestCoupleAPIErrorsHTTP(t *testing.T) {
if err != nil {
t.Fatalf("failed to send request: %v", err)
}
+
+ expectedError := &Error{
+ Response: resp,
+ Code: http.StatusInternalServerError,
+ Message: "Unexpected Content-Type: Expected: application/json, Received: text/html\nResponse body: " + rawResponse,
+ }
+
defer resp.Body.Close()
- _, err = coupleAPIErrorsHTTP(resp, nil)
- if diff := cmp.Diff(expectedError, err); diff != "" {
- t.Errorf("expected error to match but got diff:\n%s", diff)
+ _, err = coupleAPIErrors(resp, nil)
+
+ if !strings.Contains(err.Error(), strconv.Itoa(expectedError.Code)) {
+ t.Errorf("expected error code %d, got %d", expectedError.Code, resp.StatusCode)
+ }
+
+ if !strings.Contains(err.Error(), expectedError.Message) {
+ t.Errorf("expected error message %s, got %s", expectedError.Message, err.Error())
}
})
@@ -337,14 +256,19 @@ func TestCoupleAPIErrorsHTTP(t *testing.T) {
},
}
- expectedError := Error{
- Code: http.StatusBadGateway,
- Message: http.StatusText(http.StatusBadGateway),
+ expectedError := &Error{
+ Response: resp,
+ Code: http.StatusBadGateway,
+ Message: http.StatusText(http.StatusBadGateway),
+ }
+
+ _, err := coupleAPIErrors(resp, nil)
+ if !strings.Contains(err.Error(), strconv.Itoa(expectedError.Code)) {
+ t.Errorf("expected error code %d, got %d", expectedError.Code, resp.StatusCode)
}
- _, err := coupleAPIErrorsHTTP(resp, nil)
- if !cmp.Equal(err, expectedError) {
- t.Errorf("expected error %#v to match error %#v", err, expectedError)
+ if !strings.Contains(err.Error(), expectedError.Message) {
+ t.Errorf("expected error message %s, got %s", expectedError.Message, err.Error())
}
})
}
@@ -382,26 +306,26 @@ func TestErrorIs(t *testing.T) {
expectedResult: true,
},
{
- testName: "default and Error from empty resty error",
- err1: NewError(restyError("", "")),
+ testName: "default and Error from empty http error",
+ err1: NewError(httpError("", "")),
err2: defaultError,
expectedResult: true,
},
{
- testName: "default and Error from resty error with field",
- err1: NewError(restyError("", "test field")),
+ testName: "default and Error from http error with field",
+ err1: NewError(httpError("", "test field")),
err2: defaultError,
expectedResult: true,
},
{
- testName: "default and Error from resty error with field and reason",
- err1: NewError(restyError("test reason", "test field")),
+ testName: "default and Error from http error with field and reason",
+ err1: NewError(httpError("test reason", "test field")),
err2: defaultError,
expectedResult: true,
},
{
- testName: "default and Error from resty error with reason",
- err1: NewError(restyError("test reason", "")),
+ testName: "default and Error from http error with reason",
+ err1: NewError(httpError("test reason", "")),
err2: defaultError,
expectedResult: true,
},
diff --git a/go.mod b/go.mod
index b00d38c4c..6cc016482 100644
--- a/go.mod
+++ b/go.mod
@@ -1,7 +1,6 @@
module github.com/linode/linodego
require (
- github.com/go-resty/resty/v2 v2.17.2
github.com/google/go-cmp v0.7.0
github.com/google/go-querystring v1.2.0
github.com/jarcoal/httpmock v1.4.1
diff --git a/go.sum b/go.sum
index fcb368761..5b27625ab 100644
--- a/go.sum
+++ b/go.sum
@@ -1,8 +1,6 @@
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/go-resty/resty/v2 v2.17.2 h1:FQW5oHYcIlkCNrMD2lloGScxcHJ0gkjshV3qcQAyHQk=
-github.com/go-resty/resty/v2 v2.17.2/go.mod h1:kCKZ3wWmwJaNc7S29BRtUhJwy7iqmn+2mLtQrOyQlVA=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
@@ -29,8 +27,6 @@ golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
-golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
-golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/ini.v1 v1.67.1 h1:tVBILHy0R6e4wkYOn3XmiITt/hEVH4TFMYvAX2Ytz6k=
diff --git a/images.go b/images.go
index 5fdf644fb..da2287047 100644
--- a/images.go
+++ b/images.go
@@ -4,9 +4,9 @@ import (
"context"
"encoding/json"
"io"
+ "net/http"
"time"
- "github.com/go-resty/resty/v2"
"github.com/linode/linodego/internal/parseabletime"
)
@@ -297,17 +297,48 @@ func (c *Client) CreateImageUpload(ctx context.Context, opts ImageCreateUploadOp
// UploadImageToURL uploads the given image to the given upload URL.
func (c *Client) UploadImageToURL(ctx context.Context, uploadURL string, image io.Reader) error {
- // Linode-specific headers do not need to be sent to this endpoint
- req := resty.New().SetDebug(c.resty.Debug).R().
- SetContext(ctx).
- SetContentLength(true).
- SetHeader("Content-Type", "application/octet-stream").
- SetBody(image)
+ clonedClient := *c.httpClient
+ clonedClient.Transport = http.DefaultTransport
- _, err := coupleAPIErrors(req.
- Put(uploadURL))
+ var contentLength int64 = -1
- return err
+ if seeker, ok := image.(io.Seeker); ok {
+ size, err := seeker.Seek(0, io.SeekEnd)
+ if err != nil {
+ return err
+ }
+
+ _, err = seeker.Seek(0, io.SeekStart)
+ if err != nil {
+ return err
+ }
+
+ contentLength = size
+ }
+
+ req, err := http.NewRequestWithContext(ctx, http.MethodPut, uploadURL, image)
+ if err != nil {
+ return err
+ }
+
+ if contentLength >= 0 {
+ req.ContentLength = contentLength
+ }
+
+ req.Header.Set("Content-Type", "application/octet-stream")
+ req.Header.Set("User-Agent", c.userAgent)
+
+ resp, err := clonedClient.Do(req)
+ if resp != nil && resp.Body != nil {
+ defer resp.Body.Close()
+ }
+
+ _, err = coupleAPIErrors(resp, err)
+ if err != nil {
+ return err
+ }
+
+ return nil
}
// UploadImage creates and uploads an image.
diff --git a/internal/testutil/mock.go b/internal/testutil/mock.go
index c8235ce65..752b27f9f 100644
--- a/internal/testutil/mock.go
+++ b/internal/testutil/mock.go
@@ -116,15 +116,15 @@ type TestLogger struct {
}
func (l *TestLogger) Errorf(format string, v ...any) {
- l.outputf("ERROR RESTY "+format, v...)
+ l.outputf("ERROR "+format, v...)
}
func (l *TestLogger) Warnf(format string, v ...any) {
- l.outputf("WARN RESTY "+format, v...)
+ l.outputf("WARN "+format, v...)
}
func (l *TestLogger) Debugf(format string, v ...any) {
- l.outputf("DEBUG RESTY "+format, v...)
+ l.outputf("DEBUG "+format, v...)
}
func (l *TestLogger) outputf(format string, v ...any) {
diff --git a/k8s/go.mod b/k8s/go.mod
index 4e148b8c5..fe876ba3c 100644
--- a/k8s/go.mod
+++ b/k8s/go.mod
@@ -14,7 +14,6 @@ require (
github.com/go-openapi/jsonpointer v0.19.6 // indirect
github.com/go-openapi/jsonreference v0.20.2 // indirect
github.com/go-openapi/swag v0.22.3 // indirect
- github.com/go-resty/resty/v2 v2.17.2 // indirect
github.com/gogo/protobuf v1.3.2 // indirect
github.com/golang/protobuf v1.5.4 // indirect
github.com/google/gnostic-models v0.6.8 // indirect
diff --git a/k8s/go.sum b/k8s/go.sum
index 4e571690a..f93e11a91 100644
--- a/k8s/go.sum
+++ b/k8s/go.sum
@@ -12,8 +12,6 @@ github.com/go-openapi/jsonreference v0.20.2 h1:3sVjiK66+uXK/6oQ8xgcRKcFgQ5KXa2Kv
github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En5Ap4rVB5KVcIDZG2k=
github.com/go-openapi/swag v0.22.3 h1:yMBqmnQ0gyZvEb/+KzuWZOXgllrXT4SADYbvDaXHv/g=
github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14=
-github.com/go-resty/resty/v2 v2.17.2 h1:FQW5oHYcIlkCNrMD2lloGScxcHJ0gkjshV3qcQAyHQk=
-github.com/go-resty/resty/v2 v2.17.2/go.mod h1:kCKZ3wWmwJaNc7S29BRtUhJwy7iqmn+2mLtQrOyQlVA=
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
diff --git a/logger.go b/logger.go
index 890327e2b..fc9504b50 100644
--- a/logger.go
+++ b/logger.go
@@ -1,52 +1,54 @@
package linodego
import (
+ "fmt"
"log"
"os"
+ "strings"
)
-//nolint:unused
-type httpLogger interface {
+type Logger interface {
Errorf(format string, v ...any)
Warnf(format string, v ...any)
Debugf(format string, v ...any)
}
-//nolint:unused
type logger struct {
l *log.Logger
}
-//nolint:unused
func createLogger() *logger {
l := &logger{l: log.New(os.Stderr, "", log.Ldate|log.Lmicroseconds)}
return l
}
-//nolint:unused
-var _ httpLogger = (*logger)(nil)
+var _ Logger = (*logger)(nil)
-//nolint:unused
func (l *logger) Errorf(format string, v ...any) {
- l.output("ERROR RESTY "+format, v...)
+ l.output("ERROR "+format, v...)
}
-//nolint:unused
func (l *logger) Warnf(format string, v ...any) {
- l.output("WARN RESTY "+format, v...)
+ l.output("WARN "+format, v...)
}
-//nolint:unused
func (l *logger) Debugf(format string, v ...any) {
- l.output("DEBUG RESTY "+format, v...)
+ l.output("DEBUG "+format, v...)
}
-//nolint:unused
func (l *logger) output(format string, v ...any) { //nolint:goprintffuncname
+ // Render the final message first, then sanitize control characters
+ // to prevent log injection via both the format string and variadic args.
+ var msg string
if len(v) == 0 {
- l.l.Print(format)
- return
+ msg = format
+ } else {
+ msg = fmt.Sprintf(format, v...)
}
- l.l.Printf(format, v...)
+ msg = strings.ReplaceAll(msg, "\r\n", "\\n")
+ msg = strings.ReplaceAll(msg, "\r", "\\n")
+ msg = strings.ReplaceAll(msg, "\n", "\\n")
+
+ l.l.Print(msg)
}
diff --git a/monitor_alert_definitions.go b/monitor_alert_definitions.go
index 730665655..7988ab673 100644
--- a/monitor_alert_definitions.go
+++ b/monitor_alert_definitions.go
@@ -1,8 +1,10 @@
package linodego
import (
+ "bytes"
"context"
"encoding/json"
+ "net/http"
"time"
"github.com/linode/linodego/internal/parseabletime"
@@ -263,25 +265,28 @@ func (c *Client) CreateMonitorAlertDefinitionWithIdempotency(
var result AlertDefinition
- req := c.R(ctx).SetResult(&result)
-
- if idempotencyKey != "" {
- req.SetHeader("Idempotency-Key", idempotencyKey)
- }
-
body, err := json.Marshal(opts)
if err != nil {
return nil, err
}
- req.SetBody(string(body))
+ params := requestParams{
+ Response: &result,
+ Body: bytes.NewReader(body),
+ }
+
+ if idempotencyKey != "" {
+ params.Headers = http.Header{
+ "Idempotency-Key": {idempotencyKey},
+ }
+ }
- r, err := coupleAPIErrors(req.Post(e))
+ err = c.doRequest(ctx, http.MethodPost, e, params, nil)
if err != nil {
return nil, err
}
- return r.Result().(*AlertDefinition), nil
+ return &result, nil
}
// UpdateMonitorAlertDefinition updates an ACLP Monitor Alert Definition.
diff --git a/monitor_api_services.go b/monitor_api_services.go
index 9d379353e..a7ee4ca6d 100644
--- a/monitor_api_services.go
+++ b/monitor_api_services.go
@@ -4,8 +4,10 @@
package linodego
import (
+ "bytes"
"context"
"encoding/json"
+ "net/http"
"time"
)
@@ -101,7 +103,11 @@ type MetricAbsoluteTimeDuration struct {
func (mc *MonitorClient) FetchEntityMetrics(ctx context.Context, serviceType string, opts *EntityMetricsFetchOptions) (*EntityMetrics, error) {
endpoint := formatAPIPath("monitor/services/%s/metrics", serviceType)
- req := mc.R(ctx).SetResult(&EntityMetrics{})
+ var result EntityMetrics
+
+ params := requestParams{
+ Response: &result,
+ }
if opts != nil {
body, err := json.Marshal(opts)
@@ -109,13 +115,13 @@ func (mc *MonitorClient) FetchEntityMetrics(ctx context.Context, serviceType str
return nil, err
}
- req.SetBody(string(body))
+ params.Body = bytes.NewReader(body)
}
- r, err := coupleAPIErrors(req.Post(endpoint))
+ err := mc.doRequest(ctx, http.MethodPost, endpoint, params)
if err != nil {
return nil, err
}
- return r.Result().(*EntityMetrics), nil
+ return &result, nil
}
diff --git a/pagination.go b/pagination.go
index 074720e82..b0fec7040 100644
--- a/pagination.go
+++ b/pagination.go
@@ -9,10 +9,9 @@ import (
"encoding/hex"
"encoding/json"
"fmt"
+ "net/http"
"reflect"
"strconv"
-
- "github.com/go-resty/resty/v2"
)
// PageOptions are the pagination parameters for List endpoints
@@ -56,38 +55,51 @@ func (l ListOptions) Hash() (string, error) {
return hex.EncodeToString(h.Sum(nil)), nil
}
-func applyListOptionsToRequest(opts *ListOptions, req *resty.Request) error {
+func createListOptionsToRequestMutator(opts *ListOptions) func(*http.Request) error {
if opts == nil {
return nil
}
- if opts.QueryParams != nil {
- params, err := flattenQueryStruct(opts.QueryParams)
- if err != nil {
- return fmt.Errorf("failed to apply list options: %w", err)
+ // Return a mutator to apply query parameters and headers
+ return func(req *http.Request) error {
+ query := req.URL.Query()
+
+ // Apply QueryParams from ListOptions if present
+ if opts.QueryParams != nil {
+ params, err := flattenQueryStruct(opts.QueryParams)
+ if err != nil {
+ return fmt.Errorf("failed to apply list options: %w", err)
+ }
+
+ for key, value := range params {
+ query.Set(key, value)
+ }
}
- req.SetQueryParams(params)
- }
+ // Apply pagination options
+ if opts.PageOptions != nil && opts.Page > 0 {
+ query.Set("page", strconv.Itoa(opts.Page))
+ }
- if opts.PageOptions != nil && opts.Page > 0 {
- req.SetQueryParam("page", strconv.Itoa(opts.Page))
- }
+ if opts.PageSize > 0 {
+ query.Set("page_size", strconv.Itoa(opts.PageSize))
+ }
- if opts.PageSize > 0 {
- req.SetQueryParam("page_size", strconv.Itoa(opts.PageSize))
- }
+ // Apply filters as headers
+ if len(opts.Filter) > 0 {
+ req.Header.Set("X-Filter", opts.Filter)
+ }
- if len(opts.Filter) > 0 {
- req.SetHeader("X-Filter", opts.Filter)
- }
+ // Assign the updated query back to the request URL
+ req.URL.RawQuery = query.Encode()
- return nil
+ return nil
+ }
}
type PagedResponse interface {
endpoint(...any) string
- castResult(*resty.Request, string) (int, int, error)
+ castResult(*http.Request, string) (int, int, error)
}
// flattenQueryStruct flattens a structure into a Resty-compatible query param map.
diff --git a/request_helpers.go b/request_helpers.go
index d70e515ea..e50e4ec6d 100644
--- a/request_helpers.go
+++ b/request_helpers.go
@@ -1,9 +1,11 @@
package linodego
import (
+ "bytes"
"context"
"encoding/json"
"fmt"
+ "net/http"
"net/url"
"reflect"
)
@@ -60,56 +62,33 @@ func handlePaginatedResults[T any, O any](
handlePage := func(page int) error {
var resultType paginatedResponse[T]
- // Override the page to be applied in applyListOptionsToRequest(...)
+ // Override the page to be applied in createListOptionsToRequestMutator(...)
opts.Page = page
- // This request object cannot be reused for each page request
- // because it can lead to possible data corruption
- req := client.R(ctx).SetResult(&resultType)
-
- // Apply all user-provided list options to the request
- if err := applyListOptionsToRequest(opts, req); err != nil {
- return err
+ params := requestParams{
+ Response: &resultType,
}
- // Set request body if provided
if reqBody != "" {
- req.SetBody(reqBody)
+ params.Body = bytes.NewReader([]byte(reqBody))
}
- var response *paginatedResponse[T]
- // Execute the appropriate HTTP method
- switch method {
- case "GET":
- res, err := coupleAPIErrors(req.Get(endpoint))
- if err != nil {
- return err
- }
-
- response = res.Result().(*paginatedResponse[T])
- case "PUT":
- res, err := coupleAPIErrors(req.Put(endpoint))
- if err != nil {
- return err
- }
-
- response = res.Result().(*paginatedResponse[T])
- case "POST":
- res, err := coupleAPIErrors(req.Post(endpoint))
- if err != nil {
- return err
- }
-
- response = res.Result().(*paginatedResponse[T])
- default:
- return fmt.Errorf("unsupported HTTP method: %s", method)
+ // Create a mutator to apply all user-provided list options to the request
+ mutator := createListOptionsToRequestMutator(opts)
+
+ // Make the request using doRequest
+ err := client.doRequest(ctx, method, endpoint, params, &mutator)
+ if err != nil {
+ return err
}
// Update pagination metadata
opts.Page = page
- opts.Pages = response.Pages
- opts.Results = response.Results
- result = append(result, response.Data...)
+ opts.Pages = resultType.Pages
+ opts.Results = resultType.Results
+
+ // Append the data to the result slice
+ result = append(result, resultType.Data...)
return nil
}
@@ -127,13 +106,12 @@ func handlePaginatedResults[T any, O any](
return nil, err
}
- // If the user has explicitly specified a page, we don't
- // need to get any other pages.
+ // If a specific page is defined, return the result
if pageDefined {
return result, nil
}
- // Get the rest of the pages
+ // Get the remaining pages
for page := 2; page <= opts.Pages; page++ {
if err := handlePage(page); err != nil {
return nil, err
@@ -187,14 +165,16 @@ func doGETRequest[T any](
) (*T, error) {
var resultType T
- req := client.R(ctx).SetResult(&resultType)
+ params := requestParams{
+ Response: &resultType,
+ }
- r, err := coupleAPIErrors(req.Get(endpoint))
+ err := client.doRequest(ctx, http.MethodGet, endpoint, params, nil)
if err != nil {
return nil, err
}
- return r.Result().(*T), nil
+ return &resultType, nil
}
// doPOSTRequest runs a PUT request using the given client, API endpoint,
@@ -208,12 +188,13 @@ func doPOSTRequest[T, O any](
var resultType T
numOpts := len(options)
-
if numOpts > 1 {
- return nil, fmt.Errorf("invalid number of options: %d", len(options))
+ return nil, fmt.Errorf("invalid number of options: %d", numOpts)
}
- req := client.R(ctx).SetResult(&resultType)
+ params := requestParams{
+ Response: &resultType,
+ }
if numOpts > 0 && !isNil(options[0]) {
body, err := json.Marshal(options[0])
@@ -221,15 +202,15 @@ func doPOSTRequest[T, O any](
return nil, err
}
- req.SetBody(string(body))
+ params.Body = bytes.NewReader(body)
}
- r, err := coupleAPIErrors(req.Post(endpoint))
+ err := client.doRequest(ctx, http.MethodPost, endpoint, params, nil)
if err != nil {
return nil, err
}
- return r.Result().(*T), nil
+ return &resultType, nil
}
// doPOSTRequestNoResponseBody runs a POST request using the given client, API endpoint,
@@ -241,6 +222,7 @@ func doPOSTRequestNoResponseBody[T any](
options ...T,
) error {
_, err := doPOSTRequest[any, T](ctx, client, endpoint, options...)
+
return err
}
@@ -265,12 +247,13 @@ func doPUTRequest[T, O any](
var resultType T
numOpts := len(options)
-
if numOpts > 1 {
- return nil, fmt.Errorf("invalid number of options: %d", len(options))
+ return nil, fmt.Errorf("invalid number of options: %d", numOpts)
}
- req := client.R(ctx).SetResult(&resultType)
+ params := requestParams{
+ Response: &resultType,
+ }
if numOpts > 0 && !isNil(options[0]) {
body, err := json.Marshal(options[0])
@@ -278,15 +261,15 @@ func doPUTRequest[T, O any](
return nil, err
}
- req.SetBody(string(body))
+ params.Body = bytes.NewReader(body)
}
- r, err := coupleAPIErrors(req.Put(endpoint))
+ err := client.doRequest(ctx, http.MethodPut, endpoint, params, nil)
if err != nil {
return nil, err
}
- return r.Result().(*T), nil
+ return &resultType, nil
}
// doDELETERequest runs a DELETE request using the given client
@@ -296,8 +279,8 @@ func doDELETERequest(
client *Client,
endpoint string,
) error {
- req := client.R(ctx)
- _, err := coupleAPIErrors(req.Delete(endpoint))
+ params := requestParams{}
+ err := client.doRequest(ctx, http.MethodDelete, endpoint, params, nil)
return err
}
diff --git a/request_helpers_test.go b/request_helpers_test.go
index ce4bf80b5..033c86628 100644
--- a/request_helpers_test.go
+++ b/request_helpers_test.go
@@ -80,11 +80,8 @@ func TestRequestHelpers_post(t *testing.T) {
func TestRequestHelpers_postNoOptions(t *testing.T) {
client := testutil.CreateMockClient(t, NewClient)
- httpmock.RegisterRegexpResponder(
- "POST",
- testutil.MockRequestURL("/foo/bar"),
- testutil.MockRequestBodyValidateNoBody(t, testResponse),
- )
+ httpmock.RegisterRegexpResponder("POST", testutil.MockRequestURL("/foo/bar"),
+ testutil.MockRequestBodyValidateNoBody(t, testResponse))
result, err := doPOSTRequest[testResultType, any](
context.Background(),
@@ -124,11 +121,8 @@ func TestRequestHelpers_put(t *testing.T) {
func TestRequestHelpers_putNoOptions(t *testing.T) {
client := testutil.CreateMockClient(t, NewClient)
- httpmock.RegisterRegexpResponder(
- "PUT",
- testutil.MockRequestURL("/foo/bar"),
- testutil.MockRequestBodyValidateNoBody(t, testResponse),
- )
+ httpmock.RegisterRegexpResponder("PUT", testutil.MockRequestURL("/foo/bar"),
+ testutil.MockRequestBodyValidateNoBody(t, testResponse))
result, err := doPUTRequest[testResultType, any](
context.Background(),
@@ -147,11 +141,8 @@ func TestRequestHelpers_putNoOptions(t *testing.T) {
func TestRequestHelpers_delete(t *testing.T) {
client := testutil.CreateMockClient(t, NewClient)
- httpmock.RegisterRegexpResponder(
- "DELETE",
- testutil.MockRequestURL("/foo/bar/foo%20bar"),
- httpmock.NewStringResponder(200, "{}"),
- )
+ httpmock.RegisterRegexpResponder("DELETE", testutil.MockRequestURL("/foo/bar/foo%20bar"),
+ httpmock.NewStringResponder(200, "{}"))
if err := doDELETERequest(
context.Background(),
@@ -169,14 +160,8 @@ func TestRequestHelpers_paginateAll(t *testing.T) {
numRequests := 0
- httpmock.RegisterRegexpResponder(
- "GET",
- testutil.MockRequestURL("/foo/bar"),
- mockPaginatedResponse(
- buildPaginatedEntries(totalResults),
- &numRequests,
- ),
- )
+ httpmock.RegisterRegexpResponder("GET", testutil.MockRequestURL("/foo/bar"),
+ mockPaginatedResponse(buildPaginatedEntries(totalResults), &numRequests))
response, err := getPaginatedResults[testResultType](
context.Background(),
@@ -205,14 +190,8 @@ func TestRequestHelpers_paginateSingle(t *testing.T) {
numRequests := 0
- httpmock.RegisterRegexpResponder(
- "GET",
- testutil.MockRequestURL("/foo/bar"),
- mockPaginatedResponse(
- buildPaginatedEntries(12),
- &numRequests,
- ),
- )
+ httpmock.RegisterRegexpResponder("GET", testutil.MockRequestURL("/foo/bar"),
+ mockPaginatedResponse(buildPaginatedEntries(12), &numRequests))
response, err := getPaginatedResults[testResultType](
context.Background(),
diff --git a/request_log_template.tmpl b/request_log_template.tmpl
new file mode 100644
index 000000000..250547bd8
--- /dev/null
+++ b/request_log_template.tmpl
@@ -0,0 +1,8 @@
+
+============================================================================================
+~~~ REQUEST ~~~
+{{.Request}}
+HOST: {{.Host}}
+HEADERS: {{.Headers}}
+BODY: {{.Body}}
+--------------------------------------------------------------------------------------------
\ No newline at end of file
diff --git a/response_log_template.tmpl b/response_log_template.tmpl
new file mode 100644
index 000000000..7bd5f38d8
--- /dev/null
+++ b/response_log_template.tmpl
@@ -0,0 +1,10 @@
+
+============================================================================================
+~~~ RESPONSE ~~~
+STATUS: {{.Status}}
+PROTO: {{.Proto}}
+RECEIVED AT: {{.ReceivedAt}}
+TIME DURATION: {{.TimeDuration}}
+HEADERS: {{.Headers}}
+BODY: {{.Body}}
+--------------------------------------------------------------------------------------------
\ No newline at end of file
diff --git a/retries.go b/retries.go
index 047fed84e..24cbf2454 100644
--- a/retries.go
+++ b/retries.go
@@ -1,74 +1,91 @@
package linodego
import (
+ "bytes"
+ "encoding/json"
"errors"
+ "io"
"log"
"net/http"
"strconv"
"time"
- "github.com/go-resty/resty/v2"
"golang.org/x/net/http2"
)
const (
- retryAfterHeaderName = "Retry-After"
- maintenanceModeHeaderName = "X-Maintenance-Mode"
-
- defaultRetryCount = 1000
+ RetryAfterHeaderName = "Retry-After"
+ MaintenanceModeHeaderName = "X-Maintenance-Mode"
+ DefaultRetryCount = 1000
)
-// RetryConditional func(r *resty.Response) (shouldRetry bool)
-type RetryConditional resty.RetryConditionFunc
+// RetryConditional is a type alias for a function that determines if a request should be retried based on the response and error.
+type RetryConditional func(*http.Response, error) bool
-// RetryAfter func(c *resty.Client, r *resty.Response) (time.Duration, error)
-type RetryAfter resty.RetryAfterFunc
+// RetryAfter is a type alias for a function that determines the duration to wait before retrying based on the response.
+type RetryAfter func(*http.Response) (time.Duration, error)
-// Configures resty to
-// lock until enough time has passed to retry the request as determined by the Retry-After response header.
-// If the Retry-After header is not set, we fall back to value of SetPollDelay.
-func configureRetries(c *Client) {
- c.resty.
- SetRetryCount(defaultRetryCount).
- AddRetryCondition(checkRetryConditionals(c)).
- SetRetryAfter(respectRetryAfter)
+// ConfigureRetries configures http.Client to lock until enough time has passed to retry the request as determined by the Retry-After response header.
+// If the Retry-After header is not set, we fall back to the value of SetPollDelay.
+func ConfigureRetries(c *Client) {
+ c.SetRetryAfter(RespectRetryAfter)
+ c.SetRetryCount(DefaultRetryCount)
}
-func checkRetryConditionals(c *Client) func(*resty.Response, error) bool {
- return func(r *resty.Response, err error) bool {
- for _, retryConditional := range c.retryConditionals {
- retry := retryConditional(r, err)
- if retry {
- log.Printf("[INFO] Received error %s - Retrying", r.Error())
- return true
- }
- }
+func RespectRetryAfter(resp *http.Response) (time.Duration, error) {
+ if resp == nil {
+ return 0, nil
+ }
- return false
+ retryAfterStr := resp.Header.Get(RetryAfterHeaderName)
+ if retryAfterStr == "" {
+ return 0, nil
+ }
+
+ retryAfter, err := strconv.Atoi(retryAfterStr)
+ if err != nil {
+ return 0, err
}
+
+ duration := time.Duration(retryAfter) * time.Second
+ log.Printf("[INFO] Respecting Retry-After Header of %d (%s)", retryAfter, duration)
+
+ return duration, nil
}
-// SetLinodeBusyRetry configures resty to retry specifically on "Linode busy." errors
-// The retry wait time is configured in SetPollDelay
-func linodeBusyRetryCondition(r *resty.Response, _ error) bool {
- apiError, ok := r.Error().(*APIError)
+// Retry conditions
+
+func LinodeBusyRetryCondition(resp *http.Response, _ error) bool {
+ if resp == nil {
+ return false
+ }
+
+ apiError, ok := getAPIError(resp)
linodeBusy := ok && apiError.Error() == "Linode busy."
- retry := r.StatusCode() == http.StatusBadRequest && linodeBusy
+ retry := resp.StatusCode == http.StatusBadRequest && linodeBusy
return retry
}
-func tooManyRequestsRetryCondition(r *resty.Response, _ error) bool {
- return r.StatusCode() == http.StatusTooManyRequests
+func TooManyRequestsRetryCondition(resp *http.Response, _ error) bool {
+ if resp == nil {
+ return false
+ }
+
+ return resp.StatusCode == http.StatusTooManyRequests
}
-func serviceUnavailableRetryCondition(r *resty.Response, _ error) bool {
- serviceUnavailable := r.StatusCode() == http.StatusServiceUnavailable
+func ServiceUnavailableRetryCondition(resp *http.Response, _ error) bool {
+ if resp == nil {
+ return false
+ }
+
+ serviceUnavailable := resp.StatusCode == http.StatusServiceUnavailable
// During maintenance events, the API will return a 503 and add
// an `X-MAINTENANCE-MODE` header. Don't retry during maintenance
// events, only for legitimate 503s.
- if serviceUnavailable && r.Header().Get(maintenanceModeHeaderName) != "" {
+ if serviceUnavailable && resp.Header.Get(MaintenanceModeHeaderName) != "" {
log.Printf("[INFO] Linode API is under maintenance, request will not be retried - please see status.linode.com for more information")
return false
}
@@ -76,33 +93,47 @@ func serviceUnavailableRetryCondition(r *resty.Response, _ error) bool {
return serviceUnavailable
}
-func requestTimeoutRetryCondition(r *resty.Response, _ error) bool {
- return r.StatusCode() == http.StatusRequestTimeout
+func RequestTimeoutRetryCondition(resp *http.Response, _ error) bool {
+ if resp == nil {
+ return false
+ }
+
+ return resp.StatusCode == http.StatusRequestTimeout
}
-func requestGOAWAYRetryCondition(_ *resty.Response, e error) bool {
- return errors.As(e, &http2.GoAwayError{})
+func RequestGOAWAYRetryCondition(_ *http.Response, err error) bool {
+ return errors.As(err, &http2.GoAwayError{})
}
-func requestNGINXRetryCondition(r *resty.Response, _ error) bool {
- return r.StatusCode() == http.StatusBadRequest &&
- r.Header().Get("Server") == "nginx" &&
- r.Header().Get("Content-Type") == "text/html"
+func RequestNGINXRetryCondition(resp *http.Response, _ error) bool {
+ if resp == nil {
+ return false
+ }
+
+ return resp.StatusCode == http.StatusBadRequest &&
+ resp.Header.Get("Server") == "nginx" &&
+ resp.Header.Get("Content-Type") == "text/html"
}
-func respectRetryAfter(client *resty.Client, resp *resty.Response) (time.Duration, error) {
- retryAfterStr := resp.Header().Get(retryAfterHeaderName)
- if retryAfterStr == "" {
- return 0, nil
+// Helper function to extract APIError from response
+func getAPIError(resp *http.Response) (*APIError, bool) {
+ if resp.Body == nil {
+ return nil, false
}
- retryAfter, err := strconv.Atoi(retryAfterStr)
+ body, err := io.ReadAll(resp.Body)
if err != nil {
- return 0, err
+ return nil, false
}
- duration := time.Duration(retryAfter) * time.Second
- log.Printf("[INFO] Respecting Retry-After Header of %d (%s) (max %s)", retryAfter, duration, client.RetryMaxWaitTime)
+ resp.Body = io.NopCloser(bytes.NewReader(body))
- return duration, nil
+ var apiError APIError
+
+ err = json.Unmarshal(body, &apiError)
+ if err != nil {
+ return nil, false
+ }
+
+ return &apiError, true
}
diff --git a/retries_http.go b/retries_http.go
deleted file mode 100644
index 46b986e8d..000000000
--- a/retries_http.go
+++ /dev/null
@@ -1,132 +0,0 @@
-package linodego
-
-import (
- "encoding/json"
- "errors"
- "log"
- "net/http"
- "strconv"
- "time"
-
- "golang.org/x/net/http2"
-)
-
-const (
- // nolint:unused
- httpRetryAfterHeaderName = "Retry-After"
- // nolint:unused
- httpMaintenanceModeHeaderName = "X-Maintenance-Mode"
-
- // nolint:unused
- httpDefaultRetryCount = 1000
-)
-
-// RetryConditional is a type alias for a function that determines if a request should be retried based on the response and error.
-// nolint:unused
-type httpRetryConditional func(*http.Response, error) bool
-
-// RetryAfter is a type alias for a function that determines the duration to wait before retrying based on the response.
-// nolint:unused
-type httpRetryAfter func(*http.Response) (time.Duration, error)
-
-// Configures http.Client to lock until enough time has passed to retry the request as determined by the Retry-After response header.
-// If the Retry-After header is not set, we fall back to the value of SetPollDelay.
-// nolint:unused
-func httpConfigureRetries(c *httpClient) {
- c.retryConditionals = append(c.retryConditionals, httpcheckRetryConditionals(c))
- c.retryAfter = httpRespectRetryAfter
-}
-
-// nolint:unused
-func httpcheckRetryConditionals(c *httpClient) httpRetryConditional {
- return func(resp *http.Response, err error) bool {
- for _, retryConditional := range c.retryConditionals {
- retry := retryConditional(resp, err)
- if retry {
- log.Printf("[INFO] Received error %v - Retrying", err)
- return true
- }
- }
-
- return false
- }
-}
-
-// nolint:unused
-func httpRespectRetryAfter(resp *http.Response) (time.Duration, error) {
- retryAfterStr := resp.Header.Get(retryAfterHeaderName)
- if retryAfterStr == "" {
- return 0, nil
- }
-
- retryAfter, err := strconv.Atoi(retryAfterStr)
- if err != nil {
- return 0, err
- }
-
- duration := time.Duration(retryAfter) * time.Second
- log.Printf("[INFO] Respecting Retry-After Header of %d (%s)", retryAfter, duration)
-
- return duration, nil
-}
-
-// Retry conditions
-
-// nolint:unused
-func httpLinodeBusyRetryCondition(resp *http.Response, _ error) bool {
- apiError, ok := getAPIError(resp)
- linodeBusy := ok && apiError.Error() == "Linode busy."
- retry := resp.StatusCode == http.StatusBadRequest && linodeBusy
-
- return retry
-}
-
-// nolint:unused
-func httpTooManyRequestsRetryCondition(resp *http.Response, _ error) bool {
- return resp.StatusCode == http.StatusTooManyRequests
-}
-
-// nolint:unused
-func httpServiceUnavailableRetryCondition(resp *http.Response, _ error) bool {
- serviceUnavailable := resp.StatusCode == http.StatusServiceUnavailable
-
- // During maintenance events, the API will return a 503 and add
- // an `X-MAINTENANCE-MODE` header. Don't retry during maintenance
- // events, only for legitimate 503s.
- if serviceUnavailable && resp.Header.Get(maintenanceModeHeaderName) != "" {
- log.Printf("[INFO] Linode API is under maintenance, request will not be retried - please see status.linode.com for more information")
- return false
- }
-
- return serviceUnavailable
-}
-
-// nolint:unused
-func httpRequestTimeoutRetryCondition(resp *http.Response, _ error) bool {
- return resp.StatusCode == http.StatusRequestTimeout
-}
-
-// nolint:unused
-func httpRequestGOAWAYRetryCondition(_ *http.Response, err error) bool {
- return errors.As(err, &http2.GoAwayError{})
-}
-
-// nolint:unused
-func httpRequestNGINXRetryCondition(resp *http.Response, _ error) bool {
- return resp.StatusCode == http.StatusBadRequest &&
- resp.Header.Get("Server") == "nginx" &&
- resp.Header.Get("Content-Type") == "text/html"
-}
-
-// Helper function to extract APIError from response
-// nolint:unused
-func getAPIError(resp *http.Response) (*APIError, bool) {
- var apiError APIError
-
- err := json.NewDecoder(resp.Body).Decode(&apiError)
- if err != nil {
- return nil, false
- }
-
- return &apiError, true
-}
diff --git a/retries_http_test.go b/retries_http_test.go
deleted file mode 100644
index 35eea5fc9..000000000
--- a/retries_http_test.go
+++ /dev/null
@@ -1,81 +0,0 @@
-package linodego
-
-import (
- "bytes"
- "encoding/json"
- "io"
- "net/http"
- "testing"
- "time"
-)
-
-func TestHTTPLinodeBusyRetryCondition(t *testing.T) {
- var retry bool
-
- // Initialize response body
- rawResponse := &http.Response{
- StatusCode: http.StatusBadRequest,
- Body: io.NopCloser(bytes.NewBuffer(nil)),
- }
-
- retry = httpLinodeBusyRetryCondition(rawResponse, nil)
-
- if retry {
- t.Errorf("Should not have retried")
- }
-
- apiError := APIError{
- Errors: []APIErrorReason{
- {Reason: "Linode busy."},
- },
- }
- rawResponse.Body = createResponseBody(apiError)
-
- retry = httpLinodeBusyRetryCondition(rawResponse, nil)
-
- if !retry {
- t.Errorf("Should have retried")
- }
-}
-
-func TestHTTPServiceUnavailableRetryCondition(t *testing.T) {
- rawResponse := &http.Response{
- StatusCode: http.StatusServiceUnavailable,
- Header: http.Header{httpRetryAfterHeaderName: []string{"20"}},
- Body: io.NopCloser(bytes.NewBuffer(nil)), // Initialize response body
- }
-
- if retry := httpServiceUnavailableRetryCondition(rawResponse, nil); !retry {
- t.Error("expected request to be retried")
- }
-
- if retryAfter, err := httpRespectRetryAfter(rawResponse); err != nil {
- t.Errorf("expected error to be nil but got %s", err)
- } else if retryAfter != time.Second*20 {
- t.Errorf("expected retryAfter to be 20 but got %d", retryAfter)
- }
-}
-
-func TestHTTPServiceMaintenanceModeRetryCondition(t *testing.T) {
- rawResponse := &http.Response{
- StatusCode: http.StatusServiceUnavailable,
- Header: http.Header{
- httpRetryAfterHeaderName: []string{"20"},
- httpMaintenanceModeHeaderName: []string{"Currently in maintenance mode."},
- },
- Body: io.NopCloser(bytes.NewBuffer(nil)), // Initialize response body
- }
-
- if retry := httpServiceUnavailableRetryCondition(rawResponse, nil); retry {
- t.Error("expected retry to be skipped due to maintenance mode header")
- }
-}
-
-// Helper function to create a response body from an object
-func createResponseBody(obj interface{}) io.ReadCloser {
- body, err := json.Marshal(obj)
- if err != nil {
- panic(err)
- }
- return io.NopCloser(bytes.NewBuffer(body))
-}
diff --git a/retries_test.go b/retries_test.go
index 4f0029388..45b5fc4d3 100644
--- a/retries_test.go
+++ b/retries_test.go
@@ -1,24 +1,24 @@
package linodego
import (
+ "bytes"
+ "encoding/json"
+ "io"
"net/http"
"testing"
"time"
-
- "github.com/go-resty/resty/v2"
)
func TestLinodeBusyRetryCondition(t *testing.T) {
var retry bool
- request := resty.Request{}
- rawResponse := http.Response{StatusCode: http.StatusBadRequest}
- response := resty.Response{
- Request: &request,
- RawResponse: &rawResponse,
+ // Initialize response body
+ rawResponse := &http.Response{
+ StatusCode: http.StatusBadRequest,
+ Body: io.NopCloser(bytes.NewBuffer(nil)),
}
- retry = linodeBusyRetryCondition(&response, nil)
+ retry = LinodeBusyRetryCondition(rawResponse, nil)
if retry {
t.Errorf("Should not have retried")
@@ -29,48 +29,53 @@ func TestLinodeBusyRetryCondition(t *testing.T) {
{Reason: "Linode busy."},
},
}
- request.SetError(&apiError)
+ rawResponse.Body = createResponseBody(apiError)
- retry = linodeBusyRetryCondition(&response, nil)
+ retry = LinodeBusyRetryCondition(rawResponse, nil)
if !retry {
t.Errorf("Should have retried")
}
}
-func TestLinodeServiceUnavailableRetryCondition(t *testing.T) {
- request := resty.Request{}
- rawResponse := http.Response{StatusCode: http.StatusServiceUnavailable, Header: http.Header{
- retryAfterHeaderName: []string{"20"},
- }}
- response := resty.Response{
- Request: &request,
- RawResponse: &rawResponse,
+func TestServiceUnavailableRetryCondition(t *testing.T) {
+ rawResponse := &http.Response{
+ StatusCode: http.StatusServiceUnavailable,
+ Header: http.Header{RetryAfterHeaderName: []string{"20"}},
+ Body: io.NopCloser(bytes.NewBuffer(nil)), // Initialize response body
}
- if retry := serviceUnavailableRetryCondition(&response, nil); !retry {
+ if retry := ServiceUnavailableRetryCondition(rawResponse, nil); !retry {
t.Error("expected request to be retried")
}
- if retryAfter, err := respectRetryAfter(NewClient(nil).resty, &response); err != nil {
+ if retryAfter, err := RespectRetryAfter(rawResponse); err != nil {
t.Errorf("expected error to be nil but got %s", err)
} else if retryAfter != time.Second*20 {
t.Errorf("expected retryAfter to be 20 but got %d", retryAfter)
}
}
-func TestLinodeServiceMaintenanceModeRetryCondition(t *testing.T) {
- request := resty.Request{}
- rawResponse := http.Response{StatusCode: http.StatusServiceUnavailable, Header: http.Header{
- retryAfterHeaderName: []string{"20"},
- maintenanceModeHeaderName: []string{"Currently in maintenance mode."},
- }}
- response := resty.Response{
- Request: &request,
- RawResponse: &rawResponse,
+func TestServiceMaintenanceModeRetryCondition(t *testing.T) {
+ rawResponse := &http.Response{
+ StatusCode: http.StatusServiceUnavailable,
+ Header: http.Header{
+ RetryAfterHeaderName: []string{"20"},
+ MaintenanceModeHeaderName: []string{"Currently in maintenance mode."},
+ },
+ Body: io.NopCloser(bytes.NewBuffer(nil)), // Initialize response body
}
- if retry := serviceUnavailableRetryCondition(&response, nil); retry {
+ if retry := ServiceUnavailableRetryCondition(rawResponse, nil); retry {
t.Error("expected retry to be skipped due to maintenance mode header")
}
}
+
+// Helper function to create a response body from an object
+func createResponseBody(obj interface{}) io.ReadCloser {
+ body, err := json.Marshal(obj)
+ if err != nil {
+ panic(err)
+ }
+ return io.NopCloser(bytes.NewBuffer(body))
+}
diff --git a/test/go.mod b/test/go.mod
index c1f5dd3a2..a5a9b6ec2 100644
--- a/test/go.mod
+++ b/test/go.mod
@@ -20,7 +20,6 @@ require (
github.com/go-openapi/jsonpointer v0.19.6 // indirect
github.com/go-openapi/jsonreference v0.20.2 // indirect
github.com/go-openapi/swag v0.22.3 // indirect
- github.com/go-resty/resty/v2 v2.17.2 // indirect
github.com/gogo/protobuf v1.3.2 // indirect
github.com/golang/protobuf v1.5.4 // indirect
github.com/google/gnostic-models v0.6.8 // indirect
diff --git a/test/go.sum b/test/go.sum
index 9689a3a72..c74c0080a 100644
--- a/test/go.sum
+++ b/test/go.sum
@@ -14,8 +14,6 @@ github.com/go-openapi/jsonreference v0.20.2 h1:3sVjiK66+uXK/6oQ8xgcRKcFgQ5KXa2Kv
github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En5Ap4rVB5KVcIDZG2k=
github.com/go-openapi/swag v0.22.3 h1:yMBqmnQ0gyZvEb/+KzuWZOXgllrXT4SADYbvDaXHv/g=
github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14=
-github.com/go-resty/resty/v2 v2.17.2 h1:FQW5oHYcIlkCNrMD2lloGScxcHJ0gkjshV3qcQAyHQk=
-github.com/go-resty/resty/v2 v2.17.2/go.mod h1:kCKZ3wWmwJaNc7S29BRtUhJwy7iqmn+2mLtQrOyQlVA=
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
diff --git a/test/integration/cache_test.go b/test/integration/cache_test.go
index fd4207de2..9468e870c 100644
--- a/test/integration/cache_test.go
+++ b/test/integration/cache_test.go
@@ -28,8 +28,8 @@ func TestCache_RegionList(t *testing.T) {
totalRequests := int64(0)
client.OnBeforeRequest(func(request *linodego.Request) error {
- page := request.QueryParam.Get("page")
- if !strings.Contains(request.URL, "regions") || page != "1" {
+ page := request.URL.Query().Get("page")
+ if !strings.Contains(request.URL.String(), "regions") || page != "1" {
return nil
}
@@ -91,8 +91,8 @@ func TestCache_Expiration(t *testing.T) {
totalRequests := int64(0)
client.OnBeforeRequest(func(request *linodego.Request) error {
- page := request.QueryParam.Get("page")
- if !strings.Contains(request.URL, "kernels") || page != "1" {
+ page := request.URL.Query().Get("page")
+ if !strings.Contains(request.URL.String(), "kernels") || page != "1" {
return nil
}
diff --git a/test/integration/fixtures/TestMaintenancePolicies_List.yaml b/test/integration/fixtures/TestMaintenancePolicies_List.yaml
index 54b36a96c..e700c5a77 100644
--- a/test/integration/fixtures/TestMaintenancePolicies_List.yaml
+++ b/test/integration/fixtures/TestMaintenancePolicies_List.yaml
@@ -11,17 +11,17 @@ interactions:
- application/json
User-Agent:
- linodego/dev https://github.com/linode/linodego
- url: https://api.linode.com/v4beta/maintenance/policies
+ url: https://api.linode.com/v4beta/maintenance/policies?page=1
method: GET
response:
body: '{"data": [{"slug": "linode/migrate", "label": "Migrate", "description":
"Migrates the Linode to a new host while it remains fully operational. Recommended
for maximizing availability.", "type": "migrate", "notification_period_sec":
- 300, "is_default": true}, {"slug": "linode/power_off_on", "label": "Power-off/on",
- "description": "Powers off the Linode at the start of the maintenance event
- and reboots it once the maintenance finishes. Recommended for maximizing performance.",
- "type": "power_off_on", "notification_period_sec": 1800, "is_default": false}],
- "page": 1, "pages": 1, "results": 2}'
+ 10800, "is_default": true}, {"slug": "linode/power_off_on", "label": "Power
+ Off / Power On", "description": "Powers off the Linode at the start of the maintenance
+ event and reboots it once the maintenance finishes. Recommended for maximizing
+ performance.", "type": "power_off_on", "notification_period_sec": 604800, "is_default":
+ false}], "page": 1, "pages": 1, "results": 2}'
headers:
Access-Control-Allow-Credentials:
- "true"
@@ -33,22 +33,24 @@ interactions:
- '*'
Access-Control-Expose-Headers:
- X-OAuth-Scopes, X-Accepted-OAuth-Scopes, X-Status
+ Akamai-Internal-Account:
+ - '*'
Cache-Control:
- - private, max-age=0, s-maxage=0, no-cache, no-store
- - private, max-age=60, s-maxage=60
+ - max-age=0, no-cache, no-store
Connection:
- keep-alive
Content-Length:
- - "595"
+ - "607"
Content-Security-Policy:
- default-src 'none'
Content-Type:
- application/json
- Server:
- - nginx/1.18.0
+ Expires:
+ - Tue, 21 Apr 2026 18:20:32 GMT
+ Pragma:
+ - no-cache
Strict-Transport-Security:
- max-age=31536000
- - max-age=31536000
Vary:
- Authorization, X-Filter
- Authorization, X-Filter
@@ -62,7 +64,7 @@ interactions:
X-Oauth-Scopes:
- unknown
X-Ratelimit-Limit:
- - "400"
+ - "1840"
X-Xss-Protection:
- 1; mode=block
status: 200 OK
diff --git a/test/integration/maintenance_test.go b/test/integration/maintenance_test.go
index 8ce207aad..b8d22650c 100644
--- a/test/integration/maintenance_test.go
+++ b/test/integration/maintenance_test.go
@@ -2,10 +2,8 @@ package integration
import (
"context"
- "encoding/json"
"testing"
- "github.com/linode/linodego"
"github.com/stretchr/testify/require"
)
@@ -13,21 +11,7 @@ func TestMaintenancePolicies_List(t *testing.T) {
client, fixtureTeardown := createTestClient(t, "fixtures/TestMaintenancePolicies_List")
defer fixtureTeardown()
- resp, err := client.R(context.Background()).Get("maintenance/policies")
- require.NoError(t, err)
-
- var result map[string]any
- err = json.Unmarshal(resp.Body(), &result)
- require.NoError(t, err)
-
- dataRaw, ok := result["data"]
- require.True(t, ok, "Expected 'data' key in response")
-
- dataJSON, err := json.Marshal(dataRaw)
- require.NoError(t, err)
-
- var policies []linodego.MaintenancePolicy
- err = json.Unmarshal(dataJSON, &policies)
+ policies, err := client.ListMaintenancePolicies(context.Background(), nil)
require.NoError(t, err)
if len(policies) == 0 {
diff --git a/test/unit/images_test.go b/test/unit/images_test.go
index dc9aa9ba7..e89cec8ef 100644
--- a/test/unit/images_test.go
+++ b/test/unit/images_test.go
@@ -271,6 +271,14 @@ func TestImage_Upload(t *testing.T) {
base.MockPost("images/upload", fixtureData)
+ // Mock the PUT request to the upload URL returned in the fixture.
+ // UploadImageToURL uses http.DefaultTransport, so we need to
+ // activate httpmock on the default transport as well.
+ httpmock.Activate()
+ defer httpmock.DeactivateAndReset()
+ httpmock.RegisterResponder("PUT", "https://example.com/upload-endpoint",
+ httpmock.NewStringResponder(200, "{}"))
+
image, err := base.Client.UploadImage(context.Background(), requestData)
assert.NoError(t, err)