| /* |
| * Copyright (c) 2020 AT&T Intellectual Property. |
| * Copyright (c) 2020 Nokia. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| * This source code is part of the near-RT RIC (RAN Intelligent Controller) |
| * platform project (RICP). |
| */ |
| |
| package main |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "fmt" |
| "io/ioutil" |
| "net/http" |
| "os" |
| "time" |
| |
| "gerrit.o-ran-sc.org/r/ric-plt/alarm-go/alarm" |
| app "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp" |
| clientruntime "github.com/go-openapi/runtime/client" |
| "github.com/go-openapi/strfmt" |
| "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" |
| ) |
| |
| func (a *AlarmManager) ClearExpiredAlarms(m AlarmNotification, idx int, mLocked bool) bool { |
| d, ok := alarm.RICAlarmDefinitions[m.Alarm.SpecificProblem] |
| if !ok || d.TimeToLive == 0 { |
| return false |
| } |
| |
| elapsed := (time.Now().UnixNano() - m.AlarmTime) / 1e9 |
| if int(elapsed) >= d.TimeToLive { |
| app.Logger.Info("Alarm (sp=%d id=%d) with TTL=%d expired, clearing ...", m.Alarm.SpecificProblem, m.AlarmId, d.TimeToLive) |
| |
| m.AlarmAction = alarm.AlarmActionClear |
| m.AlarmTime = time.Now().UnixNano() |
| |
| if !mLocked { // For testing purpose |
| a.mutex.Lock() |
| } |
| a.ProcessClearAlarm(&m, d, idx) |
| return true |
| } |
| return false |
| } |
| |
| func (a *AlarmManager) StartTTLTimer(interval int) { |
| tick := time.Tick(time.Duration(interval) * time.Second) |
| for range tick { |
| a.mutex.Lock() |
| for idx, m := range a.activeAlarms { |
| if a.ClearExpiredAlarms(m, idx, true) { |
| a.mutex.Lock() // ClearExpiredAlarms unlocks the mutex, so re-lock here |
| continue |
| } |
| } |
| a.mutex.Unlock() |
| } |
| } |
| |
| func (a *AlarmManager) StartAlertTimer() { |
| tick := time.Tick(time.Duration(a.alertInterval) * time.Millisecond) |
| for range tick { |
| a.mutex.Lock() |
| for _, m := range a.activeAlarms { |
| app.Logger.Info("Re-raising alarm: %v", m) |
| a.PostAlert(a.GenerateAlertLabels(m.AlarmId, m.Alarm, AlertStatusActive, m.AlarmTime)) |
| } |
| a.mutex.Unlock() |
| } |
| } |
| |
| func (a *AlarmManager) Consume(rp *app.RMRParams) (err error) { |
| app.Logger.Info("Message received!") |
| |
| defer app.Rmr.Free(rp.Mbuf) |
| switch rp.Mtype { |
| case alarm.RIC_ALARM_UPDATE: |
| a.HandleAlarms(rp) |
| default: |
| app.Logger.Info("Unknown Message Type '%d', discarding", rp.Mtype) |
| } |
| |
| return nil |
| } |
| |
| func (a *AlarmManager) HandleAlarms(rp *app.RMRParams) (*alert.PostAlertsOK, error) { |
| var m alarm.AlarmMessage |
| app.Logger.Info("Received JSON: %s", rp.Payload) |
| if err := json.Unmarshal(rp.Payload, &m); err != nil { |
| app.Logger.Error("json.Unmarshal failed: %v", err) |
| return nil, err |
| } |
| app.Logger.Info("newAlarm: %v", m) |
| |
| return a.ProcessAlarm(&AlarmNotification{m, alarm.AlarmDefinition{}}) |
| } |
| |
| func (a *AlarmManager) ProcessAlarm(m *AlarmNotification) (*alert.PostAlertsOK, error) { |
| a.mutex.Lock() |
| alarmDef := &alarm.AlarmDefinition{} |
| var ok bool |
| if alarmDef, ok = alarm.RICAlarmDefinitions[m.Alarm.SpecificProblem]; !ok { |
| app.Logger.Warn("Alarm (SP='%d') not recognized, suppressing ...", m.Alarm.SpecificProblem) |
| a.mutex.Unlock() |
| return nil, nil |
| } |
| |
| idx, found := a.IsMatchFound(m.Alarm) |
| // Suppress duplicate alarms |
| if found && m.AlarmAction == alarm.AlarmActionRaise { |
| app.Logger.Info("Duplicate alarm found, suppressing ...") |
| if m.PerceivedSeverity == a.activeAlarms[idx].PerceivedSeverity { |
| // Duplicate with same severity found |
| a.mutex.Unlock() |
| return nil, nil |
| } else { |
| // Remove duplicate with different severity |
| a.activeAlarms = a.RemoveAlarm(a.activeAlarms, idx, "active") |
| } |
| } |
| |
| // Clear alarm if found from active alarm list |
| if found && m.AlarmAction == alarm.AlarmActionClear { |
| return a.ProcessClearAlarm(m, alarmDef, idx) |
| } |
| |
| // New alarm -> update active alarms and post to Alert Manager |
| if m.AlarmAction == alarm.AlarmActionRaise { |
| return a.ProcessRaiseAlarm(m, alarmDef) |
| } |
| |
| a.mutex.Unlock() |
| return nil, nil |
| } |
| |
| func (a *AlarmManager) ProcessRaiseAlarm(m *AlarmNotification, alarmDef *alarm.AlarmDefinition) (*alert.PostAlertsOK, error) { |
| app.Logger.Debug("Raise alarmDef.RaiseDelay = %v, AlarmNotification = %v", alarmDef.RaiseDelay, *m) |
| |
| // RaiseDelay > 0 in an alarm object in active alarm table indicates that raise delay is still ongoing for the alarm |
| m.AlarmDefinition.RaiseDelay = alarmDef.RaiseDelay |
| a.UpdateAlarmFields(a.GenerateAlarmId(), m) |
| a.UpdateActiveAlarmList(m) |
| a.mutex.Unlock() |
| |
| if alarmDef.RaiseDelay > 0 { |
| timerDelay(alarmDef.RaiseDelay) |
| a.mutex.Lock() |
| // Alarm may have been deleted from active alarms table during delay or table index may have changed |
| idx, found := a.IsMatchFound(m.Alarm) |
| if found { |
| // Alarm is not showed in active alarms or alarm history via CLI before RaiseDelay has elapsed, i.e the value is 0 |
| a.activeAlarms[idx].AlarmDefinition.RaiseDelay = 0 |
| app.Logger.Debug("Raise after delay alarmDef.RaiseDelay = %v, AlarmNotification = %v", alarmDef.RaiseDelay, *m) |
| a.mutex.Unlock() |
| } else { |
| app.Logger.Debug("Alarm deleted during raise delay. AlarmNotification = %v", *m) |
| a.mutex.Unlock() |
| return nil, nil |
| } |
| } |
| |
| m.AlarmDefinition.RaiseDelay = 0 |
| a.UpdateAlarmHistoryList(m) |
| a.WriteAlarmInfoToPersistentVolume() |
| |
| // Send alarm notification to NOMA, if enabled |
| if app.Config.GetBool("controls.noma.enabled") { |
| return a.PostAlarm(m) |
| } |
| return a.PostAlert(a.GenerateAlertLabels(m.AlarmId, m.Alarm, AlertStatusActive, m.AlarmTime)) |
| } |
| |
| func (a *AlarmManager) ProcessClearAlarm(m *AlarmNotification, alarmDef *alarm.AlarmDefinition, idx int) (*alert.PostAlertsOK, error) { |
| app.Logger.Debug("Clear alarmDef.ClearDelay = %v, AlarmNotification = %v", alarmDef.ClearDelay, *m) |
| if alarmDef.ClearDelay > 0 { |
| a.mutex.Unlock() |
| timerDelay(alarmDef.ClearDelay) |
| app.Logger.Debug("Clear after delay alarmDef.ClearDelay = %v, AlarmNotification = %v", alarmDef.ClearDelay, *m) |
| a.mutex.Lock() |
| // Another alarm clear may have happened during delay and active alarms table index changed |
| var found bool |
| idx, found = a.IsMatchFound(m.Alarm) |
| if !found { |
| a.mutex.Unlock() |
| return nil, nil |
| } |
| } |
| a.UpdateAlarmFields(a.activeAlarms[idx].AlarmId, m) |
| a.alarmHistory = append(a.alarmHistory, *m) |
| a.activeAlarms = a.RemoveAlarm(a.activeAlarms, idx, "active") |
| if (len(a.alarmHistory) >= a.maxAlarmHistory) && (a.exceededAlarmHistoryOn == false) { |
| app.Logger.Warn("alarm history count exceeded maxAlarmHistory threshold") |
| a.GenerateThresholdAlarm(alarm.ALARM_HISTORY_EXCEED_MAX_THRESHOLD, "history") |
| } |
| |
| if a.exceededActiveAlarmOn && m.Alarm.SpecificProblem == alarm.ACTIVE_ALARM_EXCEED_MAX_THRESHOLD { |
| a.exceededActiveAlarmOn = false |
| } |
| |
| if a.exceededAlarmHistoryOn && m.Alarm.SpecificProblem == alarm.ALARM_HISTORY_EXCEED_MAX_THRESHOLD { |
| a.exceededAlarmHistoryOn = false |
| } |
| a.WriteAlarmInfoToPersistentVolume() |
| |
| a.mutex.Unlock() |
| if a.postClear && app.Config.GetBool("controls.noma.enabled") { |
| m.PerceivedSeverity = alarm.SeverityCleared |
| return a.PostAlarm(m) |
| } |
| return nil, nil |
| } |
| |
| func timerDelay(delay int) { |
| timer := time.NewTimer(time.Duration(delay) * time.Second) |
| <-timer.C |
| } |
| |
| func (a *AlarmManager) IsMatchFound(newAlarm alarm.Alarm) (int, bool) { |
| for i, m := range a.activeAlarms { |
| if m.ManagedObjectId == newAlarm.ManagedObjectId && m.ApplicationId == newAlarm.ApplicationId && |
| m.SpecificProblem == newAlarm.SpecificProblem && m.IdentifyingInfo == newAlarm.IdentifyingInfo { |
| return i, true |
| } |
| } |
| return -1, false |
| } |
| |
| func (a *AlarmManager) RemoveAlarm(alarms []AlarmNotification, i int, listName string) []AlarmNotification { |
| app.Logger.Info("Alarm '%+v' deleted from the '%s' list", alarms[i], listName) |
| copy(alarms[i:], alarms[i+1:]) |
| return alarms[:len(alarms)-1] |
| } |
| |
| func (a *AlarmManager) GenerateAlarmId() int { |
| a.uniqueAlarmId++ // @todo: generate a unique ID |
| return a.uniqueAlarmId |
| } |
| |
| func (a *AlarmManager) UpdateAlarmFields(alarmId int, newAlarm *AlarmNotification) { |
| alarmDef := alarm.RICAlarmDefinitions[newAlarm.SpecificProblem] |
| newAlarm.AlarmId = alarmId |
| newAlarm.AlarmText = alarmDef.AlarmText |
| newAlarm.EventType = alarmDef.EventType |
| } |
| |
| func (a *AlarmManager) GenerateThresholdAlarm(sp int, data string) bool { |
| thresholdAlarm := a.alarmClient.NewAlarm(sp, alarm.SeverityWarning, "threshold", data) |
| thresholdMessage := alarm.AlarmMessage{ |
| Alarm: thresholdAlarm, |
| AlarmAction: alarm.AlarmActionRaise, |
| AlarmTime: time.Now().UnixNano(), |
| } |
| alarmDef := alarm.RICAlarmDefinitions[sp] |
| alarmId := a.GenerateAlarmId() |
| alarmDef.AlarmId = alarmId |
| a.activeAlarms = append(a.activeAlarms, AlarmNotification{thresholdMessage, *alarmDef}) |
| a.alarmHistory = append(a.alarmHistory, AlarmNotification{thresholdMessage, *alarmDef}) |
| |
| return true |
| } |
| |
| func (a *AlarmManager) UpdateActiveAlarmList(newAlarm *AlarmNotification) { |
| /* If maximum number of active alarms is reached, an error log writing is made, and new alarm indicating the problem is raised. |
| The attempt to raise the alarm next time will be suppressed when found as duplicate. */ |
| if (len(a.activeAlarms) >= a.maxActiveAlarms) && (a.exceededActiveAlarmOn == false) { |
| app.Logger.Warn("active alarm count exceeded maxActiveAlarms threshold") |
| a.exceededActiveAlarmOn = a.GenerateThresholdAlarm(alarm.ACTIVE_ALARM_EXCEED_MAX_THRESHOLD, "active") |
| } |
| |
| // @todo: For now just keep the active alarms in-memory. Use SDL later for persistence |
| a.activeAlarms = append(a.activeAlarms, *newAlarm) |
| } |
| |
| func (a *AlarmManager) UpdateAlarmHistoryList(newAlarm *AlarmNotification) { |
| /* If maximum number of events in alarm history is reached, an error log writing is made, |
| and new alarm indicating the problem is raised. The attempt to add new event time will |
| be suppressed */ |
| |
| if (len(a.alarmHistory) >= a.maxAlarmHistory) && (a.exceededAlarmHistoryOn == false) { |
| app.Logger.Warn("alarm history count exceeded maxAlarmHistory threshold") |
| a.exceededAlarmHistoryOn = a.GenerateThresholdAlarm(alarm.ALARM_HISTORY_EXCEED_MAX_THRESHOLD, "history") |
| } |
| |
| // @todo: For now just keep the alarms history in-memory. Use SDL later for persistence |
| a.alarmHistory = append(a.alarmHistory, *newAlarm) |
| } |
| |
| func (a *AlarmManager) PostAlarm(m *AlarmNotification) (*alert.PostAlertsOK, error) { |
| result, err := json.Marshal(m) |
| if err != nil { |
| app.Logger.Info("json.Marshal failed: %v", err) |
| return nil, err |
| } |
| |
| fullUrl := fmt.Sprintf("%s/%s", app.Config.GetString("controls.noma.host"), app.Config.GetString("controls.noma.alarmUrl")) |
| app.Logger.Info("Posting alarm to '%s'", fullUrl) |
| |
| resp, err := http.Post(fullUrl, "application/json", bytes.NewReader(result)) |
| if err != nil || resp == nil { |
| app.Logger.Info("Unable to post alarm to '%s': %v", fullUrl, err) |
| } |
| |
| return nil, err |
| } |
| |
| func (a *AlarmManager) GenerateAlertLabels(alarmId int, newAlarm alarm.Alarm, status AlertStatus, alarmTime int64) (models.LabelSet, models.LabelSet) { |
| alarmDef := alarm.RICAlarmDefinitions[newAlarm.SpecificProblem] |
| amLabels := models.LabelSet{ |
| "status": string(status), |
| "alertname": alarmDef.AlarmText, |
| "severity": string(newAlarm.PerceivedSeverity), |
| "service": fmt.Sprintf("%s/%s", newAlarm.ManagedObjectId, newAlarm.ApplicationId), |
| "system_name": "RIC", |
| } |
| amAnnotations := models.LabelSet{ |
| "alarm_id": fmt.Sprintf("%d", alarmId), |
| "specific_problem": fmt.Sprintf("%d", newAlarm.SpecificProblem), |
| "event_type": alarmDef.EventType, |
| "identifying_info": newAlarm.IdentifyingInfo, |
| "additional_info": newAlarm.AdditionalInfo, |
| "description": fmt.Sprintf("%s:%s", newAlarm.IdentifyingInfo, newAlarm.AdditionalInfo), |
| "instructions": alarmDef.OperationInstructions, |
| "timestamp": fmt.Sprintf("%s", time.Unix(0, alarmTime).Format("02/01/2006, 15:04:05")), |
| } |
| |
| return amLabels, amAnnotations |
| } |
| |
| func (a *AlarmManager) NewAlertmanagerClient() *client.Alertmanager { |
| cr := clientruntime.New(a.amHost, a.amBaseUrl, a.amSchemes) |
| return client.New(cr, strfmt.Default) |
| } |
| |
| func (a *AlarmManager) PostAlert(amLabels, amAnnotations models.LabelSet) (*alert.PostAlertsOK, error) { |
| pa := &models.PostableAlert{ |
| Alert: models.Alert{ |
| GeneratorURL: strfmt.URI(""), |
| Labels: amLabels, |
| }, |
| Annotations: amAnnotations, |
| } |
| alertParams := alert.NewPostAlertsParams().WithAlerts(models.PostableAlerts{pa}) |
| |
| app.Logger.Info("Posting alerts: labels: %+v, annotations: %+v", amLabels, amAnnotations) |
| ok, err := a.NewAlertmanagerClient().Alert.PostAlerts(alertParams) |
| if err != nil { |
| app.Logger.Error("Posting alerts to '%s/%s' failed with error: %v", a.amHost, a.amBaseUrl, err) |
| } |
| return ok, err |
| } |
| |
| func (a *AlarmManager) StatusCB() bool { |
| if !a.rmrReady { |
| app.Logger.Info("RMR not ready yet!") |
| } |
| |
| return a.rmrReady |
| } |
| |
| func (a *AlarmManager) ConfigChangeCB(configparam string) { |
| |
| a.maxActiveAlarms = app.Config.GetInt("controls.maxActiveAlarms") |
| if a.maxActiveAlarms == 0 { |
| a.maxActiveAlarms = 5000 |
| } |
| |
| a.maxAlarmHistory = app.Config.GetInt("controls.maxAlarmHistory") |
| if a.maxAlarmHistory == 0 { |
| a.maxAlarmHistory = 20000 |
| } |
| |
| a.alertInterval = viper.GetInt("controls.promAlertManager.alertInterval") |
| a.amHost = viper.GetString("controls.promAlertManager.address") |
| |
| app.Logger.Debug("ConfigChangeCB: maxActiveAlarms %v", a.maxActiveAlarms) |
| app.Logger.Debug("ConfigChangeCB: maxAlarmHistory = %v", a.maxAlarmHistory) |
| app.Logger.Debug("ConfigChangeCB: alertInterval %v", a.alertInterval) |
| app.Logger.Debug("ConfigChangeCB: amHost = %v", a.amHost) |
| |
| return |
| } |
| |
| func (a *AlarmManager) ReadAlarmDefinitionFromJson() { |
| |
| filename := os.Getenv("DEF_FILE") |
| file, err := ioutil.ReadFile(filename) |
| if err == nil { |
| data := RicAlarmDefinitions{} |
| err = json.Unmarshal([]byte(file), &data) |
| if err == nil { |
| for _, alarmDefinition := range data.AlarmDefinitions { |
| _, exists := alarm.RICAlarmDefinitions[alarmDefinition.AlarmId] |
| if exists { |
| app.Logger.Error("ReadAlarmDefinitionFromJson: alarm definition already exists for %v", alarmDefinition.AlarmId) |
| } else { |
| app.Logger.Debug("ReadAlarmDefinitionFromJson: alarm %v", alarmDefinition.AlarmId) |
| ricAlarmDefintion := new(alarm.AlarmDefinition) |
| ricAlarmDefintion.AlarmId = alarmDefinition.AlarmId |
| ricAlarmDefintion.AlarmText = alarmDefinition.AlarmText |
| ricAlarmDefintion.EventType = alarmDefinition.EventType |
| ricAlarmDefintion.OperationInstructions = alarmDefinition.OperationInstructions |
| ricAlarmDefintion.RaiseDelay = alarmDefinition.RaiseDelay |
| ricAlarmDefintion.ClearDelay = alarmDefinition.ClearDelay |
| ricAlarmDefintion.TimeToLive = alarmDefinition.TimeToLive |
| alarm.RICAlarmDefinitions[alarmDefinition.AlarmId] = ricAlarmDefintion |
| } |
| } |
| } else { |
| app.Logger.Error("ReadAlarmDefinitionFromJson: json.Unmarshal failed with error %v", err) |
| } |
| } else { |
| app.Logger.Error("ReadAlarmDefinitionFromJson: ioutil.ReadFile failed with error %v", err) |
| } |
| } |
| |
| func (a *AlarmManager) ReadAlarmInfoFromPersistentVolume() { |
| var alarmpersistentinfo AlarmPersistentInfo |
| byteValue, rerr := ioutil.ReadFile(a.alarmInfoPvFile) |
| if rerr != nil { |
| app.Logger.Error("ararminfo.json file read error %v", rerr) |
| } else { |
| err := json.Unmarshal(byteValue, &alarmpersistentinfo) |
| if err != nil { |
| app.Logger.Error("alarmpersistentinfo json unmarshal error %v", err) |
| } else { |
| a.uniqueAlarmId = alarmpersistentinfo.UniqueAlarmId |
| a.activeAlarms = make([]AlarmNotification, len(alarmpersistentinfo.ActiveAlarms)) |
| a.alarmHistory = make([]AlarmNotification, len(alarmpersistentinfo.AlarmHistory)) |
| copy(a.activeAlarms, alarmpersistentinfo.ActiveAlarms) |
| copy(a.alarmHistory, alarmpersistentinfo.AlarmHistory) |
| } |
| } |
| } |
| |
| func (a *AlarmManager) WriteAlarmInfoToPersistentVolume() { |
| var alarmpersistentinfo AlarmPersistentInfo |
| alarmpersistentinfo.UniqueAlarmId = a.uniqueAlarmId |
| alarmpersistentinfo.ActiveAlarms = make([]AlarmNotification, len(a.activeAlarms)) |
| alarmpersistentinfo.AlarmHistory = make([]AlarmNotification, len(a.alarmHistory)) |
| |
| copy(alarmpersistentinfo.ActiveAlarms, a.activeAlarms) |
| copy(alarmpersistentinfo.AlarmHistory, a.alarmHistory) |
| |
| wdata, err := json.MarshalIndent(alarmpersistentinfo, "", " ") |
| if err != nil { |
| app.Logger.Error("alarmpersistentinfo json marshal error %v", err) |
| } else { |
| werr := ioutil.WriteFile(a.alarmInfoPvFile, wdata, 0777) |
| if werr != nil { |
| app.Logger.Error("alarminfo.json file write error %v", werr) |
| } |
| } |
| } |
| |
| func (a *AlarmManager) Run(sdlcheck bool, ttlInterval int) { |
| app.Logger.SetMdc("alarmManager", fmt.Sprintf("%s:%s", Version, Hash)) |
| app.SetReadyCB(func(d interface{}) { a.rmrReady = true }, true) |
| app.Resource.InjectStatusCb(a.StatusCB) |
| app.AddConfigChangeListener(a.ConfigChangeCB) |
| |
| alarm.RICAlarmDefinitions = make(map[int]*alarm.AlarmDefinition) |
| a.ReadAlarmDefinitionFromJson() |
| |
| a.InjectRoutes() |
| |
| // Start background timer for re-raising alerts |
| go a.StartAlertTimer() |
| go a.StartTTLTimer(ttlInterval) |
| |
| a.alarmClient, _ = alarm.InitAlarm("SEP", "ALARMMANAGER") |
| |
| a.ReadAlarmInfoFromPersistentVolume() |
| |
| app.RunWithParams(a, sdlcheck) |
| } |
| |
| func NewAlarmManager(amHost string, alertInterval int, clearAlarm bool) *AlarmManager { |
| if alertInterval == 0 { |
| alertInterval = viper.GetInt("controls.promAlertManager.alertInterval") |
| } |
| |
| if amHost == "" { |
| amHost = viper.GetString("controls.promAlertManager.address") |
| } |
| |
| maxActiveAlarms := app.Config.GetInt("controls.maxActiveAlarms") |
| if maxActiveAlarms == 0 { |
| maxActiveAlarms = 5000 |
| } |
| |
| maxAlarmHistory := app.Config.GetInt("controls.maxAlarmHistory") |
| if maxAlarmHistory == 0 { |
| maxAlarmHistory = 20000 |
| } |
| |
| return &AlarmManager{ |
| rmrReady: false, |
| postClear: clearAlarm, |
| amHost: amHost, |
| amBaseUrl: app.Config.GetString("controls.promAlertManager.baseUrl"), |
| amSchemes: []string{app.Config.GetString("controls.promAlertManager.schemes")}, |
| alertInterval: alertInterval, |
| activeAlarms: make([]AlarmNotification, 0), |
| alarmHistory: make([]AlarmNotification, 0), |
| uniqueAlarmId: 0, |
| maxActiveAlarms: maxActiveAlarms, |
| maxAlarmHistory: maxAlarmHistory, |
| exceededActiveAlarmOn: false, |
| exceededAlarmHistoryOn: false, |
| alarmInfoPvFile: app.Config.GetString("controls.alarmInfoPvFile"), |
| } |
| } |
| |
| // Main function |
| func main() { |
| NewAlarmManager("", 0, true).Run(true, 10) |
| } |