blob: 1ff069168704574fa17e466d1e6375267c193ae7 [file] [log] [blame]
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001/*
2 * Copyright 2020-present Open Networking Foundation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +000017//Package core provides the utility for onu devices, flows and statistics
18package core
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000019
20import (
21 "context"
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000022 "errors"
23 "fmt"
Holger Hildebrandt24d51952020-05-04 14:03:42 +000024 "strconv"
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000025 "sync"
26 "time"
27
khenaidoo7d3c5582021-08-11 18:09:44 -040028 "github.com/opencord/voltha-openonu-adapter-go/internal/pkg/config"
mpagenko1f8e8822021-06-25 14:10:21 +000029
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000030 "github.com/gogo/protobuf/proto"
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000031 "github.com/looplab/fsm"
Holger Hildebrandt9ac0d0f2020-05-13 11:22:02 +000032 me "github.com/opencord/omci-lib-go/generated"
khenaidoo7d3c5582021-08-11 18:09:44 -040033 "github.com/opencord/voltha-lib-go/v7/pkg/db"
34 "github.com/opencord/voltha-lib-go/v7/pkg/events/eventif"
35 flow "github.com/opencord/voltha-lib-go/v7/pkg/flows"
36 vgrpc "github.com/opencord/voltha-lib-go/v7/pkg/grpc"
37 "github.com/opencord/voltha-lib-go/v7/pkg/log"
Mahir Gunyelcb128ae2021-10-06 09:42:05 -070038 platform "github.com/opencord/voltha-lib-go/v7/pkg/platform"
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +000039 almgr "github.com/opencord/voltha-openonu-adapter-go/internal/pkg/almgr"
40 avcfg "github.com/opencord/voltha-openonu-adapter-go/internal/pkg/avcfg"
41 cmn "github.com/opencord/voltha-openonu-adapter-go/internal/pkg/common"
42 mib "github.com/opencord/voltha-openonu-adapter-go/internal/pkg/mib"
43 otst "github.com/opencord/voltha-openonu-adapter-go/internal/pkg/omcitst"
44 pmmgr "github.com/opencord/voltha-openonu-adapter-go/internal/pkg/pmmgr"
45 "github.com/opencord/voltha-openonu-adapter-go/internal/pkg/swupg"
46 uniprt "github.com/opencord/voltha-openonu-adapter-go/internal/pkg/uniprt"
khenaidoo7d3c5582021-08-11 18:09:44 -040047 vc "github.com/opencord/voltha-protos/v5/go/common"
48 "github.com/opencord/voltha-protos/v5/go/extension"
49 ic "github.com/opencord/voltha-protos/v5/go/inter_container"
50 of "github.com/opencord/voltha-protos/v5/go/openflow_13"
mpagenko59862f02021-10-11 08:53:18 +000051 "github.com/opencord/voltha-protos/v5/go/openolt"
khenaidoo7d3c5582021-08-11 18:09:44 -040052 oop "github.com/opencord/voltha-protos/v5/go/openolt"
mpagenko59862f02021-10-11 08:53:18 +000053 "github.com/opencord/voltha-protos/v5/go/tech_profile"
khenaidoo7d3c5582021-08-11 18:09:44 -040054 "github.com/opencord/voltha-protos/v5/go/voltha"
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000055)
56
mpagenko38662d02021-08-11 09:45:19 +000057// Constants for timeouts
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000058const (
mpagenko38662d02021-08-11 09:45:19 +000059 cTimeOutRemoveUpgrade = 1 //for usage in seconds
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000060)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000061
mpagenko1cc3cb42020-07-27 15:24:38 +000062const (
63 // events of Device FSM
64 devEvDeviceInit = "devEvDeviceInit"
65 devEvGrpcConnected = "devEvGrpcConnected"
66 devEvGrpcDisconnected = "devEvGrpcDisconnected"
67 devEvDeviceUpInd = "devEvDeviceUpInd"
68 devEvDeviceDownInd = "devEvDeviceDownInd"
69)
70const (
71 // states of Device FSM
72 devStNull = "devStNull"
73 devStDown = "devStDown"
74 devStInit = "devStInit"
75 devStConnected = "devStConnected"
76 devStUp = "devStUp"
77)
78
Holger Hildebrandt24d51952020-05-04 14:03:42 +000079//Event category and subcategory definitions - same as defiend for OLT in eventmgr.go - should be done more centrally
80const (
Himani Chawla4d908332020-08-31 12:30:20 +053081 pon = voltha.EventSubCategory_PON
82 //olt = voltha.EventSubCategory_OLT
83 //ont = voltha.EventSubCategory_ONT
84 //onu = voltha.EventSubCategory_ONU
85 //nni = voltha.EventSubCategory_NNI
86 //service = voltha.EventCategory_SERVICE
87 //security = voltha.EventCategory_SECURITY
88 equipment = voltha.EventCategory_EQUIPMENT
89 //processing = voltha.EventCategory_PROCESSING
90 //environment = voltha.EventCategory_ENVIRONMENT
91 //communication = voltha.EventCategory_COMMUNICATION
Holger Hildebrandt24d51952020-05-04 14:03:42 +000092)
93
94const (
95 cEventObjectType = "ONU"
96)
97const (
98 cOnuActivatedEvent = "ONU_ACTIVATED"
99)
100
mpagenkof1fc3862021-02-16 10:09:52 +0000101type omciIdleCheckStruct struct {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000102 omciIdleCheckFunc func(*deviceHandler, context.Context, cmn.UsedOmciConfigFsms, string) bool
mpagenkof1fc3862021-02-16 10:09:52 +0000103 omciIdleState string
Holger Hildebrandt10d98192021-01-27 15:29:31 +0000104}
105
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000106var fsmOmciIdleStateFuncMap = map[cmn.UsedOmciConfigFsms]omciIdleCheckStruct{
107 cmn.CUploadFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, mib.CMibUlFsmIdleState},
108 cmn.CDownloadFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, mib.CMibDlFsmIdleState},
109 cmn.CUniLockFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, uniprt.CUniFsmIdleState},
110 cmn.CUniUnLockFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, uniprt.CUniFsmIdleState},
111 cmn.CAniConfigFsm: {(*deviceHandler).isAniConfigFsmInOmciIdleState, avcfg.CAniFsmIdleState},
112 cmn.CUniVlanConfigFsm: {(*deviceHandler).isUniVlanConfigFsmInOmciIdleState, avcfg.CVlanFsmIdleState},
113 cmn.CL2PmFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, pmmgr.CL2PmFsmIdleState},
114 cmn.COnuUpgradeFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, swupg.COnuUpgradeFsmIdleState},
Holger Hildebrandt3a644642020-12-02 09:46:18 +0000115}
116
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000117const (
118 cNoReconciling = iota
119 cOnuConfigReconciling
120 cSkipOnuConfigReconciling
121)
122
Girish Gowdrae95687a2021-09-08 16:30:58 -0700123// FlowCb is the flow control block containing flow add/delete information along with a response channel
124type FlowCb struct {
125 ctx context.Context // Flow handler context
126 addFlow bool // if true flow to be added, else removed
127 flowItem *of.OfpFlowStats
128 uniPort *cmn.OnuUniPort
129 flowMetaData *voltha.FlowMetadata
130 respChan *chan error // channel to report the Flow handling error
131}
132
Himani Chawla6d2ae152020-09-02 13:11:20 +0530133//deviceHandler will interact with the ONU ? device.
134type deviceHandler struct {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000135 DeviceID string
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000136 DeviceType string
137 adminState string
138 device *voltha.Device
139 logicalDeviceID string
140 ProxyAddressID string
141 ProxyAddressType string
Himani Chawla4d908332020-08-31 12:30:20 +0530142 parentID string
Holger Hildebrandt24d51952020-05-04 14:03:42 +0000143 ponPortNumber uint32
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000144
khenaidoo7d3c5582021-08-11 18:09:44 -0400145 coreClient *vgrpc.Client
146 EventProxy eventif.EventProxy
Holger Hildebrandtc54939a2020-06-17 08:14:27 +0000147
Girish Gowdra5a7c4922021-01-22 18:33:41 -0800148 pmConfigs *voltha.PmConfigs
khenaidoo7d3c5582021-08-11 18:09:44 -0400149 config *config.AdapterFlags
Girish Gowdrae09a6202021-01-12 18:10:59 -0800150
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000151 pOpenOnuAc *OpenONUAC
152 pDeviceStateFsm *fsm.FSM
Himani Chawla4d908332020-08-31 12:30:20 +0530153 //pPonPort *voltha.Port
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000154 deviceEntrySet chan bool //channel for DeviceEntry set event
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000155 pOnuOmciDevice *mib.OnuDeviceEntry
156 pOnuTP *avcfg.OnuUniTechProf
157 pOnuMetricsMgr *pmmgr.OnuMetricsManager
158 pAlarmMgr *almgr.OnuAlarmManager
159 pSelfTestHdlr *otst.SelfTestControlBlock
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000160 exitChannel chan int
161 lockDevice sync.RWMutex
162 pOnuIndication *oop.OnuIndication
163 deviceReason uint8
164 mutexDeviceReason sync.RWMutex
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000165 pLockStateFsm *uniprt.LockStateFsm
166 pUnlockStateFsm *uniprt.LockStateFsm
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000167
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000168 //flowMgr *OpenOltFlowMgr
169 //eventMgr *OpenOltEventMgr
170 //resourceMgr *rsrcMgr.OpenOltResourceMgr
171
172 //discOnus sync.Map
173 //onus sync.Map
174 //portStats *OpenOltStatisticsMgr
Holger Hildebrandtff05b682021-03-16 15:02:05 +0000175 collectorIsRunning bool
176 mutexCollectorFlag sync.RWMutex
177 stopCollector chan bool
178 alarmManagerIsRunning bool
179 mutextAlarmManagerFlag sync.RWMutex
180 stopAlarmManager chan bool
181 stopHeartbeatCheck chan bool
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000182 uniEntityMap cmn.OnuUniPortMap
Holger Hildebrandtff05b682021-03-16 15:02:05 +0000183 mutexKvStoreContext sync.Mutex
184 lockVlanConfig sync.RWMutex
mpagenkobc4170a2021-08-17 16:42:10 +0000185 lockVlanAdd sync.RWMutex
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000186 UniVlanConfigFsmMap map[uint8]*avcfg.UniVlanConfigFsm
Holger Hildebrandtff05b682021-03-16 15:02:05 +0000187 lockUpgradeFsm sync.RWMutex
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000188 pOnuUpradeFsm *swupg.OnuUpgradeFsm
mpagenko59862f02021-10-11 08:53:18 +0000189 upgradeCanceled bool
Holger Hildebrandtff05b682021-03-16 15:02:05 +0000190 reconciling uint8
191 mutexReconcilingFlag sync.RWMutex
192 chReconcilingFinished chan bool //channel to indicate that reconciling has been finished
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000193 mutexReadyForOmciConfig sync.RWMutex
194 readyForOmciConfig bool
Holger Hildebrandtff05b682021-03-16 15:02:05 +0000195 deletionInProgress bool
196 mutexDeletionInProgressFlag sync.RWMutex
mpagenko38662d02021-08-11 09:45:19 +0000197 pLastUpgradeImageState *voltha.ImageState
198 upgradeFsmChan chan struct{}
Girish Gowdrae95687a2021-09-08 16:30:58 -0700199
200 flowCbChan []chan FlowCb
201 mutexFlowMonitoringRoutineFlag sync.RWMutex
202 stopFlowMonitoringRoutine []chan bool // length of slice equal to number of uni ports
203 isFlowMonitoringRoutineActive []bool // length of slice equal to number of uni ports
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000204}
205
Himani Chawla6d2ae152020-09-02 13:11:20 +0530206//newDeviceHandler creates a new device handler
khenaidoo7d3c5582021-08-11 18:09:44 -0400207func newDeviceHandler(ctx context.Context, cc *vgrpc.Client, ep eventif.EventProxy, device *voltha.Device, adapter *OpenONUAC) *deviceHandler {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530208 var dh deviceHandler
khenaidoo7d3c5582021-08-11 18:09:44 -0400209 dh.coreClient = cc
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000210 dh.EventProxy = ep
khenaidoo7d3c5582021-08-11 18:09:44 -0400211 dh.config = adapter.config
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000212 cloned := (proto.Clone(device)).(*voltha.Device)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000213 dh.DeviceID = cloned.Id
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000214 dh.DeviceType = cloned.Type
215 dh.adminState = "up"
216 dh.device = cloned
217 dh.pOpenOnuAc = adapter
218 dh.exitChannel = make(chan int, 1)
219 dh.lockDevice = sync.RWMutex{}
mpagenko3af1f032020-06-10 08:53:41 +0000220 dh.deviceEntrySet = make(chan bool, 1)
Holger Hildebrandt10d98192021-01-27 15:29:31 +0000221 dh.collectorIsRunning = false
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000222 dh.stopCollector = make(chan bool, 2)
Himani Chawla4c1d4c72021-02-18 12:14:31 +0530223 dh.alarmManagerIsRunning = false
Himani Chawlaac1f5ad2021-02-04 21:21:54 +0530224 dh.stopAlarmManager = make(chan bool, 2)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000225 dh.stopHeartbeatCheck = make(chan bool, 2)
226 //dh.metrics = pmmetrics.NewPmMetrics(cloned.Id, pmmetrics.Frequency(150), pmmetrics.FrequencyOverride(false), pmmetrics.Grouped(false), pmmetrics.Metrics(pmNames))
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000227 //TODO initialize the support classes.
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000228 dh.uniEntityMap = make(map[uint32]*cmn.OnuUniPort)
mpagenkof1fc3862021-02-16 10:09:52 +0000229 dh.lockVlanConfig = sync.RWMutex{}
mpagenkobc4170a2021-08-17 16:42:10 +0000230 dh.lockVlanAdd = sync.RWMutex{}
mpagenko80622a52021-02-09 16:53:23 +0000231 dh.lockUpgradeFsm = sync.RWMutex{}
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000232 dh.UniVlanConfigFsmMap = make(map[uint8]*avcfg.UniVlanConfigFsm)
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000233 dh.reconciling = cNoReconciling
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +0000234 dh.chReconcilingFinished = make(chan bool)
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000235 dh.readyForOmciConfig = false
Holger Hildebrandtff05b682021-03-16 15:02:05 +0000236 dh.deletionInProgress = false
mpagenko38662d02021-08-11 09:45:19 +0000237 dh.pLastUpgradeImageState = &voltha.ImageState{
238 DownloadState: voltha.ImageState_DOWNLOAD_UNKNOWN,
239 Reason: voltha.ImageState_UNKNOWN_ERROR,
240 ImageState: voltha.ImageState_IMAGE_UNKNOWN,
241 }
242 dh.upgradeFsmChan = make(chan struct{})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000243
Girish Gowdra5a7c4922021-01-22 18:33:41 -0800244 if dh.device.PmConfigs != nil { // can happen after onu adapter restart
245 dh.pmConfigs = cloned.PmConfigs
246 } /* else {
247 // will be populated when onu_metrics_mananger is initialized.
248 }*/
Girish Gowdrae09a6202021-01-12 18:10:59 -0800249
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000250 // Device related state machine
251 dh.pDeviceStateFsm = fsm.NewFSM(
mpagenko1cc3cb42020-07-27 15:24:38 +0000252 devStNull,
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000253 fsm.Events{
mpagenko1cc3cb42020-07-27 15:24:38 +0000254 {Name: devEvDeviceInit, Src: []string{devStNull, devStDown}, Dst: devStInit},
255 {Name: devEvGrpcConnected, Src: []string{devStInit}, Dst: devStConnected},
256 {Name: devEvGrpcDisconnected, Src: []string{devStConnected, devStDown}, Dst: devStInit},
257 {Name: devEvDeviceUpInd, Src: []string{devStConnected, devStDown}, Dst: devStUp},
258 {Name: devEvDeviceDownInd, Src: []string{devStUp}, Dst: devStDown},
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000259 },
260 fsm.Callbacks{
dbainbri4d3a0dc2020-12-02 00:33:42 +0000261 "before_event": func(e *fsm.Event) { dh.logStateChange(ctx, e) },
262 ("before_" + devEvDeviceInit): func(e *fsm.Event) { dh.doStateInit(ctx, e) },
263 ("after_" + devEvDeviceInit): func(e *fsm.Event) { dh.postInit(ctx, e) },
264 ("before_" + devEvGrpcConnected): func(e *fsm.Event) { dh.doStateConnected(ctx, e) },
265 ("before_" + devEvGrpcDisconnected): func(e *fsm.Event) { dh.doStateInit(ctx, e) },
266 ("after_" + devEvGrpcDisconnected): func(e *fsm.Event) { dh.postInit(ctx, e) },
267 ("before_" + devEvDeviceUpInd): func(e *fsm.Event) { dh.doStateUp(ctx, e) },
268 ("before_" + devEvDeviceDownInd): func(e *fsm.Event) { dh.doStateDown(ctx, e) },
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000269 },
270 )
mpagenkoaf801632020-07-03 10:00:42 +0000271
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000272 return &dh
273}
274
Himani Chawla6d2ae152020-09-02 13:11:20 +0530275// start save the device to the data model
276func (dh *deviceHandler) start(ctx context.Context) {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000277 logger.Debugw(ctx, "starting-device-handler", log.Fields{"device": dh.device, "device-id": dh.DeviceID})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000278 // Add the initial device to the local model
dbainbri4d3a0dc2020-12-02 00:33:42 +0000279 logger.Debug(ctx, "device-handler-started")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000280}
281
Himani Chawla4d908332020-08-31 12:30:20 +0530282/*
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000283// stop stops the device dh. Not much to do for now
Himani Chawla6d2ae152020-09-02 13:11:20 +0530284func (dh *deviceHandler) stop(ctx context.Context) {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000285 logger.Debug("stopping-device-handler")
286 dh.exitChannel <- 1
287}
Himani Chawla4d908332020-08-31 12:30:20 +0530288*/
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000289
290// ##########################################################################################
Himani Chawla6d2ae152020-09-02 13:11:20 +0530291// deviceHandler methods that implement the adapters interface requests ##### begin #########
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000292
Girish Gowdrae0140f02021-02-02 16:55:09 -0800293//adoptOrReconcileDevice adopts the ONU device
Himani Chawla6d2ae152020-09-02 13:11:20 +0530294func (dh *deviceHandler) adoptOrReconcileDevice(ctx context.Context, device *voltha.Device) {
khenaidoo7d3c5582021-08-11 18:09:44 -0400295 logger.Debugw(ctx, "adopt_or_reconcile_device", log.Fields{"device-id": device.Id, "Address": device.GetHostAndPort()})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000296
dbainbri4d3a0dc2020-12-02 00:33:42 +0000297 logger.Debugw(ctx, "Device FSM: ", log.Fields{"state": string(dh.pDeviceStateFsm.Current())})
mpagenko1cc3cb42020-07-27 15:24:38 +0000298 if dh.pDeviceStateFsm.Is(devStNull) {
299 if err := dh.pDeviceStateFsm.Event(devEvDeviceInit); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000300 logger.Errorw(ctx, "Device FSM: Can't go to state DeviceInit", log.Fields{"err": err})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000301 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000302 logger.Debugw(ctx, "Device FSM: ", log.Fields{"state": string(dh.pDeviceStateFsm.Current())})
Girish Gowdraaf0ad632021-01-27 13:00:01 -0800303 // device.PmConfigs is not nil in cases when adapter restarts. We should not re-set the core again.
304 if device.PmConfigs == nil {
Girish Gowdra5a7c4922021-01-22 18:33:41 -0800305 // Now, set the initial PM configuration for that device
khenaidoo7d3c5582021-08-11 18:09:44 -0400306 if err := dh.updatePMConfigInCore(ctx, dh.pmConfigs); err != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000307 logger.Errorw(ctx, "error updating pm config to core", log.Fields{"device-id": dh.DeviceID, "err": err})
Girish Gowdra5a7c4922021-01-22 18:33:41 -0800308 }
Girish Gowdrae09a6202021-01-12 18:10:59 -0800309 }
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000310 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000311 logger.Debugw(ctx, "AdoptOrReconcileDevice: Agent/device init already done", log.Fields{"device-id": device.Id})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000312 }
313
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000314}
315
khenaidoo7d3c5582021-08-11 18:09:44 -0400316func (dh *deviceHandler) handleOMCIIndication(ctx context.Context, msg *ic.OmciMessage) error {
mpagenko80622a52021-02-09 16:53:23 +0000317 /* msg print moved symmetrically to omci_cc, if wanted here as additional debug, than perhaps only based on additional debug setting!
Himani Chawla26e555c2020-08-31 12:30:20 +0530318 //assuming omci message content is hex coded!
319 // with restricted output of 16(?) bytes would be ...omciMsg.Message[:16]
dbainbri4d3a0dc2020-12-02 00:33:42 +0000320 logger.Debugw(ctx, "inter-adapter-recv-omci", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000321 "device-id": dh.DeviceID, "RxOmciMessage": hex.EncodeToString(omciMsg.Message)})
mpagenko80622a52021-02-09 16:53:23 +0000322 */
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000323 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
Himani Chawla26e555c2020-08-31 12:30:20 +0530324 if pDevEntry != nil {
Holger Hildebrandt2fb70892020-10-28 11:53:18 +0000325 if pDevEntry.PDevOmciCC != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000326 return pDevEntry.PDevOmciCC.ReceiveMessage(log.WithSpanFromContext(context.TODO(), ctx), msg.Message)
Holger Hildebrandt2fb70892020-10-28 11:53:18 +0000327 }
khenaidoo7d3c5582021-08-11 18:09:44 -0400328 logger.Debugw(ctx, "omciCC not ready to receive omci messages - incoming omci message ignored", log.Fields{"rxMsg": msg.Message})
Himani Chawla26e555c2020-08-31 12:30:20 +0530329 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000330 logger.Errorw(ctx, "No valid OnuDevice -aborting", log.Fields{"device-id": dh.DeviceID})
331 return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID)
Himani Chawla26e555c2020-08-31 12:30:20 +0530332}
333
khenaidoo7d3c5582021-08-11 18:09:44 -0400334func (dh *deviceHandler) handleTechProfileDownloadRequest(ctx context.Context, techProfMsg *ic.TechProfileDownloadMessage) error {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000335 logger.Infow(ctx, "tech-profile-download-request", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt80129db2020-11-23 10:49:32 +0000336
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000337 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000338 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000339 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
340 return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000341 }
Himani Chawla26e555c2020-08-31 12:30:20 +0530342 if dh.pOnuTP == nil {
343 //should normally not happen ...
dbainbri4d3a0dc2020-12-02 00:33:42 +0000344 logger.Errorw(ctx, "onuTechProf instance not set up for DLMsg request - ignoring request",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000345 log.Fields{"device-id": dh.DeviceID})
346 return fmt.Errorf("techProfile DLMsg request while onuTechProf instance not setup: %s", dh.DeviceID)
Himani Chawla26e555c2020-08-31 12:30:20 +0530347 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000348 if !dh.IsReadyForOmciConfig() {
349 logger.Errorw(ctx, "TechProf-set rejected: improper device state", log.Fields{"device-id": dh.DeviceID,
350 "device-state": dh.GetDeviceReasonString()})
351 return fmt.Errorf("improper device state %s on device %s", dh.GetDeviceReasonString(), dh.DeviceID)
Himani Chawla26e555c2020-08-31 12:30:20 +0530352 }
mpagenkofc4f56e2020-11-04 17:17:49 +0000353 //previous state test here was just this one, now extended for more states to reject the SetRequest:
354 // at least 'mib-downloaded' should be reached for processing of this specific ONU configuration
355 // if (dh.deviceReason == "stopping-openomci") || (dh.deviceReason == "omci-admin-lock")
Himani Chawla26e555c2020-08-31 12:30:20 +0530356
Himani Chawla26e555c2020-08-31 12:30:20 +0530357 // we have to lock access to TechProfile processing based on different messageType calls or
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000358 // even to fast subsequent calls of the same messageType as well as OnuKVStore processing due
359 // to possible concurrent access by flow processing
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000360 dh.pOnuTP.LockTpProcMutex()
361 defer dh.pOnuTP.UnlockTpProcMutex()
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000362
363 if techProfMsg.UniId > 255 {
364 return fmt.Errorf(fmt.Sprintf("received UniId value exceeds range: %d, device-id: %s",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000365 techProfMsg.UniId, dh.DeviceID))
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000366 }
367 uniID := uint8(techProfMsg.UniId)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000368 tpID, err := cmn.GetTpIDFromTpPath(techProfMsg.TpInstancePath)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800369 if err != nil {
Girish Gowdra50e56422021-06-01 16:46:04 -0700370 logger.Errorw(ctx, "error-parsing-tpid-from-tppath", log.Fields{"err": err, "tp-path": techProfMsg.TpInstancePath})
Girish Gowdra041dcb32020-11-16 16:54:30 -0800371 return err
372 }
Girish Gowdra50e56422021-06-01 16:46:04 -0700373 logger.Debugw(ctx, "unmarshal-techprof-msg-body", log.Fields{"uniID": uniID, "tp-path": techProfMsg.TpInstancePath, "tpID": tpID})
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000374
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000375 if bTpModify := pDevEntry.UpdateOnuUniTpPath(ctx, uniID, uint8(tpID), techProfMsg.TpInstancePath); bTpModify {
Himani Chawla26e555c2020-08-31 12:30:20 +0530376
Girish Gowdra50e56422021-06-01 16:46:04 -0700377 switch tpInst := techProfMsg.TechTpInstance.(type) {
khenaidoo7d3c5582021-08-11 18:09:44 -0400378 case *ic.TechProfileDownloadMessage_TpInstance:
Girish Gowdra50e56422021-06-01 16:46:04 -0700379 logger.Debugw(ctx, "onu-uni-tp-path-modified", log.Fields{"uniID": uniID, "tp-path": techProfMsg.TpInstancePath, "tpID": tpID})
380 // if there has been some change for some uni TechProfilePath
381 //in order to allow concurrent calls to other dh instances we do not wait for execution here
382 //but doing so we can not indicate problems to the caller (who does what with that then?)
383 //by now we just assume straightforward successful execution
384 //TODO!!! Generally: In this scheme it would be good to have some means to indicate
385 // possible problems to the caller later autonomously
Himani Chawla26e555c2020-08-31 12:30:20 +0530386
Girish Gowdra50e56422021-06-01 16:46:04 -0700387 // deadline context to ensure completion of background routines waited for
388 //20200721: 10s proved to be less in 8*8 ONU test on local vbox machine with debug, might be further adapted
389 deadline := time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution
390 dctx, cancel := context.WithDeadline(context.Background(), deadline)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000391
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000392 dh.pOnuTP.ResetTpProcessingErrorIndication(uniID, tpID)
Girish Gowdra50e56422021-06-01 16:46:04 -0700393
394 var wg sync.WaitGroup
395 wg.Add(1) // for the 1 go routine to finish
396 // attention: deadline completion check and wg.Done is to be done in both routines
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000397 go dh.pOnuTP.ConfigureUniTp(log.WithSpanFromContext(dctx, ctx), uniID, techProfMsg.TpInstancePath, *tpInst.TpInstance, &wg)
Girish Gowdra50e56422021-06-01 16:46:04 -0700398 dh.waitForCompletion(ctx, cancel, &wg, "TechProfDwld") //wait for background process to finish
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000399 if tpErr := dh.pOnuTP.GetTpProcessingErrorIndication(uniID, tpID); tpErr != nil {
400 logger.Errorw(ctx, "error-processing-tp", log.Fields{"device-id": dh.DeviceID, "err": tpErr, "tp-path": techProfMsg.TpInstancePath})
Girish Gowdra50e56422021-06-01 16:46:04 -0700401 return tpErr
402 }
403 deadline = time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution
404 dctx2, cancel2 := context.WithDeadline(context.Background(), deadline)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000405 pDevEntry.ResetKvProcessingErrorIndication()
Girish Gowdra50e56422021-06-01 16:46:04 -0700406 wg.Add(1) // for the 1 go routine to finish
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000407 go pDevEntry.UpdateOnuKvStore(log.WithSpanFromContext(dctx2, ctx), &wg)
Girish Gowdra50e56422021-06-01 16:46:04 -0700408 dh.waitForCompletion(ctx, cancel2, &wg, "TechProfDwld") //wait for background process to finish
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000409 if kvErr := pDevEntry.GetKvProcessingErrorIndication(); kvErr != nil {
410 logger.Errorw(ctx, "error-updating-KV", log.Fields{"device-id": dh.DeviceID, "err": kvErr, "tp-path": techProfMsg.TpInstancePath})
Girish Gowdra50e56422021-06-01 16:46:04 -0700411 return kvErr
412 }
413 return nil
414 default:
415 logger.Errorw(ctx, "unsupported-tp-instance-type", log.Fields{"tp-path": techProfMsg.TpInstancePath})
416 return fmt.Errorf("unsupported-tp-instance-type--tp-id-%v", techProfMsg.TpInstancePath)
Mahir Gunyel7f4483a2021-05-06 12:53:43 -0700417 }
Himani Chawla26e555c2020-08-31 12:30:20 +0530418 }
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000419 // no change, nothing really to do - return success
Girish Gowdra50e56422021-06-01 16:46:04 -0700420 logger.Debugw(ctx, "onu-uni-tp-path-not-modified", log.Fields{"uniID": uniID, "tp-path": techProfMsg.TpInstancePath, "tpID": tpID})
Himani Chawla26e555c2020-08-31 12:30:20 +0530421 return nil
422}
423
khenaidoo7d3c5582021-08-11 18:09:44 -0400424func (dh *deviceHandler) handleDeleteGemPortRequest(ctx context.Context, delGemPortMsg *ic.DeleteGemPortMessage) error {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000425 logger.Infow(ctx, "delete-gem-port-request", log.Fields{"device-id": dh.DeviceID})
Himani Chawla26e555c2020-08-31 12:30:20 +0530426
427 if dh.pOnuTP == nil {
428 //should normally not happen ...
dbainbri4d3a0dc2020-12-02 00:33:42 +0000429 logger.Warnw(ctx, "onuTechProf instance not set up for DelGem request - ignoring request",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000430 log.Fields{"device-id": dh.DeviceID})
431 return fmt.Errorf("techProfile DelGem request while onuTechProf instance not setup: %s", dh.DeviceID)
Himani Chawla26e555c2020-08-31 12:30:20 +0530432 }
Himani Chawla26e555c2020-08-31 12:30:20 +0530433 //compare TECH_PROFILE_DOWNLOAD_REQUEST
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000434 dh.pOnuTP.LockTpProcMutex()
435 defer dh.pOnuTP.UnlockTpProcMutex()
Himani Chawla26e555c2020-08-31 12:30:20 +0530436
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000437 if delGemPortMsg.UniId > 255 {
438 return fmt.Errorf(fmt.Sprintf("received UniId value exceeds range: %d, device-id: %s",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000439 delGemPortMsg.UniId, dh.DeviceID))
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000440 }
441 uniID := uint8(delGemPortMsg.UniId)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000442 tpID, err := cmn.GetTpIDFromTpPath(delGemPortMsg.TpInstancePath)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800443 if err != nil {
Girish Gowdra50e56422021-06-01 16:46:04 -0700444 logger.Errorw(ctx, "error-extracting-tp-id-from-tp-path", log.Fields{"err": err, "tp-path": delGemPortMsg.TpInstancePath})
Girish Gowdra041dcb32020-11-16 16:54:30 -0800445 return err
446 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000447 logger.Infow(ctx, "delete-gem-port-request", log.Fields{"device-id": dh.DeviceID, "uni-id": uniID, "tpID": tpID, "gem": delGemPortMsg.GemPortId})
mpagenkofc4f56e2020-11-04 17:17:49 +0000448 //a removal of some GemPort would never remove the complete TechProfile entry (done on T-Cont)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000449
Mahir Gunyel9545be22021-07-04 15:53:16 -0700450 return dh.deleteTechProfileResource(ctx, uniID, tpID, delGemPortMsg.TpInstancePath,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000451 avcfg.CResourceGemPort, delGemPortMsg.GemPortId)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000452
Himani Chawla26e555c2020-08-31 12:30:20 +0530453}
454
khenaidoo7d3c5582021-08-11 18:09:44 -0400455func (dh *deviceHandler) handleDeleteTcontRequest(ctx context.Context, delTcontMsg *ic.DeleteTcontMessage) error {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000456 logger.Infow(ctx, "delete-tcont-request", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000457
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000458 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000459 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000460 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
461 return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000462 }
Himani Chawla26e555c2020-08-31 12:30:20 +0530463 if dh.pOnuTP == nil {
464 //should normally not happen ...
dbainbri4d3a0dc2020-12-02 00:33:42 +0000465 logger.Warnw(ctx, "onuTechProf instance not set up for DelTcont request - ignoring request",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000466 log.Fields{"device-id": dh.DeviceID})
467 return fmt.Errorf("techProfile DelTcont request while onuTechProf instance not setup: %s", dh.DeviceID)
Himani Chawla26e555c2020-08-31 12:30:20 +0530468 }
469
Himani Chawla26e555c2020-08-31 12:30:20 +0530470 //compare TECH_PROFILE_DOWNLOAD_REQUEST
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000471 dh.pOnuTP.LockTpProcMutex()
472 defer dh.pOnuTP.UnlockTpProcMutex()
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000473
474 if delTcontMsg.UniId > 255 {
475 return fmt.Errorf(fmt.Sprintf("received UniId value exceeds range: %d, device-id: %s",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000476 delTcontMsg.UniId, dh.DeviceID))
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000477 }
478 uniID := uint8(delTcontMsg.UniId)
Girish Gowdra50e56422021-06-01 16:46:04 -0700479 tpPath := delTcontMsg.TpInstancePath
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000480 tpID, err := cmn.GetTpIDFromTpPath(tpPath)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800481 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000482 logger.Errorw(ctx, "error-extracting-tp-id-from-tp-path", log.Fields{"err": err, "tp-path": tpPath})
Girish Gowdra041dcb32020-11-16 16:54:30 -0800483 return err
484 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000485 logger.Infow(ctx, "delete-tcont-request", log.Fields{"device-id": dh.DeviceID, "uni-id": uniID, "tpID": tpID, "tcont": delTcontMsg.AllocId})
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000486
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000487 pDevEntry.FreeTcont(ctx, uint16(delTcontMsg.AllocId))
Himani Chawla26e555c2020-08-31 12:30:20 +0530488
Mahir Gunyel9545be22021-07-04 15:53:16 -0700489 return dh.deleteTechProfileResource(ctx, uniID, tpID, delTcontMsg.TpInstancePath,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000490 avcfg.CResourceTcont, delTcontMsg.AllocId)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000491
Mahir Gunyel9545be22021-07-04 15:53:16 -0700492}
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000493
Mahir Gunyel9545be22021-07-04 15:53:16 -0700494func (dh *deviceHandler) deleteTechProfileResource(ctx context.Context,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000495 uniID uint8, tpID uint8, pathString string, resource avcfg.ResourceEntry, entryID uint32) error {
496 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
Mahir Gunyel9545be22021-07-04 15:53:16 -0700497 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000498 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
499 return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID)
Himani Chawla26e555c2020-08-31 12:30:20 +0530500 }
Mahir Gunyel9545be22021-07-04 15:53:16 -0700501 var resourceName string
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000502 if avcfg.CResourceGemPort == resource {
Mahir Gunyel9545be22021-07-04 15:53:16 -0700503 resourceName = "Gem"
504 } else {
505 resourceName = "Tcont"
506 }
507
508 // deadline context to ensure completion of background routines waited for
509 deadline := time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution
510 dctx, cancel := context.WithDeadline(context.Background(), deadline)
511
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000512 dh.pOnuTP.ResetTpProcessingErrorIndication(uniID, tpID)
Mahir Gunyel9545be22021-07-04 15:53:16 -0700513
514 var wg sync.WaitGroup
515 wg.Add(1) // for the 1 go routine to finish
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000516 go dh.pOnuTP.DeleteTpResource(log.WithSpanFromContext(dctx, ctx), uniID, tpID, pathString,
Mahir Gunyel9545be22021-07-04 15:53:16 -0700517 resource, entryID, &wg)
518 dh.waitForCompletion(ctx, cancel, &wg, resourceName+"Delete") //wait for background process to finish
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000519 if err := dh.pOnuTP.GetTpProcessingErrorIndication(uniID, tpID); err != nil {
520 logger.Errorw(ctx, err.Error(), log.Fields{"device-id": dh.DeviceID})
Mahir Gunyel9545be22021-07-04 15:53:16 -0700521 return err
522 }
523
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000524 if dh.pOnuTP.IsTechProfileConfigCleared(ctx, uniID, tpID) {
525 logger.Debugw(ctx, "techProfile-config-cleared", log.Fields{"device-id": dh.DeviceID, "uni-id": uniID, "tpID": tpID})
526 if bTpModify := pDevEntry.UpdateOnuUniTpPath(ctx, uniID, tpID, ""); bTpModify {
527 pDevEntry.ResetKvProcessingErrorIndication()
Mahir Gunyel9545be22021-07-04 15:53:16 -0700528 var wg2 sync.WaitGroup
529 dctx2, cancel2 := context.WithDeadline(context.Background(), deadline)
530 wg2.Add(1)
531 // Removal of the gem id mapping represents the removal of the tech profile
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000532 logger.Infow(ctx, "remove-techProfile-indication-in-kv", log.Fields{"device-id": dh.DeviceID, "uni-id": uniID, "tpID": tpID})
533 go pDevEntry.UpdateOnuKvStore(log.WithSpanFromContext(dctx2, ctx), &wg2)
Mahir Gunyel9545be22021-07-04 15:53:16 -0700534 dh.waitForCompletion(ctx, cancel2, &wg2, "TechProfileDeleteOn"+resourceName) //wait for background process to finish
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000535 if err := pDevEntry.GetKvProcessingErrorIndication(); err != nil {
536 logger.Errorw(ctx, err.Error(), log.Fields{"device-id": dh.DeviceID})
Mahir Gunyel9545be22021-07-04 15:53:16 -0700537 return err
538 }
539 }
540 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000541 logger.Debugw(ctx, "delete-tech-profile-resource-completed", log.Fields{"device-id": dh.DeviceID,
Mahir Gunyel9545be22021-07-04 15:53:16 -0700542 "uni-id": uniID, "tpID": tpID, "resource-type": resourceName, "resource-id": entryID})
Himani Chawla26e555c2020-08-31 12:30:20 +0530543 return nil
544}
545
mpagenkodff5dda2020-08-28 11:52:01 +0000546//FlowUpdateIncremental removes and/or adds the flow changes on a given device
dbainbri4d3a0dc2020-12-02 00:33:42 +0000547func (dh *deviceHandler) FlowUpdateIncremental(ctx context.Context,
khenaidoo7d3c5582021-08-11 18:09:44 -0400548 apOfFlowChanges *of.FlowChanges,
549 apOfGroupChanges *of.FlowGroupChanges, apFlowMetaData *voltha.FlowMetadata) error {
Girish Gowdrae95687a2021-09-08 16:30:58 -0700550 logger.Debugw(ctx, "FlowUpdateIncremental started", log.Fields{"device-id": dh.DeviceID, "flow": apOfFlowChanges, "metadata": apFlowMetaData})
551 var errorsList []error
552 var retError error
mpagenko01e726e2020-10-23 09:45:29 +0000553 //Remove flows (always remove flows first - remove old and add new with same cookie may be part of the same request)
mpagenkodff5dda2020-08-28 11:52:01 +0000554 if apOfFlowChanges.ToRemove != nil {
555 for _, flowItem := range apOfFlowChanges.ToRemove.Items {
mpagenkodff5dda2020-08-28 11:52:01 +0000556 if flowItem.GetCookie() == 0 {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000557 logger.Warnw(ctx, "flow-remove no cookie: ignore and continuing on checking further flows", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000558 "device-id": dh.DeviceID})
559 retError = fmt.Errorf("flow-remove no cookie, device-id %s", dh.DeviceID)
Girish Gowdrae95687a2021-09-08 16:30:58 -0700560 errorsList = append(errorsList, retError)
mpagenkodff5dda2020-08-28 11:52:01 +0000561 continue
562 }
563 flowInPort := flow.GetInPort(flowItem)
564 if flowInPort == uint32(of.OfpPortNo_OFPP_INVALID) {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000565 logger.Warnw(ctx, "flow-remove inPort invalid: ignore and continuing on checking further flows", log.Fields{"device-id": dh.DeviceID})
566 retError = fmt.Errorf("flow-remove inPort invalid, device-id %s", dh.DeviceID)
Girish Gowdrae95687a2021-09-08 16:30:58 -0700567 errorsList = append(errorsList, retError)
mpagenko01e726e2020-10-23 09:45:29 +0000568 continue
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000569 //return fmt.Errorf("flow inPort invalid: %s", dh.DeviceID)
mpagenkodff5dda2020-08-28 11:52:01 +0000570 } else if flowInPort == dh.ponPortNumber {
mpagenko01e726e2020-10-23 09:45:29 +0000571 //this is some downstream flow, not regarded as error, just ignored
dbainbri4d3a0dc2020-12-02 00:33:42 +0000572 logger.Debugw(ctx, "flow-remove for downstream: ignore and continuing on checking further flows", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000573 "device-id": dh.DeviceID, "inPort": flowInPort})
mpagenkodff5dda2020-08-28 11:52:01 +0000574 continue
575 } else {
576 // this is the relevant upstream flow
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000577 var loUniPort *cmn.OnuUniPort
mpagenkodff5dda2020-08-28 11:52:01 +0000578 if uniPort, exist := dh.uniEntityMap[flowInPort]; exist {
579 loUniPort = uniPort
580 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000581 logger.Warnw(ctx, "flow-remove inPort not found in UniPorts: ignore and continuing on checking further flows",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000582 log.Fields{"device-id": dh.DeviceID, "inPort": flowInPort})
mpagenko01e726e2020-10-23 09:45:29 +0000583 retError = fmt.Errorf("flow-remove inPort not found in UniPorts, inPort %d, device-id %s",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000584 flowInPort, dh.DeviceID)
Girish Gowdrae95687a2021-09-08 16:30:58 -0700585 errorsList = append(errorsList, retError)
mpagenko01e726e2020-10-23 09:45:29 +0000586 continue
mpagenkodff5dda2020-08-28 11:52:01 +0000587 }
588 flowOutPort := flow.GetOutPort(flowItem)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000589 logger.Debugw(ctx, "flow-remove port indications", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000590 "device-id": dh.DeviceID, "inPort": flowInPort, "outPort": flowOutPort,
591 "uniPortName": loUniPort.Name})
Girish Gowdrae95687a2021-09-08 16:30:58 -0700592
593 if dh.GetFlowMonitoringIsRunning(loUniPort.UniID) {
594 // Step1 : Fill flowControlBlock
595 // Step2 : Push the flowControlBlock to ONU channel
596 // Step3 : Wait on response channel for response
597 // Step4 : Return error value
598 startTime := time.Now()
599 respChan := make(chan error)
600 flowCb := FlowCb{
601 ctx: ctx,
602 addFlow: false,
603 flowItem: flowItem,
604 flowMetaData: nil,
605 uniPort: loUniPort,
606 respChan: &respChan,
607 }
608 dh.flowCbChan[loUniPort.UniID] <- flowCb
609 logger.Infow(ctx, "process-flow-remove-start", log.Fields{"device-id": dh.DeviceID})
610 // Wait on the channel for flow handlers return value
611 retError = <-respChan
612 logger.Infow(ctx, "process-flow-remove-end", log.Fields{"device-id": dh.DeviceID, "err": retError, "totalTimeSeconds": time.Since(startTime).Seconds()})
613 if retError != nil {
614 logger.Warnw(ctx, "flow-delete processing error: continuing on checking further flows",
615 log.Fields{"device-id": dh.DeviceID, "error": retError})
616 errorsList = append(errorsList, retError)
617 continue
618 }
619 } else {
620 retError = fmt.Errorf("flow-handler-routine-not-active-for-onu--device-id-%v", dh.DeviceID)
621 errorsList = append(errorsList, retError)
mpagenkodff5dda2020-08-28 11:52:01 +0000622 }
623 }
624 }
625 }
mpagenko01e726e2020-10-23 09:45:29 +0000626 if apOfFlowChanges.ToAdd != nil {
627 for _, flowItem := range apOfFlowChanges.ToAdd.Items {
628 if flowItem.GetCookie() == 0 {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000629 logger.Debugw(ctx, "incremental flow-add no cookie: ignore and continuing on checking further flows", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000630 "device-id": dh.DeviceID})
631 retError = fmt.Errorf("flow-add no cookie, device-id %s", dh.DeviceID)
Girish Gowdrae95687a2021-09-08 16:30:58 -0700632 errorsList = append(errorsList, retError)
mpagenko01e726e2020-10-23 09:45:29 +0000633 continue
634 }
635 flowInPort := flow.GetInPort(flowItem)
636 if flowInPort == uint32(of.OfpPortNo_OFPP_INVALID) {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000637 logger.Warnw(ctx, "flow-add inPort invalid: ignore and continuing on checking further flows", log.Fields{"device-id": dh.DeviceID})
638 retError = fmt.Errorf("flow-add inPort invalid, device-id %s", dh.DeviceID)
Girish Gowdrae95687a2021-09-08 16:30:58 -0700639 errorsList = append(errorsList, retError)
mpagenko01e726e2020-10-23 09:45:29 +0000640 continue
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000641 //return fmt.Errorf("flow inPort invalid: %s", dh.DeviceID)
mpagenko01e726e2020-10-23 09:45:29 +0000642 } else if flowInPort == dh.ponPortNumber {
643 //this is some downstream flow
dbainbri4d3a0dc2020-12-02 00:33:42 +0000644 logger.Debugw(ctx, "flow-add for downstream: ignore and continuing on checking further flows", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000645 "device-id": dh.DeviceID, "inPort": flowInPort})
mpagenko01e726e2020-10-23 09:45:29 +0000646 continue
647 } else {
648 // this is the relevant upstream flow
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000649 var loUniPort *cmn.OnuUniPort
mpagenko01e726e2020-10-23 09:45:29 +0000650 if uniPort, exist := dh.uniEntityMap[flowInPort]; exist {
651 loUniPort = uniPort
652 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000653 logger.Warnw(ctx, "flow-add inPort not found in UniPorts: ignore and continuing on checking further flows",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000654 log.Fields{"device-id": dh.DeviceID, "inPort": flowInPort})
mpagenko01e726e2020-10-23 09:45:29 +0000655 retError = fmt.Errorf("flow-add inPort not found in UniPorts, inPort %d, device-id %s",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000656 flowInPort, dh.DeviceID)
Girish Gowdrae95687a2021-09-08 16:30:58 -0700657 errorsList = append(errorsList, retError)
mpagenko01e726e2020-10-23 09:45:29 +0000658 continue
mpagenko01e726e2020-10-23 09:45:29 +0000659 }
mpagenkofc4f56e2020-11-04 17:17:49 +0000660 // let's still assume that we receive the flow-add only in some 'active' device state (as so far observed)
661 // if not, we just throw some error here to have an indication about that, if we really need to support that
662 // then we would need to create some means to activate the internal stored flows
663 // after the device gets active automatically (and still with its dependency to the TechProfile)
664 // for state checking compare also code here: processInterAdapterTechProfileDownloadReqMessage
665 // also abort for the other still possible flows here
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000666 if !dh.IsReadyForOmciConfig() {
667 logger.Errorw(ctx, "flow-add rejected: improper device state", log.Fields{"device-id": dh.DeviceID,
668 "last device-reason": dh.GetDeviceReasonString()})
Girish Gowdrae95687a2021-09-08 16:30:58 -0700669 retError = fmt.Errorf("improper device state on device %s", dh.DeviceID)
670 errorsList = append(errorsList, retError)
671 continue
mpagenkofc4f56e2020-11-04 17:17:49 +0000672 }
673
mpagenko01e726e2020-10-23 09:45:29 +0000674 flowOutPort := flow.GetOutPort(flowItem)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000675 logger.Debugw(ctx, "flow-add port indications", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000676 "device-id": dh.DeviceID, "inPort": flowInPort, "outPort": flowOutPort,
677 "uniPortName": loUniPort.Name})
Girish Gowdrae95687a2021-09-08 16:30:58 -0700678 if dh.GetFlowMonitoringIsRunning(loUniPort.UniID) {
679 // Step1 : Fill flowControlBlock
680 // Step2 : Push the flowControlBlock to ONU channel
681 // Step3 : Wait on response channel for response
682 // Step4 : Return error value
683 startTime := time.Now()
684 respChan := make(chan error)
685 flowCb := FlowCb{
686 ctx: ctx,
687 addFlow: true,
688 flowItem: flowItem,
689 flowMetaData: apFlowMetaData,
690 uniPort: loUniPort,
691 respChan: &respChan,
692 }
693 dh.flowCbChan[loUniPort.UniID] <- flowCb
694 logger.Infow(ctx, "process-flow-add-start", log.Fields{"device-id": dh.DeviceID})
695 // Wait on the channel for flow handlers return value
696 retError = <-respChan
697 logger.Infow(ctx, "process-flow-add-end", log.Fields{"device-id": dh.DeviceID, "err": retError, "totalTimeSeconds": time.Since(startTime).Seconds()})
698 if retError != nil {
699 logger.Warnw(ctx, "flow-add processing error: continuing on checking further flows",
700 log.Fields{"device-id": dh.DeviceID, "error": retError})
701 errorsList = append(errorsList, retError)
702 continue
703 }
704 } else {
705 retError = fmt.Errorf("flow-handler-routine-not-active-for-onu--device-id-%v", dh.DeviceID)
706 errorsList = append(errorsList, retError)
mpagenko01e726e2020-10-23 09:45:29 +0000707 }
708 }
709 }
710 }
Girish Gowdrae95687a2021-09-08 16:30:58 -0700711 if len(errorsList) > 0 {
712 logger.Errorw(ctx, "error-processing-flow", log.Fields{"device-id": dh.DeviceID, "errList": errorsList})
713 return fmt.Errorf("errors-installing-one-or-more-flows-groups, errors:%v", errorsList)
714 }
715 return nil
mpagenkodff5dda2020-08-28 11:52:01 +0000716}
717
Himani Chawla6d2ae152020-09-02 13:11:20 +0530718//disableDevice locks the ONU and its UNI/VEIP ports (admin lock via OMCI)
mpagenkofc4f56e2020-11-04 17:17:49 +0000719//following are the expected device states after this activity:
720//Device Admin-State : down (on rwCore), Port-State: UNKNOWN, Conn-State: REACHABLE, Reason: omci-admin-lock
721// (Conn-State: REACHABLE might conflict with some previous ONU Down indication - maybe to be resolved later)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000722func (dh *deviceHandler) disableDevice(ctx context.Context, device *voltha.Device) {
723 logger.Debugw(ctx, "disable-device", log.Fields{"device-id": device.Id, "SerialNumber": device.SerialNumber})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000724
mpagenko900ee4b2020-10-12 11:56:34 +0000725 //admin-lock reason can also be used uniquely for setting the DeviceState accordingly
mpagenkofc4f56e2020-11-04 17:17:49 +0000726 //note that disableDevice sequences in some 'ONU active' state may yield also
727 // "tech...delete-success" or "omci-flow-deleted" according to further received requests in the end
mpagenko900ee4b2020-10-12 11:56:34 +0000728 // - inblock state checking to prevent possibly unneeded processing (on command repitition)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000729 if dh.getDeviceReason() != cmn.DrOmciAdminLock {
mpagenkofc4f56e2020-11-04 17:17:49 +0000730 //disable-device shall be just a UNi/ONU-G related admin state setting
731 //all other configurations/FSM's shall not be impacted and shall execute as required by the system
mpagenko900ee4b2020-10-12 11:56:34 +0000732
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000733 if dh.IsReadyForOmciConfig() {
mpagenko01e726e2020-10-23 09:45:29 +0000734 // disable UNI ports/ONU
735 // *** should generate UniDisableStateDone event - used to disable the port(s) on success
736 if dh.pLockStateFsm == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000737 dh.createUniLockFsm(ctx, true, cmn.UniDisableStateDone)
mpagenko01e726e2020-10-23 09:45:29 +0000738 } else { //LockStateFSM already init
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000739 dh.pLockStateFsm.SetSuccessEvent(cmn.UniDisableStateDone)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000740 dh.runUniLockFsm(ctx, true)
mpagenko01e726e2020-10-23 09:45:29 +0000741 }
742 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000743 logger.Debugw(ctx, "DeviceStateUpdate upon disable", log.Fields{"ConnectStatus": voltha.ConnectStatus_REACHABLE,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000744 "OperStatus": voltha.OperStatus_UNKNOWN, "device-id": dh.DeviceID})
khenaidoo7d3c5582021-08-11 18:09:44 -0400745 if err := dh.updateDeviceStateInCore(ctx, &ic.DeviceStateFilter{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000746 DeviceId: dh.DeviceID,
khenaidoo7d3c5582021-08-11 18:09:44 -0400747 ConnStatus: voltha.ConnectStatus_REACHABLE,
748 OperStatus: voltha.OperStatus_UNKNOWN,
749 }); err != nil {
mpagenko01e726e2020-10-23 09:45:29 +0000750 //TODO with VOL-3045/VOL-3046: return the error and stop further processing
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000751 logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err})
mpagenko01e726e2020-10-23 09:45:29 +0000752 }
mpagenko01e726e2020-10-23 09:45:29 +0000753 // DeviceReason to update acc.to modified py code as per beginning of Sept 2020
Holger Hildebrandt80129db2020-11-23 10:49:32 +0000754
755 //TODO with VOL-3045/VOL-3046: catch and return error, valid for all occurrences in the codebase
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000756 _ = dh.deviceReasonUpdate(ctx, cmn.DrOmciAdminLock, true)
mpagenko3af1f032020-06-10 08:53:41 +0000757 }
ozgecanetsiafce57b12020-05-25 14:39:35 +0300758 }
759}
760
Himani Chawla6d2ae152020-09-02 13:11:20 +0530761//reEnableDevice unlocks the ONU and its UNI/VEIP ports (admin unlock via OMCI)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000762func (dh *deviceHandler) reEnableDevice(ctx context.Context, device *voltha.Device) {
763 logger.Debugw(ctx, "reenable-device", log.Fields{"device-id": device.Id, "SerialNumber": device.SerialNumber})
mpagenko3af1f032020-06-10 08:53:41 +0000764
mpagenkoaa3afe92021-05-21 16:20:58 +0000765 //setting readyForOmciConfig here is just a workaround for BBSIM testing in the sequence
mpagenkofc4f56e2020-11-04 17:17:49 +0000766 // OnuSoftReboot-disable-enable, because BBSIM does not generate a new OnuIndication-Up event after SoftReboot
767 // which is the assumption for real ONU's, where the ready-state is then set according to the following MibUpload/Download
768 // for real ONU's that should have nearly no influence
769 // Note that for real ONU's there is anyway a problematic situation with following sequence:
770 // OnuIndication-Dw (or not active at all) (- disable) - enable: here already the LockFsm may run into timeout (no OmciResponse)
771 // but that anyway is hopefully resolved by some OnuIndication-Up event (maybe to be tested)
772 // one could also argue, that a device-enable should also enable attempts for specific omci configuration
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000773 dh.SetReadyForOmciConfig(true) //needed to allow subsequent flow/techProf config (on BBSIM)
mpagenkofc4f56e2020-11-04 17:17:49 +0000774
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000775 // enable ONU/UNI ports
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000776 // *** should generate cmn.UniEnableStateDone event - used to disable the port(s) on success
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000777 if dh.pUnlockStateFsm == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000778 dh.createUniLockFsm(ctx, false, cmn.UniEnableStateDone)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000779 } else { //UnlockStateFSM already init
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000780 dh.pUnlockStateFsm.SetSuccessEvent(cmn.UniEnableStateDone)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000781 dh.runUniLockFsm(ctx, false)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000782 }
ozgecanetsiafce57b12020-05-25 14:39:35 +0300783}
784
dbainbri4d3a0dc2020-12-02 00:33:42 +0000785func (dh *deviceHandler) reconcileDeviceOnuInd(ctx context.Context) {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000786 logger.Debugw(ctx, "reconciling - simulate onu indication", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtf41a1602020-08-19 09:52:50 +0000787
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000788 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000789 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000790 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000791 return
792 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000793 if err := pDevEntry.RestoreDataFromOnuKvStore(log.WithSpanFromContext(context.TODO(), ctx)); err != nil {
mpagenko2418ab02020-11-12 12:58:06 +0000794 if err == fmt.Errorf("no-ONU-data-found") {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000795 logger.Debugw(ctx, "no persistent data found - abort reconciling", log.Fields{"device-id": dh.DeviceID})
mpagenko2418ab02020-11-12 12:58:06 +0000796 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000797 logger.Errorw(ctx, "reconciling - restoring OnuTp-data failed - abort", log.Fields{"err": err, "device-id": dh.DeviceID})
mpagenko2418ab02020-11-12 12:58:06 +0000798 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000799 dh.StopReconciling(ctx, false)
Holger Hildebrandtf41a1602020-08-19 09:52:50 +0000800 return
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000801 }
Himani Chawla4d908332020-08-31 12:30:20 +0530802 var onuIndication oop.OnuIndication
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000803 pDevEntry.MutexPersOnuConfig.RLock()
804 onuIndication.IntfId = pDevEntry.SOnuPersistentData.PersIntfID
805 onuIndication.OnuId = pDevEntry.SOnuPersistentData.PersOnuID
806 onuIndication.OperState = pDevEntry.SOnuPersistentData.PersOperState
807 onuIndication.AdminState = pDevEntry.SOnuPersistentData.PersAdminState
808 pDevEntry.MutexPersOnuConfig.RUnlock()
dbainbri4d3a0dc2020-12-02 00:33:42 +0000809 _ = dh.createInterface(ctx, &onuIndication)
Holger Hildebrandtf41a1602020-08-19 09:52:50 +0000810}
811
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000812func (dh *deviceHandler) ReconcileDeviceTechProf(ctx context.Context) {
813 logger.Debugw(ctx, "reconciling - trigger tech profile config", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtf41a1602020-08-19 09:52:50 +0000814
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000815 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000816 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000817 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
818 if !dh.IsSkipOnuConfigReconciling() {
819 dh.StopReconciling(ctx, false)
Holger Hildebrandt7e9de862021-03-26 14:01:49 +0000820 }
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000821 return
822 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000823 dh.pOnuTP.LockTpProcMutex()
824 defer dh.pOnuTP.UnlockTpProcMutex()
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000825
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000826 pDevEntry.MutexPersOnuConfig.RLock()
mpagenko2dc896e2021-08-02 12:03:59 +0000827 persMutexLock := true
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000828 if len(pDevEntry.SOnuPersistentData.PersUniConfig) == 0 {
829 pDevEntry.MutexPersOnuConfig.RUnlock()
dbainbri4d3a0dc2020-12-02 00:33:42 +0000830 logger.Debugw(ctx, "reconciling - no uni-configs have been stored before adapter restart - terminate reconcilement",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000831 log.Fields{"device-id": dh.DeviceID})
832 if !dh.IsSkipOnuConfigReconciling() {
833 dh.StopReconciling(ctx, true)
Holger Hildebrandt7e9de862021-03-26 14:01:49 +0000834 }
Holger Hildebrandt3a644642020-12-02 09:46:18 +0000835 return
836 }
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000837 flowsFound := false
Girish Gowdra50e56422021-06-01 16:46:04 -0700838 techProfsFound := false
839 techProfInstLoadFailed := false
840outerLoop:
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000841 for _, uniData := range pDevEntry.SOnuPersistentData.PersUniConfig {
Holger Hildebrandt3a644642020-12-02 09:46:18 +0000842 //TODO: check for uni-port specific reconcilement in case of multi-uni-port-per-onu-support
843 if len(uniData.PersTpPathMap) == 0 {
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000844 logger.Debugw(ctx, "reconciling - no TPs stored for uniID",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000845 log.Fields{"uni-id": uniData.PersUniID, "device-id": dh.DeviceID})
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000846 continue
Holger Hildebrandt3a644642020-12-02 09:46:18 +0000847 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000848 //release MutexPersOnuConfig before TechProfile (ANIConfig) processing as otherwise the reception of
849 // OMCI frames may get completely stuck due to lock request within IncrementMibDataSync() at OMCI
mpagenko2dc896e2021-08-02 12:03:59 +0000850 // frame reception may also lock the complete OMCI reception processing based on mutexRxSchedMap
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000851 pDevEntry.MutexPersOnuConfig.RUnlock()
mpagenko2dc896e2021-08-02 12:03:59 +0000852 persMutexLock = false
Girish Gowdra50e56422021-06-01 16:46:04 -0700853 techProfsFound = true // set to true if we found TP once for any UNI port
Girish Gowdra041dcb32020-11-16 16:54:30 -0800854 for tpID := range uniData.PersTpPathMap {
Girish Gowdra50e56422021-06-01 16:46:04 -0700855 // Request the TpInstance again from the openolt adapter in case of reconcile
khenaidoo7d3c5582021-08-11 18:09:44 -0400856 iaTechTpInst, err := dh.getTechProfileInstanceFromParentAdapter(ctx,
857 dh.device.ProxyAddress.AdapterEndpoint,
858 &ic.TechProfileInstanceRequestMessage{
859 DeviceId: dh.device.Id,
860 TpInstancePath: uniData.PersTpPathMap[tpID],
861 ParentDeviceId: dh.parentID,
862 ParentPonPort: dh.device.ParentPortNo,
863 OnuId: dh.device.ProxyAddress.OnuId,
864 UniId: uint32(uniData.PersUniID),
865 })
Girish Gowdra50e56422021-06-01 16:46:04 -0700866 if err != nil || iaTechTpInst == nil {
867 logger.Errorw(ctx, "error fetching tp instance",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000868 log.Fields{"tp-id": tpID, "tpPath": uniData.PersTpPathMap[tpID], "uni-id": uniData.PersUniID, "device-id": dh.DeviceID, "err": err})
Girish Gowdra50e56422021-06-01 16:46:04 -0700869 techProfInstLoadFailed = true // stop loading tp instance as soon as we hit failure
870 break outerLoop
871 }
872 var tpInst tech_profile.TechProfileInstance
873 switch techTpInst := iaTechTpInst.TechTpInstance.(type) {
khenaidoo7d3c5582021-08-11 18:09:44 -0400874 case *ic.TechProfileDownloadMessage_TpInstance: // supports only GPON, XGPON, XGS-PON
Girish Gowdra50e56422021-06-01 16:46:04 -0700875 tpInst = *techTpInst.TpInstance
mpagenko2dc896e2021-08-02 12:03:59 +0000876 logger.Debugw(ctx, "received-tp-instance-successfully-after-reconcile", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000877 "tp-id": tpID, "tpPath": uniData.PersTpPathMap[tpID], "uni-id": uniData.PersUniID, "device-id": dh.DeviceID})
Girish Gowdra50e56422021-06-01 16:46:04 -0700878 default: // do not support epon or other tech
mpagenko2dc896e2021-08-02 12:03:59 +0000879 logger.Errorw(ctx, "unsupported-tech-profile", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000880 "tp-id": tpID, "tpPath": uniData.PersTpPathMap[tpID], "uni-id": uniData.PersUniID, "device-id": dh.DeviceID})
Girish Gowdra50e56422021-06-01 16:46:04 -0700881 techProfInstLoadFailed = true // stop loading tp instance as soon as we hit failure
882 break outerLoop
883 }
884
Girish Gowdra041dcb32020-11-16 16:54:30 -0800885 // deadline context to ensure completion of background routines waited for
886 //20200721: 10s proved to be less in 8*8 ONU test on local vbox machine with debug, might be further adapted
887 deadline := time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution
dbainbri4d3a0dc2020-12-02 00:33:42 +0000888 dctx, cancel := context.WithDeadline(ctx, deadline)
Holger Hildebrandtf41a1602020-08-19 09:52:50 +0000889
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000890 dh.pOnuTP.ResetTpProcessingErrorIndication(uniData.PersUniID, tpID)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800891 var wg sync.WaitGroup
892 wg.Add(1) // for the 1 go routine to finish
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000893 go dh.pOnuTP.ConfigureUniTp(log.WithSpanFromContext(dctx, ctx), uniData.PersUniID, uniData.PersTpPathMap[tpID], tpInst, &wg)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000894 dh.waitForCompletion(ctx, cancel, &wg, "TechProfReconcile") //wait for background process to finish
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000895 if err := dh.pOnuTP.GetTpProcessingErrorIndication(uniData.PersUniID, tpID); err != nil {
896 logger.Errorw(ctx, err.Error(), log.Fields{"device-id": dh.DeviceID})
Girish Gowdra50e56422021-06-01 16:46:04 -0700897 techProfInstLoadFailed = true // stop loading tp instance as soon as we hit failure
898 break outerLoop
Girish Gowdra041dcb32020-11-16 16:54:30 -0800899 }
mpagenko2dc896e2021-08-02 12:03:59 +0000900 } // for all TpPath entries for this UNI
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000901 if len(uniData.PersFlowParams) != 0 {
902 flowsFound = true
Holger Hildebrandt3a644642020-12-02 09:46:18 +0000903 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000904 pDevEntry.MutexPersOnuConfig.RLock() //set protection again for loop test on SOnuPersistentData
mpagenko2dc896e2021-08-02 12:03:59 +0000905 persMutexLock = true
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000906 } // for all UNI entries from SOnuPersistentData
907 if persMutexLock { // if loop was left with MutexPersOnuConfig still set
908 pDevEntry.MutexPersOnuConfig.RUnlock()
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000909 }
mpagenko2dc896e2021-08-02 12:03:59 +0000910
911 //had to move techProf/flow result evaluation into separate function due to SCA complexity limit
912 dh.updateReconcileStates(ctx, techProfsFound, techProfInstLoadFailed, flowsFound)
913}
914
915func (dh *deviceHandler) updateReconcileStates(ctx context.Context,
916 abTechProfsFound bool, abTechProfInstLoadFailed bool, abFlowsFound bool) {
917 if !abTechProfsFound {
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000918 logger.Debugw(ctx, "reconciling - no TPs have been stored before adapter restart - terminate reconcilement",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000919 log.Fields{"device-id": dh.DeviceID})
920 if !dh.IsSkipOnuConfigReconciling() {
921 dh.StopReconciling(ctx, true)
Holger Hildebrandt7e9de862021-03-26 14:01:49 +0000922 }
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000923 return
924 }
mpagenko2dc896e2021-08-02 12:03:59 +0000925 if abTechProfInstLoadFailed {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000926 dh.SetDeviceReason(cmn.DrTechProfileConfigDownloadFailed)
927 dh.StopReconciling(ctx, false)
Girish Gowdra50e56422021-06-01 16:46:04 -0700928 return
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000929 } else if dh.IsSkipOnuConfigReconciling() {
930 dh.SetDeviceReason(cmn.DrTechProfileConfigDownloadSuccess)
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000931 }
mpagenko2dc896e2021-08-02 12:03:59 +0000932 if !abFlowsFound {
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000933 logger.Debugw(ctx, "reconciling - no flows have been stored before adapter restart - terminate reconcilement",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000934 log.Fields{"device-id": dh.DeviceID})
935 if !dh.IsSkipOnuConfigReconciling() {
936 dh.StopReconciling(ctx, true)
Holger Hildebrandt7e9de862021-03-26 14:01:49 +0000937 }
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000938 }
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000939}
940
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000941func (dh *deviceHandler) ReconcileDeviceFlowConfig(ctx context.Context) {
942 logger.Debugw(ctx, "reconciling - trigger flow config", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000943
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000944 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000945 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000946 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
947 if !dh.IsSkipOnuConfigReconciling() {
948 dh.StopReconciling(ctx, false)
Holger Hildebrandt7e9de862021-03-26 14:01:49 +0000949 }
Holger Hildebrandtf41a1602020-08-19 09:52:50 +0000950 return
951 }
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000952
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000953 pDevEntry.MutexPersOnuConfig.RLock()
954 if len(pDevEntry.SOnuPersistentData.PersUniConfig) == 0 {
955 pDevEntry.MutexPersOnuConfig.RUnlock()
dbainbri4d3a0dc2020-12-02 00:33:42 +0000956 logger.Debugw(ctx, "reconciling - no uni-configs have been stored before adapter restart - terminate reconcilement",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000957 log.Fields{"device-id": dh.DeviceID})
958 if !dh.IsSkipOnuConfigReconciling() {
959 dh.StopReconciling(ctx, true)
Holger Hildebrandt7e9de862021-03-26 14:01:49 +0000960 }
Holger Hildebrandt3a644642020-12-02 09:46:18 +0000961 return
962 }
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000963 flowsFound := false
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000964 for _, uniData := range pDevEntry.SOnuPersistentData.PersUniConfig {
Holger Hildebrandt3a644642020-12-02 09:46:18 +0000965 //TODO: check for uni-port specific reconcilement in case of multi-uni-port-per-onu-support
966 if len(uniData.PersFlowParams) == 0 {
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000967 logger.Debugw(ctx, "reconciling - no flows stored for uniID",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000968 log.Fields{"uni-id": uniData.PersUniID, "device-id": dh.DeviceID})
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000969 continue
970 }
971 if len(uniData.PersTpPathMap) == 0 {
972 logger.Warnw(ctx, "reconciling - flows but no TPs stored for uniID",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000973 log.Fields{"uni-id": uniData.PersUniID, "device-id": dh.DeviceID})
Holger Hildebrandt7e9de862021-03-26 14:01:49 +0000974 // It doesn't make sense to configure any flows if no TPs are available
975 continue
Holger Hildebrandt3a644642020-12-02 09:46:18 +0000976 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000977 //release MutexPersOnuConfig before VlanConfig processing as otherwise the reception of
978 // OMCI frames may get completely stuck due to lock request within IncrementMibDataSync() at OMCI
mpagenko2dc896e2021-08-02 12:03:59 +0000979 // frame reception may also lock the complete OMCI reception processing based on mutexRxSchedMap
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000980 pDevEntry.MutexPersOnuConfig.RUnlock()
mpagenko2dc896e2021-08-02 12:03:59 +0000981
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000982 var uniPort *cmn.OnuUniPort
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000983 var exist bool
Mahir Gunyelcb128ae2021-10-06 09:42:05 -0700984 uniNo := platform.MkUniPortNum(ctx, dh.pOnuIndication.GetIntfId(), dh.pOnuIndication.GetOnuId(), uint32(uniData.PersUniID))
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000985 if uniPort, exist = dh.uniEntityMap[uniNo]; !exist {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000986 logger.Errorw(ctx, "reconciling - OnuUniPort data not found - terminate reconcilement",
987 log.Fields{"uniNo": uniNo, "device-id": dh.DeviceID})
988 if !dh.IsSkipOnuConfigReconciling() {
989 dh.StopReconciling(ctx, false)
Holger Hildebrandt7e9de862021-03-26 14:01:49 +0000990 }
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000991 return
992 }
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000993 flowsFound = true
Andrea Campanellaf66ac6e2021-05-24 17:09:20 +0200994 lastFlowToReconcile := false
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000995 flowsProcessed := 0
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000996 pDevEntry.SetReconcilingFlows(true)
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000997 for _, flowData := range uniData.PersFlowParams {
mpagenko2dc896e2021-08-02 12:03:59 +0000998 logger.Debugw(ctx, "reconciling - add flow with cookie slice", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +0000999 "device-id": dh.DeviceID, "uni-id": uniData.PersUniID, "cookies": flowData.CookieSlice})
Andrea Campanellaf66ac6e2021-05-24 17:09:20 +02001000 if flowsProcessed == len(uniData.PersFlowParams)-1 {
1001 lastFlowToReconcile = true
1002 }
mpagenko01e726e2020-10-23 09:45:29 +00001003 //the slice can be passed 'by value' here, - which internally passes its reference copy
mpagenko7d14de12021-07-27 08:31:56 +00001004 dh.lockVlanConfig.Lock()
Holger Hildebrandt47555e72020-09-21 11:07:24 +00001005 if _, exist = dh.UniVlanConfigFsmMap[uniData.PersUniID]; exist {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001006 if err := dh.UniVlanConfigFsmMap[uniData.PersUniID].SetUniFlowParams(ctx, flowData.VlanRuleParams.TpID,
mpagenko01e726e2020-10-23 09:45:29 +00001007 flowData.CookieSlice, uint16(flowData.VlanRuleParams.MatchVid), uint16(flowData.VlanRuleParams.SetVid),
Girish Gowdrae95687a2021-09-08 16:30:58 -07001008 uint8(flowData.VlanRuleParams.SetPcp), lastFlowToReconcile, flowData.Meter, nil); err != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001009 logger.Errorw(ctx, err.Error(), log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt47555e72020-09-21 11:07:24 +00001010 }
Holger Hildebrandt47555e72020-09-21 11:07:24 +00001011 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001012 if err := dh.createVlanFilterFsm(ctx, uniPort, flowData.VlanRuleParams.TpID, flowData.CookieSlice,
mpagenko01e726e2020-10-23 09:45:29 +00001013 uint16(flowData.VlanRuleParams.MatchVid), uint16(flowData.VlanRuleParams.SetVid),
Girish Gowdrae95687a2021-09-08 16:30:58 -07001014 uint8(flowData.VlanRuleParams.SetPcp), cmn.OmciVlanFilterAddDone, lastFlowToReconcile, flowData.Meter, nil); err != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001015 logger.Errorw(ctx, err.Error(), log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt47555e72020-09-21 11:07:24 +00001016 }
1017 }
mpagenko7d14de12021-07-27 08:31:56 +00001018 dh.lockVlanConfig.Unlock()
Holger Hildebrandtbe523842021-03-10 10:47:18 +00001019 flowsProcessed++
mpagenko2dc896e2021-08-02 12:03:59 +00001020 } //for all flows of this UNI
1021 logger.Debugw(ctx, "reconciling - flows processed", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001022 "device-id": dh.DeviceID, "uni-id": uniData.PersUniID, "flowsProcessed": flowsProcessed,
1023 "NumUniFlows": dh.UniVlanConfigFsmMap[uniData.PersUniID].NumUniFlows,
1024 "ConfiguredUniFlow": dh.UniVlanConfigFsmMap[uniData.PersUniID].ConfiguredUniFlow})
Andrea Campanellaf66ac6e2021-05-24 17:09:20 +02001025 // this can't be used as global finished reconciling flag because
1026 // assumes is getting called before the state machines for the last flow is completed,
1027 // while this is not guaranteed.
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001028 //dh.SetReconcilingFlows(false)
1029 pDevEntry.MutexPersOnuConfig.RLock() //set protection again for loop test on SOnuPersistentData
1030 } // for all UNI entries from SOnuPersistentData
1031 pDevEntry.MutexPersOnuConfig.RUnlock()
mpagenko2dc896e2021-08-02 12:03:59 +00001032
Holger Hildebrandtbe523842021-03-10 10:47:18 +00001033 if !flowsFound {
1034 logger.Debugw(ctx, "reconciling - no flows have been stored before adapter restart - terminate reconcilement",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001035 log.Fields{"device-id": dh.DeviceID})
1036 if !dh.IsSkipOnuConfigReconciling() {
1037 dh.StopReconciling(ctx, true)
Holger Hildebrandt7e9de862021-03-26 14:01:49 +00001038 }
Holger Hildebrandtbe523842021-03-10 10:47:18 +00001039 return
1040 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001041 if dh.IsSkipOnuConfigReconciling() {
1042 dh.SetDeviceReason(cmn.DrOmciFlowsPushed)
Holger Hildebrandt47555e72020-09-21 11:07:24 +00001043 }
1044}
1045
Holger Hildebrandt1b8f4ad2021-03-25 15:53:51 +00001046func (dh *deviceHandler) reconcileEnd(ctx context.Context) {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001047 logger.Debugw(ctx, "reconciling - completed!", log.Fields{"device-id": dh.DeviceID})
1048 dh.StopReconciling(ctx, true)
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +00001049}
1050
dbainbri4d3a0dc2020-12-02 00:33:42 +00001051func (dh *deviceHandler) deleteDevicePersistencyData(ctx context.Context) error {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001052 logger.Debugw(ctx, "delete device persistency data", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt47555e72020-09-21 11:07:24 +00001053
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001054 pDevEntry := dh.GetOnuDeviceEntry(ctx, false)
Holger Hildebrandt47555e72020-09-21 11:07:24 +00001055 if pDevEntry == nil {
mpagenko2418ab02020-11-12 12:58:06 +00001056 //IfDevEntry does not exist here, no problem - no persistent data should have been stored
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001057 logger.Debugw(ctx, "OnuDevice does not exist - nothing to delete", log.Fields{"device-id": dh.DeviceID})
mpagenko2418ab02020-11-12 12:58:06 +00001058 return nil
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +00001059 }
Holger Hildebrandt47555e72020-09-21 11:07:24 +00001060
1061 // deadline context to ensure completion of background routines waited for
1062 //20200721: 10s proved to be less in 8*8 ONU test on local vbox machine with debug, might be further adapted
Himani Chawlad96df182020-09-28 11:12:02 +05301063 deadline := time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution
dbainbri4d3a0dc2020-12-02 00:33:42 +00001064 dctx, cancel := context.WithDeadline(ctx, deadline)
Holger Hildebrandt47555e72020-09-21 11:07:24 +00001065
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001066 pDevEntry.ResetKvProcessingErrorIndication()
Holger Hildebrandt47555e72020-09-21 11:07:24 +00001067
1068 var wg sync.WaitGroup
1069 wg.Add(1) // for the 1 go routine to finish
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001070 go pDevEntry.DeleteDataFromOnuKvStore(log.WithSpanFromContext(dctx, ctx), &wg)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001071 dh.waitForCompletion(ctx, cancel, &wg, "DeleteDevice") //wait for background process to finish
Holger Hildebrandt47555e72020-09-21 11:07:24 +00001072
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +00001073 // TODO: further actions - stop metrics and FSMs, remove device ...
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001074 return pDevEntry.GetKvProcessingErrorIndication()
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +00001075}
1076
mpagenko15ff4a52021-03-02 10:09:20 +00001077//func (dh *deviceHandler) rebootDevice(ctx context.Context, device *voltha.Device) error {
1078// before this change here return like this was used:
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001079// return fmt.Errorf("device-unreachable: %s, %s", dh.DeviceID, device.SerialNumber)
mpagenko15ff4a52021-03-02 10:09:20 +00001080//was and is called in background - error return does not make sense
1081func (dh *deviceHandler) rebootDevice(ctx context.Context, aCheckDeviceState bool, device *voltha.Device) {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001082 logger.Infow(ctx, "reboot-device", log.Fields{"device-id": dh.DeviceID, "SerialNumber": dh.device.SerialNumber})
mpagenko15ff4a52021-03-02 10:09:20 +00001083 if aCheckDeviceState && device.ConnectStatus != voltha.ConnectStatus_REACHABLE {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001084 logger.Errorw(ctx, "device-unreachable", log.Fields{"device-id": device.Id, "SerialNumber": device.SerialNumber})
mpagenko15ff4a52021-03-02 10:09:20 +00001085 return
ozgecanetsiae11479f2020-07-06 09:44:47 +03001086 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001087 if err := dh.pOnuOmciDevice.Reboot(log.WithSpanFromContext(context.TODO(), ctx)); err != nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301088 //TODO with VOL-3045/VOL-3046: return the error and stop further processing
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001089 logger.Errorw(ctx, "error-rebooting-device", log.Fields{"device-id": dh.DeviceID, "error": err})
mpagenko15ff4a52021-03-02 10:09:20 +00001090 return
Himani Chawla4d908332020-08-31 12:30:20 +05301091 }
mpagenko01e726e2020-10-23 09:45:29 +00001092
1093 //transfer the possibly modified logical uni port state
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001094 dh.DisableUniPortStateUpdate(ctx)
mpagenko01e726e2020-10-23 09:45:29 +00001095
dbainbri4d3a0dc2020-12-02 00:33:42 +00001096 logger.Debugw(ctx, "call DeviceStateUpdate upon reboot", log.Fields{"ConnectStatus": voltha.ConnectStatus_REACHABLE,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001097 "OperStatus": voltha.OperStatus_DISCOVERED, "device-id": dh.DeviceID})
khenaidoo7d3c5582021-08-11 18:09:44 -04001098 if err := dh.updateDeviceStateInCore(ctx, &ic.DeviceStateFilter{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001099 DeviceId: dh.DeviceID,
khenaidoo7d3c5582021-08-11 18:09:44 -04001100 ConnStatus: voltha.ConnectStatus_REACHABLE,
1101 OperStatus: voltha.OperStatus_DISCOVERED,
1102 }); err != nil {
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001103 //TODO with VOL-3045/VOL-3046: return the error and stop further processing
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001104 logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err})
mpagenko15ff4a52021-03-02 10:09:20 +00001105 return
ozgecanetsiae11479f2020-07-06 09:44:47 +03001106 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001107 if err := dh.deviceReasonUpdate(ctx, cmn.DrRebooting, true); err != nil {
mpagenko15ff4a52021-03-02 10:09:20 +00001108 return
ozgecanetsiae11479f2020-07-06 09:44:47 +03001109 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001110 dh.SetReadyForOmciConfig(false)
mpagenko8b07c1b2020-11-26 10:36:31 +00001111 //no specific activity to synchronize any internal FSM to the 'rebooted' state is explicitly done here
1112 // the expectation ids for a real device, that it will be synced with the expected following 'down' indication
1113 // as BBSIM does not support this testing requires explicite disable/enable device calls in which sequence also
1114 // all other FSM's should be synchronized again
ozgecanetsiae11479f2020-07-06 09:44:47 +03001115}
1116
mpagenkoc8bba412021-01-15 15:38:44 +00001117//doOnuSwUpgrade initiates the SW download transfer to the ONU and on success activates the (inactive) image
mpagenko38662d02021-08-11 09:45:19 +00001118// used only for old - R2.7 style - upgrade API
mpagenko80622a52021-02-09 16:53:23 +00001119func (dh *deviceHandler) doOnuSwUpgrade(ctx context.Context, apImageDsc *voltha.ImageDownload,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001120 apDownloadManager *swupg.AdapterDownloadManager) error {
mpagenko80622a52021-02-09 16:53:23 +00001121 logger.Debugw(ctx, "onuSwUpgrade requested", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001122 "device-id": dh.DeviceID, "image-name": (*apImageDsc).Name})
mpagenko80622a52021-02-09 16:53:23 +00001123
1124 var err error
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001125 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
mpagenko15ff4a52021-03-02 10:09:20 +00001126 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001127 logger.Errorw(ctx, "start Onu SW upgrade rejected: no valid OnuDevice", log.Fields{"device-id": dh.DeviceID})
1128 return fmt.Errorf("start Onu SW upgrade rejected: no valid OnuDevice for device-id: %s", dh.DeviceID)
mpagenko15ff4a52021-03-02 10:09:20 +00001129 }
1130
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001131 if dh.IsReadyForOmciConfig() {
mpagenko15ff4a52021-03-02 10:09:20 +00001132 var inactiveImageID uint16
1133 if inactiveImageID, err = pDevEntry.GetInactiveImageMeID(ctx); err == nil {
1134 dh.lockUpgradeFsm.Lock()
mpagenko59862f02021-10-11 08:53:18 +00001135 //lockUpgradeFsm must be release before cancellation as this may implicitly request RemoveOnuUpgradeFsm()
1136 // but must be still locked at calling createOnuUpgradeFsm
mpagenko15ff4a52021-03-02 10:09:20 +00001137 if dh.pOnuUpradeFsm == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001138 err = dh.createOnuUpgradeFsm(ctx, pDevEntry, cmn.OmciOnuSwUpgradeDone)
mpagenko59862f02021-10-11 08:53:18 +00001139 dh.lockUpgradeFsm.Unlock()
mpagenko15ff4a52021-03-02 10:09:20 +00001140 if err == nil {
1141 if err = dh.pOnuUpradeFsm.SetDownloadParams(ctx, inactiveImageID, apImageDsc, apDownloadManager); err != nil {
1142 logger.Errorw(ctx, "onu upgrade fsm could not set parameters", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001143 "device-id": dh.DeviceID, "error": err})
mpagenko15ff4a52021-03-02 10:09:20 +00001144 }
1145 } else {
1146 logger.Errorw(ctx, "onu upgrade fsm could not be created", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001147 "device-id": dh.DeviceID, "error": err})
mpagenko80622a52021-02-09 16:53:23 +00001148 }
mpagenko15ff4a52021-03-02 10:09:20 +00001149 } else { //OnuSw upgrade already running - restart (with possible abort of running)
mpagenko59862f02021-10-11 08:53:18 +00001150 dh.lockUpgradeFsm.Unlock()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001151 logger.Debugw(ctx, "Onu SW upgrade already running - abort", log.Fields{"device-id": dh.DeviceID})
mpagenko59862f02021-10-11 08:53:18 +00001152 if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation
1153 dh.upgradeCanceled = true
1154 dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_REQUEST) //complete abort
1155 }
mpagenko38662d02021-08-11 09:45:19 +00001156 //no effort spent anymore for the old API to automatically cancel and restart the download
1157 // like done for the new API
mpagenko80622a52021-02-09 16:53:23 +00001158 }
mpagenko15ff4a52021-03-02 10:09:20 +00001159 } else {
1160 logger.Errorw(ctx, "start Onu SW upgrade rejected: no inactive image", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001161 "device-id": dh.DeviceID, "error": err})
mpagenko80622a52021-02-09 16:53:23 +00001162 }
1163 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001164 logger.Errorw(ctx, "start Onu SW upgrade rejected: no active OMCI connection", log.Fields{"device-id": dh.DeviceID})
1165 err = fmt.Errorf("start Onu SW upgrade rejected: no active OMCI connection for device-id: %s", dh.DeviceID)
mpagenko80622a52021-02-09 16:53:23 +00001166 }
1167 return err
mpagenkoc8bba412021-01-15 15:38:44 +00001168}
1169
mpagenkoc26d4c02021-05-06 14:27:57 +00001170//onuSwUpgradeAfterDownload initiates the SW download transfer to the ONU with activate and commit options
1171// after the OnuImage has been downloaded to the adapter, called in background
1172func (dh *deviceHandler) onuSwUpgradeAfterDownload(ctx context.Context, apImageRequest *voltha.DeviceImageDownloadRequest,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001173 apDownloadManager *swupg.FileDownloadManager, aImageIdentifier string) {
mpagenkoc26d4c02021-05-06 14:27:57 +00001174
1175 var err error
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001176 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
mpagenkoc26d4c02021-05-06 14:27:57 +00001177 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001178 logger.Errorw(ctx, "start Onu SW upgrade rejected: no valid OnuDevice", log.Fields{"device-id": dh.DeviceID})
mpagenkoc26d4c02021-05-06 14:27:57 +00001179 return
1180 }
1181
1182 var inactiveImageID uint16
1183 if inactiveImageID, err = pDevEntry.GetInactiveImageMeID(ctx); err == nil {
1184 logger.Debugw(ctx, "onuSwUpgrade requested", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001185 "device-id": dh.DeviceID, "image-version": apImageRequest.Image.Version, "to onu-image": inactiveImageID})
mpagenko38662d02021-08-11 09:45:19 +00001186
mpagenko59862f02021-10-11 08:53:18 +00001187 dh.lockUpgradeFsm.Lock()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001188 //lockUpgradeFsm must be release before cancellation as this may implicitly request RemoveOnuUpgradeFsm()
mpagenko59862f02021-10-11 08:53:18 +00001189 // but must be still locked at calling createOnuUpgradeFsm
1190 // (and working with a local pointer copy does not work here if asynchronous request are done to fast
1191 // [e.g.leaving the local pointer on nil even though a creation is already on the way])
1192 if dh.pOnuUpradeFsm != nil {
mpagenko38662d02021-08-11 09:45:19 +00001193 //OnuSw upgrade already running on this device (e.g. with activate/commit not yet set)
1194 // abort the current processing, running upgrades are always aborted by newer request
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001195 logger.Debugw(ctx, "Onu SW upgrade already running - abort previous activity", log.Fields{"device-id": dh.DeviceID})
mpagenko38662d02021-08-11 09:45:19 +00001196 //flush the remove upgradeFsmChan channel
1197 select {
1198 case <-dh.upgradeFsmChan:
1199 logger.Debug(ctx, "flushed-upgrade-fsm-channel")
1200 default:
mpagenkoc26d4c02021-05-06 14:27:57 +00001201 }
mpagenko59862f02021-10-11 08:53:18 +00001202 dh.lockUpgradeFsm.Unlock()
1203 if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation
1204 dh.upgradeCanceled = true
1205 dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_REQUEST) //complete abort
1206 }
mpagenko38662d02021-08-11 09:45:19 +00001207 select {
1208 case <-time.After(cTimeOutRemoveUpgrade * time.Second):
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001209 logger.Errorw(ctx, "could not remove Upgrade FSM in time, aborting", log.Fields{"device-id": dh.DeviceID})
mpagenko38662d02021-08-11 09:45:19 +00001210 //should not appear, can't proceed with new upgrade, perhaps operator can retry manually later
1211 return
1212 case <-dh.upgradeFsmChan:
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001213 logger.Debugw(ctx, "recent Upgrade FSM removed, proceed with new request", log.Fields{"device-id": dh.DeviceID})
mpagenko38662d02021-08-11 09:45:19 +00001214 }
mpagenko59862f02021-10-11 08:53:18 +00001215 dh.lockUpgradeFsm.Lock() //lock again for following creation
mpagenkoc26d4c02021-05-06 14:27:57 +00001216 }
mpagenko38662d02021-08-11 09:45:19 +00001217
1218 //here it can be assumed that no running upgrade processing exists (anymore)
mpagenko59862f02021-10-11 08:53:18 +00001219 //OmciOnuSwUpgradeDone could be used to create some event notification with information on upgrade completion,
mpagenko38662d02021-08-11 09:45:19 +00001220 // but none yet defined
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001221 err = dh.createOnuUpgradeFsm(ctx, pDevEntry, cmn.OmciOnuSwUpgradeDone)
mpagenko59862f02021-10-11 08:53:18 +00001222 dh.lockUpgradeFsm.Unlock()
mpagenko38662d02021-08-11 09:45:19 +00001223 if err == nil {
1224 if err = dh.pOnuUpradeFsm.SetDownloadParamsAfterDownload(ctx, inactiveImageID,
1225 apImageRequest, apDownloadManager, aImageIdentifier); err != nil {
1226 logger.Errorw(ctx, "onu upgrade fsm could not set parameters", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001227 "device-id": dh.DeviceID, "error": err})
mpagenkoc26d4c02021-05-06 14:27:57 +00001228 return
1229 }
mpagenko38662d02021-08-11 09:45:19 +00001230 } else {
1231 logger.Errorw(ctx, "onu upgrade fsm could not be created", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001232 "device-id": dh.DeviceID, "error": err})
mpagenkoc26d4c02021-05-06 14:27:57 +00001233 }
1234 return
1235 }
1236 logger.Errorw(ctx, "start Onu SW upgrade rejected: no inactive image", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001237 "device-id": dh.DeviceID, "error": err})
mpagenkoc26d4c02021-05-06 14:27:57 +00001238}
1239
1240//onuSwActivateRequest ensures activation of the requested image with commit options
mpagenko183647c2021-06-08 15:25:04 +00001241func (dh *deviceHandler) onuSwActivateRequest(ctx context.Context,
1242 aVersion string, aCommitRequest bool) (*voltha.ImageState, error) {
mpagenkoc26d4c02021-05-06 14:27:57 +00001243 var err error
1244 //SW activation for the ONU image may have two use cases, one of them is selected here according to following prioritization:
1245 // 1.) activation of the image for a started upgrade process (in case the running upgrade runs on the requested image)
1246 // 2.) activation of the inactive image
1247
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001248 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
mpagenkoc26d4c02021-05-06 14:27:57 +00001249 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001250 logger.Errorw(ctx, "Onu image activation rejected: no valid OnuDevice", log.Fields{"device-id": dh.DeviceID})
1251 return nil, fmt.Errorf("no valid OnuDevice for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001252 }
1253 dh.lockUpgradeFsm.RLock()
1254 if dh.pOnuUpradeFsm != nil {
1255 dh.lockUpgradeFsm.RUnlock()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001256 onuVolthaDevice, getErr := dh.getDeviceFromCore(ctx, dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001257 if getErr != nil || onuVolthaDevice == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001258 logger.Errorw(ctx, "Failed to fetch Onu device for image activation", log.Fields{"device-id": dh.DeviceID, "err": getErr})
1259 return nil, fmt.Errorf("could not fetch device for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001260 }
mpagenko59862f02021-10-11 08:53:18 +00001261 if dh.upgradeCanceled { //avoid starting some new action in case it is already doing the cancelation
1262 logger.Errorw(ctx, "Some upgrade procedure still runs cancelation - abort", log.Fields{"device-id": dh.DeviceID})
1263 return nil, fmt.Errorf("request collides with some ongoing cancelation for device-id: %s", dh.DeviceID)
1264 }
mpagenkoc26d4c02021-05-06 14:27:57 +00001265 // use the OnuVendor identification from this device for the internal unique name
1266 imageIdentifier := onuVolthaDevice.VendorId + aVersion //head on vendor ID of the ONU
mpagenko38662d02021-08-11 09:45:19 +00001267 // 1.) check a started upgrade process and relay the activation request to it
mpagenkoc26d4c02021-05-06 14:27:57 +00001268 if err = dh.pOnuUpradeFsm.SetActivationParamsRunning(ctx, imageIdentifier, aCommitRequest); err != nil {
mpagenko183647c2021-06-08 15:25:04 +00001269 //if some ONU upgrade is ongoing we do not accept some explicit ONU image-version related activation
mpagenkoc26d4c02021-05-06 14:27:57 +00001270 logger.Errorw(ctx, "onu upgrade fsm did not accept activation while running", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001271 "device-id": dh.DeviceID, "error": err})
1272 return nil, fmt.Errorf("activation not accepted for this version for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001273 }
mpagenko183647c2021-06-08 15:25:04 +00001274 logger.Debugw(ctx, "image activation acknowledged by onu upgrade processing", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001275 "device-id": dh.DeviceID, "image-id": imageIdentifier})
mpagenko38662d02021-08-11 09:45:19 +00001276 pImageStates := dh.pOnuUpradeFsm.GetImageStates(ctx, "", aVersion)
mpagenko183647c2021-06-08 15:25:04 +00001277 return pImageStates, nil
mpagenkoc26d4c02021-05-06 14:27:57 +00001278 } //else
1279 dh.lockUpgradeFsm.RUnlock()
1280
1281 // 2.) check if requested image-version equals the inactive one and start its activation
1282 // (image version is not [yet] checked - would be possible, but with increased effort ...)
1283 var inactiveImageID uint16
1284 if inactiveImageID, err = pDevEntry.GetInactiveImageMeID(ctx); err != nil || inactiveImageID > 1 {
1285 logger.Errorw(ctx, "get inactive image failed", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001286 "device-id": dh.DeviceID, "err": err, "image-id": inactiveImageID})
1287 return nil, fmt.Errorf("no valid inactive image found for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001288 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001289 err = dh.createOnuUpgradeFsm(ctx, pDevEntry, cmn.OmciOnuSwUpgradeDone)
mpagenkoc26d4c02021-05-06 14:27:57 +00001290 if err == nil {
1291 if err = dh.pOnuUpradeFsm.SetActivationParamsStart(ctx, aVersion,
1292 inactiveImageID, aCommitRequest); err != nil {
1293 logger.Errorw(ctx, "onu upgrade fsm did not accept activation to start", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001294 "device-id": dh.DeviceID, "error": err})
1295 return nil, fmt.Errorf("activation to start from scratch not accepted for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001296 }
1297 logger.Debugw(ctx, "inactive image activation acknowledged by onu upgrade", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001298 "device-id": dh.DeviceID, "image-version": aVersion})
mpagenko38662d02021-08-11 09:45:19 +00001299 pImageStates := dh.pOnuUpradeFsm.GetImageStates(ctx, "", aVersion)
mpagenko183647c2021-06-08 15:25:04 +00001300 return pImageStates, nil
mpagenkoc26d4c02021-05-06 14:27:57 +00001301 } //else
1302 logger.Errorw(ctx, "onu upgrade fsm could not be created", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001303 "device-id": dh.DeviceID, "error": err})
1304 return nil, fmt.Errorf("could not start upgradeFsm for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001305}
1306
1307//onuSwCommitRequest ensures commitment of the requested image
mpagenko183647c2021-06-08 15:25:04 +00001308func (dh *deviceHandler) onuSwCommitRequest(ctx context.Context,
1309 aVersion string) (*voltha.ImageState, error) {
mpagenkoc26d4c02021-05-06 14:27:57 +00001310 var err error
1311 //SW commitment for the ONU image may have two use cases, one of them is selected here according to following prioritization:
1312 // 1.) commitment of the image for a started upgrade process (in case the running upgrade runs on the requested image)
1313 // 2.) commitment of the active image
1314
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001315 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
mpagenkoc26d4c02021-05-06 14:27:57 +00001316 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001317 logger.Errorw(ctx, "Onu image commitment rejected: no valid OnuDevice", log.Fields{"device-id": dh.DeviceID})
1318 return nil, fmt.Errorf("no valid OnuDevice for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001319 }
1320 dh.lockUpgradeFsm.RLock()
1321 if dh.pOnuUpradeFsm != nil {
1322 dh.lockUpgradeFsm.RUnlock()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001323 onuVolthaDevice, getErr := dh.getDeviceFromCore(ctx, dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001324 if getErr != nil || onuVolthaDevice == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001325 logger.Errorw(ctx, "Failed to fetch Onu device for image commitment", log.Fields{"device-id": dh.DeviceID, "err": getErr})
1326 return nil, fmt.Errorf("could not fetch device for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001327 }
mpagenko59862f02021-10-11 08:53:18 +00001328 if dh.upgradeCanceled { //avoid starting some new action in case it is already doing the cancelation
1329 logger.Errorw(ctx, "Some upgrade procedure still runs cancelation - abort", log.Fields{"device-id": dh.DeviceID})
1330 return nil, fmt.Errorf("request collides with some ongoing cancelation for device-id: %s", dh.DeviceID)
1331 }
mpagenkoc26d4c02021-05-06 14:27:57 +00001332 // use the OnuVendor identification from this device for the internal unique name
1333 imageIdentifier := onuVolthaDevice.VendorId + aVersion //head on vendor ID of the ONU
mpagenko38662d02021-08-11 09:45:19 +00001334 // 1.) check a started upgrade process and relay the commitment request to it
1335 // the running upgrade may be based either on the imageIdentifier (started from download)
1336 // or on the imageVersion (started from pure activation)
1337 if err = dh.pOnuUpradeFsm.SetCommitmentParamsRunning(ctx, imageIdentifier, aVersion); err != nil {
1338 //if some ONU upgrade is ongoing we do not accept some explicit different ONU image-version related commitment
mpagenkoc26d4c02021-05-06 14:27:57 +00001339 logger.Errorw(ctx, "onu upgrade fsm did not accept commitment while running", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001340 "device-id": dh.DeviceID, "error": err})
1341 return nil, fmt.Errorf("commitment not accepted for this version for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001342 }
mpagenko183647c2021-06-08 15:25:04 +00001343 logger.Debugw(ctx, "image commitment acknowledged by onu upgrade processing", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001344 "device-id": dh.DeviceID, "image-id": imageIdentifier})
mpagenko38662d02021-08-11 09:45:19 +00001345 pImageStates := dh.pOnuUpradeFsm.GetImageStates(ctx, "", aVersion)
mpagenko183647c2021-06-08 15:25:04 +00001346 return pImageStates, nil
mpagenkoc26d4c02021-05-06 14:27:57 +00001347 } //else
1348 dh.lockUpgradeFsm.RUnlock()
1349
mpagenko183647c2021-06-08 15:25:04 +00001350 // 2.) use the active image to directly commit
mpagenkoc26d4c02021-05-06 14:27:57 +00001351 var activeImageID uint16
1352 if activeImageID, err = pDevEntry.GetActiveImageMeID(ctx); err != nil || activeImageID > 1 {
1353 logger.Errorw(ctx, "get active image failed", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001354 "device-id": dh.DeviceID, "err": err, "image-id": activeImageID})
1355 return nil, fmt.Errorf("no valid active image found for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001356 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001357 err = dh.createOnuUpgradeFsm(ctx, pDevEntry, cmn.OmciOnuSwUpgradeDone)
mpagenkoc26d4c02021-05-06 14:27:57 +00001358 if err == nil {
1359 if err = dh.pOnuUpradeFsm.SetCommitmentParamsStart(ctx, aVersion, activeImageID); err != nil {
1360 logger.Errorw(ctx, "onu upgrade fsm did not accept commitment to start", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001361 "device-id": dh.DeviceID, "error": err})
1362 return nil, fmt.Errorf("commitment to start from scratch not accepted for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001363 }
1364 logger.Debugw(ctx, "active image commitment acknowledged by onu upgrade", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001365 "device-id": dh.DeviceID, "image-version": aVersion})
mpagenko38662d02021-08-11 09:45:19 +00001366 pImageStates := dh.pOnuUpradeFsm.GetImageStates(ctx, "", aVersion)
mpagenko183647c2021-06-08 15:25:04 +00001367 return pImageStates, nil
mpagenkoc26d4c02021-05-06 14:27:57 +00001368 } //else
1369 logger.Errorw(ctx, "onu upgrade fsm could not be created", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001370 "device-id": dh.DeviceID, "error": err})
1371 return nil, fmt.Errorf("could not start upgradeFsm for device-id: %s", dh.DeviceID)
mpagenkoc26d4c02021-05-06 14:27:57 +00001372}
1373
mpagenkoaa3afe92021-05-21 16:20:58 +00001374func (dh *deviceHandler) requestOnuSwUpgradeState(ctx context.Context, aImageIdentifier string,
mpagenko38662d02021-08-11 09:45:19 +00001375 aVersion string) *voltha.ImageState {
1376 var pImageState *voltha.ImageState
mpagenkoaa3afe92021-05-21 16:20:58 +00001377 dh.lockUpgradeFsm.RLock()
mpagenko38662d02021-08-11 09:45:19 +00001378 defer dh.lockUpgradeFsm.RUnlock()
mpagenkoaa3afe92021-05-21 16:20:58 +00001379 if dh.pOnuUpradeFsm != nil {
mpagenko38662d02021-08-11 09:45:19 +00001380 pImageState = dh.pOnuUpradeFsm.GetImageStates(ctx, aImageIdentifier, aVersion)
1381 } else { //use the last stored ImageState (if the requested Imageversion coincides)
1382 if aVersion == dh.pLastUpgradeImageState.Version {
1383 pImageState = dh.pLastUpgradeImageState
1384 } else { //state request for an image version different from last processed image version
1385 pImageState = &voltha.ImageState{
1386 Version: aVersion,
1387 //we cannot state something concerning this version
1388 DownloadState: voltha.ImageState_DOWNLOAD_UNKNOWN,
1389 Reason: voltha.ImageState_NO_ERROR,
1390 ImageState: voltha.ImageState_IMAGE_UNKNOWN,
1391 }
mpagenkoaa3afe92021-05-21 16:20:58 +00001392 }
1393 }
mpagenko38662d02021-08-11 09:45:19 +00001394 return pImageState
mpagenkoaa3afe92021-05-21 16:20:58 +00001395}
1396
1397func (dh *deviceHandler) cancelOnuSwUpgrade(ctx context.Context, aImageIdentifier string,
1398 aVersion string, pDeviceImageState *voltha.DeviceImageState) {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001399 pDeviceImageState.DeviceId = dh.DeviceID
mpagenko7455fd42021-06-10 16:25:55 +00001400 pDeviceImageState.ImageState.Version = aVersion
mpagenkoaa3afe92021-05-21 16:20:58 +00001401 dh.lockUpgradeFsm.RLock()
1402 if dh.pOnuUpradeFsm != nil {
mpagenko45586762021-10-01 08:30:22 +00001403 dh.lockUpgradeFsm.RUnlock()
1404 // so then we cancel the upgrade operation
1405 // but before we still request the actual upgrade states (which should not change with the cancellation)
1406 pImageState := dh.pOnuUpradeFsm.GetImageStates(ctx, aImageIdentifier, aVersion)
1407 pDeviceImageState.ImageState.DownloadState = pImageState.DownloadState
1408 pDeviceImageState.ImageState.Reason = voltha.ImageState_CANCELLED_ON_REQUEST
1409 pDeviceImageState.ImageState.ImageState = pImageState.ImageState
1410 if pImageState.DownloadState != voltha.ImageState_DOWNLOAD_UNKNOWN {
1411 //so here the imageIdentifier or version equals to what is used in the upgrade FSM
mpagenko59862f02021-10-11 08:53:18 +00001412 if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation
1413 dh.upgradeCanceled = true
1414 dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_REQUEST) //complete abort
1415 }
mpagenko45586762021-10-01 08:30:22 +00001416 } //nothing to cancel (upgrade FSM for different image stays alive)
mpagenkoaa3afe92021-05-21 16:20:58 +00001417 } else {
mpagenko45586762021-10-01 08:30:22 +00001418 dh.lockUpgradeFsm.RUnlock()
mpagenko38662d02021-08-11 09:45:19 +00001419 // if no upgrade is ongoing, nothing is canceled and accordingly the states of the requested image are unknown
1420 // reset also the dh handler LastUpgradeImageState (not relevant anymore/cleared)
1421 (*dh.pLastUpgradeImageState).DownloadState = voltha.ImageState_DOWNLOAD_UNKNOWN
1422 (*dh.pLastUpgradeImageState).Reason = voltha.ImageState_NO_ERROR
1423 (*dh.pLastUpgradeImageState).ImageState = voltha.ImageState_IMAGE_UNKNOWN
1424 (*dh.pLastUpgradeImageState).Version = "" //reset to 'no (relevant) upgrade done' (like initial state)
mpagenkoaa3afe92021-05-21 16:20:58 +00001425 pDeviceImageState.ImageState.DownloadState = voltha.ImageState_DOWNLOAD_UNKNOWN
1426 pDeviceImageState.ImageState.Reason = voltha.ImageState_NO_ERROR
mpagenko38662d02021-08-11 09:45:19 +00001427 pDeviceImageState.ImageState.ImageState = voltha.ImageState_IMAGE_UNKNOWN
1428 //an abort request to a not active upgrade processing can be used to reset the device upgrade states completely
mpagenkoaa3afe92021-05-21 16:20:58 +00001429 }
1430}
1431
Holger Hildebrandtfb402a62021-05-26 14:40:49 +00001432func (dh *deviceHandler) getOnuImages(ctx context.Context) (*voltha.OnuImages, error) {
1433
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001434 var onuImageStatus *swupg.OnuImageStatus
Holger Hildebrandtfb402a62021-05-26 14:40:49 +00001435
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001436 pDevEntry := dh.GetOnuDeviceEntry(ctx, false)
Holger Hildebrandtfb402a62021-05-26 14:40:49 +00001437 if pDevEntry != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001438 onuImageStatus = swupg.NewOnuImageStatus(dh, pDevEntry)
1439 pDevEntry.MutexOnuImageStatus.Lock()
1440 pDevEntry.POnuImageStatus = onuImageStatus
1441 pDevEntry.MutexOnuImageStatus.Unlock()
Holger Hildebrandtfb402a62021-05-26 14:40:49 +00001442
1443 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001444 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtfb402a62021-05-26 14:40:49 +00001445 return nil, fmt.Errorf("no-valid-OnuDevice-aborting")
1446 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001447 images, err := onuImageStatus.GetOnuImageStatus(ctx)
1448 pDevEntry.MutexOnuImageStatus.Lock()
1449 pDevEntry.POnuImageStatus = nil
1450 pDevEntry.MutexOnuImageStatus.Unlock()
Holger Hildebrandtfb402a62021-05-26 14:40:49 +00001451 return images, err
1452}
1453
Himani Chawla6d2ae152020-09-02 13:11:20 +05301454// deviceHandler methods that implement the adapters interface requests## end #########
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001455// #####################################################################################
1456
1457// ################ to be updated acc. needs of ONU Device ########################
Himani Chawla6d2ae152020-09-02 13:11:20 +05301458// deviceHandler StateMachine related state transition methods ##### begin #########
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001459
dbainbri4d3a0dc2020-12-02 00:33:42 +00001460func (dh *deviceHandler) logStateChange(ctx context.Context, e *fsm.Event) {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001461 logger.Debugw(ctx, "Device FSM: ", log.Fields{"event name": string(e.Event), "src state": string(e.Src), "dst state": string(e.Dst), "device-id": dh.DeviceID})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001462}
1463
1464// doStateInit provides the device update to the core
dbainbri4d3a0dc2020-12-02 00:33:42 +00001465func (dh *deviceHandler) doStateInit(ctx context.Context, e *fsm.Event) {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001466
dbainbri4d3a0dc2020-12-02 00:33:42 +00001467 logger.Debug(ctx, "doStateInit-started")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001468 var err error
1469
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001470 // populate what we know. rest comes later after mib sync
1471 dh.device.Root = false
1472 dh.device.Vendor = "OpenONU"
1473 dh.device.Model = "go"
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001474 dh.device.Reason = cmn.DeviceReasonMap[cmn.DrActivatingOnu]
1475 dh.SetDeviceReason(cmn.DrActivatingOnu)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001476
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001477 dh.logicalDeviceID = dh.DeviceID // really needed - what for ??? //TODO!!!
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001478
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001479 if !dh.IsReconciling() {
1480 logger.Infow(ctx, "DeviceUpdate", log.Fields{"deviceReason": dh.device.Reason, "device-id": dh.DeviceID})
khenaidoo7d3c5582021-08-11 18:09:44 -04001481 if err := dh.updateDeviceInCore(ctx, dh.device); err != nil {
1482 logger.Errorw(ctx, "device-update-failed", log.Fields{"device-id": dh.device.Id, "error": err})
1483 }
Himani Chawlac07fda02020-12-09 16:21:21 +05301484 //TODO Need to Update Device Reason To CORE as part of device update userstory
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001485 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001486 logger.Debugw(ctx, "reconciling - don't notify core about DeviceUpdate",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001487 log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001488 }
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001489
Himani Chawla4d908332020-08-31 12:30:20 +05301490 dh.parentID = dh.device.ParentId
Holger Hildebrandt24d51952020-05-04 14:03:42 +00001491 dh.ponPortNumber = dh.device.ParentPortNo
1492
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001493 // store proxy parameters for later communication - assumption: invariant, else they have to be requested dynamically!!
1494 dh.ProxyAddressID = dh.device.ProxyAddress.GetDeviceId()
1495 dh.ProxyAddressType = dh.device.ProxyAddress.GetDeviceType()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001496 logger.Debugw(ctx, "device-updated", log.Fields{"device-id": dh.DeviceID, "proxyAddressID": dh.ProxyAddressID,
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001497 "proxyAddressType": dh.ProxyAddressType, "SNR": dh.device.SerialNumber,
Himani Chawla4d908332020-08-31 12:30:20 +05301498 "ParentId": dh.parentID, "ParentPortNo": dh.ponPortNumber})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001499
1500 /*
1501 self._pon = PonPort.create(self, self._pon_port_number)
1502 self._pon.add_peer(self.parent_id, self._pon_port_number)
1503 self.logger.debug('adding-pon-port-to-agent',
1504 type=self._pon.get_port().type,
1505 admin_state=self._pon.get_port().admin_state,
1506 oper_status=self._pon.get_port().oper_status,
1507 )
1508 */
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001509 if !dh.IsReconciling() {
1510 logger.Debugw(ctx, "adding-pon-port", log.Fields{"device-id": dh.DeviceID, "ponPortNo": dh.ponPortNumber})
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001511 var ponPortNo uint32 = 1
1512 if dh.ponPortNumber != 0 {
1513 ponPortNo = dh.ponPortNumber
1514 }
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001515
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001516 pPonPort := &voltha.Port{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001517 DeviceId: dh.DeviceID,
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001518 PortNo: ponPortNo,
1519 Label: fmt.Sprintf("pon-%d", ponPortNo),
1520 Type: voltha.Port_PON_ONU,
1521 OperStatus: voltha.OperStatus_ACTIVE,
Himani Chawla4d908332020-08-31 12:30:20 +05301522 Peers: []*voltha.Port_PeerPort{{DeviceId: dh.parentID, // Peer device is OLT
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001523 PortNo: ponPortNo}}, // Peer port is parent's port number
1524 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001525 if err = dh.CreatePortInCore(ctx, pPonPort); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001526 logger.Fatalf(ctx, "Device FSM: PortCreated-failed-%s", err)
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001527 e.Cancel(err)
1528 return
1529 }
1530 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001531 logger.Debugw(ctx, "reconciling - pon-port already added", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001532 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001533 logger.Debug(ctx, "doStateInit-done")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001534}
1535
1536// postInit setups the DeviceEntry for the conerned device
dbainbri4d3a0dc2020-12-02 00:33:42 +00001537func (dh *deviceHandler) postInit(ctx context.Context, e *fsm.Event) {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001538
dbainbri4d3a0dc2020-12-02 00:33:42 +00001539 logger.Debug(ctx, "postInit-started")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001540 var err error
1541 /*
1542 dh.Client = oop.NewOpenoltClient(dh.clientCon)
1543 dh.pTransitionMap.Handle(ctx, GrpcConnected)
1544 return nil
1545 */
dbainbri4d3a0dc2020-12-02 00:33:42 +00001546 if err = dh.addOnuDeviceEntry(log.WithSpanFromContext(context.TODO(), ctx)); err != nil {
1547 logger.Fatalf(ctx, "Device FSM: addOnuDeviceEntry-failed-%s", err)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001548 e.Cancel(err)
1549 return
1550 }
1551
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001552 if dh.IsReconciling() {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001553 go dh.reconcileDeviceOnuInd(ctx)
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001554 // reconcilement will be continued after mib download is done
1555 }
Girish Gowdrae09a6202021-01-12 18:10:59 -08001556
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001557 /*
1558 ############################################################################
1559 # Setup Alarm handler
1560 self.events = AdapterEvents(self.core_proxy, device.id, self.logical_device_id,
1561 device.serial_number)
1562 ############################################################################
1563 # Setup PM configuration for this device
1564 # Pass in ONU specific options
1565 kwargs = {
1566 OnuPmMetrics.DEFAULT_FREQUENCY_KEY: OnuPmMetrics.DEFAULT_ONU_COLLECTION_FREQUENCY,
1567 'heartbeat': self.heartbeat,
1568 OnuOmciPmMetrics.OMCI_DEV_KEY: self._onu_omci_device
1569 }
1570 self.logger.debug('create-pm-metrics', device_id=device.id, serial_number=device.serial_number)
1571 self._pm_metrics = OnuPmMetrics(self.events, self.core_proxy, self.device_id,
1572 self.logical_device_id, device.serial_number,
1573 grouped=True, freq_override=False, **kwargs)
1574 pm_config = self._pm_metrics.make_proto()
1575 self._onu_omci_device.set_pm_config(self._pm_metrics.omci_pm.openomci_interval_pm)
1576 self.logger.info("initial-pm-config", device_id=device.id, serial_number=device.serial_number)
1577 yield self.core_proxy.device_pm_config_update(pm_config, init=True)
1578
1579 # Note, ONU ID and UNI intf set in add_uni_port method
1580 self._onu_omci_device.alarm_synchronizer.set_alarm_params(mgr=self.events,
1581 ani_ports=[self._pon])
1582
1583 # Code to Run OMCI Test Action
1584 kwargs_omci_test_action = {
1585 OmciTestRequest.DEFAULT_FREQUENCY_KEY:
1586 OmciTestRequest.DEFAULT_COLLECTION_FREQUENCY
1587 }
1588 serial_number = device.serial_number
1589 self._test_request = OmciTestRequest(self.core_proxy,
1590 self.omci_agent, self.device_id,
1591 AniG, serial_number,
1592 self.logical_device_id,
1593 exclusive=False,
1594 **kwargs_omci_test_action)
1595
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001596 self.Enabled = True
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001597 else:
1598 self.logger.info('onu-already-activated')
1599 */
Girish Gowdrae09a6202021-01-12 18:10:59 -08001600
dbainbri4d3a0dc2020-12-02 00:33:42 +00001601 logger.Debug(ctx, "postInit-done")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001602}
1603
1604// doStateConnected get the device info and update to voltha core
1605// for comparison of the original method (not that easy to uncomment): compare here:
1606// voltha-openolt-adapter/adaptercore/device_handler.go
1607// -> this one obviously initiates all communication interfaces of the device ...?
dbainbri4d3a0dc2020-12-02 00:33:42 +00001608func (dh *deviceHandler) doStateConnected(ctx context.Context, e *fsm.Event) {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001609
dbainbri4d3a0dc2020-12-02 00:33:42 +00001610 logger.Debug(ctx, "doStateConnected-started")
Himani Chawla4d908332020-08-31 12:30:20 +05301611 err := errors.New("device FSM: function not implemented yet")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001612 e.Cancel(err)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001613 logger.Debug(ctx, "doStateConnected-done")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001614}
1615
1616// doStateUp handle the onu up indication and update to voltha core
dbainbri4d3a0dc2020-12-02 00:33:42 +00001617func (dh *deviceHandler) doStateUp(ctx context.Context, e *fsm.Event) {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001618
dbainbri4d3a0dc2020-12-02 00:33:42 +00001619 logger.Debug(ctx, "doStateUp-started")
Himani Chawla4d908332020-08-31 12:30:20 +05301620 err := errors.New("device FSM: function not implemented yet")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001621 e.Cancel(err)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001622 logger.Debug(ctx, "doStateUp-done")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001623
1624 /*
1625 // Synchronous call to update device state - this method is run in its own go routine
1626 if err := dh.coreProxy.DeviceStateUpdate(ctx, dh.device.Id, voltha.ConnectStatus_REACHABLE,
1627 voltha.OperStatus_ACTIVE); err != nil {
mpagenko01e726e2020-10-23 09:45:29 +00001628 logger.Errorw("Failed to update device with OLT UP indication", log.Fields{"device-id": dh.device.Id, "error": err})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001629 return err
1630 }
1631 return nil
1632 */
1633}
1634
1635// doStateDown handle the onu down indication
dbainbri4d3a0dc2020-12-02 00:33:42 +00001636func (dh *deviceHandler) doStateDown(ctx context.Context, e *fsm.Event) {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001637
dbainbri4d3a0dc2020-12-02 00:33:42 +00001638 logger.Debug(ctx, "doStateDown-started")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001639 var err error
1640
Holger Hildebrandt24d51952020-05-04 14:03:42 +00001641 device := dh.device
1642 if device == nil {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001643 /*TODO: needs to handle error scenarios */
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001644 logger.Errorw(ctx, "Failed to fetch handler device", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001645 e.Cancel(err)
1646 return
1647 }
1648
1649 cloned := proto.Clone(device).(*voltha.Device)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001650 logger.Debugw(ctx, "do-state-down", log.Fields{"ClonedDeviceID": cloned.Id})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001651 /*
1652 // Update the all ports state on that device to disable
1653 if er := dh.coreProxy.PortsStateUpdate(ctx, cloned.Id, voltha.OperStatus_UNKNOWN); er != nil {
mpagenko01e726e2020-10-23 09:45:29 +00001654 logger.Errorw("updating-ports-failed", log.Fields{"device-id": device.Id, "error": er})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001655 return er
1656 }
1657
1658 //Update the device oper state and connection status
1659 cloned.OperStatus = voltha.OperStatus_UNKNOWN
1660 cloned.ConnectStatus = common.ConnectStatus_UNREACHABLE
1661 dh.device = cloned
1662
1663 if er := dh.coreProxy.DeviceStateUpdate(ctx, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); er != nil {
mpagenko01e726e2020-10-23 09:45:29 +00001664 logger.Errorw("error-updating-device-state", log.Fields{"device-id": device.Id, "error": er})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001665 return er
1666 }
1667
1668 //get the child device for the parent device
1669 onuDevices, err := dh.coreProxy.GetChildDevices(ctx, dh.device.Id)
1670 if err != nil {
mpagenko01e726e2020-10-23 09:45:29 +00001671 logger.Errorw("failed to get child devices information", log.Fields{"device-id": dh.device.Id, "error": err})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001672 return err
1673 }
1674 for _, onuDevice := range onuDevices.Items {
1675
1676 // Update onu state as down in onu adapter
1677 onuInd := oop.OnuIndication{}
1678 onuInd.OperState = "down"
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001679 er := dh.adapterProxy.SendInterAdapterMessage(ctx, &onuInd, ic.InterAdapterMessageType_ONU_IND_REQUEST,
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001680 "openolt", onuDevice.Type, onuDevice.Id, onuDevice.ProxyAddress.DeviceId, "")
1681 if er != nil {
1682 logger.Errorw("Failed to send inter-adapter-message", log.Fields{"OnuInd": onuInd,
mpagenko01e726e2020-10-23 09:45:29 +00001683 "From Adapter": "openolt", "DevieType": onuDevice.Type, "device-id": onuDevice.Id})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001684 //Do not return here and continue to process other ONUs
1685 }
1686 }
1687 // * Discovered ONUs entries need to be cleared , since after OLT
1688 // is up, it starts sending discovery indications again* /
1689 dh.discOnus = sync.Map{}
mpagenko01e726e2020-10-23 09:45:29 +00001690 logger.Debugw("do-state-down-end", log.Fields{"device-id": device.Id})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001691 return nil
1692 */
Himani Chawla4d908332020-08-31 12:30:20 +05301693 err = errors.New("device FSM: function not implemented yet")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001694 e.Cancel(err)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001695 logger.Debug(ctx, "doStateDown-done")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001696}
1697
Himani Chawla6d2ae152020-09-02 13:11:20 +05301698// deviceHandler StateMachine related state transition methods ##### end #########
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001699// #################################################################################
1700
1701// ###################################################
Himani Chawla6d2ae152020-09-02 13:11:20 +05301702// deviceHandler utility methods ##### begin #########
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001703
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001704//GetOnuDeviceEntry gets the ONU device entry and may wait until its value is defined
1705func (dh *deviceHandler) GetOnuDeviceEntry(ctx context.Context, aWait bool) *mib.OnuDeviceEntry {
mpagenko3af1f032020-06-10 08:53:41 +00001706 dh.lockDevice.RLock()
1707 pOnuDeviceEntry := dh.pOnuOmciDevice
1708 if aWait && pOnuDeviceEntry == nil {
1709 //keep the read sema short to allow for subsequent write
1710 dh.lockDevice.RUnlock()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001711 logger.Debugw(ctx, "Waiting for DeviceEntry to be set ...", log.Fields{"device-id": dh.DeviceID})
mpagenko3af1f032020-06-10 08:53:41 +00001712 // based on concurrent processing the deviceEntry setup may not yet be finished at his point
1713 // so it might be needed to wait here for that event with some timeout
1714 select {
1715 case <-time.After(60 * time.Second): //timer may be discussed ...
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001716 logger.Errorw(ctx, "No valid DeviceEntry set after maxTime", log.Fields{"device-id": dh.DeviceID})
mpagenko3af1f032020-06-10 08:53:41 +00001717 return nil
1718 case <-dh.deviceEntrySet:
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001719 logger.Debugw(ctx, "devicEntry ready now - continue", log.Fields{"device-id": dh.DeviceID})
mpagenko3af1f032020-06-10 08:53:41 +00001720 // if written now, we can return the written value without sema
1721 return dh.pOnuOmciDevice
1722 }
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001723 }
mpagenko3af1f032020-06-10 08:53:41 +00001724 dh.lockDevice.RUnlock()
1725 return pOnuDeviceEntry
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001726}
1727
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001728//setDeviceHandlerEntries sets the ONU device entry within the handler
1729func (dh *deviceHandler) setDeviceHandlerEntries(apDeviceEntry *mib.OnuDeviceEntry, apOnuTp *avcfg.OnuUniTechProf,
1730 apOnuMetricsMgr *pmmgr.OnuMetricsManager, apOnuAlarmMgr *almgr.OnuAlarmManager, apSelfTestHdlr *otst.SelfTestControlBlock) {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001731 dh.lockDevice.Lock()
1732 defer dh.lockDevice.Unlock()
mpagenkoaf801632020-07-03 10:00:42 +00001733 dh.pOnuOmciDevice = apDeviceEntry
1734 dh.pOnuTP = apOnuTp
Girish Gowdrae09a6202021-01-12 18:10:59 -08001735 dh.pOnuMetricsMgr = apOnuMetricsMgr
Himani Chawlaac1f5ad2021-02-04 21:21:54 +05301736 dh.pAlarmMgr = apOnuAlarmMgr
Girish Gowdra6afb56a2021-04-27 17:47:57 -07001737 dh.pSelfTestHdlr = apSelfTestHdlr
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001738}
1739
Himani Chawla6d2ae152020-09-02 13:11:20 +05301740//addOnuDeviceEntry creates a new ONU device or returns the existing
1741func (dh *deviceHandler) addOnuDeviceEntry(ctx context.Context) error {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001742 logger.Debugw(ctx, "adding-deviceEntry", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001743
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001744 deviceEntry := dh.GetOnuDeviceEntry(ctx, false)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001745 if deviceEntry == nil {
1746 /* costum_me_map in python code seems always to be None,
1747 we omit that here first (declaration unclear) -> todo at Adapter specialization ...*/
1748 /* also no 'clock' argument - usage open ...*/
1749 /* and no alarm_db yet (oo.alarm_db) */
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001750 deviceEntry = mib.NewOnuDeviceEntry(ctx, dh.coreClient, dh, dh.pOpenOnuAc)
1751 onuTechProfProc := avcfg.NewOnuUniTechProf(ctx, dh, deviceEntry)
1752 onuMetricsMgr := pmmgr.NewOnuMetricsManager(ctx, dh, deviceEntry)
1753 onuAlarmManager := almgr.NewAlarmManager(ctx, dh, deviceEntry)
1754 selfTestHdlr := otst.NewSelfTestMsgHandlerCb(ctx, dh, deviceEntry)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001755 //error treatment possible //TODO!!!
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001756 dh.setDeviceHandlerEntries(deviceEntry, onuTechProfProc, onuMetricsMgr, onuAlarmManager, selfTestHdlr)
mpagenko3af1f032020-06-10 08:53:41 +00001757 // fire deviceEntry ready event to spread to possibly waiting processing
1758 dh.deviceEntrySet <- true
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001759 logger.Debugw(ctx, "onuDeviceEntry-added", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001760 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001761 logger.Debugw(ctx, "onuDeviceEntry-add: Device already exists", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001762 }
1763 // might be updated with some error handling !!!
1764 return nil
1765}
1766
dbainbri4d3a0dc2020-12-02 00:33:42 +00001767func (dh *deviceHandler) createInterface(ctx context.Context, onuind *oop.OnuIndication) error {
1768 logger.Debugw(ctx, "create_interface-started", log.Fields{"OnuId": onuind.GetOnuId(),
Holger Hildebrandt24d51952020-05-04 14:03:42 +00001769 "OnuIntfId": onuind.GetIntfId(), "OnuSerialNumber": onuind.GetSerialNumber()})
1770
1771 dh.pOnuIndication = onuind // let's revise if storing the pointer is sufficient...
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001772
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001773 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00001774 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001775 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
1776 return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00001777 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001778 if !dh.IsReconciling() {
1779 if err := dh.StorePersistentData(ctx); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001780 logger.Warnw(ctx, "store persistent data error - continue as there will be additional write attempts",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001781 log.Fields{"device-id": dh.DeviceID, "err": err})
Holger Hildebrandt3a644642020-12-02 09:46:18 +00001782 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001783 logger.Debugw(ctx, "call DeviceStateUpdate upon create interface", log.Fields{"ConnectStatus": voltha.ConnectStatus_REACHABLE,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001784 "OperStatus": voltha.OperStatus_ACTIVATING, "device-id": dh.DeviceID})
khenaidoo7d3c5582021-08-11 18:09:44 -04001785
1786 if err := dh.updateDeviceStateInCore(ctx, &ic.DeviceStateFilter{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001787 DeviceId: dh.DeviceID,
khenaidoo7d3c5582021-08-11 18:09:44 -04001788 OperStatus: voltha.OperStatus_ACTIVATING,
1789 ConnStatus: voltha.ConnectStatus_REACHABLE,
1790 }); err != nil {
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001791 //TODO with VOL-3045/VOL-3046: return the error and stop further processing
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001792 logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err})
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00001793 }
1794 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001795 logger.Debugw(ctx, "reconciling - don't notify core about DeviceStateUpdate to ACTIVATING",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001796 log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt3a644642020-12-02 09:46:18 +00001797
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001798 pDevEntry.MutexPersOnuConfig.RLock()
1799 if !pDevEntry.SOnuPersistentData.PersUniUnlockDone {
1800 pDevEntry.MutexPersOnuConfig.RUnlock()
dbainbri4d3a0dc2020-12-02 00:33:42 +00001801 logger.Debugw(ctx, "reconciling - uni-ports were not unlocked before adapter restart - resume with a normal start-up",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001802 log.Fields{"device-id": dh.DeviceID})
1803 dh.StopReconciling(ctx, true)
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +00001804 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001805 pDevEntry.MutexPersOnuConfig.RUnlock()
Holger Hildebrandt3a644642020-12-02 09:46:18 +00001806 }
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001807 }
Holger Hildebrandt24d51952020-05-04 14:03:42 +00001808 // It does not look to me as if makes sense to work with the real core device here, (not the stored clone)?
1809 // in this code the GetDevice would just make a check if the DeviceID's Device still exists in core
1810 // in python code it looks as the started onu_omci_device might have been updated with some new instance state of the core device
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001811 // but I would not know why, and the go code anyway does not work with the device directly anymore in the mib.OnuDeviceEntry
Holger Hildebrandt24d51952020-05-04 14:03:42 +00001812 // so let's just try to keep it simple ...
1813 /*
dbainbri4d3a0dc2020-12-02 00:33:42 +00001814 device, err := dh.coreProxy.GetDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, dh.device.Id)
Holger Hildebrandt24d51952020-05-04 14:03:42 +00001815 if err != nil || device == nil {
1816 //TODO: needs to handle error scenarios
1817 logger.Errorw("Failed to fetch device device at creating If", log.Fields{"err": err})
1818 return errors.New("Voltha Device not found")
1819 }
1820 */
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001821
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001822 if err := pDevEntry.Start(log.WithSpanFromContext(context.TODO(), ctx)); err != nil {
Holger Hildebrandt3a644642020-12-02 09:46:18 +00001823 return err
mpagenko3af1f032020-06-10 08:53:41 +00001824 }
Holger Hildebrandt3a644642020-12-02 09:46:18 +00001825
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001826 _ = dh.deviceReasonUpdate(ctx, cmn.DrStartingOpenomci, !dh.IsReconciling())
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001827
1828 /* this might be a good time for Omci Verify message? */
1829 verifyExec := make(chan bool)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001830 omciVerify := otst.NewOmciTestRequest(log.WithSpanFromContext(context.TODO(), ctx),
mpagenko3af1f032020-06-10 08:53:41 +00001831 dh.device.Id, pDevEntry.PDevOmciCC,
mpagenko900ee4b2020-10-12 11:56:34 +00001832 true, true) //exclusive and allowFailure (anyway not yet checked)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001833 omciVerify.PerformOmciTest(log.WithSpanFromContext(context.TODO(), ctx), verifyExec)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001834
1835 /* give the handler some time here to wait for the OMCi verification result
1836 after Timeout start and try MibUpload FSM anyway
1837 (to prevent stopping on just not supported OMCI verification from ONU) */
1838 select {
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001839 case <-time.After(pDevEntry.PDevOmciCC.GetMaxOmciTimeoutWithRetries() * time.Second):
dbainbri4d3a0dc2020-12-02 00:33:42 +00001840 logger.Warn(ctx, "omci start-verification timed out (continue normal)")
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001841 case testresult := <-verifyExec:
dbainbri4d3a0dc2020-12-02 00:33:42 +00001842 logger.Infow(ctx, "Omci start verification done", log.Fields{"result": testresult})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001843 }
1844
1845 /* In py code it looks earlier (on activate ..)
1846 # Code to Run OMCI Test Action
1847 kwargs_omci_test_action = {
1848 OmciTestRequest.DEFAULT_FREQUENCY_KEY:
1849 OmciTestRequest.DEFAULT_COLLECTION_FREQUENCY
1850 }
1851 serial_number = device.serial_number
1852 self._test_request = OmciTestRequest(self.core_proxy,
1853 self.omci_agent, self.device_id,
1854 AniG, serial_number,
1855 self.logical_device_id,
1856 exclusive=False,
1857 **kwargs_omci_test_action)
1858 ...
1859 # Start test requests after a brief pause
1860 if not self._test_request_started:
1861 self._test_request_started = True
1862 tststart = _STARTUP_RETRY_WAIT * (random.randint(1, 5))
1863 reactor.callLater(tststart, self._test_request.start_collector)
1864
1865 */
1866 /* which is then: in omci_test_request.py : */
1867 /*
1868 def start_collector(self, callback=None):
1869 """
1870 Start the collection loop for an adapter if the frequency > 0
1871
1872 :param callback: (callable) Function to call to collect PM data
1873 """
1874 self.logger.info("starting-pm-collection", device_name=self.name, default_freq=self.default_freq)
1875 if callback is None:
1876 callback = self.perform_test_omci
1877
1878 if self.lc is None:
1879 self.lc = LoopingCall(callback)
1880
1881 if self.default_freq > 0:
1882 self.lc.start(interval=self.default_freq / 10)
1883
1884 def perform_test_omci(self):
1885 """
1886 Perform the initial test request
1887 """
1888 ani_g_entities = self._device.configuration.ani_g_entities
1889 ani_g_entities_ids = list(ani_g_entities.keys()) if ani_g_entities \
1890 is not None else None
1891 self._entity_id = ani_g_entities_ids[0]
1892 self.logger.info('perform-test', entity_class=self._entity_class,
1893 entity_id=self._entity_id)
1894 try:
1895 frame = MEFrame(self._entity_class, self._entity_id, []).test()
1896 result = yield self._device.omci_cc.send(frame)
1897 if not result.fields['omci_message'].fields['success_code']:
1898 self.logger.info('Self-Test Submitted Successfully',
1899 code=result.fields[
1900 'omci_message'].fields['success_code'])
1901 else:
1902 raise TestFailure('Test Failure: {}'.format(
1903 result.fields['omci_message'].fields['success_code']))
1904 except TimeoutError as e:
1905 self.deferred.errback(failure.Failure(e))
1906
1907 except Exception as e:
1908 self.logger.exception('perform-test-Error', e=e,
1909 class_id=self._entity_class,
1910 entity_id=self._entity_id)
1911 self.deferred.errback(failure.Failure(e))
1912
1913 */
1914
1915 // PM related heartbeat??? !!!TODO....
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001916 //self._heartbeat.Enabled = True
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001917
mpagenko1cc3cb42020-07-27 15:24:38 +00001918 /* Note: Even though FSM calls look 'synchronous' here, FSM is running in background with the effect that possible errors
1919 * within the MibUpload are not notified in the OnuIndication response, this might be acceptable here,
1920 * as further OltAdapter processing may rely on the deviceReason event 'MibUploadDone' as a result of the FSM processing
Himani Chawla4d908332020-08-31 12:30:20 +05301921 * otherwise some processing synchronization would be required - cmp. e.g TechProfile processing
mpagenko1cc3cb42020-07-27 15:24:38 +00001922 */
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001923 //call MibUploadFSM - transition up to state UlStInSync
1924 pMibUlFsm := pDevEntry.PMibUploadFsm.PFsm
Holger Hildebrandt9ac0d0f2020-05-13 11:22:02 +00001925 if pMibUlFsm != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001926 if pMibUlFsm.Is(mib.UlStDisabled) {
1927 if err := pMibUlFsm.Event(mib.UlEvStart); err != nil {
1928 logger.Errorw(ctx, "MibSyncFsm: Can't go to state starting", log.Fields{"device-id": dh.DeviceID, "err": err})
1929 return fmt.Errorf("can't go to state starting: %s", dh.DeviceID)
Himani Chawla4d908332020-08-31 12:30:20 +05301930 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001931 logger.Debugw(ctx, "MibSyncFsm", log.Fields{"state": string(pMibUlFsm.Current())})
Himani Chawla4d908332020-08-31 12:30:20 +05301932 //Determine ONU status and start/re-start MIB Synchronization tasks
1933 //Determine if this ONU has ever synchronized
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001934 if pDevEntry.IsNewOnu() {
1935 if err := pMibUlFsm.Event(mib.UlEvResetMib); err != nil {
1936 logger.Errorw(ctx, "MibSyncFsm: Can't go to state resetting_mib", log.Fields{"device-id": dh.DeviceID, "err": err})
1937 return fmt.Errorf("can't go to state resetting_mib: %s", dh.DeviceID)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001938 }
Himani Chawla4d908332020-08-31 12:30:20 +05301939 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001940 if err := pMibUlFsm.Event(mib.UlEvExamineMds); err != nil {
1941 logger.Errorw(ctx, "MibSyncFsm: Can't go to state examine_mds", log.Fields{"device-id": dh.DeviceID, "err": err})
1942 return fmt.Errorf("can't go to examine_mds: %s", dh.DeviceID)
Himani Chawla4d908332020-08-31 12:30:20 +05301943 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001944 logger.Debugw(ctx, "state of MibSyncFsm", log.Fields{"state": string(pMibUlFsm.Current())})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001945 }
Holger Hildebrandt9ac0d0f2020-05-13 11:22:02 +00001946 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001947 logger.Errorw(ctx, "wrong state of MibSyncFsm - want: disabled", log.Fields{"have": string(pMibUlFsm.Current()),
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001948 "device-id": dh.DeviceID})
1949 return fmt.Errorf("wrong state of MibSyncFsm: %s", dh.DeviceID)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001950 }
1951 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001952 logger.Errorw(ctx, "MibSyncFsm invalid - cannot be executed!!", log.Fields{"device-id": dh.DeviceID})
1953 return fmt.Errorf("can't execute MibSync: %s", dh.DeviceID)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00001954 }
1955 return nil
1956}
1957
dbainbri4d3a0dc2020-12-02 00:33:42 +00001958func (dh *deviceHandler) updateInterface(ctx context.Context, onuind *oop.OnuIndication) error {
mpagenko3af1f032020-06-10 08:53:41 +00001959 //state checking to prevent unneeded processing (eg. on ONU 'unreachable' and 'down')
mpagenkofc4f56e2020-11-04 17:17:49 +00001960 // (but note that the deviceReason may also have changed to e.g. TechProf*Delete_Success in between)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001961 if dh.getDeviceReason() != cmn.DrStoppingOpenomci {
1962 logger.Debugw(ctx, "updateInterface-started - stopping-device", log.Fields{"device-id": dh.DeviceID})
mpagenko2418ab02020-11-12 12:58:06 +00001963
mpagenko900ee4b2020-10-12 11:56:34 +00001964 //stop all running FSM processing - make use of the DH-state as mirrored in the deviceReason
1965 //here no conflict with aborted FSM's should arise as a complete OMCI initialization is assumed on ONU-Up
1966 //but that might change with some simple MDS check on ONU-Up treatment -> attention!!!
Holger Hildebrandt10d98192021-01-27 15:29:31 +00001967 if err := dh.resetFsms(ctx, true); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001968 logger.Errorw(ctx, "error-updateInterface at FSM stop",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001969 log.Fields{"device-id": dh.DeviceID, "error": err})
mpagenko900ee4b2020-10-12 11:56:34 +00001970 // abort: system behavior is just unstable ...
1971 return err
1972 }
mpagenkoa40e99a2020-11-17 13:50:39 +00001973 //all stored persistent data are not valid anymore (loosing knowledge about the connected ONU)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001974 _ = dh.deleteDevicePersistencyData(ctx) //ignore possible errors here and continue, hope is that data is synchronized with new ONU-Up
mpagenko900ee4b2020-10-12 11:56:34 +00001975
1976 //deviceEntry stop without omciCC reset here, regarding the OMCI_CC still valid for this ONU
1977 // - in contrary to disableDevice - compare with processUniDisableStateDoneEvent
1978 //stop the device entry which resets the attached omciCC
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001979 pDevEntry := dh.GetOnuDeviceEntry(ctx, false)
mpagenko3af1f032020-06-10 08:53:41 +00001980 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001981 logger.Errorw(ctx, "No valid OnuDevice -aborting", log.Fields{"device-id": dh.DeviceID})
1982 return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID)
mpagenko3af1f032020-06-10 08:53:41 +00001983 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001984 _ = pDevEntry.Stop(log.WithSpanFromContext(context.TODO(), ctx), false)
mpagenko3af1f032020-06-10 08:53:41 +00001985
1986 //TODO!!! remove existing traffic profiles
1987 /* from py code, if TP's exist, remove them - not yet implemented
1988 self._tp = dict()
1989 # Let TP download happen again
1990 for uni_id in self._tp_service_specific_task:
1991 self._tp_service_specific_task[uni_id].clear()
1992 for uni_id in self._tech_profile_download_done:
1993 self._tech_profile_download_done[uni_id].clear()
1994 */
1995
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001996 dh.DisableUniPortStateUpdate(ctx)
mpagenko3af1f032020-06-10 08:53:41 +00001997
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00001998 dh.SetReadyForOmciConfig(false)
mpagenkofc4f56e2020-11-04 17:17:49 +00001999
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002000 if err := dh.deviceReasonUpdate(ctx, cmn.DrStoppingOpenomci, true); err != nil {
mpagenko3af1f032020-06-10 08:53:41 +00002001 // abort: system behavior is just unstable ...
2002 return err
2003 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002004 logger.Debugw(ctx, "call DeviceStateUpdate upon update interface", log.Fields{"ConnectStatus": voltha.ConnectStatus_UNREACHABLE,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002005 "OperStatus": voltha.OperStatus_DISCOVERED, "device-id": dh.DeviceID})
khenaidoo7d3c5582021-08-11 18:09:44 -04002006 if err := dh.updateDeviceStateInCore(ctx, &ic.DeviceStateFilter{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002007 DeviceId: dh.DeviceID,
khenaidoo7d3c5582021-08-11 18:09:44 -04002008 ConnStatus: voltha.ConnectStatus_UNREACHABLE,
2009 OperStatus: voltha.OperStatus_DISCOVERED,
2010 }); err != nil {
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00002011 //TODO with VOL-3045/VOL-3046: return the error and stop further processing
dbainbri4d3a0dc2020-12-02 00:33:42 +00002012 logger.Errorw(ctx, "error-updating-device-state unreachable-discovered",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002013 log.Fields{"device-id": dh.DeviceID, "error": err})
mpagenko3af1f032020-06-10 08:53:41 +00002014 // abort: system behavior is just unstable ...
2015 return err
2016 }
2017 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002018 logger.Debugw(ctx, "updateInterface - device already stopped", log.Fields{"device-id": dh.DeviceID})
mpagenko3af1f032020-06-10 08:53:41 +00002019 }
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00002020 return nil
2021}
2022
Holger Hildebrandt10d98192021-01-27 15:29:31 +00002023func (dh *deviceHandler) resetFsms(ctx context.Context, includingMibSyncFsm bool) error {
mpagenko900ee4b2020-10-12 11:56:34 +00002024 //all possible FSM's are stopped or reset here to ensure their transition to 'disabled'
2025 //it is not sufficient to stop/reset the latest running FSM as done in previous versions
2026 // as after down/up procedures all FSM's might be active/ongoing (in theory)
2027 // and using the stop/reset event should never harm
2028
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002029 pDevEntry := dh.GetOnuDeviceEntry(ctx, false)
mpagenko900ee4b2020-10-12 11:56:34 +00002030 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002031 logger.Errorw(ctx, "No valid OnuDevice -aborting", log.Fields{"device-id": dh.DeviceID})
2032 return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID)
mpagenko900ee4b2020-10-12 11:56:34 +00002033 }
Holger Hildebrandtc8ece362021-05-17 12:01:10 +00002034 if pDevEntry.PDevOmciCC != nil {
mpagenko8cd1bf72021-06-22 10:11:19 +00002035 pDevEntry.PDevOmciCC.CancelRequestMonitoring(ctx)
Holger Hildebrandtc8ece362021-05-17 12:01:10 +00002036 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002037 pDevEntry.MutexOnuImageStatus.RLock()
2038 if pDevEntry.POnuImageStatus != nil {
2039 pDevEntry.POnuImageStatus.CancelProcessing(ctx)
Holger Hildebrandtfb402a62021-05-26 14:40:49 +00002040 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002041 pDevEntry.MutexOnuImageStatus.RUnlock()
mpagenkoaa3afe92021-05-21 16:20:58 +00002042
Holger Hildebrandt10d98192021-01-27 15:29:31 +00002043 if includingMibSyncFsm {
Holger Hildebrandtb4563ab2021-04-14 10:27:20 +00002044 pDevEntry.CancelProcessing(ctx)
mpagenko900ee4b2020-10-12 11:56:34 +00002045 }
2046 //MibDownload may run
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002047 pMibDlFsm := pDevEntry.PMibDownloadFsm.PFsm
mpagenko900ee4b2020-10-12 11:56:34 +00002048 if pMibDlFsm != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002049 _ = pMibDlFsm.Event(mib.DlEvReset)
mpagenko900ee4b2020-10-12 11:56:34 +00002050 }
2051 //port lock/unlock FSM's may be active
2052 if dh.pUnlockStateFsm != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002053 _ = dh.pUnlockStateFsm.PAdaptFsm.PFsm.Event(uniprt.UniEvReset)
mpagenko900ee4b2020-10-12 11:56:34 +00002054 }
2055 if dh.pLockStateFsm != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002056 _ = dh.pLockStateFsm.PAdaptFsm.PFsm.Event(uniprt.UniEvReset)
mpagenko900ee4b2020-10-12 11:56:34 +00002057 }
2058 //techProfile related PonAniConfigFsm FSM may be active
2059 if dh.pOnuTP != nil {
2060 // should always be the case here
2061 // FSM stop maybe encapsulated as OnuTP method - perhaps later in context of module splitting
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002062 if dh.pOnuTP.PAniConfigFsm != nil {
2063 for uniTP := range dh.pOnuTP.PAniConfigFsm {
2064 dh.pOnuTP.PAniConfigFsm[uniTP].CancelProcessing(ctx)
Girish Gowdra041dcb32020-11-16 16:54:30 -08002065 }
mpagenko900ee4b2020-10-12 11:56:34 +00002066 }
2067 for _, uniPort := range dh.uniEntityMap {
mpagenko900ee4b2020-10-12 11:56:34 +00002068 // reset the possibly existing VlanConfigFsm
mpagenkof1fc3862021-02-16 10:09:52 +00002069 dh.lockVlanConfig.RLock()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002070 if pVlanFilterFsm, exist := dh.UniVlanConfigFsmMap[uniPort.UniID]; exist {
mpagenko900ee4b2020-10-12 11:56:34 +00002071 //VlanFilterFsm exists and was already started
mpagenko7d6bb022021-03-11 15:07:55 +00002072 dh.lockVlanConfig.RUnlock()
2073 //reset of all Fsm is always accompanied by global persistency data removal
2074 // no need to remove specific data
2075 pVlanFilterFsm.RequestClearPersistency(false)
2076 //ensure the FSM processing is stopped in case waiting for some response
mpagenko73143992021-04-09 15:17:10 +00002077 pVlanFilterFsm.CancelProcessing(ctx)
mpagenkof1fc3862021-02-16 10:09:52 +00002078 } else {
2079 dh.lockVlanConfig.RUnlock()
mpagenko900ee4b2020-10-12 11:56:34 +00002080 }
2081 }
2082 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002083 if dh.GetCollectorIsRunning() {
Holger Hildebrandt10d98192021-01-27 15:29:31 +00002084 // Stop collector routine
2085 dh.stopCollector <- true
2086 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002087 if dh.GetAlarmManagerIsRunning(ctx) {
Himani Chawla4c1d4c72021-02-18 12:14:31 +05302088 dh.stopAlarmManager <- true
2089 }
Girish Gowdra10123c02021-08-30 11:52:06 -07002090 if dh.pSelfTestHdlr.GetSelfTestHandlerIsRunning() {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002091 dh.pSelfTestHdlr.StopSelfTestModule <- true
Girish Gowdra10123c02021-08-30 11:52:06 -07002092 }
Himani Chawla4c1d4c72021-02-18 12:14:31 +05302093
Girish Gowdrae95687a2021-09-08 16:30:58 -07002094 // Note: We want flow deletes to be processed on onu down, so do not stop flow monitoring routines
2095
mpagenko80622a52021-02-09 16:53:23 +00002096 //reset a possibly running upgrade FSM
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002097 // (note the Upgrade FSM may stay alive e.g. in state UpgradeStWaitForCommit to endure the ONU reboot)
mpagenko80622a52021-02-09 16:53:23 +00002098 dh.lockUpgradeFsm.RLock()
mpagenko38662d02021-08-11 09:45:19 +00002099 lopOnuUpradeFsm := dh.pOnuUpradeFsm
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002100 //lockUpgradeFsm must be release before cancellation as this may implicitly request RemoveOnuUpgradeFsm()
mpagenko80622a52021-02-09 16:53:23 +00002101 dh.lockUpgradeFsm.RUnlock()
mpagenko38662d02021-08-11 09:45:19 +00002102 if lopOnuUpradeFsm != nil {
mpagenko59862f02021-10-11 08:53:18 +00002103 if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation
2104 //here we do not expect intermediate cancelation, we still allow for other commands on this FSM
2105 // (even though it may also run into direct cancellation, a bit hard to verify here)
2106 // so don't set 'dh.upgradeCanceled = true' here!
2107 lopOnuUpradeFsm.CancelProcessing(ctx, false, voltha.ImageState_CANCELLED_ON_ONU_STATE) //conditional cancel
2108 }
mpagenko38662d02021-08-11 09:45:19 +00002109 }
mpagenko80622a52021-02-09 16:53:23 +00002110
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002111 logger.Infow(ctx, "resetFsms done", log.Fields{"device-id": dh.DeviceID})
mpagenko900ee4b2020-10-12 11:56:34 +00002112 return nil
2113}
2114
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002115func (dh *deviceHandler) processMibDatabaseSyncEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) {
2116 logger.Debugw(ctx, "MibInSync event received, adding uni ports and locking the ONU interfaces", log.Fields{"device-id": dh.DeviceID})
Himani Chawla26e555c2020-08-31 12:30:20 +05302117
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002118 // store persistent data collected during MIB upload processing
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002119 if err := dh.StorePersistentData(ctx); err != nil {
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002120 logger.Warnw(ctx, "store persistent data error - continue as there will be additional write attempts",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002121 log.Fields{"device-id": dh.DeviceID, "err": err})
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002122 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002123 _ = dh.deviceReasonUpdate(ctx, cmn.DrDiscoveryMibsyncComplete, !dh.IsReconciling())
2124 dh.AddAllUniPorts(ctx)
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002125
mpagenkoa40e99a2020-11-17 13:50:39 +00002126 /* 200605: lock processing after initial MIBUpload removed now as the ONU should be in the lock state per default here */
2127 /* 201117: build_dt-berlin-pod-openonugo_1T8GEM_voltha_DT_openonugo_master_test runs into error TC
2128 * 'Test Disable ONUs and OLT Then Delete ONUs and OLT for DT' with Sercom ONU, which obviously needs
2129 * disable/enable toggling here to allow traffic
2130 * but moreover it might be useful for tracking the interface operState changes if this will be implemented,
2131 * like the py comment says:
2132 * # start by locking all the unis till mib sync and initial mib is downloaded
2133 * # this way we can capture the port down/up events when we are ready
2134 */
Himani Chawla26e555c2020-08-31 12:30:20 +05302135
mpagenkoa40e99a2020-11-17 13:50:39 +00002136 // Init Uni Ports to Admin locked state
2137 // *** should generate UniLockStateDone event *****
2138 if dh.pLockStateFsm == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002139 dh.createUniLockFsm(ctx, true, cmn.UniLockStateDone)
mpagenkoa40e99a2020-11-17 13:50:39 +00002140 } else { //LockStateFSM already init
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002141 dh.pLockStateFsm.SetSuccessEvent(cmn.UniLockStateDone)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002142 dh.runUniLockFsm(ctx, true)
mpagenkoa40e99a2020-11-17 13:50:39 +00002143 }
2144}
2145
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002146func (dh *deviceHandler) processUniLockStateDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) {
2147 logger.Infow(ctx, "UniLockStateDone event: Starting MIB download", log.Fields{"device-id": dh.DeviceID})
Himani Chawla26e555c2020-08-31 12:30:20 +05302148 /* Mib download procedure -
2149 ***** should run over 'downloaded' state and generate MibDownloadDone event *****
2150 */
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002151 pDevEntry := dh.GetOnuDeviceEntry(ctx, false)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002152 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002153 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002154 return
2155 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002156 pMibDlFsm := pDevEntry.PMibDownloadFsm.PFsm
Himani Chawla26e555c2020-08-31 12:30:20 +05302157 if pMibDlFsm != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002158 if pMibDlFsm.Is(mib.DlStDisabled) {
2159 if err := pMibDlFsm.Event(mib.DlEvStart); err != nil {
2160 logger.Errorw(ctx, "MibDownloadFsm: Can't go to state starting", log.Fields{"device-id": dh.DeviceID, "err": err})
Himani Chawla26e555c2020-08-31 12:30:20 +05302161 // maybe try a FSM reset and then again ... - TODO!!!
2162 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002163 logger.Debugw(ctx, "MibDownloadFsm", log.Fields{"state": string(pMibDlFsm.Current())})
Himani Chawla26e555c2020-08-31 12:30:20 +05302164 // maybe use more specific states here for the specific download steps ...
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002165 if err := pMibDlFsm.Event(mib.DlEvCreateGal); err != nil {
2166 logger.Errorw(ctx, "MibDownloadFsm: Can't start CreateGal", log.Fields{"device-id": dh.DeviceID, "err": err})
Himani Chawla26e555c2020-08-31 12:30:20 +05302167 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002168 logger.Debugw(ctx, "state of MibDownloadFsm", log.Fields{"state": string(pMibDlFsm.Current())})
Himani Chawla26e555c2020-08-31 12:30:20 +05302169 //Begin MIB data download (running autonomously)
2170 }
2171 }
2172 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002173 logger.Errorw(ctx, "wrong state of MibDownloadFsm - want: disabled", log.Fields{"have": string(pMibDlFsm.Current()),
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002174 "device-id": dh.DeviceID})
Himani Chawla26e555c2020-08-31 12:30:20 +05302175 // maybe try a FSM reset and then again ... - TODO!!!
2176 }
2177 /***** Mib download started */
2178 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002179 logger.Errorw(ctx, "MibDownloadFsm invalid - cannot be executed!!", log.Fields{"device-id": dh.DeviceID})
Himani Chawla26e555c2020-08-31 12:30:20 +05302180 }
2181}
2182
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002183func (dh *deviceHandler) processMibDownloadDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) {
2184 logger.Debugw(ctx, "MibDownloadDone event received, unlocking the ONU interfaces", log.Fields{"device-id": dh.DeviceID})
Himani Chawla26e555c2020-08-31 12:30:20 +05302185 //initiate DevStateUpdate
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002186 if !dh.IsReconciling() {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002187 logger.Debugw(ctx, "call DeviceStateUpdate upon mib-download done", log.Fields{"ConnectStatus": voltha.ConnectStatus_REACHABLE,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002188 "OperStatus": voltha.OperStatus_ACTIVE, "device-id": dh.DeviceID})
mpagenko15ff4a52021-03-02 10:09:20 +00002189 //we allow a possible OnuSw image commit only in the normal startup, not at reconciling
2190 // in case of adapter restart connected to an ONU upgrade I would not rely on the image quality
2191 // maybe some 'forced' commitment can be done in this situation from system management (or upgrade restarted)
2192 dh.checkOnOnuImageCommit(ctx)
khenaidoo7d3c5582021-08-11 18:09:44 -04002193 if err := dh.updateDeviceStateInCore(ctx, &ic.DeviceStateFilter{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002194 DeviceId: dh.DeviceID,
khenaidoo7d3c5582021-08-11 18:09:44 -04002195 ConnStatus: voltha.ConnectStatus_REACHABLE,
2196 OperStatus: voltha.OperStatus_ACTIVE,
2197 }); err != nil {
Himani Chawla26e555c2020-08-31 12:30:20 +05302198 //TODO with VOL-3045/VOL-3046: return the error and stop further processing
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002199 logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err})
Himani Chawla26e555c2020-08-31 12:30:20 +05302200 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002201 logger.Debugw(ctx, "dev state updated to 'Oper.Active'", log.Fields{"device-id": dh.DeviceID})
Himani Chawla26e555c2020-08-31 12:30:20 +05302202 }
2203 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002204 logger.Debugw(ctx, "reconciling - don't notify core about DeviceStateUpdate to ACTIVE",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002205 log.Fields{"device-id": dh.DeviceID})
Himani Chawla26e555c2020-08-31 12:30:20 +05302206 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002207 _ = dh.deviceReasonUpdate(ctx, cmn.DrInitialMibDownloaded, !dh.IsReconciling())
Girish Gowdrae0140f02021-02-02 16:55:09 -08002208
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002209 if !dh.GetCollectorIsRunning() {
Girish Gowdra7b0ee5c2021-03-19 21:48:15 -07002210 // Start PM collector routine
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002211 go dh.StartCollector(ctx)
Girish Gowdra7b0ee5c2021-03-19 21:48:15 -07002212 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002213 if !dh.GetAlarmManagerIsRunning(ctx) {
2214 go dh.StartAlarmManager(ctx)
Girish Gowdra7b0ee5c2021-03-19 21:48:15 -07002215 }
2216
Girish Gowdrae95687a2021-09-08 16:30:58 -07002217 // Start flow handler routines per UNI
2218 for _, uniPort := range dh.uniEntityMap {
2219 // only if this port was enabled for use by the operator at startup
2220 if (1<<uniPort.UniID)&dh.pOpenOnuAc.config.UniPortMask == (1 << uniPort.UniID) {
2221 if !dh.GetFlowMonitoringIsRunning(uniPort.UniID) {
2222 go dh.PerOnuFlowHandlerRoutine(uniPort.UniID)
2223 }
2224 }
2225 }
2226
Girish Gowdrae0140f02021-02-02 16:55:09 -08002227 // Initialize classical L2 PM Interval Counters
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002228 if err := dh.pOnuMetricsMgr.PAdaptFsm.PFsm.Event(pmmgr.L2PmEventInit); err != nil {
Girish Gowdrae0140f02021-02-02 16:55:09 -08002229 // There is no way we should be landing here, but if we do then
2230 // there is nothing much we can do about this other than log error
2231 logger.Errorw(ctx, "error starting l2 pm fsm", log.Fields{"device-id": dh.device.Id, "err": err})
2232 }
2233
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002234 dh.SetReadyForOmciConfig(true)
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002235
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002236 pDevEntry := dh.GetOnuDeviceEntry(ctx, false)
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002237 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002238 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002239 return
2240 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002241 pDevEntry.MutexPersOnuConfig.RLock()
2242 if dh.IsReconciling() && pDevEntry.SOnuPersistentData.PersUniDisableDone {
2243 pDevEntry.MutexPersOnuConfig.RUnlock()
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002244 logger.Debugw(ctx, "reconciling - uni-ports were disabled by admin before adapter restart - keep the ports locked",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002245 log.Fields{"device-id": dh.DeviceID})
2246 go dh.ReconcileDeviceTechProf(ctx)
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002247 // reconcilement will be continued after ani config is done
2248 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002249 pDevEntry.MutexPersOnuConfig.RUnlock()
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002250 // *** should generate UniUnlockStateDone event *****
2251 if dh.pUnlockStateFsm == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002252 dh.createUniLockFsm(ctx, false, cmn.UniUnlockStateDone)
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002253 } else { //UnlockStateFSM already init
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002254 dh.pUnlockStateFsm.SetSuccessEvent(cmn.UniUnlockStateDone)
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002255 dh.runUniLockFsm(ctx, false)
2256 }
Himani Chawla26e555c2020-08-31 12:30:20 +05302257 }
2258}
2259
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002260func (dh *deviceHandler) processUniUnlockStateDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) {
2261 dh.EnableUniPortStateUpdate(ctx) //cmp python yield self.enable_ports()
Himani Chawla26e555c2020-08-31 12:30:20 +05302262
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002263 if !dh.IsReconciling() {
2264 logger.Infow(ctx, "UniUnlockStateDone event: Sending OnuUp event", log.Fields{"device-id": dh.DeviceID})
ozgecanetsia2f05ed32021-05-31 17:13:48 +03002265 raisedTs := time.Now().Unix()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002266 go dh.sendOnuOperStateEvent(ctx, voltha.OperStatus_ACTIVE, dh.DeviceID, raisedTs) //cmp python onu_active_event
2267 pDevEntry := dh.GetOnuDeviceEntry(ctx, false)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002268 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002269 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002270 return
2271 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002272 pDevEntry.MutexPersOnuConfig.Lock()
2273 pDevEntry.SOnuPersistentData.PersUniUnlockDone = true
2274 pDevEntry.MutexPersOnuConfig.Unlock()
2275 if err := dh.StorePersistentData(ctx); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002276 logger.Warnw(ctx, "store persistent data error - continue for now as there will be additional write attempts",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002277 log.Fields{"device-id": dh.DeviceID, "err": err})
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002278 }
Himani Chawla26e555c2020-08-31 12:30:20 +05302279 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002280 logger.Debugw(ctx, "reconciling - don't notify core that onu went to active but trigger tech profile config",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002281 log.Fields{"device-id": dh.DeviceID})
2282 go dh.ReconcileDeviceTechProf(ctx)
Holger Hildebrandt47555e72020-09-21 11:07:24 +00002283 // reconcilement will be continued after ani config is done
Himani Chawla26e555c2020-08-31 12:30:20 +05302284 }
2285}
2286
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002287func (dh *deviceHandler) processUniDisableStateDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002288 logger.Debugw(ctx, "DeviceStateUpdate upon disable", log.Fields{"ConnectStatus": voltha.ConnectStatus_REACHABLE,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002289 "OperStatus": voltha.OperStatus_UNKNOWN, "device-id": dh.DeviceID})
khenaidoo7d3c5582021-08-11 18:09:44 -04002290
2291 if err := dh.updateDeviceStateInCore(ctx, &ic.DeviceStateFilter{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002292 DeviceId: dh.DeviceID,
khenaidoo7d3c5582021-08-11 18:09:44 -04002293 ConnStatus: voltha.ConnectStatus_REACHABLE,
2294 OperStatus: voltha.OperStatus_UNKNOWN,
2295 }); err != nil {
mpagenko900ee4b2020-10-12 11:56:34 +00002296 //TODO with VOL-3045/VOL-3046: return the error and stop further processing
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002297 logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err})
mpagenko900ee4b2020-10-12 11:56:34 +00002298 }
2299
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002300 logger.Debugw(ctx, "DeviceReasonUpdate upon disable", log.Fields{"reason": cmn.DeviceReasonMap[cmn.DrOmciAdminLock], "device-id": dh.DeviceID})
mpagenko900ee4b2020-10-12 11:56:34 +00002301 // DeviceReason to update acc.to modified py code as per beginning of Sept 2020
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002302 _ = dh.deviceReasonUpdate(ctx, cmn.DrOmciAdminLock, true)
mpagenko900ee4b2020-10-12 11:56:34 +00002303
2304 //transfer the modified logical uni port state
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002305 dh.DisableUniPortStateUpdate(ctx)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002306
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002307 pDevEntry := dh.GetOnuDeviceEntry(ctx, false)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002308 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002309 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002310 return
2311 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002312 pDevEntry.MutexPersOnuConfig.Lock()
2313 pDevEntry.SOnuPersistentData.PersUniDisableDone = true
2314 pDevEntry.MutexPersOnuConfig.Unlock()
2315 if err := dh.StorePersistentData(ctx); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002316 logger.Warnw(ctx, "store persistent data error - continue for now as there will be additional write attempts",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002317 log.Fields{"device-id": dh.DeviceID, "err": err})
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002318 }
mpagenko900ee4b2020-10-12 11:56:34 +00002319}
2320
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002321func (dh *deviceHandler) processUniEnableStateDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002322 logger.Debugw(ctx, "DeviceStateUpdate upon re-enable", log.Fields{"ConnectStatus": voltha.ConnectStatus_REACHABLE,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002323 "OperStatus": voltha.OperStatus_ACTIVE, "device-id": dh.DeviceID})
khenaidoo7d3c5582021-08-11 18:09:44 -04002324 if err := dh.updateDeviceStateInCore(ctx, &ic.DeviceStateFilter{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002325 DeviceId: dh.DeviceID,
khenaidoo7d3c5582021-08-11 18:09:44 -04002326 ConnStatus: voltha.ConnectStatus_REACHABLE,
2327 OperStatus: voltha.OperStatus_ACTIVE,
2328 }); err != nil {
mpagenko900ee4b2020-10-12 11:56:34 +00002329 //TODO with VOL-3045/VOL-3046: return the error and stop further processing
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002330 logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err})
mpagenko900ee4b2020-10-12 11:56:34 +00002331 }
2332
dbainbri4d3a0dc2020-12-02 00:33:42 +00002333 logger.Debugw(ctx, "DeviceReasonUpdate upon re-enable", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002334 "reason": cmn.DeviceReasonMap[cmn.DrOnuReenabled], "device-id": dh.DeviceID})
mpagenko900ee4b2020-10-12 11:56:34 +00002335 // DeviceReason to update acc.to modified py code as per beginning of Sept 2020
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002336 _ = dh.deviceReasonUpdate(ctx, cmn.DrOnuReenabled, true)
mpagenko900ee4b2020-10-12 11:56:34 +00002337
2338 //transfer the modified logical uni port state
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002339 dh.EnableUniPortStateUpdate(ctx)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002340
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002341 pDevEntry := dh.GetOnuDeviceEntry(ctx, false)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002342 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002343 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002344 return
2345 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002346 pDevEntry.MutexPersOnuConfig.Lock()
2347 pDevEntry.SOnuPersistentData.PersUniDisableDone = false
2348 pDevEntry.MutexPersOnuConfig.Unlock()
2349 if err := dh.StorePersistentData(ctx); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002350 logger.Warnw(ctx, "store persistent data error - continue for now as there will be additional write attempts",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002351 log.Fields{"device-id": dh.DeviceID, "err": err})
Holger Hildebrandt3a644642020-12-02 09:46:18 +00002352 }
mpagenko900ee4b2020-10-12 11:56:34 +00002353}
2354
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002355func (dh *deviceHandler) processOmciAniConfigDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) {
2356 if devEvent == cmn.OmciAniConfigDone {
2357 logger.Debugw(ctx, "OmciAniConfigDone event received", log.Fields{"device-id": dh.DeviceID})
mpagenkofc4f56e2020-11-04 17:17:49 +00002358 // attention: the device reason update is done based on ONU-UNI-Port related activity
2359 // - which may cause some inconsistency
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002360 if dh.getDeviceReason() != cmn.DrTechProfileConfigDownloadSuccess {
mpagenkofc4f56e2020-11-04 17:17:49 +00002361 // which may be the case from some previous actvity even on this UNI Port (but also other UNI ports)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002362 _ = dh.deviceReasonUpdate(ctx, cmn.DrTechProfileConfigDownloadSuccess, !dh.IsReconciling())
Himani Chawla26e555c2020-08-31 12:30:20 +05302363 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002364 if dh.IsReconciling() {
2365 go dh.ReconcileDeviceFlowConfig(ctx)
mpagenkofc4f56e2020-11-04 17:17:49 +00002366 }
2367 } else { // should be the OmciAniResourceRemoved block
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002368 logger.Debugw(ctx, "OmciAniResourceRemoved event received", log.Fields{"device-id": dh.DeviceID})
mpagenkofc4f56e2020-11-04 17:17:49 +00002369 // attention: the device reason update is done based on ONU-UNI-Port related activity
2370 // - which may cause some inconsistency
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002371 if dh.getDeviceReason() != cmn.DrTechProfileConfigDeleteSuccess {
mpagenkofc4f56e2020-11-04 17:17:49 +00002372 // which may be the case from some previous actvity even on this ONU port (but also other UNI ports)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002373 _ = dh.deviceReasonUpdate(ctx, cmn.DrTechProfileConfigDeleteSuccess, true)
mpagenkofc4f56e2020-11-04 17:17:49 +00002374 }
Holger Hildebrandt47555e72020-09-21 11:07:24 +00002375 }
Himani Chawla26e555c2020-08-31 12:30:20 +05302376}
2377
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002378func (dh *deviceHandler) processOmciVlanFilterDoneEvent(ctx context.Context, aDevEvent cmn.OnuDeviceEvent) {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002379 logger.Debugw(ctx, "OmciVlanFilterDone event received",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002380 log.Fields{"device-id": dh.DeviceID, "event": aDevEvent})
Himani Chawla26e555c2020-08-31 12:30:20 +05302381 // attention: the device reason update is done based on ONU-UNI-Port related activity
2382 // - which may cause some inconsistency
Himani Chawla26e555c2020-08-31 12:30:20 +05302383
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002384 if aDevEvent == cmn.OmciVlanFilterAddDone || aDevEvent == cmn.OmciVlanFilterAddDoneNoKvStore {
2385 if dh.getDeviceReason() != cmn.DrOmciFlowsPushed {
mpagenkofc4f56e2020-11-04 17:17:49 +00002386 // which may be the case from some previous actvity on another UNI Port of the ONU
2387 // or even some previous flow add activity on the same port
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002388 _ = dh.deviceReasonUpdate(ctx, cmn.DrOmciFlowsPushed, !dh.IsReconciling())
2389 if dh.IsReconciling() {
Holger Hildebrandt1b8f4ad2021-03-25 15:53:51 +00002390 go dh.reconcileEnd(ctx)
mpagenkofc4f56e2020-11-04 17:17:49 +00002391 }
2392 }
2393 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002394 if dh.getDeviceReason() != cmn.DrOmciFlowsDeleted {
mpagenkofc4f56e2020-11-04 17:17:49 +00002395 //not relevant for reconcile
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002396 _ = dh.deviceReasonUpdate(ctx, cmn.DrOmciFlowsDeleted, true)
Holger Hildebrandt47555e72020-09-21 11:07:24 +00002397 }
Himani Chawla26e555c2020-08-31 12:30:20 +05302398 }
mpagenkof1fc3862021-02-16 10:09:52 +00002399
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002400 if aDevEvent == cmn.OmciVlanFilterAddDone || aDevEvent == cmn.OmciVlanFilterRemDone {
mpagenkof1fc3862021-02-16 10:09:52 +00002401 //events that request KvStore write
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002402 if err := dh.StorePersistentData(ctx); err != nil {
mpagenkof1fc3862021-02-16 10:09:52 +00002403 logger.Warnw(ctx, "store persistent data error - continue for now as there will be additional write attempts",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002404 log.Fields{"device-id": dh.DeviceID, "err": err})
mpagenkof1fc3862021-02-16 10:09:52 +00002405 }
2406 } else {
2407 logger.Debugw(ctx, "OmciVlanFilter*Done* - write to KvStore not requested",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002408 log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt10d98192021-01-27 15:29:31 +00002409 }
Himani Chawla26e555c2020-08-31 12:30:20 +05302410}
2411
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002412//DeviceProcStatusUpdate evaluates possible processing events and initiates according next activities
2413func (dh *deviceHandler) DeviceProcStatusUpdate(ctx context.Context, devEvent cmn.OnuDeviceEvent) {
Himani Chawla4d908332020-08-31 12:30:20 +05302414 switch devEvent {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002415 case cmn.MibDatabaseSync:
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002416 {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002417 dh.processMibDatabaseSyncEvent(ctx, devEvent)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002418 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002419 case cmn.UniLockStateDone:
mpagenkoa40e99a2020-11-17 13:50:39 +00002420 {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002421 dh.processUniLockStateDoneEvent(ctx, devEvent)
mpagenkoa40e99a2020-11-17 13:50:39 +00002422 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002423 case cmn.MibDownloadDone:
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002424 {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002425 dh.processMibDownloadDoneEvent(ctx, devEvent)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002426 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002427 case cmn.UniUnlockStateDone:
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002428 {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002429 dh.processUniUnlockStateDoneEvent(ctx, devEvent)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002430 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002431 case cmn.UniEnableStateDone:
mpagenko900ee4b2020-10-12 11:56:34 +00002432 {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002433 dh.processUniEnableStateDoneEvent(ctx, devEvent)
mpagenko900ee4b2020-10-12 11:56:34 +00002434 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002435 case cmn.UniDisableStateDone:
mpagenko900ee4b2020-10-12 11:56:34 +00002436 {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002437 dh.processUniDisableStateDoneEvent(ctx, devEvent)
mpagenko900ee4b2020-10-12 11:56:34 +00002438 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002439 case cmn.OmciAniConfigDone, cmn.OmciAniResourceRemoved:
mpagenko3dbcdd22020-07-22 07:38:45 +00002440 {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002441 dh.processOmciAniConfigDoneEvent(ctx, devEvent)
mpagenko3dbcdd22020-07-22 07:38:45 +00002442 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002443 case cmn.OmciVlanFilterAddDone, cmn.OmciVlanFilterAddDoneNoKvStore, cmn.OmciVlanFilterRemDone, cmn.OmciVlanFilterRemDoneNoKvStore:
mpagenkodff5dda2020-08-28 11:52:01 +00002444 {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002445 dh.processOmciVlanFilterDoneEvent(ctx, devEvent)
mpagenkodff5dda2020-08-28 11:52:01 +00002446 }
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002447 default:
2448 {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002449 logger.Debugw(ctx, "unhandled-device-event", log.Fields{"device-id": dh.DeviceID, "event": devEvent})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002450 }
2451 } //switch
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00002452}
2453
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002454func (dh *deviceHandler) addUniPort(ctx context.Context, aUniInstNo uint16, aUniID uint8, aPortType cmn.UniPortType) {
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002455 // parameters are IntfId, OnuId, uniId
Mahir Gunyelcb128ae2021-10-06 09:42:05 -07002456 uniNo := platform.MkUniPortNum(ctx, dh.pOnuIndication.GetIntfId(), dh.pOnuIndication.GetOnuId(),
Himani Chawla4d908332020-08-31 12:30:20 +05302457 uint32(aUniID))
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002458 if _, present := dh.uniEntityMap[uniNo]; present {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002459 logger.Warnw(ctx, "OnuUniPort-add: Port already exists", log.Fields{"for InstanceId": aUniInstNo})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00002460 } else {
Himani Chawla4d908332020-08-31 12:30:20 +05302461 //with arguments aUniID, a_portNo, aPortType
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002462 pUniPort := cmn.NewOnuUniPort(ctx, aUniID, uniNo, aUniInstNo, aPortType)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00002463 if pUniPort == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002464 logger.Warnw(ctx, "OnuUniPort-add: Could not create Port", log.Fields{"for InstanceId": aUniInstNo})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00002465 } else {
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002466 //store UniPort with the System-PortNumber key
2467 dh.uniEntityMap[uniNo] = pUniPort
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002468 if !dh.IsReconciling() {
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00002469 // create announce the UniPort to the core as VOLTHA Port object
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002470 if err := pUniPort.CreateVolthaPort(ctx, dh); err == nil {
2471 logger.Infow(ctx, "OnuUniPort-added", log.Fields{"for PortNo": uniNo})
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00002472 } //error logging already within UniPort method
2473 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002474 logger.Debugw(ctx, "reconciling - OnuUniPort already added", log.Fields{"for PortNo": uniNo, "device-id": dh.DeviceID})
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00002475 }
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +00002476 }
2477 }
2478}
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002479
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002480func (dh *deviceHandler) AddAllUniPorts(ctx context.Context) {
2481 pDevEntry := dh.GetOnuDeviceEntry(ctx, false)
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002482 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002483 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002484 return
2485 }
Girish Gowdrae95687a2021-09-08 16:30:58 -07002486 uniCnt := uint8(0) //UNI Port limit: see MaxUnisPerOnu (by now 16) (OMCI supports max 255 p.b.)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002487 if pptpInstKeys := pDevEntry.GetOnuDB().GetSortedInstKeys(
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002488 ctx, me.PhysicalPathTerminationPointEthernetUniClassID); len(pptpInstKeys) > 0 {
2489 for _, mgmtEntityID := range pptpInstKeys {
2490 logger.Debugw(ctx, "Add PPTPEthUni port for MIB-stored instance:", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002491 "device-id": dh.DeviceID, "PPTPEthUni EntityID": mgmtEntityID})
Girish Gowdrae95687a2021-09-08 16:30:58 -07002492 dh.addUniPort(ctx, mgmtEntityID, uniCnt, cmn.UniPPTP)
2493 uniCnt++
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002494 }
2495 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002496 logger.Debugw(ctx, "No PPTP instances found", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002497 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002498 if veipInstKeys := pDevEntry.GetOnuDB().GetSortedInstKeys(
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002499 ctx, me.VirtualEthernetInterfacePointClassID); len(veipInstKeys) > 0 {
2500 for _, mgmtEntityID := range veipInstKeys {
2501 logger.Debugw(ctx, "Add VEIP for MIB-stored instance:", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002502 "device-id": dh.DeviceID, "VEIP EntityID": mgmtEntityID})
Girish Gowdrae95687a2021-09-08 16:30:58 -07002503 dh.addUniPort(ctx, mgmtEntityID, uniCnt, cmn.UniVEIP)
2504 uniCnt++
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002505 }
2506 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002507 logger.Debugw(ctx, "No VEIP instances found", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002508 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002509 if potsInstKeys := pDevEntry.GetOnuDB().GetSortedInstKeys(
ozgecanetsia124d9732021-09-16 14:31:57 +03002510 ctx, me.PhysicalPathTerminationPointPotsUniClassID); len(potsInstKeys) > 0 {
2511 for _, mgmtEntityID := range potsInstKeys {
2512 logger.Debugw(ctx, "Add PPTP Pots UNI for MIB-stored instance:", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002513 "device-id": dh.DeviceID, "PPTP Pots UNI EntityID": mgmtEntityID})
Girish Gowdrae95687a2021-09-08 16:30:58 -07002514 dh.addUniPort(ctx, mgmtEntityID, uniCnt, cmn.UniPPTPPots)
2515 uniCnt++
ozgecanetsia124d9732021-09-16 14:31:57 +03002516 }
2517 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002518 logger.Debugw(ctx, "No PPTP Pots UNI instances found", log.Fields{"device-id": dh.DeviceID})
ozgecanetsia124d9732021-09-16 14:31:57 +03002519 }
Girish Gowdrae95687a2021-09-08 16:30:58 -07002520 if uniCnt == 0 {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002521 logger.Warnw(ctx, "No UniG instances found", log.Fields{"device-id": dh.DeviceID})
Girish Gowdrae95687a2021-09-08 16:30:58 -07002522 return
2523 }
2524
2525 dh.flowCbChan = make([]chan FlowCb, uniCnt)
2526 dh.stopFlowMonitoringRoutine = make([]chan bool, uniCnt)
2527 dh.isFlowMonitoringRoutineActive = make([]bool, uniCnt)
2528 for i := 0; i < int(uniCnt); i++ {
2529 dh.flowCbChan[i] = make(chan FlowCb, dh.pOpenOnuAc.config.MaxConcurrentFlowsPerUni)
2530 dh.stopFlowMonitoringRoutine[i] = make(chan bool)
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002531 }
2532}
2533
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002534// EnableUniPortStateUpdate enables UniPortState and update core port state accordingly
2535func (dh *deviceHandler) EnableUniPortStateUpdate(ctx context.Context) {
Holger Hildebrandtbe674422020-05-05 13:05:30 +00002536 // py code was updated 2003xx to activate the real ONU UNI ports per OMCI (VEIP or PPTP)
Himani Chawla4d908332020-08-31 12:30:20 +05302537 // but towards core only the first port active state is signaled
Holger Hildebrandtbe674422020-05-05 13:05:30 +00002538 // with following remark:
2539 // # TODO: for now only support the first UNI given no requirement for multiple uni yet. Also needed to reduce flow
2540 // # load on the core
2541
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002542 // lock_ports(false) as done in py code here is shifted to separate call from device event processing
Holger Hildebrandtbe674422020-05-05 13:05:30 +00002543
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002544 for uniNo, uniPort := range dh.uniEntityMap {
mpagenko3af1f032020-06-10 08:53:41 +00002545 // only if this port is validated for operState transfer
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002546 if (1<<uniPort.UniID)&dh.pOpenOnuAc.config.UniPortMask == (1 << uniPort.UniID) {
2547 logger.Infow(ctx, "OnuUniPort-forced-OperState-ACTIVE", log.Fields{"for PortNo": uniNo, "device-id": dh.DeviceID})
2548 uniPort.SetOperState(vc.OperStatus_ACTIVE)
2549 if !dh.IsReconciling() {
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00002550 //maybe also use getter functions on uniPort - perhaps later ...
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002551 go func(port *cmn.OnuUniPort) {
khenaidoo7d3c5582021-08-11 18:09:44 -04002552 if err := dh.updatePortStateInCore(ctx, &ic.PortState{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002553 DeviceId: dh.DeviceID,
khenaidoo7d3c5582021-08-11 18:09:44 -04002554 PortType: voltha.Port_ETHERNET_UNI,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002555 PortNo: port.PortNo,
2556 OperStatus: port.OperState,
khenaidoo7d3c5582021-08-11 18:09:44 -04002557 }); err != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002558 logger.Errorw(ctx, "port-state-update-failed", log.Fields{"error": err, "port-no": uniPort.PortNo, "device-id": dh.DeviceID})
khenaidoo7d3c5582021-08-11 18:09:44 -04002559 }
2560 }(uniPort)
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00002561 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002562 logger.Debugw(ctx, "reconciling - don't notify core about PortStateUpdate", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtf41a1602020-08-19 09:52:50 +00002563 }
mpagenko3af1f032020-06-10 08:53:41 +00002564 }
2565 }
2566}
2567
2568// Disable UniPortState and update core port state accordingly
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002569func (dh *deviceHandler) DisableUniPortStateUpdate(ctx context.Context) {
2570 // compare EnableUniPortStateUpdate() above
mpagenko3af1f032020-06-10 08:53:41 +00002571 // -> use current restriction to operate only on first UNI port as inherited from actual Py code
2572 for uniNo, uniPort := range dh.uniEntityMap {
2573 // only if this port is validated for operState transfer
Matteo Scandolo20d180c2021-06-10 17:20:21 +02002574
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002575 if (1<<uniPort.UniID)&dh.pOpenOnuAc.config.UniPortMask == (1 << uniPort.UniID) {
2576 logger.Infow(ctx, "OnuUniPort-forced-OperState-UNKNOWN", log.Fields{"for PortNo": uniNo, "device-id": dh.DeviceID})
2577 uniPort.SetOperState(vc.OperStatus_UNKNOWN)
2578 if !dh.IsReconciling() {
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002579 //maybe also use getter functions on uniPort - perhaps later ...
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002580 go func(port *cmn.OnuUniPort) {
khenaidoo7d3c5582021-08-11 18:09:44 -04002581 if err := dh.updatePortStateInCore(ctx, &ic.PortState{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002582 DeviceId: dh.DeviceID,
khenaidoo7d3c5582021-08-11 18:09:44 -04002583 PortType: voltha.Port_ETHERNET_UNI,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002584 PortNo: port.PortNo,
2585 OperStatus: port.OperState,
khenaidoo7d3c5582021-08-11 18:09:44 -04002586 }); err != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002587 logger.Errorw(ctx, "port-state-update-failed", log.Fields{"error": err, "port-no": uniPort.PortNo, "device-id": dh.DeviceID})
khenaidoo7d3c5582021-08-11 18:09:44 -04002588 }
2589 }(uniPort)
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002590 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002591 logger.Debugw(ctx, "reconciling - don't notify core about PortStateUpdate", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtbe523842021-03-10 10:47:18 +00002592 }
2593
Holger Hildebrandtbe674422020-05-05 13:05:30 +00002594 }
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002595 }
2596}
2597
2598// ONU_Active/Inactive announcement on system KAFKA bus
2599// tried to re-use procedure of oltUpDownIndication from openolt_eventmgr.go with used values from Py code
dbainbri4d3a0dc2020-12-02 00:33:42 +00002600func (dh *deviceHandler) sendOnuOperStateEvent(ctx context.Context, aOperState vc.OperStatus_Types, aDeviceID string, raisedTs int64) {
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002601 var de voltha.DeviceEvent
2602 eventContext := make(map[string]string)
2603 //Populating event context
2604 // assume giving ParentId in GetDevice twice really gives the ParentDevice (there is no GetParentDevice()...)
khenaidoo7d3c5582021-08-11 18:09:44 -04002605 parentDevice, err := dh.getDeviceFromCore(ctx, dh.parentID)
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002606 if err != nil || parentDevice == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002607 logger.Errorw(ctx, "Failed to fetch parent device for OnuEvent",
Himani Chawla4d908332020-08-31 12:30:20 +05302608 log.Fields{"parentID": dh.parentID, "err": err})
Holger Hildebrandt7ec14c42021-05-28 14:21:58 +00002609 return //TODO with VOL-3045: rw-core is unresponsive: report error and/or perform self-initiated onu-reset?
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002610 }
2611 oltSerialNumber := parentDevice.SerialNumber
2612
2613 eventContext["pon-id"] = strconv.FormatUint(uint64(dh.pOnuIndication.IntfId), 10)
2614 eventContext["onu-id"] = strconv.FormatUint(uint64(dh.pOnuIndication.OnuId), 10)
2615 eventContext["serial-number"] = dh.device.SerialNumber
ssiddiqui1221d1a2021-02-15 11:12:51 +05302616 eventContext["olt-serial-number"] = oltSerialNumber
2617 eventContext["device-id"] = aDeviceID
2618 eventContext["registration-id"] = aDeviceID //py: string(device_id)??
ozgecanetsiaf0a76b62021-05-31 17:42:09 +03002619 eventContext["num-of-unis"] = strconv.Itoa(len(dh.uniEntityMap))
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002620 if deviceEntry := dh.GetOnuDeviceEntry(ctx, false); deviceEntry != nil {
2621 deviceEntry.MutexPersOnuConfig.RLock()
2622 eventContext["equipment-id"] = deviceEntry.SOnuPersistentData.PersEquipmentID
2623 deviceEntry.MutexPersOnuConfig.RUnlock()
2624 eventContext["software-version"] = deviceEntry.GetActiveImageVersion(ctx)
2625 deviceEntry.MutexPersOnuConfig.RLock()
2626 eventContext["vendor"] = deviceEntry.SOnuPersistentData.PersVendorID
2627 deviceEntry.MutexPersOnuConfig.RUnlock()
2628 eventContext["inactive-software-version"] = deviceEntry.GetInactiveImageVersion(ctx)
ozgecanetsiaf0a76b62021-05-31 17:42:09 +03002629 logger.Debugw(ctx, "prepare ONU_ACTIVATED event",
2630 log.Fields{"device-id": aDeviceID, "EventContext": eventContext})
2631 } else {
2632 logger.Errorw(ctx, "Failed to fetch device-entry. ONU_ACTIVATED event is not sent",
2633 log.Fields{"device-id": aDeviceID})
2634 return
2635 }
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002636
2637 /* Populating device event body */
2638 de.Context = eventContext
Himani Chawla4d908332020-08-31 12:30:20 +05302639 de.ResourceId = aDeviceID
2640 if aOperState == voltha.OperStatus_ACTIVE {
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002641 de.DeviceEventName = fmt.Sprintf("%s_%s", cOnuActivatedEvent, "RAISE_EVENT")
2642 de.Description = fmt.Sprintf("%s Event - %s - %s",
2643 cEventObjectType, cOnuActivatedEvent, "Raised")
2644 } else {
2645 de.DeviceEventName = fmt.Sprintf("%s_%s", cOnuActivatedEvent, "CLEAR_EVENT")
2646 de.Description = fmt.Sprintf("%s Event - %s - %s",
2647 cEventObjectType, cOnuActivatedEvent, "Cleared")
2648 }
2649 /* Send event to KAFKA */
dbainbri4d3a0dc2020-12-02 00:33:42 +00002650 if err := dh.EventProxy.SendDeviceEvent(ctx, &de, equipment, pon, raisedTs); err != nil {
2651 logger.Warnw(ctx, "could not send ONU_ACTIVATED event",
Himani Chawla4d908332020-08-31 12:30:20 +05302652 log.Fields{"device-id": aDeviceID, "error": err})
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002653 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002654 logger.Debugw(ctx, "ctx, ONU_ACTIVATED event sent to KAFKA",
Himani Chawla4d908332020-08-31 12:30:20 +05302655 log.Fields{"device-id": aDeviceID, "with-EventName": de.DeviceEventName})
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002656}
2657
Himani Chawla4d908332020-08-31 12:30:20 +05302658// createUniLockFsm initializes and runs the UniLock FSM to transfer the OMCI related commands for port lock/unlock
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002659func (dh *deviceHandler) createUniLockFsm(ctx context.Context, aAdminState bool, devEvent cmn.OnuDeviceEvent) {
2660 chLSFsm := make(chan cmn.Message, 2048)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002661 var sFsmName string
Himani Chawla4d908332020-08-31 12:30:20 +05302662 if aAdminState {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002663 logger.Debugw(ctx, "createLockStateFSM", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002664 sFsmName = "LockStateFSM"
2665 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002666 logger.Debugw(ctx, "createUnlockStateFSM", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002667 sFsmName = "UnLockStateFSM"
2668 }
mpagenko3af1f032020-06-10 08:53:41 +00002669
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002670 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
mpagenko3af1f032020-06-10 08:53:41 +00002671 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002672 logger.Errorw(ctx, "No valid OnuDevice -aborting", log.Fields{"device-id": dh.DeviceID})
mpagenko3af1f032020-06-10 08:53:41 +00002673 return
2674 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002675 pLSFsm := uniprt.NewLockStateFsm(ctx, aAdminState, devEvent, sFsmName, dh, pDevEntry, chLSFsm)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002676 if pLSFsm != nil {
Himani Chawla4d908332020-08-31 12:30:20 +05302677 if aAdminState {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002678 dh.pLockStateFsm = pLSFsm
2679 } else {
2680 dh.pUnlockStateFsm = pLSFsm
2681 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002682 dh.runUniLockFsm(ctx, aAdminState)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002683 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002684 logger.Errorw(ctx, "LockStateFSM could not be created - abort!!", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002685 }
2686}
2687
2688// runUniLockFsm starts the UniLock FSM to transfer the OMCI related commands for port lock/unlock
dbainbri4d3a0dc2020-12-02 00:33:42 +00002689func (dh *deviceHandler) runUniLockFsm(ctx context.Context, aAdminState bool) {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002690 /* Uni Port lock/unlock procedure -
2691 ***** should run via 'adminDone' state and generate the argument requested event *****
2692 */
2693 var pLSStatemachine *fsm.FSM
Himani Chawla4d908332020-08-31 12:30:20 +05302694 if aAdminState {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002695 pLSStatemachine = dh.pLockStateFsm.PAdaptFsm.PFsm
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002696 //make sure the opposite FSM is not running and if so, terminate it as not relevant anymore
2697 if (dh.pUnlockStateFsm != nil) &&
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002698 (dh.pUnlockStateFsm.PAdaptFsm.PFsm.Current() != uniprt.UniStDisabled) {
2699 _ = dh.pUnlockStateFsm.PAdaptFsm.PFsm.Event(uniprt.UniEvReset)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002700 }
2701 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002702 pLSStatemachine = dh.pUnlockStateFsm.PAdaptFsm.PFsm
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002703 //make sure the opposite FSM is not running and if so, terminate it as not relevant anymore
2704 if (dh.pLockStateFsm != nil) &&
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002705 (dh.pLockStateFsm.PAdaptFsm.PFsm.Current() != uniprt.UniStDisabled) {
2706 _ = dh.pLockStateFsm.PAdaptFsm.PFsm.Event(uniprt.UniEvReset)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002707 }
2708 }
2709 if pLSStatemachine != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002710 if pLSStatemachine.Is(uniprt.UniStDisabled) {
2711 if err := pLSStatemachine.Event(uniprt.UniEvStart); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002712 logger.Warnw(ctx, "LockStateFSM: can't start", log.Fields{"err": err})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002713 // maybe try a FSM reset and then again ... - TODO!!!
2714 } else {
2715 /***** LockStateFSM started */
dbainbri4d3a0dc2020-12-02 00:33:42 +00002716 logger.Debugw(ctx, "LockStateFSM started", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002717 "state": pLSStatemachine.Current(), "device-id": dh.DeviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002718 }
2719 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002720 logger.Warnw(ctx, "wrong state of LockStateFSM - want: disabled", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002721 "have": pLSStatemachine.Current(), "device-id": dh.DeviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002722 // maybe try a FSM reset and then again ... - TODO!!!
2723 }
2724 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002725 logger.Errorw(ctx, "LockStateFSM StateMachine invalid - cannot be executed!!", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00002726 // maybe try a FSM reset and then again ... - TODO!!!
2727 }
2728}
2729
mpagenko80622a52021-02-09 16:53:23 +00002730// createOnuUpgradeFsm initializes and runs the Onu Software upgrade FSM
mpagenko59862f02021-10-11 08:53:18 +00002731// precondition: lockUpgradeFsm is already locked from caller of this function
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002732func (dh *deviceHandler) createOnuUpgradeFsm(ctx context.Context, apDevEntry *mib.OnuDeviceEntry, aDevEvent cmn.OnuDeviceEvent) error {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002733 chUpgradeFsm := make(chan cmn.Message, 2048)
mpagenko80622a52021-02-09 16:53:23 +00002734 var sFsmName = "OnuSwUpgradeFSM"
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002735 logger.Debugw(ctx, "create OnuSwUpgradeFSM", log.Fields{"device-id": dh.DeviceID})
mpagenko15ff4a52021-03-02 10:09:20 +00002736 if apDevEntry.PDevOmciCC == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002737 logger.Errorw(ctx, "no valid OnuDevice or omciCC - abort", log.Fields{"device-id": dh.DeviceID})
mpagenko15ff4a52021-03-02 10:09:20 +00002738 return fmt.Errorf(fmt.Sprintf("no valid omciCC - abort for device-id: %s", dh.device.Id))
mpagenko80622a52021-02-09 16:53:23 +00002739 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002740 dh.pOnuUpradeFsm = swupg.NewOnuUpgradeFsm(ctx, dh, apDevEntry, apDevEntry.GetOnuDB(), aDevEvent,
mpagenko80622a52021-02-09 16:53:23 +00002741 sFsmName, chUpgradeFsm)
2742 if dh.pOnuUpradeFsm != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002743 pUpgradeStatemachine := dh.pOnuUpradeFsm.PAdaptFsm.PFsm
mpagenko80622a52021-02-09 16:53:23 +00002744 if pUpgradeStatemachine != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002745 if pUpgradeStatemachine.Is(swupg.UpgradeStDisabled) {
2746 if err := pUpgradeStatemachine.Event(swupg.UpgradeEvStart); err != nil {
mpagenko80622a52021-02-09 16:53:23 +00002747 logger.Errorw(ctx, "OnuSwUpgradeFSM: can't start", log.Fields{"err": err})
2748 // maybe try a FSM reset and then again ... - TODO!!!
2749 return fmt.Errorf(fmt.Sprintf("OnuSwUpgradeFSM could not be started for device-id: %s", dh.device.Id))
2750 }
mpagenko59862f02021-10-11 08:53:18 +00002751 /***** Upgrade FSM started */
mpagenko45586762021-10-01 08:30:22 +00002752 //reset the last stored upgrade states (which anyway should be don't care as long as the newly created FSM exists)
2753 (*dh.pLastUpgradeImageState).DownloadState = voltha.ImageState_DOWNLOAD_UNKNOWN
mpagenko38662d02021-08-11 09:45:19 +00002754 (*dh.pLastUpgradeImageState).Reason = voltha.ImageState_NO_ERROR
2755 (*dh.pLastUpgradeImageState).ImageState = voltha.ImageState_IMAGE_UNKNOWN
mpagenko80622a52021-02-09 16:53:23 +00002756 logger.Debugw(ctx, "OnuSwUpgradeFSM started", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002757 "state": pUpgradeStatemachine.Current(), "device-id": dh.DeviceID})
mpagenko80622a52021-02-09 16:53:23 +00002758 } else {
2759 logger.Errorw(ctx, "wrong state of OnuSwUpgradeFSM to start - want: disabled", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002760 "have": pUpgradeStatemachine.Current(), "device-id": dh.DeviceID})
mpagenko80622a52021-02-09 16:53:23 +00002761 // maybe try a FSM reset and then again ... - TODO!!!
2762 return fmt.Errorf(fmt.Sprintf("OnuSwUpgradeFSM could not be started for device-id: %s, wrong internal state", dh.device.Id))
2763 }
2764 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002765 logger.Errorw(ctx, "OnuSwUpgradeFSM internal FSM invalid - cannot be executed!!", log.Fields{"device-id": dh.DeviceID})
mpagenko80622a52021-02-09 16:53:23 +00002766 // maybe try a FSM reset and then again ... - TODO!!!
2767 return fmt.Errorf(fmt.Sprintf("OnuSwUpgradeFSM internal FSM could not be created for device-id: %s", dh.device.Id))
2768 }
2769 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002770 logger.Errorw(ctx, "OnuSwUpgradeFSM could not be created - abort", log.Fields{"device-id": dh.DeviceID})
mpagenko80622a52021-02-09 16:53:23 +00002771 return fmt.Errorf(fmt.Sprintf("OnuSwUpgradeFSM could not be created - abort for device-id: %s", dh.device.Id))
2772 }
2773 return nil
2774}
2775
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002776// RemoveOnuUpgradeFsm clears the Onu Software upgrade FSM
2777func (dh *deviceHandler) RemoveOnuUpgradeFsm(ctx context.Context, apImageState *voltha.ImageState) {
mpagenko80622a52021-02-09 16:53:23 +00002778 logger.Debugw(ctx, "remove OnuSwUpgradeFSM StateMachine", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002779 "device-id": dh.DeviceID})
mpagenko80622a52021-02-09 16:53:23 +00002780 dh.lockUpgradeFsm.Lock()
mpagenko59862f02021-10-11 08:53:18 +00002781 dh.pOnuUpradeFsm = nil //resource clearing is left to garbage collector
2782 dh.upgradeCanceled = false //cancelation done
mpagenko38662d02021-08-11 09:45:19 +00002783 dh.pLastUpgradeImageState = apImageState
2784 dh.lockUpgradeFsm.Unlock()
2785 //signal upgradeFsm removed using non-blocking channel send
2786 select {
2787 case dh.upgradeFsmChan <- struct{}{}:
2788 default:
2789 logger.Debugw(ctx, "removed-UpgradeFsm signal not send on upgradeFsmChan (no receiver)", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002790 "device-id": dh.DeviceID})
mpagenko38662d02021-08-11 09:45:19 +00002791 }
mpagenko80622a52021-02-09 16:53:23 +00002792}
2793
mpagenko15ff4a52021-03-02 10:09:20 +00002794// checkOnOnuImageCommit verifies if the ONU is in some upgrade state that allows for image commit and if tries to commit
2795func (dh *deviceHandler) checkOnOnuImageCommit(ctx context.Context) {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002796 pDevEntry := dh.GetOnuDeviceEntry(ctx, false)
mpagenko15ff4a52021-03-02 10:09:20 +00002797 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002798 logger.Errorw(ctx, "No valid OnuDevice -aborting checkOnOnuImageCommit", log.Fields{"device-id": dh.DeviceID})
mpagenko15ff4a52021-03-02 10:09:20 +00002799 return
2800 }
2801
2802 dh.lockUpgradeFsm.RLock()
mpagenko59862f02021-10-11 08:53:18 +00002803 //lockUpgradeFsm must be release before cancellation as this may implicitly request RemoveOnuUpgradeFsm()
mpagenko15ff4a52021-03-02 10:09:20 +00002804 if dh.pOnuUpradeFsm != nil {
mpagenko59862f02021-10-11 08:53:18 +00002805 if dh.upgradeCanceled { //avoid starting some new action in case it is already doing the cancelation
2806 dh.lockUpgradeFsm.RUnlock()
2807 logger.Errorw(ctx, "Some upgrade procedure still runs cancelation - abort", log.Fields{"device-id": dh.DeviceID})
2808 return
2809 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002810 pUpgradeStatemachine := dh.pOnuUpradeFsm.PAdaptFsm.PFsm
mpagenko15ff4a52021-03-02 10:09:20 +00002811 if pUpgradeStatemachine != nil {
2812 // commit is only processed in case out upgrade FSM indicates the according state (for automatic commit)
2813 // (some manual forced commit could do without)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002814 UpgradeState := pUpgradeStatemachine.Current()
2815 if (UpgradeState == swupg.UpgradeStWaitForCommit) ||
2816 (UpgradeState == swupg.UpgradeStRequestingActivate) {
2817 // also include UpgradeStRequestingActivate as it may be left in case the ActivateResponse just got lost
mpagenko183647c2021-06-08 15:25:04 +00002818 // here no need to update the upgrade image state to activated as the state will be immediately be set to committing
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002819 if pDevEntry.IsImageToBeCommitted(ctx, dh.pOnuUpradeFsm.InactiveImageMeID) {
mpagenko1f8e8822021-06-25 14:10:21 +00002820 activeImageID, errImg := pDevEntry.GetActiveImageMeID(ctx)
2821 if errImg != nil {
mpagenko59862f02021-10-11 08:53:18 +00002822 dh.lockUpgradeFsm.RUnlock()
mpagenko1f8e8822021-06-25 14:10:21 +00002823 logger.Errorw(ctx, "OnuSwUpgradeFSM abort - could not get active image after reboot",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002824 log.Fields{"device-id": dh.DeviceID})
mpagenko59862f02021-10-11 08:53:18 +00002825 if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation
2826 dh.upgradeCanceled = true
2827 dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_ONU_STATE) //complete abort
2828 }
mpagenko15ff4a52021-03-02 10:09:20 +00002829 return
2830 }
mpagenko59862f02021-10-11 08:53:18 +00002831 dh.lockUpgradeFsm.RUnlock()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002832 if activeImageID == dh.pOnuUpradeFsm.InactiveImageMeID {
2833 if (UpgradeState == swupg.UpgradeStRequestingActivate) && !dh.pOnuUpradeFsm.GetCommitFlag(ctx) {
mpagenko1f8e8822021-06-25 14:10:21 +00002834 // if FSM was waiting on activateResponse, new image is active, but FSM shall not commit, then:
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002835 if err := pUpgradeStatemachine.Event(swupg.UpgradeEvActivationDone); err != nil {
mpagenko1f8e8822021-06-25 14:10:21 +00002836 logger.Errorw(ctx, "OnuSwUpgradeFSM: can't call activate-done event", log.Fields{"err": err})
2837 return
2838 }
2839 logger.Debugw(ctx, "OnuSwUpgradeFSM activate-done after reboot", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002840 "state": UpgradeState, "device-id": dh.DeviceID})
mpagenko1f8e8822021-06-25 14:10:21 +00002841 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002842 //FSM in waitForCommit or (UpgradeStRequestingActivate [lost ActivateResp] and commit allowed)
2843 if err := pUpgradeStatemachine.Event(swupg.UpgradeEvCommitSw); err != nil {
mpagenko1f8e8822021-06-25 14:10:21 +00002844 logger.Errorw(ctx, "OnuSwUpgradeFSM: can't call commit event", log.Fields{"err": err})
2845 return
2846 }
2847 logger.Debugw(ctx, "OnuSwUpgradeFSM commit image requested", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002848 "state": UpgradeState, "device-id": dh.DeviceID})
mpagenko1f8e8822021-06-25 14:10:21 +00002849 }
2850 } else {
2851 logger.Errorw(ctx, "OnuSwUpgradeFSM waiting to commit/on ActivateResponse, but load did not start with expected image Id",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002852 log.Fields{"device-id": dh.DeviceID})
mpagenko59862f02021-10-11 08:53:18 +00002853 dh.upgradeCanceled = true
mpagenko38662d02021-08-11 09:45:19 +00002854 dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_ONU_STATE) //complete abort
mpagenko1f8e8822021-06-25 14:10:21 +00002855 }
mpagenko15ff4a52021-03-02 10:09:20 +00002856 return
2857 }
mpagenko59862f02021-10-11 08:53:18 +00002858 dh.lockUpgradeFsm.RUnlock()
2859 logger.Errorw(ctx, "OnuSwUpgradeFSM waiting to commit, but nothing to commit on ONU - abort upgrade",
2860 log.Fields{"device-id": dh.DeviceID})
2861 dh.upgradeCanceled = true
2862 dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_ONU_STATE) //complete abort
2863 return
2864 }
2865 //upgrade FSM is active but not waiting for commit: maybe because commit flag is not set
2866 // upgrade FSM is to be informed if the current active image is the one that was used in upgrade for the download
2867 if activeImageID, err := pDevEntry.GetActiveImageMeID(ctx); err == nil {
2868 if dh.pOnuUpradeFsm.InactiveImageMeID == activeImageID {
2869 logger.Debugw(ctx, "OnuSwUpgradeFSM image state set to activated", log.Fields{
2870 "state": pUpgradeStatemachine.Current(), "device-id": dh.DeviceID})
2871 dh.pOnuUpradeFsm.SetImageStateActive(ctx)
mpagenko183647c2021-06-08 15:25:04 +00002872 }
mpagenko15ff4a52021-03-02 10:09:20 +00002873 }
2874 }
2875 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002876 logger.Debugw(ctx, "no ONU image to be committed", log.Fields{"device-id": dh.DeviceID})
mpagenko15ff4a52021-03-02 10:09:20 +00002877 }
mpagenko59862f02021-10-11 08:53:18 +00002878 dh.lockUpgradeFsm.RUnlock()
mpagenko15ff4a52021-03-02 10:09:20 +00002879}
2880
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002881//SetBackend provides a DB backend for the specified path on the existing KV client
2882func (dh *deviceHandler) SetBackend(ctx context.Context, aBasePathKvStore string) *db.Backend {
Matteo Scandolo127c59d2021-01-28 11:31:18 -08002883
2884 logger.Debugw(ctx, "SetKVStoreBackend", log.Fields{"IpTarget": dh.pOpenOnuAc.KVStoreAddress,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002885 "BasePathKvStore": aBasePathKvStore, "device-id": dh.DeviceID})
Girish Gowdra50e56422021-06-01 16:46:04 -07002886 // kvbackend := db.NewBackend(ctx, dh.pOpenOnuAc.KVStoreType, dh.pOpenOnuAc.KVStoreAddress, dh.pOpenOnuAc.KVStoreTimeout, aBasePathKvStore)
mpagenkoaf801632020-07-03 10:00:42 +00002887 kvbackend := &db.Backend{
2888 Client: dh.pOpenOnuAc.kvClient,
2889 StoreType: dh.pOpenOnuAc.KVStoreType,
2890 /* address config update acc. to [VOL-2736] */
Matteo Scandolo127c59d2021-01-28 11:31:18 -08002891 Address: dh.pOpenOnuAc.KVStoreAddress,
mpagenkoaf801632020-07-03 10:00:42 +00002892 Timeout: dh.pOpenOnuAc.KVStoreTimeout,
2893 PathPrefix: aBasePathKvStore}
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00002894
mpagenkoaf801632020-07-03 10:00:42 +00002895 return kvbackend
Holger Hildebrandt24d51952020-05-04 14:03:42 +00002896}
khenaidoo7d3c5582021-08-11 18:09:44 -04002897func (dh *deviceHandler) getFlowOfbFields(ctx context.Context, apFlowItem *of.OfpFlowStats, loMatchVlan *uint16,
Himani Chawla26e555c2020-08-31 12:30:20 +05302898 loAddPcp *uint8, loIPProto *uint32) {
mpagenkodff5dda2020-08-28 11:52:01 +00002899
mpagenkodff5dda2020-08-28 11:52:01 +00002900 for _, field := range flow.GetOfbFields(apFlowItem) {
2901 switch field.Type {
2902 case of.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE:
2903 {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002904 logger.Debugw(ctx, "flow type EthType", log.Fields{"device-id": dh.DeviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00002905 "EthType": strconv.FormatInt(int64(field.GetEthType()), 16)})
2906 }
mpagenko01e726e2020-10-23 09:45:29 +00002907 /* TT related temporary workaround - should not be needed anymore
mpagenkodff5dda2020-08-28 11:52:01 +00002908 case of.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO:
2909 {
Himani Chawla26e555c2020-08-31 12:30:20 +05302910 *loIPProto = field.GetIpProto()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002911 logger.Debugw("flow type IpProto", log.Fields{"device-id": dh.DeviceID,
Himani Chawla26e555c2020-08-31 12:30:20 +05302912 "IpProto": strconv.FormatInt(int64(*loIPProto), 16)})
2913 if *loIPProto == 2 {
mpagenkodff5dda2020-08-28 11:52:01 +00002914 // some workaround for TT workflow at proto == 2 (IGMP trap) -> ignore the flow
2915 // avoids installing invalid EVTOCD rule
mpagenko01e726e2020-10-23 09:45:29 +00002916 logger.Debugw("flow type IpProto 2: TT workaround: ignore flow",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002917 log.Fields{"device-id": dh.DeviceID})
Himani Chawla26e555c2020-08-31 12:30:20 +05302918 return
mpagenkodff5dda2020-08-28 11:52:01 +00002919 }
2920 }
mpagenko01e726e2020-10-23 09:45:29 +00002921 */
mpagenkodff5dda2020-08-28 11:52:01 +00002922 case of.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
2923 {
Himani Chawla26e555c2020-08-31 12:30:20 +05302924 *loMatchVlan = uint16(field.GetVlanVid())
mpagenkodff5dda2020-08-28 11:52:01 +00002925 loMatchVlanMask := uint16(field.GetVlanVidMask())
Himani Chawla26e555c2020-08-31 12:30:20 +05302926 if !(*loMatchVlan == uint16(of.OfpVlanId_OFPVID_PRESENT) &&
mpagenkodff5dda2020-08-28 11:52:01 +00002927 loMatchVlanMask == uint16(of.OfpVlanId_OFPVID_PRESENT)) {
Himani Chawla26e555c2020-08-31 12:30:20 +05302928 *loMatchVlan = *loMatchVlan & 0xFFF // not transparent: copy only ID bits
mpagenkodff5dda2020-08-28 11:52:01 +00002929 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002930 logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID,
Himani Chawla26e555c2020-08-31 12:30:20 +05302931 "VID": strconv.FormatInt(int64(*loMatchVlan), 16)})
mpagenkodff5dda2020-08-28 11:52:01 +00002932 }
2933 case of.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP:
2934 {
Himani Chawla26e555c2020-08-31 12:30:20 +05302935 *loAddPcp = uint8(field.GetVlanPcp())
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002936 logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00002937 "PCP": loAddPcp})
2938 }
2939 case of.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
2940 {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002941 logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00002942 "UDP-DST": strconv.FormatInt(int64(field.GetUdpDst()), 16)})
2943 }
2944 case of.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC:
2945 {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002946 logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00002947 "UDP-SRC": strconv.FormatInt(int64(field.GetUdpSrc()), 16)})
2948 }
2949 case of.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST:
2950 {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002951 logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00002952 "IPv4-DST": field.GetIpv4Dst()})
2953 }
2954 case of.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_SRC:
2955 {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002956 logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00002957 "IPv4-SRC": field.GetIpv4Src()})
2958 }
2959 case of.OxmOfbFieldTypes_OFPXMT_OFB_METADATA:
2960 {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002961 logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00002962 "Metadata": field.GetTableMetadata()})
2963 }
2964 /*
2965 default:
2966 {
2967 //all other entires ignored
2968 }
2969 */
2970 }
2971 } //for all OfbFields
Himani Chawla26e555c2020-08-31 12:30:20 +05302972}
mpagenkodff5dda2020-08-28 11:52:01 +00002973
khenaidoo7d3c5582021-08-11 18:09:44 -04002974func (dh *deviceHandler) getFlowActions(ctx context.Context, apFlowItem *of.OfpFlowStats, loSetPcp *uint8, loSetVlan *uint16) {
mpagenkodff5dda2020-08-28 11:52:01 +00002975 for _, action := range flow.GetActions(apFlowItem) {
2976 switch action.Type {
2977 /* not used:
2978 case of.OfpActionType_OFPAT_OUTPUT:
2979 {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002980 logger.Debugw("flow action type", log.Fields{"device-id": dh.DeviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00002981 "Output": action.GetOutput()})
2982 }
2983 */
2984 case of.OfpActionType_OFPAT_PUSH_VLAN:
2985 {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002986 logger.Debugw(ctx, "flow action type", log.Fields{"device-id": dh.DeviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00002987 "PushEthType": strconv.FormatInt(int64(action.GetPush().Ethertype), 16)})
2988 }
2989 case of.OfpActionType_OFPAT_SET_FIELD:
2990 {
2991 pActionSetField := action.GetSetField()
2992 if pActionSetField.Field.OxmClass != of.OfpOxmClass_OFPXMC_OPENFLOW_BASIC {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002993 logger.Warnw(ctx, "flow action SetField invalid OxmClass (ignored)", log.Fields{"device-id": dh.DeviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00002994 "OxcmClass": pActionSetField.Field.OxmClass})
2995 }
2996 if pActionSetField.Field.GetOfbField().Type == of.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID {
Himani Chawla26e555c2020-08-31 12:30:20 +05302997 *loSetVlan = uint16(pActionSetField.Field.GetOfbField().GetVlanVid())
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00002998 logger.Debugw(ctx, "flow Set VLAN from SetField action", log.Fields{"device-id": dh.DeviceID,
Himani Chawla26e555c2020-08-31 12:30:20 +05302999 "SetVlan": strconv.FormatInt(int64(*loSetVlan), 16)})
mpagenkodff5dda2020-08-28 11:52:01 +00003000 } else if pActionSetField.Field.GetOfbField().Type == of.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP {
Himani Chawla26e555c2020-08-31 12:30:20 +05303001 *loSetPcp = uint8(pActionSetField.Field.GetOfbField().GetVlanPcp())
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003002 logger.Debugw(ctx, "flow Set PCP from SetField action", log.Fields{"device-id": dh.DeviceID,
Himani Chawla26e555c2020-08-31 12:30:20 +05303003 "SetPcp": *loSetPcp})
mpagenkodff5dda2020-08-28 11:52:01 +00003004 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003005 logger.Warnw(ctx, "flow action SetField invalid FieldType", log.Fields{"device-id": dh.DeviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00003006 "Type": pActionSetField.Field.GetOfbField().Type})
3007 }
3008 }
3009 /*
3010 default:
3011 {
3012 //all other entires ignored
3013 }
3014 */
3015 }
3016 } //for all Actions
Himani Chawla26e555c2020-08-31 12:30:20 +05303017}
3018
3019//addFlowItemToUniPort parses the actual flow item to add it to the UniPort
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003020func (dh *deviceHandler) addFlowItemToUniPort(ctx context.Context, apFlowItem *of.OfpFlowStats, apUniPort *cmn.OnuUniPort,
Girish Gowdrae95687a2021-09-08 16:30:58 -07003021 apFlowMetaData *voltha.FlowMetadata, respChan *chan error) {
Himani Chawla26e555c2020-08-31 12:30:20 +05303022 var loSetVlan uint16 = uint16(of.OfpVlanId_OFPVID_NONE) //noValidEntry
3023 var loMatchVlan uint16 = uint16(of.OfpVlanId_OFPVID_PRESENT) //reserved VLANID entry
3024 var loAddPcp, loSetPcp uint8
3025 var loIPProto uint32
3026 /* the TechProfileId is part of the flow Metadata - compare also comment within
3027 * OLT-Adapter:openolt_flowmgr.go
3028 * Metadata 8 bytes:
3029 * Most Significant 2 Bytes = Inner VLAN
3030 * Next 2 Bytes = Tech Profile ID(TPID)
3031 * Least Significant 4 Bytes = Port ID
3032 * Flow Metadata carries Tech-Profile (TP) ID and is mandatory in all
3033 * subscriber related flows.
3034 */
3035
dbainbri4d3a0dc2020-12-02 00:33:42 +00003036 metadata := flow.GetMetadataFromWriteMetadataAction(ctx, apFlowItem)
Himani Chawla26e555c2020-08-31 12:30:20 +05303037 if metadata == 0 {
dbainbri4d3a0dc2020-12-02 00:33:42 +00003038 logger.Debugw(ctx, "flow-add invalid metadata - abort",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003039 log.Fields{"device-id": dh.DeviceID})
Girish Gowdrae95687a2021-09-08 16:30:58 -07003040 *respChan <- fmt.Errorf("flow-add invalid metadata: %s", dh.DeviceID)
Himani Chawla26e555c2020-08-31 12:30:20 +05303041 }
mpagenko551a4d42020-12-08 18:09:20 +00003042 loTpID := uint8(flow.GetTechProfileIDFromWriteMetaData(ctx, metadata))
mpagenko01e726e2020-10-23 09:45:29 +00003043 loCookie := apFlowItem.GetCookie()
3044 loCookieSlice := []uint64{loCookie}
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003045 logger.Debugw(ctx, "flow-add base indications", log.Fields{"device-id": dh.DeviceID,
mpagenko01e726e2020-10-23 09:45:29 +00003046 "TechProf-Id": loTpID, "cookie": loCookie})
Himani Chawla26e555c2020-08-31 12:30:20 +05303047
dbainbri4d3a0dc2020-12-02 00:33:42 +00003048 dh.getFlowOfbFields(ctx, apFlowItem, &loMatchVlan, &loAddPcp, &loIPProto)
mpagenko01e726e2020-10-23 09:45:29 +00003049 /* TT related temporary workaround - should not be needed anymore
Himani Chawla26e555c2020-08-31 12:30:20 +05303050 if loIPProto == 2 {
3051 // some workaround for TT workflow at proto == 2 (IGMP trap) -> ignore the flow
3052 // avoids installing invalid EVTOCD rule
mpagenko01e726e2020-10-23 09:45:29 +00003053 logger.Debugw("flow-add type IpProto 2: TT workaround: ignore flow",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003054 log.Fields{"device-id": dh.DeviceID})
Himani Chawla26e555c2020-08-31 12:30:20 +05303055 return nil
3056 }
mpagenko01e726e2020-10-23 09:45:29 +00003057 */
dbainbri4d3a0dc2020-12-02 00:33:42 +00003058 dh.getFlowActions(ctx, apFlowItem, &loSetPcp, &loSetVlan)
mpagenkodff5dda2020-08-28 11:52:01 +00003059
3060 if loSetVlan == uint16(of.OfpVlanId_OFPVID_NONE) && loMatchVlan != uint16(of.OfpVlanId_OFPVID_PRESENT) {
dbainbri4d3a0dc2020-12-02 00:33:42 +00003061 logger.Errorw(ctx, "flow-add aborted - SetVlanId undefined, but MatchVid set", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003062 "device-id": dh.DeviceID, "UniPort": apUniPort.PortNo,
mpagenkodff5dda2020-08-28 11:52:01 +00003063 "set_vid": strconv.FormatInt(int64(loSetVlan), 16),
3064 "match_vid": strconv.FormatInt(int64(loMatchVlan), 16)})
3065 //TODO!!: Use DeviceId within the error response to rwCore
3066 // likewise also in other error response cases to calling components as requested in [VOL-3458]
Girish Gowdrae95687a2021-09-08 16:30:58 -07003067 *respChan <- fmt.Errorf("flow-add Set/Match VlanId inconsistent: %s", dh.DeviceID)
mpagenkodff5dda2020-08-28 11:52:01 +00003068 }
3069 if loSetVlan == uint16(of.OfpVlanId_OFPVID_NONE) && loMatchVlan == uint16(of.OfpVlanId_OFPVID_PRESENT) {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003070 logger.Debugw(ctx, "flow-add vlan-any/copy", log.Fields{"device-id": dh.DeviceID})
mpagenkodff5dda2020-08-28 11:52:01 +00003071 loSetVlan = loMatchVlan //both 'transparent' (copy any)
3072 } else {
3073 //looks like OMCI value 4097 (copyFromOuter - for Uni double tagged) is not supported here
3074 if loSetVlan != uint16(of.OfpVlanId_OFPVID_PRESENT) {
3075 // not set to transparent
Himani Chawla26e555c2020-08-31 12:30:20 +05303076 loSetVlan &= 0x0FFF //mask VID bits as prerequisite for vlanConfigFsm
mpagenkodff5dda2020-08-28 11:52:01 +00003077 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003078 logger.Debugw(ctx, "flow-add vlan-set", log.Fields{"device-id": dh.DeviceID})
mpagenkodff5dda2020-08-28 11:52:01 +00003079 }
mpagenko9a304ea2020-12-16 15:54:01 +00003080
ozgecanetsia82b91a62021-05-21 18:54:49 +03003081 var meter *voltha.OfpMeterConfig
3082 if apFlowMetaData != nil {
3083 meter = apFlowMetaData.Meters[0]
3084 }
mpagenkobc4170a2021-08-17 16:42:10 +00003085 //mutex protection as the update_flow rpc maybe running concurrently for different flows, perhaps also activities
3086 // must be set including the execution of createVlanFilterFsm() to avoid unintended creation of FSM's
3087 // when different rules are requested concurrently for the same uni
3088 // (also vlan persistency data does not support multiple FSM's on the same UNI correctly!)
3089 dh.lockVlanAdd.Lock() //prevent multiple add activities to start in parallel
3090 dh.lockVlanConfig.RLock() //read protection on UniVlanConfigFsmMap (removeFlowItemFromUniPort)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003091 logger.Debugw(ctx, "flow-add got lock", log.Fields{"device-id": dh.DeviceID, "tpID": loTpID, "uniID": apUniPort.UniID})
3092 if _, exist := dh.UniVlanConfigFsmMap[apUniPort.UniID]; exist {
mpagenkobc4170a2021-08-17 16:42:10 +00003093 //SetUniFlowParams() may block on some rule that is suspended-to-add
3094 // in order to allow for according flow removal lockVlanConfig may only be used with RLock here
Girish Gowdrae95687a2021-09-08 16:30:58 -07003095 // Also the error is returned to caller via response channel
3096 _ = dh.UniVlanConfigFsmMap[apUniPort.UniID].SetUniFlowParams(ctx, loTpID, loCookieSlice,
3097 loMatchVlan, loSetVlan, loSetPcp, false, meter, respChan)
mpagenkobc4170a2021-08-17 16:42:10 +00003098 dh.lockVlanConfig.RUnlock()
3099 dh.lockVlanAdd.Unlock() //re-admit new Add-flow-processing
Girish Gowdrae95687a2021-09-08 16:30:58 -07003100 return
mpagenkodff5dda2020-08-28 11:52:01 +00003101 }
mpagenkobc4170a2021-08-17 16:42:10 +00003102 dh.lockVlanConfig.RUnlock()
3103 dh.lockVlanConfig.Lock() //createVlanFilterFsm should always be a non-blocking operation and requires r+w lock
mpagenko7d14de12021-07-27 08:31:56 +00003104 err := dh.createVlanFilterFsm(ctx, apUniPort, loTpID, loCookieSlice,
Girish Gowdrae95687a2021-09-08 16:30:58 -07003105 loMatchVlan, loSetVlan, loSetPcp, cmn.OmciVlanFilterAddDone, false, meter, respChan)
mpagenko7d14de12021-07-27 08:31:56 +00003106 dh.lockVlanConfig.Unlock()
mpagenkobc4170a2021-08-17 16:42:10 +00003107 dh.lockVlanAdd.Unlock() //re-admit new Add-flow-processing
Girish Gowdrae95687a2021-09-08 16:30:58 -07003108 if err != nil {
3109 *respChan <- err
3110 }
mpagenko01e726e2020-10-23 09:45:29 +00003111}
3112
3113//removeFlowItemFromUniPort parses the actual flow item to remove it from the UniPort
Girish Gowdrae95687a2021-09-08 16:30:58 -07003114func (dh *deviceHandler) removeFlowItemFromUniPort(ctx context.Context, apFlowItem *of.OfpFlowStats, apUniPort *cmn.OnuUniPort, respChan *chan error) {
mpagenko01e726e2020-10-23 09:45:29 +00003115 //optimization and assumption: the flow cookie uniquely identifies the flow and with that the internal rule
3116 //hence only the cookie is used here to find the relevant flow and possibly remove the rule
3117 //no extra check is done on the rule parameters
3118 //accordingly the removal is done only once - for the first found flow with that cookie, even though
3119 // at flow creation is not assured, that the same cookie is not configured for different flows - just assumed
3120 //additionally it is assumed here, that removal can only be done for one cookie per flow in a sequence (different
3121 // from addFlow - where at reconcilement multiple cookies per flow ) can be configured in one sequence)
mpagenkofc4f56e2020-11-04 17:17:49 +00003122 // - some possible 'delete-all' sequence would have to be implemented separately (where the cookies are don't care anyway)
mpagenko01e726e2020-10-23 09:45:29 +00003123 loCookie := apFlowItem.GetCookie()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003124 logger.Debugw(ctx, "flow-remove base indications", log.Fields{"device-id": dh.DeviceID, "cookie": loCookie})
mpagenko01e726e2020-10-23 09:45:29 +00003125
3126 /* TT related temporary workaround - should not be needed anymore
3127 for _, field := range flow.GetOfbFields(apFlowItem) {
3128 if field.Type == of.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO {
3129 loIPProto := field.GetIpProto()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003130 logger.Debugw(ctx, "flow type IpProto", log.Fields{"device-id": dh.DeviceID,
mpagenko01e726e2020-10-23 09:45:29 +00003131 "IpProto": strconv.FormatInt(int64(loIPProto), 16)})
3132 if loIPProto == 2 {
3133 // some workaround for TT workflow on proto == 2 (IGMP trap) -> the flow was not added, no need to remove
mpagenko551a4d42020-12-08 18:09:20 +00003134 logger.Debugw(ctx, "flow-remove type IpProto 2: TT workaround: ignore flow",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003135 log.Fields{"device-id": dh.DeviceID})
mpagenko01e726e2020-10-23 09:45:29 +00003136 return nil
3137 }
3138 }
3139 } //for all OfbFields
3140 */
3141
mpagenko9a304ea2020-12-16 15:54:01 +00003142 //mutex protection as the update_flow rpc maybe running concurrently for different flows, perhaps also activities
mpagenkof1fc3862021-02-16 10:09:52 +00003143 dh.lockVlanConfig.RLock()
3144 defer dh.lockVlanConfig.RUnlock()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003145 logger.Debugw(ctx, "flow-remove got RLock", log.Fields{"device-id": dh.DeviceID, "uniID": apUniPort.UniID})
3146 if _, exist := dh.UniVlanConfigFsmMap[apUniPort.UniID]; exist {
Girish Gowdrae95687a2021-09-08 16:30:58 -07003147 _ = dh.UniVlanConfigFsmMap[apUniPort.UniID].RemoveUniFlowParams(ctx, loCookie, respChan)
3148 return
mpagenko01e726e2020-10-23 09:45:29 +00003149 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00003150 logger.Debugw(ctx, "flow-remove called, but no flow is configured (no VlanConfigFsm, flow already removed) ",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003151 log.Fields{"device-id": dh.DeviceID})
mpagenko01e726e2020-10-23 09:45:29 +00003152 //but as we regard the flow as not existing = removed we respond just ok
mpagenkofc4f56e2020-11-04 17:17:49 +00003153 // and treat the reason accordingly (which in the normal removal procedure is initiated by the FSM)
Girish Gowdrae95687a2021-09-08 16:30:58 -07003154 // Push response on the response channel
3155 if respChan != nil {
3156 // Do it in a non blocking fashion, so that in case the flow handler routine has shutdown for any reason, we do not block here
3157 select {
3158 case *respChan <- nil:
3159 logger.Debugw(ctx, "submitted-response-for-flow", log.Fields{"device-id": dh.DeviceID, "err": nil})
3160 default:
3161 }
3162 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003163 go dh.DeviceProcStatusUpdate(ctx, cmn.OmciVlanFilterRemDone)
mpagenkodff5dda2020-08-28 11:52:01 +00003164}
3165
Himani Chawla26e555c2020-08-31 12:30:20 +05303166// createVlanFilterFsm initializes and runs the VlanFilter FSM to transfer OMCI related VLAN config
mpagenko9a304ea2020-12-16 15:54:01 +00003167// if this function is called from possibly concurrent processes it must be mutex-protected from the caller!
mpagenko7d14de12021-07-27 08:31:56 +00003168// precondition: dh.lockVlanConfig is locked by the caller!
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003169func (dh *deviceHandler) createVlanFilterFsm(ctx context.Context, apUniPort *cmn.OnuUniPort, aTpID uint8, aCookieSlice []uint64,
Girish Gowdrae95687a2021-09-08 16:30:58 -07003170 aMatchVlan uint16, aSetVlan uint16, aSetPcp uint8, aDevEvent cmn.OnuDeviceEvent, lastFlowToReconcile bool, aMeter *voltha.OfpMeterConfig, respChan *chan error) error {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003171 chVlanFilterFsm := make(chan cmn.Message, 2048)
mpagenkodff5dda2020-08-28 11:52:01 +00003172
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003173 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
mpagenkodff5dda2020-08-28 11:52:01 +00003174 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003175 logger.Errorw(ctx, "No valid OnuDevice -aborting", log.Fields{"device-id": dh.DeviceID})
3176 return fmt.Errorf("no valid OnuDevice for device-id %x - aborting", dh.DeviceID)
mpagenkodff5dda2020-08-28 11:52:01 +00003177 }
3178
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003179 pVlanFilterFsm := avcfg.NewUniVlanConfigFsm(ctx, dh, pDevEntry, pDevEntry.PDevOmciCC, apUniPort, dh.pOnuTP,
3180 pDevEntry.GetOnuDB(), aTpID, aDevEvent, "UniVlanConfigFsm", chVlanFilterFsm,
Girish Gowdrae95687a2021-09-08 16:30:58 -07003181 dh.pOpenOnuAc.AcceptIncrementalEvto, aCookieSlice, aMatchVlan, aSetVlan, aSetPcp, lastFlowToReconcile, aMeter, respChan)
mpagenkodff5dda2020-08-28 11:52:01 +00003182 if pVlanFilterFsm != nil {
mpagenko7d14de12021-07-27 08:31:56 +00003183 //dh.lockVlanConfig is locked (by caller) throughout the state transition to 'starting'
3184 // to prevent unintended (ignored) events to be sent there (from parallel processing)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003185 dh.UniVlanConfigFsmMap[apUniPort.UniID] = pVlanFilterFsm
3186 pVlanFilterStatemachine := pVlanFilterFsm.PAdaptFsm.PFsm
mpagenkodff5dda2020-08-28 11:52:01 +00003187 if pVlanFilterStatemachine != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003188 if pVlanFilterStatemachine.Is(avcfg.VlanStDisabled) {
3189 if err := pVlanFilterStatemachine.Event(avcfg.VlanEvStart); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00003190 logger.Warnw(ctx, "UniVlanConfigFsm: can't start", log.Fields{"err": err})
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003191 return fmt.Errorf("can't start UniVlanConfigFsm for device-id %x", dh.DeviceID)
mpagenkodff5dda2020-08-28 11:52:01 +00003192 }
Himani Chawla26e555c2020-08-31 12:30:20 +05303193 /***** UniVlanConfigFsm started */
dbainbri4d3a0dc2020-12-02 00:33:42 +00003194 logger.Debugw(ctx, "UniVlanConfigFsm started", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003195 "state": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID,
3196 "UniPort": apUniPort.PortNo})
mpagenkodff5dda2020-08-28 11:52:01 +00003197 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00003198 logger.Warnw(ctx, "wrong state of UniVlanConfigFsm - want: disabled", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003199 "have": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID})
3200 return fmt.Errorf("uniVlanConfigFsm not in expected disabled state for device-id %x", dh.DeviceID)
mpagenkodff5dda2020-08-28 11:52:01 +00003201 }
3202 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00003203 logger.Errorw(ctx, "UniVlanConfigFsm StateMachine invalid - cannot be executed!!", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003204 "device-id": dh.DeviceID})
3205 return fmt.Errorf("uniVlanConfigFsm invalid for device-id %x", dh.DeviceID)
mpagenkodff5dda2020-08-28 11:52:01 +00003206 }
3207 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00003208 logger.Errorw(ctx, "UniVlanConfigFsm could not be created - abort!!", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003209 "device-id": dh.DeviceID, "UniPort": apUniPort.PortNo})
3210 return fmt.Errorf("uniVlanConfigFsm could not be created for device-id %x", dh.DeviceID)
mpagenkodff5dda2020-08-28 11:52:01 +00003211 }
3212 return nil
3213}
3214
mpagenkofc4f56e2020-11-04 17:17:49 +00003215//VerifyVlanConfigRequest checks on existence of a given uniPort
3216// and starts verification of flow config based on that
mpagenko551a4d42020-12-08 18:09:20 +00003217func (dh *deviceHandler) VerifyVlanConfigRequest(ctx context.Context, aUniID uint8, aTpID uint8) {
mpagenkofc4f56e2020-11-04 17:17:49 +00003218 //ensure that the given uniID is available (configured) in the UniPort class (used for OMCI entities)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003219 var pCurrentUniPort *cmn.OnuUniPort
mpagenkofc4f56e2020-11-04 17:17:49 +00003220 for _, uniPort := range dh.uniEntityMap {
3221 // only if this port is validated for operState transfer
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003222 if uniPort.UniID == uint8(aUniID) {
mpagenkofc4f56e2020-11-04 17:17:49 +00003223 pCurrentUniPort = uniPort
3224 break //found - end search loop
3225 }
3226 }
3227 if pCurrentUniPort == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00003228 logger.Debugw(ctx, "VerifyVlanConfig aborted: requested uniID not found in PortDB",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003229 log.Fields{"device-id": dh.DeviceID, "uni-id": aUniID})
mpagenkofc4f56e2020-11-04 17:17:49 +00003230 return
3231 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003232 dh.VerifyUniVlanConfigRequest(ctx, pCurrentUniPort, aTpID)
mpagenkofc4f56e2020-11-04 17:17:49 +00003233}
3234
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003235//VerifyUniVlanConfigRequest checks on existence of flow configuration and starts it accordingly
3236func (dh *deviceHandler) VerifyUniVlanConfigRequest(ctx context.Context, apUniPort *cmn.OnuUniPort, aTpID uint8) {
mpagenkodff5dda2020-08-28 11:52:01 +00003237 //TODO!! verify and start pending flow configuration
3238 //some pending config request my exist in case the UniVlanConfig FSM was already started - with internal data -
3239 //but execution was set to 'on hold' as first the TechProfile config had to be applied
mpagenkof1fc3862021-02-16 10:09:52 +00003240
3241 dh.lockVlanConfig.RLock()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003242 if pVlanFilterFsm, exist := dh.UniVlanConfigFsmMap[apUniPort.UniID]; exist {
mpagenkof1fc3862021-02-16 10:09:52 +00003243 dh.lockVlanConfig.RUnlock()
mpagenkodff5dda2020-08-28 11:52:01 +00003244 //VlanFilterFsm exists and was already started (assumed to wait for TechProfile execution here)
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003245 pVlanFilterStatemachine := pVlanFilterFsm.PAdaptFsm.PFsm
mpagenkodff5dda2020-08-28 11:52:01 +00003246 if pVlanFilterStatemachine != nil {
mpagenko551a4d42020-12-08 18:09:20 +00003247 //if this was an event of the TP processing that was waited for in the VlanFilterFsm
3248 if pVlanFilterFsm.GetWaitingTpID() == aTpID {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003249 if pVlanFilterStatemachine.Is(avcfg.VlanStWaitingTechProf) {
3250 if err := pVlanFilterStatemachine.Event(avcfg.VlanEvContinueConfig); err != nil {
mpagenko551a4d42020-12-08 18:09:20 +00003251 logger.Warnw(ctx, "UniVlanConfigFsm: can't continue processing", log.Fields{"err": err,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003252 "device-id": dh.DeviceID, "UniPort": apUniPort.PortNo})
mpagenko551a4d42020-12-08 18:09:20 +00003253 } else {
3254 /***** UniVlanConfigFsm continued */
3255 logger.Debugw(ctx, "UniVlanConfigFsm continued", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003256 "state": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID,
3257 "UniPort": apUniPort.PortNo})
mpagenko551a4d42020-12-08 18:09:20 +00003258 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003259 } else if pVlanFilterStatemachine.Is(avcfg.VlanStIncrFlowWaitTP) {
3260 if err := pVlanFilterStatemachine.Event(avcfg.VlanEvIncrFlowConfig); err != nil {
mpagenko551a4d42020-12-08 18:09:20 +00003261 logger.Warnw(ctx, "UniVlanConfigFsm: can't continue processing", log.Fields{"err": err,
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003262 "device-id": dh.DeviceID, "UniPort": apUniPort.PortNo})
mpagenko551a4d42020-12-08 18:09:20 +00003263 } else {
3264 /***** UniVlanConfigFsm continued */
3265 logger.Debugw(ctx, "UniVlanConfigFsm continued with incremental flow", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003266 "state": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID,
3267 "UniPort": apUniPort.PortNo})
mpagenko551a4d42020-12-08 18:09:20 +00003268 }
mpagenkodff5dda2020-08-28 11:52:01 +00003269 } else {
mpagenko551a4d42020-12-08 18:09:20 +00003270 logger.Debugw(ctx, "no state of UniVlanConfigFsm to be continued", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003271 "have": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID,
3272 "UniPort": apUniPort.PortNo})
mpagenkodff5dda2020-08-28 11:52:01 +00003273 }
3274 } else {
mpagenko551a4d42020-12-08 18:09:20 +00003275 logger.Debugw(ctx, "TechProfile Ready event for TpId that was not waited for in the VlanConfigFsm - continue waiting", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003276 "state": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID,
3277 "UniPort": apUniPort.PortNo, "techprofile-id (done)": aTpID})
mpagenkodff5dda2020-08-28 11:52:01 +00003278 }
3279 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +00003280 logger.Debugw(ctx, "UniVlanConfigFsm StateMachine does not exist, no flow processing", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003281 "device-id": dh.DeviceID, "UniPort": apUniPort.PortNo})
mpagenkodff5dda2020-08-28 11:52:01 +00003282 }
mpagenkof1fc3862021-02-16 10:09:52 +00003283 } else {
3284 dh.lockVlanConfig.RUnlock()
3285 }
mpagenkodff5dda2020-08-28 11:52:01 +00003286}
3287
3288//RemoveVlanFilterFsm deletes the stored pointer to the VlanConfigFsm
3289// intention is to provide this method to be called from VlanConfigFsm itself, when resources (and methods!) are cleaned up
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003290func (dh *deviceHandler) RemoveVlanFilterFsm(ctx context.Context, apUniPort *cmn.OnuUniPort) {
dbainbri4d3a0dc2020-12-02 00:33:42 +00003291 logger.Debugw(ctx, "remove UniVlanConfigFsm StateMachine", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003292 "device-id": dh.DeviceID, "uniPort": apUniPort.PortNo})
mpagenkodff5dda2020-08-28 11:52:01 +00003293 //save to do, even if entry dows not exist
mpagenkof1fc3862021-02-16 10:09:52 +00003294 dh.lockVlanConfig.Lock()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003295 delete(dh.UniVlanConfigFsmMap, apUniPort.UniID)
mpagenkof1fc3862021-02-16 10:09:52 +00003296 dh.lockVlanConfig.Unlock()
mpagenkodff5dda2020-08-28 11:52:01 +00003297}
Holger Hildebrandt47555e72020-09-21 11:07:24 +00003298
mpagenkof1fc3862021-02-16 10:09:52 +00003299//startWritingOnuDataToKvStore initiates the KVStore write of ONU persistent data
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003300func (dh *deviceHandler) startWritingOnuDataToKvStore(ctx context.Context, aPDevEntry *mib.OnuDeviceEntry) error {
mpagenkof1fc3862021-02-16 10:09:52 +00003301 dh.mutexKvStoreContext.Lock() //this write routine may (could) be called with the same context,
3302 defer dh.mutexKvStoreContext.Unlock() //this write routine may (could) be called with the same context,
3303 // obviously then parallel processing on the cancel must be avoided
3304 // deadline context to ensure completion of background routines waited for
3305 //20200721: 10s proved to be less in 8*8 ONU test on local vbox machine with debug, might be further adapted
3306 deadline := time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution
3307 dctx, cancel := context.WithDeadline(context.Background(), deadline)
3308
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003309 aPDevEntry.ResetKvProcessingErrorIndication()
mpagenkof1fc3862021-02-16 10:09:52 +00003310 var wg sync.WaitGroup
3311 wg.Add(1) // for the 1 go routine to finish
3312
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003313 go aPDevEntry.UpdateOnuKvStore(log.WithSpanFromContext(dctx, ctx), &wg)
mpagenkof1fc3862021-02-16 10:09:52 +00003314 dh.waitForCompletion(ctx, cancel, &wg, "UpdateKvStore") //wait for background process to finish
3315
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003316 return aPDevEntry.GetKvProcessingErrorIndication()
mpagenkof1fc3862021-02-16 10:09:52 +00003317}
3318
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003319//StorePersUniFlowConfig updates local storage of OnuUniFlowConfig and writes it into kv-store afterwards to have it
Holger Hildebrandt47555e72020-09-21 11:07:24 +00003320//available for potential reconcilement
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003321func (dh *deviceHandler) StorePersUniFlowConfig(ctx context.Context, aUniID uint8,
3322 aUniVlanFlowParams *[]cmn.UniVlanFlowParams, aWriteToKvStore bool) error {
Holger Hildebrandt47555e72020-09-21 11:07:24 +00003323
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003324 if dh.IsReconciling() {
3325 logger.Debugw(ctx, "reconciling - don't store persistent UniFlowConfig", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt47555e72020-09-21 11:07:24 +00003326 return nil
3327 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003328 logger.Debugw(ctx, "Store or clear persistent UniFlowConfig", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandt47555e72020-09-21 11:07:24 +00003329
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003330 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
Holger Hildebrandt47555e72020-09-21 11:07:24 +00003331 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003332 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID})
3333 return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID)
Holger Hildebrandt47555e72020-09-21 11:07:24 +00003334 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003335 pDevEntry.UpdateOnuUniFlowConfig(aUniID, aUniVlanFlowParams)
Holger Hildebrandt47555e72020-09-21 11:07:24 +00003336
mpagenkof1fc3862021-02-16 10:09:52 +00003337 if aWriteToKvStore {
3338 return dh.startWritingOnuDataToKvStore(ctx, pDevEntry)
3339 }
3340 return nil
Holger Hildebrandt47555e72020-09-21 11:07:24 +00003341}
3342
dbainbri4d3a0dc2020-12-02 00:33:42 +00003343func (dh *deviceHandler) waitForCompletion(ctx context.Context, cancel context.CancelFunc, wg *sync.WaitGroup, aCallerIdent string) {
Holger Hildebrandt47555e72020-09-21 11:07:24 +00003344 defer cancel() //ensure termination of context (may be pro forma)
3345 wg.Wait()
dbainbri4d3a0dc2020-12-02 00:33:42 +00003346 logger.Debugw(ctx, "WaitGroup processing completed", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003347 "device-id": dh.DeviceID, "called from": aCallerIdent})
Holger Hildebrandt47555e72020-09-21 11:07:24 +00003348}
3349
dbainbri4d3a0dc2020-12-02 00:33:42 +00003350func (dh *deviceHandler) deviceReasonUpdate(ctx context.Context, deviceReason uint8, notifyCore bool) error {
Holger Hildebrandt80129db2020-11-23 10:49:32 +00003351
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003352 dh.SetDeviceReason(deviceReason)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00003353 if notifyCore {
Holger Hildebrandt80129db2020-11-23 10:49:32 +00003354 //TODO with VOL-3045/VOL-3046: return the error and stop further processing at calling position
khenaidoo7d3c5582021-08-11 18:09:44 -04003355 if err := dh.updateDeviceReasonInCore(ctx, &ic.DeviceReason{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003356 DeviceId: dh.DeviceID,
3357 Reason: cmn.DeviceReasonMap[deviceReason],
khenaidoo7d3c5582021-08-11 18:09:44 -04003358 }); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00003359 logger.Errorf(ctx, "DeviceReasonUpdate error: %s",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003360 log.Fields{"device-id": dh.DeviceID, "error": err}, cmn.DeviceReasonMap[deviceReason])
Holger Hildebrandt80129db2020-11-23 10:49:32 +00003361 return err
3362 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003363 logger.Infof(ctx, "DeviceReasonUpdate success: %s - device-id: %s", cmn.DeviceReasonMap[deviceReason], dh.DeviceID)
Holger Hildebrandt80129db2020-11-23 10:49:32 +00003364 return nil
3365 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003366 logger.Infof(ctx, "Don't notify core about DeviceReasonUpdate: %s - device-id: %s", cmn.DeviceReasonMap[deviceReason], dh.DeviceID)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00003367 return nil
3368}
3369
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003370func (dh *deviceHandler) StorePersistentData(ctx context.Context) error {
3371 pDevEntry := dh.GetOnuDeviceEntry(ctx, true)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00003372 if pDevEntry == nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003373 logger.Warnw(ctx, "No valid OnuDevice", log.Fields{"device-id": dh.DeviceID})
3374 return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID)
Holger Hildebrandt3a644642020-12-02 09:46:18 +00003375 }
mpagenkof1fc3862021-02-16 10:09:52 +00003376 return dh.startWritingOnuDataToKvStore(ctx, pDevEntry)
Holger Hildebrandt80129db2020-11-23 10:49:32 +00003377}
3378
ozgecanetsiab5000ef2020-11-27 14:38:20 +03003379// getUniPortMEEntityID takes uniPortNo as the input and returns the Entity ID corresponding to this UNI-G ME Instance
ozgecanetsia72e1c9f2021-05-26 17:26:29 +03003380// nolint: unused
ozgecanetsiab5000ef2020-11-27 14:38:20 +03003381func (dh *deviceHandler) getUniPortMEEntityID(uniPortNo uint32) (uint16, error) {
3382 dh.lockDevice.RLock()
3383 defer dh.lockDevice.RUnlock()
3384 if uniPort, ok := dh.uniEntityMap[uniPortNo]; ok {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003385 return uniPort.EntityID, nil
ozgecanetsiab5000ef2020-11-27 14:38:20 +03003386 }
3387 return 0, errors.New("error-fetching-uni-port")
3388}
Girish Gowdrae09a6202021-01-12 18:10:59 -08003389
3390// updatePmConfig updates the pm metrics config.
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003391func (dh *deviceHandler) updatePmConfig(ctx context.Context, pmConfigs *voltha.PmConfigs) error {
3392 var errorsList []error
3393 logger.Infow(ctx, "update-pm-config", log.Fields{"device-id": dh.device.Id, "new-pm-configs": pmConfigs, "old-pm-config": dh.pmConfigs})
Girish Gowdrae09a6202021-01-12 18:10:59 -08003394
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003395 errorsList = append(dh.handleGlobalPmConfigUpdates(ctx, pmConfigs), errorsList...)
3396 errorsList = append(dh.handleGroupPmConfigUpdates(ctx, pmConfigs), errorsList...)
3397 errorsList = append(dh.handleStandalonePmConfigUpdates(ctx, pmConfigs), errorsList...)
3398
3399 // Note that if more than one pm config field is updated in a given call, it is possible that partial pm config is handled
3400 // successfully.
3401 // TODO: Although it is possible to revert to old config in case of partial failure, the code becomes quite complex. Needs more investigation
3402 // Is it possible the rw-core reverts to old config on partial failure but adapter retains a partial new config?
3403 if len(errorsList) > 0 {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003404 logger.Errorw(ctx, "one-or-more-pm-config-failed", log.Fields{"device-id": dh.DeviceID, "pmConfig": dh.pmConfigs})
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003405 return fmt.Errorf("errors-handling-one-or-more-pm-config, errors:%v", errorsList)
Girish Gowdrae09a6202021-01-12 18:10:59 -08003406 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003407 logger.Infow(ctx, "pm-config-updated", log.Fields{"device-id": dh.DeviceID, "pmConfig": dh.pmConfigs})
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003408 return nil
Girish Gowdrae09a6202021-01-12 18:10:59 -08003409}
3410
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003411func (dh *deviceHandler) handleGlobalPmConfigUpdates(ctx context.Context, pmConfigs *voltha.PmConfigs) []error {
3412 var err error
3413 var errorsList []error
Girish Gowdra36ccf7d2021-02-25 20:42:51 -08003414 logger.Infow(ctx, "handling-global-pm-config-params - start", log.Fields{"device-id": dh.device.Id})
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003415
3416 if pmConfigs.DefaultFreq != dh.pmConfigs.DefaultFreq {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003417 if err = dh.pOnuMetricsMgr.UpdateDefaultFrequency(ctx, pmConfigs); err != nil {
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003418 errorsList = append(errorsList, err)
3419 }
3420 }
Girish Gowdra36ccf7d2021-02-25 20:42:51 -08003421 logger.Infow(ctx, "handling-global-pm-config-params - done", log.Fields{"device-id": dh.device.Id})
mpagenko15ff4a52021-03-02 10:09:20 +00003422
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003423 return errorsList
3424}
3425
3426func (dh *deviceHandler) handleGroupPmConfigUpdates(ctx context.Context, pmConfigs *voltha.PmConfigs) []error {
3427 var err error
3428 var errorsList []error
Girish Gowdra36ccf7d2021-02-25 20:42:51 -08003429 logger.Debugw(ctx, "handling-group-pm-config-params - start", log.Fields{"device-id": dh.device.Id})
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003430 // Check if group metric related config is updated
3431 for _, v := range pmConfigs.Groups {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003432 dh.pOnuMetricsMgr.OnuMetricsManagerLock.RLock()
3433 m, ok := dh.pOnuMetricsMgr.GroupMetricMap[v.GroupName]
3434 dh.pOnuMetricsMgr.OnuMetricsManagerLock.RUnlock()
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003435
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003436 if ok && m.Frequency != v.GroupFreq {
3437 if err = dh.pOnuMetricsMgr.UpdateGroupFreq(ctx, v.GroupName, pmConfigs); err != nil {
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003438 errorsList = append(errorsList, err)
3439 }
3440 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003441 if ok && m.Enabled != v.Enabled {
3442 if err = dh.pOnuMetricsMgr.UpdateGroupSupport(ctx, v.GroupName, pmConfigs); err != nil {
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003443 errorsList = append(errorsList, err)
3444 }
3445 }
3446 }
Girish Gowdra36ccf7d2021-02-25 20:42:51 -08003447 logger.Debugw(ctx, "handling-group-pm-config-params - done", log.Fields{"device-id": dh.device.Id})
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003448 return errorsList
3449}
3450
3451func (dh *deviceHandler) handleStandalonePmConfigUpdates(ctx context.Context, pmConfigs *voltha.PmConfigs) []error {
3452 var err error
3453 var errorsList []error
Girish Gowdra36ccf7d2021-02-25 20:42:51 -08003454 logger.Debugw(ctx, "handling-individual-pm-config-params - start", log.Fields{"device-id": dh.device.Id})
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003455 // Check if standalone metric related config is updated
3456 for _, v := range pmConfigs.Metrics {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003457 dh.pOnuMetricsMgr.OnuMetricsManagerLock.RLock()
3458 m, ok := dh.pOnuMetricsMgr.StandaloneMetricMap[v.Name]
3459 dh.pOnuMetricsMgr.OnuMetricsManagerLock.RUnlock()
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003460
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003461 if ok && m.Frequency != v.SampleFreq {
3462 if err = dh.pOnuMetricsMgr.UpdateMetricFreq(ctx, v.Name, pmConfigs); err != nil {
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003463 errorsList = append(errorsList, err)
3464 }
3465 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003466 if ok && m.Enabled != v.Enabled {
3467 if err = dh.pOnuMetricsMgr.UpdateMetricSupport(ctx, v.Name, pmConfigs); err != nil {
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003468 errorsList = append(errorsList, err)
3469 }
3470 }
3471 }
Girish Gowdra36ccf7d2021-02-25 20:42:51 -08003472 logger.Debugw(ctx, "handling-individual-pm-config-params - done", log.Fields{"device-id": dh.device.Id})
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003473 return errorsList
3474}
3475
3476// nolint: gocyclo
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003477func (dh *deviceHandler) StartCollector(ctx context.Context) {
Girish Gowdrae09a6202021-01-12 18:10:59 -08003478 logger.Debugf(ctx, "startingCollector")
3479
3480 // Start routine to process OMCI GET Responses
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003481 go dh.pOnuMetricsMgr.ProcessOmciMessages(ctx)
Himani Chawla43f95ff2021-06-03 00:24:12 +05303482 // Create Extended Frame PM ME
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003483 go dh.pOnuMetricsMgr.CreateEthernetFrameExtendedPMME(ctx)
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003484 // Initialize the next metric collection time.
3485 // Normally done when the onu_metrics_manager is initialized the first time, but needed again later when ONU is
3486 // reset like onu rebooted.
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003487 dh.pOnuMetricsMgr.InitializeMetricCollectionTime(ctx)
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003488 dh.setCollectorIsRunning(true)
Girish Gowdrae09a6202021-01-12 18:10:59 -08003489 for {
3490 select {
3491 case <-dh.stopCollector:
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003492 dh.setCollectorIsRunning(false)
Girish Gowdrae09a6202021-01-12 18:10:59 -08003493 logger.Debugw(ctx, "stopping-collector-for-onu", log.Fields{"device-id": dh.device.Id})
Girish Gowdrae0140f02021-02-02 16:55:09 -08003494 // Stop the L2 PM FSM
3495 go func() {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003496 if dh.pOnuMetricsMgr.PAdaptFsm != nil && dh.pOnuMetricsMgr.PAdaptFsm.PFsm != nil {
3497 if err := dh.pOnuMetricsMgr.PAdaptFsm.PFsm.Event(pmmgr.L2PmEventStop); err != nil {
3498 logger.Errorw(ctx, "error calling event", log.Fields{"device-id": dh.DeviceID, "err": err})
Girish Gowdrae0140f02021-02-02 16:55:09 -08003499 }
3500 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003501 logger.Errorw(ctx, "metrics manager fsm not initialized", log.Fields{"device-id": dh.DeviceID})
Girish Gowdrae0140f02021-02-02 16:55:09 -08003502 }
3503 }()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003504 if dh.pOnuMetricsMgr.GetOmciProcessingStatus() {
3505 dh.pOnuMetricsMgr.StopProcessingOmciResponses <- true // Stop the OMCI GET response processing routine
Girish Gowdra7b0ee5c2021-03-19 21:48:15 -07003506 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003507 if dh.pOnuMetricsMgr.GetTickGenerationStatus() {
3508 dh.pOnuMetricsMgr.StopTicks <- true
Girish Gowdra7b0ee5c2021-03-19 21:48:15 -07003509 }
Girish Gowdrae0140f02021-02-02 16:55:09 -08003510
Girish Gowdrae09a6202021-01-12 18:10:59 -08003511 return
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003512 case <-time.After(time.Duration(pmmgr.FrequencyGranularity) * time.Second): // Check every FrequencyGranularity to see if it is time for collecting metrics
3513 if !dh.pmConfigs.FreqOverride { // If FreqOverride is false, then NextGlobalMetricCollectionTime applies
3514 // If the current time is eqaul to or greater than the NextGlobalMetricCollectionTime, collect the group and standalone metrics
3515 if time.Now().Equal(dh.pOnuMetricsMgr.NextGlobalMetricCollectionTime) || time.Now().After(dh.pOnuMetricsMgr.NextGlobalMetricCollectionTime) {
3516 go dh.pOnuMetricsMgr.CollectAllGroupAndStandaloneMetrics(ctx)
Girish Gowdraaf0ad632021-01-27 13:00:01 -08003517 // Update the next metric collection time.
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003518 dh.pOnuMetricsMgr.NextGlobalMetricCollectionTime = time.Now().Add(time.Duration(dh.pmConfigs.DefaultFreq) * time.Second)
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003519 }
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003520 } else {
3521 if dh.pmConfigs.Grouped { // metrics are managed as a group
3522 // parse through the group and standalone metrics to see it is time to collect their metrics
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003523 dh.pOnuMetricsMgr.OnuMetricsManagerLock.RLock() // Rlock as we are reading GroupMetricMap and StandaloneMetricMap
Girish Gowdrae09a6202021-01-12 18:10:59 -08003524
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003525 for n, g := range dh.pOnuMetricsMgr.GroupMetricMap {
3526 // If the group is enabled AND (current time is equal to OR after NextCollectionInterval, collect the group metric)
Girish Gowdrae0140f02021-02-02 16:55:09 -08003527 // Since the L2 PM counters are collected in a separate FSM, we should avoid those counters in the check.
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003528 if g.Enabled && !g.IsL2PMCounter && (time.Now().Equal(g.NextCollectionInterval) || time.Now().After(g.NextCollectionInterval)) {
3529 go dh.pOnuMetricsMgr.CollectGroupMetric(ctx, n)
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003530 }
3531 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003532 for n, m := range dh.pOnuMetricsMgr.StandaloneMetricMap {
3533 // If the standalone is enabled AND (current time is equal to OR after NextCollectionInterval, collect the metric)
3534 if m.Enabled && (time.Now().Equal(m.NextCollectionInterval) || time.Now().After(m.NextCollectionInterval)) {
3535 go dh.pOnuMetricsMgr.CollectStandaloneMetric(ctx, n)
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003536 }
3537 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003538 dh.pOnuMetricsMgr.OnuMetricsManagerLock.RUnlock()
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003539
3540 // parse through the group and update the next metric collection time
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003541 dh.pOnuMetricsMgr.OnuMetricsManagerLock.Lock() // Lock as we are writing the next metric collection time
3542 for _, g := range dh.pOnuMetricsMgr.GroupMetricMap {
3543 // If group enabled, and the NextCollectionInterval is old (before or equal to current time), update the next collection time stamp
Girish Gowdrae0140f02021-02-02 16:55:09 -08003544 // Since the L2 PM counters are collected and managed in a separate FSM, we should avoid those counters in the check.
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003545 if g.Enabled && !g.IsL2PMCounter && (g.NextCollectionInterval.Before(time.Now()) || g.NextCollectionInterval.Equal(time.Now())) {
3546 g.NextCollectionInterval = time.Now().Add(time.Duration(g.Frequency) * time.Second)
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003547 }
3548 }
3549 // parse through the standalone metrics and update the next metric collection time
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003550 for _, m := range dh.pOnuMetricsMgr.StandaloneMetricMap {
3551 // If standalone metrics enabled, and the NextCollectionInterval is old (before or equal to current time), update the next collection time stamp
3552 if m.Enabled && (m.NextCollectionInterval.Before(time.Now()) || m.NextCollectionInterval.Equal(time.Now())) {
3553 m.NextCollectionInterval = time.Now().Add(time.Duration(m.Frequency) * time.Second)
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003554 }
3555 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003556 dh.pOnuMetricsMgr.OnuMetricsManagerLock.Unlock()
Girish Gowdra5a7c4922021-01-22 18:33:41 -08003557 } /* else { // metrics are not managed as a group
3558 // TODO: We currently do not have standalone metrics. When available, add code here to fetch the metric.
3559 } */
3560 }
Girish Gowdrae09a6202021-01-12 18:10:59 -08003561 }
3562 }
3563}
kesavandfdf77632021-01-26 23:40:33 -05003564
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003565func (dh *deviceHandler) GetUniPortStatus(ctx context.Context, uniInfo *extension.GetOnuUniInfoRequest) *extension.SingleGetValueResponse {
kesavandfdf77632021-01-26 23:40:33 -05003566
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003567 portStatus := uniprt.NewUniPortStatus(dh, dh.pOnuOmciDevice.PDevOmciCC)
3568 return portStatus.GetUniPortStatus(ctx, uniInfo.UniIndex)
kesavandfdf77632021-01-26 23:40:33 -05003569}
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003570
Himani Chawla43f95ff2021-06-03 00:24:12 +05303571func (dh *deviceHandler) getOnuOMCICounters(ctx context.Context, onuInfo *extension.GetOmciEthernetFrameExtendedPmRequest) *extension.SingleGetValueResponse {
3572 if dh.pOnuMetricsMgr == nil {
3573 return &extension.SingleGetValueResponse{
3574 Response: &extension.GetValueResponse{
3575 Status: extension.GetValueResponse_ERROR,
3576 ErrReason: extension.GetValueResponse_INTERNAL_ERROR,
3577 },
3578 }
3579 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003580 resp := dh.pOnuMetricsMgr.CollectEthernetFrameExtendedPMCounters(ctx)
Himani Chawla43f95ff2021-06-03 00:24:12 +05303581 return resp
3582}
3583
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003584func (dh *deviceHandler) isFsmInOmciIdleState(ctx context.Context, PFsm *fsm.FSM, wantedState string) bool {
3585 if PFsm == nil {
mpagenkof1fc3862021-02-16 10:09:52 +00003586 return true //FSM not active - so there is no activity on omci
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003587 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003588 return PFsm.Current() == wantedState
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003589}
3590
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003591func (dh *deviceHandler) isFsmInOmciIdleStateDefault(ctx context.Context, omciFsm cmn.UsedOmciConfigFsms, wantedState string) bool {
mpagenkofbf577d2021-10-12 11:44:33 +00003592 var pAdapterFsm *cmn.AdapterFsm
3593 //note/TODO!!: might be that access to all these specific FSM pointers need a semaphore protection as well, cmp lockUpgradeFsm
mpagenkof1fc3862021-02-16 10:09:52 +00003594 switch omciFsm {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003595 case cmn.CUploadFsm:
mpagenkof1fc3862021-02-16 10:09:52 +00003596 {
mpagenkofbf577d2021-10-12 11:44:33 +00003597 if dh.pOnuOmciDevice != nil {
3598 pAdapterFsm = dh.pOnuOmciDevice.PMibUploadFsm
3599 } else {
3600 return true //FSM not active - so there is no activity on omci
3601 }
mpagenkof1fc3862021-02-16 10:09:52 +00003602 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003603 case cmn.CDownloadFsm:
mpagenkof1fc3862021-02-16 10:09:52 +00003604 {
mpagenkofbf577d2021-10-12 11:44:33 +00003605 if dh.pOnuOmciDevice != nil {
3606 pAdapterFsm = dh.pOnuOmciDevice.PMibDownloadFsm
3607 } else {
3608 return true //FSM not active - so there is no activity on omci
3609 }
mpagenkof1fc3862021-02-16 10:09:52 +00003610 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003611 case cmn.CUniLockFsm:
mpagenkof1fc3862021-02-16 10:09:52 +00003612 {
mpagenkofbf577d2021-10-12 11:44:33 +00003613 if dh.pLockStateFsm != nil {
3614 pAdapterFsm = dh.pLockStateFsm.PAdaptFsm
3615 } else {
3616 return true //FSM not active - so there is no activity on omci
3617 }
mpagenkof1fc3862021-02-16 10:09:52 +00003618 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003619 case cmn.CUniUnLockFsm:
mpagenkof1fc3862021-02-16 10:09:52 +00003620 {
mpagenkofbf577d2021-10-12 11:44:33 +00003621 if dh.pUnlockStateFsm != nil {
3622 pAdapterFsm = dh.pUnlockStateFsm.PAdaptFsm
3623 } else {
3624 return true //FSM not active - so there is no activity on omci
3625 }
mpagenkof1fc3862021-02-16 10:09:52 +00003626 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003627 case cmn.CL2PmFsm:
mpagenkof1fc3862021-02-16 10:09:52 +00003628 {
mpagenkofbf577d2021-10-12 11:44:33 +00003629 if dh.pOnuMetricsMgr != nil {
3630 pAdapterFsm = dh.pOnuMetricsMgr.PAdaptFsm
mpagenkof1fc3862021-02-16 10:09:52 +00003631 } else {
3632 return true //FSM not active - so there is no activity on omci
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003633 }
3634 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003635 case cmn.COnuUpgradeFsm:
mpagenko80622a52021-02-09 16:53:23 +00003636 {
3637 dh.lockUpgradeFsm.RLock()
3638 defer dh.lockUpgradeFsm.RUnlock()
mpagenkofbf577d2021-10-12 11:44:33 +00003639 if dh.pOnuUpradeFsm != nil {
3640 pAdapterFsm = dh.pOnuUpradeFsm.PAdaptFsm
3641 } else {
3642 return true //FSM not active - so there is no activity on omci
3643 }
mpagenko80622a52021-02-09 16:53:23 +00003644 }
mpagenkof1fc3862021-02-16 10:09:52 +00003645 default:
3646 {
3647 logger.Errorw(ctx, "invalid stateMachine selected for idle check", log.Fields{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003648 "device-id": dh.DeviceID, "selectedFsm number": omciFsm})
mpagenkof1fc3862021-02-16 10:09:52 +00003649 return false //logical error in FSM check, do not not indicate 'idle' - we can't be sure
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003650 }
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003651 }
mpagenkofbf577d2021-10-12 11:44:33 +00003652 if pAdapterFsm != nil && pAdapterFsm.PFsm != nil {
3653 return dh.isFsmInOmciIdleState(ctx, pAdapterFsm.PFsm, wantedState)
3654 }
3655 return true //FSM not active - so there is no activity on omci
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003656}
3657
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003658func (dh *deviceHandler) isAniConfigFsmInOmciIdleState(ctx context.Context, omciFsm cmn.UsedOmciConfigFsms, idleState string) bool {
3659 for _, v := range dh.pOnuTP.PAniConfigFsm {
3660 if !dh.isFsmInOmciIdleState(ctx, v.PAdaptFsm.PFsm, idleState) {
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003661 return false
3662 }
3663 }
3664 return true
3665}
3666
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003667func (dh *deviceHandler) isUniVlanConfigFsmInOmciIdleState(ctx context.Context, omciFsm cmn.UsedOmciConfigFsms, idleState string) bool {
mpagenkof1fc3862021-02-16 10:09:52 +00003668 dh.lockVlanConfig.RLock()
3669 defer dh.lockVlanConfig.RUnlock()
3670 for _, v := range dh.UniVlanConfigFsmMap {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003671 if !dh.isFsmInOmciIdleState(ctx, v.PAdaptFsm.PFsm, idleState) {
mpagenkof1fc3862021-02-16 10:09:52 +00003672 return false
3673 }
3674 }
3675 return true //FSM not active - so there is no activity on omci
3676}
3677
3678func (dh *deviceHandler) checkUserServiceExists(ctx context.Context) bool {
3679 dh.lockVlanConfig.RLock()
3680 defer dh.lockVlanConfig.RUnlock()
3681 for _, v := range dh.UniVlanConfigFsmMap {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003682 if v.PAdaptFsm.PFsm != nil {
3683 if v.PAdaptFsm.PFsm.Is(avcfg.CVlanFsmConfiguredState) {
mpagenkof1fc3862021-02-16 10:09:52 +00003684 return true //there is at least one VLAN FSM with some active configuration
3685 }
3686 }
3687 }
3688 return false //there is no VLAN FSM with some active configuration
3689}
3690
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003691func (dh *deviceHandler) CheckAuditStartCondition(ctx context.Context, callingFsm cmn.UsedOmciConfigFsms) bool {
mpagenkof1fc3862021-02-16 10:09:52 +00003692 for fsmName, fsmStruct := range fsmOmciIdleStateFuncMap {
3693 if fsmName != callingFsm && !fsmStruct.omciIdleCheckFunc(dh, ctx, fsmName, fsmStruct.omciIdleState) {
3694 return false
3695 }
3696 }
3697 // a further check is done to identify, if at least some data traffic related configuration exists
3698 // so that a user of this ONU could be 'online' (otherwise it makes no sense to check the MDS [with the intention to keep the user service up])
3699 return dh.checkUserServiceExists(ctx)
3700}
3701
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003702func (dh *deviceHandler) PrepareReconcilingWithActiveAdapter(ctx context.Context) {
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003703 logger.Debugw(ctx, "prepare to reconcile the ONU with adapter using persistency data", log.Fields{"device-id": dh.device.Id})
3704 if err := dh.resetFsms(ctx, false); err != nil {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003705 logger.Errorw(ctx, "reset of FSMs failed!", log.Fields{"device-id": dh.DeviceID, "error": err})
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003706 // TODO: fatal error reset ONU, delete deviceHandler!
3707 return
3708 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003709 dh.uniEntityMap = make(map[uint32]*cmn.OnuUniPort)
3710 dh.StartReconciling(ctx, false)
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003711}
3712
3713func (dh *deviceHandler) setCollectorIsRunning(flagValue bool) {
3714 dh.mutexCollectorFlag.Lock()
3715 dh.collectorIsRunning = flagValue
3716 dh.mutexCollectorFlag.Unlock()
3717}
3718
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003719func (dh *deviceHandler) GetCollectorIsRunning() bool {
Holger Hildebrandt10d98192021-01-27 15:29:31 +00003720 dh.mutexCollectorFlag.RLock()
3721 flagValue := dh.collectorIsRunning
3722 dh.mutexCollectorFlag.RUnlock()
3723 return flagValue
3724}
Himani Chawlaac1f5ad2021-02-04 21:21:54 +05303725
Himani Chawla4c1d4c72021-02-18 12:14:31 +05303726func (dh *deviceHandler) setAlarmManagerIsRunning(flagValue bool) {
3727 dh.mutextAlarmManagerFlag.Lock()
3728 dh.alarmManagerIsRunning = flagValue
3729 dh.mutextAlarmManagerFlag.Unlock()
3730}
3731
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003732func (dh *deviceHandler) GetAlarmManagerIsRunning(ctx context.Context) bool {
Himani Chawla4c1d4c72021-02-18 12:14:31 +05303733 dh.mutextAlarmManagerFlag.RLock()
3734 flagValue := dh.alarmManagerIsRunning
Himani Chawla1472c682021-03-17 17:11:14 +05303735 logger.Debugw(ctx, "alarm-manager-is-running", log.Fields{"flag": dh.alarmManagerIsRunning})
Himani Chawla4c1d4c72021-02-18 12:14:31 +05303736 dh.mutextAlarmManagerFlag.RUnlock()
3737 return flagValue
3738}
3739
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003740func (dh *deviceHandler) StartAlarmManager(ctx context.Context) {
Himani Chawlaac1f5ad2021-02-04 21:21:54 +05303741 logger.Debugf(ctx, "startingAlarmManager")
3742
3743 // Start routine to process OMCI GET Responses
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003744 go dh.pAlarmMgr.StartOMCIAlarmMessageProcessing(ctx)
Himani Chawla4c1d4c72021-02-18 12:14:31 +05303745 dh.setAlarmManagerIsRunning(true)
Himani Chawlaac1f5ad2021-02-04 21:21:54 +05303746 if stop := <-dh.stopAlarmManager; stop {
3747 logger.Debugw(ctx, "stopping-collector-for-onu", log.Fields{"device-id": dh.device.Id})
Himani Chawla4c1d4c72021-02-18 12:14:31 +05303748 dh.setAlarmManagerIsRunning(false)
Himani Chawlad3dac422021-03-13 02:31:31 +05303749 go func() {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003750 if dh.pAlarmMgr.AlarmSyncFsm != nil && dh.pAlarmMgr.AlarmSyncFsm.PFsm != nil {
3751 _ = dh.pAlarmMgr.AlarmSyncFsm.PFsm.Event(almgr.AsEvStop)
Himani Chawla1472c682021-03-17 17:11:14 +05303752 }
Himani Chawlad3dac422021-03-13 02:31:31 +05303753 }()
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003754 dh.pAlarmMgr.StopProcessingOmciMessages <- true // Stop the OMCI routines if any(This will stop the fsms also)
3755 dh.pAlarmMgr.StopAlarmAuditTimer <- struct{}{}
Himani Chawla1472c682021-03-17 17:11:14 +05303756 logger.Debugw(ctx, "sent-all-stop-signals-to-alarm-manager", log.Fields{"device-id": dh.device.Id})
Himani Chawlaac1f5ad2021-02-04 21:21:54 +05303757 }
3758}
Holger Hildebrandt38985dc2021-02-18 16:25:20 +00003759
Girish Gowdrae95687a2021-09-08 16:30:58 -07003760func (dh *deviceHandler) setFlowMonitoringIsRunning(uniID uint8, flag bool) {
3761 dh.mutexFlowMonitoringRoutineFlag.Lock()
3762 defer dh.mutexFlowMonitoringRoutineFlag.Unlock()
3763 logger.Debugw(context.Background(), "set-flow-monitoring-routine", log.Fields{"flag": flag})
3764 dh.isFlowMonitoringRoutineActive[uniID] = flag
3765}
3766
3767func (dh *deviceHandler) GetFlowMonitoringIsRunning(uniID uint8) bool {
3768 dh.mutexFlowMonitoringRoutineFlag.RLock()
3769 defer dh.mutexFlowMonitoringRoutineFlag.RUnlock()
3770 logger.Debugw(context.Background(), "get-flow-monitoring-routine",
3771 log.Fields{"isFlowMonitoringRoutineActive": dh.isFlowMonitoringRoutineActive})
3772 return dh.isFlowMonitoringRoutineActive[uniID]
3773}
3774
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003775func (dh *deviceHandler) StartReconciling(ctx context.Context, skipOnuConfig bool) {
3776 logger.Debugw(ctx, "start reconciling", log.Fields{"skipOnuConfig": skipOnuConfig, "device-id": dh.DeviceID})
Holger Hildebrandtbe523842021-03-10 10:47:18 +00003777
Maninder7961d722021-06-16 22:10:28 +05303778 connectStatus := voltha.ConnectStatus_UNREACHABLE
3779 operState := voltha.OperStatus_UNKNOWN
3780
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003781 if !dh.IsReconciling() {
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +00003782 go func() {
Holger Hildebrandtbe523842021-03-10 10:47:18 +00003783 logger.Debugw(ctx, "wait for channel signal or timeout",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003784 log.Fields{"timeout": dh.pOpenOnuAc.maxTimeoutReconciling, "device-id": dh.DeviceID})
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +00003785 select {
Holger Hildebrandtb4563ab2021-04-14 10:27:20 +00003786 case success := <-dh.chReconcilingFinished:
3787 if success {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003788 if onuDevEntry := dh.GetOnuDeviceEntry(ctx, true); onuDevEntry == nil {
Maninderb5187552021-03-23 22:23:42 +05303789 logger.Errorw(ctx, "No valid OnuDevice - aborting Core DeviceStateUpdate",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003790 log.Fields{"device-id": dh.DeviceID})
Maninderb5187552021-03-23 22:23:42 +05303791 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003792 if onuDevEntry.SOnuPersistentData.PersOperState == "up" {
Maninderb5187552021-03-23 22:23:42 +05303793 connectStatus = voltha.ConnectStatus_REACHABLE
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003794 if !onuDevEntry.SOnuPersistentData.PersUniDisableDone {
3795 if onuDevEntry.SOnuPersistentData.PersUniUnlockDone {
Maninderb5187552021-03-23 22:23:42 +05303796 operState = voltha.OperStatus_ACTIVE
3797 } else {
3798 operState = voltha.OperStatus_ACTIVATING
3799 }
3800 }
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003801 } else if onuDevEntry.SOnuPersistentData.PersOperState == "down" ||
3802 onuDevEntry.SOnuPersistentData.PersOperState == "unknown" ||
3803 onuDevEntry.SOnuPersistentData.PersOperState == "" {
Maninderb5187552021-03-23 22:23:42 +05303804 operState = voltha.OperStatus_DISCOVERED
3805 }
3806
3807 logger.Debugw(ctx, "Core DeviceStateUpdate", log.Fields{"connectStatus": connectStatus, "operState": operState})
Maninderb5187552021-03-23 22:23:42 +05303808 }
Holger Hildebrandtb4563ab2021-04-14 10:27:20 +00003809 logger.Debugw(ctx, "reconciling has been finished in time",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003810 log.Fields{"device-id": dh.DeviceID})
khenaidoo7d3c5582021-08-11 18:09:44 -04003811 if err := dh.updateDeviceStateInCore(ctx, &ic.DeviceStateFilter{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003812 DeviceId: dh.DeviceID,
khenaidoo7d3c5582021-08-11 18:09:44 -04003813 ConnStatus: connectStatus,
3814 OperStatus: operState,
3815 }); err != nil {
Maninder7961d722021-06-16 22:10:28 +05303816 logger.Errorw(ctx, "unable to update device state to core",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003817 log.Fields{"device-id": dh.DeviceID, "Err": err})
Maninder7961d722021-06-16 22:10:28 +05303818 }
Holger Hildebrandtb4563ab2021-04-14 10:27:20 +00003819 } else {
Maninderb5187552021-03-23 22:23:42 +05303820 logger.Errorw(ctx, "wait for reconciling aborted",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003821 log.Fields{"device-id": dh.DeviceID})
Maninder7961d722021-06-16 22:10:28 +05303822
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003823 if onuDevEntry := dh.GetOnuDeviceEntry(ctx, true); onuDevEntry == nil {
Maninder7961d722021-06-16 22:10:28 +05303824 logger.Errorw(ctx, "No valid OnuDevice",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003825 log.Fields{"device-id": dh.DeviceID})
3826 } else if onuDevEntry.SOnuPersistentData.PersOperState == "up" {
Maninder7961d722021-06-16 22:10:28 +05303827 connectStatus = voltha.ConnectStatus_REACHABLE
3828 }
3829
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003830 dh.deviceReconcileFailedUpdate(ctx, cmn.DrReconcileCanceled, connectStatus)
Holger Hildebrandtb4563ab2021-04-14 10:27:20 +00003831 }
Holger Hildebrandt38985dc2021-02-18 16:25:20 +00003832 case <-time.After(dh.pOpenOnuAc.maxTimeoutReconciling):
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +00003833 logger.Errorw(ctx, "timeout waiting for reconciling to be finished!",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003834 log.Fields{"device-id": dh.DeviceID})
Maninder7961d722021-06-16 22:10:28 +05303835
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003836 if onuDevEntry := dh.GetOnuDeviceEntry(ctx, true); onuDevEntry == nil {
Maninder7961d722021-06-16 22:10:28 +05303837 logger.Errorw(ctx, "No valid OnuDevice",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003838 log.Fields{"device-id": dh.DeviceID})
3839 } else if onuDevEntry.SOnuPersistentData.PersOperState == "up" {
Maninder7961d722021-06-16 22:10:28 +05303840 connectStatus = voltha.ConnectStatus_REACHABLE
3841 }
3842
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003843 dh.deviceReconcileFailedUpdate(ctx, cmn.DrReconcileMaxTimeout, connectStatus)
Maninder7961d722021-06-16 22:10:28 +05303844
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +00003845 }
3846 dh.mutexReconcilingFlag.Lock()
Holger Hildebrandtbe523842021-03-10 10:47:18 +00003847 dh.reconciling = cNoReconciling
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +00003848 dh.mutexReconcilingFlag.Unlock()
3849 }()
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +00003850 }
Holger Hildebrandtbe523842021-03-10 10:47:18 +00003851 dh.mutexReconcilingFlag.Lock()
3852 if skipOnuConfig {
3853 dh.reconciling = cSkipOnuConfigReconciling
3854 } else {
3855 dh.reconciling = cOnuConfigReconciling
3856 }
3857 dh.mutexReconcilingFlag.Unlock()
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +00003858}
3859
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003860func (dh *deviceHandler) StopReconciling(ctx context.Context, success bool) {
3861 logger.Debugw(ctx, "stop reconciling", log.Fields{"device-id": dh.DeviceID, "success": success})
3862 if dh.IsReconciling() {
Girish Gowdra50e56422021-06-01 16:46:04 -07003863 dh.chReconcilingFinished <- success
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +00003864 } else {
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003865 logger.Infow(ctx, "reconciling is not running", log.Fields{"device-id": dh.DeviceID})
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +00003866 }
3867}
3868
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003869func (dh *deviceHandler) IsReconciling() bool {
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +00003870 dh.mutexReconcilingFlag.RLock()
Holger Hildebrandtbe523842021-03-10 10:47:18 +00003871 defer dh.mutexReconcilingFlag.RUnlock()
3872 return dh.reconciling != cNoReconciling
3873}
3874
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003875func (dh *deviceHandler) IsSkipOnuConfigReconciling() bool {
Holger Hildebrandtbe523842021-03-10 10:47:18 +00003876 dh.mutexReconcilingFlag.RLock()
3877 defer dh.mutexReconcilingFlag.RUnlock()
3878 return dh.reconciling == cSkipOnuConfigReconciling
3879}
3880
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003881func (dh *deviceHandler) SetDeviceReason(value uint8) {
Holger Hildebrandtbe523842021-03-10 10:47:18 +00003882 dh.mutexDeviceReason.Lock()
3883 dh.deviceReason = value
3884 dh.mutexDeviceReason.Unlock()
3885}
3886
3887func (dh *deviceHandler) getDeviceReason() uint8 {
3888 dh.mutexDeviceReason.RLock()
3889 value := dh.deviceReason
3890 dh.mutexDeviceReason.RUnlock()
Holger Hildebrandtf37b3d72021-02-17 10:25:22 +00003891 return value
3892}
Holger Hildebrandtbe523842021-03-10 10:47:18 +00003893
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003894func (dh *deviceHandler) GetDeviceReasonString() string {
3895 return cmn.DeviceReasonMap[dh.getDeviceReason()]
Holger Hildebrandtbe523842021-03-10 10:47:18 +00003896}
Holger Hildebrandtb4563ab2021-04-14 10:27:20 +00003897
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003898func (dh *deviceHandler) SetReadyForOmciConfig(flagValue bool) {
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +00003899 dh.mutexReadyForOmciConfig.Lock()
3900 dh.readyForOmciConfig = flagValue
3901 dh.mutexReadyForOmciConfig.Unlock()
3902}
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003903func (dh *deviceHandler) IsReadyForOmciConfig() bool {
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +00003904 dh.mutexReadyForOmciConfig.RLock()
3905 flagValue := dh.readyForOmciConfig
3906 dh.mutexReadyForOmciConfig.RUnlock()
3907 return flagValue
3908}
Maninder7961d722021-06-16 22:10:28 +05303909
3910func (dh *deviceHandler) deviceReconcileFailedUpdate(ctx context.Context, deviceReason uint8, connectStatus voltha.ConnectStatus_Types) {
3911 if err := dh.deviceReasonUpdate(ctx, deviceReason, true); err != nil {
3912 logger.Errorw(ctx, "unable to update device reason to core",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003913 log.Fields{"device-id": dh.DeviceID, "Err": err})
Maninder7961d722021-06-16 22:10:28 +05303914 }
3915
3916 logger.Debugw(ctx, "Core DeviceStateUpdate", log.Fields{"connectStatus": connectStatus, "operState": voltha.OperStatus_RECONCILING_FAILED})
khenaidoo7d3c5582021-08-11 18:09:44 -04003917 if err := dh.updateDeviceStateInCore(ctx, &ic.DeviceStateFilter{
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003918 DeviceId: dh.DeviceID,
khenaidoo7d3c5582021-08-11 18:09:44 -04003919 ConnStatus: connectStatus,
3920 OperStatus: voltha.OperStatus_RECONCILING_FAILED,
3921 }); err != nil {
Maninder7961d722021-06-16 22:10:28 +05303922 logger.Errorw(ctx, "unable to update device state to core",
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003923 log.Fields{"device-id": dh.DeviceID, "Err": err})
Maninder7961d722021-06-16 22:10:28 +05303924 }
3925}
khenaidoo7d3c5582021-08-11 18:09:44 -04003926
3927/*
3928Helper functions to communicate with Core
3929*/
3930
3931func (dh *deviceHandler) getDeviceFromCore(ctx context.Context, deviceID string) (*voltha.Device, error) {
3932 cClient, err := dh.coreClient.GetCoreServiceClient()
3933 if err != nil || cClient == nil {
3934 return nil, err
3935 }
3936 subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout)
3937 defer cancel()
3938 logger.Debugw(subCtx, "get-device-from-core", log.Fields{"device-id": deviceID})
3939 return cClient.GetDevice(subCtx, &vc.ID{Id: deviceID})
3940}
3941
3942func (dh *deviceHandler) updateDeviceStateInCore(ctx context.Context, deviceStateFilter *ic.DeviceStateFilter) error {
3943 cClient, err := dh.coreClient.GetCoreServiceClient()
3944 if err != nil || cClient == nil {
3945 return err
3946 }
3947 subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout)
3948 defer cancel()
3949 _, err = cClient.DeviceStateUpdate(subCtx, deviceStateFilter)
3950 logger.Debugw(subCtx, "device-updated-in-core", log.Fields{"device-state": deviceStateFilter, "error": err})
3951 return err
3952}
3953
3954func (dh *deviceHandler) updatePMConfigInCore(ctx context.Context, pmConfigs *voltha.PmConfigs) error {
3955 cClient, err := dh.coreClient.GetCoreServiceClient()
3956 if err != nil || cClient == nil {
3957 return err
3958 }
3959 subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout)
3960 defer cancel()
3961 _, err = cClient.DevicePMConfigUpdate(subCtx, pmConfigs)
3962 logger.Debugw(subCtx, "pmconfig-updated-in-core", log.Fields{"pm-configs": pmConfigs, "error": err})
3963 return err
3964}
3965
3966func (dh *deviceHandler) updateDeviceInCore(ctx context.Context, device *voltha.Device) error {
3967 cClient, err := dh.coreClient.GetCoreServiceClient()
3968 if err != nil || cClient == nil {
3969 return err
3970 }
3971 subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout)
3972 defer cancel()
3973 _, err = cClient.DeviceUpdate(subCtx, device)
3974 logger.Debugw(subCtx, "device-updated-in-core", log.Fields{"device-id": device.Id, "error": err})
3975 return err
3976}
3977
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00003978func (dh *deviceHandler) CreatePortInCore(ctx context.Context, port *voltha.Port) error {
khenaidoo7d3c5582021-08-11 18:09:44 -04003979 cClient, err := dh.coreClient.GetCoreServiceClient()
3980 if err != nil || cClient == nil {
3981 return err
3982 }
3983 subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout)
3984 defer cancel()
3985 _, err = cClient.PortCreated(subCtx, port)
3986 logger.Debugw(subCtx, "port-created-in-core", log.Fields{"port": port, "error": err})
3987 return err
3988}
3989
3990func (dh *deviceHandler) updatePortStateInCore(ctx context.Context, portState *ic.PortState) error {
3991 cClient, err := dh.coreClient.GetCoreServiceClient()
3992 if err != nil || cClient == nil {
3993 return err
3994 }
3995 subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout)
3996 defer cancel()
3997 _, err = cClient.PortStateUpdate(subCtx, portState)
3998 logger.Debugw(subCtx, "port-state-updated-in-core", log.Fields{"port-state": portState, "error": err})
3999 return err
4000}
4001
4002func (dh *deviceHandler) updateDeviceReasonInCore(ctx context.Context, reason *ic.DeviceReason) error {
4003 cClient, err := dh.coreClient.GetCoreServiceClient()
4004 if err != nil || cClient == nil {
4005 return err
4006 }
4007 subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout)
4008 defer cancel()
4009 _, err = cClient.DeviceReasonUpdate(subCtx, reason)
4010 logger.Debugw(subCtx, "device-reason-updated-in-core", log.Fields{"reason": reason, "error": err})
4011 return err
4012}
4013
4014/*
4015Helper functions to communicate with parent adapter
4016*/
4017
4018func (dh *deviceHandler) getTechProfileInstanceFromParentAdapter(ctx context.Context, parentEndpoint string,
4019 request *ic.TechProfileInstanceRequestMessage) (*ic.TechProfileDownloadMessage, error) {
4020 pgClient, err := dh.pOpenOnuAc.getParentAdapterServiceClient(parentEndpoint)
4021 if err != nil || pgClient == nil {
4022 return nil, err
4023 }
4024 subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.MaxTimeoutInterAdapterComm)
4025 defer cancel()
4026 logger.Debugw(subCtx, "get-tech-profile-instance", log.Fields{"request": request, "parent-endpoint": parentEndpoint})
4027 return pgClient.GetTechProfileInstance(subCtx, request)
4028}
4029
Girish Gowdrae95687a2021-09-08 16:30:58 -07004030// This routine is unique per ONU ID and blocks on flowControlBlock channel for incoming flows
4031// Each incoming flow is processed in a synchronous manner, i.e., the flow is processed to completion before picking another
4032func (dh *deviceHandler) PerOnuFlowHandlerRoutine(uniID uint8) {
4033 logger.Infow(context.Background(), "starting-flow-handler-routine", log.Fields{"device-id": dh.DeviceID})
4034 dh.setFlowMonitoringIsRunning(uniID, true)
4035 for {
4036 select {
4037 // block on the channel to receive an incoming flow
4038 // process the flow completely before proceeding to handle the next flow
4039 case flowCb := <-dh.flowCbChan[uniID]:
4040 startTime := time.Now()
4041 logger.Debugw(flowCb.ctx, "serial-flow-processor--start", log.Fields{"device-id": dh.DeviceID})
4042 respChan := make(chan error)
4043 if flowCb.addFlow {
4044 go dh.addFlowItemToUniPort(flowCb.ctx, flowCb.flowItem, flowCb.uniPort, flowCb.flowMetaData, &respChan)
4045 } else {
4046 go dh.removeFlowItemFromUniPort(flowCb.ctx, flowCb.flowItem, flowCb.uniPort, &respChan)
4047 }
4048 // Block on response and tunnel it back to the caller
4049 *flowCb.respChan <- <-respChan
4050 logger.Debugw(flowCb.ctx, "serial-flow-processor--end",
4051 log.Fields{"device-id": dh.DeviceID, "absoluteTimeForFlowProcessingInSecs": time.Since(startTime).Seconds()})
4052 case <-dh.stopFlowMonitoringRoutine[uniID]:
4053 logger.Infow(context.Background(), "stopping-flow-handler-routine", log.Fields{"device-id": dh.DeviceID})
4054 dh.setFlowMonitoringIsRunning(uniID, false)
4055 return
4056 }
4057 }
4058}
4059
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00004060func (dh *deviceHandler) SendOMCIRequest(ctx context.Context, parentEndpoint string, request *ic.OmciMessage) error {
khenaidoo7d3c5582021-08-11 18:09:44 -04004061 pgClient, err := dh.pOpenOnuAc.getParentAdapterServiceClient(parentEndpoint)
4062 if err != nil || pgClient == nil {
4063 return err
4064 }
4065 subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.MaxTimeoutInterAdapterComm)
4066 defer cancel()
4067 logger.Debugw(subCtx, "send-omci-request", log.Fields{"request": request, "parent-endpoint": parentEndpoint})
4068 _, err = pgClient.ProxyOmciRequest(subCtx, request)
4069 if err != nil {
4070 logger.Errorw(ctx, "omci-failure", log.Fields{"request": request, "error": err, "request-parent": request.ParentDeviceId, "request-child": request.ChildDeviceId, "request-proxy": request.ProxyAddress})
4071 }
4072 return err
4073}
Holger Hildebrandt4b5e73f2021-08-19 06:51:21 +00004074
4075// GetDeviceID - TODO: add comment
4076func (dh *deviceHandler) GetDeviceID() string {
4077 return dh.DeviceID
4078}
4079
4080// GetProxyAddressID - TODO: add comment
4081func (dh *deviceHandler) GetProxyAddressID() string {
4082 return dh.device.ProxyAddress.GetDeviceId()
4083}
4084
4085// GetProxyAddressType - TODO: add comment
4086func (dh *deviceHandler) GetProxyAddressType() string {
4087 return dh.device.ProxyAddress.GetDeviceType()
4088}
4089
4090// GetProxyAddress - TODO: add comment
4091func (dh *deviceHandler) GetProxyAddress() *voltha.Device_ProxyAddress {
4092 return dh.device.ProxyAddress
4093}
4094
4095// GetEventProxy - TODO: add comment
4096func (dh *deviceHandler) GetEventProxy() eventif.EventProxy {
4097 return dh.EventProxy
4098}
4099
4100// GetOmciTimeout - TODO: add comment
4101func (dh *deviceHandler) GetOmciTimeout() int {
4102 return dh.pOpenOnuAc.omciTimeout
4103}
4104
4105// GetAlarmAuditInterval - TODO: add comment
4106func (dh *deviceHandler) GetAlarmAuditInterval() time.Duration {
4107 return dh.pOpenOnuAc.alarmAuditInterval
4108}
4109
4110// GetDlToOnuTimeout4M - TODO: add comment
4111func (dh *deviceHandler) GetDlToOnuTimeout4M() time.Duration {
4112 return dh.pOpenOnuAc.dlToOnuTimeout4M
4113}
4114
4115// GetUniEntityMap - TODO: add comment
4116func (dh *deviceHandler) GetUniEntityMap() *cmn.OnuUniPortMap {
4117 return &dh.uniEntityMap
4118}
4119
4120// GetPonPortNumber - TODO: add comment
4121func (dh *deviceHandler) GetPonPortNumber() *uint32 {
4122 return &dh.ponPortNumber
4123}
4124
4125// GetUniVlanConfigFsm - TODO: add comment
4126func (dh *deviceHandler) GetUniVlanConfigFsm(uniID uint8) cmn.IuniVlanConfigFsm {
4127 return dh.UniVlanConfigFsmMap[uniID]
4128}
4129
4130// GetOnuAlarmManager - TODO: add comment
4131func (dh *deviceHandler) GetOnuAlarmManager() cmn.IonuAlarmManager {
4132 return dh.pAlarmMgr
4133}
4134
4135// GetOnuMetricsManager - TODO: add comment
4136func (dh *deviceHandler) GetOnuMetricsManager() cmn.IonuMetricsManager {
4137 return dh.pOnuMetricsMgr
4138}
4139
4140// GetOnuTP - TODO: add comment
4141func (dh *deviceHandler) GetOnuTP() cmn.IonuUniTechProf {
4142 return dh.pOnuTP
4143}
4144
4145// GetBackendPathPrefix - TODO: add comment
4146func (dh *deviceHandler) GetBackendPathPrefix() string {
4147 return dh.pOpenOnuAc.cm.Backend.PathPrefix
4148}
4149
4150// GetOnuIndication - TODO: add comment
4151func (dh *deviceHandler) GetOnuIndication() *openolt.OnuIndication {
4152 return dh.pOnuIndication
4153}
4154
4155// RLockMutexDeletionInProgressFlag - TODO: add comment
4156func (dh *deviceHandler) RLockMutexDeletionInProgressFlag() {
4157 dh.mutexDeletionInProgressFlag.RLock()
4158}
4159
4160// RUnlockMutexDeletionInProgressFlag - TODO: add comment
4161func (dh *deviceHandler) RUnlockMutexDeletionInProgressFlag() {
4162 dh.mutexDeletionInProgressFlag.RUnlock()
4163}
4164
4165// GetDeletionInProgress - TODO: add comment
4166func (dh *deviceHandler) GetDeletionInProgress() bool {
4167 return dh.deletionInProgress
4168}
4169
4170// GetPmConfigs - TODO: add comment
4171func (dh *deviceHandler) GetPmConfigs() *voltha.PmConfigs {
4172 return dh.pmConfigs
4173}
4174
4175// GetDeviceType - TODO: add comment
4176func (dh *deviceHandler) GetDeviceType() string {
4177 return dh.DeviceType
4178}
4179
4180// GetLogicalDeviceID - TODO: add comment
4181func (dh *deviceHandler) GetLogicalDeviceID() string {
4182 return dh.logicalDeviceID
4183}
4184
4185// GetDevice - TODO: add comment
4186func (dh *deviceHandler) GetDevice() *voltha.Device {
4187 return dh.device
4188}
4189
4190// GetMetricsEnabled - TODO: add comment
4191func (dh *deviceHandler) GetMetricsEnabled() bool {
4192 return dh.pOpenOnuAc.MetricsEnabled
4193}
4194
4195// InitPmConfigs - TODO: add comment
4196func (dh *deviceHandler) InitPmConfigs() {
4197 dh.pmConfigs = &voltha.PmConfigs{}
4198}
4199
4200// GetUniPortMask - TODO: add comment
4201func (dh *deviceHandler) GetUniPortMask() int {
4202 return dh.pOpenOnuAc.config.UniPortMask
4203}