blob: 3740cf4eec8b0e8b9ed3b86aac4816d9f0d54dcb [file] [log] [blame]
Devmalya Paulfb990a52019-07-09 10:01:49 -04001/*
Joey Armstronga6af1522023-01-17 16:06:16 -05002 * Copyright 2018-2023 Open Networking Foundation (ONF) and the ONF Contributors
Devmalya Paulfb990a52019-07-09 10:01:49 -04003
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"
Gustavo Silva41af9122022-10-11 11:05:13 -030044 oltRebootFailedEvent = "OLT_REBOOT_FAILED"
Gamze Abaka07868a52020-12-17 14:19:28 +000045 oltCommFailure = "OLT_COMMUNICATION_FAILURE"
Devmalya Paul41a762d2020-03-01 18:56:54 -050046 oltIndicationDown = "OLT_DOWN_INDICATION"
47 onuDyingGaspEvent = "ONU_DYING_GASP"
48 onuSignalsFailEvent = "ONU_SIGNALS_FAIL"
49 onuStartupFailEvent = "ONU_STARTUP_FAIL"
50 onuSignalDegradeEvent = "ONU_SIGNAL_DEGRADE"
51 onuDriftOfWindowEvent = "ONU_DRIFT_OF_WINDOW"
52 onuActivationFailEvent = "ONU_ACTIVATION_FAIL"
Devmalya Paul41a762d2020-03-01 18:56:54 -050053 onuLossOmciEvent = "ONU_LOSS_OF_OMCI_CHANNEL"
54 onuLossOfKeySyncEvent = "ONU_LOSS_OF_KEY_SYNC"
55 onuLossOfFrameEvent = "ONU_LOSS_OF_FRAME"
56 onuLossOfPloamEvent = "ONU_LOSS_OF_PLOAM"
57 ponIntfDownIndiction = "OLT_PON_INTERFACE_DOWN"
58 onuDeactivationFailureEvent = "ONU_DEACTIVATION_FAILURE"
59 onuRemoteDefectIndication = "ONU_REMOTE_DEFECT"
60 onuLossOfGEMChannelDelineationEvent = "ONU_LOSS_OF_GEM_CHANNEL_DELINEATION"
61 onuPhysicalEquipmentErrorEvent = "ONU_PHYSICAL_EQUIPMENT_ERROR"
62 onuLossOfAcknowledgementEvent = "ONU_LOSS_OF_ACKNOWLEDGEMENT"
Devmalya Pauleb5294e2020-03-19 03:01:39 -040063 onuDifferentialReachExceededEvent = "ONU_DIFFERENTIAL_REACH_EXCEEDED"
Devmalya Paulfb990a52019-07-09 10:01:49 -040064)
65
66const (
Naga Manjunath9546b912019-11-28 20:56:20 +053067 // statusCheckOn represents status check On
68 statusCheckOn = "on"
69 // statusCheckOff represents status check Off
70 statusCheckOff = "off"
71 // operationStateUp represents operation state Up
72 operationStateUp = "up"
73 // operationStateDown represents operation state Down
74 operationStateDown = "down"
75 // base10 represents base 10 conversion
76 base10 = 10
77)
78
Amit Ghosh502056b2020-07-15 09:15:48 +010079const (
Gamze Abaka07868a52020-12-17 14:19:28 +000080 // ContextOltAdminState is for the admin state of the Olt in the context of the event
81 ContextOltAdminState = "admin-state"
82 // ContextOltConnectState is for the connect state of the Olt in the context of the event
83 ContextOltConnectState = "connect-state"
Gustavo Silva41af9122022-10-11 11:05:13 -030084 // ContextOltFailureReason is to report the reason of an operation failure in the Olt
85 ContextOltFailureReason = "failure-reason"
Amit Ghosh502056b2020-07-15 09:15:48 +010086 // ContextOltOperState is for the operational state of the Olt in the context of the event
87 ContextOltOperState = "oper-state"
Gamze Abaka07868a52020-12-17 14:19:28 +000088 // ContextOltVendor is for the Olt vendor in the context of the event
89 ContextOltVendor = "vendor"
90 // ContextOltType is for the Olt type in the context of the event
91 ContextOltType = "type"
92 // ContextOltParentID is for the Olt parent id in the context of the event
93 ContextOltParentID = "parent-id"
94 // ContextOltParentPortNo is for the Olt parent port no in the context of the event
95 ContextOltParentPortNo = "parent-port-no"
96 // ContextOltFirmwareVersion is for the Olt firmware version in the context of the event
97 ContextOltFirmwareVersion = "firmware-version"
98 // ContextOltHardwareVersion is for the Olt hardware version in the context of the event
99 ContextOltHardwareVersion = "hardware-version"
100 // ContextOltSerialNumber is for the serial number of the OLT
101 ContextOltSerialNumber = "serial-number"
102 // ContextOltMacAddress is for the OLT mac address
103 ContextOltMacAddress = "mac-address"
104 // ContextDeviceID is for the device id in the context of the event
105 ContextDeviceID = "id"
Amit Ghosh502056b2020-07-15 09:15:48 +0100106 // ContextOnuOnuID is for the Onu Id in the context of the event
107 ContextOnuOnuID = "onu-id"
108 // ContextOnuPonIntfID is for the PON interface Id on which the Onu Event occurred
109 ContextOnuPonIntfID = "intf-id"
110 // ContextOnuSerialNumber is for the serial number of the ONU
111 ContextOnuSerialNumber = "serial-number"
112 // ContextOnuDeviceID is for the device id of the ONU generated by VOLTHA
113 ContextOnuDeviceID = "onu-device-id"
114 // ContextOltPonIntfID is for the PON interface Id on an OLT event
115 ContextOltPonIntfID = "intf-id"
116 // ContextOnuFailureReaseon is for the reason of failure of/at ONU indicated by the event
117 ContextOnuFailureReaseon = "fail-reason"
118 // ContextOnuDrift is for the drift of an ONU in the context of an event
119 ContextOnuDrift = "drift"
120 // ContextOnuNewEqd is for the New Eqd of an ONU in the context of an event
121 ContextOnuNewEqd = "new-eqd"
122 // ContextOnuInverseBitErrorRate is for the inverse bit error rate in the context of an ONU event
123 ContextOnuInverseBitErrorRate = "inverse-bit-error-rate"
124 // ContextOltPonIntfOperState is for the operational state of a PON port in the context of an OLT event
125 ContextOltPonIntfOperState = "oper-state"
126 // ContextOnuRemoteDefectIndicatorCount is for the rdi in the context of an ONU event
127 ContextOnuRemoteDefectIndicatorCount = "rdi-count"
128 // ContextOnuDelineationErrors is for the delineation errors if present in an ONU events context
129 ContextOnuDelineationErrors = "delineation-errors"
130 // ContextOnuDifferentialDistance is for the differential distance in an ONU event context
131 ContextOnuDifferentialDistance = "differential-distance"
ssiddiqui04386ee2021-08-23 21:58:25 +0530132 // ContextOltPonTechnology is to indicate the pon-technology type, ie, 'GPON' or 'XGS-PON' (TODO check for combo?)
133 ContextOltPonTechnology = "pon-technology"
134 // ContextOltPortLabel is to indicate the string label of the pon-port, example: pon-0
135 ContextOltPortLabel = "port-label"
Amit Ghosh502056b2020-07-15 09:15:48 +0100136)
137
Devmalya Paulfb990a52019-07-09 10:01:49 -0400138// OpenOltEventMgr struct contains
139type OpenOltEventMgr struct {
Himani Chawlacd407802020-12-10 12:08:59 +0530140 eventProxy eventif.EventProxy
Devmalya Paul90ca3012019-09-02 21:55:45 -0400141 handler *DeviceHandler
Devmalya Paulfb990a52019-07-09 10:01:49 -0400142}
143
144// 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 +0530145func NewEventMgr(eventProxy eventif.EventProxy, handler *DeviceHandler) *OpenOltEventMgr {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400146 var em OpenOltEventMgr
147 em.eventProxy = eventProxy
Devmalya Paul90ca3012019-09-02 21:55:45 -0400148 em.handler = handler
Devmalya Paulfb990a52019-07-09 10:01:49 -0400149 return &em
150}
151
152// ProcessEvents is function to process and publish OpenOLT event
Devmalya Paul41a762d2020-03-01 18:56:54 -0500153// nolint: gocyclo
Kent Hagermane6ff1012020-07-14 15:07:53 -0400154func (em *OpenOltEventMgr) ProcessEvents(ctx context.Context, alarmInd *oop.AlarmIndication, deviceID string, raisedTs int64) {
Naga Manjunath9546b912019-11-28 20:56:20 +0530155 var err error
Devmalya Paulfb990a52019-07-09 10:01:49 -0400156 switch alarmInd.Data.(type) {
157 case *oop.AlarmIndication_LosInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000158 logger.Debugw(ctx, "received-los-indication", log.Fields{"alarm-ind": alarmInd})
159 err = em.oltLosIndication(ctx, alarmInd.GetLosInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400160 case *oop.AlarmIndication_OnuAlarmInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000161 logger.Debugw(ctx, "received-onu-alarm-indication ", log.Fields{"alarm-ind": alarmInd})
162 err = em.onuAlarmIndication(ctx, alarmInd.GetOnuAlarmInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400163 case *oop.AlarmIndication_DyingGaspInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000164 logger.Debugw(ctx, "received-dying-gasp-indication", log.Fields{"alarm-ind": alarmInd})
165 err = em.onuDyingGaspIndication(ctx, alarmInd.GetDyingGaspInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400166 case *oop.AlarmIndication_OnuLossOmciInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000167 logger.Debugw(ctx, "received-onu-loss-omci-indication ", log.Fields{"alarm-ind": alarmInd})
168 err = em.onuLossOmciIndication(ctx, alarmInd.GetOnuLossOmciInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400169 case *oop.AlarmIndication_OnuDriftOfWindowInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000170 logger.Debugw(ctx, "received-onu-drift-of-window-indication ", log.Fields{"alarm-ind": alarmInd})
171 err = em.onuDriftOfWindowIndication(ctx, alarmInd.GetOnuDriftOfWindowInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400172 case *oop.AlarmIndication_OnuSignalDegradeInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000173 logger.Debugw(ctx, "received-onu-signal-degrade-indication ", log.Fields{"alarm-ind": alarmInd})
174 err = em.onuSignalDegradeIndication(ctx, alarmInd.GetOnuSignalDegradeInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400175 case *oop.AlarmIndication_OnuSignalsFailInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000176 logger.Debugw(ctx, "received-onu-signal-fail-indication ", log.Fields{"alarm-ind": alarmInd})
177 err = em.onuSignalsFailIndication(ctx, alarmInd.GetOnuSignalsFailInd(), deviceID, raisedTs)
Naga Manjunathf6f74642020-01-13 21:37:28 +0530178 case *oop.AlarmIndication_OnuStartupFailInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000179 logger.Debugw(ctx, "received-onu-startup-fail-indication ", log.Fields{"alarm-ind": alarmInd})
180 err = em.onuStartupFailedIndication(ctx, alarmInd.GetOnuStartupFailInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400181 case *oop.AlarmIndication_OnuTiwiInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000182 logger.Debugw(ctx, "received-onu-transmission-warning-indication ", log.Fields{"alarm-ind": alarmInd})
183 logger.Warnw(ctx, "not-implemented-yet", log.Fields{"alarm-ind": "Onu-Transmission-indication"})
Naga Manjunath9546b912019-11-28 20:56:20 +0530184 case *oop.AlarmIndication_OnuLossOfSyncFailInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000185 logger.Debugw(ctx, "received-onu-loss-of-sync-fail-indication ", log.Fields{"alarm-ind": alarmInd})
186 err = em.onuLossOfSyncIndication(ctx, alarmInd.GetOnuLossOfSyncFailInd(), deviceID, raisedTs)
Naga Manjunath9546b912019-11-28 20:56:20 +0530187 case *oop.AlarmIndication_OnuItuPonStatsInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000188 logger.Debugw(ctx, "received-onu-itu-pon-stats-indication ", log.Fields{"alarm-ind": alarmInd})
189 err = em.onuItuPonStatsIndication(ctx, alarmInd.GetOnuItuPonStatsInd(), deviceID, raisedTs)
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500190 case *oop.AlarmIndication_OnuDeactivationFailureInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000191 logger.Debugw(ctx, "received-onu-deactivation-failure-indication ", log.Fields{"alarm-ind": alarmInd})
192 err = em.onuDeactivationFailureIndication(ctx, alarmInd.GetOnuDeactivationFailureInd(), deviceID, raisedTs)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500193 case *oop.AlarmIndication_OnuLossGemDelineationInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000194 logger.Debugw(ctx, "received-onu-loss-of-gem-channel-delineation-indication ", log.Fields{"alarm-ind": alarmInd})
195 err = em.onuLossOfGEMChannelDelineationIndication(ctx, alarmInd.GetOnuLossGemDelineationInd(), deviceID, raisedTs)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500196 case *oop.AlarmIndication_OnuPhysicalEquipmentErrorInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000197 logger.Debugw(ctx, "received-onu-physical-equipment-error-indication ", log.Fields{"alarm-ind": alarmInd})
198 err = em.onuPhysicalEquipmentErrorIndication(ctx, alarmInd.GetOnuPhysicalEquipmentErrorInd(), deviceID, raisedTs)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500199 case *oop.AlarmIndication_OnuLossOfAckInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000200 logger.Debugw(ctx, "received-onu-loss-of-acknowledgement-indication ", log.Fields{"alarm-ind": alarmInd})
201 err = em.onuLossOfAcknowledgementIndication(ctx, alarmInd.GetOnuLossOfAckInd(), deviceID, raisedTs)
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400202 case *oop.AlarmIndication_OnuDiffReachExceededInd:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000203 logger.Debugw(ctx, "received-onu-differential-reach-exceeded-indication ", log.Fields{"alarm-ind": alarmInd})
204 err = em.onuDifferentialReachExceededIndication(ctx, alarmInd.GetOnuDiffReachExceededInd(), deviceID, raisedTs)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400205 default:
Thomas Lee S94109f12020-03-03 16:39:29 +0530206 err = olterrors.NewErrInvalidValue(log.Fields{"indication-type": alarmInd}, nil)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400207 }
Naga Manjunath9546b912019-11-28 20:56:20 +0530208 if err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400209 _ = olterrors.NewErrCommunication("publish-message", log.Fields{"indication-type": alarmInd}, err).LogAt(log.WarnLevel)
Naga Manjunath9546b912019-11-28 20:56:20 +0530210 }
Devmalya Paulfb990a52019-07-09 10:01:49 -0400211}
212
Gamze Abaka07868a52020-12-17 14:19:28 +0000213func (em *OpenOltEventMgr) oltCommunicationEvent(ctx context.Context, device *voltha.Device, raisedTs int64) {
214 if device == nil {
215 logger.Warn(ctx, "device-is-nil-can't-send-olt-communication-failure-event")
216 return
217 }
218 var de voltha.DeviceEvent
219 context := make(map[string]string)
220 context[ContextOltOperState] = device.OperStatus.String()
221 context[ContextOltAdminState] = device.AdminState.String()
222 context[ContextOltVendor] = device.Vendor
223 context[ContextOltConnectState] = device.ConnectStatus.String()
224 context[ContextOltType] = device.Type
225 context[ContextOltParentID] = device.ParentId
226 context[ContextOltParentPortNo] = fmt.Sprintf("%d", device.ParentPortNo)
227 context[ContextDeviceID] = device.Id
228 context[ContextOltFirmwareVersion] = device.FirmwareVersion
229 context[ContextOltHardwareVersion] = device.HardwareVersion
230 context[ContextOltSerialNumber] = device.SerialNumber
231 context[ContextOltMacAddress] = device.MacAddress
232 de.Context = context
233 de.ResourceId = device.Id
234
235 if device.ConnectStatus == voltha.ConnectStatus_UNREACHABLE {
236 de.DeviceEventName = fmt.Sprintf("%s_%s", oltCommFailure, "RAISE_EVENT")
237 } else {
238 de.DeviceEventName = fmt.Sprintf("%s_%s", oltCommFailure, "CLEAR_EVENT")
239 }
240
241 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
242 logger.Errorw(ctx, "failed-to-send-olt-comm-failure-event", log.Fields{"err": err})
243 }
244 logger.Debugw(ctx, "olt-comm-failure-event-sent-to-kafka",
245 log.Fields{
246 "device-id": device.Id,
247 "connect-status": device.ConnectStatus,
248 })
249}
250
Daniele Rossi051466a2019-07-26 13:39:37 +0000251// oltUpDownIndication handles Up and Down state of an OLT
Neha Sharma96b7bf22020-06-15 10:37:32 +0000252func (em *OpenOltEventMgr) oltUpDownIndication(ctx context.Context, oltIndication *oop.OltIndication, deviceID string, raisedTs int64) error {
Daniele Rossi051466a2019-07-26 13:39:37 +0000253 var de voltha.DeviceEvent
254 context := make(map[string]string)
255 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100256 context[ContextOltOperState] = oltIndication.OperState
Daniele Rossi051466a2019-07-26 13:39:37 +0000257 /* Populating device event body */
258 de.Context = context
259 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530260 if oltIndication.OperState == operationStateDown {
Daniele Rossi051466a2019-07-26 13:39:37 +0000261 de.DeviceEventName = fmt.Sprintf("%s_%s", oltIndicationDown, "RAISE_EVENT")
Naga Manjunath9546b912019-11-28 20:56:20 +0530262 } else if oltIndication.OperState == operationStateUp {
Daniele Rossi051466a2019-07-26 13:39:37 +0000263 de.DeviceEventName = fmt.Sprintf("%s_%s", oltIndicationDown, "CLEAR_EVENT")
264 }
265 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400266 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000267 return olterrors.NewErrCommunication("send-olt-event", log.Fields{"device-id": deviceID}, err)
Daniele Rossi051466a2019-07-26 13:39:37 +0000268 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000269 logger.Debugw(ctx, "olt-updown-event-sent-to-kafka", log.Fields{})
Naga Manjunath9546b912019-11-28 20:56:20 +0530270 return nil
Daniele Rossi051466a2019-07-26 13:39:37 +0000271}
272
Devmalya Paulfb990a52019-07-09 10:01:49 -0400273// OnuDiscoveryIndication is an exported method to handle ONU discovery event
Neha Sharma96b7bf22020-06-15 10:37:32 +0000274func (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 -0400275 var de voltha.DeviceEvent
276 context := make(map[string]string)
277 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100278 context[ContextOnuOnuID] = strconv.FormatUint(uint64(OnuID), base10)
279 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDisc.IntfId), base10)
280 context[ContextOnuSerialNumber] = serialNumber
281 context[ContextOnuDeviceID] = onuDeviceID
ssiddiqui04386ee2021-08-23 21:58:25 +0530282 context[ContextOltPonTechnology] = em.handler.getPonTechnology(onuDisc.IntfId)
283 context[ContextOltPortLabel], _ = GetportLabel(onuDisc.GetIntfId(), voltha.Port_PON_OLT)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400284 /* Populating device event body */
285 de.Context = context
Amit Ghosh75f0e292020-05-14 11:31:54 +0100286 de.ResourceId = oltDeviceID
Devmalya Paulfb990a52019-07-09 10:01:49 -0400287 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDiscoveryEvent, "RAISE_EVENT")
288 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530289 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_PON, raisedTs, onuDeviceID); err != nil {
Shrey Baid26912972020-04-16 21:02:31 +0530290 return olterrors.NewErrCommunication("send-onu-discovery-event",
291 log.Fields{
292 "serial-number": serialNumber,
293 "intf-id": onuDisc.IntfId}, err)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400294 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000295 logger.Debugw(ctx, "onu-discovery-event-sent-to-kafka",
Shrey Baid26912972020-04-16 21:02:31 +0530296 log.Fields{
297 "serial-number": serialNumber,
298 "intf-id": onuDisc.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530299 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400300}
301
Neha Sharma96b7bf22020-06-15 10:37:32 +0000302func (em *OpenOltEventMgr) oltLosIndication(ctx context.Context, oltLos *oop.LosIndication, deviceID string, raisedTs int64) error {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530303 var err error = nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400304 var de voltha.DeviceEvent
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530305 var alarmInd oop.OnuAlarmIndication
Mahir Gunyel85f61c12021-10-06 11:53:45 -0700306 ponIntdID := plt.PortNoToIntfID(oltLos.IntfId, voltha.Port_PON_OLT)
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530307
Devmalya Paulfb990a52019-07-09 10:01:49 -0400308 context := make(map[string]string)
309 /* Populating event context */
yasin sapli0b242942021-10-11 08:51:16 +0000310 context[ContextOltPonIntfID] = strconv.FormatUint(uint64(ponIntdID), base10)
Abhilash Laxmeshwar42b58242021-11-24 19:27:25 +0530311 context[ContextOltPortLabel], _ = GetportLabel(oltLos.IntfId, voltha.Port_PON_OLT)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400312 /* Populating device event body */
313 de.Context = context
314 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530315 if oltLos.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400316 de.DeviceEventName = fmt.Sprintf("%s_%s", oltLosEvent, "RAISE_EVENT")
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530317
318 /* When PON cable disconnected from OLT, it was expected OnuAlarmIndication
319 with "los_status: on" should be raised for each Onu connected to the PON
320 but BAL does not raise this Alarm hence manually sending OnuLosRaise event
321 for all the ONU's connected to PON on receiving LoSIndication for PON */
322 em.handler.onus.Range(func(Onukey interface{}, onuInCache interface{}) bool {
323 if onuInCache.(*OnuDevice).intfID == ponIntdID {
324 alarmInd.IntfId = ponIntdID
325 alarmInd.OnuId = onuInCache.(*OnuDevice).onuID
326 alarmInd.LosStatus = statusCheckOn
Neha Sharma96b7bf22020-06-15 10:37:32 +0000327 err = em.onuAlarmIndication(ctx, &alarmInd, deviceID, raisedTs)
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530328 }
329 return true
330 })
331 if err != nil {
332 /* Return if any error encountered while processing ONU LoS Event*/
333 return err
334 }
Devmalya Paulfb990a52019-07-09 10:01:49 -0400335 } else {
336 de.DeviceEventName = fmt.Sprintf("%s_%s", oltLosEvent, "CLEAR_EVENT")
337 }
338 /* Send event to KAFKA */
Andrea Campanella4dea6312021-02-23 10:06:18 +0100339 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530340 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400341 }
yasin sapli0b242942021-10-11 08:51:16 +0000342 logger.Debugw(ctx, "olt-los-event-sent-to-kafka", log.Fields{"intf-id": ponIntdID})
Naga Manjunath9546b912019-11-28 20:56:20 +0530343 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400344}
Gustavo Silva41af9122022-10-11 11:05:13 -0300345func (em *OpenOltEventMgr) oltRebootFailedEvent(ctx context.Context, deviceID string, reason string, raisedTs int64) error {
346 de := voltha.DeviceEvent{
347 Context: map[string]string{ContextOltFailureReason: "olt-reboot-failed"},
348 ResourceId: deviceID,
349 DeviceEventName: fmt.Sprintf("%s_%s", oltRebootFailedEvent, "RAISE_EVENT")}
350 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT,
351 raisedTs); err != nil {
352 return olterrors.NewErrCommunication("send-olt-reboot-failed-event", log.Fields{
353 "device-id": deviceID, "raised-ts": raisedTs}, err)
354 }
355 logger.Debugw(ctx, "olt-reboot-failed-event-sent-to-kafka", log.Fields{
356 "device-id": deviceID, "raised-ts": raisedTs})
357 return nil
358}
Devmalya Paulfb990a52019-07-09 10:01:49 -0400359
kesavand0ef592c2022-03-16 12:34:24 +0530360func (em *OpenOltEventMgr) populateContextWithSerialDeviceID(context map[string]string, intfID, onuID uint32) string {
Amit Ghosh502056b2020-07-15 09:15:48 +0100361 var serialNumber = ""
362 var onuDeviceID = ""
363 onu := em.handler.formOnuKey(intfID, onuID)
Naga Manjunatha8dc9372019-10-31 23:01:18 +0530364 if onu, ok := em.handler.onus.Load(onu); ok {
365 serialNumber = onu.(*OnuDevice).serialNumber
Amit Ghosh502056b2020-07-15 09:15:48 +0100366 onuDeviceID = onu.(*OnuDevice).deviceID
Devmalya Paul90ca3012019-09-02 21:55:45 -0400367 }
Amit Ghosh502056b2020-07-15 09:15:48 +0100368
ssiddiqui04386ee2021-08-23 21:58:25 +0530369 context[ContextOltPortLabel], _ = GetportLabel(intfID, voltha.Port_PON_OLT)
Amit Ghosh502056b2020-07-15 09:15:48 +0100370 context[ContextOnuSerialNumber] = serialNumber
371 context[ContextOnuDeviceID] = onuDeviceID
kesavand0ef592c2022-03-16 12:34:24 +0530372 return onuDeviceID
Amit Ghosh502056b2020-07-15 09:15:48 +0100373}
374
375func (em *OpenOltEventMgr) onuDyingGaspIndication(ctx context.Context, dgi *oop.DyingGaspIndication, deviceID string, raisedTs int64) error {
376 var de voltha.DeviceEvent
377 context := make(map[string]string)
378 /* Populating event context */
kesavand0ef592c2022-03-16 12:34:24 +0530379 onuDeviceID := em.populateContextWithSerialDeviceID(context, dgi.IntfId, dgi.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100380
381 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(dgi.IntfId), base10)
382 context[ContextOnuOnuID] = strconv.FormatUint(uint64(dgi.OnuId), base10)
383
Devmalya Paulfb990a52019-07-09 10:01:49 -0400384 /* Populating device event body */
385 de.Context = context
386 de.ResourceId = deviceID
Thomas Lee Sf68399e2020-02-11 15:41:38 +0530387 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDyingGaspEvent, "EVENT")
Devmalya Paulfb990a52019-07-09 10:01:49 -0400388 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530389 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530390 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400391 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000392 logger.Debugw(ctx, "onu-dying-gasp-event-sent-to-kafka", log.Fields{"intf-id": dgi.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530393 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400394}
395
Joey Armstrong3f0e2422023-07-05 18:25:41 -0400396// wasLosRaised checks whether los raised already. If already raised returns true else false
Neha Sharma96b7bf22020-06-15 10:37:32 +0000397func (em *OpenOltEventMgr) wasLosRaised(ctx context.Context, onuAlarm *oop.OnuAlarmIndication) bool {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530398 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
399 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000400 logger.Debugw(ctx, "onu-device-found-in-cache.", log.Fields{"intfID": onuAlarm.IntfId, "onuID": onuAlarm.OnuId})
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530401
402 if onuAlarm.LosStatus == statusCheckOn {
403 if onuInCache.(*OnuDevice).losRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000404 logger.Warnw(ctx, "onu-los-raised-already", log.Fields{"onu_id": onuAlarm.OnuId,
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530405 "intf_id": onuAlarm.IntfId, "LosStatus": onuAlarm.LosStatus})
406 return true
407 }
408 return false
409 }
410 }
411 return true
412}
413
Joey Armstrong3f0e2422023-07-05 18:25:41 -0400414// wasLosCleared checks whether los cleared already. If already cleared returns true else false
Neha Sharma96b7bf22020-06-15 10:37:32 +0000415func (em *OpenOltEventMgr) wasLosCleared(ctx context.Context, onuAlarm *oop.OnuAlarmIndication) bool {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530416 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
417 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000418 logger.Debugw(ctx, "onu-device-found-in-cache.", log.Fields{"intfID": onuAlarm.IntfId, "onuID": onuAlarm.OnuId})
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530419
420 if onuAlarm.LosStatus == statusCheckOff {
421 if !onuInCache.(*OnuDevice).losRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000422 logger.Warnw(ctx, "onu-los-cleared-already", log.Fields{"onu_id": onuAlarm.OnuId,
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530423 "intf_id": onuAlarm.IntfId, "LosStatus": onuAlarm.LosStatus})
424 return true
425 }
426 return false
427 }
428 }
429 return true
430}
431
432func (em *OpenOltEventMgr) getDeviceEventName(onuAlarm *oop.OnuAlarmIndication) string {
433 var deviceEventName string
434 if onuAlarm.LosStatus == statusCheckOn {
435 deviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "RAISE_EVENT")
436 } else if onuAlarm.LosStatus == statusCheckOff {
437 deviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "CLEAR_EVENT")
438 } else if onuAlarm.LobStatus == statusCheckOn {
439 deviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "RAISE_EVENT")
440 } else if onuAlarm.LobStatus == statusCheckOff {
441 deviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "CLEAR_EVENT")
442 } else if onuAlarm.LopcMissStatus == statusCheckOn {
443 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "RAISE_EVENT")
444 } else if onuAlarm.LopcMissStatus == statusCheckOff {
445 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "CLEAR_EVENT")
446 } else if onuAlarm.LopcMicErrorStatus == statusCheckOn {
447 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "RAISE_EVENT")
448 } else if onuAlarm.LopcMicErrorStatus == statusCheckOff {
449 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "CLEAR_EVENT")
450 } else if onuAlarm.LofiStatus == statusCheckOn {
451 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "RAISE_EVENT")
452 } else if onuAlarm.LofiStatus == statusCheckOff {
453 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "CLEAR_EVENT")
454 } else if onuAlarm.LoamiStatus == statusCheckOn {
455 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfPloamEvent, "RAISE_EVENT")
456 } else if onuAlarm.LoamiStatus == statusCheckOff {
457 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfPloamEvent, "CLEAR_EVENT")
458 }
459 return deviceEventName
460}
461
Neha Sharma96b7bf22020-06-15 10:37:32 +0000462func (em *OpenOltEventMgr) onuAlarmIndication(ctx context.Context, onuAlarm *oop.OnuAlarmIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400463 var de voltha.DeviceEvent
Amit Ghosh502056b2020-07-15 09:15:48 +0100464
Devmalya Paulfb990a52019-07-09 10:01:49 -0400465 context := make(map[string]string)
466 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100467 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuAlarm.IntfId), base10)
468 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuAlarm.OnuId), base10)
kesavand0ef592c2022-03-16 12:34:24 +0530469 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuAlarm.IntfId, onuAlarm.OnuId)
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530470
Devmalya Paulfb990a52019-07-09 10:01:49 -0400471 /* Populating device event body */
472 de.Context = context
473 de.ResourceId = deviceID
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530474 de.DeviceEventName = em.getDeviceEventName(onuAlarm)
475
476 switch onuAlarm.LosStatus {
477 case statusCheckOn:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000478 if em.wasLosRaised(ctx, onuAlarm) {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530479 /* No need to raise Onu Los Event as it might have already raised
480 or Onu might have deleted */
481 return nil
482 }
483 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
484 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
485 /* Update onu device with LoS raised state as true */
486 em.handler.onus.Store(onuKey, NewOnuDevice(onuInCache.(*OnuDevice).deviceID, onuInCache.(*OnuDevice).deviceType,
487 onuInCache.(*OnuDevice).serialNumber, onuInCache.(*OnuDevice).onuID, onuInCache.(*OnuDevice).intfID,
khenaidoo106c61a2021-08-11 18:05:46 -0400488 onuInCache.(*OnuDevice).proxyDeviceID, true, onuInCache.(*OnuDevice).adapterEndpoint))
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530489 }
490 case statusCheckOff:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000491 if em.wasLosCleared(ctx, onuAlarm) {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530492 /* No need to clear Onu Los Event as it might have already cleared
493 or Onu might have deleted */
494 return nil
495 }
496 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
497 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
498 /* Update onu device with LoS raised state as false */
499 em.handler.onus.Store(onuKey, NewOnuDevice(onuInCache.(*OnuDevice).deviceID, onuInCache.(*OnuDevice).deviceType,
500 onuInCache.(*OnuDevice).serialNumber, onuInCache.(*OnuDevice).onuID, onuInCache.(*OnuDevice).intfID,
khenaidoo106c61a2021-08-11 18:05:46 -0400501 onuInCache.(*OnuDevice).proxyDeviceID, false, onuInCache.(*OnuDevice).adapterEndpoint))
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530502 }
Devmalya Paulfb990a52019-07-09 10:01:49 -0400503 }
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530504
Devmalya Paulfb990a52019-07-09 10:01:49 -0400505 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530506 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530507 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400508 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000509 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 +0530510 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400511}
512
kesavand7cf3a052020-08-28 12:49:18 +0530513func (em *OpenOltEventMgr) onuActivationIndication(ctx context.Context, eventName string, onuInd *oop.OnuIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400514 var de voltha.DeviceEvent
515 context := make(map[string]string)
516 /* Populating event context */
kesavand7cf3a052020-08-28 12:49:18 +0530517 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuInd.IntfId), base10)
518 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuInd.OnuId), base10)
519 context[ContextOnuFailureReaseon] = onuInd.FailReason.String()
Amit Ghosh502056b2020-07-15 09:15:48 +0100520
kesavand0ef592c2022-03-16 12:34:24 +0530521 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuInd.IntfId, onuInd.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100522
Devmalya Paulfb990a52019-07-09 10:01:49 -0400523 /* Populating device event body */
524 de.Context = context
525 de.ResourceId = deviceID
kesavand7cf3a052020-08-28 12:49:18 +0530526 de.DeviceEventName = eventName
Devmalya Paulfb990a52019-07-09 10:01:49 -0400527 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530528 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_PON, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530529 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400530 }
kesavand7cf3a052020-08-28 12:49:18 +0530531 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 +0530532 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400533}
534
Neha Sharma96b7bf22020-06-15 10:37:32 +0000535func (em *OpenOltEventMgr) onuLossOmciIndication(ctx context.Context, onuLossOmci *oop.OnuLossOfOmciChannelIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400536 var de voltha.DeviceEvent
537 context := make(map[string]string)
538 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100539 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuLossOmci.IntfId), base10)
540 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuLossOmci.OnuId), base10)
541
kesavand0ef592c2022-03-16 12:34:24 +0530542 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuLossOmci.IntfId, onuLossOmci.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100543
Devmalya Paulfb990a52019-07-09 10:01:49 -0400544 /* Populating device event body */
545 de.Context = context
546 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530547 if onuLossOmci.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400548 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "RAISE_EVENT")
549 } else {
550 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "CLEAR_EVENT")
551 }
552 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530553 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530554 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400555 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000556 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 +0530557 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400558}
559
Neha Sharma96b7bf22020-06-15 10:37:32 +0000560func (em *OpenOltEventMgr) onuDriftOfWindowIndication(ctx context.Context, onuDriftWindow *oop.OnuDriftOfWindowIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400561 var de voltha.DeviceEvent
562 context := make(map[string]string)
563 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100564 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDriftWindow.IntfId), base10)
565 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuDriftWindow.OnuId), base10)
566 context[ContextOnuDrift] = strconv.FormatUint(uint64(onuDriftWindow.Drift), base10)
567 context[ContextOnuNewEqd] = strconv.FormatUint(uint64(onuDriftWindow.NewEqd), base10)
568
kesavand0ef592c2022-03-16 12:34:24 +0530569 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuDriftWindow.IntfId, onuDriftWindow.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100570
Devmalya Paulfb990a52019-07-09 10:01:49 -0400571 /* Populating device event body */
572 de.Context = context
573 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530574 if onuDriftWindow.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400575 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "RAISE_EVENT")
576 } else {
577 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "CLEAR_EVENT")
578 }
579 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530580 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530581 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400582 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000583 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 +0530584 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400585}
586
Neha Sharma96b7bf22020-06-15 10:37:32 +0000587func (em *OpenOltEventMgr) onuSignalDegradeIndication(ctx context.Context, onuSignalDegrade *oop.OnuSignalDegradeIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400588 var de voltha.DeviceEvent
589 context := make(map[string]string)
590 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100591 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuSignalDegrade.IntfId), base10)
592 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuSignalDegrade.OnuId), base10)
593 context[ContextOnuInverseBitErrorRate] = strconv.FormatUint(uint64(onuSignalDegrade.InverseBitErrorRate), base10)
594
kesavand0ef592c2022-03-16 12:34:24 +0530595 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuSignalDegrade.IntfId, onuSignalDegrade.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100596
Devmalya Paulfb990a52019-07-09 10:01:49 -0400597 /* Populating device event body */
598 de.Context = context
599 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530600 if onuSignalDegrade.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400601 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "RAISE_EVENT")
602 } else {
603 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "CLEAR_EVENT")
604 }
605 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530606 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530607 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400608 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000609 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 +0530610 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400611}
612
Neha Sharma96b7bf22020-06-15 10:37:32 +0000613func (em *OpenOltEventMgr) onuSignalsFailIndication(ctx context.Context, onuSignalsFail *oop.OnuSignalsFailureIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400614 var de voltha.DeviceEvent
615 context := make(map[string]string)
616 /* Populating event context */
kesavand0ef592c2022-03-16 12:34:24 +0530617 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuSignalsFail.IntfId, onuSignalsFail.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100618
619 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuSignalsFail.OnuId), base10)
620 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuSignalsFail.IntfId), base10)
621 context[ContextOnuInverseBitErrorRate] = strconv.FormatUint(uint64(onuSignalsFail.InverseBitErrorRate), base10)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400622 /* Populating device event body */
623 de.Context = context
624 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530625 if onuSignalsFail.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400626 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "RAISE_EVENT")
627 } else {
628 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "CLEAR_EVENT")
629 }
630 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530631 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530632 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400633 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000634 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 +0530635 return nil
636}
637
Neha Sharma96b7bf22020-06-15 10:37:32 +0000638func (em *OpenOltEventMgr) onuStartupFailedIndication(ctx context.Context, onuStartupFail *oop.OnuStartupFailureIndication, deviceID string, raisedTs int64) error {
Naga Manjunathf6f74642020-01-13 21:37:28 +0530639 var de voltha.DeviceEvent
640 context := make(map[string]string)
641 /* Populating event context */
kesavand0ef592c2022-03-16 12:34:24 +0530642 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuStartupFail.IntfId, onuStartupFail.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100643
644 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuStartupFail.OnuId), base10)
645 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuStartupFail.IntfId), base10)
Naga Manjunathf6f74642020-01-13 21:37:28 +0530646
647 /* Populating device event body */
648 de.Context = context
649 de.ResourceId = deviceID
650 if onuStartupFail.Status == statusCheckOn {
651 de.DeviceEventName = fmt.Sprintf("%s_%s", onuStartupFailEvent, "RAISE_EVENT")
652 } else {
653 de.DeviceEventName = fmt.Sprintf("%s_%s", onuStartupFailEvent, "CLEAR_EVENT")
654 }
655 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530656 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs, onuDeviceID); err != nil {
Naga Manjunathf6f74642020-01-13 21:37:28 +0530657 return err
658 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000659 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 +0530660 return nil
661}
662
Neha Sharma96b7bf22020-06-15 10:37:32 +0000663func (em *OpenOltEventMgr) onuLossOfSyncIndication(ctx context.Context, onuLOKI *oop.OnuLossOfKeySyncFailureIndication, deviceID string, raisedTs int64) error {
Naga Manjunath9546b912019-11-28 20:56:20 +0530664 var de voltha.DeviceEvent
665 context := make(map[string]string)
666 /* Populating event context */
kesavand0ef592c2022-03-16 12:34:24 +0530667 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuLOKI.IntfId, onuLOKI.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100668
669 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuLOKI.OnuId), base10)
670 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuLOKI.IntfId), base10)
Naga Manjunath9546b912019-11-28 20:56:20 +0530671 /* Populating device event body */
672 de.Context = context
673 de.ResourceId = deviceID
674 if onuLOKI.Status == statusCheckOn {
675 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "RAISE_EVENT")
676 } else {
677 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "CLEAR_EVENT")
678 }
679
680 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530681 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_SECURITY, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530682 return err
683 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000684 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 +0530685 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400686}
kesavand39e0aa32020-01-28 20:58:50 -0500687
688// oltIntfOperIndication handles Up and Down state of an OLT PON ports
Kent Hagermane6ff1012020-07-14 15:07:53 -0400689func (em *OpenOltEventMgr) oltIntfOperIndication(ctx context.Context, ifindication *oop.IntfOperIndication, deviceID string, raisedTs int64) {
Mahir Gunyel85f61c12021-10-06 11:53:45 -0700690 portNo := plt.IntfIDToPortNo(ifindication.IntfId, voltha.Port_PON_OLT)
khenaidoodc2116e2021-10-19 17:33:19 -0400691 if port, err := em.handler.getPortFromCore(ctx, &ca.PortFilter{
khenaidoo106c61a2021-08-11 18:05:46 -0400692 DeviceId: deviceID,
693 Port: portNo,
694 }); err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700695 logger.Warnw(ctx, "Error while fetching port object", log.Fields{"device-id": deviceID, "err": err})
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400696 } else if port.AdminState != common.AdminState_ENABLED {
697 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 -0400698 return
kesavand39e0aa32020-01-28 20:58:50 -0500699 }
700 /* Populating event context */
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400701 context := map[string]string{ContextOltPonIntfOperState: ifindication.GetOperState()}
kesavand39e0aa32020-01-28 20:58:50 -0500702 /* Populating device event body */
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400703 var de voltha.DeviceEvent
kesavand39e0aa32020-01-28 20:58:50 -0500704 de.Context = context
705 de.ResourceId = deviceID
706
707 if ifindication.GetOperState() == operationStateDown {
708 de.DeviceEventName = fmt.Sprintf("%s_%s", ponIntfDownIndiction, "RAISE_EVENT")
709 } else if ifindication.OperState == operationStateUp {
710 de.DeviceEventName = fmt.Sprintf("%s_%s", ponIntfDownIndiction, "CLEAR_EVENT")
711 }
712 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400713 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
714 _ = 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)
715 return
kesavand39e0aa32020-01-28 20:58:50 -0500716 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000717 logger.Debug(ctx, "sent-olt-intf-oper-status-event-to-kafka")
kesavand39e0aa32020-01-28 20:58:50 -0500718}
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500719
Neha Sharma96b7bf22020-06-15 10:37:32 +0000720func (em *OpenOltEventMgr) onuDeactivationFailureIndication(ctx context.Context, onuDFI *oop.OnuDeactivationFailureIndication, deviceID string, raisedTs int64) error {
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500721 var de voltha.DeviceEvent
722 context := make(map[string]string)
723 /* Populating event context */
kesavand0ef592c2022-03-16 12:34:24 +0530724 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuDFI.IntfId, onuDFI.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100725
726 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuDFI.OnuId), base10)
727 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDFI.IntfId), base10)
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500728 /* Populating device event body */
729 de.Context = context
730 de.ResourceId = deviceID
Devmalya Paula1efa642020-04-20 01:36:43 -0400731 if onuDFI.Status == statusCheckOn {
732 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDeactivationFailureEvent, "RAISE_EVENT")
733 } else {
734 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDeactivationFailureEvent, "CLEAR_EVENT")
735 }
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500736 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530737 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500738 return err
739 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000740 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 -0500741 return nil
742}
Amit Ghosh502056b2020-07-15 09:15:48 +0100743
Neha Sharma96b7bf22020-06-15 10:37:32 +0000744func (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 -0500745 /* Populating event context */
746 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100747 ContextOnuOnuID: strconv.FormatUint(uint64(onuID), base10),
748 ContextOnuPonIntfID: strconv.FormatUint(uint64(intfID), base10),
749 ContextOnuRemoteDefectIndicatorCount: strconv.FormatUint(rdiCount, base10),
Devmalya Paul6f063a62020-02-19 19:19:06 -0500750 }
kesavand0ef592c2022-03-16 12:34:24 +0530751 onuDeviceID := em.populateContextWithSerialDeviceID(context, intfID, onuID)
Amit Ghosh502056b2020-07-15 09:15:48 +0100752
Devmalya Paul6f063a62020-02-19 19:19:06 -0500753 /* Populating device event body */
754 de := &voltha.DeviceEvent{
Devmalya Paula1efa642020-04-20 01:36:43 -0400755 Context: context,
756 ResourceId: deviceID,
757 }
758 if status == statusCheckOn {
759 de.DeviceEventName = fmt.Sprintf("%s_%s", onuRemoteDefectIndication, "RAISE_EVENT")
760 } else {
761 de.DeviceEventName = fmt.Sprintf("%s_%s", onuRemoteDefectIndication, "CLEAR_EVENT")
Devmalya Paul6f063a62020-02-19 19:19:06 -0500762 }
763 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530764 if err := em.eventProxy.SendDeviceEventWithKey(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Devmalya Paul6f063a62020-02-19 19:19:06 -0500765 return err
766 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000767 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 -0400768 return nil
769}
770
Neha Sharma96b7bf22020-06-15 10:37:32 +0000771func (em *OpenOltEventMgr) onuItuPonStatsIndication(ctx context.Context, onuIPS *oop.OnuItuPonStatsIndication, deviceID string, raisedTs int64) error {
Devmalya Paula1efa642020-04-20 01:36:43 -0400772 onuDevice, found := em.handler.onus.Load(em.handler.formOnuKey(onuIPS.IntfId, onuIPS.OnuId))
773 if !found {
774 return errors.New("unknown-onu-device")
775 }
776 if onuIPS.GetRdiErrorInd().Status == statusCheckOn {
777 if !onuDevice.(*OnuDevice).rdiRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000778 if err := em.onuRemoteDefectIndication(ctx, onuIPS.OnuId, onuIPS.IntfId, onuIPS.GetRdiErrorInd().RdiErrorCount, statusCheckOn, deviceID, raisedTs); err != nil {
Devmalya Paula1efa642020-04-20 01:36:43 -0400779 return err
780 }
781 onuDevice.(*OnuDevice).rdiRaised = true
782 return nil
783 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000784 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 -0400785 } else {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000786 if err := em.onuRemoteDefectIndication(ctx, onuIPS.OnuId, onuIPS.IntfId, onuIPS.GetRdiErrorInd().RdiErrorCount, statusCheckOff, deviceID, raisedTs); err != nil {
Devmalya Paula1efa642020-04-20 01:36:43 -0400787 return err
788 }
789 onuDevice.(*OnuDevice).rdiRaised = false
790 }
Devmalya Paul41a762d2020-03-01 18:56:54 -0500791 return nil
792}
793
Neha Sharma96b7bf22020-06-15 10:37:32 +0000794func (em *OpenOltEventMgr) onuLossOfGEMChannelDelineationIndication(ctx context.Context, onuGCD *oop.OnuLossOfGEMChannelDelineationIndication, deviceID string, raisedTs int64) error {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500795 /* Populating event context */
796 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100797 ContextOnuOnuID: strconv.FormatUint(uint64(onuGCD.OnuId), base10),
798 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuGCD.IntfId), base10),
799 ContextOnuDelineationErrors: strconv.FormatUint(uint64(onuGCD.DelineationErrors), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500800 }
kesavand0ef592c2022-03-16 12:34:24 +0530801 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuGCD.IntfId, onuGCD.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100802
Devmalya Paul41a762d2020-03-01 18:56:54 -0500803 /* Populating device event body */
804 de := &voltha.DeviceEvent{
805 Context: context,
806 ResourceId: deviceID,
807 }
808 if onuGCD.Status == statusCheckOn {
809 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfGEMChannelDelineationEvent, "RAISE_EVENT")
810 } else {
811 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfGEMChannelDelineationEvent, "CLEAR_EVENT")
812 }
813 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530814 if err := em.eventProxy.SendDeviceEventWithKey(ctx, de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500815 return err
816 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000817 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 -0500818 return nil
819}
820
Neha Sharma96b7bf22020-06-15 10:37:32 +0000821func (em *OpenOltEventMgr) onuPhysicalEquipmentErrorIndication(ctx context.Context, onuErr *oop.OnuPhysicalEquipmentErrorIndication, deviceID string, raisedTs int64) error {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500822 /* Populating event context */
823 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100824 ContextOnuOnuID: strconv.FormatUint(uint64(onuErr.OnuId), base10),
825 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuErr.IntfId), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500826 }
kesavand0ef592c2022-03-16 12:34:24 +0530827 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuErr.IntfId, onuErr.OnuId)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500828 /* Populating device event body */
829 de := &voltha.DeviceEvent{
830 Context: context,
831 ResourceId: deviceID,
832 }
833 if onuErr.Status == statusCheckOn {
834 de.DeviceEventName = fmt.Sprintf("%s_%s", onuPhysicalEquipmentErrorEvent, "RAISE_EVENT")
835 } else {
836 de.DeviceEventName = fmt.Sprintf("%s_%s", onuPhysicalEquipmentErrorEvent, "CLEAR_EVENT")
837 }
838 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530839 if err := em.eventProxy.SendDeviceEventWithKey(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500840 return err
841 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000842 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 -0500843 return nil
844}
845
Neha Sharma96b7bf22020-06-15 10:37:32 +0000846func (em *OpenOltEventMgr) onuLossOfAcknowledgementIndication(ctx context.Context, onuLOA *oop.OnuLossOfAcknowledgementIndication, deviceID string, raisedTs int64) error {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500847 /* Populating event context */
848 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100849 ContextOnuOnuID: strconv.FormatUint(uint64(onuLOA.OnuId), base10),
850 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuLOA.IntfId), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500851 }
kesavand0ef592c2022-03-16 12:34:24 +0530852 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuLOA.IntfId, onuLOA.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100853
Devmalya Paul41a762d2020-03-01 18:56:54 -0500854 /* Populating device event body */
855 de := &voltha.DeviceEvent{
856 Context: context,
857 ResourceId: deviceID,
858 }
859 if onuLOA.Status == statusCheckOn {
860 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfAcknowledgementEvent, "RAISE_EVENT")
861 } else {
862 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfAcknowledgementEvent, "CLEAR_EVENT")
863 }
864 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530865 if err := em.eventProxy.SendDeviceEventWithKey(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500866 return err
867 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000868 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 -0500869 return nil
870}
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400871
Neha Sharma96b7bf22020-06-15 10:37:32 +0000872func (em *OpenOltEventMgr) onuDifferentialReachExceededIndication(ctx context.Context, onuDRE *oop.OnuDifferentialReachExceededIndication, deviceID string, raisedTs int64) error {
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400873 /* Populating event context */
874 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100875 ContextOnuOnuID: strconv.FormatUint(uint64(onuDRE.OnuId), base10),
876 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuDRE.IntfId), base10),
877 ContextOnuDifferentialDistance: strconv.FormatUint(uint64(onuDRE.Distance), base10),
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400878 }
kesavand0ef592c2022-03-16 12:34:24 +0530879 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuDRE.IntfId, onuDRE.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100880
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400881 /* Populating device event body */
882 de := &voltha.DeviceEvent{
883 Context: context,
884 ResourceId: deviceID,
885 }
886 if onuDRE.Status == statusCheckOn {
887 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDifferentialReachExceededEvent, "RAISE_EVENT")
888 } else {
889 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDifferentialReachExceededEvent, "CLEAR_EVENT")
890 }
891 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530892 if err := em.eventProxy.SendDeviceEventWithKey(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400893 return err
894 }
Girish Kumara1ea2aa2020-08-19 18:14:22 +0000895 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 -0400896 return nil
897}