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("rad", "Raise alarm delay", commando.Int, 0).
 146                 AddFlag("cad", "Clear alarm delay", commando.Int, 0).
 147                 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
 148                 AddFlag("port", "Alarm manager host address", commando.String, "8080").
 149                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
 150                         postAlarmDefinition(flags)
 151                 })
 152                 // Delete alarm definition
 153         commando.
 154                 Register("undefine").
 155                 SetShortDescription("Define alarm with given parameters").
 156                 AddFlag("aid", "alarm identifier", commando.Int, nil).
 157                 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
 158                 AddFlag("port", "Alarm manager host address", commando.String, "8080").
 159                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
 160                         deleteAlarmDefinition(flags)
 161                 })
 162                 // Conduct performance test for alarm-go
 163         commando.
 164                 Register("perf").
 165                 SetShortDescription("Conduct performance test with given parameters").
 166                 AddFlag("prf", "performance profile id", commando.Int, nil).
 167                 AddFlag("nal", "number of alarms", commando.Int, nil).
 168                 AddFlag("aps", "alarms per sec", commando.Int, nil).
 169                 AddFlag("tim", "total time of test", commando.Int, nil).
 170                 AddFlag("host", "Alarm manager host address", commando.String, alarmManagerHost).
 171                 AddFlag("port", "Alarm manager host address", commando.String, "8080").
 172                 AddFlag("if", "http or rmr used as interface", commando.String, "http").
 173                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
 174                         conductperformancetest(flags)
 175                 })
 176
 177         // Get alerts from Prometheus Alert Manager
 178         commando.
 179                 Register("gapam").
 180                 SetShortDescription("Get alerts from Prometheus Alert Manager").
 181                 AddFlag("active", "Active alerts in Prometheus Alert Manager", commando.Bool, true).
 182                 AddFlag("inhibited", "Inhibited alerts in Prometheus Alert Manager", commando.Bool, true).
 183                 AddFlag("silenced", "Silenced alerts in Prometheus Alert Manager", commando.Bool, true).
 184                 AddFlag("unprocessed", "Unprocessed alerts in Prometheus Alert Manager", commando.Bool, true).
 185                 AddFlag("host", "Prometheus Alert Manager host address", commando.String, alertManagerHost).
 186                 AddFlag("port", "Prometheus Alert Manager port", commando.String, "9093").
 187                 SetAction(func(args map[string]commando.ArgValue, flags map[string]commando.FlagValue) {
 188                         displayAlerts(flags)
 189                 })
 190
 191         // parse command-line arguments
 192         commando.Parse(nil)
 193 }
 194
 195 func readAlarmParams(flags map[string]commando.FlagValue, clear bool) (a alarm.Alarm) {
 196         a.ManagedObjectId, _ = flags["moid"].GetString()
 197         a.ApplicationId, _ = flags["apid"].GetString()
 198         a.SpecificProblem, _ = flags["sp"].GetInt()
 199         a.IdentifyingInfo, _ = flags["iinfo"].GetString()
 200
 201         if !clear {
 202                 s, _ := flags["severity"].GetString()
 203                 a.PerceivedSeverity = alarm.Severity(s)
 204         }
 205
 206         if !clear {
 207                 a.AdditionalInfo, _ = flags["aai"].GetString()
 208         }
 209         return
 210 }
 211
 212 func getAlarms(flags map[string]commando.FlagValue, action alarm.AlarmAction) (alarms []AlarmNotification) {
 213         host, _ := flags["host"].GetString()
 214         port, _ := flags["port"].GetString()
 215         targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/%s", host, port, action)
 216         resp, err := http.Get(targetUrl)
 217         if err != nil || resp == nil || resp.Body == nil {
 218                 fmt.Println("Couldn't fetch active alarm list due to error: ", err)
 219                 return alarms
 220         }
 221
 222         defer resp.Body.Close()
 223
 224         body, err := ioutil.ReadAll(resp.Body)
 225         if err != nil {
 226                 fmt.Println("ioutil.ReadAll failed: ", err)
 227                 return alarms
 228         }
 229
 230         json.Unmarshal([]byte(body), &alarms)
 231         return alarms
 232 }
 233
 234 func postAlarmWithRmrIf(a alarm.Alarm, action alarm.AlarmAction, alarmClient *AlarmClient) {
 235         if alarmClient == nil {
 236                 alarmClient = NewAlarmClient("my-pod", "my-app")
 237         }
 238         if alarmClient == nil {
 239                 return
 240         }
 241
 242         // Wait until RMR is up-and-running
 243         for !alarmClient.alarmer.IsRMRReady() {
 244                 time.Sleep(100 * time.Millisecond)
 245         }
 246
 247         if action == alarm.AlarmActionRaise {
 248                 alarmClient.alarmer.Raise(a)
 249         }
 250
 251         if action == alarm.AlarmActionClear {
 252                 alarmClient.alarmer.Clear(a)
 253         }
 254         return
 255 }
 256
 257 func postAlarmWithHttpIf(targetUrl string, a alarm.Alarm, action alarm.AlarmAction) {
 258         m := alarm.AlarmMessage{Alarm: a, AlarmAction: action}
 259         jsonData, err := json.Marshal(m)
 260         if err != nil {
 261                 fmt.Println("json.Marshal failed: ", err)
 262                 return
 263         }
 264
 265         resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
 266         if err != nil || resp == nil {
 267                 fmt.Println("Couldn't fetch active alarm list due to error: ", err)
 268                 return
 269         }
 270 }
 271
 272 func postAlarm(flags map[string]commando.FlagValue, a alarm.Alarm, action alarm.AlarmAction, alarmClient *AlarmClient) {
 273         // Check the interface to be used for raise or clear the alarm
 274         rmr_or_http, _ := flags["if"].GetString()
 275         if rmr_or_http == "rmr" {
 276                 postAlarmWithRmrIf(a, action, alarmClient)
 277         } else {
 278
 279                 host, _ := flags["host"].GetString()
 280                 port, _ := flags["port"].GetString()
 281                 targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms", host, port)
 282                 postAlarmWithHttpIf(targetUrl, a, action)
 283         }
 284         fmt.Println("command executed successfully!")
 285 }
 286
 287 func displayAlarms(alarms []AlarmNotification, isHistory bool) {
 288         t := table.NewWriter()
 289         t.SetOutputMirror(os.Stdout)
 290         if isHistory {
 291                 t.AppendHeader(table.Row{"ID", "SP", "MOID", "APPID", "IINFO", "SEVERITY", "AAI", "ACTION", "TIME"})
 292         } else {
 293                 t.AppendHeader(table.Row{"ID", "SP", "MOID", "APPID", "IINFO", "SEVERITY", "AAI", "TIME"})
 294         }
 295
 296         for _, a := range alarms {
 297                 // Do not show alarm before raiseDelay has elapsed
 298                 alarmTime := time.Unix(0, a.AlarmTime).Format("02/01/2006, 15:04:05")
 299                 if isHistory {
 300                         t.AppendRows([]table.Row{
 301                                 {a.AlarmId, a.SpecificProblem, a.ManagedObjectId, a.ApplicationId, a.IdentifyingInfo, a.PerceivedSeverity, a.AdditionalInfo, a.AlarmAction, alarmTime},
 302                         })
 303                 } else {
 304                         if a.AlarmDefinition.RaiseDelay == 0 {
 305                                 t.AppendRows([]table.Row{
 306                                         {a.AlarmId, a.SpecificProblem, a.ManagedObjectId, a.ApplicationId, a.IdentifyingInfo, a.PerceivedSeverity, a.AdditionalInfo, alarmTime},
 307                                 })
 308                         }
 309                 }
 310         }
 311
 312         t.SetStyle(table.StyleColoredBright)
 313         t.Render()
 314 }
 315
 316 func postAlarmConfig(flags map[string]commando.FlagValue) {
 317         host, _ := flags["host"].GetString()
 318         port, _ := flags["port"].GetString()
 319         maxactivealarms, _ := flags["mal"].GetInt()
 320         maxalarmhistory, _ := flags["mah"].GetInt()
 321         targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/config", host, port)
 322
 323         m := alarm.AlarmConfigParams{MaxActiveAlarms: maxactivealarms, MaxAlarmHistory: maxalarmhistory}
 324         jsonData, err := json.Marshal(m)
 325         if err != nil {
 326                 fmt.Println("json.Marshal failed: ", err)
 327                 return
 328         }
 329
 330         resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
 331         if err != nil || resp == nil {
 332                 fmt.Println("Couldn't fetch post alarm configuration due to error: ", err)
 333                 return
 334         }
 335 }
 336
 337 func postAlarmDefinition(flags map[string]commando.FlagValue) {
 338         host, _ := flags["host"].GetString()
 339         port, _ := flags["port"].GetString()
 340         alarmid, _ := flags["aid"].GetInt()
 341         alarmtxt, _ := flags["atx"].GetString()
 342         etype, _ := flags["ety"].GetString()
 343         operation, _ := flags["oin"].GetString()
 344         raiseDelay, _ := flags["rad"].GetInt()
 345         clearDelay, _ := flags["cad"].GetInt()
 346
 347         targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/define", host, port)
 348
 349         var alarmdefinition alarm.AlarmDefinition
 350         alarmdefinition.AlarmId = alarmid
 351         alarmdefinition.AlarmText = alarmtxt
 352         alarmdefinition.EventType = etype
 353         alarmdefinition.OperationInstructions = operation
 354         alarmdefinition.RaiseDelay = raiseDelay
 355         alarmdefinition.ClearDelay = clearDelay
 356
 357         m := CliAlarmDefinitions{AlarmDefinitions: []*alarm.AlarmDefinition{&alarmdefinition}}
 358         jsonData, err := json.Marshal(m)
 359         if err != nil {
 360                 fmt.Println("json.Marshal failed: ", err)
 361                 return
 362         }
 363
 364         resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
 365         if err != nil || resp == nil {
 366                 fmt.Println("Couldn't post alarm definition due to error: ", err)
 367                 return
 368         }
 369 }
 370
 371 func deleteAlarmDefinition(flags map[string]commando.FlagValue) {
 372         host, _ := flags["host"].GetString()
 373         port, _ := flags["port"].GetString()
 374         alarmid, _ := flags["aid"].GetInt()
 375         salarmid := strconv.FormatUint(uint64(alarmid), 10)
 376         targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/define/%s", host, port, salarmid)
 377
 378         client := &http.Client{}
 379         req, err := http.NewRequest("DELETE", targetUrl, nil)
 380         if err != nil || req == nil {
 381                 fmt.Println("Couldn't make delete request due to error: ", err)
 382                 return
 383         }
 384         resp, errr := client.Do(req)
 385         if errr != nil || resp == nil {
 386                 fmt.Println("Couldn't send delete request due to error: ", err)
 387                 return
 388         }
 389 }
 390
 391 // NewAlarmClient returns a new AlarmClient.
 392 func NewAlarmClient(moId, appId string) *AlarmClient {
 393         alarmInstance, err := alarm.InitAlarm(moId, appId)
 394         if err == nil {
 395                 return &AlarmClient{
 396                         alarmer: alarmInstance,
 397                 }
 398         }
 399         fmt.Println("Failed to create alarmInstance", err)
 400         return nil
 401 }
 402
 403 // Conduct performance testing
 404 func conductperformancetest(flags map[string]commando.FlagValue) {
 405         var readerror error
 406         var senderror error
 407         var readobjerror error
 408         host, _ := flags["host"].GetString()
 409         port, _ := flags["port"].GetString()
 410         targetUrl := fmt.Sprintf("http://%s:%s/ric/v1/alarms/define", host, port)
 411         readerror = readPerfAlarmDefinitionFromJson()
 412         if readerror == nil {
 413                 senderror = sendPerfAlarmDefinitionToAlarmManager(targetUrl)
 414                 if senderror == nil {
 415                         fmt.Println("sent performance alarm definitions to alarm manager")
 416                         CLIPerfAlarmObjects = make(map[int]*alarm.Alarm)
 417                         readobjerror = readPerfAlarmObjectFromJson()
 418                         if readobjerror == nil {
 419                                 profile, _ := flags["prf"].GetInt()
 420                                 if profile == 1 {
 421                                         fmt.Println("starting peak performance test")
 422                                         peakPerformanceTest(flags)
 423                                 } else if profile == 2 {
 424                                         fmt.Println("starting endurance test")
 425                                         enduranceTest(flags)
 426                                 } else {
 427                                         fmt.Println("Unknown profile, received profile = ", profile)
 428                                 }
 429                         } else {
 430                                 fmt.Println("reading performance alarm objects from json file failed ")
 431                         }
 432                 } else {
 433                         fmt.Println("sending performance alarm definitions to alarm manager failed ")
 434                 }
 435
 436         } else {
 437                 fmt.Println("reading performance alarm definitions from json file failed ")
 438         }
 439 }
 440
 441 func peakPerformanceTest(flags map[string]commando.FlagValue) {
 442         nalarms, _ := flags["nal"].GetInt()
 443         var count int = 0
 444         for aid, obj := range CLIPerfAlarmObjects {
 445                 count = count + 1
 446                 if count <= nalarms {
 447                         fmt.Println("peakPerformanceTest: invoking worker routine ", count, aid, *obj)
 448                         wg.Add(1)
 449                         go raiseClearAlarmOnce(obj, flags)
 450                 } else {
 451                         break
 452                 }
 453         }
 454         fmt.Println("peakPerformanceTest: Waiting for workers to finish")
 455         wg.Wait()
 456         fmt.Println("peakPerformanceTest: Wait completed")
 457 }
 458
 459 func enduranceTest(flags map[string]commando.FlagValue) {
 460         alarmspersec, _ := flags["aps"].GetInt()
 461         var count int = 0
 462         for aid, obj := range CLIPerfAlarmObjects {
 463                 count = count + 1
 464                 if count <= alarmspersec {
 465                         fmt.Println("enduranceTest: invoking worker routine ", count, aid, *obj)
 466                         wg.Add(1)
 467                         go raiseClearAlarmOverPeriod(obj, flags)
 468                 } else {
 469                         break
 470                 }
 471         }
 472         fmt.Println("enduranceTest: Waiting for workers to finish")
 473         wg.Wait()
 474         fmt.Println("enduranceTest: Wait completed")
 475 }
 476
 477 func readPerfAlarmObjectFromJson() error {
 478
 479         filename := os.Getenv("PERF_OBJ_FILE")
 480         fmt.Printf("readPerfAlarmObjectFromJson: filename = %s\n", filename)
 481
 482         file, err := ioutil.ReadFile(filename)
 483         if err == nil {
 484                 data := RicPerfAlarmObjects{}
 485                 err = json.Unmarshal([]byte(file), &data)
 486                 if err == nil {
 487                         for _, alarmObject := range data.AlarmObjects {
 488                                 ricAlarmObject := new(alarm.Alarm)
 489                                 ricAlarmObject.ManagedObjectId = alarmObject.ManagedObjectId
 490                                 ricAlarmObject.ApplicationId = alarmObject.ApplicationId
 491                                 ricAlarmObject.SpecificProblem = alarmObject.SpecificProblem
 492                                 ricAlarmObject.PerceivedSeverity = alarmObject.PerceivedSeverity
 493                                 ricAlarmObject.AdditionalInfo = alarmObject.AdditionalInfo
 494                                 ricAlarmObject.IdentifyingInfo = alarmObject.IdentifyingInfo
 495                                 CLIPerfAlarmObjects[alarmObject.SpecificProblem] = ricAlarmObject
 496                         }
 497                 } else {
 498                         fmt.Println("readPerfAlarmObjectFromJson: json.Unmarshal failed with error: ", err)
 499                         return err
 500                 }
 501         } else {
 502                 fmt.Printf("readPerfAlarmObjectFromJson: ioutil.ReadFile failed with error: %v, filename: %s\n", err, filename)
 503                 fmt.Printf("readPerfAlarmObjectFromJson: current directory: %s\n", getCurrentDirectory())
 504                 return err
 505         }
 506         return nil
 507 }
 508
 509 func readPerfAlarmDefinitionFromJson() error {
 510
 511         filename := os.Getenv("PERF_DEF_FILE")
 512         fmt.Printf("ReadPerfAlarmDefinitionFromJson: filename = %s\n", filename)
 513
 514         file, err := ioutil.ReadFile(filename)
 515         if err == nil {
 516                 data := CliAlarmDefinitions{}
 517                 err = json.Unmarshal([]byte(file), &data)
 518                 if err == nil {
 519                         for _, alarmDefinition := range data.AlarmDefinitions {
 520                                 _, exists := alarm.RICAlarmDefinitions[alarmDefinition.AlarmId]
 521                                 if exists {
 522                                         fmt.Println("ReadPerfAlarmDefinitionFromJson: alarm definition already exists for ", alarmDefinition.AlarmId)
 523                                 } else {
 524                                         fmt.Println("ReadPerfAlarmDefinitionFromJson: alarm ", alarmDefinition.AlarmId)
 525                                         ricAlarmDefintion := new(alarm.AlarmDefinition)
 526                                         ricAlarmDefintion.AlarmId = alarmDefinition.AlarmId
 527                                         ricAlarmDefintion.AlarmText = alarmDefinition.AlarmText
 528                                         ricAlarmDefintion.EventType = alarmDefinition.EventType
 529                                         ricAlarmDefintion.OperationInstructions = alarmDefinition.OperationInstructions
 530                                         ricAlarmDefintion.RaiseDelay = alarmDefinition.RaiseDelay
 531                                         ricAlarmDefintion.ClearDelay = alarmDefinition.ClearDelay
 532                                         CliPerfAlarmDefinitions.AlarmDefinitions = append(CliPerfAlarmDefinitions.AlarmDefinitions, ricAlarmDefintion)
 533                                 }
 534                         }
 535                 } else {
 536                         fmt.Println("ReadPerfAlarmDefinitionFromJson: json.Unmarshal failed with error: ", err)
 537                         return err
 538                 }
 539         } else {
 540                 fmt.Printf("ReadPerfAlarmDefinitionFromJson: ioutil.ReadFile failed with error: %v, filename: %s\n", err, filename)
 541                 fmt.Printf("ReadPerfAlarmDefinitionFromJson: current directory: %s\n", getCurrentDirectory())
 542
 543                 return err
 544         }
 545         return nil
 546 }
 547
 548 func sendPerfAlarmDefinitionToAlarmManager(targetUrl string) error {
 549
 550         jsonData, err := json.Marshal(CliPerfAlarmDefinitions)
 551         if err != nil {
 552                 fmt.Println("sendPerfAlarmDefinitionToAlarmManager: json.Marshal failed: ", err)
 553                 return err
 554         }
 555
 556         resp, err := http.Post(targetUrl, "application/json", bytes.NewBuffer(jsonData))
 557         if err != nil || resp == nil {
 558                 fmt.Println("sendPerfAlarmDefinitionToAlarmManager: Couldn't post alarm definition to targeturl due to error: ", targetUrl, err)
 559                 return err
 560         }
 561         return nil
 562 }
 563
 564 func wakeUpAfterTime(timeinseconds int, chn chan string, action string) {
 565         time.Sleep(time.Second * time.Duration(timeinseconds))
 566         chn <- action
 567 }
 568
 569 func raiseClearAlarmOnce(alarmobject *alarm.Alarm, flags map[string]commando.FlagValue) {
 570         var alarmClient *AlarmClient = nil
 571         defer wg.Done()
 572         chn := make(chan string, 1)
 573         rmr_or_http, _ := flags["if"].GetString()
 574         if rmr_or_http == "rmr" {
 575                 alarmClient = NewAlarmClient("my-pod", "my-app")
 576         }
 577         postAlarm(flags, *alarmobject, alarm.AlarmActionRaise, alarmClient)
 578         go wakeUpAfterTime(PeakTestDuration, chn, Clear)
 579         select {
 580         case res := <-chn:
 581                 if res == Clear {
 582                         postAlarm(flags, *alarmobject, alarm.AlarmActionClear, alarmClient)
 583                         go wakeUpAfterTime(PeakTestDuration, chn, End)
 584                 } else if res == End {
 585                         return
 586                 }
 587         }
 588 }
 589
 590 func raiseClearAlarmOverPeriod(alarmobject *alarm.Alarm, flags map[string]commando.FlagValue) {
 591         var alarmClient *AlarmClient = nil
 592         defer wg.Done()
 593         timeinminutes, _ := flags["tim"].GetInt()
 594         timeinseconds := timeinminutes * 60
 595         chn := make(chan string, 1)
 596         rmr_or_http, _ := flags["if"].GetString()
 597         if rmr_or_http == "rmr" {
 598                 alarmClient = NewAlarmClient("my-pod", "my-app")
 599         }
 600         postAlarm(flags, *alarmobject, alarm.AlarmActionRaise, alarmClient)
 601         go wakeUpAfterTime(OneSecondDuration, chn, Clear)
 602         go wakeUpAfterTime(timeinseconds, chn, End)
 603         for {
 604                 select {
 605                 case res := <-chn:
 606                         if res == Raise {
 607                                 postAlarm(flags, *alarmobject, alarm.AlarmActionRaise, alarmClient)
 608                                 go wakeUpAfterTime(OneSecondDuration, chn, Clear)
 609                         } else if res == Clear {
 610                                 postAlarm(flags, *alarmobject, alarm.AlarmActionClear, alarmClient)
 611                                 go wakeUpAfterTime(OneSecondDuration, chn, Raise)
 612                         } else if res == End {
 613                                 return
 614                         }
 615                 }
 616         }
 617 }
 618
 619 func displayAlerts(flags map[string]commando.FlagValue) {
 620         resp, err := getAlerts(flags)
 621         if err != nil {
 622                 fmt.Println(err)
 623                 return
 624         }
 625
 626         if resp == nil {
 627                 fmt.Println("resp= nil")
 628                 return
 629         }
 630
 631         t := table.NewWriter()
 632         t.SetOutputMirror(os.Stdout)
 633         t.AppendHeader(table.Row{"Alerts from Prometheus Alert Manager"})
 634         for _, gettableAlert := range resp.Payload {
 635                 t.AppendRow([]interface{}{"------------------------------------"})
 636                 if gettableAlert != nil {
 637                         for key, item := range gettableAlert.Annotations {
 638                                 t.AppendRow([]interface{}{key, item})
 639                         }
 640                         if gettableAlert.EndsAt != nil {
 641                                 t.AppendRow([]interface{}{"EndsAt", *gettableAlert.EndsAt})
 642                         }
 643                         if gettableAlert.Fingerprint != nil {
 644                                 t.AppendRow([]interface{}{"Fingerprint", *gettableAlert.Fingerprint})
 645                         }
 646                         for key, item := range gettableAlert.Receivers {
 647                                 if gettableAlert.Receivers != nil {
 648                                         t.AppendRow([]interface{}{key, *item.Name})
 649                                 }
 650                         }
 651                         if gettableAlert.StartsAt != nil {
 652                                 t.AppendRow([]interface{}{"StartsAt", *gettableAlert.StartsAt})
 653                         }
 654                         if gettableAlert.Status != nil {
 655                                 t.AppendRow([]interface{}{"InhibitedBy", gettableAlert.Status.InhibitedBy})
 656                                 t.AppendRow([]interface{}{"SilencedBy", gettableAlert.Status.SilencedBy})
 657                                 t.AppendRow([]interface{}{"State", *gettableAlert.Status.State})
 658                         }
 659                         if gettableAlert.UpdatedAt != nil {
 660                                 t.AppendRow([]interface{}{"UpdatedAt", *gettableAlert.UpdatedAt})
 661                         }
 662                         t.AppendRow([]interface{}{"GeneratorURL", gettableAlert.Alert.GeneratorURL})
 663                         for key, item := range gettableAlert.Alert.Labels {
 664                                 t.AppendRow([]interface{}{key, item})
 665                         }
 666                 }
 667         }
 668         t.SetStyle(table.StyleColoredBright)
 669         t.Render()
 670 }
 671
 672 func getAlerts(flags map[string]commando.FlagValue) (*alert.GetAlertsOK, error) {
 673         active, _ := flags["active"].GetBool()
 674         inhibited, _ := flags["inhibited"].GetBool()
 675         silenced, _ := flags["silenced"].GetBool()
 676         unprocessed, _ := flags["unprocessed"].GetBool()
 677         amHost, _ := flags["host"].GetString()
 678         amPort, _ := flags["port"].GetString()
 679         var amAddress string
 680         if amHost == "" {
 681                 amAddress = viper.GetString("controls.promAlertManager.address")
 682         } else {
 683                 amAddress = amHost + ":" + amPort
 684         }
 685
 686         alertParams := alert.NewGetAlertsParams()
 687         alertParams.Active = &active
 688         alertParams.Inhibited = &inhibited
 689         alertParams.Silenced = &silenced
 690         alertParams.Unprocessed = &unprocessed
 691         amBaseUrl := viper.GetString("controls.promAlertManager.baseUrl")
 692         amSchemes := []string{viper.GetString("controls.promAlertManager.schemes")}
 693         resp, err := newAlertManagerClient(amAddress, amBaseUrl, amSchemes).Alert.GetAlerts(alertParams)
 694         if err != nil {
 695                 err = fmt.Errorf("GetAlerts from '%s%s' failed with error: %v", amAddress, amBaseUrl, err)
 696         }
 697         return resp, err
 698 }
 699
 700 func newAlertManagerClient(amAddress string, amBaseUrl string, amSchemes []string) *client.Alertmanager {
 701         cr := clientruntime.New(amAddress, amBaseUrl, amSchemes)
 702         return client.New(cr, strfmt.Default)
 703 }
 704
 705 func getCurrentDirectory() string {
 706         dir, err := os.Getwd()
 707         if err != nil {
 708                 fmt.Println(err)
 709         }
 710         return dir
 711 }