blob: f17814e01be245fd77cb993a41227eabd63fff63 [file] [log] [blame]
Devmalya Paulfb990a52019-07-09 10:01:49 -04001/*
Joey Armstrong11f5a572024-01-12 19:11:32 -05002 * Copyright 2018-2024 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
Marcos Aurelio Carrero (Furukawa)1992f992023-11-14 14:31:40 -0300387
388 if dgi.Status == statusCheckOn {
389 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDyingGaspEvent, "RAISE_EVENT")
390 } else {
391 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDyingGaspEvent, "CLEAR_EVENT")
392 }
393
Devmalya Paulfb990a52019-07-09 10:01:49 -0400394 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530395 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530396 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400397 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000398 logger.Debugw(ctx, "onu-dying-gasp-event-sent-to-kafka", log.Fields{"intf-id": dgi.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530399 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400400}
401
Joey Armstrong3f0e2422023-07-05 18:25:41 -0400402// wasLosRaised checks whether los raised already. If already raised returns true else false
Neha Sharma96b7bf22020-06-15 10:37:32 +0000403func (em *OpenOltEventMgr) wasLosRaised(ctx context.Context, onuAlarm *oop.OnuAlarmIndication) bool {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530404 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
405 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000406 logger.Debugw(ctx, "onu-device-found-in-cache.", log.Fields{"intfID": onuAlarm.IntfId, "onuID": onuAlarm.OnuId})
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530407
408 if onuAlarm.LosStatus == statusCheckOn {
409 if onuInCache.(*OnuDevice).losRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000410 logger.Warnw(ctx, "onu-los-raised-already", log.Fields{"onu_id": onuAlarm.OnuId,
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530411 "intf_id": onuAlarm.IntfId, "LosStatus": onuAlarm.LosStatus})
412 return true
413 }
414 return false
415 }
416 }
417 return true
418}
419
Joey Armstrong3f0e2422023-07-05 18:25:41 -0400420// wasLosCleared checks whether los cleared already. If already cleared returns true else false
Neha Sharma96b7bf22020-06-15 10:37:32 +0000421func (em *OpenOltEventMgr) wasLosCleared(ctx context.Context, onuAlarm *oop.OnuAlarmIndication) bool {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530422 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
423 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000424 logger.Debugw(ctx, "onu-device-found-in-cache.", log.Fields{"intfID": onuAlarm.IntfId, "onuID": onuAlarm.OnuId})
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530425
426 if onuAlarm.LosStatus == statusCheckOff {
427 if !onuInCache.(*OnuDevice).losRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000428 logger.Warnw(ctx, "onu-los-cleared-already", log.Fields{"onu_id": onuAlarm.OnuId,
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530429 "intf_id": onuAlarm.IntfId, "LosStatus": onuAlarm.LosStatus})
430 return true
431 }
432 return false
433 }
434 }
435 return true
436}
437
438func (em *OpenOltEventMgr) getDeviceEventName(onuAlarm *oop.OnuAlarmIndication) string {
439 var deviceEventName string
440 if onuAlarm.LosStatus == statusCheckOn {
441 deviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "RAISE_EVENT")
442 } else if onuAlarm.LosStatus == statusCheckOff {
443 deviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "CLEAR_EVENT")
444 } else if onuAlarm.LobStatus == statusCheckOn {
445 deviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "RAISE_EVENT")
446 } else if onuAlarm.LobStatus == statusCheckOff {
447 deviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "CLEAR_EVENT")
448 } else if onuAlarm.LopcMissStatus == statusCheckOn {
449 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "RAISE_EVENT")
450 } else if onuAlarm.LopcMissStatus == statusCheckOff {
451 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "CLEAR_EVENT")
452 } else if onuAlarm.LopcMicErrorStatus == statusCheckOn {
453 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "RAISE_EVENT")
454 } else if onuAlarm.LopcMicErrorStatus == statusCheckOff {
455 deviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "CLEAR_EVENT")
456 } else if onuAlarm.LofiStatus == statusCheckOn {
457 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "RAISE_EVENT")
458 } else if onuAlarm.LofiStatus == statusCheckOff {
459 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "CLEAR_EVENT")
460 } else if onuAlarm.LoamiStatus == statusCheckOn {
461 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfPloamEvent, "RAISE_EVENT")
462 } else if onuAlarm.LoamiStatus == statusCheckOff {
463 deviceEventName = fmt.Sprintf("%s_%s", onuLossOfPloamEvent, "CLEAR_EVENT")
464 }
465 return deviceEventName
466}
467
Neha Sharma96b7bf22020-06-15 10:37:32 +0000468func (em *OpenOltEventMgr) onuAlarmIndication(ctx context.Context, onuAlarm *oop.OnuAlarmIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400469 var de voltha.DeviceEvent
Amit Ghosh502056b2020-07-15 09:15:48 +0100470
Devmalya Paulfb990a52019-07-09 10:01:49 -0400471 context := make(map[string]string)
472 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100473 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuAlarm.IntfId), base10)
474 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuAlarm.OnuId), base10)
kesavand0ef592c2022-03-16 12:34:24 +0530475 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuAlarm.IntfId, onuAlarm.OnuId)
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530476
Devmalya Paulfb990a52019-07-09 10:01:49 -0400477 /* Populating device event body */
478 de.Context = context
479 de.ResourceId = deviceID
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530480 de.DeviceEventName = em.getDeviceEventName(onuAlarm)
481
482 switch onuAlarm.LosStatus {
483 case statusCheckOn:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000484 if em.wasLosRaised(ctx, onuAlarm) {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530485 /* No need to raise Onu Los Event as it might have already raised
486 or Onu might have deleted */
487 return nil
488 }
489 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
490 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
491 /* Update onu device with LoS raised state as true */
492 em.handler.onus.Store(onuKey, NewOnuDevice(onuInCache.(*OnuDevice).deviceID, onuInCache.(*OnuDevice).deviceType,
493 onuInCache.(*OnuDevice).serialNumber, onuInCache.(*OnuDevice).onuID, onuInCache.(*OnuDevice).intfID,
khenaidoo106c61a2021-08-11 18:05:46 -0400494 onuInCache.(*OnuDevice).proxyDeviceID, true, onuInCache.(*OnuDevice).adapterEndpoint))
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530495 }
496 case statusCheckOff:
Neha Sharma96b7bf22020-06-15 10:37:32 +0000497 if em.wasLosCleared(ctx, onuAlarm) {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530498 /* No need to clear Onu Los Event as it might have already cleared
499 or Onu might have deleted */
500 return nil
501 }
502 onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
503 if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
504 /* Update onu device with LoS raised state as false */
505 em.handler.onus.Store(onuKey, NewOnuDevice(onuInCache.(*OnuDevice).deviceID, onuInCache.(*OnuDevice).deviceType,
506 onuInCache.(*OnuDevice).serialNumber, onuInCache.(*OnuDevice).onuID, onuInCache.(*OnuDevice).intfID,
khenaidoo106c61a2021-08-11 18:05:46 -0400507 onuInCache.(*OnuDevice).proxyDeviceID, false, onuInCache.(*OnuDevice).adapterEndpoint))
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530508 }
Devmalya Paulfb990a52019-07-09 10:01:49 -0400509 }
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530510
Devmalya Paulfb990a52019-07-09 10:01:49 -0400511 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530512 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530513 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400514 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000515 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 +0530516 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400517}
518
kesavand7cf3a052020-08-28 12:49:18 +0530519func (em *OpenOltEventMgr) onuActivationIndication(ctx context.Context, eventName string, onuInd *oop.OnuIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400520 var de voltha.DeviceEvent
521 context := make(map[string]string)
522 /* Populating event context */
kesavand7cf3a052020-08-28 12:49:18 +0530523 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuInd.IntfId), base10)
524 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuInd.OnuId), base10)
525 context[ContextOnuFailureReaseon] = onuInd.FailReason.String()
Amit Ghosh502056b2020-07-15 09:15:48 +0100526
kesavand0ef592c2022-03-16 12:34:24 +0530527 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuInd.IntfId, onuInd.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100528
Devmalya Paulfb990a52019-07-09 10:01:49 -0400529 /* Populating device event body */
530 de.Context = context
531 de.ResourceId = deviceID
kesavand7cf3a052020-08-28 12:49:18 +0530532 de.DeviceEventName = eventName
Devmalya Paulfb990a52019-07-09 10:01:49 -0400533 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530534 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_PON, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530535 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400536 }
kesavand7cf3a052020-08-28 12:49:18 +0530537 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 +0530538 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400539}
540
Neha Sharma96b7bf22020-06-15 10:37:32 +0000541func (em *OpenOltEventMgr) onuLossOmciIndication(ctx context.Context, onuLossOmci *oop.OnuLossOfOmciChannelIndication, 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(onuLossOmci.IntfId), base10)
546 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuLossOmci.OnuId), base10)
547
kesavand0ef592c2022-03-16 12:34:24 +0530548 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuLossOmci.IntfId, onuLossOmci.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100549
Devmalya Paulfb990a52019-07-09 10:01:49 -0400550 /* Populating device event body */
551 de.Context = context
552 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530553 if onuLossOmci.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400554 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "RAISE_EVENT")
555 } else {
556 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "CLEAR_EVENT")
557 }
558 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530559 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530560 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400561 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000562 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 +0530563 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400564}
565
Neha Sharma96b7bf22020-06-15 10:37:32 +0000566func (em *OpenOltEventMgr) onuDriftOfWindowIndication(ctx context.Context, onuDriftWindow *oop.OnuDriftOfWindowIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400567 var de voltha.DeviceEvent
568 context := make(map[string]string)
569 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100570 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDriftWindow.IntfId), base10)
571 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuDriftWindow.OnuId), base10)
572 context[ContextOnuDrift] = strconv.FormatUint(uint64(onuDriftWindow.Drift), base10)
573 context[ContextOnuNewEqd] = strconv.FormatUint(uint64(onuDriftWindow.NewEqd), base10)
574
kesavand0ef592c2022-03-16 12:34:24 +0530575 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuDriftWindow.IntfId, onuDriftWindow.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100576
Devmalya Paulfb990a52019-07-09 10:01:49 -0400577 /* Populating device event body */
578 de.Context = context
579 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530580 if onuDriftWindow.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400581 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "RAISE_EVENT")
582 } else {
583 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "CLEAR_EVENT")
584 }
585 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530586 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530587 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400588 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000589 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 +0530590 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400591}
592
Neha Sharma96b7bf22020-06-15 10:37:32 +0000593func (em *OpenOltEventMgr) onuSignalDegradeIndication(ctx context.Context, onuSignalDegrade *oop.OnuSignalDegradeIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400594 var de voltha.DeviceEvent
595 context := make(map[string]string)
596 /* Populating event context */
Amit Ghosh502056b2020-07-15 09:15:48 +0100597 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuSignalDegrade.IntfId), base10)
598 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuSignalDegrade.OnuId), base10)
599 context[ContextOnuInverseBitErrorRate] = strconv.FormatUint(uint64(onuSignalDegrade.InverseBitErrorRate), base10)
600
kesavand0ef592c2022-03-16 12:34:24 +0530601 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuSignalDegrade.IntfId, onuSignalDegrade.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100602
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 onuSignalDegrade.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400607 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "RAISE_EVENT")
608 } else {
609 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "CLEAR_EVENT")
610 }
611 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530612 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); 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-signal-degrade-event-sent-to-kafka", log.Fields{"onu-id": onuSignalDegrade.OnuId, "intf-id": onuSignalDegrade.IntfId})
Naga Manjunath9546b912019-11-28 20:56:20 +0530616 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400617}
618
Neha Sharma96b7bf22020-06-15 10:37:32 +0000619func (em *OpenOltEventMgr) onuSignalsFailIndication(ctx context.Context, onuSignalsFail *oop.OnuSignalsFailureIndication, deviceID string, raisedTs int64) error {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400620 var de voltha.DeviceEvent
621 context := make(map[string]string)
622 /* Populating event context */
kesavand0ef592c2022-03-16 12:34:24 +0530623 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuSignalsFail.IntfId, onuSignalsFail.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100624
625 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuSignalsFail.OnuId), base10)
626 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuSignalsFail.IntfId), base10)
627 context[ContextOnuInverseBitErrorRate] = strconv.FormatUint(uint64(onuSignalsFail.InverseBitErrorRate), base10)
Devmalya Paulfb990a52019-07-09 10:01:49 -0400628 /* Populating device event body */
629 de.Context = context
630 de.ResourceId = deviceID
Naga Manjunath9546b912019-11-28 20:56:20 +0530631 if onuSignalsFail.Status == statusCheckOn {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400632 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "RAISE_EVENT")
633 } else {
634 de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "CLEAR_EVENT")
635 }
636 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530637 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530638 return err
Devmalya Paulfb990a52019-07-09 10:01:49 -0400639 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000640 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 +0530641 return nil
642}
643
Neha Sharma96b7bf22020-06-15 10:37:32 +0000644func (em *OpenOltEventMgr) onuStartupFailedIndication(ctx context.Context, onuStartupFail *oop.OnuStartupFailureIndication, deviceID string, raisedTs int64) error {
Naga Manjunathf6f74642020-01-13 21:37:28 +0530645 var de voltha.DeviceEvent
646 context := make(map[string]string)
647 /* Populating event context */
kesavand0ef592c2022-03-16 12:34:24 +0530648 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuStartupFail.IntfId, onuStartupFail.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100649
650 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuStartupFail.OnuId), base10)
651 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuStartupFail.IntfId), base10)
Naga Manjunathf6f74642020-01-13 21:37:28 +0530652
653 /* Populating device event body */
654 de.Context = context
655 de.ResourceId = deviceID
656 if onuStartupFail.Status == statusCheckOn {
657 de.DeviceEventName = fmt.Sprintf("%s_%s", onuStartupFailEvent, "RAISE_EVENT")
658 } else {
659 de.DeviceEventName = fmt.Sprintf("%s_%s", onuStartupFailEvent, "CLEAR_EVENT")
660 }
661 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530662 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs, onuDeviceID); err != nil {
Naga Manjunathf6f74642020-01-13 21:37:28 +0530663 return err
664 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000665 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 +0530666 return nil
667}
668
Neha Sharma96b7bf22020-06-15 10:37:32 +0000669func (em *OpenOltEventMgr) onuLossOfSyncIndication(ctx context.Context, onuLOKI *oop.OnuLossOfKeySyncFailureIndication, deviceID string, raisedTs int64) error {
Naga Manjunath9546b912019-11-28 20:56:20 +0530670 var de voltha.DeviceEvent
671 context := make(map[string]string)
672 /* Populating event context */
kesavand0ef592c2022-03-16 12:34:24 +0530673 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuLOKI.IntfId, onuLOKI.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100674
675 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuLOKI.OnuId), base10)
676 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuLOKI.IntfId), base10)
Naga Manjunath9546b912019-11-28 20:56:20 +0530677 /* Populating device event body */
678 de.Context = context
679 de.ResourceId = deviceID
680 if onuLOKI.Status == statusCheckOn {
681 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "RAISE_EVENT")
682 } else {
683 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "CLEAR_EVENT")
684 }
685
686 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530687 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_SECURITY, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Naga Manjunath9546b912019-11-28 20:56:20 +0530688 return err
689 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000690 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 +0530691 return nil
Devmalya Paulfb990a52019-07-09 10:01:49 -0400692}
kesavand39e0aa32020-01-28 20:58:50 -0500693
694// oltIntfOperIndication handles Up and Down state of an OLT PON ports
Kent Hagermane6ff1012020-07-14 15:07:53 -0400695func (em *OpenOltEventMgr) oltIntfOperIndication(ctx context.Context, ifindication *oop.IntfOperIndication, deviceID string, raisedTs int64) {
Mahir Gunyel85f61c12021-10-06 11:53:45 -0700696 portNo := plt.IntfIDToPortNo(ifindication.IntfId, voltha.Port_PON_OLT)
khenaidoodc2116e2021-10-19 17:33:19 -0400697 if port, err := em.handler.getPortFromCore(ctx, &ca.PortFilter{
khenaidoo106c61a2021-08-11 18:05:46 -0400698 DeviceId: deviceID,
699 Port: portNo,
700 }); err != nil {
Girish Gowdra8a0bdcd2021-05-13 12:31:04 -0700701 logger.Warnw(ctx, "Error while fetching port object", log.Fields{"device-id": deviceID, "err": err})
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400702 } else if port.AdminState != common.AdminState_ENABLED {
703 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 -0400704 return
kesavand39e0aa32020-01-28 20:58:50 -0500705 }
706 /* Populating event context */
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400707 context := map[string]string{ContextOltPonIntfOperState: ifindication.GetOperState()}
kesavand39e0aa32020-01-28 20:58:50 -0500708 /* Populating device event body */
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400709 var de voltha.DeviceEvent
kesavand39e0aa32020-01-28 20:58:50 -0500710 de.Context = context
711 de.ResourceId = deviceID
712
713 if ifindication.GetOperState() == operationStateDown {
714 de.DeviceEventName = fmt.Sprintf("%s_%s", ponIntfDownIndiction, "RAISE_EVENT")
715 } else if ifindication.OperState == operationStateUp {
716 de.DeviceEventName = fmt.Sprintf("%s_%s", ponIntfDownIndiction, "CLEAR_EVENT")
717 }
718 /* Send event to KAFKA */
Kent Hagermane6ff1012020-07-14 15:07:53 -0400719 if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
720 _ = 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)
721 return
kesavand39e0aa32020-01-28 20:58:50 -0500722 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000723 logger.Debug(ctx, "sent-olt-intf-oper-status-event-to-kafka")
kesavand39e0aa32020-01-28 20:58:50 -0500724}
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500725
Neha Sharma96b7bf22020-06-15 10:37:32 +0000726func (em *OpenOltEventMgr) onuDeactivationFailureIndication(ctx context.Context, onuDFI *oop.OnuDeactivationFailureIndication, deviceID string, raisedTs int64) error {
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500727 var de voltha.DeviceEvent
728 context := make(map[string]string)
729 /* Populating event context */
kesavand0ef592c2022-03-16 12:34:24 +0530730 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuDFI.IntfId, onuDFI.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100731
732 context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuDFI.OnuId), base10)
733 context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDFI.IntfId), base10)
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500734 /* Populating device event body */
735 de.Context = context
736 de.ResourceId = deviceID
Devmalya Paula1efa642020-04-20 01:36:43 -0400737 if onuDFI.Status == statusCheckOn {
738 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDeactivationFailureEvent, "RAISE_EVENT")
739 } else {
740 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDeactivationFailureEvent, "CLEAR_EVENT")
741 }
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500742 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530743 if err := em.eventProxy.SendDeviceEventWithKey(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Devmalya Paul1abc34e2020-02-04 20:48:06 -0500744 return err
745 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000746 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 -0500747 return nil
748}
Amit Ghosh502056b2020-07-15 09:15:48 +0100749
Neha Sharma96b7bf22020-06-15 10:37:32 +0000750func (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 -0500751 /* Populating event context */
752 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100753 ContextOnuOnuID: strconv.FormatUint(uint64(onuID), base10),
754 ContextOnuPonIntfID: strconv.FormatUint(uint64(intfID), base10),
755 ContextOnuRemoteDefectIndicatorCount: strconv.FormatUint(rdiCount, base10),
Devmalya Paul6f063a62020-02-19 19:19:06 -0500756 }
kesavand0ef592c2022-03-16 12:34:24 +0530757 onuDeviceID := em.populateContextWithSerialDeviceID(context, intfID, onuID)
Amit Ghosh502056b2020-07-15 09:15:48 +0100758
Devmalya Paul6f063a62020-02-19 19:19:06 -0500759 /* Populating device event body */
760 de := &voltha.DeviceEvent{
Devmalya Paula1efa642020-04-20 01:36:43 -0400761 Context: context,
762 ResourceId: deviceID,
763 }
764 if status == statusCheckOn {
765 de.DeviceEventName = fmt.Sprintf("%s_%s", onuRemoteDefectIndication, "RAISE_EVENT")
766 } else {
767 de.DeviceEventName = fmt.Sprintf("%s_%s", onuRemoteDefectIndication, "CLEAR_EVENT")
Devmalya Paul6f063a62020-02-19 19:19:06 -0500768 }
769 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530770 if err := em.eventProxy.SendDeviceEventWithKey(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Devmalya Paul6f063a62020-02-19 19:19:06 -0500771 return err
772 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000773 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 -0400774 return nil
775}
776
Neha Sharma96b7bf22020-06-15 10:37:32 +0000777func (em *OpenOltEventMgr) onuItuPonStatsIndication(ctx context.Context, onuIPS *oop.OnuItuPonStatsIndication, deviceID string, raisedTs int64) error {
Devmalya Paula1efa642020-04-20 01:36:43 -0400778 onuDevice, found := em.handler.onus.Load(em.handler.formOnuKey(onuIPS.IntfId, onuIPS.OnuId))
779 if !found {
780 return errors.New("unknown-onu-device")
781 }
782 if onuIPS.GetRdiErrorInd().Status == statusCheckOn {
783 if !onuDevice.(*OnuDevice).rdiRaised {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000784 if err := em.onuRemoteDefectIndication(ctx, onuIPS.OnuId, onuIPS.IntfId, onuIPS.GetRdiErrorInd().RdiErrorCount, statusCheckOn, deviceID, raisedTs); err != nil {
Devmalya Paula1efa642020-04-20 01:36:43 -0400785 return err
786 }
787 onuDevice.(*OnuDevice).rdiRaised = true
788 return nil
789 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000790 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 -0400791 } else {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000792 if err := em.onuRemoteDefectIndication(ctx, onuIPS.OnuId, onuIPS.IntfId, onuIPS.GetRdiErrorInd().RdiErrorCount, statusCheckOff, deviceID, raisedTs); err != nil {
Devmalya Paula1efa642020-04-20 01:36:43 -0400793 return err
794 }
795 onuDevice.(*OnuDevice).rdiRaised = false
796 }
Devmalya Paul41a762d2020-03-01 18:56:54 -0500797 return nil
798}
799
Neha Sharma96b7bf22020-06-15 10:37:32 +0000800func (em *OpenOltEventMgr) onuLossOfGEMChannelDelineationIndication(ctx context.Context, onuGCD *oop.OnuLossOfGEMChannelDelineationIndication, deviceID string, raisedTs int64) error {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500801 /* Populating event context */
802 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100803 ContextOnuOnuID: strconv.FormatUint(uint64(onuGCD.OnuId), base10),
804 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuGCD.IntfId), base10),
805 ContextOnuDelineationErrors: strconv.FormatUint(uint64(onuGCD.DelineationErrors), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500806 }
kesavand0ef592c2022-03-16 12:34:24 +0530807 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuGCD.IntfId, onuGCD.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100808
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 onuGCD.Status == statusCheckOn {
815 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfGEMChannelDelineationEvent, "RAISE_EVENT")
816 } else {
817 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfGEMChannelDelineationEvent, "CLEAR_EVENT")
818 }
819 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530820 if err := em.eventProxy.SendDeviceEventWithKey(ctx, de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); 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-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 -0500824 return nil
825}
826
Neha Sharma96b7bf22020-06-15 10:37:32 +0000827func (em *OpenOltEventMgr) onuPhysicalEquipmentErrorIndication(ctx context.Context, onuErr *oop.OnuPhysicalEquipmentErrorIndication, 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(onuErr.OnuId), base10),
831 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuErr.IntfId), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500832 }
kesavand0ef592c2022-03-16 12:34:24 +0530833 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuErr.IntfId, onuErr.OnuId)
Devmalya Paul41a762d2020-03-01 18:56:54 -0500834 /* Populating device event body */
835 de := &voltha.DeviceEvent{
836 Context: context,
837 ResourceId: deviceID,
838 }
839 if onuErr.Status == statusCheckOn {
840 de.DeviceEventName = fmt.Sprintf("%s_%s", onuPhysicalEquipmentErrorEvent, "RAISE_EVENT")
841 } else {
842 de.DeviceEventName = fmt.Sprintf("%s_%s", onuPhysicalEquipmentErrorEvent, "CLEAR_EVENT")
843 }
844 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530845 if err := em.eventProxy.SendDeviceEventWithKey(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500846 return err
847 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000848 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 -0500849 return nil
850}
851
Neha Sharma96b7bf22020-06-15 10:37:32 +0000852func (em *OpenOltEventMgr) onuLossOfAcknowledgementIndication(ctx context.Context, onuLOA *oop.OnuLossOfAcknowledgementIndication, deviceID string, raisedTs int64) error {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500853 /* Populating event context */
854 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100855 ContextOnuOnuID: strconv.FormatUint(uint64(onuLOA.OnuId), base10),
856 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuLOA.IntfId), base10),
Devmalya Paul41a762d2020-03-01 18:56:54 -0500857 }
kesavand0ef592c2022-03-16 12:34:24 +0530858 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuLOA.IntfId, onuLOA.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100859
Devmalya Paul41a762d2020-03-01 18:56:54 -0500860 /* Populating device event body */
861 de := &voltha.DeviceEvent{
862 Context: context,
863 ResourceId: deviceID,
864 }
865 if onuLOA.Status == statusCheckOn {
866 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfAcknowledgementEvent, "RAISE_EVENT")
867 } else {
868 de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfAcknowledgementEvent, "CLEAR_EVENT")
869 }
870 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530871 if err := em.eventProxy.SendDeviceEventWithKey(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Devmalya Paul41a762d2020-03-01 18:56:54 -0500872 return err
873 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000874 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 -0500875 return nil
876}
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400877
Neha Sharma96b7bf22020-06-15 10:37:32 +0000878func (em *OpenOltEventMgr) onuDifferentialReachExceededIndication(ctx context.Context, onuDRE *oop.OnuDifferentialReachExceededIndication, deviceID string, raisedTs int64) error {
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400879 /* Populating event context */
880 context := map[string]string{
Amit Ghosh502056b2020-07-15 09:15:48 +0100881 ContextOnuOnuID: strconv.FormatUint(uint64(onuDRE.OnuId), base10),
882 ContextOnuPonIntfID: strconv.FormatUint(uint64(onuDRE.IntfId), base10),
883 ContextOnuDifferentialDistance: strconv.FormatUint(uint64(onuDRE.Distance), base10),
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400884 }
kesavand0ef592c2022-03-16 12:34:24 +0530885 onuDeviceID := em.populateContextWithSerialDeviceID(context, onuDRE.IntfId, onuDRE.OnuId)
Amit Ghosh502056b2020-07-15 09:15:48 +0100886
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400887 /* Populating device event body */
888 de := &voltha.DeviceEvent{
889 Context: context,
890 ResourceId: deviceID,
891 }
892 if onuDRE.Status == statusCheckOn {
893 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDifferentialReachExceededEvent, "RAISE_EVENT")
894 } else {
895 de.DeviceEventName = fmt.Sprintf("%s_%s", onuDifferentialReachExceededEvent, "CLEAR_EVENT")
896 }
897 /* Send event to KAFKA */
kesavand0ef592c2022-03-16 12:34:24 +0530898 if err := em.eventProxy.SendDeviceEventWithKey(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs, onuDeviceID); err != nil {
Devmalya Pauleb5294e2020-03-19 03:01:39 -0400899 return err
900 }
Girish Kumara1ea2aa2020-08-19 18:14:22 +0000901 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 -0400902 return nil
903}