forked from IBM/newrelic-cli
/
update_alertsconditions.go
220 lines (205 loc) · 7.52 KB
/
update_alertsconditions.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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
/*
* Copyright 2017-2018 IBM Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package update
import (
"context"
"fmt"
"os"
"reflect"
"strconv"
"github.com/spf13/cobra"
"github.com/IBM/newrelic-cli/newrelic"
"github.com/IBM/newrelic-cli/tracker"
"github.com/IBM/newrelic-cli/utils"
)
var alertsconditionsCmd = &cobra.Command{
Use: "alertsconditions",
Short: "Update alerts_conditions from a file.",
Aliases: []string{"ac", "alertcondition", "alertscondition"},
Example: "nr update alertsconditions -f <example.yaml>",
Run: func(cmd *cobra.Command, args []string) {
file, err := utils.GetArg(cmd, "file")
if err != nil {
fmt.Printf("Unable to get argument 'file': %v\n", err)
os.Exit(1)
return
}
f, err := os.Open(file)
defer f.Close()
if err != nil {
fmt.Printf("Unable to open file '%v': %v\n", file, err)
os.Exit(1)
return
}
// validation
decorder := utils.NewYAMLOrJSONDecoder(f, 4096)
flags := cmd.Flags()
var conditionType string
var errConditionType error
if flags.Lookup("type-condition") != nil {
conditionType, errConditionType = cmd.Flags().GetString("type-condition")
if errConditionType != nil {
fmt.Printf("error accessing flag %s for command %s: %v\n", "type-condition", cmd.Name(), errConditionType)
os.Exit(1)
return
}
var alertConditionID int64
var cat newrelic.ConditionCategory
var ac = new(newrelic.AlertsConditionEntity)
if conditionType == "plugins" {
var ace = new(newrelic.AlertsPluginsConditionEntity)
err = decorder.Decode(ace)
if err != nil {
fmt.Printf("Unable to decode for plugins type condition %q: %v\n", file, err)
os.Exit(1)
return
}
if reflect.DeepEqual(new(newrelic.AlertsPluginsConditionEntity), ace) {
fmt.Printf("Error validating for plugins type condition %q.\n", file)
os.Exit(1)
return
}
cat = newrelic.ConditionPlugins
ac.AlertsPluginsConditionEntity = ace
alertConditionID = *ac.AlertsPluginsConditionEntity.AlertsPluginsCondition.ID
} else if conditionType == "synthetics" {
var ace = new(newrelic.AlertsSyntheticsConditionEntity)
err = decorder.Decode(ace)
if err != nil {
fmt.Printf("Unable to decode for synthetics type condition %q: %v\n", file, err)
os.Exit(1)
return
}
if reflect.DeepEqual(new(newrelic.AlertsSyntheticsConditionEntity), ace) {
fmt.Printf("Error validating for synthetics type condition %q.\n", file)
os.Exit(1)
return
}
cat = newrelic.ConditionSynthetics
ac.AlertsSyntheticsConditionEntity = ace
alertConditionID = *ac.AlertsSyntheticsConditionEntity.AlertsSyntheticsCondition.ID
} else if conditionType == "ext" {
var ace = new(newrelic.AlertsExternalServiceConditionEntity)
err = decorder.Decode(ace)
if err != nil {
fmt.Printf("Unable to decode for ext type condition %q: %v\n", file, err)
os.Exit(1)
return
}
if reflect.DeepEqual(new(newrelic.AlertsExternalServiceConditionEntity), ace) {
fmt.Printf("Error validating for ext type condition %q.\n", file)
os.Exit(1)
return
}
cat = newrelic.ConditionExternalService
ac.AlertsExternalServiceConditionEntity = ace
alertConditionID = *ac.AlertsExternalServiceConditionEntity.AlertsExternalServiceCondition.ID
} else if conditionType == "nrql" {
var ace = new(newrelic.AlertsNRQLConditionEntity)
err = decorder.Decode(ace)
if err != nil {
fmt.Printf("Unable to decode for nrql type condition %q: %v\n", file, err)
os.Exit(1)
return
}
if reflect.DeepEqual(new(newrelic.AlertsNRQLConditionEntity), ace) {
fmt.Printf("Error validating for nrql type condition %q.\n", file)
os.Exit(1)
return
}
cat = newrelic.ConditionNRQL
ac.AlertsNRQLConditionEntity = ace
alertConditionID = *ac.AlertsNRQLConditionEntity.AlertsNRQLCondition.ID
} else {
var ace = new(newrelic.AlertsDefaultConditionEntity)
err = decorder.Decode(ace)
if err != nil {
fmt.Printf("Unable to decode for default type condition %q: %v\n", file, err)
os.Exit(1)
return
}
if reflect.DeepEqual(new(newrelic.AlertsDefaultConditionEntity), ace) {
fmt.Printf("Error validating for default type condition %q.\n", file)
os.Exit(1)
return
}
cat = newrelic.ConditionDefault
ac.AlertsDefaultConditionEntity = ace
alertConditionID = *ac.AlertsDefaultConditionEntity.AlertsDefaultCondition.ID
}
// start to update
client, err := utils.GetNewRelicClient()
if err != nil {
fmt.Println(err)
os.Exit(1)
return
}
_, resp, err := client.AlertsConditions.Update(context.Background(), cat, ac, alertConditionID)
if err != nil {
fmt.Printf("Failed to update condition, %v\n", err)
os.Exit(1)
return
} else {
var statusCode = resp.StatusCode
fmt.Printf("Response status code: %d. Update alert conditions, condition id: '%d'\n", statusCode, alertConditionID)
if resp.StatusCode >= 400 {
os.Exit(1)
return
}
}
} else {
fmt.Println("Can not find type-condition argument.")
os.Exit(1)
return
}
os.Exit(0)
},
}
func UpdateCondition(cat newrelic.ConditionCategory, ac *newrelic.AlertsConditionEntity, alertConditionID int64) (*newrelic.AlertsConditionEntity, error, tracker.ReturnValue) {
// start to update
client, err := utils.GetNewRelicClient()
if err != nil {
fmt.Println(err)
ret := tracker.ToReturnValue(false, tracker.OPERATION_NAME_UPDATE_ALERT_CONDITION_BY_ID, err, tracker.ERR_CREATE_NR_CLINET, "")
return nil, err, ret
}
alertsConditionEntity, resp, err := client.AlertsConditions.Update(context.Background(), cat, ac, alertConditionID)
if err != nil {
fmt.Printf("Failed to update condition, %v\n", err)
ret := tracker.ToReturnValue(false, tracker.OPERATION_NAME_UPDATE_ALERT_CONDITION_BY_ID, err, tracker.ERR_REST_CALL, "")
return nil, err, ret
} else {
tracker.AppendRESTCallResult(client.AlertsConditions, tracker.OPERATION_NAME_UPDATE_ALERT_CONDITION_BY_ID, resp.StatusCode, "alert condtion id:"+strconv.FormatInt(alertConditionID, 10))
if resp.StatusCode >= 400 {
var statusCode = resp.StatusCode
fmt.Printf("Response status code: %d. Update alert conditions, condition id: '%d'\n", statusCode, alertConditionID)
ret := tracker.ToReturnValue(false, tracker.OPERATION_NAME_UPDATE_ALERT_CONDITION_BY_ID, tracker.ERR_REST_CALL_NOT_2XX, tracker.ERR_REST_CALL_NOT_2XX, "")
return nil, err, ret
}
}
ret := tracker.ToReturnValue(true, tracker.OPERATION_NAME_UPDATE_ALERT_CONDITION_BY_ID, nil, nil, "")
return alertsConditionEntity, err, ret
}
func init() {
UpdateCmd.AddCommand(alertsconditionsCmd)
// Here you will define your flags and configuration settings.
// Cobra supports Persistent Flags which will work for this command
// and all subcommands, e.g.:
// alertsconditionsCmd.PersistentFlags().String("foo", "", "A help for foo")
// Cobra supports local flags which will only run when this command
// is called directly, e.g.:
// alertsconditionsCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
}