Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

fix(sdk-go): bound Retry-After to a delay that fits a Duration

Yudhi Armyndharisa432e2975933
diff --git a/sdk/go/client_test.go b/sdk/go/client_test.go
index d1d8f33b5..ad58db5e3 100644
--- a/sdk/go/client_test.go
+++ b/sdk/go/client_test.go
@@ -2073,3 +2073,87 @@ func TestNon2xxResponsesDoNotDecodeSuccess(t *testing.T) {
}
}
}
+
+func TestRetryAfterDurationBounds(t *testing.T) {
+ const longest = time.Duration(1<<63 - 1)
+ for _, tc := range []struct {
+ name, header string
+ want time.Duration
+ valid bool
+ }{
+ {"zero", "0", 0, true},
+ {"small", "2", 2 * time.Second, true},
+ {"positive sign", "+2", 2 * time.Second, true},
+ {"negative zero", "-0", 0, true},
+ {"leading zeroes", strings.Repeat("0", 80) + "2", 2 * time.Second, true},
+ {"last whole second", "9223372036", 9223372036000000000, true},
+ {"overflow boundary", "9223372037", longest, true},
+ {"max integer", "9223372036854775807", longest, true},
+ {"oversized integer", strings.Repeat("9", 80), longest, true},
+ {"oversized positive integer", "+" + strings.Repeat("9", 80), longest, true},
+ {"negative", "-1", 0, false},
+ {"oversized negative integer", "-" + strings.Repeat("9", 80), 0, false},
+ {"fraction", "0.25", 0, false},
+ {"invalid suffix after overflow", strings.Repeat("9", 80) + "x", 0, false},
+ {"invalid", "soon", 0, false},
+ {"sign only", "+", 0, false},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ got, valid := retryAfterHeader(http.Header{"Retry-After": {tc.header}})
+ if got != tc.want || valid != tc.valid {
+ t.Errorf("duration = %s, valid = %v; want %s, %v", got, valid, tc.want, tc.valid)
+ }
+ })
+ }
+ for _, tc := range []struct {
+ name, body string
+ want time.Duration
+ }{
+ {"small body", `{"retryAfterSeconds":2}`, 2 * time.Second},
+ {"fractional body", `{"retryAfterSeconds":0.25}`, 250 * time.Millisecond},
+ {"zero body overrides header", `{"retryAfterSeconds":0}`, 0},
+ {"negative body uses header", `{"retryAfterSeconds":-1}`, 7 * time.Second},
+ {"missing body delay uses header", `{}`, 7 * time.Second},
+ {"wrong body type uses header", `{"retryAfterSeconds":"2"}`, 7 * time.Second},
+ {"large body overrides header", `{"retryAfterSeconds":1e20}`, longest},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ got := parseAPIError(429, []byte(tc.body), "GET /x", http.Header{"Retry-After": {"7"}})
+ if got.RetryAfter != tc.want {
+ t.Errorf("RetryAfter = %s, want %s", got.RetryAfter, tc.want)
+ }
+ })
+ }
+}
+
+func TestRetryDoesNotResendBeforeOversizedRetryAfter(t *testing.T) {
+ for _, status := range []int{429, 503} {
+ for _, header := range []string{"9223372037", strings.Repeat("9", 80)} {
+ for _, respect := range []bool{true, false} {
+ t.Run(fmt.Sprintf("%d/%s/respect=%v", status, header, respect), func(t *testing.T) {
+ var calls int32
+ rt := RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
+ if atomic.AddInt32(&calls, 1) == 1 {
+ return &http.Response{StatusCode: status, Header: http.Header{"Retry-After": {header}}, Body: io.NopCloser(strings.NewReader(`{}`)), Request: req}, nil
+ }
+ return &http.Response{StatusCode: 200, Header: http.Header{}, Body: io.NopCloser(strings.NewReader(`{}`)), Request: req}, nil
+ })
+ c := newTestClient(t, rt, WithTimeout(500*time.Millisecond), WithRetry(RetryPolicy{
+ MaxRetries: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond, RespectRetryAfter: respect,
+ }))
+ err := c.Do(context.Background(), "GET", "/api/x", nil, nil, nil)
+ if !respect {
+ if err != nil || calls != 2 {
+ t.Errorf("disabled Retry-After: error = %v, calls = %d", err, calls)
+ }
+ return
+ }
+ var apiErr *APIError
+ if !errors.As(err, &apiErr) || apiErr.StatusCode != status || apiErr.RetryAfter <= 0 || calls != 1 {
+ t.Errorf("error = %v, calls = %d; want the first response without a retry", err, calls)
+ }
+ })
+ }
+ }
+ }
+}
diff --git a/sdk/go/errors.go b/sdk/go/errors.go
index c365db43d..85fe57f82 100644
--- a/sdk/go/errors.go
+++ b/sdk/go/errors.go
@@ -175,7 +175,11 @@ func parseAPIError(status int, raw []byte, context string, header http.Header) *
// The body's retryAfterSeconds wins: send pacing puts its wait (possibly
// hours) only there, and a header added by a proxy must not shorten it.
if secs, ok := fields["retryAfterSeconds"].(float64); ok && secs >= 0 {
- apiErr.RetryAfter = time.Duration(secs * float64(time.Second))
+ if nanos := secs * float64(time.Second); nanos >= float64(maxRetryAfter) {
+ apiErr.RetryAfter = maxRetryAfter
+ } else {
+ apiErr.RetryAfter = time.Duration(nanos)
+ }
} else if d, ok := retryAfterHeader(header); ok {
apiErr.RetryAfter = d
}
diff --git a/sdk/go/retry.go b/sdk/go/retry.go
index 233e4cd1c..399660120 100644
--- a/sdk/go/retry.go
+++ b/sdk/go/retry.go
@@ -8,6 +8,7 @@ import (
"io"
"net/http"
"strconv"
+ "strings"
"time"
)
@@ -145,15 +146,26 @@ func parseRetryAfter(resp *http.Response) (time.Duration, bool) {
return retryAfterHeader(resp.Header)
}
-// retryAfterHeader reads Retry-After as whole seconds or an HTTP date.
+// maxRetryAfter stands for a delay too long to count: it is past any request deadline.
+const maxRetryAfter = time.Duration(1<<63 - 1)
+
+// retryAfterHeader reads Retry-After as whole seconds or an HTTP date. A count of seconds that does
+// not fit a Duration is reported as maxRetryAfter, not wrapped around to a short or negative wait.
func retryAfterHeader(h http.Header) (time.Duration, bool) {
v := h.Get("Retry-After")
if v == "" {
return 0, false
}
- if secs, err := strconv.Atoi(v); err == nil && secs >= 0 {
+ if secs, err := strconv.ParseInt(v, 10, 64); err == nil && secs >= 0 {
+ if secs > int64(maxRetryAfter/time.Second) {
+ return maxRetryAfter, true
+ }
return time.Duration(secs) * time.Second, true
}
+ // ParseInt also fails on a count beyond int64: that is still a long delay, unlike "-5" or "soon".
+ if digits := strings.TrimPrefix(v, "+"); digits != "" && strings.Trim(digits, "0123456789") == "" {
+ return maxRetryAfter, true
+ }
if t, err := http.ParseTime(v); err == nil {
if d := time.Until(t); d > 0 {
return d, true