-
Notifications
You must be signed in to change notification settings - Fork 0
/
client.go
173 lines (146 loc) · 4.29 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
162
163
164
165
166
167
168
169
170
171
172
173
package bettergoapi
import (
"bytes"
"encoding/json"
"errors"
"io"
"log"
"net/http"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/pieoneers/jsonapi-go"
)
var awsSession *session.Session
type HClient interface {
Do(req *http.Request) (*http.Response, error)
}
func GetAWS() *session.Session {
if awsSession == nil {
awsSession = session.Must(session.NewSession())
}
return awsSession
}
func lowerMakeReq(method string, path string, body io.Reader, Token string) (*http.Request, error) {
req, err := http.NewRequest(method, bettergoapiURL+path, body)
if req != nil {
req.Header.Set("Authorization", "Bearer "+Token)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Accept", "*/*")
req.Header.Set("User-Agent", "curl/7.85.0")
}
return req, err
}
func makeReq(method string, path string, body io.Reader) (*http.Request, error) {
Token := os.Getenv("TEAM_TOKEN")
if Token == "" {
sess := GetAWS()
svc := ssm.New(sess)
param, err := svc.GetParameter(&ssm.GetParameterInput{
Name: aws.String("bettergoapi-monitor-token"),
WithDecryption: aws.Bool(true),
})
if err != nil {
log.Print("env var not set and failed to get from ssm")
//log.Fatal(err)
} else {
Token = *param.Parameter.Value
}
}
return lowerMakeReq(method, path, body, Token)
}
func GetRemote(path string, cli HClient) ([]byte, error) {
req, _ := makeReq("GET", path, nil)
res, err := cli.Do(req)
if err != nil || res.StatusCode != http.StatusOK {
return nil, err
}
byteData, _ := io.ReadAll(res.Body)
res.Body.Close()
return byteData, err
}
func PostRemote(cli HClient, path string, obj []byte) ([]byte, error) {
req, _ := makeReq("POST", path, bytes.NewBuffer(obj))
// uncomment this to see the raw http request. Note this breaks the Do() as the body is consumed
//req.Write(os.Stdout)
var res *http.Response
res, err := cli.Do(req)
if res != nil && res.Body != nil {
byteData, _ := io.ReadAll(res.Body)
res.Body.Close()
if res.StatusCode != http.StatusCreated || err != nil {
log.Print("post failed ", res.Status)
log.Print("response was ", string(byteData))
return nil, errors.New("create failed")
}
return byteData, err
}
log.Print("nil res")
return nil, err
}
func PatchRemote(cli HClient, path string, obj []byte) ([]byte, error) {
req, _ := makeReq("PATCH", path, bytes.NewBuffer(obj))
// uncomment this to see the raw http request. Note this breaks the Do() as the body is consumed
//req.Write(os.Stdout)
var res *http.Response
res, err := cli.Do(req)
if res != nil && res.Body != nil {
byteData, _ := io.ReadAll(res.Body)
res.Body.Close()
if res.StatusCode != http.StatusOK || err != nil {
log.Print("patch failed ", res.Status)
log.Print("response was ", string(byteData))
return nil, errors.New("patch failed")
}
return byteData, err
}
//log.Print("nil res")
return nil, err
}
// &http.Client{}
func GetMonitors(cli HClient) (Monitors, error) {
d, err := GetRemote("monitors", cli)
if err != nil {
return nil, err
}
var monitors Monitors = Monitors{}
_, err = jsonapi.Unmarshal(d, &monitors)
if err != nil {
return nil, err
}
return monitors, err
}
func PutMonitor(cli HClient, newMonitor Monitor) (Monitor, error) {
var newMonitorResult = Monitor{}
data, err := json.MarshalIndent(newMonitor, " ", " ")
if err != nil {
return newMonitorResult, err
}
byteData, err := PostRemote(cli, "monitors", data)
if err != nil {
return newMonitorResult, err
}
jsonapi.Unmarshal(byteData, &newMonitorResult)
return newMonitorResult, nil
}
func PatchMonitor(cli HClient, updateMonitor Monitor) (Monitor, error) {
var patchResult = Monitor{}
// save the ID to put in the path
id := updateMonitor.ID
// clear the updateMonitor.ID so it doesn't get sent to the API in the body
updateMonitor.ID = ""
data, err := json.MarshalIndent(updateMonitor, " ", " ")
if err != nil {
return patchResult, err
}
// bytedata should contain the updated monitor
byteData, err := PatchRemote(cli, "monitors/"+id, data)
// if there is an error, return it and a blank monitor
if err != nil {
return patchResult, err
}
// if there is no error, unmarshal the result and return it
jsonapi.Unmarshal(byteData, &patchResult)
return patchResult, nil
}