cli/alarm-cli.go

   1 package main
   2
   3 import (
   4         "bytes"
   5         "encoding/json"
   6         "fmt"
   7         "io/ioutil"
   8         "net/http"
   9         "os"
  10         "strconv"
  11         "sync"
  12         "time"
  13
  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/spf13/viper"
  21         "github.com/thatisuday/commando"
  22 )
  23
  24 type CliAlarmDefinitions struct {
  25         AlarmDefinitions []*alarm.AlarmDefinition `json:"alarmdefinitions"`
  26 }
  27
  28 type AlarmClient struct {
  29         alarmer *alarm.RICAlarm
  30 }
  31
  32 type RicPerfAlarmObjects struct {
  33         AlarmObjects []*alarm.Alarm `json:"alarmobjects"`
  34 }
  35
  36 type AlarmNotification struct {
  37         alarm.AlarmMessage
  38         alarm.AlarmDefinition
  39 }
  40
  41 var CLIPerfAlarmObjects map[int]*alarm.Alarm
  42
  43 var wg sync.WaitGroup
  44
  45 var CliPerfAlarmDefinitions CliAlarmDefinitions
  46
  47 const (
  48         Raise             string = "RAISE"
  49         Clear             string = "CLEAR"
  50         End               string = "END"
  51         PeakTestDuration  int    = 60
  52         OneSecondDuration int    = 1
  53 )
  54
  55 func main() {
  56         alarmManagerHost := "localhost"
  57         if h := os.Getenv("ALARM_MANAGER_HOST"); h != "" {
  58                 alarmManagerHost = h
  59         }
  60
  61         alertManagerHost := "localhost"
  62         if h := os.Getenv("ALERT_MANAGER_HOST"); h != "" {
  63                 alertManagerHost = h
  64         }
  65
  66         // configure commando
  67         commando.
  68                 SetExecutableName("alarm-cli").
  69                 SetVersion("1.0.0").
  70                 SetDescription("This CLI tool provides management interface to SEP alarm system")
  71
  72         // Get active alarms
  73         commando.
  74                 Register("active").
  75                 SetShortDescription("Displays the SEP active alarms").
  76                 SetDescription("This command displays more information about the SEP active alarms").
  77                 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
  78                 AddFlag("port", "Alarm manager host address", commando.String, "8080").
  79                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
  80                         displayAlarms(getAlarms(flags, "active"), false)
  81                 })
  82
  83         // Get alarm history
  84         commando.
  85                 Register("history").
  86                 SetShortDescription("Displays the SEP alarm history").
  87                 SetDescription("This command displays more information about the SEP alarm history").
  88                 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
  89                 AddFlag("port", "Alarm manager host address", commando.String, "8080").
  90                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
  91                         displayAlarms(getAlarms(flags, "history"), true)
  92                 })
  93
  94         // Raise an alarm
  95         commando.
  96                 Register("raise").
  97                 SetShortDescription("Raises alarm with given parameters").
  98                 AddFlag("moid", "Managed object Id", commando.String, nil).
  99                 AddFlag("apid", "Application Id", commando.String, nil).
 100                 AddFlag("sp", "Specific problem Id", commando.Int, nil).
 101                 AddFlag("severity", "Perceived severity", commando.String, nil).
 102                 AddFlag("iinfo", "Application identifying info", commando.String, nil).
 103                 AddFlag("aai", "Application additional info", commando.String, "-").
 104                 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
 105                 AddFlag("port", "Alarm manager host address", commando.String, "8080").
 106                 AddFlag("if", "http or rmr used as interface", commando.String, "http").
 107                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
 108                         postAlarm(flags, readAlarmParams(flags, false), alarm.AlarmActionRaise, nil)
 109                 })
 110
 111         // Clear an alarm
 112         commando.
 113                 Register("clear").
 114                 SetShortDescription("Raises alarm with given parameters").
 115                 AddFlag("moid", "Managed object Id", commando.String, nil).
 116                 AddFlag("apid", "Application Id", commando.String, nil).
 117                 AddFlag("sp", "Specific problem Id", commando.Int, nil).
 118                 AddFlag("iinfo", "Application identifying info", commando.String, nil).
 119                 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
 120                 AddFlag("port", "Alarm manager host address", commando.String, "8080").
 121                 AddFlag("if", "http or rmr used as interface", commando.String, "http").
 122                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
 123                         postAlarm(flags, readAlarmParams(flags, true), alarm.AlarmActionClear, nil)
 124                 })
 125
 126         // Configure an alarm manager
 127         commando.
 128                 Register("configure").
 129                 SetShortDescription("Configure alarm manager with given parameters").
 130                 AddFlag("mal", "max active alarms", commando.Int, nil).
 131                 AddFlag("mah", "max alarm history", commando.Int, nil).
 132                 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
 133                 AddFlag("port", "Alarm manager host address", commando.String, "8080").
 134                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
 135                         postAlarmConfig(flags)
 136                 })
 137         // Create alarm definition
 138         commando.
 139                 Register("define").
 140                 SetShortDescription("Define alarm with given parameters").
 141                 AddFlag("aid", "alarm identifier", commando.Int, nil).
 142                 AddFlag("atx", "alarm text", commando.String, nil).
 143                 AddFlag("ety", "event type", commando.String, nil).
 144                 AddFlag("oin", "operation instructions", commando.String, nil).
 145                 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
 146                 AddFlag("port", "Alarm manager host address", commando.String, "8080").
 147                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
 148                         postAlarmDefinition(flags)
 149                 })
 150                 // Delete alarm definition
 151         commando.
 152                 Register("undefine").
 153                 SetShortDescription("Define alarm with given parameters").
 154                 AddFlag("aid", "alarm identifier", commando.Int, nil).
 155                 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
 156                 AddFlag("port", "Alarm manager host address", commando.String, "8080").
 157                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
 158                         deleteAlarmDefinition(flags)
 159                 })
 160                 // Conduct performance test for alarm-go
 161         commando.
 162                 Register("perf").
 163                 SetShortDescription("Conduct performance test with given parameters").
 164                 AddFlag("prf", "performance profile id", commando.Int, nil).
 165                 AddFlag("nal", "number of alarms", commando.Int, nil).
 166                 AddFlag("aps", "alarms per sec", commando.Int, nil).
 167                 AddFlag("tim", "total time of test", commando.Int, nil).
 168                 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
 169                 AddFlag("port", "Alarm manager host address", commando.String, "8080").
 170                 AddFlag("if", "http or rmr used as interface", commando.String, "http").
 171                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
 172                         conductperformancetest(flags)
 173                 })
 174
 175         // Get alerts from Prometheus Alert Manager
 176         commando.
 177                 Register("gapam").
 178                 SetShortDescription("Get alerts from Prometheus Alert Manager").
 179                 AddFlag("active", "Active alerts in Prometheus Alert Manager", commando.Bool, true).
 180                 AddFlag("inhibited", "Inhibited alerts in Prometheus Alert Manager", commando.Bool, true).
 181                 AddFlag("silenced", "Silenced alerts in Prometheus Alert Manager", commando.Bool, true).
 182                 AddFlag("unprocessed", "Unprocessed alerts in Prometheus Alert Manager", commando.Bool, true).
 183                 AddFlag("host", "Prometheus Alert Manager host address", commando.String, alertManagerHost).
 184                 AddFlag("port", "Prometheus Alert Manager port", commando.String, "9093").
 185                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
 186                         displayAlerts(flags)
 187                 })
 188
 189         // parse command-line arguments
 190         commando.Parse(nil)
 191 }
 192
 193 func readAlarmParams(flags map[string]commando.FlagValue, clear bool) (a alarm.Alarm) {
 194         a.ManagedObjectId, _ = flags["moid"].GetString()
 195         a.ApplicationId, _ = flags["apid"].GetString()
 196         a.SpecificProblem, _ = flags["sp"].GetInt()
 197         a.IdentifyingInfo, _ = flags["iinfo"].GetString()
 198
 199         if !clear {
 200                 s, _ := flags["severity"].GetString()
 201                 a.PerceivedSeverity = alarm.Severity(s)
 202         }
 203
 204         if !clear {
 205                 a.AdditionalInfo, _ = flags["aai"].GetString()
 206         }
 207         return
 208 }
 209
 210 func getAlarms(flags map[string]commando.FlagValue, action alarm.AlarmAction) (alarms []AlarmNotification) {
 211         host, _ := flags["host"].GetString()
 212         port, _ := flags["port"].GetString()
 213         targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/%s", host, port, action)
 214         resp, err := http.Get(targetUrl)
 215         if err != nil || resp == nil || resp.Body == nil {
 216                 fmt.Println("Couldn't fetch active alarm list due to error: ", err)
 217                 return alarms
 218         }
 219
 220         defer resp.Body.Close()
 221
 222         body, err := ioutil.ReadAll(resp.Body)
 223         if err != nil {
 224                 fmt.Println("ioutil.ReadAll failed: ", err)
 225                 return alarms
 226         }
 227
 228         json.Unmarshal([]byte(body), &alarms)
 229         return alarms
 230 }
 231
 232 func postAlarmWithRmrIf(a alarm.Alarm, action alarm.AlarmAction, alarmClient *AlarmClient) {
 233         if alarmClient == nil {
 234                 alarmClient = NewAlarmClient("my-pod", "my-app")
 235         }
 236         if alarmClient == nil {
 237                 return
 238         }
 239
 240         // Wait until RMR is up-and-running
 241         for !alarmClient.alarmer.IsRMRReady() {
 242                 time.Sleep(100 * time.Millisecond)
 243         }
 244
 245         if action == alarm.AlarmActionRaise {
 246                 alarmClient.alarmer.Raise(a)
 247         }
 248
 249         if action == alarm.AlarmActionClear {
 250                 alarmClient.alarmer.Clear(a)
 251         }
 252         return
 253 }
 254
 255 func postAlarmWithHttpIf(targetUrl string, a alarm.Alarm, action alarm.AlarmAction) {
 256         m := alarm.AlarmMessage{Alarm: a, AlarmAction: action}
 257         jsonData, err := json.Marshal(m)
 258         if err != nil {
 259                 fmt.Println("json.Marshal failed: ", err)
 260                 return
 261         }
 262
 263         resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
 264         if err != nil || resp == nil {
 265                 fmt.Println("Couldn't fetch active alarm list due to error: ", err)
 266                 return
 267         }
 268 }
 269
 270 func postAlarm(flags map[string]commando.FlagValue, a alarm.Alarm, action alarm.AlarmAction, alarmClient *AlarmClient) {
 271         // Check the interface to be used for raise or clear the alarm
 272         rmr_or_http, _ := flags["if"].GetString()
 273         if rmr_or_http == "rmr" {
 274                 postAlarmWithRmrIf(a, action, alarmClient)
 275         } else {
 276
 277                 host, _ := flags["host"].GetString()
 278                 port, _ := flags["port"].GetString()
 279                 targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms", host, port)
 280                 postAlarmWithHttpIf(targetUrl, a, action)
 281         }
 282         fmt.Println("command executed successfully!")
 283 }
 284
 285 func displayAlarms(alarms []AlarmNotification, isHistory bool) {
 286         t := table.NewWriter()
 287         t.SetOutputMirror(os.Stdout)
 288         if isHistory {
 289                 t.AppendHeader(table.Row{"ID", "SP", "MOID", "APPID", "IINFO", "SEVERITY", "AAI", "ACTION", "TIME"})
 290         } else {
 291                 t.AppendHeader(table.Row{"ID", "SP", "MOID", "APPID", "IINFO", "SEVERITY", "AAI", "TIME"})
 292         }
 293
 294         for _, a := range alarms {
 295                 alarmTime := time.Unix(0, a.AlarmTime).Format("02/01/2006, 15:04:05")
 296                 if isHistory {
 297                         t.AppendRows([]table.Row{
 298                                 {a.AlarmId, a.SpecificProblem, a.ManagedObjectId, a.ApplicationId, a.IdentifyingInfo, a.PerceivedSeverity, a.AdditionalInfo, a.AlarmAction, alarmTime},
 299                         })
 300                 } else {
 301                         t.AppendRows([]table.Row{
 302                                 {a.AlarmId, a.SpecificProblem, a.ManagedObjectId, a.ApplicationId, a.IdentifyingInfo, a.PerceivedSeverity, a.AdditionalInfo, alarmTime},
 303                         })
 304                 }
 305         }
 306
 307         t.SetStyle(table.StyleColoredBright)
 308         t.Render()
 309 }
 310
 311 func postAlarmConfig(flags map[string]commando.FlagValue) {
 312         host, _ := flags["host"].GetString()
 313         port, _ := flags["port"].GetString()
 314         maxactivealarms, _ := flags["mal"].GetInt()
 315         maxalarmhistory, _ := flags["mah"].GetInt()
 316         targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/config", host, port)
 317
 318         m := alarm.AlarmConfigParams{MaxActiveAlarms: maxactivealarms, MaxAlarmHistory: maxalarmhistory}
 319         jsonData, err := json.Marshal(m)
 320         if err != nil {
 321                 fmt.Println("json.Marshal failed: ", err)
 322                 return
 323         }
 324
 325         resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
 326         if err != nil || resp == nil {
 327                 fmt.Println("Couldn't fetch post alarm configuration due to error: ", err)
 328                 return
 329         }
 330 }
 331
 332 func postAlarmDefinition(flags map[string]commando.FlagValue) {
 333         host, _ := flags["host"].GetString()
 334         port, _ := flags["port"].GetString()
 335         alarmid, _ := flags["aid"].GetInt()
 336         alarmtxt, _ := flags["atx"].GetString()
 337         etype, _ := flags["ety"].GetString()
 338         operation, _ := flags["oin"].GetString()
 339         targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/define", host, port)
 340
 341         var alarmdefinition alarm.AlarmDefinition
 342         alarmdefinition.AlarmId = alarmid
 343         alarmdefinition.AlarmText = alarmtxt
 344         alarmdefinition.EventType = etype
 345         alarmdefinition.OperationInstructions = operation
 346
 347         m := CliAlarmDefinitions{AlarmDefinitions: []*alarm.AlarmDefinition{&alarmdefinition}}
 348         jsonData, err := json.Marshal(m)
 349         if err != nil {
 350                 fmt.Println("json.Marshal failed: ", err)
 351                 return
 352         }
 353
 354         resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
 355         if err != nil || resp == nil {
 356                 fmt.Println("Couldn't post alarm definition due to error: ", err)
 357                 return
 358         }
 359 }
 360
 361 func deleteAlarmDefinition(flags map[string]commando.FlagValue) {
 362         host, _ := flags["host"].GetString()
 363         port, _ := flags["port"].GetString()
 364         alarmid, _ := flags["aid"].GetInt()
 365         salarmid := strconv.FormatUint(uint64(alarmid), 10)
 366         targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/define/%s", host, port, salarmid)
 367
 368         client := &http.Client{}
 369         req, err := http.NewRequest("DELETE", targetUrl, nil)
 370         if err != nil || req == nil {
 371                 fmt.Println("Couldn't make delete request due to error: ", err)
 372                 return
 373         }
 374         resp, errr := client.Do(req)
 375         if errr != nil || resp == nil {
 376                 fmt.Println("Couldn't send delete request due to error: ", err)
 377                 return
 378         }
 379 }
 380
 381 // NewAlarmClient returns a new AlarmClient.
 382 func NewAlarmClient(moId, appId string) *AlarmClient {
 383         alarmInstance, err := alarm.InitAlarm(moId, appId)
 384         if err == nil {
 385                 return &AlarmClient{
 386                         alarmer: alarmInstance,
 387                 }
 388         }
 389         fmt.Println("Failed to create alarmInstance", err)
 390         return nil
 391 }
 392
 393 // Conduct performance testing
 394 func conductperformancetest(flags map[string]commando.FlagValue) {
 395         var readerror error
 396         var senderror error
 397         var readobjerror error
 398         host, _ := flags["host"].GetString()
 399         port, _ := flags["port"].GetString()
 400         targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/define", host, port)
 401         readerror = readPerfAlarmDefinitionFromJson()
 402         if readerror == nil {
 403                 senderror = sendPerfAlarmDefinitionToAlarmManager(targetUrl)
 404                 if senderror == nil {
 405                         fmt.Println("sent performance alarm definitions to alarm manager")
 406                         CLIPerfAlarmObjects = make(map[int]*alarm.Alarm)
 407                         readobjerror = readPerfAlarmObjectFromJson()
 408                         if readobjerror == nil {
 409                                 profile, _ := flags["prf"].GetInt()
 410                                 if profile == 1 {
 411                                         fmt.Println("starting peak performance test")
 412                                         peakPerformanceTest(flags)
 413                                 } else if profile == 2 {
 414                                         fmt.Println("starting endurance test")
 415                                         enduranceTest(flags)
 416                                 } else {
 417                                         fmt.Println("Unknown profile, received profile = ", profile)
 418                                 }
 419                         } else {
 420                                 fmt.Println("reading performance alarm objects from json file failed ")
 421                         }
 422                 } else {
 423                         fmt.Println("sending performance alarm definitions to alarm manager failed ")
 424                 }
 425
 426         } else {
 427                 fmt.Println("reading performance alarm definitions from json file failed ")
 428         }
 429
 430 }
 431
 432 func peakPerformanceTest(flags map[string]commando.FlagValue) {
 433         nalarms, _ := flags["nal"].GetInt()
 434         var count int = 0
 435         for aid, obj := range CLIPerfAlarmObjects {
 436                 count = count + 1
 437                 if count <= nalarms {
 438                         fmt.Println("peakPerformanceTest: invoking worker routine ", count, aid, *obj)
 439                         wg.Add(1)
 440                         go raiseClearAlarmOnce(obj, flags)
 441                 } else {
 442                         break
 443                 }
 444         }
 445         fmt.Println("peakPerformanceTest: Waiting for workers to finish")
 446         wg.Wait()
 447         fmt.Println("peakPerformanceTest: Wait completed")
 448 }
 449
 450 func enduranceTest(flags map[string]commando.FlagValue) {
 451         alarmspersec, _ := flags["aps"].GetInt()
 452         var count int = 0
 453         for aid, obj := range CLIPerfAlarmObjects {
 454                 count = count + 1
 455                 if count <= alarmspersec {
 456                         fmt.Println("enduranceTest: invoking worker routine ", count, aid, *obj)
 457                         wg.Add(1)
 458                         go raiseClearAlarmOverPeriod(obj, flags)
 459                 } else {
 460                         break
 461                 }
 462         }
 463         fmt.Println("enduranceTest: Waiting for workers to finish")
 464         wg.Wait()
 465         fmt.Println("enduranceTest: Wait completed")
 466 }
 467
 468 func readPerfAlarmObjectFromJson() error {
 469         filename := os.Getenv("PERF_OBJ_FILE")
 470         file, err := ioutil.ReadFile(filename)
 471         if err == nil {
 472                 data := RicPerfAlarmObjects{}
 473                 err = json.Unmarshal([]byte(file), &data)
 474                 if err == nil {
 475                         for _, alarmObject := range data.AlarmObjects {
 476                                 ricAlarmObject := new(alarm.Alarm)
 477                                 ricAlarmObject.ManagedObjectId = alarmObject.ManagedObjectId
 478                                 ricAlarmObject.ApplicationId = alarmObject.ApplicationId
 479                                 ricAlarmObject.SpecificProblem = alarmObject.SpecificProblem
 480                                 ricAlarmObject.PerceivedSeverity = alarmObject.PerceivedSeverity
 481                                 ricAlarmObject.AdditionalInfo = alarmObject.AdditionalInfo
 482                                 ricAlarmObject.IdentifyingInfo = alarmObject.IdentifyingInfo
 483                                 CLIPerfAlarmObjects[alarmObject.SpecificProblem] = ricAlarmObject
 484                         }
 485                 } else {
 486                         fmt.Println("readPerfAlarmObjectFromJson: json.Unmarshal failed with error ", err)
 487                         return err
 488                 }
 489         } else {
 490                 fmt.Println("readPerfAlarmObjectFromJson: ioutil.ReadFile failed with error ", err)
 491                 return err
 492         }
 493         return nil
 494 }
 495
 496 func readPerfAlarmDefinitionFromJson() error {
 497         filename := os.Getenv("PERF_DEF_FILE")
 498         file, err := ioutil.ReadFile(filename)
 499         if err == nil {
 500                 data := CliAlarmDefinitions{}
 501                 err = json.Unmarshal([]byte(file), &data)
 502                 if err == nil {
 503                         for _, alarmDefinition := range data.AlarmDefinitions {
 504                                 _, exists := alarm.RICAlarmDefinitions[alarmDefinition.AlarmId]
 505                                 if exists {
 506                                         fmt.Println("ReadPerfAlarmDefinitionFromJson: alarm definition already exists for ", alarmDefinition.AlarmId)
 507                                 } else {
 508                                         fmt.Println("ReadPerfAlarmDefinitionFromJson: alarm ", alarmDefinition.AlarmId)
 509                                         ricAlarmDefintion := new(alarm.AlarmDefinition)
 510                                         ricAlarmDefintion.AlarmId = alarmDefinition.AlarmId
 511                                         ricAlarmDefintion.AlarmText = alarmDefinition.AlarmText
 512                                         ricAlarmDefintion.EventType = alarmDefinition.EventType
 513                                         ricAlarmDefintion.OperationInstructions = alarmDefinition.OperationInstructions
 514                                         CliPerfAlarmDefinitions.AlarmDefinitions = append(CliPerfAlarmDefinitions.AlarmDefinitions, ricAlarmDefintion)
 515                                 }
 516                         }
 517                 } else {
 518                         fmt.Println("ReadPerfAlarmDefinitionFromJson: json.Unmarshal failed with error: ", err)
 519                         return err
 520                 }
 521         } else {
 522                 fmt.Println("ReadPerfAlarmDefinitionFromJson: ioutil.ReadFile failed with error: ", err)
 523                 return err
 524         }
 525         return nil
 526 }
 527
 528 func sendPerfAlarmDefinitionToAlarmManager(targetUrl string) error {
 529
 530         jsonData, err := json.Marshal(CliPerfAlarmDefinitions)
 531         if err != nil {
 532                 fmt.Println("sendPerfAlarmDefinitionToAlarmManager: json.Marshal failed: ", err)
 533                 return err
 534         }
 535
 536         resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
 537         if err != nil || resp == nil {
 538                 fmt.Println("sendPerfAlarmDefinitionToAlarmManager: Couldn't post alarm definition to targeturl due to error: ", targetUrl, err)
 539                 return err
 540         }
 541         return nil
 542 }
 543
 544 func wakeUpAfterTime(timeinseconds int, chn chan string, action string) {
 545         time.Sleep(time.Second * time.Duration(timeinseconds))
 546         chn <- action
 547 }
 548
 549 func raiseClearAlarmOnce(alarmobject *alarm.Alarm, flags map[string]commando.FlagValue) {
 550         var alarmClient *AlarmClient = nil
 551         defer wg.Done()
 552         chn := make(chan string, 1)
 553         rmr_or_http, _ := flags["if"].GetString()
 554         if rmr_or_http == "rmr" {
 555                 alarmClient = NewAlarmClient("my-pod", "my-app")
 556         }
 557         postAlarm(flags, *alarmobject, alarm.AlarmActionRaise, alarmClient)
 558         go wakeUpAfterTime(PeakTestDuration, chn, Clear)
 559         select {
 560         case res := <-chn:
 561                 if res == Clear {
 562                         postAlarm(flags, *alarmobject, alarm.AlarmActionClear, alarmClient)
 563                         go wakeUpAfterTime(PeakTestDuration, chn, End)
 564                 } else if res == End {
 565                         return
 566                 }
 567         }
 568 }
 569
 570 func raiseClearAlarmOverPeriod(alarmobject *alarm.Alarm, flags map[string]commando.FlagValue) {
 571         var alarmClient *AlarmClient = nil
 572         defer wg.Done()
 573         timeinminutes, _ := flags["tim"].GetInt()
 574         timeinseconds := timeinminutes * 60
 575         chn := make(chan string, 1)
 576         rmr_or_http, _ := flags["if"].GetString()
 577         if rmr_or_http == "rmr" {
 578                 alarmClient = NewAlarmClient("my-pod", "my-app")
 579         }
 580         postAlarm(flags, *alarmobject, alarm.AlarmActionRaise, alarmClient)
 581         go wakeUpAfterTime(OneSecondDuration, chn, Clear)
 582         go wakeUpAfterTime(timeinseconds, chn, End)
 583         for {
 584                 select {
 585                 case res := <-chn:
 586                         if res == Raise {
 587                                 postAlarm(flags, *alarmobject, alarm.AlarmActionRaise, alarmClient)
 588                                 go wakeUpAfterTime(OneSecondDuration, chn, Clear)
 589                         } else if res == Clear {
 590                                 postAlarm(flags, *alarmobject, alarm.AlarmActionClear, alarmClient)
 591                                 go wakeUpAfterTime(OneSecondDuration, chn, Raise)
 592                         } else if res == End {
 593                                 return
 594                         }
 595                 }
 596         }
 597 }
 598
 599 func displayAlerts(flags map[string]commando.FlagValue) {
 600         resp, err := getAlerts(flags)
 601         if err != nil {
 602                 fmt.Println(err)
 603                 return
 604         }
 605
 606         if resp == nil {
 607                 fmt.Println("resp= nil")
 608                 return
 609         }
 610
 611         t := table.NewWriter()
 612         t.SetOutputMirror(os.Stdout)
 613         t.AppendHeader(table.Row{"Alerts from Prometheus Alert Manager"})
 614         for _, gettableAlert := range resp.Payload {
 615                 t.AppendRow([]interface{}{"------------------------------------"})
 616                 if gettableAlert != nil {
 617                         for key, item := range gettableAlert.Annotations {
 618                                 t.AppendRow([]interface{}{key, item})
 619                         }
 620                         if gettableAlert.EndsAt != nil {
 621                                 t.AppendRow([]interface{}{"EndsAt", *gettableAlert.EndsAt})
 622                         }
 623                         if gettableAlert.Fingerprint != nil {
 624                                 t.AppendRow([]interface{}{"Fingerprint", *gettableAlert.Fingerprint})
 625                         }
 626                         for key, item := range gettableAlert.Receivers {
 627                                 if gettableAlert.Receivers != nil {
 628                                         t.AppendRow([]interface{}{key, *item.Name})
 629                                 }
 630                         }
 631                         if gettableAlert.StartsAt != nil {
 632                                 t.AppendRow([]interface{}{"StartsAt", *gettableAlert.StartsAt})
 633                         }
 634                         if gettableAlert.Status != nil {
 635                                 t.AppendRow([]interface{}{"InhibitedBy", gettableAlert.Status.InhibitedBy})
 636                                 t.AppendRow([]interface{}{"SilencedBy", gettableAlert.Status.SilencedBy})
 637                                 t.AppendRow([]interface{}{"State", *gettableAlert.Status.State})
 638                         }
 639                         if gettableAlert.UpdatedAt != nil {
 640                                 t.AppendRow([]interface{}{"UpdatedAt", *gettableAlert.UpdatedAt})
 641                         }
 642                         t.AppendRow([]interface{}{"GeneratorURL", gettableAlert.Alert.GeneratorURL})
 643                         for key, item := range gettableAlert.Alert.Labels {
 644                                 t.AppendRow([]interface{}{key, item})
 645                         }
 646                 }
 647         }
 648         t.SetStyle(table.StyleColoredBright)
 649         t.Render()
 650 }
 651
 652 func getAlerts(flags map[string]commando.FlagValue) (*alert.GetAlertsOK, error) {
 653         active, _ := flags["active"].GetBool()
 654         inhibited, _ := flags["inhibited"].GetBool()
 655         silenced, _ := flags["silenced"].GetBool()
 656         unprocessed, _ := flags["unprocessed"].GetBool()
 657         amHost, _ := flags["host"].GetString()
 658         amPort, _ := flags["port"].GetString()
 659         var amAddress string
 660         if amHost == "" {
 661                 amAddress = viper.GetString("controls.promAlertManager.address")
 662         } else {
 663                 amAddress = amHost + ":" + amPort
 664         }
 665
 666         alertParams := alert.NewGetAlertsParams()
 667         alertParams.Active = &active
 668         alertParams.Inhibited = &inhibited
 669         alertParams.Silenced = &silenced
 670         alertParams.Unprocessed = &unprocessed
 671         amBaseUrl := viper.GetString("controls.promAlertManager.baseUrl")
 672         amSchemes := []string{viper.GetString("controls.promAlertManager.schemes")}
 673         resp, err := newAlertManagerClient(amAddress, amBaseUrl, amSchemes).Alert.GetAlerts(alertParams)
 674         if err != nil {
 675                 err = fmt.Errorf("GetAlerts from '%s%s' failed with error: %v", amAddress, amBaseUrl, err)
 676         }
 677         return resp, err
 678 }
 679
 680 func newAlertManagerClient(amAddress string, amBaseUrl string, amSchemes []string) *client.Alertmanager {
 681         cr := clientruntime.New(amAddress, amBaseUrl, amSchemes)
 682         return client.New(cr, strfmt.Default)
 683 }