blob: 336592c14578e7d7c3fb36d012eca50a3bc57515 [file] [log] [blame]
Devmalya Paulfb990a52019-07-09 10:01:49 -04001/*
2 * Copyright 2018-present Open Networking Foundation
3
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7
8 * http://www.apache.org/licenses/LICENSE-2.0
9
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Scott Bakerdbd960e2020-02-28 08:57:51 -080017// Package core provides APIs for the openOLT adapter
18package core
Devmalya Paulfb990a52019-07-09 10:01:49 -040019
20import (
Neha Sharma96b7bf22020-06-15 10:37:32 +000021 "context"
Devmalya Paula1efa642020-04-20 01:36:43 -040022 "errors"
Devmalya Paulfb990a52019-07-09 10:01:49 -040023 "fmt"
Naga Manjunath9546b912019-11-28 20:56:20 +053024 "strconv"
Naga Manjunatha8dc9372019-10-31 23:01:18 +053025
Himani Chawlacd407802020-12-10 12:08:59 +053026 "github.com/opencord/voltha-lib-go/v4/pkg/events/eventif"
Girish Gowdraa09aeab2020-09-14 16:30:52 -070027 "github.com/opencord/voltha-lib-go/v4/pkg/log"
Thomas Lee S94109f12020-03-03 16:39:29 +053028 "github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
Girish Gowdraa09aeab2020-09-14 16:30:52 -070029 "github.com/opencord/voltha-protos/v4/go/common"
30 oop "github.com/opencord/voltha-protos/v4/go/openolt"
31 "github.com/opencord/voltha-protos/v4/go/voltha"
Devmalya Paulfb990a52019-07-09 10:01:49 -040032)
33
34const (
Devmalya Paul41a762d2020-03-01 18:56:54 -050035 onuDiscoveryEvent = "ONU_DISCOVERY"
36 onuLosEvent = "ONU_LOSS_OF_SIGNAL"
37 onuLobEvent = "ONU_LOSS_OF_BURST"
38 onuLopcMissEvent = "ONU_LOPC_MISS"
39 onuLopcMicErrorEvent = "ONU_LOPC_MIC_ERROR"
40 oltLosEvent = "OLT_LOSS_OF_SIGNAL"
Gamze Abaka07868a52020-12-17 14:19:28 +000041 oltCommFailure = "OLT_COMMUNICATION_FAILURE"
Devmalya Paul41a762d2020-03-01 18:56:54 -050042 oltIndicationDown = "OLT_DOWN_INDICATION"
43 onuDyingGaspEvent = "ONU_DYING_GASP"
44 onuSignalsFailEvent = "ONU_SIGNALS_FAIL"
45 onuStartupFailEvent = "ONU_STARTUP_FAIL"
46 onuSignalDegradeEvent = "ONU_SIGNAL_DEGRADE"
47 onuDriftOfWindowEvent = "ONU_DRIFT_OF_WINDOW"
48 onuActivationFailEvent = "ONU_ACTIVATION_FAIL"
Devmalya Paul41a762d2020-03-01 18:56:54 -050049 onuLossOmciEvent = "ONU_LOSS_OF_OMCI_CHANNEL"
50 onuLossOfKeySyncEvent = "ONU_LOSS_OF_KEY_SYNC"
51 onuLossOfFrameEvent = "ONU_LOSS_OF_FRAME"
52 onuLossOfPloamEvent = "ONU_LOSS_OF_PLOAM"
53 ponIntfDownIndiction = "OLT_PON_INTERFACE_DOWN"
54 onuDeactivationFailureEvent = "ONU_DEACTIVATION_FAILURE"
55 onuRemoteDefectIndication = "ONU_REMOTE_DEFECT"
56 onuLossOfGEMChannelDelineationEvent = "ONU_LOSS_OF_GEM_CHANNEL_DELINEATION"
57 onuPhysicalEquipmentErrorEvent = "ONU_PHYSICAL_EQUIPMENT_ERROR"
58 onuLossOfAcknowledgementEvent = "ONU_LOSS_OF_ACKNOWLEDGEMENT"
Devmalya Pauleb5294e2020-03-19 03:01:39 -040059 onuDifferentialReachExceededEvent = "ONU_DIFFERENTIAL_REACH_EXCEEDED"
Devmalya Paulfb990a52019-07-09 10:01:49 -040060)
61
62const (
Naga Manjunath9546b912019-11-28 20:56:20 +053063 // statusCheckOn represents status check On
64 statusCheckOn = "on"
65 // statusCheckOff represents status check Off
66 statusCheckOff = "off"
67 // operationStateUp represents operation state Up
68 operationStateUp = "up"
69 // operationStateDown represents operation state Down
70 operationStateDown = "down"
71 // base10 represents base 10 conversion
72 base10 = 10
73)
74
Amit Ghosh502056b2020-07-15 09:15:48 +010075const (
Gamze Abaka07868a52020-12-17 14:19:28 +000076 // ContextOltAdminState is for the admin state of the Olt in the context of the event
77 ContextOltAdminState = "admin-state"
78 // ContextOltConnectState is for the connect state of the Olt in the context of the event
79 ContextOltConnectState = "connect-state"
Amit Ghosh502056b2020-07-15 09:15:48 +010080 // ContextOltOperState is for the operational state of the Olt in the context of the event
81 ContextOltOperState = "oper-state"
Gamze Abaka07868a52020-12-17 14:19:28 +000082 // ContextOltVendor is for the Olt vendor in the context of the event
83 ContextOltVendor = "vendor"
84 // ContextOltType is for the Olt type in the context of the event
85 ContextOltType = "type"
86 // ContextOltParentID is for the Olt parent id in the context of the event
87 ContextOltParentID = "parent-id"
88 // ContextOltParentPortNo is for the Olt parent port no in the context of the event
89 ContextOltParentPortNo = "parent-port-no"
90 // ContextOltFirmwareVersion is for the Olt firmware version in the context of the event
91 ContextOltFirmwareVersion = "firmware-version"
92 // ContextOltHardwareVersion is for the Olt hardware version in the context of the event
93 ContextOltHardwareVersion = "hardware-version"
94 // ContextOltSerialNumber is for the serial number of the OLT
95 ContextOltSerialNumber = "serial-number"
96 // ContextOltMacAddress is for the OLT mac address
97 ContextOltMacAddress = "mac-address"
98 // ContextDeviceID is for the device id in the context of the event
99 ContextDeviceID = "id"
Amit Ghosh502056b2020-07-15 09:15:48 +0100100 // ContextOnuOnuID is for the Onu Id in the context of the event
101 ContextOnuOnuID = "onu-id"
102 // ContextOnuPonIntfID is for the PON interface Id on which the Onu Event occurred
103 ContextOnuPonIntfID = "intf-id"
104 // ContextOnuSerialNumber is for the serial number of the ONU
105 ContextOnuSerialNumber = "serial-number"
106 // ContextOnuDeviceID is for the device id of the ONU generated by VOLTHA
107 ContextOnuDeviceID = "onu-device-id"
108 // ContextOltPonIntfID is for the PON interface Id on an OLT event
109 ContextOltPonIntfID = "intf-id"
110 // ContextOnuFailureReaseon is for the reason of failure of/at ONU indicated by the event
111 ContextOnuFailureReaseon = "fail-reason"
112 // ContextOnuDrift is for the drift of an ONU in the context of an event
113 ContextOnuDrift = "drift"
114 // ContextOnuNewEqd is for the New Eqd of an ONU in the context of an event
115 ContextOnuNewEqd = "new-eqd"
116 // ContextOnuInverseBitErrorRate is for the inverse bit error rate in the context of an ONU event
117 ContextOnuInverseBitErrorRate = "inverse-bit-error-rate"
118 // ContextOltPonIntfOperState is for the operational state of a PON port in the context of an OLT event
119 ContextOltPonIntfOperState = "oper-state"
120 // ContextOnuRemoteDefectIndicatorCount is for the rdi in the context of an ONU event
121 ContextOnuRemoteDefectIndicatorCount = "rdi-count"
122 // ContextOnuDelineationErrors is for the delineation errors if present in an ONU events context
123 ContextOnuDelineationErrors = "delineation-errors"
124 // ContextOnuDifferentialDistance is for the differential distance in an ONU event context
125 ContextOnuDifferentialDistance = "differential-distance"
126)
127
Devmalya Paulfb990a52019-07-09 10:01:49 -0400128// OpenOltEventMgr struct contains
129type OpenOltEventMgr struct {
Himani Chawlacd407802020-12-10 12:08:59 +0530130 eventProxy eventif.EventProxy
Devmalya Paul90ca3012019-09-02 21:55:45 -0400131 handler *DeviceHandler
Devmalya Paulfb990a52019-07-09 10:01:49 -0400132}
133
134// NewEventMgr is a Function to get a new event manager struct for the OpenOLT to process and publish OpenOLT event
Himani Chawlacd407802020-12-10 12:08:59 +0530135func NewEventMgr(eventProxy eventif.EventProxy, handler *DeviceHandler) *OpenOltEventMgr {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400136 var em OpenOltEventMgr
137 em.eventProxy = eventProxy
Devmalya Paul90ca3012019-09-02 21:55:45 -0400138 em.handler = handler
Devmalya Paulfb990a52019-07-09 10:01:49 -0400139 return &em
140}
141
142// ProcessEvents is function to process and publish OpenOLT event
Devmalya Paul41a762d2020-03-01 18:56:54 -0500143// nolint: gocyclo
Kent Hagermane6ff1012020-07-14 15:07:53 -0400144func (em *OpenOltEventMgr) ProcessEvents(ctx context.Context, alarmInd *oop.AlarmIndication, deviceID string, raisedTs int64) {
Naga Manjunath9546b912019-11-28 20:56:20 +0530145 var err error
Devmalya Paulfb990a52019-07-09 10:01:49 -0400146 switch alarmInd.Data.(type) {
147 case *oop.AlarmIndication_LosInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000148 logger.Debugw(ctx, "received-los-indication", log.Fields{"alarm-ind": alarmInd})
149 err = em.oltLosIndication(ctx, alarmInd.GetLosInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400150 case *oop.AlarmIndication_OnuAlarmInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000151 logger.Debugw(ctx, "received-onu-alarm-indication ", log.Fields{"alarm-ind": alarmInd})
152 err = em.onuAlarmIndication(ctx, alarmInd.GetOnuAlarmInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400153 case *oop.AlarmIndication_DyingGaspInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000154 logger.Debugw(ctx, "received-dying-gasp-indication", log.Fields{"alarm-ind": alarmInd})
155 err = em.onuDyingGaspIndication(ctx, alarmInd.GetDyingGaspInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400156 case *oop.AlarmIndication_OnuLossOmciInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000157 logger.Debugw(ctx, "received-onu-loss-omci-indication ", log.Fields{"alarm-ind": alarmInd})
158 err = em.onuLossOmciIndication(ctx, alarmInd.GetOnuLossOmciInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400159 case *oop.AlarmIndication_OnuDriftOfWindowInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000160 logger.Debugw(ctx, "received-onu-drift-of-window-indication ", log.Fields{"alarm-ind": alarmInd})
161 err = em.onuDriftOfWindowIndication(ctx, alarmInd.GetOnuDriftOfWindowInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400162 case *oop.AlarmIndication_OnuSignalDegradeInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000163 logger.Debugw(ctx, "received-onu-signal-degrade-indication ", log.Fields{"alarm-ind": alarmInd})
164 err = em.onuSignalDegradeIndication(ctx, alarmInd.GetOnuSignalDegradeInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400165 case *oop.AlarmIndication_OnuSignalsFailInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000166 logger.Debugw(ctx, "received-onu-signal-fail-indication ", log.Fields{"alarm-ind": alarmInd})
167 err = em.onuSignalsFailIndication(ctx, alarmInd.GetOnuSignalsFailInd(), deviceID, raisedTs)
Naga Manjunathf6f74642020-01-13 21:37:28 +0530168 case *oop.AlarmIndication_OnuStartupFailInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000169 logger.Debugw(ctx, "received-onu-startup-fail-indication ", log.Fields{"alarm-ind": alarmInd})
170 err = em.onuStartupFailedIndication(ctx, alarmInd.GetOnuStartupFailInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400171 case *oop.AlarmIndication_OnuTiwiInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000172 logger.Debugw(ctx, "received-onu-transmission-warning-indication ", log.Fields{"alarm-ind": alarmInd})
173 logger.Warnw(ctx, "not-implemented-yet", log.Fields{"alarm-ind": "Onu-Transmission-indication"})
Naga Manjunath9546b912019-11-28 20:56:20 +0530174 case *oop.AlarmIndication_OnuLossOfSyncFailInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000175 logger.Debugw(ctx, "received-onu-loss-of-sync-fail-indication ", log.Fields{"alarm-ind": alarmInd})
176 err = em.onuLossOfSyncIndication(ctx, alarmInd.GetOnuLossOfSyncFailInd(), deviceID, raisedTs)
Naga Manjunath9546b912019-11-28 20:56:20 +0530177 case *oop.AlarmIndication_OnuItuPonStatsInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000178 logger.Debugw(ctx, "received-onu-itu-pon-stats-indication ", log.Fields{"alarm-ind": alarmInd})
179 err = em.onuItuPonStatsIndication(ctx, alarmInd.GetOnuItuPonStatsInd(), deviceID, raisedTs)
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500180 case *oop.AlarmIndication_OnuDeactivationFailureInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000181 logger.Debugw(ctx, "received-onu-deactivation-failure-indication ", log.Fields{"alarm-ind": alarmInd})
182 err = em.onuDeactivationFailureIndication(ctx, alarmInd.GetOnuDeactivationFailureInd(), deviceID, raisedTs)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500183 case *oop.AlarmIndication_OnuLossGemDelineationInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000184 logger.Debugw(ctx, "received-onu-loss-of-gem-channel-delineation-indication ", log.Fields{"alarm-ind": alarmInd})
185 err = em.onuLossOfGEMChannelDelineationIndication(ctx, alarmInd.GetOnuLossGemDelineationInd(), deviceID, raisedTs)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500186 case *oop.AlarmIndication_OnuPhysicalEquipmentErrorInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000187 logger.Debugw(ctx, "received-onu-physical-equipment-error-indication ", log.Fields{"alarm-ind": alarmInd})
188 err = em.onuPhysicalEquipmentErrorIndication(ctx, alarmInd.GetOnuPhysicalEquipmentErrorInd(), deviceID, raisedTs)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500189 case *oop.AlarmIndication_OnuLossOfAckInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000190 logger.Debugw(ctx, "received-onu-loss-of-acknowledgement-indication ", log.Fields{"alarm-ind": alarmInd})
191 err = em.onuLossOfAcknowledgementIndication(ctx, alarmInd.GetOnuLossOfAckInd(), deviceID, raisedTs)
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400192 case *oop.AlarmIndication_OnuDiffReachExceededInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000193 logger.Debugw(ctx, "received-onu-differential-reach-exceeded-indication ", log.Fields{"alarm-ind": alarmInd})
194 err = em.onuDifferentialReachExceededIndication(ctx, alarmInd.GetOnuDiffReachExceededInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400195 default:
Thomas Lee S94109f12020-03-03 16:39:29 +0530196 err = olterrors.NewErrInvalidValue(log.Fields{"indication-type": alarmInd}, nil)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400197 }
Naga Manjunath9546b912019-11-28 20:56:20 +0530198 if err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400199 _ = olterrors.NewErrCommunication("publish-message", log.Fields{"indication-type": alarmInd}, err).LogAt(log.WarnLevel)
Naga Manjunath9546b912019-11-28 20:56:20 +0530200 }
Devmalya Paulfb990a52019-07-09 10:01:49 -0400201}
202
Gamze Abaka07868a52020-12-17 14:19:28 +0000203func (em *OpenOltEventMgr) oltCommunicationEvent(ctx context.Context, device *voltha.Device, raisedTs int64) {
204 if device == nil {
205 logger.Warn(ctx, "device-is-nil-can't-send-olt-communication-failure-event")
206 return
207 }
208 var de voltha.DeviceEvent
209 context := make(map[string]string)
210 context[ContextOltOperState] = device.OperStatus.String()
211 context[ContextOltAdminState] = device.AdminState.String()
212 context[ContextOltVendor] = device.Vendor
213 context[ContextOltConnectState] = device.ConnectStatus.String()
214 context[ContextOltType] = device.Type
215 context[ContextOltParentID] = device.ParentId
216 context[ContextOltParentPortNo] = fmt.Sprintf("%d", device.ParentPortNo)
217 context[ContextDeviceID] = device.Id
218 context[ContextOltFirmwareVersion] = device.FirmwareVersion
219 context[ContextOltHardwareVersion] = device.HardwareVersion
220 context[ContextOltSerialNumber] = device.SerialNumber
221 context[ContextOltMacAddress] = device.MacAddress
222 de.Context = context
223 de.ResourceId = device.Id
224
225 if device.ConnectStatus == voltha.ConnectStatus_UNREACHABLE {
226 de.DeviceEventName = fmt.Sprintf("%s_%s", oltCommFailure, "RAISE_EVENT")
227 } else {
228 de.DeviceEventName = fmt.Sprintf("%s_%s", oltCommFailure, "CLEAR_EVENT")
229 }
230
231 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
232 logger.Errorw(ctx, "failed-to-send-olt-comm-failure-event", log.Fields{"err": err})
233 }
234 logger.Debugw(ctx, "olt-comm-failure-event-sent-to-kafka",
235 log.Fields{
236 "device-id": device.Id,
237 "connect-status": device.ConnectStatus,
238 })
239}
240
Daniele Rossi051466a2019-07-26 13:39:37 +0000241// oltUpDownIndication handles Up and Down state of an OLT
Neha Sharma96b7bf22020-06-15 10:37:32 +0000242func (em *OpenOltEventMgr) oltUpDownIndication(ctx context.Context, oltIndication *oop.OltIndication, deviceID string, raisedTs int64) error {
Daniele Rossi051466a2019-07-26 13:39:37 +0000243 var de voltha.DeviceEvent
244 context := make(map[string]string)
245 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100246 context[ContextOltOperState] = oltIndication.OperState
Daniele Rossi051466a2019-07-26 13:39:37 +0000247 /* Populating device event body */
248 de.Context = context
249 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530250 if oltIndication.OperState == operationStateDown {
Daniele Rossi051466a2019-07-26 13:39:37 +0000251 de.DeviceEventName = fmt.Sprintf("%s_%s", oltIndicationDown, "RAISE_EVENT")
Naga Manjunath9546b912019-11-28 20:56:20 +0530252 } else if oltIndication.OperState == operationStateUp {
Daniele Rossi051466a2019-07-26 13:39:37 +0000253 de.DeviceEventName = fmt.Sprintf("%s_%s", oltIndicationDown, "CLEAR_EVENT")
254 }
255 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400256 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000257 return olterrors.NewErrCommunication("send-olt-event", log.Fields{"device-id": deviceID}, err)
Daniele Rossi051466a2019-07-26 13:39:37 +0000258 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000259 logger.Debugw(ctx, "olt-updown-event-sent-to-kafka", log.Fields{})
Naga Manjunath9546b912019-11-28 20:56:20 +0530260 return nil
Daniele Rossi051466a2019-07-26 13:39:37 +0000261}
262
Devmalya Paulfb990a52019-07-09 10:01:49 -0400263// OnuDiscoveryIndication is an exported method to handle ONU discovery event
Neha Sharma96b7bf22020-06-15 10:37:32 +0000264func (em *OpenOltEventMgr) OnuDiscoveryIndication(ctx context.Context, onuDisc *oop.OnuDiscIndication, oltDeviceID string, onuDeviceID string, OnuID uint32, serialNumber string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400265 var de voltha.DeviceEvent
266 context := make(map[string]string)
267 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100268 context[ContextOnuOnuID] = strconv.FormatUint(uint64(OnuID), base10)
269 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDisc.IntfId), base10)
270 context[ContextOnuSerialNumber] = serialNumber
271 context[ContextOnuDeviceID] = onuDeviceID
Devmalya Paulfb990a52019-07-09 10:01:49 -0400272 /* Populating device event body */
273 de.Context = context
Amit Ghosh75f0e292020-05-14 11:31:54 +0100274 de.ResourceId = oltDeviceID
Devmalya Paulfb990a52019-07-09 10:01:49 -0400275 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDiscoveryEvent, "RAISE_EVENT")
276 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400277 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_PON, raisedTs); err != nil {
Shrey Baid26912972020-04-16 21:02:31 +0530278 return olterrors.NewErrCommunication("send-onu-discovery-event",
279 log.Fields{
280 "serial-number": serialNumber,
281 "intf-id": onuDisc.IntfId}, err)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400282 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000283 logger.Debugw(ctx, "onu-discovery-event-sent-to-kafka",
Shrey Baid26912972020-04-16 21:02:31 +0530284 log.Fields{
285 "serial-number": serialNumber,
286 "intf-id": onuDisc.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530287 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400288}
289
Neha Sharma96b7bf22020-06-15 10:37:32 +0000290func (em *OpenOltEventMgr) oltLosIndication(ctx context.Context, oltLos *oop.LosIndication, deviceID string, raisedTs int64) error {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530291 var err error = nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400292 var de voltha.DeviceEvent
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530293 var alarmInd oop.OnuAlarmIndication
294 ponIntdID := PortNoToIntfID(oltLos.IntfId, voltha.Port_PON_OLT)
295
Devmalya Paulfb990a52019-07-09 10:01:49 -0400296 context := make(map[string]string)
297 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100298 context[ContextOltPonIntfID] = strconv.FormatUint(uint64(oltLos.IntfId), base10)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400299 /* Populating device event body */
300 de.Context = context
301 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530302 if oltLos.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400303 de.DeviceEventName = fmt.Sprintf("%s_%s", oltLosEvent, "RAISE_EVENT")
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530304
305 /* When PON cable disconnected from OLT, it was expected OnuAlarmIndication
306 with "los_status: on" should be raised for each Onu connected to the PON
307 but BAL does not raise this Alarm hence manually sending OnuLosRaise event
308 for all the ONU's connected to PON on receiving LoSIndication for PON */
309 em.handler.onus.Range(func(Onukey interface{}, onuInCache interface{}) bool {
310 if onuInCache.(*OnuDevice).intfID == ponIntdID {
311 alarmInd.IntfId = ponIntdID
312 alarmInd.OnuId = onuInCache.(*OnuDevice).onuID
313 alarmInd.LosStatus = statusCheckOn
Neha Sharma96b7bf22020-06-15 10:37:32 +0000314 err = em.onuAlarmIndication(ctx, &alarmInd, deviceID, raisedTs)
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530315 }
316 return true
317 })
318 if err != nil {
319 /* Return if any error encountered while processing ONU LoS Event*/
320 return err
321 }
Devmalya Paulfb990a52019-07-09 10:01:49 -0400322 } else {
323 de.DeviceEventName = fmt.Sprintf("%s_%s", oltLosEvent, "CLEAR_EVENT")
324 }
325 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100326 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530327 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400328 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000329 logger.Debugw(ctx, "olt-los-event-sent-to-kafka", log.Fields{"intf-id": oltLos.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530330 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400331}
332
Amit Ghosh502056b2020-07-15 09:15:48 +0100333func (em *OpenOltEventMgr) populateContextWithSerialDeviceID(context map[string]string, intfID, onuID uint32) {
334 var serialNumber = ""
335 var onuDeviceID = ""
336 onu := em.handler.formOnuKey(intfID, onuID)
Naga Manjunatha8dc9372019-10-31 23:01:18 +0530337 if onu, ok := em.handler.onus.Load(onu); ok {
338 serialNumber = onu.(*OnuDevice).serialNumber
Amit Ghosh502056b2020-07-15 09:15:48 +0100339 onuDeviceID = onu.(*OnuDevice).deviceID
Devmalya Paul90ca3012019-09-02 21:55:45 -0400340 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100341
342 context[ContextOnuSerialNumber] = serialNumber
343 context[ContextOnuDeviceID] = onuDeviceID
344}
345
346func (em *OpenOltEventMgr) onuDyingGaspIndication(ctx context.Context, dgi *oop.DyingGaspIndication, deviceID string, raisedTs int64) error {
347 var de voltha.DeviceEvent
348 context := make(map[string]string)
349 /* Populating event context */
350 em.populateContextWithSerialDeviceID(context, dgi.IntfId, dgi.OnuId)
351
352 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(dgi.IntfId), base10)
353 context[ContextOnuOnuID] = strconv.FormatUint(uint64(dgi.OnuId), base10)
354
Devmalya Paulfb990a52019-07-09 10:01:49 -0400355 /* Populating device event body */
356 de.Context = context
357 de.ResourceId = deviceID
Thomas Lee Sf68399e2020-02-11 15:41:38 +0530358 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDyingGaspEvent, "EVENT")
Devmalya Paulfb990a52019-07-09 10:01:49 -0400359 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100360 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530361 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400362 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000363 logger.Debugw(ctx, "onu-dying-gasp-event-sent-to-kafka", log.Fields{"intf-id": dgi.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530364 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400365}
366
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530367//wasLosRaised checks whether los raised already. If already raised returns true else false
Neha Sharma96b7bf22020-06-15 10:37:32 +0000368func (em *OpenOltEventMgr) wasLosRaised(ctx context.Context, onuAlarm *oop.OnuAlarmIndication) bool {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530369 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
370 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000371 logger.Debugw(ctx, "onu-device-found-in-cache.", log.Fields{"intfID": onuAlarm.IntfId, "onuID": onuAlarm.OnuId})
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530372
373 if onuAlarm.LosStatus == statusCheckOn {
374 if onuInCache.(*OnuDevice).losRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000375 logger.Warnw(ctx, "onu-los-raised-already", log.Fields{"onu_id": onuAlarm.OnuId,
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530376 "intf_id": onuAlarm.IntfId, "LosStatus": onuAlarm.LosStatus})
377 return true
378 }
379 return false
380 }
381 }
382 return true
383}
384
385//wasLosCleared checks whether los cleared already. If already cleared returns true else false
Neha Sharma96b7bf22020-06-15 10:37:32 +0000386func (em *OpenOltEventMgr) wasLosCleared(ctx context.Context, onuAlarm *oop.OnuAlarmIndication) bool {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530387 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
388 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000389 logger.Debugw(ctx, "onu-device-found-in-cache.", log.Fields{"intfID": onuAlarm.IntfId, "onuID": onuAlarm.OnuId})
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530390
391 if onuAlarm.LosStatus == statusCheckOff {
392 if !onuInCache.(*OnuDevice).losRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000393 logger.Warnw(ctx, "onu-los-cleared-already", log.Fields{"onu_id": onuAlarm.OnuId,
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530394 "intf_id": onuAlarm.IntfId, "LosStatus": onuAlarm.LosStatus})
395 return true
396 }
397 return false
398 }
399 }
400 return true
401}
402
403func (em *OpenOltEventMgr) getDeviceEventName(onuAlarm *oop.OnuAlarmIndication) string {
404 var deviceEventName string
405 if onuAlarm.LosStatus == statusCheckOn {
406 deviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "RAISE_EVENT")
407 } else if onuAlarm.LosStatus == statusCheckOff {
408 deviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "CLEAR_EVENT")
409 } else if onuAlarm.LobStatus == statusCheckOn {
410 deviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "RAISE_EVENT")
411 } else if onuAlarm.LobStatus == statusCheckOff {
412 deviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "CLEAR_EVENT")
413 } else if onuAlarm.LopcMissStatus == statusCheckOn {
414 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "RAISE_EVENT")
415 } else if onuAlarm.LopcMissStatus == statusCheckOff {
416 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "CLEAR_EVENT")
417 } else if onuAlarm.LopcMicErrorStatus == statusCheckOn {
418 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "RAISE_EVENT")
419 } else if onuAlarm.LopcMicErrorStatus == statusCheckOff {
420 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "CLEAR_EVENT")
421 } else if onuAlarm.LofiStatus == statusCheckOn {
422 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "RAISE_EVENT")
423 } else if onuAlarm.LofiStatus == statusCheckOff {
424 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "CLEAR_EVENT")
425 } else if onuAlarm.LoamiStatus == statusCheckOn {
426 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfPloamEvent, "RAISE_EVENT")
427 } else if onuAlarm.LoamiStatus == statusCheckOff {
428 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfPloamEvent, "CLEAR_EVENT")
429 }
430 return deviceEventName
431}
432
Neha Sharma96b7bf22020-06-15 10:37:32 +0000433func (em *OpenOltEventMgr) onuAlarmIndication(ctx context.Context, onuAlarm *oop.OnuAlarmIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400434 var de voltha.DeviceEvent
Amit Ghosh502056b2020-07-15 09:15:48 +0100435
Devmalya Paulfb990a52019-07-09 10:01:49 -0400436 context := make(map[string]string)
437 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100438 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuAlarm.IntfId), base10)
439 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuAlarm.OnuId), base10)
440 em.populateContextWithSerialDeviceID(context, onuAlarm.IntfId, onuAlarm.OnuId)
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530441
Devmalya Paulfb990a52019-07-09 10:01:49 -0400442 /* Populating device event body */
443 de.Context = context
444 de.ResourceId = deviceID
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530445 de.DeviceEventName = em.getDeviceEventName(onuAlarm)
446
447 switch onuAlarm.LosStatus {
448 case statusCheckOn:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000449 if em.wasLosRaised(ctx, onuAlarm) {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530450 /* No need to raise Onu Los Event as it might have already raised
451 or Onu might have deleted */
452 return nil
453 }
454 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
455 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
456 /* Update onu device with LoS raised state as true */
457 em.handler.onus.Store(onuKey, NewOnuDevice(onuInCache.(*OnuDevice).deviceID, onuInCache.(*OnuDevice).deviceType,
458 onuInCache.(*OnuDevice).serialNumber, onuInCache.(*OnuDevice).onuID, onuInCache.(*OnuDevice).intfID,
459 onuInCache.(*OnuDevice).proxyDeviceID, true))
460 }
461 case statusCheckOff:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000462 if em.wasLosCleared(ctx, onuAlarm) {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530463 /* No need to clear Onu Los Event as it might have already cleared
464 or Onu might have deleted */
465 return nil
466 }
467 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
468 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
469 /* Update onu device with LoS raised state as false */
470 em.handler.onus.Store(onuKey, NewOnuDevice(onuInCache.(*OnuDevice).deviceID, onuInCache.(*OnuDevice).deviceType,
471 onuInCache.(*OnuDevice).serialNumber, onuInCache.(*OnuDevice).onuID, onuInCache.(*OnuDevice).intfID,
472 onuInCache.(*OnuDevice).proxyDeviceID, false))
473 }
Devmalya Paulfb990a52019-07-09 10:01:49 -0400474 }
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530475
Devmalya Paulfb990a52019-07-09 10:01:49 -0400476 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400477 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530478 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400479 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000480 logger.Debugw(ctx, "onu-los-event-sent-to-kafka", log.Fields{"onu-id": onuAlarm.OnuId, "intf-id": onuAlarm.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530481 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400482}
483
kesavand7cf3a052020-08-28 12:49:18 +0530484func (em *OpenOltEventMgr) onuActivationIndication(ctx context.Context, eventName string, onuInd *oop.OnuIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400485 var de voltha.DeviceEvent
486 context := make(map[string]string)
487 /* Populating event context */
kesavand7cf3a052020-08-28 12:49:18 +0530488 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuInd.IntfId), base10)
489 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuInd.OnuId), base10)
490 context[ContextOnuFailureReaseon] = onuInd.FailReason.String()
Amit Ghosh502056b2020-07-15 09:15:48 +0100491
kesavand7cf3a052020-08-28 12:49:18 +0530492 em.populateContextWithSerialDeviceID(context, onuInd.IntfId, onuInd.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100493
Devmalya Paulfb990a52019-07-09 10:01:49 -0400494 /* Populating device event body */
495 de.Context = context
496 de.ResourceId = deviceID
kesavand7cf3a052020-08-28 12:49:18 +0530497 de.DeviceEventName = eventName
Devmalya Paulfb990a52019-07-09 10:01:49 -0400498 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400499 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_PON, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530500 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400501 }
kesavand7cf3a052020-08-28 12:49:18 +0530502 logger.Debugw(ctx, "onu-activation-failure-event-sent-to-kafka", log.Fields{"onu-id": onuInd.OnuId, "intf-id": onuInd.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530503 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400504}
505
Neha Sharma96b7bf22020-06-15 10:37:32 +0000506func (em *OpenOltEventMgr) onuLossOmciIndication(ctx context.Context, onuLossOmci *oop.OnuLossOfOmciChannelIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400507 var de voltha.DeviceEvent
508 context := make(map[string]string)
509 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100510 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuLossOmci.IntfId), base10)
511 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuLossOmci.OnuId), base10)
512
513 em.populateContextWithSerialDeviceID(context, onuLossOmci.IntfId, onuLossOmci.OnuId)
514
Devmalya Paulfb990a52019-07-09 10:01:49 -0400515 /* Populating device event body */
516 de.Context = context
517 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530518 if onuLossOmci.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400519 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "RAISE_EVENT")
520 } else {
521 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "CLEAR_EVENT")
522 }
523 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100524 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530525 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400526 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000527 logger.Debugw(ctx, "onu-loss-of-omci-channel-event-sent-to-kafka", log.Fields{"onu-id": onuLossOmci.OnuId, "intf-id": onuLossOmci.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530528 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400529}
530
Neha Sharma96b7bf22020-06-15 10:37:32 +0000531func (em *OpenOltEventMgr) onuDriftOfWindowIndication(ctx context.Context, onuDriftWindow *oop.OnuDriftOfWindowIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400532 var de voltha.DeviceEvent
533 context := make(map[string]string)
534 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100535 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDriftWindow.IntfId), base10)
536 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuDriftWindow.OnuId), base10)
537 context[ContextOnuDrift] = strconv.FormatUint(uint64(onuDriftWindow.Drift), base10)
538 context[ContextOnuNewEqd] = strconv.FormatUint(uint64(onuDriftWindow.NewEqd), base10)
539
540 em.populateContextWithSerialDeviceID(context, onuDriftWindow.IntfId, onuDriftWindow.OnuId)
541
Devmalya Paulfb990a52019-07-09 10:01:49 -0400542 /* Populating device event body */
543 de.Context = context
544 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530545 if onuDriftWindow.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400546 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "RAISE_EVENT")
547 } else {
548 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "CLEAR_EVENT")
549 }
550 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100551 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530552 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400553 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000554 logger.Debugw(ctx, "onu-drift-of-window-event-sent-to-kafka", log.Fields{"onu-id": onuDriftWindow.OnuId, "intf-id": onuDriftWindow.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530555 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400556}
557
Neha Sharma96b7bf22020-06-15 10:37:32 +0000558func (em *OpenOltEventMgr) onuSignalDegradeIndication(ctx context.Context, onuSignalDegrade *oop.OnuSignalDegradeIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400559 var de voltha.DeviceEvent
560 context := make(map[string]string)
561 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100562 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuSignalDegrade.IntfId), base10)
563 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuSignalDegrade.OnuId), base10)
564 context[ContextOnuInverseBitErrorRate] = strconv.FormatUint(uint64(onuSignalDegrade.InverseBitErrorRate), base10)
565
566 em.populateContextWithSerialDeviceID(context, onuSignalDegrade.IntfId, onuSignalDegrade.OnuId)
567
Devmalya Paulfb990a52019-07-09 10:01:49 -0400568 /* Populating device event body */
569 de.Context = context
570 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530571 if onuSignalDegrade.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400572 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "RAISE_EVENT")
573 } else {
574 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "CLEAR_EVENT")
575 }
576 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100577 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530578 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400579 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000580 logger.Debugw(ctx, "onu-signal-degrade-event-sent-to-kafka", log.Fields{"onu-id": onuSignalDegrade.OnuId, "intf-id": onuSignalDegrade.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530581 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400582}
583
Neha Sharma96b7bf22020-06-15 10:37:32 +0000584func (em *OpenOltEventMgr) onuSignalsFailIndication(ctx context.Context, onuSignalsFail *oop.OnuSignalsFailureIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400585 var de voltha.DeviceEvent
586 context := make(map[string]string)
587 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100588 em.populateContextWithSerialDeviceID(context, onuSignalsFail.IntfId, onuSignalsFail.OnuId)
589
590 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuSignalsFail.OnuId), base10)
591 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuSignalsFail.IntfId), base10)
592 context[ContextOnuInverseBitErrorRate] = strconv.FormatUint(uint64(onuSignalsFail.InverseBitErrorRate), base10)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400593 /* Populating device event body */
594 de.Context = context
595 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530596 if onuSignalsFail.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400597 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "RAISE_EVENT")
598 } else {
599 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "CLEAR_EVENT")
600 }
601 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100602 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530603 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400604 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000605 logger.Debugw(ctx, "onu-signals-fail-event-sent-to-kafka", log.Fields{"onu-id": onuSignalsFail.OnuId, "intf-id": onuSignalsFail.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530606 return nil
607}
608
Neha Sharma96b7bf22020-06-15 10:37:32 +0000609func (em *OpenOltEventMgr) onuStartupFailedIndication(ctx context.Context, onuStartupFail *oop.OnuStartupFailureIndication, deviceID string, raisedTs int64) error {
Naga Manjunathf6f74642020-01-13 21:37:28 +0530610 var de voltha.DeviceEvent
611 context := make(map[string]string)
612 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100613 em.populateContextWithSerialDeviceID(context, onuStartupFail.IntfId, onuStartupFail.OnuId)
614
615 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuStartupFail.OnuId), base10)
616 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuStartupFail.IntfId), base10)
Naga Manjunathf6f74642020-01-13 21:37:28 +0530617
618 /* Populating device event body */
619 de.Context = context
620 de.ResourceId = deviceID
621 if onuStartupFail.Status == statusCheckOn {
622 de.DeviceEventName = fmt.Sprintf("%s_%s", onuStartupFailEvent, "RAISE_EVENT")
623 } else {
624 de.DeviceEventName = fmt.Sprintf("%s_%s", onuStartupFailEvent, "CLEAR_EVENT")
625 }
626 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400627 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs); err != nil {
Naga Manjunathf6f74642020-01-13 21:37:28 +0530628 return err
629 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000630 logger.Debugw(ctx, "onu-startup-fail-event-sent-to-kafka", log.Fields{"onu-id": onuStartupFail.OnuId, "intf-id": onuStartupFail.IntfId})
Naga Manjunathf6f74642020-01-13 21:37:28 +0530631 return nil
632}
633
Neha Sharma96b7bf22020-06-15 10:37:32 +0000634func (em *OpenOltEventMgr) onuLossOfSyncIndication(ctx context.Context, onuLOKI *oop.OnuLossOfKeySyncFailureIndication, deviceID string, raisedTs int64) error {
Naga Manjunath9546b912019-11-28 20:56:20 +0530635 var de voltha.DeviceEvent
636 context := make(map[string]string)
637 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100638 em.populateContextWithSerialDeviceID(context, onuLOKI.IntfId, onuLOKI.OnuId)
639
640 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuLOKI.OnuId), base10)
641 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuLOKI.IntfId), base10)
Naga Manjunath9546b912019-11-28 20:56:20 +0530642 /* Populating device event body */
643 de.Context = context
644 de.ResourceId = deviceID
645 if onuLOKI.Status == statusCheckOn {
646 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "RAISE_EVENT")
647 } else {
648 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "CLEAR_EVENT")
649 }
650
651 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400652 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_SECURITY, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530653 return err
654 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000655 logger.Debugw(ctx, "onu-loss-of-key-sync-event-sent-to-kafka", log.Fields{"onu-id": onuLOKI.OnuId, "intf-id": onuLOKI.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530656 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400657}
kesavand39e0aa32020-01-28 20:58:50 -0500658
659// oltIntfOperIndication handles Up and Down state of an OLT PON ports
Kent Hagermane6ff1012020-07-14 15:07:53 -0400660func (em *OpenOltEventMgr) oltIntfOperIndication(ctx context.Context, ifindication *oop.IntfOperIndication, deviceID string, raisedTs int64) {
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400661 portNo := IntfIDToPortNo(ifindication.IntfId, voltha.Port_PON_OLT)
662 if port, err := em.handler.coreProxy.GetDevicePort(ctx, deviceID, portNo); err != nil {
663 logger.Warnw(ctx, "Error while fetching port object", log.Fields{"device-id": deviceID, "error": err})
664 } else if port.AdminState != common.AdminState_ENABLED {
665 logger.Debugw(ctx, "port-disable/enable-event-not-generated--the-port-is-not-enabled-by-operator", log.Fields{"device-id": deviceID, "port": port})
Kent Hagermane6ff1012020-07-14 15:07:53 -0400666 return
kesavand39e0aa32020-01-28 20:58:50 -0500667 }
668 /* Populating event context */
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400669 context := map[string]string{ContextOltPonIntfOperState: ifindication.GetOperState()}
kesavand39e0aa32020-01-28 20:58:50 -0500670 /* Populating device event body */
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400671 var de voltha.DeviceEvent
kesavand39e0aa32020-01-28 20:58:50 -0500672 de.Context = context
673 de.ResourceId = deviceID
674
675 if ifindication.GetOperState() == operationStateDown {
676 de.DeviceEventName = fmt.Sprintf("%s_%s", ponIntfDownIndiction, "RAISE_EVENT")
677 } else if ifindication.OperState == operationStateUp {
678 de.DeviceEventName = fmt.Sprintf("%s_%s", ponIntfDownIndiction, "CLEAR_EVENT")
679 }
680 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400681 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
682 _ = olterrors.NewErrCommunication("send-olt-intf-oper-status-event", log.Fields{"device-id": deviceID, "intf-id": ifindication.IntfId, "oper-state": ifindication.OperState}, err).LogAt(log.WarnLevel)
683 return
kesavand39e0aa32020-01-28 20:58:50 -0500684 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000685 logger.Debug(ctx, "sent-olt-intf-oper-status-event-to-kafka")
kesavand39e0aa32020-01-28 20:58:50 -0500686}
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500687
Neha Sharma96b7bf22020-06-15 10:37:32 +0000688func (em *OpenOltEventMgr) onuDeactivationFailureIndication(ctx context.Context, onuDFI *oop.OnuDeactivationFailureIndication, deviceID string, raisedTs int64) error {
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500689 var de voltha.DeviceEvent
690 context := make(map[string]string)
691 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100692 em.populateContextWithSerialDeviceID(context, onuDFI.IntfId, onuDFI.OnuId)
693
694 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuDFI.OnuId), base10)
695 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDFI.IntfId), base10)
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500696 /* Populating device event body */
697 de.Context = context
698 de.ResourceId = deviceID
Devmalya Paula1efa642020-04-20 01:36:43 -0400699 if onuDFI.Status == statusCheckOn {
700 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDeactivationFailureEvent, "RAISE_EVENT")
701 } else {
702 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDeactivationFailureEvent, "CLEAR_EVENT")
703 }
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500704 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400705 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500706 return err
707 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000708 logger.Debugw(ctx, "onu-deactivation-failure-event-sent-to-kafka", log.Fields{"onu-id": onuDFI.OnuId, "intf-id": onuDFI.IntfId})
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500709 return nil
710}
Amit Ghosh502056b2020-07-15 09:15:48 +0100711
Neha Sharma96b7bf22020-06-15 10:37:32 +0000712func (em *OpenOltEventMgr) onuRemoteDefectIndication(ctx context.Context, onuID uint32, intfID uint32, rdiCount uint64, status string, deviceID string, raisedTs int64) error {
Devmalya Paul6f063a62020-02-19 19:19:06 -0500713 /* Populating event context */
714 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100715 ContextOnuOnuID: strconv.FormatUint(uint64(onuID), base10),
716 ContextOnuPonIntfID: strconv.FormatUint(uint64(intfID), base10),
717 ContextOnuRemoteDefectIndicatorCount: strconv.FormatUint(rdiCount, base10),
Devmalya Paul6f063a62020-02-19 19:19:06 -0500718 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100719 em.populateContextWithSerialDeviceID(context, intfID, onuID)
720
Devmalya Paul6f063a62020-02-19 19:19:06 -0500721 /* Populating device event body */
722 de := &voltha.DeviceEvent{
Devmalya Paula1efa642020-04-20 01:36:43 -0400723 Context: context,
724 ResourceId: deviceID,
725 }
726 if status == statusCheckOn {
727 de.DeviceEventName = fmt.Sprintf("%s_%s", onuRemoteDefectIndication, "RAISE_EVENT")
728 } else {
729 de.DeviceEventName = fmt.Sprintf("%s_%s", onuRemoteDefectIndication, "CLEAR_EVENT")
Devmalya Paul6f063a62020-02-19 19:19:06 -0500730 }
731 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400732 if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Paul6f063a62020-02-19 19:19:06 -0500733 return err
734 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000735 logger.Debugw(ctx, "onu-remote-defect-event-sent-to-kafka", log.Fields{"onu-id": onuID, "intf-id": intfID})
Devmalya Paula1efa642020-04-20 01:36:43 -0400736 return nil
737}
738
Neha Sharma96b7bf22020-06-15 10:37:32 +0000739func (em *OpenOltEventMgr) onuItuPonStatsIndication(ctx context.Context, onuIPS *oop.OnuItuPonStatsIndication, deviceID string, raisedTs int64) error {
Devmalya Paula1efa642020-04-20 01:36:43 -0400740 onuDevice, found := em.handler.onus.Load(em.handler.formOnuKey(onuIPS.IntfId, onuIPS.OnuId))
741 if !found {
742 return errors.New("unknown-onu-device")
743 }
744 if onuIPS.GetRdiErrorInd().Status == statusCheckOn {
745 if !onuDevice.(*OnuDevice).rdiRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000746 if err := em.onuRemoteDefectIndication(ctx, onuIPS.OnuId, onuIPS.IntfId, onuIPS.GetRdiErrorInd().RdiErrorCount, statusCheckOn, deviceID, raisedTs); err != nil {
Devmalya Paula1efa642020-04-20 01:36:43 -0400747 return err
748 }
749 onuDevice.(*OnuDevice).rdiRaised = true
750 return nil
751 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000752 logger.Debugw(ctx, "onu-remote-defect-already-raised", log.Fields{"onu-id": onuIPS.OnuId, "intf-id": onuIPS.IntfId})
Devmalya Paula1efa642020-04-20 01:36:43 -0400753 } else {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000754 if err := em.onuRemoteDefectIndication(ctx, onuIPS.OnuId, onuIPS.IntfId, onuIPS.GetRdiErrorInd().RdiErrorCount, statusCheckOff, deviceID, raisedTs); err != nil {
Devmalya Paula1efa642020-04-20 01:36:43 -0400755 return err
756 }
757 onuDevice.(*OnuDevice).rdiRaised = false
758 }
Devmalya Paul41a762d2020-03-01 18:56:54 -0500759 return nil
760}
761
Neha Sharma96b7bf22020-06-15 10:37:32 +0000762func (em *OpenOltEventMgr) onuLossOfGEMChannelDelineationIndication(ctx context.Context, onuGCD *oop.OnuLossOfGEMChannelDelineationIndication, deviceID string, raisedTs int64) error {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500763 /* Populating event context */
764 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100765 ContextOnuOnuID: strconv.FormatUint(uint64(onuGCD.OnuId), base10),
766 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuGCD.IntfId), base10),
767 ContextOnuDelineationErrors: strconv.FormatUint(uint64(onuGCD.DelineationErrors), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500768 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100769 em.populateContextWithSerialDeviceID(context, onuGCD.IntfId, onuGCD.OnuId)
770
Devmalya Paul41a762d2020-03-01 18:56:54 -0500771 /* Populating device event body */
772 de := &voltha.DeviceEvent{
773 Context: context,
774 ResourceId: deviceID,
775 }
776 if onuGCD.Status == statusCheckOn {
777 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfGEMChannelDelineationEvent, "RAISE_EVENT")
778 } else {
779 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfGEMChannelDelineationEvent, "CLEAR_EVENT")
780 }
781 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400782 if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500783 return err
784 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000785 logger.Debugw(ctx, "onu-loss-of-gem-channel-delineation-event-sent-to-kafka", log.Fields{"onu-id": onuGCD.OnuId, "intf-id": onuGCD.IntfId})
Devmalya Paul41a762d2020-03-01 18:56:54 -0500786 return nil
787}
788
Neha Sharma96b7bf22020-06-15 10:37:32 +0000789func (em *OpenOltEventMgr) onuPhysicalEquipmentErrorIndication(ctx context.Context, onuErr *oop.OnuPhysicalEquipmentErrorIndication, deviceID string, raisedTs int64) error {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500790 /* Populating event context */
791 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100792 ContextOnuOnuID: strconv.FormatUint(uint64(onuErr.OnuId), base10),
793 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuErr.IntfId), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500794 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100795 em.populateContextWithSerialDeviceID(context, onuErr.IntfId, onuErr.OnuId)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500796 /* Populating device event body */
797 de := &voltha.DeviceEvent{
798 Context: context,
799 ResourceId: deviceID,
800 }
801 if onuErr.Status == statusCheckOn {
802 de.DeviceEventName = fmt.Sprintf("%s_%s", onuPhysicalEquipmentErrorEvent, "RAISE_EVENT")
803 } else {
804 de.DeviceEventName = fmt.Sprintf("%s_%s", onuPhysicalEquipmentErrorEvent, "CLEAR_EVENT")
805 }
806 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400807 if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500808 return err
809 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000810 logger.Debugw(ctx, "onu-physical-equipment-error-event-sent-to-kafka", log.Fields{"onu-id": onuErr.OnuId, "intf-id": onuErr.IntfId})
Devmalya Paul41a762d2020-03-01 18:56:54 -0500811 return nil
812}
813
Neha Sharma96b7bf22020-06-15 10:37:32 +0000814func (em *OpenOltEventMgr) onuLossOfAcknowledgementIndication(ctx context.Context, onuLOA *oop.OnuLossOfAcknowledgementIndication, deviceID string, raisedTs int64) error {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500815 /* Populating event context */
816 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100817 ContextOnuOnuID: strconv.FormatUint(uint64(onuLOA.OnuId), base10),
818 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuLOA.IntfId), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500819 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100820 em.populateContextWithSerialDeviceID(context, onuLOA.IntfId, onuLOA.OnuId)
821
Devmalya Paul41a762d2020-03-01 18:56:54 -0500822 /* Populating device event body */
823 de := &voltha.DeviceEvent{
824 Context: context,
825 ResourceId: deviceID,
826 }
827 if onuLOA.Status == statusCheckOn {
828 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfAcknowledgementEvent, "RAISE_EVENT")
829 } else {
830 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfAcknowledgementEvent, "CLEAR_EVENT")
831 }
832 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400833 if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500834 return err
835 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000836 logger.Debugw(ctx, "onu-physical-equipment-error-event-sent-to-kafka", log.Fields{"onu-id": onuLOA.OnuId, "intf-id": onuLOA.IntfId})
Devmalya Paul6f063a62020-02-19 19:19:06 -0500837 return nil
838}
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400839
Neha Sharma96b7bf22020-06-15 10:37:32 +0000840func (em *OpenOltEventMgr) onuDifferentialReachExceededIndication(ctx context.Context, onuDRE *oop.OnuDifferentialReachExceededIndication, deviceID string, raisedTs int64) error {
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400841 /* Populating event context */
842 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100843 ContextOnuOnuID: strconv.FormatUint(uint64(onuDRE.OnuId), base10),
844 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuDRE.IntfId), base10),
845 ContextOnuDifferentialDistance: strconv.FormatUint(uint64(onuDRE.Distance), base10),
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400846 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100847 em.populateContextWithSerialDeviceID(context, onuDRE.IntfId, onuDRE.OnuId)
848
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400849 /* Populating device event body */
850 de := &voltha.DeviceEvent{
851 Context: context,
852 ResourceId: deviceID,
853 }
854 if onuDRE.Status == statusCheckOn {
855 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDifferentialReachExceededEvent, "RAISE_EVENT")
856 } else {
857 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDifferentialReachExceededEvent, "CLEAR_EVENT")
858 }
859 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400860 if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400861 return err
862 }
Girish Kumara1ea2aa2020-08-19 18:14:22 +0000863 logger.Debugw(ctx, "onu-differential-reach-exceeded–event-sent-to-kafka", log.Fields{"onu-id": onuDRE.OnuId, "intf-id": onuDRE.IntfId})
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400864 return nil
865}