-
Notifications
You must be signed in to change notification settings - Fork 0
/
client.go
134 lines (116 loc) · 3.21 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
package aliyun_igraph_go_sdk
import (
"bytes"
"encoding/json"
"fmt"
"github.com/valyala/fasthttp"
"net/url"
"strings"
"time"
)
const (
REQUEST_METHOD = "GET"
)
type Client struct {
Endpoint string
UserName string
PassWord string
Src string
clientConfig ClientConfig
httpClient *fasthttp.Client
}
func NewClient(endpoint string, userName string, passWord string, src string) *Client {
if len(src) == 0 {
src = userName + "_" + endpoint
}
return &Client{
Endpoint: endpoint,
UserName: userName,
PassWord: passWord,
Src: src,
httpClient: defaultHttpClient,
}
}
type ClientConfig struct {
MaxConnsPerHost int
RequestTimeout time.Duration
}
// WithRequestTimeout with custom timeout for a request
func (c *Client) WithRequestTimeout(timeout time.Duration) *Client {
c.httpClient.ReadTimeout = timeout
c.httpClient.WriteTimeout = timeout
return c
}
func (c *Client) InitConfig(clientConfig ClientConfig) {
if clientConfig.MaxConnsPerHost > 0 {
c.httpClient.MaxConnsPerHost = clientConfig.MaxConnsPerHost
}
c.clientConfig = clientConfig
}
func (c *Client) buildReadUrl(readRequest *ReadRequest) url.URL {
uri := url.URL{Path: "app"}
src := c.Src
rawUrl := readRequest.BuildUri()
uri.RawQuery = strings.Join([]string{"app=gremlin", "src=" + src, rawUrl}, "&")
return uri
}
func (c *Client) Read(readRequest *ReadRequest) (*Response, error) {
vErr := readRequest.Validate()
if vErr != nil {
return nil, vErr
}
if len(c.Src) == 0 {
return nil, InvalidParamsError{"Src is empty"}
}
buildUri := c.buildReadUrl(readRequest)
uri := buildUri.RequestURI()
headers := map[string]string{}
body, statusCode, err := request(c, REQUEST_METHOD, uri, headers, nil)
if err != nil {
return nil, err
}
readResult := ReadResult{}
d := json.NewDecoder(bytes.NewReader([]byte(body)))
d.UseNumber()
if jErr := d.Decode(&readResult); jErr != nil {
fmt.Println(jErr)
return nil, NewBadResponseError("Illegal readResult:"+string(body), nil, statusCode)
}
var resp *Response
if len(readResult.ErrorInfo) == 0 {
resp = NewResponse(readResult.Result)
} else {
return nil, NewBadResponseError(fmt.Sprintf("Failed to read, message:%v",
readResult.ErrorInfo), nil, statusCode)
}
return resp, nil
}
func (c *Client) Write(writeRequest *WriteRequest) (*Response, error) {
vErr := writeRequest.Validate()
if vErr != nil {
return nil, vErr
}
buildUri := writeRequest.BuildUri()
uri := buildUri.RequestURI()
headers := map[string]string{}
body, statusCode, err := request(c, REQUEST_METHOD, uri, headers, nil)
if err != nil {
return nil, err
}
writeResult := WriteResult{}
if jErr := json.Unmarshal(body, &writeResult); jErr != nil {
fmt.Println(jErr)
return nil, NewBadResponseError("Illegal writeResult:"+string(body), nil, statusCode)
}
switch writeResult.Errno {
case 0:
results := []*Result{}
return NewResponse(results), nil
case 1:
return nil, NewBadResponseError(fmt.Sprintf("Failed to write, illegal reqeust body, errorCode[%v], resp:[%v]",
writeResult.Errno, string(body)), nil, statusCode)
default:
return nil, NewBadResponseError(fmt.Sprintf("Failed to write, errorCode[%v], resp:[%v]",
writeResult.Errno, string(body)), nil, statusCode)
}
}