/
response.go
98 lines (83 loc) · 2.23 KB
/
response.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
package kong
import (
"encoding/json"
"fmt"
"io"
"net/http"
"strconv"
"time"
)
// Response is a Kong Admin API response.
// It contains the response headers, status and status code.
type Response struct {
Header http.Header
Status string
StatusCode int
}
func newResponse(res *http.Response) *Response {
return &Response{
Header: res.Header,
Status: res.Status,
StatusCode: res.StatusCode,
}
}
func messageFromBody(b []byte) string {
s := struct {
Message string
}{}
if err := json.Unmarshal(b, &s); err != nil {
return fmt.Sprintf("<failed to parse response body: %v>", err)
}
return s.Message
}
// detailsFromBodyDetailsField extract details from body if the response body contains a "details" field.
// Used for extracting details from response from Konnect APIs when error happens.
func detailsFromBodyDetailsField(b []byte) any {
s := struct {
Details any `json:"details"`
}{}
if err := json.Unmarshal(b, &s); err != nil {
return nil
}
return s.Details
}
func hasError(res *http.Response) error {
if res.StatusCode >= 200 && res.StatusCode <= 399 {
return nil
}
body, err := io.ReadAll(res.Body)
if err != nil {
return fmt.Errorf("failed to read error body: %w", err)
}
apiErr := NewAPIError(res.StatusCode, messageFromBody(body))
if details, ok := extractErrDetails(res, body); ok {
apiErr.SetDetails(details)
}
return apiErr
}
func extractErrDetails(res *http.Response, body []byte) (any, bool) {
// firstly deal with certain status code.
switch res.StatusCode {
case http.StatusTooManyRequests:
return extractErrTooManyRequestsDetails(res)
}
// Then extract details from "details" field in the response body.
if detailsFromRespBody := detailsFromBodyDetailsField(body); detailsFromRespBody != nil {
return detailsFromRespBody, true
}
return nil, false
}
func extractErrTooManyRequestsDetails(res *http.Response) (ErrTooManyRequestsDetails, bool) {
const (
base = 10
bitSize = 64
)
if retryAfter := res.Header.Get("Retry-After"); retryAfter != "" {
if sleep, err := strconv.ParseInt(retryAfter, base, bitSize); err == nil {
return ErrTooManyRequestsDetails{
RetryAfter: time.Second * time.Duration(sleep),
}, true
}
}
return ErrTooManyRequestsDetails{}, false
}