blob: a3bf0034840e9ae293430ae4319fa30b5f9beab6 [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
khenaidoodc2116e2021-10-19 17:33:19 -040026 ca "github.com/opencord/voltha-protos/v5/go/core_adapter"
khenaidoo106c61a2021-08-11 18:05:46 -040027
28 "github.com/opencord/voltha-lib-go/v7/pkg/events/eventif"
29 "github.com/opencord/voltha-lib-go/v7/pkg/log"
Mahir Gunyel85f61c12021-10-06 11:53:45 -070030 plt "github.com/opencord/voltha-lib-go/v7/pkg/platform"
Thomas Lee S94109f12020-03-03 16:39:29 +053031 "github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
khenaidoo106c61a2021-08-11 18:05:46 -040032 "github.com/opencord/voltha-protos/v5/go/common"
33 oop "github.com/opencord/voltha-protos/v5/go/openolt"
34 "github.com/opencord/voltha-protos/v5/go/voltha"
Devmalya Paulfb990a52019-07-09 10:01:49 -040035)
36
37const (
Devmalya Paul41a762d2020-03-01 18:56:54 -050038 onuDiscoveryEvent = "ONU_DISCOVERY"
39 onuLosEvent = "ONU_LOSS_OF_SIGNAL"
40 onuLobEvent = "ONU_LOSS_OF_BURST"
41 onuLopcMissEvent = "ONU_LOPC_MISS"
42 onuLopcMicErrorEvent = "ONU_LOPC_MIC_ERROR"
43 oltLosEvent = "OLT_LOSS_OF_SIGNAL"
Gamze Abaka07868a52020-12-17 14:19:28 +000044 oltCommFailure = "OLT_COMMUNICATION_FAILURE"
Devmalya Paul41a762d2020-03-01 18:56:54 -050045 oltIndicationDown = "OLT_DOWN_INDICATION"
46 onuDyingGaspEvent = "ONU_DYING_GASP"
47 onuSignalsFailEvent = "ONU_SIGNALS_FAIL"
48 onuStartupFailEvent = "ONU_STARTUP_FAIL"
49 onuSignalDegradeEvent = "ONU_SIGNAL_DEGRADE"
50 onuDriftOfWindowEvent = "ONU_DRIFT_OF_WINDOW"
51 onuActivationFailEvent = "ONU_ACTIVATION_FAIL"
Devmalya Paul41a762d2020-03-01 18:56:54 -050052 onuLossOmciEvent = "ONU_LOSS_OF_OMCI_CHANNEL"
53 onuLossOfKeySyncEvent = "ONU_LOSS_OF_KEY_SYNC"
54 onuLossOfFrameEvent = "ONU_LOSS_OF_FRAME"
55 onuLossOfPloamEvent = "ONU_LOSS_OF_PLOAM"
56 ponIntfDownIndiction = "OLT_PON_INTERFACE_DOWN"
57 onuDeactivationFailureEvent = "ONU_DEACTIVATION_FAILURE"
58 onuRemoteDefectIndication = "ONU_REMOTE_DEFECT"
59 onuLossOfGEMChannelDelineationEvent = "ONU_LOSS_OF_GEM_CHANNEL_DELINEATION"
60 onuPhysicalEquipmentErrorEvent = "ONU_PHYSICAL_EQUIPMENT_ERROR"
61 onuLossOfAcknowledgementEvent = "ONU_LOSS_OF_ACKNOWLEDGEMENT"
Devmalya Pauleb5294e2020-03-19 03:01:39 -040062 onuDifferentialReachExceededEvent = "ONU_DIFFERENTIAL_REACH_EXCEEDED"
Devmalya Paulfb990a52019-07-09 10:01:49 -040063)
64
65const (
Naga Manjunath9546b912019-11-28 20:56:20 +053066 // statusCheckOn represents status check On
67 statusCheckOn = "on"
68 // statusCheckOff represents status check Off
69 statusCheckOff = "off"
70 // operationStateUp represents operation state Up
71 operationStateUp = "up"
72 // operationStateDown represents operation state Down
73 operationStateDown = "down"
74 // base10 represents base 10 conversion
75 base10 = 10
76)
77
Amit Ghosh502056b2020-07-15 09:15:48 +010078const (
Gamze Abaka07868a52020-12-17 14:19:28 +000079 // ContextOltAdminState is for the admin state of the Olt in the context of the event
80 ContextOltAdminState = "admin-state"
81 // ContextOltConnectState is for the connect state of the Olt in the context of the event
82 ContextOltConnectState = "connect-state"
Amit Ghosh502056b2020-07-15 09:15:48 +010083 // ContextOltOperState is for the operational state of the Olt in the context of the event
84 ContextOltOperState = "oper-state"
Gamze Abaka07868a52020-12-17 14:19:28 +000085 // ContextOltVendor is for the Olt vendor in the context of the event
86 ContextOltVendor = "vendor"
87 // ContextOltType is for the Olt type in the context of the event
88 ContextOltType = "type"
89 // ContextOltParentID is for the Olt parent id in the context of the event
90 ContextOltParentID = "parent-id"
91 // ContextOltParentPortNo is for the Olt parent port no in the context of the event
92 ContextOltParentPortNo = "parent-port-no"
93 // ContextOltFirmwareVersion is for the Olt firmware version in the context of the event
94 ContextOltFirmwareVersion = "firmware-version"
95 // ContextOltHardwareVersion is for the Olt hardware version in the context of the event
96 ContextOltHardwareVersion = "hardware-version"
97 // ContextOltSerialNumber is for the serial number of the OLT
98 ContextOltSerialNumber = "serial-number"
99 // ContextOltMacAddress is for the OLT mac address
100 ContextOltMacAddress = "mac-address"
101 // ContextDeviceID is for the device id in the context of the event
102 ContextDeviceID = "id"
Amit Ghosh502056b2020-07-15 09:15:48 +0100103 // ContextOnuOnuID is for the Onu Id in the context of the event
104 ContextOnuOnuID = "onu-id"
105 // ContextOnuPonIntfID is for the PON interface Id on which the Onu Event occurred
106 ContextOnuPonIntfID = "intf-id"
107 // ContextOnuSerialNumber is for the serial number of the ONU
108 ContextOnuSerialNumber = "serial-number"
109 // ContextOnuDeviceID is for the device id of the ONU generated by VOLTHA
110 ContextOnuDeviceID = "onu-device-id"
111 // ContextOltPonIntfID is for the PON interface Id on an OLT event
112 ContextOltPonIntfID = "intf-id"
113 // ContextOnuFailureReaseon is for the reason of failure of/at ONU indicated by the event
114 ContextOnuFailureReaseon = "fail-reason"
115 // ContextOnuDrift is for the drift of an ONU in the context of an event
116 ContextOnuDrift = "drift"
117 // ContextOnuNewEqd is for the New Eqd of an ONU in the context of an event
118 ContextOnuNewEqd = "new-eqd"
119 // ContextOnuInverseBitErrorRate is for the inverse bit error rate in the context of an ONU event
120 ContextOnuInverseBitErrorRate = "inverse-bit-error-rate"
121 // ContextOltPonIntfOperState is for the operational state of a PON port in the context of an OLT event
122 ContextOltPonIntfOperState = "oper-state"
123 // ContextOnuRemoteDefectIndicatorCount is for the rdi in the context of an ONU event
124 ContextOnuRemoteDefectIndicatorCount = "rdi-count"
125 // ContextOnuDelineationErrors is for the delineation errors if present in an ONU events context
126 ContextOnuDelineationErrors = "delineation-errors"
127 // ContextOnuDifferentialDistance is for the differential distance in an ONU event context
128 ContextOnuDifferentialDistance = "differential-distance"
ssiddiqui04386ee2021-08-23 21:58:25 +0530129 // ContextOltPonTechnology is to indicate the pon-technology type, ie, 'GPON' or 'XGS-PON' (TODO check for combo?)
130 ContextOltPonTechnology = "pon-technology"
131 // ContextOltPortLabel is to indicate the string label of the pon-port, example: pon-0
132 ContextOltPortLabel = "port-label"
Amit Ghosh502056b2020-07-15 09:15:48 +0100133)
134
Devmalya Paulfb990a52019-07-09 10:01:49 -0400135// OpenOltEventMgr struct contains
136type OpenOltEventMgr struct {
Himani Chawlacd407802020-12-10 12:08:59 +0530137 eventProxy eventif.EventProxy
Devmalya Paul90ca3012019-09-02 21:55:45 -0400138 handler *DeviceHandler
Devmalya Paulfb990a52019-07-09 10:01:49 -0400139}
140
141// 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 +0530142func NewEventMgr(eventProxy eventif.EventProxy, handler *DeviceHandler) *OpenOltEventMgr {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400143 var em OpenOltEventMgr
144 em.eventProxy = eventProxy
Devmalya Paul90ca3012019-09-02 21:55:45 -0400145 em.handler = handler
Devmalya Paulfb990a52019-07-09 10:01:49 -0400146 return &em
147}
148
149// ProcessEvents is function to process and publish OpenOLT event
Devmalya Paul41a762d2020-03-01 18:56:54 -0500150// nolint: gocyclo
Kent Hagermane6ff1012020-07-14 15:07:53 -0400151func (em *OpenOltEventMgr) ProcessEvents(ctx context.Context, alarmInd *oop.AlarmIndication, deviceID string, raisedTs int64) {
Naga Manjunath9546b912019-11-28 20:56:20 +0530152 var err error
Devmalya Paulfb990a52019-07-09 10:01:49 -0400153 switch alarmInd.Data.(type) {
154 case *oop.AlarmIndication_LosInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000155 logger.Debugw(ctx, "received-los-indication", log.Fields{"alarm-ind": alarmInd})
156 err = em.oltLosIndication(ctx, alarmInd.GetLosInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400157 case *oop.AlarmIndication_OnuAlarmInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000158 logger.Debugw(ctx, "received-onu-alarm-indication ", log.Fields{"alarm-ind": alarmInd})
159 err = em.onuAlarmIndication(ctx, alarmInd.GetOnuAlarmInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400160 case *oop.AlarmIndication_DyingGaspInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000161 logger.Debugw(ctx, "received-dying-gasp-indication", log.Fields{"alarm-ind": alarmInd})
162 err = em.onuDyingGaspIndication(ctx, alarmInd.GetDyingGaspInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400163 case *oop.AlarmIndication_OnuLossOmciInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000164 logger.Debugw(ctx, "received-onu-loss-omci-indication ", log.Fields{"alarm-ind": alarmInd})
165 err = em.onuLossOmciIndication(ctx, alarmInd.GetOnuLossOmciInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400166 case *oop.AlarmIndication_OnuDriftOfWindowInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000167 logger.Debugw(ctx, "received-onu-drift-of-window-indication ", log.Fields{"alarm-ind": alarmInd})
168 err = em.onuDriftOfWindowIndication(ctx, alarmInd.GetOnuDriftOfWindowInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400169 case *oop.AlarmIndication_OnuSignalDegradeInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000170 logger.Debugw(ctx, "received-onu-signal-degrade-indication ", log.Fields{"alarm-ind": alarmInd})
171 err = em.onuSignalDegradeIndication(ctx, alarmInd.GetOnuSignalDegradeInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400172 case *oop.AlarmIndication_OnuSignalsFailInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000173 logger.Debugw(ctx, "received-onu-signal-fail-indication ", log.Fields{"alarm-ind": alarmInd})
174 err = em.onuSignalsFailIndication(ctx, alarmInd.GetOnuSignalsFailInd(), deviceID, raisedTs)
Naga Manjunathf6f74642020-01-13 21:37:28 +0530175 case *oop.AlarmIndication_OnuStartupFailInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000176 logger.Debugw(ctx, "received-onu-startup-fail-indication ", log.Fields{"alarm-ind": alarmInd})
177 err = em.onuStartupFailedIndication(ctx, alarmInd.GetOnuStartupFailInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400178 case *oop.AlarmIndication_OnuTiwiInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000179 logger.Debugw(ctx, "received-onu-transmission-warning-indication ", log.Fields{"alarm-ind": alarmInd})
180 logger.Warnw(ctx, "not-implemented-yet", log.Fields{"alarm-ind": "Onu-Transmission-indication"})
Naga Manjunath9546b912019-11-28 20:56:20 +0530181 case *oop.AlarmIndication_OnuLossOfSyncFailInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000182 logger.Debugw(ctx, "received-onu-loss-of-sync-fail-indication ", log.Fields{"alarm-ind": alarmInd})
183 err = em.onuLossOfSyncIndication(ctx, alarmInd.GetOnuLossOfSyncFailInd(), deviceID, raisedTs)
Naga Manjunath9546b912019-11-28 20:56:20 +0530184 case *oop.AlarmIndication_OnuItuPonStatsInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000185 logger.Debugw(ctx, "received-onu-itu-pon-stats-indication ", log.Fields{"alarm-ind": alarmInd})
186 err = em.onuItuPonStatsIndication(ctx, alarmInd.GetOnuItuPonStatsInd(), deviceID, raisedTs)
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500187 case *oop.AlarmIndication_OnuDeactivationFailureInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000188 logger.Debugw(ctx, "received-onu-deactivation-failure-indication ", log.Fields{"alarm-ind": alarmInd})
189 err = em.onuDeactivationFailureIndication(ctx, alarmInd.GetOnuDeactivationFailureInd(), deviceID, raisedTs)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500190 case *oop.AlarmIndication_OnuLossGemDelineationInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000191 logger.Debugw(ctx, "received-onu-loss-of-gem-channel-delineation-indication ", log.Fields{"alarm-ind": alarmInd})
192 err = em.onuLossOfGEMChannelDelineationIndication(ctx, alarmInd.GetOnuLossGemDelineationInd(), deviceID, raisedTs)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500193 case *oop.AlarmIndication_OnuPhysicalEquipmentErrorInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000194 logger.Debugw(ctx, "received-onu-physical-equipment-error-indication ", log.Fields{"alarm-ind": alarmInd})
195 err = em.onuPhysicalEquipmentErrorIndication(ctx, alarmInd.GetOnuPhysicalEquipmentErrorInd(), deviceID, raisedTs)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500196 case *oop.AlarmIndication_OnuLossOfAckInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000197 logger.Debugw(ctx, "received-onu-loss-of-acknowledgement-indication ", log.Fields{"alarm-ind": alarmInd})
198 err = em.onuLossOfAcknowledgementIndication(ctx, alarmInd.GetOnuLossOfAckInd(), deviceID, raisedTs)
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400199 case *oop.AlarmIndication_OnuDiffReachExceededInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000200 logger.Debugw(ctx, "received-onu-differential-reach-exceeded-indication ", log.Fields{"alarm-ind": alarmInd})
201 err = em.onuDifferentialReachExceededIndication(ctx, alarmInd.GetOnuDiffReachExceededInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400202 default:
Thomas Lee S94109f12020-03-03 16:39:29 +0530203 err = olterrors.NewErrInvalidValue(log.Fields{"indication-type": alarmInd}, nil)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400204 }
Naga Manjunath9546b912019-11-28 20:56:20 +0530205 if err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400206 _ = olterrors.NewErrCommunication("publish-message", log.Fields{"indication-type": alarmInd}, err).LogAt(log.WarnLevel)
Naga Manjunath9546b912019-11-28 20:56:20 +0530207 }
Devmalya Paulfb990a52019-07-09 10:01:49 -0400208}
209
Gamze Abaka07868a52020-12-17 14:19:28 +0000210func (em *OpenOltEventMgr) oltCommunicationEvent(ctx context.Context, device *voltha.Device, raisedTs int64) {
211 if device == nil {
212 logger.Warn(ctx, "device-is-nil-can't-send-olt-communication-failure-event")
213 return
214 }
215 var de voltha.DeviceEvent
216 context := make(map[string]string)
217 context[ContextOltOperState] = device.OperStatus.String()
218 context[ContextOltAdminState] = device.AdminState.String()
219 context[ContextOltVendor] = device.Vendor
220 context[ContextOltConnectState] = device.ConnectStatus.String()
221 context[ContextOltType] = device.Type
222 context[ContextOltParentID] = device.ParentId
223 context[ContextOltParentPortNo] = fmt.Sprintf("%d", device.ParentPortNo)
224 context[ContextDeviceID] = device.Id
225 context[ContextOltFirmwareVersion] = device.FirmwareVersion
226 context[ContextOltHardwareVersion] = device.HardwareVersion
227 context[ContextOltSerialNumber] = device.SerialNumber
228 context[ContextOltMacAddress] = device.MacAddress
229 de.Context = context
230 de.ResourceId = device.Id
231
232 if device.ConnectStatus == voltha.ConnectStatus_UNREACHABLE {
233 de.DeviceEventName = fmt.Sprintf("%s_%s", oltCommFailure, "RAISE_EVENT")
234 } else {
235 de.DeviceEventName = fmt.Sprintf("%s_%s", oltCommFailure, "CLEAR_EVENT")
236 }
237
238 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
239 logger.Errorw(ctx, "failed-to-send-olt-comm-failure-event", log.Fields{"err": err})
240 }
241 logger.Debugw(ctx, "olt-comm-failure-event-sent-to-kafka",
242 log.Fields{
243 "device-id": device.Id,
244 "connect-status": device.ConnectStatus,
245 })
246}
247
Daniele Rossi051466a2019-07-26 13:39:37 +0000248// oltUpDownIndication handles Up and Down state of an OLT
Neha Sharma96b7bf22020-06-15 10:37:32 +0000249func (em *OpenOltEventMgr) oltUpDownIndication(ctx context.Context, oltIndication *oop.OltIndication, deviceID string, raisedTs int64) error {
Daniele Rossi051466a2019-07-26 13:39:37 +0000250 var de voltha.DeviceEvent
251 context := make(map[string]string)
252 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100253 context[ContextOltOperState] = oltIndication.OperState
Daniele Rossi051466a2019-07-26 13:39:37 +0000254 /* Populating device event body */
255 de.Context = context
256 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530257 if oltIndication.OperState == operationStateDown {
Daniele Rossi051466a2019-07-26 13:39:37 +0000258 de.DeviceEventName = fmt.Sprintf("%s_%s", oltIndicationDown, "RAISE_EVENT")
Naga Manjunath9546b912019-11-28 20:56:20 +0530259 } else if oltIndication.OperState == operationStateUp {
Daniele Rossi051466a2019-07-26 13:39:37 +0000260 de.DeviceEventName = fmt.Sprintf("%s_%s", oltIndicationDown, "CLEAR_EVENT")
261 }
262 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400263 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000264 return olterrors.NewErrCommunication("send-olt-event", log.Fields{"device-id": deviceID}, err)
Daniele Rossi051466a2019-07-26 13:39:37 +0000265 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000266 logger.Debugw(ctx, "olt-updown-event-sent-to-kafka", log.Fields{})
Naga Manjunath9546b912019-11-28 20:56:20 +0530267 return nil
Daniele Rossi051466a2019-07-26 13:39:37 +0000268}
269
Devmalya Paulfb990a52019-07-09 10:01:49 -0400270// OnuDiscoveryIndication is an exported method to handle ONU discovery event
Neha Sharma96b7bf22020-06-15 10:37:32 +0000271func (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 -0400272 var de voltha.DeviceEvent
273 context := make(map[string]string)
274 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100275 context[ContextOnuOnuID] = strconv.FormatUint(uint64(OnuID), base10)
276 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDisc.IntfId), base10)
277 context[ContextOnuSerialNumber] = serialNumber
278 context[ContextOnuDeviceID] = onuDeviceID
ssiddiqui04386ee2021-08-23 21:58:25 +0530279 context[ContextOltPonTechnology] = em.handler.getPonTechnology(onuDisc.IntfId)
280 context[ContextOltPortLabel], _ = GetportLabel(onuDisc.GetIntfId(), voltha.Port_PON_OLT)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400281 /* Populating device event body */
282 de.Context = context
Amit Ghosh75f0e292020-05-14 11:31:54 +0100283 de.ResourceId = oltDeviceID
Devmalya Paulfb990a52019-07-09 10:01:49 -0400284 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDiscoveryEvent, "RAISE_EVENT")
285 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400286 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_PON, raisedTs); err != nil {
Shrey Baid26912972020-04-16 21:02:31 +0530287 return olterrors.NewErrCommunication("send-onu-discovery-event",
288 log.Fields{
289 "serial-number": serialNumber,
290 "intf-id": onuDisc.IntfId}, err)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400291 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000292 logger.Debugw(ctx, "onu-discovery-event-sent-to-kafka",
Shrey Baid26912972020-04-16 21:02:31 +0530293 log.Fields{
294 "serial-number": serialNumber,
295 "intf-id": onuDisc.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530296 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400297}
298
Neha Sharma96b7bf22020-06-15 10:37:32 +0000299func (em *OpenOltEventMgr) oltLosIndication(ctx context.Context, oltLos *oop.LosIndication, deviceID string, raisedTs int64) error {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530300 var err error = nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400301 var de voltha.DeviceEvent
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530302 var alarmInd oop.OnuAlarmIndication
Mahir Gunyel85f61c12021-10-06 11:53:45 -0700303 ponIntdID := plt.PortNoToIntfID(oltLos.IntfId, voltha.Port_PON_OLT)
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530304
Devmalya Paulfb990a52019-07-09 10:01:49 -0400305 context := make(map[string]string)
306 /* Populating event context */
yasin sapli0b242942021-10-11 08:51:16 +0000307 context[ContextOltPonIntfID] = strconv.FormatUint(uint64(ponIntdID), base10)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400308 /* Populating device event body */
309 de.Context = context
310 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530311 if oltLos.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400312 de.DeviceEventName = fmt.Sprintf("%s_%s", oltLosEvent, "RAISE_EVENT")
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530313
314 /* When PON cable disconnected from OLT, it was expected OnuAlarmIndication
315 with "los_status: on" should be raised for each Onu connected to the PON
316 but BAL does not raise this Alarm hence manually sending OnuLosRaise event
317 for all the ONU's connected to PON on receiving LoSIndication for PON */
318 em.handler.onus.Range(func(Onukey interface{}, onuInCache interface{}) bool {
319 if onuInCache.(*OnuDevice).intfID == ponIntdID {
320 alarmInd.IntfId = ponIntdID
321 alarmInd.OnuId = onuInCache.(*OnuDevice).onuID
322 alarmInd.LosStatus = statusCheckOn
Neha Sharma96b7bf22020-06-15 10:37:32 +0000323 err = em.onuAlarmIndication(ctx, &alarmInd, deviceID, raisedTs)
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530324 }
325 return true
326 })
327 if err != nil {
328 /* Return if any error encountered while processing ONU LoS Event*/
329 return err
330 }
Devmalya Paulfb990a52019-07-09 10:01:49 -0400331 } else {
332 de.DeviceEventName = fmt.Sprintf("%s_%s", oltLosEvent, "CLEAR_EVENT")
333 }
334 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100335 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530336 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400337 }
yasin sapli0b242942021-10-11 08:51:16 +0000338 logger.Debugw(ctx, "olt-los-event-sent-to-kafka", log.Fields{"intf-id": ponIntdID})
Naga Manjunath9546b912019-11-28 20:56:20 +0530339 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400340}
341
Amit Ghosh502056b2020-07-15 09:15:48 +0100342func (em *OpenOltEventMgr) populateContextWithSerialDeviceID(context map[string]string, intfID, onuID uint32) {
343 var serialNumber = ""
344 var onuDeviceID = ""
345 onu := em.handler.formOnuKey(intfID, onuID)
Naga Manjunatha8dc9372019-10-31 23:01:18 +0530346 if onu, ok := em.handler.onus.Load(onu); ok {
347 serialNumber = onu.(*OnuDevice).serialNumber
Amit Ghosh502056b2020-07-15 09:15:48 +0100348 onuDeviceID = onu.(*OnuDevice).deviceID
Devmalya Paul90ca3012019-09-02 21:55:45 -0400349 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100350
ssiddiqui04386ee2021-08-23 21:58:25 +0530351 context[ContextOltPortLabel], _ = GetportLabel(intfID, voltha.Port_PON_OLT)
Amit Ghosh502056b2020-07-15 09:15:48 +0100352 context[ContextOnuSerialNumber] = serialNumber
353 context[ContextOnuDeviceID] = onuDeviceID
354}
355
356func (em *OpenOltEventMgr) onuDyingGaspIndication(ctx context.Context, dgi *oop.DyingGaspIndication, deviceID string, raisedTs int64) error {
357 var de voltha.DeviceEvent
358 context := make(map[string]string)
359 /* Populating event context */
360 em.populateContextWithSerialDeviceID(context, dgi.IntfId, dgi.OnuId)
361
362 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(dgi.IntfId), base10)
363 context[ContextOnuOnuID] = strconv.FormatUint(uint64(dgi.OnuId), base10)
364
Devmalya Paulfb990a52019-07-09 10:01:49 -0400365 /* Populating device event body */
366 de.Context = context
367 de.ResourceId = deviceID
Thomas Lee Sf68399e2020-02-11 15:41:38 +0530368 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDyingGaspEvent, "EVENT")
Devmalya Paulfb990a52019-07-09 10:01:49 -0400369 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100370 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530371 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400372 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000373 logger.Debugw(ctx, "onu-dying-gasp-event-sent-to-kafka", log.Fields{"intf-id": dgi.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530374 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400375}
376
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530377//wasLosRaised checks whether los raised already. If already raised returns true else false
Neha Sharma96b7bf22020-06-15 10:37:32 +0000378func (em *OpenOltEventMgr) wasLosRaised(ctx context.Context, onuAlarm *oop.OnuAlarmIndication) bool {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530379 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
380 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000381 logger.Debugw(ctx, "onu-device-found-in-cache.", log.Fields{"intfID": onuAlarm.IntfId, "onuID": onuAlarm.OnuId})
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530382
383 if onuAlarm.LosStatus == statusCheckOn {
384 if onuInCache.(*OnuDevice).losRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000385 logger.Warnw(ctx, "onu-los-raised-already", log.Fields{"onu_id": onuAlarm.OnuId,
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530386 "intf_id": onuAlarm.IntfId, "LosStatus": onuAlarm.LosStatus})
387 return true
388 }
389 return false
390 }
391 }
392 return true
393}
394
395//wasLosCleared checks whether los cleared already. If already cleared returns true else false
Neha Sharma96b7bf22020-06-15 10:37:32 +0000396func (em *OpenOltEventMgr) wasLosCleared(ctx context.Context, onuAlarm *oop.OnuAlarmIndication) bool {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530397 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
398 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000399 logger.Debugw(ctx, "onu-device-found-in-cache.", log.Fields{"intfID": onuAlarm.IntfId, "onuID": onuAlarm.OnuId})
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530400
401 if onuAlarm.LosStatus == statusCheckOff {
402 if !onuInCache.(*OnuDevice).losRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000403 logger.Warnw(ctx, "onu-los-cleared-already", log.Fields{"onu_id": onuAlarm.OnuId,
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530404 "intf_id": onuAlarm.IntfId, "LosStatus": onuAlarm.LosStatus})
405 return true
406 }
407 return false
408 }
409 }
410 return true
411}
412
413func (em *OpenOltEventMgr) getDeviceEventName(onuAlarm *oop.OnuAlarmIndication) string {
414 var deviceEventName string
415 if onuAlarm.LosStatus == statusCheckOn {
416 deviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "RAISE_EVENT")
417 } else if onuAlarm.LosStatus == statusCheckOff {
418 deviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "CLEAR_EVENT")
419 } else if onuAlarm.LobStatus == statusCheckOn {
420 deviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "RAISE_EVENT")
421 } else if onuAlarm.LobStatus == statusCheckOff {
422 deviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "CLEAR_EVENT")
423 } else if onuAlarm.LopcMissStatus == statusCheckOn {
424 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "RAISE_EVENT")
425 } else if onuAlarm.LopcMissStatus == statusCheckOff {
426 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "CLEAR_EVENT")
427 } else if onuAlarm.LopcMicErrorStatus == statusCheckOn {
428 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "RAISE_EVENT")
429 } else if onuAlarm.LopcMicErrorStatus == statusCheckOff {
430 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "CLEAR_EVENT")
431 } else if onuAlarm.LofiStatus == statusCheckOn {
432 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "RAISE_EVENT")
433 } else if onuAlarm.LofiStatus == statusCheckOff {
434 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "CLEAR_EVENT")
435 } else if onuAlarm.LoamiStatus == statusCheckOn {
436 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfPloamEvent, "RAISE_EVENT")
437 } else if onuAlarm.LoamiStatus == statusCheckOff {
438 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfPloamEvent, "CLEAR_EVENT")
439 }
440 return deviceEventName
441}
442
Neha Sharma96b7bf22020-06-15 10:37:32 +0000443func (em *OpenOltEventMgr) onuAlarmIndication(ctx context.Context, onuAlarm *oop.OnuAlarmIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400444 var de voltha.DeviceEvent
Amit Ghosh502056b2020-07-15 09:15:48 +0100445
Devmalya Paulfb990a52019-07-09 10:01:49 -0400446 context := make(map[string]string)
447 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100448 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuAlarm.IntfId), base10)
449 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuAlarm.OnuId), base10)
450 em.populateContextWithSerialDeviceID(context, onuAlarm.IntfId, onuAlarm.OnuId)
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530451
Devmalya Paulfb990a52019-07-09 10:01:49 -0400452 /* Populating device event body */
453 de.Context = context
454 de.ResourceId = deviceID
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530455 de.DeviceEventName = em.getDeviceEventName(onuAlarm)
456
457 switch onuAlarm.LosStatus {
458 case statusCheckOn:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000459 if em.wasLosRaised(ctx, onuAlarm) {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530460 /* No need to raise Onu Los Event as it might have already raised
461 or Onu might have deleted */
462 return nil
463 }
464 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
465 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
466 /* Update onu device with LoS raised state as true */
467 em.handler.onus.Store(onuKey, NewOnuDevice(onuInCache.(*OnuDevice).deviceID, onuInCache.(*OnuDevice).deviceType,
468 onuInCache.(*OnuDevice).serialNumber, onuInCache.(*OnuDevice).onuID, onuInCache.(*OnuDevice).intfID,
khenaidoo106c61a2021-08-11 18:05:46 -0400469 onuInCache.(*OnuDevice).proxyDeviceID, true, onuInCache.(*OnuDevice).adapterEndpoint))
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530470 }
471 case statusCheckOff:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000472 if em.wasLosCleared(ctx, onuAlarm) {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530473 /* No need to clear Onu Los Event as it might have already cleared
474 or Onu might have deleted */
475 return nil
476 }
477 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
478 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
479 /* Update onu device with LoS raised state as false */
480 em.handler.onus.Store(onuKey, NewOnuDevice(onuInCache.(*OnuDevice).deviceID, onuInCache.(*OnuDevice).deviceType,
481 onuInCache.(*OnuDevice).serialNumber, onuInCache.(*OnuDevice).onuID, onuInCache.(*OnuDevice).intfID,
khenaidoo106c61a2021-08-11 18:05:46 -0400482 onuInCache.(*OnuDevice).proxyDeviceID, false, onuInCache.(*OnuDevice).adapterEndpoint))
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530483 }
Devmalya Paulfb990a52019-07-09 10:01:49 -0400484 }
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530485
Devmalya Paulfb990a52019-07-09 10:01:49 -0400486 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400487 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530488 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400489 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000490 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 +0530491 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400492}
493
kesavand7cf3a052020-08-28 12:49:18 +0530494func (em *OpenOltEventMgr) onuActivationIndication(ctx context.Context, eventName string, onuInd *oop.OnuIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400495 var de voltha.DeviceEvent
496 context := make(map[string]string)
497 /* Populating event context */
kesavand7cf3a052020-08-28 12:49:18 +0530498 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuInd.IntfId), base10)
499 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuInd.OnuId), base10)
500 context[ContextOnuFailureReaseon] = onuInd.FailReason.String()
Amit Ghosh502056b2020-07-15 09:15:48 +0100501
kesavand7cf3a052020-08-28 12:49:18 +0530502 em.populateContextWithSerialDeviceID(context, onuInd.IntfId, onuInd.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100503
Devmalya Paulfb990a52019-07-09 10:01:49 -0400504 /* Populating device event body */
505 de.Context = context
506 de.ResourceId = deviceID
kesavand7cf3a052020-08-28 12:49:18 +0530507 de.DeviceEventName = eventName
Devmalya Paulfb990a52019-07-09 10:01:49 -0400508 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400509 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_PON, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530510 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400511 }
kesavand7cf3a052020-08-28 12:49:18 +0530512 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 +0530513 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400514}
515
Neha Sharma96b7bf22020-06-15 10:37:32 +0000516func (em *OpenOltEventMgr) onuLossOmciIndication(ctx context.Context, onuLossOmci *oop.OnuLossOfOmciChannelIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400517 var de voltha.DeviceEvent
518 context := make(map[string]string)
519 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100520 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuLossOmci.IntfId), base10)
521 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuLossOmci.OnuId), base10)
522
523 em.populateContextWithSerialDeviceID(context, onuLossOmci.IntfId, onuLossOmci.OnuId)
524
Devmalya Paulfb990a52019-07-09 10:01:49 -0400525 /* Populating device event body */
526 de.Context = context
527 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530528 if onuLossOmci.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400529 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "RAISE_EVENT")
530 } else {
531 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "CLEAR_EVENT")
532 }
533 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100534 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530535 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400536 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000537 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 +0530538 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400539}
540
Neha Sharma96b7bf22020-06-15 10:37:32 +0000541func (em *OpenOltEventMgr) onuDriftOfWindowIndication(ctx context.Context, onuDriftWindow *oop.OnuDriftOfWindowIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400542 var de voltha.DeviceEvent
543 context := make(map[string]string)
544 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100545 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDriftWindow.IntfId), base10)
546 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuDriftWindow.OnuId), base10)
547 context[ContextOnuDrift] = strconv.FormatUint(uint64(onuDriftWindow.Drift), base10)
548 context[ContextOnuNewEqd] = strconv.FormatUint(uint64(onuDriftWindow.NewEqd), base10)
549
550 em.populateContextWithSerialDeviceID(context, onuDriftWindow.IntfId, onuDriftWindow.OnuId)
551
Devmalya Paulfb990a52019-07-09 10:01:49 -0400552 /* Populating device event body */
553 de.Context = context
554 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530555 if onuDriftWindow.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400556 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "RAISE_EVENT")
557 } else {
558 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "CLEAR_EVENT")
559 }
560 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100561 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530562 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400563 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000564 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 +0530565 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400566}
567
Neha Sharma96b7bf22020-06-15 10:37:32 +0000568func (em *OpenOltEventMgr) onuSignalDegradeIndication(ctx context.Context, onuSignalDegrade *oop.OnuSignalDegradeIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400569 var de voltha.DeviceEvent
570 context := make(map[string]string)
571 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100572 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuSignalDegrade.IntfId), base10)
573 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuSignalDegrade.OnuId), base10)
574 context[ContextOnuInverseBitErrorRate] = strconv.FormatUint(uint64(onuSignalDegrade.InverseBitErrorRate), base10)
575
576 em.populateContextWithSerialDeviceID(context, onuSignalDegrade.IntfId, onuSignalDegrade.OnuId)
577
Devmalya Paulfb990a52019-07-09 10:01:49 -0400578 /* Populating device event body */
579 de.Context = context
580 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530581 if onuSignalDegrade.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400582 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "RAISE_EVENT")
583 } else {
584 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "CLEAR_EVENT")
585 }
586 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100587 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530588 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400589 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000590 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 +0530591 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400592}
593
Neha Sharma96b7bf22020-06-15 10:37:32 +0000594func (em *OpenOltEventMgr) onuSignalsFailIndication(ctx context.Context, onuSignalsFail *oop.OnuSignalsFailureIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400595 var de voltha.DeviceEvent
596 context := make(map[string]string)
597 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100598 em.populateContextWithSerialDeviceID(context, onuSignalsFail.IntfId, onuSignalsFail.OnuId)
599
600 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuSignalsFail.OnuId), base10)
601 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuSignalsFail.IntfId), base10)
602 context[ContextOnuInverseBitErrorRate] = strconv.FormatUint(uint64(onuSignalsFail.InverseBitErrorRate), base10)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400603 /* Populating device event body */
604 de.Context = context
605 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530606 if onuSignalsFail.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400607 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "RAISE_EVENT")
608 } else {
609 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "CLEAR_EVENT")
610 }
611 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100612 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530613 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400614 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000615 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 +0530616 return nil
617}
618
Neha Sharma96b7bf22020-06-15 10:37:32 +0000619func (em *OpenOltEventMgr) onuStartupFailedIndication(ctx context.Context, onuStartupFail *oop.OnuStartupFailureIndication, deviceID string, raisedTs int64) error {
Naga Manjunathf6f74642020-01-13 21:37:28 +0530620 var de voltha.DeviceEvent
621 context := make(map[string]string)
622 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100623 em.populateContextWithSerialDeviceID(context, onuStartupFail.IntfId, onuStartupFail.OnuId)
624
625 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuStartupFail.OnuId), base10)
626 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuStartupFail.IntfId), base10)
Naga Manjunathf6f74642020-01-13 21:37:28 +0530627
628 /* Populating device event body */
629 de.Context = context
630 de.ResourceId = deviceID
631 if onuStartupFail.Status == statusCheckOn {
632 de.DeviceEventName = fmt.Sprintf("%s_%s", onuStartupFailEvent, "RAISE_EVENT")
633 } else {
634 de.DeviceEventName = fmt.Sprintf("%s_%s", onuStartupFailEvent, "CLEAR_EVENT")
635 }
636 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400637 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs); err != nil {
Naga Manjunathf6f74642020-01-13 21:37:28 +0530638 return err
639 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000640 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 +0530641 return nil
642}
643
Neha Sharma96b7bf22020-06-15 10:37:32 +0000644func (em *OpenOltEventMgr) onuLossOfSyncIndication(ctx context.Context, onuLOKI *oop.OnuLossOfKeySyncFailureIndication, deviceID string, raisedTs int64) error {
Naga Manjunath9546b912019-11-28 20:56:20 +0530645 var de voltha.DeviceEvent
646 context := make(map[string]string)
647 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100648 em.populateContextWithSerialDeviceID(context, onuLOKI.IntfId, onuLOKI.OnuId)
649
650 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuLOKI.OnuId), base10)
651 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuLOKI.IntfId), base10)
Naga Manjunath9546b912019-11-28 20:56:20 +0530652 /* Populating device event body */
653 de.Context = context
654 de.ResourceId = deviceID
655 if onuLOKI.Status == statusCheckOn {
656 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "RAISE_EVENT")
657 } else {
658 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "CLEAR_EVENT")
659 }
660
661 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400662 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_SECURITY, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530663 return err
664 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000665 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 +0530666 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400667}
kesavand39e0aa32020-01-28 20:58:50 -0500668
669// oltIntfOperIndication handles Up and Down state of an OLT PON ports
Kent Hagermane6ff1012020-07-14 15:07:53 -0400670func (em *OpenOltEventMgr) oltIntfOperIndication(ctx context.Context, ifindication *oop.IntfOperIndication, deviceID string, raisedTs int64) {
Mahir Gunyel85f61c12021-10-06 11:53:45 -0700671 portNo := plt.IntfIDToPortNo(ifindication.IntfId, voltha.Port_PON_OLT)
khenaidoodc2116e2021-10-19 17:33:19 -0400672 if port, err := em.handler.getPortFromCore(ctx, &ca.PortFilter{
khenaidoo106c61a2021-08-11 18:05:46 -0400673 DeviceId: deviceID,
674 Port: portNo,
675 }); err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700676 logger.Warnw(ctx, "Error while fetching port object", log.Fields{"device-id": deviceID, "err": err})
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400677 } else if port.AdminState != common.AdminState_ENABLED {
678 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 -0400679 return
kesavand39e0aa32020-01-28 20:58:50 -0500680 }
681 /* Populating event context */
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400682 context := map[string]string{ContextOltPonIntfOperState: ifindication.GetOperState()}
kesavand39e0aa32020-01-28 20:58:50 -0500683 /* Populating device event body */
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400684 var de voltha.DeviceEvent
kesavand39e0aa32020-01-28 20:58:50 -0500685 de.Context = context
686 de.ResourceId = deviceID
687
688 if ifindication.GetOperState() == operationStateDown {
689 de.DeviceEventName = fmt.Sprintf("%s_%s", ponIntfDownIndiction, "RAISE_EVENT")
690 } else if ifindication.OperState == operationStateUp {
691 de.DeviceEventName = fmt.Sprintf("%s_%s", ponIntfDownIndiction, "CLEAR_EVENT")
692 }
693 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400694 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
695 _ = 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)
696 return
kesavand39e0aa32020-01-28 20:58:50 -0500697 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000698 logger.Debug(ctx, "sent-olt-intf-oper-status-event-to-kafka")
kesavand39e0aa32020-01-28 20:58:50 -0500699}
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500700
Neha Sharma96b7bf22020-06-15 10:37:32 +0000701func (em *OpenOltEventMgr) onuDeactivationFailureIndication(ctx context.Context, onuDFI *oop.OnuDeactivationFailureIndication, deviceID string, raisedTs int64) error {
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500702 var de voltha.DeviceEvent
703 context := make(map[string]string)
704 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100705 em.populateContextWithSerialDeviceID(context, onuDFI.IntfId, onuDFI.OnuId)
706
707 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuDFI.OnuId), base10)
708 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDFI.IntfId), base10)
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500709 /* Populating device event body */
710 de.Context = context
711 de.ResourceId = deviceID
Devmalya Paula1efa642020-04-20 01:36:43 -0400712 if onuDFI.Status == statusCheckOn {
713 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDeactivationFailureEvent, "RAISE_EVENT")
714 } else {
715 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDeactivationFailureEvent, "CLEAR_EVENT")
716 }
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500717 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400718 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500719 return err
720 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000721 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 -0500722 return nil
723}
Amit Ghosh502056b2020-07-15 09:15:48 +0100724
Neha Sharma96b7bf22020-06-15 10:37:32 +0000725func (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 -0500726 /* Populating event context */
727 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100728 ContextOnuOnuID: strconv.FormatUint(uint64(onuID), base10),
729 ContextOnuPonIntfID: strconv.FormatUint(uint64(intfID), base10),
730 ContextOnuRemoteDefectIndicatorCount: strconv.FormatUint(rdiCount, base10),
Devmalya Paul6f063a62020-02-19 19:19:06 -0500731 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100732 em.populateContextWithSerialDeviceID(context, intfID, onuID)
733
Devmalya Paul6f063a62020-02-19 19:19:06 -0500734 /* Populating device event body */
735 de := &voltha.DeviceEvent{
Devmalya Paula1efa642020-04-20 01:36:43 -0400736 Context: context,
737 ResourceId: deviceID,
738 }
739 if status == statusCheckOn {
740 de.DeviceEventName = fmt.Sprintf("%s_%s", onuRemoteDefectIndication, "RAISE_EVENT")
741 } else {
742 de.DeviceEventName = fmt.Sprintf("%s_%s", onuRemoteDefectIndication, "CLEAR_EVENT")
Devmalya Paul6f063a62020-02-19 19:19:06 -0500743 }
744 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400745 if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Paul6f063a62020-02-19 19:19:06 -0500746 return err
747 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000748 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 -0400749 return nil
750}
751
Neha Sharma96b7bf22020-06-15 10:37:32 +0000752func (em *OpenOltEventMgr) onuItuPonStatsIndication(ctx context.Context, onuIPS *oop.OnuItuPonStatsIndication, deviceID string, raisedTs int64) error {
Devmalya Paula1efa642020-04-20 01:36:43 -0400753 onuDevice, found := em.handler.onus.Load(em.handler.formOnuKey(onuIPS.IntfId, onuIPS.OnuId))
754 if !found {
755 return errors.New("unknown-onu-device")
756 }
757 if onuIPS.GetRdiErrorInd().Status == statusCheckOn {
758 if !onuDevice.(*OnuDevice).rdiRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000759 if err := em.onuRemoteDefectIndication(ctx, onuIPS.OnuId, onuIPS.IntfId, onuIPS.GetRdiErrorInd().RdiErrorCount, statusCheckOn, deviceID, raisedTs); err != nil {
Devmalya Paula1efa642020-04-20 01:36:43 -0400760 return err
761 }
762 onuDevice.(*OnuDevice).rdiRaised = true
763 return nil
764 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000765 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 -0400766 } else {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000767 if err := em.onuRemoteDefectIndication(ctx, onuIPS.OnuId, onuIPS.IntfId, onuIPS.GetRdiErrorInd().RdiErrorCount, statusCheckOff, deviceID, raisedTs); err != nil {
Devmalya Paula1efa642020-04-20 01:36:43 -0400768 return err
769 }
770 onuDevice.(*OnuDevice).rdiRaised = false
771 }
Devmalya Paul41a762d2020-03-01 18:56:54 -0500772 return nil
773}
774
Neha Sharma96b7bf22020-06-15 10:37:32 +0000775func (em *OpenOltEventMgr) onuLossOfGEMChannelDelineationIndication(ctx context.Context, onuGCD *oop.OnuLossOfGEMChannelDelineationIndication, deviceID string, raisedTs int64) error {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500776 /* Populating event context */
777 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100778 ContextOnuOnuID: strconv.FormatUint(uint64(onuGCD.OnuId), base10),
779 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuGCD.IntfId), base10),
780 ContextOnuDelineationErrors: strconv.FormatUint(uint64(onuGCD.DelineationErrors), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500781 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100782 em.populateContextWithSerialDeviceID(context, onuGCD.IntfId, onuGCD.OnuId)
783
Devmalya Paul41a762d2020-03-01 18:56:54 -0500784 /* Populating device event body */
785 de := &voltha.DeviceEvent{
786 Context: context,
787 ResourceId: deviceID,
788 }
789 if onuGCD.Status == statusCheckOn {
790 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfGEMChannelDelineationEvent, "RAISE_EVENT")
791 } else {
792 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfGEMChannelDelineationEvent, "CLEAR_EVENT")
793 }
794 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400795 if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500796 return err
797 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000798 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 -0500799 return nil
800}
801
Neha Sharma96b7bf22020-06-15 10:37:32 +0000802func (em *OpenOltEventMgr) onuPhysicalEquipmentErrorIndication(ctx context.Context, onuErr *oop.OnuPhysicalEquipmentErrorIndication, deviceID string, raisedTs int64) error {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500803 /* Populating event context */
804 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100805 ContextOnuOnuID: strconv.FormatUint(uint64(onuErr.OnuId), base10),
806 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuErr.IntfId), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500807 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100808 em.populateContextWithSerialDeviceID(context, onuErr.IntfId, onuErr.OnuId)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500809 /* Populating device event body */
810 de := &voltha.DeviceEvent{
811 Context: context,
812 ResourceId: deviceID,
813 }
814 if onuErr.Status == statusCheckOn {
815 de.DeviceEventName = fmt.Sprintf("%s_%s", onuPhysicalEquipmentErrorEvent, "RAISE_EVENT")
816 } else {
817 de.DeviceEventName = fmt.Sprintf("%s_%s", onuPhysicalEquipmentErrorEvent, "CLEAR_EVENT")
818 }
819 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400820 if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500821 return err
822 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000823 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 -0500824 return nil
825}
826
Neha Sharma96b7bf22020-06-15 10:37:32 +0000827func (em *OpenOltEventMgr) onuLossOfAcknowledgementIndication(ctx context.Context, onuLOA *oop.OnuLossOfAcknowledgementIndication, deviceID string, raisedTs int64) error {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500828 /* Populating event context */
829 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100830 ContextOnuOnuID: strconv.FormatUint(uint64(onuLOA.OnuId), base10),
831 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuLOA.IntfId), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500832 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100833 em.populateContextWithSerialDeviceID(context, onuLOA.IntfId, onuLOA.OnuId)
834
Devmalya Paul41a762d2020-03-01 18:56:54 -0500835 /* Populating device event body */
836 de := &voltha.DeviceEvent{
837 Context: context,
838 ResourceId: deviceID,
839 }
840 if onuLOA.Status == statusCheckOn {
841 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfAcknowledgementEvent, "RAISE_EVENT")
842 } else {
843 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfAcknowledgementEvent, "CLEAR_EVENT")
844 }
845 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400846 if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500847 return err
848 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000849 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 -0500850 return nil
851}
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400852
Neha Sharma96b7bf22020-06-15 10:37:32 +0000853func (em *OpenOltEventMgr) onuDifferentialReachExceededIndication(ctx context.Context, onuDRE *oop.OnuDifferentialReachExceededIndication, deviceID string, raisedTs int64) error {
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400854 /* Populating event context */
855 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100856 ContextOnuOnuID: strconv.FormatUint(uint64(onuDRE.OnuId), base10),
857 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuDRE.IntfId), base10),
858 ContextOnuDifferentialDistance: strconv.FormatUint(uint64(onuDRE.Distance), base10),
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400859 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100860 em.populateContextWithSerialDeviceID(context, onuDRE.IntfId, onuDRE.OnuId)
861
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400862 /* Populating device event body */
863 de := &voltha.DeviceEvent{
864 Context: context,
865 ResourceId: deviceID,
866 }
867 if onuDRE.Status == statusCheckOn {
868 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDifferentialReachExceededEvent, "RAISE_EVENT")
869 } else {
870 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDifferentialReachExceededEvent, "CLEAR_EVENT")
871 }
872 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400873 if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400874 return err
875 }
Girish Kumara1ea2aa2020-08-19 18:14:22 +0000876 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 -0400877 return nil
878}