adapter/cmd/adapter.go

   1 /*
   2  *  Copyright (c) 2020 AT&T Intellectual Property.
   3  *  Copyright (c) 2020 Nokia.
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  * This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18  * platform project (RICP).
  19  */
  20
  21 package main
  22
  23 import (
  24         "encoding/json"
  25         "fmt"
  26         "sync"
  27         "time"
  28
  29         clientruntime "github.com/go-openapi/runtime/client"
  30         "github.com/go-openapi/strfmt"
  31         "github.com/prometheus/alertmanager/api/v2/client"
  32         "github.com/prometheus/alertmanager/api/v2/client/alert"
  33         "github.com/prometheus/alertmanager/api/v2/models"
  34         "github.com/spf13/viper"
  35
  36         "gerrit.o-ran-sc.org/r/ric-plt/alarm-go/alarm"
  37         app "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  38 )
  39
  40 type AlertStatus string
  41
  42 const (
  43         AlertStatusActive   = "active"
  44         AlertStatusResolved = "resolved"
  45 )
  46
  47 type AlarmAdapter struct {
  48         amHost        string
  49         amBaseUrl     string
  50         amSchemes     []string
  51         alertInterval int
  52         activeAlarms  []alarm.Alarm
  53         mutex         sync.Mutex
  54         rmrReady      bool
  55         postClear     bool
  56 }
  57
  58 var Version string
  59 var Hash string
  60
  61 // Main function
  62 func main() {
  63         NewAlarmAdapter("", 0).Run(true)
  64 }
  65
  66 func NewAlarmAdapter(amHost string, alertInterval int) *AlarmAdapter {
  67         if alertInterval == 0 {
  68                 alertInterval = viper.GetInt("promAlertManager.alertInterval")
  69         }
  70
  71         if amHost == "" {
  72                 amHost = viper.GetString("promAlertManager.address")
  73         }
  74
  75         return &AlarmAdapter{
  76                 rmrReady:      false,
  77                 amHost:        amHost,
  78                 amBaseUrl:     viper.GetString("promAlertManager.baseUrl"),
  79                 amSchemes:     []string{viper.GetString("promAlertManager.schemes")},
  80                 alertInterval: alertInterval,
  81                 activeAlarms:  make([]alarm.Alarm, 0),
  82         }
  83 }
  84
  85 func (a *AlarmAdapter) Run(sdlcheck bool) {
  86         app.Logger.SetMdc("alarmAdapter", fmt.Sprintf("%s:%s", Version, Hash))
  87         app.SetReadyCB(func(d interface{}) { a.rmrReady = true }, true)
  88         app.Resource.InjectStatusCb(a.StatusCB)
  89
  90         app.Resource.InjectRoute("/ric/v1/alarms", a.GetActiveAlarms, "GET")
  91         app.Resource.InjectRoute("/ric/v1/alarms", a.RaiseAlarm, "POST")
  92         app.Resource.InjectRoute("/ric/v1/alarms", a.ClearAlarm, "DELETE")
  93
  94         // Start background timer for re-raising alerts
  95         a.postClear = sdlcheck
  96         go a.StartAlertTimer()
  97
  98         app.RunWithParams(a, sdlcheck)
  99 }
 100
 101 func (a *AlarmAdapter) StartAlertTimer() {
 102         tick := time.Tick(time.Duration(a.alertInterval) * time.Millisecond)
 103         for range tick {
 104                 a.mutex.Lock()
 105                 for _, m := range a.activeAlarms {
 106                         app.Logger.Info("Re-raising alarm: %v", m)
 107                         a.PostAlert(a.GenerateAlertLabels(m, AlertStatusActive))
 108                 }
 109                 a.mutex.Unlock()
 110         }
 111 }
 112
 113 func (a *AlarmAdapter) Consume(rp *app.RMRParams) (err error) {
 114         app.Logger.Info("Message received!")
 115
 116         defer app.Rmr.Free(rp.Mbuf)
 117         switch rp.Mtype {
 118         case alarm.RIC_ALARM_UPDATE:
 119                 a.HandleAlarms(rp)
 120         default:
 121                 app.Logger.Info("Unknown Message Type '%d', discarding", rp.Mtype)
 122         }
 123
 124         return nil
 125 }
 126
 127 func (a *AlarmAdapter) HandleAlarms(rp *app.RMRParams) (*alert.PostAlertsOK, error) {
 128         var m alarm.AlarmMessage
 129         if err := json.Unmarshal(rp.Payload, &m); err != nil {
 130                 app.Logger.Error("json.Unmarshal failed: %v", err)
 131                 return nil, err
 132         }
 133         app.Logger.Info("newAlarm: %v", m)
 134
 135         if _, ok := alarm.RICAlarmDefinitions[m.Alarm.SpecificProblem]; !ok {
 136                 app.Logger.Warn("Alarm (SP='%d') not recognized, ignoring ...", m.Alarm.SpecificProblem)
 137                 return nil, nil
 138         }
 139
 140         // Suppress duplicate alarms
 141         idx, found := a.IsMatchFound(m.Alarm)
 142         if found && m.AlarmAction != alarm.AlarmActionClear {
 143                 app.Logger.Info("Duplicate alarm ... suppressing!")
 144                 return nil, nil
 145         }
 146
 147         // Clear alarm if found from active alarm list
 148         if m.AlarmAction == alarm.AlarmActionClear {
 149                 if found {
 150                         a.activeAlarms = a.RemoveAlarm(a.activeAlarms, idx)
 151                         app.Logger.Info("Active alarm cleared!")
 152
 153                         if a.postClear {
 154                                 return a.PostAlert(a.GenerateAlertLabels(m.Alarm, AlertStatusResolved))
 155                         }
 156                 }
 157                 app.Logger.Info("No matching alarm found, ignoring!")
 158                 return nil, nil
 159         }
 160
 161         // New alarm -> update active alarms and post to Alert Manager
 162         if m.AlarmAction == alarm.AlarmActionRaise {
 163                 a.UpdateActiveAlarms(m.Alarm)
 164                 return a.PostAlert(a.GenerateAlertLabels(m.Alarm, AlertStatusActive))
 165         }
 166
 167         return nil, nil
 168 }
 169
 170 func (a *AlarmAdapter) IsMatchFound(newAlarm alarm.Alarm) (int, bool) {
 171         for i, m := range a.activeAlarms {
 172                 if m.ManagedObjectId == newAlarm.ManagedObjectId && m.ApplicationId == newAlarm.ApplicationId &&
 173                         m.SpecificProblem == newAlarm.SpecificProblem && m.IdentifyingInfo == newAlarm.IdentifyingInfo {
 174                         return i, true
 175                 }
 176         }
 177         return -1, false
 178 }
 179
 180 func (a *AlarmAdapter) RemoveAlarm(alarms []alarm.Alarm, i int) []alarm.Alarm {
 181         a.mutex.Lock()
 182         defer a.mutex.Unlock()
 183
 184         copy(alarms[i:], alarms[i+1:])
 185         return alarms[:len(alarms)-1]
 186 }
 187
 188 func (a *AlarmAdapter) UpdateActiveAlarms(newAlarm alarm.Alarm) {
 189         a.mutex.Lock()
 190         defer a.mutex.Unlock()
 191
 192         // For now just keep the active alarms in-memory. Use SDL later
 193         a.activeAlarms = append(a.activeAlarms, newAlarm)
 194 }
 195
 196 func (a *AlarmAdapter) GenerateAlertLabels(newAlarm alarm.Alarm, status AlertStatus) (models.LabelSet, models.LabelSet) {
 197         alarmDef := alarm.RICAlarmDefinitions[newAlarm.SpecificProblem]
 198         amLabels := models.LabelSet{
 199                 "status":      string(status),
 200                 "alertname":   alarmDef.AlarmText,
 201                 "severity":    string(newAlarm.PerceivedSeverity),
 202                 "service":     fmt.Sprintf("%s:%s", newAlarm.ManagedObjectId, newAlarm.ApplicationId),
 203                 "system_name": "RIC",
 204         }
 205         amAnnotations := models.LabelSet{
 206                 "alarm_id":        string(alarmDef.AlarmId),
 207                 "description":     newAlarm.IdentifyingInfo,
 208                 "additional_info": newAlarm.AdditionalInfo,
 209                 "summary":         alarmDef.EventType,
 210                 "instructions":    alarmDef.OperationInstructions,
 211         }
 212
 213         return amLabels, amAnnotations
 214 }
 215
 216 func (a *AlarmAdapter) NewAlertmanagerClient() *client.Alertmanager {
 217         cr := clientruntime.New(a.amHost, a.amBaseUrl, a.amSchemes)
 218         return client.New(cr, strfmt.Default)
 219 }
 220
 221 func (a *AlarmAdapter) PostAlert(amLabels, amAnnotations models.LabelSet) (*alert.PostAlertsOK, error) {
 222         pa := &models.PostableAlert{
 223                 Alert: models.Alert{
 224                         GeneratorURL: strfmt.URI(""),
 225                         Labels:       amLabels,
 226                 },
 227                 Annotations: amAnnotations,
 228         }
 229         alertParams := alert.NewPostAlertsParams().WithAlerts(models.PostableAlerts{pa})
 230
 231         app.Logger.Info("Posting alerts: labels: %v, annotations: %v", amLabels, amAnnotations)
 232         ok, err := a.NewAlertmanagerClient().Alert.PostAlerts(alertParams)
 233         if err != nil {
 234                 app.Logger.Error("Posting alerts to '%s/%s' failed with error: %v", a.amHost, a.amBaseUrl, err)
 235         }
 236         return ok, err
 237 }
 238
 239 func (a *AlarmAdapter) StatusCB() bool {
 240         if !a.rmrReady {
 241                 app.Logger.Info("RMR not ready yet!")
 242         }
 243
 244         return a.rmrReady
 245 }