-
Notifications
You must be signed in to change notification settings - Fork 0
/
request.go
123 lines (113 loc) · 2.75 KB
/
request.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
package go_cmq
import (
"crypto/hmac"
"crypto/sha1"
"crypto/sha256"
"crypto/tls"
"encoding/base64"
"fmt"
"hash"
"io"
"math/rand"
"net"
"net/http"
"net/url"
"strconv"
"strings"
"time"
)
var defaultTransport = &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
}).DialContext,
MaxIdleConns: 500,
MaxIdleConnsPerHost: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
func init() {
rand.Seed(time.Now().Unix())
}
func getCommonParams(req reqCommon) map[string]interface{} {
params := make(map[string]interface{})
params["Action"] = req.Action
if req.Region != "" {
params["Region"] = req.Region
}
params["Timestamp"] = strconv.FormatInt(time.Now().Unix(), 10)
params["Nonce"] = strconv.Itoa(rand.Int())
params["SecretId"] = req.SecretId
if req.SignatureMethod == signSHA256 {
params["SignatureMethod"] = signSHA256
} else {
params["SignatureMethod"] = signSHA1
}
if req.Token != "" {
params["Token"] = req.Token
}
return params
}
type reqCommon struct {
Action string
Region string
// Timestamp uint64
// Nonce uint64
SecretId string
Signature string
SignatureMethod string
Token string
}
func (a *Account) getResponse(params map[string]interface{}) ([]byte, error) {
encoder := false
if a.Method == http.MethodGet {
encoder = true
}
paramStr := mapToURLParam(params, encoder)
var h hash.Hash
if a.SignatureMethod == signSHA256 {
h = hmac.New(sha256.New, []byte(a.SecretKey))
} else {
h = hmac.New(sha1.New, []byte(a.SecretKey))
}
host, _ := url.Parse(a.domain)
tx := a.Method + host.Host + path + "?" + paramStr
h.Write([]byte(tx))
sign := base64.StdEncoding.EncodeToString(h.Sum(nil))
var req *http.Request
var err error
if a.Method == http.MethodGet {
params["Signature"] = sign
up := mapToURLParam(params, encoder)
req, err = http.NewRequest(a.Method, a.domain+path+"?"+up, nil)
if err != nil {
return nil, err
}
} else {
params["Signature"] = url.QueryEscape(sign)
up := mapToURLParam(params, encoder)
req, err = http.NewRequest(a.Method, a.QueueDomain+path, strings.NewReader(up))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded;charset=utf-8")
}
resp, err := a.CmqHttp.Do(req)
if err != nil {
return nil, err
}
defer func() {
_ = resp.Body.Close()
}()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("http error code %d", resp.StatusCode)
}
body, err2 := io.ReadAll(resp.Body)
if err2 != nil {
return nil, err2
}
return body, nil
}