milos/st-agent-worker
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: milos:0fe54519ea14bb0663d62eba4ac7bb9531733f36
Branches Tags
milos:main
..
compare: milos:726376f9a1c35778f2feb6d4d7a577a2cd86343c
Branches Tags
milos:main

No commits in common. "0fe54519ea14bb0663d62eba4ac7bb9531733f36" and "726376f9a1c35778f2feb6d4d7a577a2cd86343c" have entirely different histories.
0fe54519ea ... 726376f9a1

1 changed files with 47 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

100
client.go
View file

@ -29,65 +29,59 @@ func NewClient(key string, dryRun bool) *Client {
key: key, key: key,
dryRun: dryRun, dryRun: dryRun,
http: &http.Client{Timeout: 30 * time.Second}, http: &http.Client{Timeout: 30 * time.Second},
// limit to 2 requests per second, no bursts to avoid 429s // 60 requests per 30 seconds: 2/sec sustained, burst of 60.
limiter: rate.NewLimiter(2, 1), limiter: rate.NewLimiter(2, 60),
} }
} }
// do applies the rate limit, retries once on 429, and returns the raw body. // do applies the rate limit, retries once on 429, and returns the raw body.
// rebuilds the body on every attempt func (c *Client) do(ctx context.Context, method, path string, body io.Reader) ([]byte, error) {
func (c *Client) do(ctx context.Context, method, path string, body []byte) ([]byte, error) { if err := c.limiter.Wait(ctx); err != nil {
for attempt := 0; ; attempt++ { return nil, err
if err := c.limiter.Wait(ctx); err != nil {
return nil, err
}
var r io.Reader
if body != nil {
r = bytes.NewReader(body) // fresh reader each attempt
}
req, err := http.NewRequestWithContext(ctx, method, baseURL+path, r)
if err != nil {
return nil, err
}
req.Header.Set("Authorization", "Bearer "+c.key)
req.Header.Set("Accept", "application/json")
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
resp, err := c.http.Do(req)
if err != nil {
return nil, err
}
if resp.StatusCode == http.StatusTooManyRequests && attempt < 3 {
resp.Body.Close()
wait := 30 * time.Second
if s := resp.Header.Get("Retry-After"); s != "" {
if secs, err := strconv.Atoi(s); err == nil {
wait = time.Duration(secs) * time.Second
}
}
log.Printf("rate limited; waiting %s", wait)
select {
case <-time.After(wait):
continue
case <-ctx.Done():
return nil, ctx.Err()
}
}
raw, err := io.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
return nil, err
}
if resp.StatusCode < 200 || resp.StatusCode > 299 {
return nil, fmt.Errorf("%s %s: %d: %s", method, path, resp.StatusCode, truncate(raw))
}
return raw, nil
} }
req, err := http.NewRequestWithContext(ctx, method, baseURL+path, body)
if err != nil {
return nil, err
}
req.Header.Set("Authorization", "Bearer "+c.key)
req.Header.Set("Accept", "application/json")
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
resp, err := c.http.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode == http.StatusTooManyRequests {
wait := 30 * time.Second
if s := resp.Header.Get("Retry-After"); s != "" {
if secs, err := strconv.Atoi(s); err == nil {
wait = time.Duration(secs) * time.Second
}
}
log.Printf("rate limited; waiting %s", wait)
select {
case <-time.After(wait):
case <-ctx.Done():
return nil, ctx.Err()
}
return c.do(ctx, method, path, body)
}
raw, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
if resp.StatusCode < 200 || resp.StatusCode > 299 {
return nil, fmt.Errorf("%s %s: %d: %s", method, path, resp.StatusCode, truncate(raw))
}
return raw, nil
} }
func truncate(b []byte) string { func truncate(b []byte) string {
if len(b) > 300 { if len(b) > 300 {
return string(b[:300]) + "..." return string(b[:300]) + "..."