14 "gerrit.o-ran-sc.org/r/ric-plt/alarm-go/alarm"
15 clientruntime "github.com/go-openapi/runtime/client"
16 "github.com/go-openapi/strfmt"
17 "github.com/jedib0t/go-pretty/table"
18 "github.com/prometheus/alertmanager/api/v2/client"
19 "github.com/prometheus/alertmanager/api/v2/client/alert"
20 "github.com/prometheus/alertmanager/api/v2/models"
21 "github.com/thatisuday/commando"
24 type CliAlarmDefinitions struct {
25 AlarmDefinitions []*alarm.AlarmDefinition `json:"alarmdefinitions"`
28 type AlarmClient struct {
29 alarmer *alarm.RICAlarm
32 type RicPerfAlarmObjects struct {
33 AlarmObjects []*alarm.Alarm `json:"alarmobjects"`
36 type AlarmNotification struct {
41 var CLIPerfAlarmObjects map[int]*alarm.Alarm
45 var CliPerfAlarmDefinitions CliAlarmDefinitions
48 Raise string = "RAISE"
49 Clear string = "CLEAR"
51 PeakTestDuration int = 60
52 OneSecondDuration int = 1
56 alarmManagerHost := "localhost"
57 if h := os.Getenv("ALARM_MANAGER_HOST"); h != "" {
61 alertManagerHost := "localhost"
62 if h := os.Getenv("ALERT_MANAGER_HOST"); h != "" {
68 SetExecutableName("alarm-cli").
70 SetDescription("This CLI tool provides management interface to SEP alarm system")
72 registerActiveCmd(alarmManagerHost)
73 registerHistoryCmd(alarmManagerHost)
74 registerRaiseCmd(alarmManagerHost)
75 registerClearCmd(alarmManagerHost)
76 registerDefineCmd(alarmManagerHost)
77 registerUndefineCmd(alarmManagerHost)
78 registerConfigureCmd(alarmManagerHost)
79 registerPerfCmd(alarmManagerHost)
80 registerAlertCmd(alertManagerHost)
82 // parse command-line arguments
86 func registerActiveCmd(alarmManagerHost string) {
89 SetShortDescription("Displays the SEP active alarms").
90 SetDescription("This command displays more information about the SEP active alarms").
91 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
92 AddFlag("port", "Alarm manager host address", commando.String, "8080").
93 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
94 displayAlarms(getAlarms(flags, "active"), false)
98 func registerHistoryCmd(alarmManagerHost string) {
102 SetShortDescription("Displays the SEP alarm history").
103 SetDescription("This command displays more information about the SEP alarm history").
104 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
105 AddFlag("port", "Alarm manager host address", commando.String, "8080").
106 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
107 displayAlarms(getAlarms(flags, "history"), true)
111 func registerRaiseCmd(alarmManagerHost string) {
115 SetShortDescription("Raises alarm with given parameters").
116 AddFlag("moid", "Managed object Id", commando.String, nil).
117 AddFlag("apid", "Application Id", commando.String, nil).
118 AddFlag("sp", "Specific problem Id", commando.Int, nil).
119 AddFlag("severity", "Perceived severity", commando.String, nil).
120 AddFlag("iinfo", "Application identifying info", commando.String, nil).
121 AddFlag("aai", "Application additional info", commando.String, "-").
122 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
123 AddFlag("port", "Alarm manager host address", commando.String, "8080").
124 AddFlag("if", "http or rmr used as interface", commando.String, "http").
125 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
126 postAlarm(flags, readAlarmParams(flags, false), alarm.AlarmActionRaise, nil)
131 func registerClearCmd(alarmManagerHost string) {
135 SetShortDescription("Raises alarm with given parameters").
136 AddFlag("moid", "Managed object Id", commando.String, nil).
137 AddFlag("apid", "Application Id", commando.String, nil).
138 AddFlag("sp", "Specific problem Id", commando.Int, nil).
139 AddFlag("iinfo", "Application identifying info", commando.String, nil).
140 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
141 AddFlag("port", "Alarm manager host address", commando.String, "8080").
142 AddFlag("if", "http or rmr used as interface", commando.String, "http").
143 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
144 postAlarm(flags, readAlarmParams(flags, true), alarm.AlarmActionClear, nil)
149 func registerConfigureCmd(alarmManagerHost string) {
150 // Configure an alarm manager
152 Register("configure").
153 SetShortDescription("Configure alarm manager with given parameters").
154 AddFlag("mal", "max active alarms", commando.Int, nil).
155 AddFlag("mah", "max alarm history", commando.Int, nil).
156 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
157 AddFlag("port", "Alarm manager host address", commando.String, "8080").
158 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
159 postAlarmConfig(flags)
163 func registerDefineCmd(alarmManagerHost string) {
164 // Create alarm definition
167 SetShortDescription("Define alarm with given parameters").
168 AddFlag("aid", "alarm identifier", commando.Int, nil).
169 AddFlag("atx", "alarm text", commando.String, nil).
170 AddFlag("ety", "event type", commando.String, nil).
171 AddFlag("oin", "operation instructions", commando.String, nil).
172 AddFlag("rad", "Raise alarm delay", commando.Int, 0).
173 AddFlag("cad", "Clear alarm delay", commando.Int, 0).
174 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
175 AddFlag("port", "Alarm manager host address", commando.String, "8080").
176 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
177 postAlarmDefinition(flags)
181 func registerUndefineCmd(alarmManagerHost string) {
182 // Delete alarm definition
184 Register("undefine").
185 SetShortDescription("Define alarm with given parameters").
186 AddFlag("aid", "alarm identifier", commando.Int, nil).
187 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
188 AddFlag("port", "Alarm manager host address", commando.String, "8080").
189 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
190 deleteAlarmDefinition(flags)
194 func registerPerfCmd(alarmManagerHost string) {
195 // Conduct performance test for alarm-go
198 SetShortDescription("Conduct performance test with given parameters").
199 AddFlag("prf", "performance profile id", commando.Int, nil).
200 AddFlag("nal", "number of alarms", commando.Int, nil).
201 AddFlag("aps", "alarms per sec", commando.Int, nil).
202 AddFlag("tim", "total time of test", commando.Int, nil).
203 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
204 AddFlag("port", "Alarm manager host address", commando.String, "8080").
205 AddFlag("if", "http or rmr used as interface", commando.String, "http").
206 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
207 conductperformancetest(flags)
211 func registerAlertCmd(alertManagerHost string) {
212 // Get alerts from Prometheus Alert Manager
215 SetShortDescription("Get alerts from Prometheus Alert Manager").
216 AddFlag("active", "Active alerts in Prometheus Alert Manager", commando.Bool, true).
217 AddFlag("inhibited", "Inhibited alerts in Prometheus Alert Manager", commando.Bool, true).
218 AddFlag("silenced", "Silenced alerts in Prometheus Alert Manager", commando.Bool, true).
219 AddFlag("unprocessed", "Unprocessed alerts in Prometheus Alert Manager", commando.Bool, true).
220 AddFlag("host", "Prometheus Alert Manager host address", commando.String, alertManagerHost).
221 AddFlag("port", "Prometheus Alert Manager port", commando.String, "9093").
222 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
227 func readAlarmParams(flags map[string]commando.FlagValue, clear bool) (a alarm.Alarm) {
228 a.ManagedObjectId, _ = flags["moid"].GetString()
229 a.ApplicationId, _ = flags["apid"].GetString()
230 a.SpecificProblem, _ = flags["sp"].GetInt()
231 a.IdentifyingInfo, _ = flags["iinfo"].GetString()
234 s, _ := flags["severity"].GetString()
235 a.PerceivedSeverity = alarm.Severity(s)
239 a.AdditionalInfo, _ = flags["aai"].GetString()
244 func getAlarms(flags map[string]commando.FlagValue, action alarm.AlarmAction) (alarms []AlarmNotification) {
245 host, _ := flags["host"].GetString()
246 port, _ := flags["port"].GetString()
247 targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/%s", host, port, action)
248 resp, err := http.Get(targetUrl)
249 if err != nil || resp == nil || resp.Body == nil {
250 fmt.Println("Couldn't fetch active alarm list due to error: ", err)
254 defer resp.Body.Close()
256 body, err := ioutil.ReadAll(resp.Body)
258 fmt.Println("ioutil.ReadAll failed: ", err)
262 json.Unmarshal([]byte(body), &alarms)
266 func postAlarmWithRmrIf(a alarm.Alarm, action alarm.AlarmAction, alarmClient *AlarmClient) {
267 if alarmClient == nil {
268 alarmClient = NewAlarmClient("my-pod", "my-app")
270 if alarmClient == nil {
274 // Wait until RMR is up-and-running
275 for !alarmClient.alarmer.IsRMRReady() {
276 time.Sleep(100 * time.Millisecond)
279 if action == alarm.AlarmActionRaise {
280 alarmClient.alarmer.Raise(a)
283 if action == alarm.AlarmActionClear {
284 alarmClient.alarmer.Clear(a)
289 func postAlarmWithHttpIf(targetUrl string, a alarm.Alarm, action alarm.AlarmAction) {
290 m := alarm.AlarmMessage{Alarm: a, AlarmAction: action}
291 jsonData, err := json.Marshal(m)
293 fmt.Println("json.Marshal failed: ", err)
297 resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
298 if err != nil || resp == nil {
299 fmt.Println("Couldn't fetch active alarm list due to error: ", err)
304 func postAlarm(flags map[string]commando.FlagValue, a alarm.Alarm, action alarm.AlarmAction, alarmClient *AlarmClient) {
305 // Check the interface to be used for raise or clear the alarm
306 rmr_or_http, _ := flags["if"].GetString()
307 if rmr_or_http == "rmr" {
308 postAlarmWithRmrIf(a, action, alarmClient)
311 host, _ := flags["host"].GetString()
312 port, _ := flags["port"].GetString()
313 targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms", host, port)
314 postAlarmWithHttpIf(targetUrl, a, action)
316 fmt.Println("command executed successfully!")
319 func displayAlarms(alarms []AlarmNotification, isHistory bool) {
320 t := table.NewWriter()
321 t.SetOutputMirror(os.Stdout)
323 t.AppendHeader(table.Row{"ID", "SP", "MOID", "APPID", "IINFO", "SEVERITY", "AAI", "ACTION", "TIME"})
325 t.AppendHeader(table.Row{"ID", "SP", "MOID", "APPID", "IINFO", "SEVERITY", "AAI", "TIME"})
328 for _, a := range alarms {
329 // Do not show alarm before raiseDelay has elapsed
330 alarmTime := time.Unix(0, a.AlarmTime).Format("02/01/2006, 15:04:05")
332 t.AppendRows([]table.Row{
333 {a.AlarmId, a.SpecificProblem, a.ManagedObjectId, a.ApplicationId, a.IdentifyingInfo, a.PerceivedSeverity, a.AdditionalInfo, a.AlarmAction, alarmTime},
336 if a.AlarmDefinition.RaiseDelay == 0 {
337 t.AppendRows([]table.Row{
338 {a.AlarmId, a.SpecificProblem, a.ManagedObjectId, a.ApplicationId, a.IdentifyingInfo, a.PerceivedSeverity, a.AdditionalInfo, alarmTime},
344 t.SetStyle(table.StyleColoredBright)
348 func postAlarmConfig(flags map[string]commando.FlagValue) {
349 host, _ := flags["host"].GetString()
350 port, _ := flags["port"].GetString()
351 maxactivealarms, _ := flags["mal"].GetInt()
352 maxalarmhistory, _ := flags["mah"].GetInt()
353 targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/config", host, port)
355 m := alarm.AlarmConfigParams{MaxActiveAlarms: maxactivealarms, MaxAlarmHistory: maxalarmhistory}
356 jsonData, err := json.Marshal(m)
358 fmt.Println("json.Marshal failed: ", err)
362 resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
363 if err != nil || resp == nil {
364 fmt.Println("Couldn't fetch post alarm configuration due to error: ", err)
369 func postAlarmDefinition(flags map[string]commando.FlagValue) {
370 host, _ := flags["host"].GetString()
371 port, _ := flags["port"].GetString()
372 alarmid, _ := flags["aid"].GetInt()
373 alarmtxt, _ := flags["atx"].GetString()
374 etype, _ := flags["ety"].GetString()
375 operation, _ := flags["oin"].GetString()
376 raiseDelay, _ := flags["rad"].GetInt()
377 clearDelay, _ := flags["cad"].GetInt()
379 targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/define", host, port)
381 var alarmdefinition alarm.AlarmDefinition
382 alarmdefinition.AlarmId = alarmid
383 alarmdefinition.AlarmText = alarmtxt
384 alarmdefinition.EventType = etype
385 alarmdefinition.OperationInstructions = operation
386 alarmdefinition.RaiseDelay = raiseDelay
387 alarmdefinition.ClearDelay = clearDelay
389 m := CliAlarmDefinitions{AlarmDefinitions: []*alarm.AlarmDefinition{&alarmdefinition}}
390 jsonData, err := json.Marshal(m)
392 fmt.Println("json.Marshal failed: ", err)
396 resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
397 if err != nil || resp == nil {
398 fmt.Println("Couldn't post alarm definition due to error: ", err)
403 func deleteAlarmDefinition(flags map[string]commando.FlagValue) {
404 host, _ := flags["host"].GetString()
405 port, _ := flags["port"].GetString()
406 alarmid, _ := flags["aid"].GetInt()
407 salarmid := strconv.FormatUint(uint64(alarmid), 10)
408 targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/define/%s", host, port, salarmid)
410 client := &http.Client{}
411 req, err := http.NewRequest("DELETE", targetUrl, nil)
412 if err != nil || req == nil {
413 fmt.Println("Couldn't make delete request due to error: ", err)
416 resp, errr := client.Do(req)
417 if errr != nil || resp == nil {
418 fmt.Println("Couldn't send delete request due to error: ", err)
423 // NewAlarmClient returns a new AlarmClient.
424 func NewAlarmClient(moId, appId string) *AlarmClient {
425 alarmInstance, err := alarm.InitAlarm(moId, appId)
428 alarmer: alarmInstance,
431 fmt.Println("Failed to create alarmInstance", err)
435 // Conduct performance testing
436 func conductperformancetest(flags map[string]commando.FlagValue) {
439 var readobjerror error
440 host, _ := flags["host"].GetString()
441 port, _ := flags["port"].GetString()
442 targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/define", host, port)
443 readerror = readPerfAlarmDefinitionFromJson()
444 if readerror == nil {
445 senderror = sendPerfAlarmDefinitionToAlarmManager(targetUrl)
446 if senderror == nil {
447 fmt.Println("sent performance alarm definitions to alarm manager")
448 CLIPerfAlarmObjects = make(map[int]*alarm.Alarm)
449 readobjerror = readPerfAlarmObjectFromJson()
450 if readobjerror == nil {
451 profile, _ := flags["prf"].GetInt()
453 fmt.Println("starting peak performance test")
454 peakPerformanceTest(flags)
455 } else if profile == 2 {
456 fmt.Println("starting endurance test")
459 fmt.Println("Unknown profile, received profile = ", profile)
462 fmt.Println("reading performance alarm objects from json file failed ")
465 fmt.Println("sending performance alarm definitions to alarm manager failed ")
469 fmt.Println("reading performance alarm definitions from json file failed ")
473 func peakPerformanceTest(flags map[string]commando.FlagValue) {
474 nalarms, _ := flags["nal"].GetInt()
476 for aid, obj := range CLIPerfAlarmObjects {
478 if count <= nalarms {
479 fmt.Println("peakPerformanceTest: invoking worker routine ", count, aid, *obj)
481 go raiseClearAlarmOnce(obj, flags)
486 fmt.Println("peakPerformanceTest: Waiting for workers to finish")
488 fmt.Println("peakPerformanceTest: Wait completed")
491 func enduranceTest(flags map[string]commando.FlagValue) {
492 alarmspersec, _ := flags["aps"].GetInt()
494 for aid, obj := range CLIPerfAlarmObjects {
496 if count <= alarmspersec {
497 fmt.Println("enduranceTest: invoking worker routine ", count, aid, *obj)
499 go raiseClearAlarmOverPeriod(obj, flags)
504 fmt.Println("enduranceTest: Waiting for workers to finish")
506 fmt.Println("enduranceTest: Wait completed")
509 func readPerfAlarmObjectFromJson() error {
511 filename := os.Getenv("PERF_OBJ_FILE")
512 fmt.Printf("readPerfAlarmObjectFromJson: filename = %s\n", filename)
514 file, err := ioutil.ReadFile(filename)
516 data := RicPerfAlarmObjects{}
517 err = json.Unmarshal([]byte(file), &data)
519 for _, alarmObject := range data.AlarmObjects {
520 ricAlarmObject := new(alarm.Alarm)
521 ricAlarmObject.ManagedObjectId = alarmObject.ManagedObjectId
522 ricAlarmObject.ApplicationId = alarmObject.ApplicationId
523 ricAlarmObject.SpecificProblem = alarmObject.SpecificProblem
524 ricAlarmObject.PerceivedSeverity = alarmObject.PerceivedSeverity
525 ricAlarmObject.AdditionalInfo = alarmObject.AdditionalInfo
526 ricAlarmObject.IdentifyingInfo = alarmObject.IdentifyingInfo
527 CLIPerfAlarmObjects[alarmObject.SpecificProblem] = ricAlarmObject
530 fmt.Println("readPerfAlarmObjectFromJson: json.Unmarshal failed with error: ", err)
534 fmt.Printf("readPerfAlarmObjectFromJson: ioutil.ReadFile failed with error: %v, filename: %s\n", err, filename)
535 fmt.Printf("readPerfAlarmObjectFromJson: current directory: %s\n", getCurrentDirectory())
541 func readPerfAlarmDefinitionFromJson() error {
543 filename := os.Getenv("PERF_DEF_FILE")
544 fmt.Printf("ReadPerfAlarmDefinitionFromJson: filename = %s\n", filename)
546 file, err := ioutil.ReadFile(filename)
548 data := CliAlarmDefinitions{}
549 err = json.Unmarshal([]byte(file), &data)
551 for _, alarmDefinition := range data.AlarmDefinitions {
552 _, exists := alarm.RICAlarmDefinitions[alarmDefinition.AlarmId]
554 fmt.Println("ReadPerfAlarmDefinitionFromJson: alarm definition already exists for ", alarmDefinition.AlarmId)
556 fmt.Println("ReadPerfAlarmDefinitionFromJson: alarm ", alarmDefinition.AlarmId)
557 ricAlarmDefintion := new(alarm.AlarmDefinition)
558 ricAlarmDefintion.AlarmId = alarmDefinition.AlarmId
559 ricAlarmDefintion.AlarmText = alarmDefinition.AlarmText
560 ricAlarmDefintion.EventType = alarmDefinition.EventType
561 ricAlarmDefintion.OperationInstructions = alarmDefinition.OperationInstructions
562 ricAlarmDefintion.RaiseDelay = alarmDefinition.RaiseDelay
563 ricAlarmDefintion.ClearDelay = alarmDefinition.ClearDelay
564 CliPerfAlarmDefinitions.AlarmDefinitions = append(CliPerfAlarmDefinitions.AlarmDefinitions, ricAlarmDefintion)
568 fmt.Println("ReadPerfAlarmDefinitionFromJson: json.Unmarshal failed with error: ", err)
572 fmt.Printf("ReadPerfAlarmDefinitionFromJson: ioutil.ReadFile failed with error: %v, filename: %s\n", err, filename)
573 fmt.Printf("ReadPerfAlarmDefinitionFromJson: current directory: %s\n", getCurrentDirectory())
580 func sendPerfAlarmDefinitionToAlarmManager(targetUrl string) error {
582 jsonData, err := json.Marshal(CliPerfAlarmDefinitions)
584 fmt.Println("sendPerfAlarmDefinitionToAlarmManager: json.Marshal failed: ", err)
588 resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
589 if err != nil || resp == nil {
590 fmt.Println("sendPerfAlarmDefinitionToAlarmManager: Couldn't post alarm definition to targeturl due to error: ", targetUrl, err)
596 func wakeUpAfterTime(timeinseconds int, chn chan string, action string) {
597 time.Sleep(time.Second * time.Duration(timeinseconds))
601 func raiseClearAlarmOnce(alarmobject *alarm.Alarm, flags map[string]commando.FlagValue) {
602 var alarmClient *AlarmClient = nil
604 chn := make(chan string, 1)
605 rmr_or_http, _ := flags["if"].GetString()
606 if rmr_or_http == "rmr" {
607 alarmClient = NewAlarmClient("my-pod", "my-app")
609 postAlarm(flags, *alarmobject, alarm.AlarmActionRaise, alarmClient)
610 go wakeUpAfterTime(PeakTestDuration, chn, Clear)
614 postAlarm(flags, *alarmobject, alarm.AlarmActionClear, alarmClient)
615 go wakeUpAfterTime(PeakTestDuration, chn, End)
616 } else if res == End {
622 func raiseClearAlarmOverPeriod(alarmobject *alarm.Alarm, flags map[string]commando.FlagValue) {
623 var alarmClient *AlarmClient = nil
625 timeinminutes, _ := flags["tim"].GetInt()
626 timeinseconds := timeinminutes * 60
627 chn := make(chan string, 1)
628 rmr_or_http, _ := flags["if"].GetString()
629 if rmr_or_http == "rmr" {
630 alarmClient = NewAlarmClient("my-pod", "my-app")
632 postAlarm(flags, *alarmobject, alarm.AlarmActionRaise, alarmClient)
633 go wakeUpAfterTime(OneSecondDuration, chn, Clear)
634 go wakeUpAfterTime(timeinseconds, chn, End)
639 postAlarm(flags, *alarmobject, alarm.AlarmActionRaise, alarmClient)
640 go wakeUpAfterTime(OneSecondDuration, chn, Clear)
641 } else if res == Clear {
642 postAlarm(flags, *alarmobject, alarm.AlarmActionClear, alarmClient)
643 go wakeUpAfterTime(OneSecondDuration, chn, Raise)
644 } else if res == End {
651 func dispalyAlertAnnotations(t table.Writer, gettableAlert *models.GettableAlert) {
652 var annotationmap map[string]string
653 annotationmap = make(map[string]string)
654 for key, item := range gettableAlert.Annotations {
655 annotationmap[key] = item
657 t.AppendRow([]interface{}{"alarm_id", annotationmap["alarm_id"]})
658 t.AppendRow([]interface{}{"specific_problem", annotationmap["specific_problem"]})
659 t.AppendRow([]interface{}{"timestamp", annotationmap["timestamp"]})
660 t.AppendRow([]interface{}{"event_type", annotationmap["event_type"]})
661 t.AppendRow([]interface{}{"description", annotationmap["description"]})
662 t.AppendRow([]interface{}{"additional_info", annotationmap["additional_info"]})
663 t.AppendRow([]interface{}{"identifying_info", annotationmap["identifying_info"]})
664 t.AppendRow([]interface{}{"instructions", annotationmap["instructions"]})
667 func displayAlertLabels(t table.Writer, gettableAlert *models.GettableAlert) {
668 var labelmap map[string]string
669 labelmap = make(map[string]string)
670 for key, item := range gettableAlert.Alert.Labels {
673 t.AppendRow([]interface{}{"alertname", labelmap["alertname"]})
674 t.AppendRow([]interface{}{"status", labelmap["status"]})
675 t.AppendRow([]interface{}{"severity", labelmap["severity"]})
676 t.AppendRow([]interface{}{"system_name", labelmap["system_name"]})
677 t.AppendRow([]interface{}{"service", labelmap["service"]})
680 func displaySingleAlert(t table.Writer, gettableAlert *models.GettableAlert) {
681 t.AppendRow([]interface{}{"------------------------------------"})
682 dispalyAlertAnnotations(t, gettableAlert)
683 if gettableAlert.EndsAt != nil {
684 t.AppendRow([]interface{}{"EndsAt", *gettableAlert.EndsAt})
686 if gettableAlert.Fingerprint != nil {
687 t.AppendRow([]interface{}{"Fingerprint", *gettableAlert.Fingerprint})
689 for key, item := range gettableAlert.Receivers {
690 if gettableAlert.Receivers != nil {
691 t.AppendRow([]interface{}{key, *item.Name})
694 if gettableAlert.StartsAt != nil {
695 t.AppendRow([]interface{}{"StartsAt", *gettableAlert.StartsAt})
697 if gettableAlert.Status != nil {
698 t.AppendRow([]interface{}{"InhibitedBy", gettableAlert.Status.InhibitedBy})
699 t.AppendRow([]interface{}{"SilencedBy", gettableAlert.Status.SilencedBy})
700 t.AppendRow([]interface{}{"State", *gettableAlert.Status.State})
702 if gettableAlert.UpdatedAt != nil {
703 t.AppendRow([]interface{}{"UpdatedAt", *gettableAlert.UpdatedAt})
705 t.AppendRow([]interface{}{"GeneratorURL", gettableAlert.Alert.GeneratorURL})
706 displayAlertLabels(t, gettableAlert)
709 func displayAlerts(flags map[string]commando.FlagValue) {
710 resp, err := getAlerts(flags)
717 fmt.Println("resp= nil")
721 t := table.NewWriter()
722 t.SetOutputMirror(os.Stdout)
723 t.AppendHeader(table.Row{"Alerts from Prometheus Alert Manager"})
724 for _, gettableAlert := range resp.Payload {
725 if gettableAlert == nil {
729 displaySingleAlert(t, gettableAlert)
731 t.SetStyle(table.StyleColoredBright)
735 func getAlerts(flags map[string]commando.FlagValue) (*alert.GetAlertsOK, error) {
736 active, _ := flags["active"].GetBool()
737 inhibited, _ := flags["inhibited"].GetBool()
738 silenced, _ := flags["silenced"].GetBool()
739 unprocessed, _ := flags["unprocessed"].GetBool()
740 amHost, _ := flags["host"].GetString()
741 amPort, _ := flags["port"].GetString()
742 amAddress := amHost + ":" + amPort
743 amBaseUrl := "api/v2"
744 amSchemes := []string{"http"}
746 alertParams := alert.NewGetAlertsParams()
747 alertParams.Active = &active
748 alertParams.Inhibited = &inhibited
749 alertParams.Silenced = &silenced
750 alertParams.Unprocessed = &unprocessed
751 resp, err := newAlertManagerClient(amAddress, amBaseUrl, amSchemes).Alert.GetAlerts(alertParams)
753 err = fmt.Errorf("GetAlerts from amAddress = %s with amBaseUrl = %s failed with error: %v", amAddress, amBaseUrl, err)
758 func newAlertManagerClient(amAddress string, amBaseUrl string, amSchemes []string) *client.Alertmanager {
759 cr := clientruntime.New(amAddress, amBaseUrl, amSchemes)
760 return client.New(cr, strfmt.Default)
763 func getCurrentDirectory() string {
764 dir, err := os.Getwd()