"github.com/jedib0t/go-pretty/table"
"github.com/prometheus/alertmanager/api/v2/client"
"github.com/prometheus/alertmanager/api/v2/client/alert"
+ "github.com/prometheus/alertmanager/api/v2/models"
"github.com/spf13/viper"
"github.com/thatisuday/commando"
)
SetVersion("1.0.0").
SetDescription("This CLI tool provides management interface to SEP alarm system")
- // Get active alarms
+ registerActiveCmd(alarmManagerHost)
+ registerHistoryCmd(alarmManagerHost)
+ registerRaiseCmd(alarmManagerHost)
+ registerClearCmd(alarmManagerHost)
+ registerDefineCmd(alarmManagerHost)
+ registerUndefineCmd(alarmManagerHost)
+ registerConfigureCmd(alarmManagerHost)
+ registerPerfCmd(alarmManagerHost)
+ registerAlertCmd(alertManagerHost)
+
+ // parse command-line arguments
+ commando.Parse(nil)
+}
+
+func registerActiveCmd(alarmManagerHost string) {
commando.
Register("active").
SetShortDescription("Displays the SEP active alarms").
SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
displayAlarms(getAlarms(flags, "active"), false)
})
+}
+func registerHistoryCmd(alarmManagerHost string) {
// Get alarm history
commando.
Register("history").
SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
displayAlarms(getAlarms(flags, "history"), true)
})
+}
+func registerRaiseCmd(alarmManagerHost string) {
// Raise an alarm
commando.
Register("raise").
postAlarm(flags, readAlarmParams(flags, false), alarm.AlarmActionRaise, nil)
})
+}
+
+func registerClearCmd(alarmManagerHost string) {
// Clear an alarm
commando.
Register("clear").
postAlarm(flags, readAlarmParams(flags, true), alarm.AlarmActionClear, nil)
})
+}
+
+func registerConfigureCmd(alarmManagerHost string) {
// Configure an alarm manager
commando.
Register("configure").
SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
postAlarmConfig(flags)
})
+}
+
+func registerDefineCmd(alarmManagerHost string) {
// Create alarm definition
commando.
Register("define").
AddFlag("atx", "alarm text", commando.String, nil).
AddFlag("ety", "event type", commando.String, nil).
AddFlag("oin", "operation instructions", commando.String, nil).
+ AddFlag("rad", "Raise alarm delay", commando.Int, 0).
+ AddFlag("cad", "Clear alarm delay", commando.Int, 0).
AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
AddFlag("port", "Alarm manager host address", commando.String, "8080").
SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
postAlarmDefinition(flags)
})
- // Delete alarm definition
+}
+
+func registerUndefineCmd(alarmManagerHost string) {
+ // Delete alarm definition
commando.
Register("undefine").
SetShortDescription("Define alarm with given parameters").
SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
deleteAlarmDefinition(flags)
})
- // Conduct performance test for alarm-go
+}
+
+func registerPerfCmd(alarmManagerHost string) {
+ // Conduct performance test for alarm-go
commando.
Register("perf").
SetShortDescription("Conduct performance test with given parameters").
SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
conductperformancetest(flags)
})
+}
+func registerAlertCmd(alertManagerHost string) {
// Get alerts from Prometheus Alert Manager
commando.
- Register("gapam").
+ Register("alerts").
SetShortDescription("Get alerts from Prometheus Alert Manager").
AddFlag("active", "Active alerts in Prometheus Alert Manager", commando.Bool, true).
AddFlag("inhibited", "Inhibited alerts in Prometheus Alert Manager", commando.Bool, true).
SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
displayAlerts(flags)
})
-
- // parse command-line arguments
- commando.Parse(nil)
}
func readAlarmParams(flags map[string]commando.FlagValue, clear bool) (a alarm.Alarm) {
}
for _, a := range alarms {
+ // Do not show alarm before raiseDelay has elapsed
alarmTime := time.Unix(0, a.AlarmTime).Format("02/01/2006, 15:04:05")
if isHistory {
t.AppendRows([]table.Row{
{a.AlarmId, a.SpecificProblem, a.ManagedObjectId, a.ApplicationId, a.IdentifyingInfo, a.PerceivedSeverity, a.AdditionalInfo, a.AlarmAction, alarmTime},
})
} else {
- t.AppendRows([]table.Row{
- {a.AlarmId, a.SpecificProblem, a.ManagedObjectId, a.ApplicationId, a.IdentifyingInfo, a.PerceivedSeverity, a.AdditionalInfo, alarmTime},
- })
+ if a.AlarmDefinition.RaiseDelay == 0 {
+ t.AppendRows([]table.Row{
+ {a.AlarmId, a.SpecificProblem, a.ManagedObjectId, a.ApplicationId, a.IdentifyingInfo, a.PerceivedSeverity, a.AdditionalInfo, alarmTime},
+ })
+ }
}
}
alarmtxt, _ := flags["atx"].GetString()
etype, _ := flags["ety"].GetString()
operation, _ := flags["oin"].GetString()
+ raiseDelay, _ := flags["rad"].GetInt()
+ clearDelay, _ := flags["cad"].GetInt()
+
targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/define", host, port)
var alarmdefinition alarm.AlarmDefinition
alarmdefinition.AlarmText = alarmtxt
alarmdefinition.EventType = etype
alarmdefinition.OperationInstructions = operation
+ alarmdefinition.RaiseDelay = raiseDelay
+ alarmdefinition.ClearDelay = clearDelay
m := CliAlarmDefinitions{AlarmDefinitions: []*alarm.AlarmDefinition{&alarmdefinition}}
jsonData, err := json.Marshal(m)
} else {
fmt.Println("reading performance alarm definitions from json file failed ")
}
-
}
func peakPerformanceTest(flags map[string]commando.FlagValue) {
}
func readPerfAlarmObjectFromJson() error {
+
filename := os.Getenv("PERF_OBJ_FILE")
+ fmt.Printf("readPerfAlarmObjectFromJson: filename = %s\n", filename)
+
file, err := ioutil.ReadFile(filename)
if err == nil {
data := RicPerfAlarmObjects{}
CLIPerfAlarmObjects[alarmObject.SpecificProblem] = ricAlarmObject
}
} else {
- fmt.Println("readPerfAlarmObjectFromJson: json.Unmarshal failed with error ", err)
+ fmt.Println("readPerfAlarmObjectFromJson: json.Unmarshal failed with error: ", err)
return err
}
} else {
- fmt.Println("readPerfAlarmObjectFromJson: ioutil.ReadFile failed with error ", err)
+ fmt.Printf("readPerfAlarmObjectFromJson: ioutil.ReadFile failed with error: %v, filename: %s\n", err, filename)
+ fmt.Printf("readPerfAlarmObjectFromJson: current directory: %s\n", getCurrentDirectory())
return err
}
return nil
}
func readPerfAlarmDefinitionFromJson() error {
+
filename := os.Getenv("PERF_DEF_FILE")
+ fmt.Printf("ReadPerfAlarmDefinitionFromJson: filename = %s\n", filename)
+
file, err := ioutil.ReadFile(filename)
if err == nil {
data := CliAlarmDefinitions{}
ricAlarmDefintion.AlarmText = alarmDefinition.AlarmText
ricAlarmDefintion.EventType = alarmDefinition.EventType
ricAlarmDefintion.OperationInstructions = alarmDefinition.OperationInstructions
+ ricAlarmDefintion.RaiseDelay = alarmDefinition.RaiseDelay
+ ricAlarmDefintion.ClearDelay = alarmDefinition.ClearDelay
CliPerfAlarmDefinitions.AlarmDefinitions = append(CliPerfAlarmDefinitions.AlarmDefinitions, ricAlarmDefintion)
}
}
return err
}
} else {
- fmt.Println("ReadPerfAlarmDefinitionFromJson: ioutil.ReadFile failed with error: ", err)
+ fmt.Printf("ReadPerfAlarmDefinitionFromJson: ioutil.ReadFile failed with error: %v, filename: %s\n", err, filename)
+ fmt.Printf("ReadPerfAlarmDefinitionFromJson: current directory: %s\n", getCurrentDirectory())
+
return err
}
return nil
}
}
+func displaySingleAlert(t table.Writer, gettableAlert *models.GettableAlert) {
+ t.AppendRow([]interface{}{"------------------------------------"})
+ for key, item := range gettableAlert.Annotations {
+ t.AppendRow([]interface{}{key, item})
+ }
+ if gettableAlert.EndsAt != nil {
+ t.AppendRow([]interface{}{"EndsAt", *gettableAlert.EndsAt})
+ }
+ if gettableAlert.Fingerprint != nil {
+ t.AppendRow([]interface{}{"Fingerprint", *gettableAlert.Fingerprint})
+ }
+ for key, item := range gettableAlert.Receivers {
+ if gettableAlert.Receivers != nil {
+ t.AppendRow([]interface{}{key, *item.Name})
+ }
+ }
+ if gettableAlert.StartsAt != nil {
+ t.AppendRow([]interface{}{"StartsAt", *gettableAlert.StartsAt})
+ }
+ if gettableAlert.Status != nil {
+ t.AppendRow([]interface{}{"InhibitedBy", gettableAlert.Status.InhibitedBy})
+ t.AppendRow([]interface{}{"SilencedBy", gettableAlert.Status.SilencedBy})
+ t.AppendRow([]interface{}{"State", *gettableAlert.Status.State})
+ }
+ if gettableAlert.UpdatedAt != nil {
+ t.AppendRow([]interface{}{"UpdatedAt", *gettableAlert.UpdatedAt})
+ }
+ t.AppendRow([]interface{}{"GeneratorURL", gettableAlert.Alert.GeneratorURL})
+ for key, item := range gettableAlert.Alert.Labels {
+ t.AppendRow([]interface{}{key, item})
+ }
+}
+
func displayAlerts(flags map[string]commando.FlagValue) {
resp, err := getAlerts(flags)
if err != nil {
t.SetOutputMirror(os.Stdout)
t.AppendHeader(table.Row{"Alerts from Prometheus Alert Manager"})
for _, gettableAlert := range resp.Payload {
- t.AppendRow([]interface{}{"------------------------------------"})
- if gettableAlert != nil {
- for key, item := range gettableAlert.Annotations {
- t.AppendRow([]interface{}{key, item})
- }
- if gettableAlert.EndsAt != nil {
- t.AppendRow([]interface{}{"EndsAt", *gettableAlert.EndsAt})
- }
- if gettableAlert.Fingerprint != nil {
- t.AppendRow([]interface{}{"Fingerprint", *gettableAlert.Fingerprint})
- }
- for key, item := range gettableAlert.Receivers {
- if gettableAlert.Receivers != nil {
- t.AppendRow([]interface{}{key, *item.Name})
- }
- }
- if gettableAlert.StartsAt != nil {
- t.AppendRow([]interface{}{"StartsAt", *gettableAlert.StartsAt})
- }
- if gettableAlert.Status != nil {
- t.AppendRow([]interface{}{"InhibitedBy", gettableAlert.Status.InhibitedBy})
- t.AppendRow([]interface{}{"SilencedBy", gettableAlert.Status.SilencedBy})
- t.AppendRow([]interface{}{"State", *gettableAlert.Status.State})
- }
- if gettableAlert.UpdatedAt != nil {
- t.AppendRow([]interface{}{"UpdatedAt", *gettableAlert.UpdatedAt})
- }
- t.AppendRow([]interface{}{"GeneratorURL", gettableAlert.Alert.GeneratorURL})
- for key, item := range gettableAlert.Alert.Labels {
- t.AppendRow([]interface{}{key, item})
- }
+ if gettableAlert == nil {
+ continue
}
+
+ displaySingleAlert(t, gettableAlert)
}
t.SetStyle(table.StyleColoredBright)
t.Render()
cr := clientruntime.New(amAddress, amBaseUrl, amSchemes)
return client.New(cr, strfmt.Default)
}
+
+func getCurrentDirectory() string {
+ dir, err := os.Getwd()
+ if err != nil {
+ fmt.Println(err)
+ }
+ return dir
+}