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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
package eduvpn
import (
"fmt"
"io"
"io/ioutil"
"net/http"
"net/url"
"strings"
)
type HTTPResourceError struct {
URL string
Err error
}
func (e *HTTPResourceError) Error() string {
return fmt.Sprintf("failed obtaining HTTP resource %s with error %v", e.URL, e.Err)
}
type HTTPStatusError struct {
URL string
Status int
}
func (e *HTTPStatusError) Error() string {
return fmt.Sprintf("failed obtaining HTTP resource %s as it gave an unsuccesful status code %d", e.URL, e.Status)
}
type HTTPReadError struct {
URL string
Err error
}
func (e *HTTPReadError) Error() string {
return fmt.Sprintf("failed reading HTTP resource %s with error %v", e.URL, e.Err)
}
type HTTPParseJsonError struct {
URL string
Body string
Err error
}
func (e *HTTPParseJsonError) Error() string {
return fmt.Sprintf("failed parsing json %s for HTTP resource %s with error %v", e.Body, e.URL, e.Err)
}
type HTTPRequestCreateError struct {
URL string
Err error
}
func (e *HTTPRequestCreateError) Error() string {
return fmt.Sprintf("failed to create HTTP request with url %s and error %v", e.URL, e.Err)
}
type URLParameters map[string]string
type HTTPOptionalParams struct {
Headers *http.Header
URLParameters *URLParameters
Body url.Values
}
// Construct an URL including on parameters
func HTTPConstructURL(baseURL string, parameters URLParameters) (string, error) {
url, err := url.Parse(baseURL)
if err != nil {
return "", err
}
q := url.Query()
for parameter, value := range parameters {
q.Set(parameter, value)
}
url.RawQuery = q.Encode()
return url.String(), nil
}
// Convenience functions
func HTTPGet(url string) (http.Header, []byte, error) {
return HTTPMethodWithOpts(http.MethodGet, url, nil)
}
func HTTPPost(url string, body url.Values) (http.Header, []byte, error) {
return HTTPMethodWithOpts(http.MethodGet, url, &HTTPOptionalParams{Body: body})
}
func HTTPGetWithOpts(url string, opts *HTTPOptionalParams) (http.Header, []byte, error) {
return HTTPMethodWithOpts(http.MethodGet, url, opts)
}
func HTTPPostWithOpts(url string, opts *HTTPOptionalParams) (http.Header, []byte, error) {
return HTTPMethodWithOpts(http.MethodPost, url, opts)
}
func httpOptionalURL(url string, opts *HTTPOptionalParams) (string, error) {
if opts != nil && opts.URLParameters != nil {
url, urlErr := HTTPConstructURL(url, *opts.URLParameters)
if urlErr != nil {
return url, &HTTPRequestCreateError{URL: url, Err: urlErr}
}
return url, nil
}
return url, nil
}
func httpOptionalHeaders(req *http.Request, opts *HTTPOptionalParams) {
// Add headers
if opts != nil && opts.Headers != nil && req != nil {
for k, v := range *opts.Headers {
req.Header.Add(k, v[0])
}
}
}
func httpOptionalBodyReader(opts *HTTPOptionalParams) io.Reader {
if opts != nil && opts.Body != nil {
return strings.NewReader(opts.Body.Encode())
}
return nil
}
func HTTPMethodWithOpts(method string, url string, opts *HTTPOptionalParams) (http.Header, []byte, error) {
// Make sure the url contains all the parameters
// This can return an error,
// it already has the right error so so we don't wrap it further
url, urlErr := httpOptionalURL(url, opts)
if urlErr != nil {
return nil, nil, urlErr
}
// Create a client
client := &http.Client{}
// Create request object with the body reader generated from the optional arguments
req, reqErr := http.NewRequest(method, url, httpOptionalBodyReader(opts))
if reqErr != nil {
return nil, nil, &HTTPRequestCreateError{URL: url, Err: reqErr}
}
// Make sure the headers contain all the parameters
httpOptionalHeaders(req, opts)
// Do request
resp, respErr := client.Do(req)
if respErr != nil {
return nil, nil, &HTTPResourceError{URL: url, Err: respErr}
}
// Request successful, make sure body is closed at the end
defer resp.Body.Close()
// Return a string
body, readErr := ioutil.ReadAll(resp.Body)
if readErr != nil {
return resp.Header, nil, &HTTPReadError{URL: url, Err: readErr}
}
if resp.StatusCode < 200 || resp.StatusCode > 299 {
return resp.Header, body, &HTTPStatusError{URL: url, Status: resp.StatusCode}
}
// Return the body in bytes and signal the status error if there was one
return resp.Header, body, nil
}
|
