/
client.go
161 lines (147 loc) · 3.82 KB
/
client.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
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
package hpool
import (
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"log"
"net/http"
"net/http/httputil"
"net/url"
"strings"
"time"
)
var ErrUnauthorizedAccess = errors.New("Unauthorized access")
type client struct {
authToken string
httpClient *http.Client
httpTimeout time.Duration
debug bool
}
// NewClient return a new Hpool HTTP client
func NewClient(accessToken string) (c *client) {
return &client{accessToken, &http.Client{}, 30 * time.Second, false}
}
// NewClientWithCustomHttpConfig returns a new Hpool HTTP client using the predefined http client
func NewClientWithCustomHttpConfig(accessToken string, httpClient *http.Client) (c *client) {
timeout := httpClient.Timeout
if timeout <= 0 {
timeout = 30 * time.Second
}
return &client{accessToken, httpClient, timeout, false}
}
// NewClient returns a new Hpool HTTP client with custom timeout
func NewClientWithCustomTimeout(accessToken string, timeout time.Duration) (c *client) {
return &client{accessToken, &http.Client{}, timeout, false}
}
func (c client) dumpRequest(r *http.Request) {
if r == nil {
log.Print("dumpReq ok: <nil>")
return
}
dump, err := httputil.DumpRequest(r, true)
if err != nil {
log.Print("dumpReq err:", err)
} else {
log.Print("dumpReq ok:", string(dump))
}
}
func (c client) dumpResponse(r *http.Response) {
if r == nil {
log.Print("dumpResponse ok: <nil>")
return
}
dump, err := httputil.DumpResponse(r, true)
if err != nil {
log.Print("dumpResponse err:", err)
} else {
log.Print("dumpResponse ok:", string(dump))
}
}
// doTimeoutRequest do a HTTP request with timeout
func (c *client) doTimeoutRequest(timer *time.Timer, req *http.Request) (*http.Response, error) {
// Do the request in the background so we can check the timeout
type result struct {
resp *http.Response
err error
}
done := make(chan result, 1)
go func() {
if c.debug {
c.dumpRequest(req)
}
resp, err := c.httpClient.Do(req)
if c.debug {
c.dumpResponse(resp)
}
done <- result{resp, err}
}()
// Wait for the read or the timeout
select {
case r := <-done:
return r.resp, r.err
case <-timer.C:
return nil, errors.New("timeout on reading data from Hpool API")
}
}
// do prepare and process HTTP request to Hpool API
func (c *client) do(method string, ressource string, payload map[string]string, authNeeded bool) (response []byte, err error) {
connectTimer := time.NewTimer(c.httpTimeout)
var rawurl string
if strings.HasPrefix(ressource, "http") {
rawurl = ressource
} else {
rawurl = fmt.Sprintf("%s/%s", API_BASE, ressource)
}
var formData string
if method == "GET" {
var URL *url.URL
URL, err = url.Parse(rawurl)
if err != nil {
return
}
q := URL.Query()
for key, value := range payload {
q.Set(key, value)
}
formData = q.Encode()
URL.RawQuery = formData
rawurl = URL.String()
} else {
formDataBytes, _ := json.Marshal(payload)
formData = string(formDataBytes)
}
req, err := http.NewRequest(method, rawurl, strings.NewReader(formData))
if err != nil {
return
}
if method == "POST" || method == "PUT" {
req.Header.Add("Content-Type", "application/json;charset=utf-8")
}
req.Header.Add("Accept", "application/json")
// Auth
if authNeeded {
if len(c.authToken) == 0 {
err = errors.New("You need to set Auth Token to call this method")
return
}
req.AddCookie(&http.Cookie{Name: "auth_token", Value: c.authToken})
}
resp, err := c.doTimeoutRequest(connectTimer, req)
if err != nil {
return
}
defer resp.Body.Close()
response, err = ioutil.ReadAll(resp.Body)
//fmt.Println(fmt.Sprintf("reponse %s", response), err)
if err != nil {
return response, err
}
if resp.StatusCode == 401 {
err = ErrUnauthorizedAccess
} else if resp.StatusCode != 200 && resp.StatusCode != 400 {
//if resp.StatusCode != 200 {
err = errors.New(resp.Status)
}
return response, err
}