| 1 |
package discord |
| 2 |
|
| 3 |
import ( |
| 4 |
"bytes" |
| 5 |
"context" |
| 6 |
"encoding/json" |
| 7 |
"errors" |
| 8 |
"fmt" |
| 9 |
"io" |
| 10 |
"maps" |
| 11 |
"math" |
| 12 |
"mime/multipart" |
| 13 |
"net" |
| 14 |
"net/http" |
| 15 |
"net/url" |
| 16 |
"strconv" |
| 17 |
"strings" |
| 18 |
"time" |
| 19 |
|
| 20 |
"github.com/nicholas-fedor/shoutrrr/pkg/types" |
| 21 |
) |
| 22 |
|
| 23 |
// HTTPClient defines the interface for HTTP operations. |
| 24 |
type HTTPClient interface { |
| 25 |
Do(req *http.Request) (*http.Response, error) |
| 26 |
} |
| 27 |
|
| 28 |
// Sleeper defines the interface for sleep operations. |
| 29 |
type Sleeper interface { |
| 30 |
Sleep(d time.Duration) |
| 31 |
} |
| 32 |
|
| 33 |
// RealSleeper is the default implementation using time.Sleep. |
| 34 |
type RealSleeper struct{} |
| 35 |
|
| 36 |
// DefaultHTTPClient is the default implementation using http.DefaultClient with timeout. |
| 37 |
type DefaultHTTPClient struct { |
| 38 |
client *http.Client |
| 39 |
} |
| 40 |
|
| 41 |
// RequestPreparer defines the interface for preparing HTTP requests. |
| 42 |
type RequestPreparer interface { |
| 43 |
PrepareRequest(ctx context.Context, requestURL string) (*http.Request, error) |
| 44 |
} |
| 45 |
|
| 46 |
// JSONRequestPreparer prepares JSON requests. |
| 47 |
type JSONRequestPreparer struct { |
| 48 |
payload []byte |
| 49 |
} |
| 50 |
|
| 51 |
// MultipartRequestPreparer prepares multipart/form-data requests. |
| 52 |
type MultipartRequestPreparer struct { |
| 53 |
payload *WebhookPayload |
| 54 |
files []types.File |
| 55 |
} |
| 56 |
|
| 57 |
const ( |
| 58 |
// defaultHTTPTimeout is the default timeout for HTTP requests to Discord. |
| 59 |
defaultHTTPTimeout = 30 * time.Second |
| 60 |
|
| 61 |
// serverErrorStatusCode is the HTTP status code for server errors (5xx). |
| 62 |
serverErrorStatusCode = 500 |
| 63 |
) |
| 64 |
|
| 65 |
const ( |
| 66 |
maxRetries = 5 |
| 67 |
baseBackoff = time.Second |
| 68 |
maxBackoff = 64 * time.Second |
| 69 |
maxRetryTimeout = 5 * time.Minute |
| 70 |
backoffBase = 2 |
| 71 |
) |
| 72 |
|
| 73 |
func (RealSleeper) Sleep(d time.Duration) { |
| 74 |
time.Sleep(d) |
| 75 |
} |
| 76 |
|
| 77 |
// NewDefaultHTTPClient creates a new default HTTP client with a reasonable timeout. |
| 78 |
func NewDefaultHTTPClient() *DefaultHTTPClient { |
| 79 |
return &DefaultHTTPClient{ |
| 80 |
client: &http.Client{ |
| 81 |
Timeout: defaultHTTPTimeout, // Default timeout for Discord requests |
| 82 |
}, |
| 83 |
} |
| 84 |
} |
| 85 |
|
| 86 |
// Do performs the HTTP request. |
| 87 |
func (c *DefaultHTTPClient) Do(req *http.Request) (*http.Response, error) { |
| 88 |
resp, err := c.client.Do(req) |
| 89 |
if err != nil { |
| 90 |
return nil, fmt.Errorf("performing HTTP request: %w", err) |
| 91 |
} |
| 92 |
|
| 93 |
return resp, nil |
| 94 |
} |
| 95 |
|
| 96 |
// PrepareRequest creates a JSON POST request. |
| 97 |
func (p *JSONRequestPreparer) PrepareRequest( |
| 98 |
ctx context.Context, |
| 99 |
requestURL string, |
| 100 |
) (*http.Request, error) { |
| 101 |
req, err := http.NewRequestWithContext(ctx, http.MethodPost, requestURL, bytes.NewReader(p.payload)) |
| 102 |
if err != nil { |
| 103 |
return nil, fmt.Errorf("creating HTTP request: %w", err) |
| 104 |
} |
| 105 |
|
| 106 |
req.Header.Set("Content-Type", "application/json") |
| 107 |
req.Header.Set("User-Agent", "shoutrrr") |
| 108 |
|
| 109 |
return req, nil |
| 110 |
} |
| 111 |
|
| 112 |
// PrepareRequest creates a multipart POST request. |
| 113 |
func (p *MultipartRequestPreparer) PrepareRequest( |
| 114 |
ctx context.Context, |
| 115 |
requestURL string, |
| 116 |
) (*http.Request, error) { |
| 117 |
var body bytes.Buffer |
| 118 |
|
| 119 |
writer := multipart.NewWriter(&body) |
| 120 |
|
| 121 |
// Add payload as JSON |
| 122 |
payloadBytes, err := json.Marshal(p.payload) |
| 123 |
if err != nil { |
| 124 |
return nil, fmt.Errorf("marshaling payload to JSON: %w", err) |
| 125 |
} |
| 126 |
|
| 127 |
err = writer.WriteField("payload_json", string(payloadBytes)) |
| 128 |
if err != nil { |
| 129 |
return nil, fmt.Errorf("writing payload_json field: %w", err) |
| 130 |
} |
| 131 |
|
| 132 |
// Add files |
| 133 |
for i, file := range p.files { |
| 134 |
fw, err := writer.CreateFormFile(fmt.Sprintf("files[%d]", i), file.Name) |
| 135 |
if err != nil { |
| 136 |
return nil, fmt.Errorf("creating form file for %s: %w", file.Name, err) |
| 137 |
} |
| 138 |
|
| 139 |
_, err = io.Copy(fw, bytes.NewReader(file.Data)) |
| 140 |
if err != nil { |
| 141 |
return nil, fmt.Errorf("writing file data for %s: %w", file.Name, err) |
| 142 |
} |
| 143 |
} |
| 144 |
|
| 145 |
if err := writer.Close(); err != nil { |
| 146 |
return nil, fmt.Errorf("closing multipart writer: %w", err) |
| 147 |
} |
| 148 |
|
| 149 |
req, err := http.NewRequestWithContext(ctx, http.MethodPost, requestURL, &body) |
| 150 |
if err != nil { |
| 151 |
return nil, fmt.Errorf("creating HTTP request: %w", err) |
| 152 |
} |
| 153 |
|
| 154 |
req.Header.Set("Content-Type", writer.FormDataContentType()) |
| 155 |
req.Header.Set("User-Agent", "shoutrrr") |
| 156 |
|
| 157 |
return req, nil |
| 158 |
} |
| 159 |
|
| 160 |
// isTransientError checks if an error is transient and should be retried. |
| 161 |
func isTransientError(err error) bool { |
| 162 |
if err == nil { |
| 163 |
return false |
| 164 |
} |
| 165 |
|
| 166 |
if errors.Is(err, context.Canceled) { |
| 167 |
return false |
| 168 |
} |
| 169 |
|
| 170 |
if errors.Is(err, context.DeadlineExceeded) { |
| 171 |
return true |
| 172 |
} |
| 173 |
|
| 174 |
var netErr net.Error |
| 175 |
if errors.As(err, &netErr) { |
| 176 |
return netErr.Timeout() || |
| 177 |
netErr.Temporary() //nolint:staticcheck // Temporary is deprecated but still used for compatibility |
| 178 |
} |
| 179 |
|
| 180 |
var urlErr *url.Error |
| 181 |
if errors.As(err, &urlErr) { |
| 182 |
return isTransientError(urlErr.Err) |
| 183 |
} |
| 184 |
|
| 185 |
errStr := err.Error() |
| 186 |
|
| 187 |
return strings.Contains(errStr, "connection refused") || |
| 188 |
strings.Contains(errStr, "connection reset") |
| 189 |
} |
| 190 |
|
| 191 |
// executeWithTransportRetry executes an HTTP request with transport-level retries. |
| 192 |
func executeWithTransportRetry( |
| 193 |
ctx context.Context, |
| 194 |
httpClient HTTPClient, |
| 195 |
bodyBytes []byte, |
| 196 |
req *http.Request, |
| 197 |
sleeper Sleeper, |
| 198 |
) (*http.Response, error) { |
| 199 |
const maxTransportRetries = 3 |
| 200 |
|
| 201 |
for transportAttempt := 0; transportAttempt <= maxTransportRetries; transportAttempt++ { |
| 202 |
newReq, err := http.NewRequestWithContext( |
| 203 |
ctx, |
| 204 |
req.Method, |
| 205 |
req.URL.String(), |
| 206 |
bytes.NewReader(bodyBytes), |
| 207 |
) |
| 208 |
if err != nil { |
| 209 |
return nil, fmt.Errorf("creating retry request: %w", err) |
| 210 |
} |
| 211 |
|
| 212 |
maps.Copy(newReq.Header, req.Header) |
| 213 |
|
| 214 |
res, err := httpClient.Do(newReq) |
| 215 |
if err != nil { |
| 216 |
if isTransientError(err) && transportAttempt < maxTransportRetries { |
| 217 |
wait := time.Duration( |
| 218 |
math.Min( |
| 219 |
math.Pow(backoffBase, float64(transportAttempt))*float64(baseBackoff), |
| 220 |
float64(maxBackoff), |
| 221 |
), |
| 222 |
) |
| 223 |
|
| 224 |
select { |
| 225 |
case <-ctx.Done(): |
| 226 |
return nil, fmt.Errorf("making HTTP POST request: %w", ctx.Err()) |
| 227 |
default: |
| 228 |
sleeper.Sleep(wait) |
| 229 |
} |
| 230 |
|
| 231 |
continue |
| 232 |
} |
| 233 |
|
| 234 |
return nil, fmt.Errorf("making HTTP POST request: %w", err) |
| 235 |
} |
| 236 |
|
| 237 |
return res, nil |
| 238 |
} |
| 239 |
|
| 240 |
return nil, fmt.Errorf("making HTTP POST request: %w", ErrMaxRetries) |
| 241 |
} |
| 242 |
|
| 243 |
// handleServerError handles 5xx server errors with retry logic. |
| 244 |
func handleServerError( |
| 245 |
ctx context.Context, |
| 246 |
res *http.Response, |
| 247 |
attempt int, |
| 248 |
startTime time.Time, |
| 249 |
sleeper Sleeper, |
| 250 |
) error { |
| 251 |
if res.StatusCode < serverErrorStatusCode { |
| 252 |
return nil |
| 253 |
} |
| 254 |
|
| 255 |
if attempt >= maxRetries { |
| 256 |
_ = res.Body.Close() |
| 257 |
|
| 258 |
return ErrMaxRetries |
| 259 |
} |
| 260 |
|
| 261 |
wait := time.Duration( |
| 262 |
math.Min( |
| 263 |
math.Pow(backoffBase, float64(attempt))*float64(baseBackoff), |
| 264 |
float64(maxBackoff), |
| 265 |
), |
| 266 |
) |
| 267 |
|
| 268 |
if err := waitWithTimeout(ctx, wait, startTime, sleeper); err != nil { |
| 269 |
_ = res.Body.Close() |
| 270 |
|
| 271 |
return err |
| 272 |
} |
| 273 |
|
| 274 |
_ = res.Body.Close() |
| 275 |
|
| 276 |
return nil // Continue retry |
| 277 |
} |
| 278 |
|
| 279 |
// sendWithRetry executes an HTTP request with exponential backoff retries. |
| 280 |
func sendWithRetry( |
| 281 |
ctx context.Context, |
| 282 |
preparer RequestPreparer, |
| 283 |
requestURL string, |
| 284 |
httpClient HTTPClient, |
| 285 |
sleeper Sleeper, |
| 286 |
) error { |
| 287 |
startTime := time.Now() |
| 288 |
|
| 289 |
for attempt := 0; attempt <= maxRetries; attempt++ { |
| 290 |
// Check if we've exceeded the maximum retry timeout |
| 291 |
if time.Since(startTime) > maxRetryTimeout { |
| 292 |
return fmt.Errorf( |
| 293 |
"max retry timeout exceeded after %v: %w", |
| 294 |
maxRetryTimeout, |
| 295 |
ErrMaxRetries, |
| 296 |
) |
| 297 |
} |
| 298 |
|
| 299 |
// Prepare the request |
| 300 |
req, err := preparer.PrepareRequest(ctx, requestURL) |
| 301 |
if err != nil { |
| 302 |
return fmt.Errorf("preparing request: %w", err) |
| 303 |
} |
| 304 |
|
| 305 |
// Read the request body to preserve it for retries |
| 306 |
bodyBytes, err := io.ReadAll(req.Body) |
| 307 |
if err != nil { |
| 308 |
return fmt.Errorf("reading request body: %w", err) |
| 309 |
} |
| 310 |
|
| 311 |
_ = req.Body.Close() |
| 312 |
|
| 313 |
// Execute request with transport retries |
| 314 |
res, err := executeWithTransportRetry(ctx, httpClient, bodyBytes, req, sleeper) |
| 315 |
if err != nil { |
| 316 |
return err |
| 317 |
} |
| 318 |
|
| 319 |
if res == nil { |
| 320 |
return ErrUnknownAPIError |
| 321 |
} |
| 322 |
|
| 323 |
// Handle rate limit response |
| 324 |
if res.StatusCode == http.StatusTooManyRequests { |
| 325 |
if err := handleRateLimitResponse(ctx, res, attempt, startTime, sleeper); err != nil { |
| 326 |
_ = res.Body.Close() |
| 327 |
|
| 328 |
return err |
| 329 |
} |
| 330 |
|
| 331 |
_ = res.Body.Close() |
| 332 |
|
| 333 |
continue |
| 334 |
} |
| 335 |
|
| 336 |
// Handle server errors |
| 337 |
if err := handleServerError(ctx, res, attempt, startTime, sleeper); err != nil { |
| 338 |
_ = res.Body.Close() |
| 339 |
|
| 340 |
return err |
| 341 |
} |
| 342 |
|
| 343 |
if res.StatusCode >= serverErrorStatusCode { |
| 344 |
_ = res.Body.Close() |
| 345 |
|
| 346 |
continue |
| 347 |
} |
| 348 |
|
| 349 |
if res.StatusCode != http.StatusNoContent && res.StatusCode != http.StatusOK { |
| 350 |
_ = res.Body.Close() |
| 351 |
|
| 352 |
return fmt.Errorf("%w: %s", ErrUnexpectedStatus, res.Status) |
| 353 |
} |
| 354 |
|
| 355 |
_ = res.Body.Close() |
| 356 |
|
| 357 |
return nil |
| 358 |
} |
| 359 |
|
| 360 |
return ErrMaxRetries |
| 361 |
} |
| 362 |
|
| 363 |
// waitWithTimeout waits for the specified duration with timeout and context cancellation checks. |
| 364 |
func waitWithTimeout( |
| 365 |
ctx context.Context, |
| 366 |
wait time.Duration, |
| 367 |
startTime time.Time, |
| 368 |
sleeper Sleeper, |
| 369 |
) error { |
| 370 |
// Don't wait longer than remaining timeout |
| 371 |
if wait > maxRetryTimeout-time.Since(startTime) { |
| 372 |
return fmt.Errorf( |
| 373 |
"wait time %v would exceed max retry timeout %v: %w", |
| 374 |
wait, |
| 375 |
maxRetryTimeout, |
| 376 |
ErrRateLimited, |
| 377 |
) |
| 378 |
} |
| 379 |
|
| 380 |
select { |
| 381 |
case <-ctx.Done(): |
| 382 |
return fmt.Errorf("context canceled during wait: %w", ctx.Err()) |
| 383 |
default: |
| 384 |
sleeper.Sleep(wait) |
| 385 |
} |
| 386 |
|
| 387 |
return nil |
| 388 |
} |
| 389 |
|
| 390 |
// handleRateLimitResponse handles rate limiting logic for 429 responses. |
| 391 |
func handleRateLimitResponse( |
| 392 |
ctx context.Context, |
| 393 |
res *http.Response, |
| 394 |
attempt int, |
| 395 |
startTime time.Time, |
| 396 |
sleeper Sleeper, |
| 397 |
) error { |
| 398 |
retryAfter := res.Header.Get("Retry-After") |
| 399 |
if retryAfter != "" { |
| 400 |
if seconds, err := strconv.ParseFloat(retryAfter, 64); err == nil { |
| 401 |
wait := time.Duration(seconds * float64(time.Second)) |
| 402 |
if err := waitWithTimeout(ctx, wait, startTime, sleeper); err != nil { |
| 403 |
_ = res.Body.Close() |
| 404 |
|
| 405 |
return err |
| 406 |
} |
| 407 |
|
| 408 |
_ = res.Body.Close() |
| 409 |
|
| 410 |
return nil // Continue retry |
| 411 |
} |
| 412 |
} |
| 413 |
// Fallback to exponential backoff |
| 414 |
wait := time.Duration( |
| 415 |
math.Min(math.Pow(backoffBase, float64(attempt))*float64(baseBackoff), float64(maxBackoff)), |
| 416 |
) |
| 417 |
if err := waitWithTimeout(ctx, wait, startTime, sleeper); err != nil { |
| 418 |
_ = res.Body.Close() |
| 419 |
|
| 420 |
return err |
| 421 |
} |
| 422 |
|
| 423 |
_ = res.Body.Close() |
| 424 |
|
| 425 |
return nil // Continue retry |
| 426 |
} |