Debian Codegraph @

pkg/services/chat/discord/discord_sender.go

raw
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 }