Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1 | /* |
| 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 Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 17 | //Package core provides the utility for onu devices, flows and statistics |
| 18 | package core |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 19 | |
| 20 | import ( |
| 21 | "context" |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 22 | "errors" |
| 23 | "fmt" |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 24 | "strconv" |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 25 | "sync" |
| 26 | "time" |
| 27 | |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 28 | "github.com/opencord/voltha-openonu-adapter-go/internal/pkg/config" |
mpagenko | 1f8e882 | 2021-06-25 14:10:21 +0000 | [diff] [blame] | 29 | |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 30 | "github.com/gogo/protobuf/proto" |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 31 | "github.com/looplab/fsm" |
mpagenko | 836a1fd | 2021-11-01 16:12:42 +0000 | [diff] [blame] | 32 | me "github.com/opencord/omci-lib-go/v2/generated" |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 33 | "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 Gunyel | cb128ae | 2021-10-06 09:42:05 -0700 | [diff] [blame] | 38 | platform "github.com/opencord/voltha-lib-go/v7/pkg/platform" |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 39 | 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" |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 47 | vc "github.com/opencord/voltha-protos/v5/go/common" |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 48 | ca "github.com/opencord/voltha-protos/v5/go/core_adapter" |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 49 | "github.com/opencord/voltha-protos/v5/go/extension" |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 50 | "github.com/opencord/voltha-protos/v5/go/inter_adapter" |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 51 | ia "github.com/opencord/voltha-protos/v5/go/inter_adapter" |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 52 | of "github.com/opencord/voltha-protos/v5/go/openflow_13" |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 53 | "github.com/opencord/voltha-protos/v5/go/openolt" |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 54 | oop "github.com/opencord/voltha-protos/v5/go/openolt" |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 55 | "github.com/opencord/voltha-protos/v5/go/tech_profile" |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 56 | "github.com/opencord/voltha-protos/v5/go/voltha" |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 57 | ) |
| 58 | |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 59 | const ( |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 60 | //constants for reconcile flow check channel |
| 61 | cWaitReconcileFlowAbortOnSuccess = 0xFFFD |
| 62 | cWaitReconcileFlowAbortOnError = 0xFFFE |
| 63 | cWaitReconcileFlowNoActivity = 0xFFFF |
| 64 | ) |
| 65 | |
| 66 | const ( |
| 67 | // constants for timeouts |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 68 | cTimeOutRemoveUpgrade = 1 //for usage in seconds |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 69 | ) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 70 | |
mpagenko | 1cc3cb4 | 2020-07-27 15:24:38 +0000 | [diff] [blame] | 71 | const ( |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 72 | // dummy constant - irregular value for ConnState - used to avoiding setting this state in the updateDeviceState() |
| 73 | // should better be defined in voltha protobuf or best solution would be to define an interface to just set the OperState |
| 74 | // as long as such is not available by the libraries - use this workaround |
| 75 | connectStatusINVALID = 255 // as long as not used as key in voltha.ConnectStatus_Types_name |
| 76 | ) |
| 77 | |
| 78 | const ( |
mpagenko | 1cc3cb4 | 2020-07-27 15:24:38 +0000 | [diff] [blame] | 79 | // events of Device FSM |
| 80 | devEvDeviceInit = "devEvDeviceInit" |
| 81 | devEvGrpcConnected = "devEvGrpcConnected" |
| 82 | devEvGrpcDisconnected = "devEvGrpcDisconnected" |
| 83 | devEvDeviceUpInd = "devEvDeviceUpInd" |
| 84 | devEvDeviceDownInd = "devEvDeviceDownInd" |
| 85 | ) |
| 86 | const ( |
| 87 | // states of Device FSM |
| 88 | devStNull = "devStNull" |
| 89 | devStDown = "devStDown" |
| 90 | devStInit = "devStInit" |
| 91 | devStConnected = "devStConnected" |
| 92 | devStUp = "devStUp" |
| 93 | ) |
| 94 | |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 95 | //Event category and subcategory definitions - same as defiend for OLT in eventmgr.go - should be done more centrally |
| 96 | const ( |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 97 | pon = voltha.EventSubCategory_PON |
| 98 | //olt = voltha.EventSubCategory_OLT |
| 99 | //ont = voltha.EventSubCategory_ONT |
| 100 | //onu = voltha.EventSubCategory_ONU |
| 101 | //nni = voltha.EventSubCategory_NNI |
| 102 | //service = voltha.EventCategory_SERVICE |
| 103 | //security = voltha.EventCategory_SECURITY |
| 104 | equipment = voltha.EventCategory_EQUIPMENT |
| 105 | //processing = voltha.EventCategory_PROCESSING |
| 106 | //environment = voltha.EventCategory_ENVIRONMENT |
| 107 | //communication = voltha.EventCategory_COMMUNICATION |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 108 | ) |
| 109 | |
| 110 | const ( |
| 111 | cEventObjectType = "ONU" |
| 112 | ) |
| 113 | const ( |
| 114 | cOnuActivatedEvent = "ONU_ACTIVATED" |
| 115 | ) |
| 116 | |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 117 | type omciIdleCheckStruct struct { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 118 | omciIdleCheckFunc func(*deviceHandler, context.Context, cmn.UsedOmciConfigFsms, string) bool |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 119 | omciIdleState string |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 120 | } |
| 121 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 122 | var fsmOmciIdleStateFuncMap = map[cmn.UsedOmciConfigFsms]omciIdleCheckStruct{ |
| 123 | cmn.CUploadFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, mib.CMibUlFsmIdleState}, |
| 124 | cmn.CDownloadFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, mib.CMibDlFsmIdleState}, |
| 125 | cmn.CUniLockFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, uniprt.CUniFsmIdleState}, |
| 126 | cmn.CUniUnLockFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, uniprt.CUniFsmIdleState}, |
| 127 | cmn.CAniConfigFsm: {(*deviceHandler).isAniConfigFsmInOmciIdleState, avcfg.CAniFsmIdleState}, |
| 128 | cmn.CUniVlanConfigFsm: {(*deviceHandler).isUniVlanConfigFsmInOmciIdleState, avcfg.CVlanFsmIdleState}, |
| 129 | cmn.CL2PmFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, pmmgr.CL2PmFsmIdleState}, |
| 130 | cmn.COnuUpgradeFsm: {(*deviceHandler).isFsmInOmciIdleStateDefault, swupg.COnuUpgradeFsmIdleState}, |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 131 | } |
| 132 | |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 133 | const ( |
| 134 | cNoReconciling = iota |
| 135 | cOnuConfigReconciling |
| 136 | cSkipOnuConfigReconciling |
| 137 | ) |
| 138 | |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 139 | // FlowCb is the flow control block containing flow add/delete information along with a response channel |
| 140 | type FlowCb struct { |
| 141 | ctx context.Context // Flow handler context |
| 142 | addFlow bool // if true flow to be added, else removed |
| 143 | flowItem *of.OfpFlowStats |
| 144 | uniPort *cmn.OnuUniPort |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 145 | flowMetaData *of.FlowMetadata |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 146 | respChan *chan error // channel to report the Flow handling error |
| 147 | } |
| 148 | |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 149 | //deviceHandler will interact with the ONU ? device. |
| 150 | type deviceHandler struct { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 151 | DeviceID string |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 152 | DeviceType string |
| 153 | adminState string |
| 154 | device *voltha.Device |
| 155 | logicalDeviceID string |
| 156 | ProxyAddressID string |
| 157 | ProxyAddressType string |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 158 | parentID string |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 159 | ponPortNumber uint32 |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 160 | |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 161 | coreClient *vgrpc.Client |
| 162 | EventProxy eventif.EventProxy |
Holger Hildebrandt | c54939a | 2020-06-17 08:14:27 +0000 | [diff] [blame] | 163 | |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 164 | pmConfigs *voltha.PmConfigs |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 165 | config *config.AdapterFlags |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 166 | |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 167 | pOpenOnuAc *OpenONUAC |
| 168 | pDeviceStateFsm *fsm.FSM |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 169 | //pPonPort *voltha.Port |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 170 | deviceEntrySet chan bool //channel for DeviceEntry set event |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 171 | pOnuOmciDevice *mib.OnuDeviceEntry |
| 172 | pOnuTP *avcfg.OnuUniTechProf |
| 173 | pOnuMetricsMgr *pmmgr.OnuMetricsManager |
| 174 | pAlarmMgr *almgr.OnuAlarmManager |
| 175 | pSelfTestHdlr *otst.SelfTestControlBlock |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 176 | exitChannel chan int |
| 177 | lockDevice sync.RWMutex |
| 178 | pOnuIndication *oop.OnuIndication |
| 179 | deviceReason uint8 |
| 180 | mutexDeviceReason sync.RWMutex |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 181 | pLockStateFsm *uniprt.LockStateFsm |
| 182 | pUnlockStateFsm *uniprt.LockStateFsm |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 183 | |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 184 | //flowMgr *OpenOltFlowMgr |
| 185 | //eventMgr *OpenOltEventMgr |
| 186 | //resourceMgr *rsrcMgr.OpenOltResourceMgr |
| 187 | |
| 188 | //discOnus sync.Map |
| 189 | //onus sync.Map |
| 190 | //portStats *OpenOltStatisticsMgr |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 191 | collectorIsRunning bool |
| 192 | mutexCollectorFlag sync.RWMutex |
| 193 | stopCollector chan bool |
| 194 | alarmManagerIsRunning bool |
| 195 | mutextAlarmManagerFlag sync.RWMutex |
| 196 | stopAlarmManager chan bool |
| 197 | stopHeartbeatCheck chan bool |
| 198 | uniEntityMap cmn.OnuUniPortMap |
| 199 | mutexKvStoreContext sync.Mutex |
| 200 | lockVlanConfig sync.RWMutex |
| 201 | lockVlanAdd sync.RWMutex |
| 202 | UniVlanConfigFsmMap map[uint8]*avcfg.UniVlanConfigFsm |
| 203 | lockUpgradeFsm sync.RWMutex |
| 204 | pOnuUpradeFsm *swupg.OnuUpgradeFsm |
| 205 | upgradeCanceled bool |
| 206 | reconciling uint8 |
| 207 | mutexReconcilingFlag sync.RWMutex |
Holger Hildebrandt | 7741f27 | 2022-01-18 08:17:39 +0000 | [diff] [blame^] | 208 | reconcilingFirstPass bool |
| 209 | mutexReconcilingFirstPassFlag sync.RWMutex |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 210 | reconcilingReasonUpdate bool |
| 211 | mutexReconcilingReasonUpdate sync.RWMutex |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 212 | chUniVlanConfigReconcilingDone chan uint16 //channel to indicate that VlanConfig reconciling for a specific UNI has been finished |
| 213 | chReconcilingFinished chan bool //channel to indicate that reconciling has been finished |
| 214 | reconcileExpiryComplete time.Duration |
| 215 | reconcileExpiryVlanConfig time.Duration |
| 216 | mutexReadyForOmciConfig sync.RWMutex |
| 217 | readyForOmciConfig bool |
| 218 | deletionInProgress bool |
| 219 | mutexDeletionInProgressFlag sync.RWMutex |
| 220 | pLastUpgradeImageState *voltha.ImageState |
| 221 | upgradeFsmChan chan struct{} |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 222 | |
| 223 | flowCbChan []chan FlowCb |
| 224 | mutexFlowMonitoringRoutineFlag sync.RWMutex |
| 225 | stopFlowMonitoringRoutine []chan bool // length of slice equal to number of uni ports |
| 226 | isFlowMonitoringRoutineActive []bool // length of slice equal to number of uni ports |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 227 | } |
| 228 | |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 229 | //newDeviceHandler creates a new device handler |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 230 | func newDeviceHandler(ctx context.Context, cc *vgrpc.Client, ep eventif.EventProxy, device *voltha.Device, adapter *OpenONUAC) *deviceHandler { |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 231 | var dh deviceHandler |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 232 | dh.coreClient = cc |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 233 | dh.EventProxy = ep |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 234 | dh.config = adapter.config |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 235 | cloned := (proto.Clone(device)).(*voltha.Device) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 236 | dh.DeviceID = cloned.Id |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 237 | dh.DeviceType = cloned.Type |
| 238 | dh.adminState = "up" |
| 239 | dh.device = cloned |
| 240 | dh.pOpenOnuAc = adapter |
| 241 | dh.exitChannel = make(chan int, 1) |
| 242 | dh.lockDevice = sync.RWMutex{} |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 243 | dh.deviceEntrySet = make(chan bool, 1) |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 244 | dh.collectorIsRunning = false |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 245 | dh.stopCollector = make(chan bool, 2) |
Himani Chawla | 4c1d4c7 | 2021-02-18 12:14:31 +0530 | [diff] [blame] | 246 | dh.alarmManagerIsRunning = false |
Himani Chawla | ac1f5ad | 2021-02-04 21:21:54 +0530 | [diff] [blame] | 247 | dh.stopAlarmManager = make(chan bool, 2) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 248 | dh.stopHeartbeatCheck = make(chan bool, 2) |
| 249 | //dh.metrics = pmmetrics.NewPmMetrics(cloned.Id, pmmetrics.Frequency(150), pmmetrics.FrequencyOverride(false), pmmetrics.Grouped(false), pmmetrics.Metrics(pmNames)) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 250 | //TODO initialize the support classes. |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 251 | dh.uniEntityMap = make(map[uint32]*cmn.OnuUniPort) |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 252 | dh.lockVlanConfig = sync.RWMutex{} |
mpagenko | bc4170a | 2021-08-17 16:42:10 +0000 | [diff] [blame] | 253 | dh.lockVlanAdd = sync.RWMutex{} |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 254 | dh.lockUpgradeFsm = sync.RWMutex{} |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 255 | dh.UniVlanConfigFsmMap = make(map[uint8]*avcfg.UniVlanConfigFsm) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 256 | dh.reconciling = cNoReconciling |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 257 | dh.reconcilingReasonUpdate = false |
Holger Hildebrandt | 7741f27 | 2022-01-18 08:17:39 +0000 | [diff] [blame^] | 258 | dh.reconcilingFirstPass = true |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 259 | dh.chReconcilingFinished = make(chan bool) |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 260 | dh.reconcileExpiryComplete = adapter.maxTimeoutReconciling //assumption is to have it as duration in s! |
| 261 | rECSeconds := int(dh.reconcileExpiryComplete / time.Second) |
| 262 | if rECSeconds < 2 { |
| 263 | dh.reconcileExpiryComplete = time.Duration(2) * time.Second //ensure a minimum expiry time of 2s for complete reconciling |
| 264 | rECSeconds = 2 |
| 265 | } |
| 266 | rEVCSeconds := rECSeconds / 2 |
| 267 | dh.reconcileExpiryVlanConfig = time.Duration(rEVCSeconds) * time.Second //set this duration to some according lower value |
Holger Hildebrandt | 0da7e6f | 2021-05-12 13:08:43 +0000 | [diff] [blame] | 268 | dh.readyForOmciConfig = false |
Holger Hildebrandt | ff05b68 | 2021-03-16 15:02:05 +0000 | [diff] [blame] | 269 | dh.deletionInProgress = false |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 270 | dh.pLastUpgradeImageState = &voltha.ImageState{ |
| 271 | DownloadState: voltha.ImageState_DOWNLOAD_UNKNOWN, |
| 272 | Reason: voltha.ImageState_UNKNOWN_ERROR, |
| 273 | ImageState: voltha.ImageState_IMAGE_UNKNOWN, |
| 274 | } |
| 275 | dh.upgradeFsmChan = make(chan struct{}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 276 | |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 277 | if dh.device.PmConfigs != nil { // can happen after onu adapter restart |
| 278 | dh.pmConfigs = cloned.PmConfigs |
| 279 | } /* else { |
| 280 | // will be populated when onu_metrics_mananger is initialized. |
| 281 | }*/ |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 282 | |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 283 | // Device related state machine |
| 284 | dh.pDeviceStateFsm = fsm.NewFSM( |
mpagenko | 1cc3cb4 | 2020-07-27 15:24:38 +0000 | [diff] [blame] | 285 | devStNull, |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 286 | fsm.Events{ |
mpagenko | 1cc3cb4 | 2020-07-27 15:24:38 +0000 | [diff] [blame] | 287 | {Name: devEvDeviceInit, Src: []string{devStNull, devStDown}, Dst: devStInit}, |
| 288 | {Name: devEvGrpcConnected, Src: []string{devStInit}, Dst: devStConnected}, |
| 289 | {Name: devEvGrpcDisconnected, Src: []string{devStConnected, devStDown}, Dst: devStInit}, |
| 290 | {Name: devEvDeviceUpInd, Src: []string{devStConnected, devStDown}, Dst: devStUp}, |
| 291 | {Name: devEvDeviceDownInd, Src: []string{devStUp}, Dst: devStDown}, |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 292 | }, |
| 293 | fsm.Callbacks{ |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 294 | "before_event": func(e *fsm.Event) { dh.logStateChange(ctx, e) }, |
| 295 | ("before_" + devEvDeviceInit): func(e *fsm.Event) { dh.doStateInit(ctx, e) }, |
| 296 | ("after_" + devEvDeviceInit): func(e *fsm.Event) { dh.postInit(ctx, e) }, |
| 297 | ("before_" + devEvGrpcConnected): func(e *fsm.Event) { dh.doStateConnected(ctx, e) }, |
| 298 | ("before_" + devEvGrpcDisconnected): func(e *fsm.Event) { dh.doStateInit(ctx, e) }, |
| 299 | ("after_" + devEvGrpcDisconnected): func(e *fsm.Event) { dh.postInit(ctx, e) }, |
| 300 | ("before_" + devEvDeviceUpInd): func(e *fsm.Event) { dh.doStateUp(ctx, e) }, |
| 301 | ("before_" + devEvDeviceDownInd): func(e *fsm.Event) { dh.doStateDown(ctx, e) }, |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 302 | }, |
| 303 | ) |
mpagenko | af80163 | 2020-07-03 10:00:42 +0000 | [diff] [blame] | 304 | |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 305 | return &dh |
| 306 | } |
| 307 | |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 308 | // start save the device to the data model |
| 309 | func (dh *deviceHandler) start(ctx context.Context) { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 310 | logger.Debugw(ctx, "starting-device-handler", log.Fields{"device": dh.device, "device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 311 | // Add the initial device to the local model |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 312 | logger.Debugw(ctx, "device-handler-started", log.Fields{"device": dh.device}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 313 | } |
| 314 | |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 315 | /* |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 316 | // stop stops the device dh. Not much to do for now |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 317 | func (dh *deviceHandler) stop(ctx context.Context) { |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 318 | logger.Debug("stopping-device-handler") |
| 319 | dh.exitChannel <- 1 |
| 320 | } |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 321 | */ |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 322 | |
| 323 | // ########################################################################################## |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 324 | // deviceHandler methods that implement the adapters interface requests ##### begin ######### |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 325 | |
Girish Gowdra | e0140f0 | 2021-02-02 16:55:09 -0800 | [diff] [blame] | 326 | //adoptOrReconcileDevice adopts the ONU device |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 327 | func (dh *deviceHandler) adoptOrReconcileDevice(ctx context.Context, device *voltha.Device) { |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 328 | logger.Debugw(ctx, "adopt_or_reconcile_device", log.Fields{"device-id": device.Id, "Address": device.GetHostAndPort()}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 329 | |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 330 | logger.Debugw(ctx, "Device FSM: ", log.Fields{"device-id": device.Id, "state": string(dh.pDeviceStateFsm.Current())}) |
mpagenko | 1cc3cb4 | 2020-07-27 15:24:38 +0000 | [diff] [blame] | 331 | if dh.pDeviceStateFsm.Is(devStNull) { |
| 332 | if err := dh.pDeviceStateFsm.Event(devEvDeviceInit); err != nil { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 333 | logger.Errorw(ctx, "Device FSM: Can't go to state DeviceInit", log.Fields{"device-id": device.Id, "err": err}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 334 | } |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 335 | logger.Debugw(ctx, "Device FSM: ", log.Fields{"device-id": device.Id, "state": string(dh.pDeviceStateFsm.Current())}) |
Girish Gowdra | af0ad63 | 2021-01-27 13:00:01 -0800 | [diff] [blame] | 336 | // device.PmConfigs is not nil in cases when adapter restarts. We should not re-set the core again. |
| 337 | if device.PmConfigs == nil { |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 338 | // Now, set the initial PM configuration for that device |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 339 | if err := dh.updatePMConfigInCore(ctx, dh.pmConfigs); err != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 340 | logger.Errorw(ctx, "error updating pm config to core", log.Fields{"device-id": dh.DeviceID, "err": err}) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 341 | } |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 342 | } |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 343 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 344 | logger.Debugw(ctx, "AdoptOrReconcileDevice: Agent/device init already done", log.Fields{"device-id": device.Id}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 345 | } |
| 346 | |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 347 | } |
| 348 | |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 349 | func (dh *deviceHandler) handleOMCIIndication(ctx context.Context, msg *ia.OmciMessage) error { |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 350 | /* msg print moved symmetrically to omci_cc, if wanted here as additional debug, than perhaps only based on additional debug setting! |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 351 | //assuming omci message content is hex coded! |
| 352 | // with restricted output of 16(?) bytes would be ...omciMsg.Message[:16] |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 353 | logger.Debugw(ctx, "inter-adapter-recv-omci", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 354 | "device-id": dh.DeviceID, "RxOmciMessage": hex.EncodeToString(omciMsg.Message)}) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 355 | */ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 356 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 357 | if pDevEntry != nil { |
Holger Hildebrandt | 2fb7089 | 2020-10-28 11:53:18 +0000 | [diff] [blame] | 358 | if pDevEntry.PDevOmciCC != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 359 | return pDevEntry.PDevOmciCC.ReceiveMessage(log.WithSpanFromContext(context.TODO(), ctx), msg.Message) |
Holger Hildebrandt | 2fb7089 | 2020-10-28 11:53:18 +0000 | [diff] [blame] | 360 | } |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 361 | logger.Debugw(ctx, "omciCC not ready to receive omci messages - incoming omci message ignored", log.Fields{"device-id": dh.DeviceID, |
| 362 | "rxMsg": msg.Message}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 363 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 364 | logger.Errorw(ctx, "No valid OnuDevice -aborting", log.Fields{"device-id": dh.DeviceID}) |
| 365 | return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 366 | } |
| 367 | |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 368 | func (dh *deviceHandler) handleTechProfileDownloadRequest(ctx context.Context, techProfMsg *ia.TechProfileDownloadMessage) error { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 369 | logger.Infow(ctx, "tech-profile-download-request", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 80129db | 2020-11-23 10:49:32 +0000 | [diff] [blame] | 370 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 371 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 372 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 373 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
| 374 | return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 375 | } |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 376 | if dh.pOnuTP == nil { |
| 377 | //should normally not happen ... |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 378 | logger.Errorw(ctx, "onuTechProf instance not set up for DLMsg request - ignoring request", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 379 | log.Fields{"device-id": dh.DeviceID}) |
| 380 | return fmt.Errorf("techProfile DLMsg request while onuTechProf instance not setup: %s", dh.DeviceID) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 381 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 382 | if !dh.IsReadyForOmciConfig() { |
| 383 | logger.Errorw(ctx, "TechProf-set rejected: improper device state", log.Fields{"device-id": dh.DeviceID, |
| 384 | "device-state": dh.GetDeviceReasonString()}) |
| 385 | return fmt.Errorf("improper device state %s on device %s", dh.GetDeviceReasonString(), dh.DeviceID) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 386 | } |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 387 | //previous state test here was just this one, now extended for more states to reject the SetRequest: |
| 388 | // at least 'mib-downloaded' should be reached for processing of this specific ONU configuration |
| 389 | // if (dh.deviceReason == "stopping-openomci") || (dh.deviceReason == "omci-admin-lock") |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 390 | |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 391 | // we have to lock access to TechProfile processing based on different messageType calls or |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 392 | // even to fast subsequent calls of the same messageType as well as OnuKVStore processing due |
| 393 | // to possible concurrent access by flow processing |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 394 | dh.pOnuTP.LockTpProcMutex() |
| 395 | defer dh.pOnuTP.UnlockTpProcMutex() |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 396 | |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 397 | if techProfMsg.UniId >= platform.MaxUnisPerOnu { |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 398 | return fmt.Errorf(fmt.Sprintf("received UniId value exceeds range: %d, device-id: %s", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 399 | techProfMsg.UniId, dh.DeviceID)) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 400 | } |
| 401 | uniID := uint8(techProfMsg.UniId) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 402 | tpID, err := cmn.GetTpIDFromTpPath(techProfMsg.TpInstancePath) |
Girish Gowdra | 041dcb3 | 2020-11-16 16:54:30 -0800 | [diff] [blame] | 403 | if err != nil { |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 404 | logger.Errorw(ctx, "error-parsing-tpid-from-tppath", log.Fields{"err": err, "tp-path": techProfMsg.TpInstancePath}) |
Girish Gowdra | 041dcb3 | 2020-11-16 16:54:30 -0800 | [diff] [blame] | 405 | return err |
| 406 | } |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 407 | logger.Debugw(ctx, "unmarshal-techprof-msg-body", log.Fields{"device-id": dh.DeviceID, |
| 408 | "uniID": uniID, "tp-path": techProfMsg.TpInstancePath, "tpID": tpID}) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 409 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 410 | if bTpModify := pDevEntry.UpdateOnuUniTpPath(ctx, uniID, uint8(tpID), techProfMsg.TpInstancePath); bTpModify { |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 411 | |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 412 | switch tpInst := techProfMsg.TechTpInstance.(type) { |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 413 | case *ia.TechProfileDownloadMessage_TpInstance: |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 414 | logger.Debugw(ctx, "onu-uni-tp-path-modified", log.Fields{"device-id": dh.DeviceID, |
| 415 | "uniID": uniID, "tp-path": techProfMsg.TpInstancePath, "tpID": tpID}) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 416 | // if there has been some change for some uni TechProfilePath |
| 417 | //in order to allow concurrent calls to other dh instances we do not wait for execution here |
| 418 | //but doing so we can not indicate problems to the caller (who does what with that then?) |
| 419 | //by now we just assume straightforward successful execution |
| 420 | //TODO!!! Generally: In this scheme it would be good to have some means to indicate |
| 421 | // possible problems to the caller later autonomously |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 422 | |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 423 | // deadline context to ensure completion of background routines waited for |
| 424 | //20200721: 10s proved to be less in 8*8 ONU test on local vbox machine with debug, might be further adapted |
| 425 | deadline := time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution |
| 426 | dctx, cancel := context.WithDeadline(context.Background(), deadline) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 427 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 428 | dh.pOnuTP.ResetTpProcessingErrorIndication(uniID, tpID) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 429 | |
| 430 | var wg sync.WaitGroup |
| 431 | wg.Add(1) // for the 1 go routine to finish |
| 432 | // attention: deadline completion check and wg.Done is to be done in both routines |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 433 | go dh.pOnuTP.ConfigureUniTp(log.WithSpanFromContext(dctx, ctx), uniID, techProfMsg.TpInstancePath, *tpInst.TpInstance, &wg) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 434 | dh.waitForCompletion(ctx, cancel, &wg, "TechProfDwld") //wait for background process to finish |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 435 | if tpErr := dh.pOnuTP.GetTpProcessingErrorIndication(uniID, tpID); tpErr != nil { |
| 436 | logger.Errorw(ctx, "error-processing-tp", log.Fields{"device-id": dh.DeviceID, "err": tpErr, "tp-path": techProfMsg.TpInstancePath}) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 437 | return tpErr |
| 438 | } |
| 439 | deadline = time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution |
| 440 | dctx2, cancel2 := context.WithDeadline(context.Background(), deadline) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 441 | pDevEntry.ResetKvProcessingErrorIndication() |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 442 | wg.Add(1) // for the 1 go routine to finish |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 443 | go pDevEntry.UpdateOnuKvStore(log.WithSpanFromContext(dctx2, ctx), &wg) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 444 | dh.waitForCompletion(ctx, cancel2, &wg, "TechProfDwld") //wait for background process to finish |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 445 | if kvErr := pDevEntry.GetKvProcessingErrorIndication(); kvErr != nil { |
| 446 | logger.Errorw(ctx, "error-updating-KV", log.Fields{"device-id": dh.DeviceID, "err": kvErr, "tp-path": techProfMsg.TpInstancePath}) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 447 | return kvErr |
| 448 | } |
| 449 | return nil |
| 450 | default: |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 451 | logger.Errorw(ctx, "unsupported-tp-instance-type", log.Fields{"device-id": dh.DeviceID, "tp-path": techProfMsg.TpInstancePath}) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 452 | return fmt.Errorf("unsupported-tp-instance-type--tp-id-%v", techProfMsg.TpInstancePath) |
Mahir Gunyel | 7f4483a | 2021-05-06 12:53:43 -0700 | [diff] [blame] | 453 | } |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 454 | } |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 455 | // no change, nothing really to do - return success |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 456 | logger.Debugw(ctx, "onu-uni-tp-path-not-modified", log.Fields{"device-id": dh.DeviceID, |
| 457 | "uniID": uniID, "tp-path": techProfMsg.TpInstancePath, "tpID": tpID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 458 | return nil |
| 459 | } |
| 460 | |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 461 | func (dh *deviceHandler) handleDeleteGemPortRequest(ctx context.Context, delGemPortMsg *ia.DeleteGemPortMessage) error { |
mpagenko | 0f54322 | 2021-11-03 16:24:14 +0000 | [diff] [blame] | 462 | logger.Infow(ctx, "delete-gem-port-request start", log.Fields{"device-id": dh.DeviceID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 463 | |
| 464 | if dh.pOnuTP == nil { |
| 465 | //should normally not happen ... |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 466 | logger.Warnw(ctx, "onuTechProf instance not set up for DelGem request - ignoring request", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 467 | log.Fields{"device-id": dh.DeviceID}) |
| 468 | return fmt.Errorf("techProfile DelGem request while onuTechProf instance not setup: %s", dh.DeviceID) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 469 | } |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 470 | //compare TECH_PROFILE_DOWNLOAD_REQUEST |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 471 | dh.pOnuTP.LockTpProcMutex() |
| 472 | defer dh.pOnuTP.UnlockTpProcMutex() |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 473 | |
mpagenko | 0f54322 | 2021-11-03 16:24:14 +0000 | [diff] [blame] | 474 | if delGemPortMsg.UniId >= platform.MaxUnisPerOnu { |
| 475 | logger.Errorw(ctx, "delete-gem-port UniId exceeds range", log.Fields{ |
| 476 | "device-id": dh.DeviceID, "uni-id": delGemPortMsg.UniId}) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 477 | return fmt.Errorf(fmt.Sprintf("received UniId value exceeds range: %d, device-id: %s", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 478 | delGemPortMsg.UniId, dh.DeviceID)) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 479 | } |
| 480 | uniID := uint8(delGemPortMsg.UniId) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 481 | tpID, err := cmn.GetTpIDFromTpPath(delGemPortMsg.TpInstancePath) |
Girish Gowdra | 041dcb3 | 2020-11-16 16:54:30 -0800 | [diff] [blame] | 482 | if err != nil { |
mpagenko | 0f54322 | 2021-11-03 16:24:14 +0000 | [diff] [blame] | 483 | logger.Errorw(ctx, "error-extracting-tp-id-from-tp-path", log.Fields{ |
| 484 | "device-id": dh.DeviceID, "err": err, "tp-path": delGemPortMsg.TpInstancePath}) |
Girish Gowdra | 041dcb3 | 2020-11-16 16:54:30 -0800 | [diff] [blame] | 485 | return err |
| 486 | } |
mpagenko | 0f54322 | 2021-11-03 16:24:14 +0000 | [diff] [blame] | 487 | logger.Infow(ctx, "delete-gem-port-request", log.Fields{ |
| 488 | "device-id": dh.DeviceID, "uni-id": uniID, "tpID": tpID, "gem": delGemPortMsg.GemPortId}) |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 489 | //a removal of some GemPort would never remove the complete TechProfile entry (done on T-Cont) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 490 | |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 491 | return dh.deleteTechProfileResource(ctx, uniID, tpID, delGemPortMsg.TpInstancePath, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 492 | avcfg.CResourceGemPort, delGemPortMsg.GemPortId) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 493 | |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 494 | } |
| 495 | |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 496 | func (dh *deviceHandler) handleDeleteTcontRequest(ctx context.Context, delTcontMsg *ia.DeleteTcontMessage) error { |
mpagenko | 0f54322 | 2021-11-03 16:24:14 +0000 | [diff] [blame] | 497 | logger.Infow(ctx, "delete-tcont-request start", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 498 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 499 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 500 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 501 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
| 502 | return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 503 | } |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 504 | if dh.pOnuTP == nil { |
| 505 | //should normally not happen ... |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 506 | logger.Warnw(ctx, "onuTechProf instance not set up for DelTcont request - ignoring request", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 507 | log.Fields{"device-id": dh.DeviceID}) |
| 508 | return fmt.Errorf("techProfile DelTcont request while onuTechProf instance not setup: %s", dh.DeviceID) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 509 | } |
| 510 | |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 511 | //compare TECH_PROFILE_DOWNLOAD_REQUEST |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 512 | dh.pOnuTP.LockTpProcMutex() |
| 513 | defer dh.pOnuTP.UnlockTpProcMutex() |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 514 | |
mpagenko | 0f54322 | 2021-11-03 16:24:14 +0000 | [diff] [blame] | 515 | if delTcontMsg.UniId >= platform.MaxUnisPerOnu { |
| 516 | logger.Errorw(ctx, "delete-tcont UniId exceeds range", log.Fields{ |
| 517 | "device-id": dh.DeviceID, "uni-id": delTcontMsg.UniId}) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 518 | return fmt.Errorf(fmt.Sprintf("received UniId value exceeds range: %d, device-id: %s", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 519 | delTcontMsg.UniId, dh.DeviceID)) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 520 | } |
| 521 | uniID := uint8(delTcontMsg.UniId) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 522 | tpPath := delTcontMsg.TpInstancePath |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 523 | tpID, err := cmn.GetTpIDFromTpPath(tpPath) |
Girish Gowdra | 041dcb3 | 2020-11-16 16:54:30 -0800 | [diff] [blame] | 524 | if err != nil { |
mpagenko | 0f54322 | 2021-11-03 16:24:14 +0000 | [diff] [blame] | 525 | logger.Errorw(ctx, "error-extracting-tp-id-from-tp-path", log.Fields{ |
| 526 | "device-id": dh.DeviceID, "err": err, "tp-path": tpPath}) |
Girish Gowdra | 041dcb3 | 2020-11-16 16:54:30 -0800 | [diff] [blame] | 527 | return err |
| 528 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 529 | logger.Infow(ctx, "delete-tcont-request", log.Fields{"device-id": dh.DeviceID, "uni-id": uniID, "tpID": tpID, "tcont": delTcontMsg.AllocId}) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 530 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 531 | pDevEntry.FreeTcont(ctx, uint16(delTcontMsg.AllocId)) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 532 | |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 533 | return dh.deleteTechProfileResource(ctx, uniID, tpID, delTcontMsg.TpInstancePath, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 534 | avcfg.CResourceTcont, delTcontMsg.AllocId) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 535 | |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 536 | } |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 537 | |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 538 | func (dh *deviceHandler) deleteTechProfileResource(ctx context.Context, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 539 | uniID uint8, tpID uint8, pathString string, resource avcfg.ResourceEntry, entryID uint32) error { |
| 540 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 541 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 542 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
| 543 | return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 544 | } |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 545 | var resourceName string |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 546 | if avcfg.CResourceGemPort == resource { |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 547 | resourceName = "Gem" |
| 548 | } else { |
| 549 | resourceName = "Tcont" |
| 550 | } |
| 551 | |
| 552 | // deadline context to ensure completion of background routines waited for |
| 553 | deadline := time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution |
| 554 | dctx, cancel := context.WithDeadline(context.Background(), deadline) |
| 555 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 556 | dh.pOnuTP.ResetTpProcessingErrorIndication(uniID, tpID) |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 557 | |
| 558 | var wg sync.WaitGroup |
| 559 | wg.Add(1) // for the 1 go routine to finish |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 560 | go dh.pOnuTP.DeleteTpResource(log.WithSpanFromContext(dctx, ctx), uniID, tpID, pathString, |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 561 | resource, entryID, &wg) |
| 562 | dh.waitForCompletion(ctx, cancel, &wg, resourceName+"Delete") //wait for background process to finish |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 563 | if err := dh.pOnuTP.GetTpProcessingErrorIndication(uniID, tpID); err != nil { |
| 564 | logger.Errorw(ctx, err.Error(), log.Fields{"device-id": dh.DeviceID}) |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 565 | return err |
| 566 | } |
| 567 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 568 | if dh.pOnuTP.IsTechProfileConfigCleared(ctx, uniID, tpID) { |
| 569 | logger.Debugw(ctx, "techProfile-config-cleared", log.Fields{"device-id": dh.DeviceID, "uni-id": uniID, "tpID": tpID}) |
| 570 | if bTpModify := pDevEntry.UpdateOnuUniTpPath(ctx, uniID, tpID, ""); bTpModify { |
| 571 | pDevEntry.ResetKvProcessingErrorIndication() |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 572 | var wg2 sync.WaitGroup |
| 573 | dctx2, cancel2 := context.WithDeadline(context.Background(), deadline) |
| 574 | wg2.Add(1) |
| 575 | // Removal of the gem id mapping represents the removal of the tech profile |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 576 | logger.Infow(ctx, "remove-techProfile-indication-in-kv", log.Fields{"device-id": dh.DeviceID, "uni-id": uniID, "tpID": tpID}) |
| 577 | go pDevEntry.UpdateOnuKvStore(log.WithSpanFromContext(dctx2, ctx), &wg2) |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 578 | dh.waitForCompletion(ctx, cancel2, &wg2, "TechProfileDeleteOn"+resourceName) //wait for background process to finish |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 579 | if err := pDevEntry.GetKvProcessingErrorIndication(); err != nil { |
| 580 | logger.Errorw(ctx, err.Error(), log.Fields{"device-id": dh.DeviceID}) |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 581 | return err |
| 582 | } |
| 583 | } |
| 584 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 585 | logger.Debugw(ctx, "delete-tech-profile-resource-completed", log.Fields{"device-id": dh.DeviceID, |
Mahir Gunyel | 9545be2 | 2021-07-04 15:53:16 -0700 | [diff] [blame] | 586 | "uni-id": uniID, "tpID": tpID, "resource-type": resourceName, "resource-id": entryID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 587 | return nil |
| 588 | } |
| 589 | |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 590 | //FlowUpdateIncremental removes and/or adds the flow changes on a given device |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 591 | func (dh *deviceHandler) FlowUpdateIncremental(ctx context.Context, |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 592 | apOfFlowChanges *of.FlowChanges, |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 593 | apOfGroupChanges *of.FlowGroupChanges, apFlowMetaData *of.FlowMetadata) error { |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 594 | logger.Debugw(ctx, "FlowUpdateIncremental started", log.Fields{"device-id": dh.DeviceID, "flow": apOfFlowChanges, "metadata": apFlowMetaData}) |
| 595 | var errorsList []error |
| 596 | var retError error |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 597 | //Remove flows (always remove flows first - remove old and add new with same cookie may be part of the same request) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 598 | if apOfFlowChanges.ToRemove != nil { |
| 599 | for _, flowItem := range apOfFlowChanges.ToRemove.Items { |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 600 | if flowItem.GetCookie() == 0 { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 601 | logger.Warnw(ctx, "flow-remove no cookie: ignore and continuing on checking further flows", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 602 | "device-id": dh.DeviceID}) |
| 603 | retError = fmt.Errorf("flow-remove no cookie, device-id %s", dh.DeviceID) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 604 | errorsList = append(errorsList, retError) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 605 | continue |
| 606 | } |
| 607 | flowInPort := flow.GetInPort(flowItem) |
| 608 | if flowInPort == uint32(of.OfpPortNo_OFPP_INVALID) { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 609 | logger.Warnw(ctx, "flow-remove inPort invalid: ignore and continuing on checking further flows", log.Fields{"device-id": dh.DeviceID}) |
| 610 | retError = fmt.Errorf("flow-remove inPort invalid, device-id %s", dh.DeviceID) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 611 | errorsList = append(errorsList, retError) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 612 | continue |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 613 | //return fmt.Errorf("flow inPort invalid: %s", dh.DeviceID) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 614 | } else if flowInPort == dh.ponPortNumber { |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 615 | //this is some downstream flow, not regarded as error, just ignored |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 616 | logger.Debugw(ctx, "flow-remove for downstream: ignore and continuing on checking further flows", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 617 | "device-id": dh.DeviceID, "inPort": flowInPort}) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 618 | continue |
| 619 | } else { |
| 620 | // this is the relevant upstream flow |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 621 | var loUniPort *cmn.OnuUniPort |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 622 | if uniPort, exist := dh.uniEntityMap[flowInPort]; exist { |
| 623 | loUniPort = uniPort |
| 624 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 625 | logger.Warnw(ctx, "flow-remove inPort not found in UniPorts: ignore and continuing on checking further flows", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 626 | log.Fields{"device-id": dh.DeviceID, "inPort": flowInPort}) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 627 | retError = fmt.Errorf("flow-remove inPort not found in UniPorts, inPort %d, device-id %s", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 628 | flowInPort, dh.DeviceID) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 629 | errorsList = append(errorsList, retError) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 630 | continue |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 631 | } |
| 632 | flowOutPort := flow.GetOutPort(flowItem) |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 633 | logger.Debugw(ctx, "flow-remove port indications", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 634 | "device-id": dh.DeviceID, "inPort": flowInPort, "outPort": flowOutPort, |
| 635 | "uniPortName": loUniPort.Name}) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 636 | |
| 637 | if dh.GetFlowMonitoringIsRunning(loUniPort.UniID) { |
| 638 | // Step1 : Fill flowControlBlock |
| 639 | // Step2 : Push the flowControlBlock to ONU channel |
| 640 | // Step3 : Wait on response channel for response |
| 641 | // Step4 : Return error value |
| 642 | startTime := time.Now() |
| 643 | respChan := make(chan error) |
| 644 | flowCb := FlowCb{ |
| 645 | ctx: ctx, |
| 646 | addFlow: false, |
| 647 | flowItem: flowItem, |
| 648 | flowMetaData: nil, |
| 649 | uniPort: loUniPort, |
| 650 | respChan: &respChan, |
| 651 | } |
| 652 | dh.flowCbChan[loUniPort.UniID] <- flowCb |
| 653 | logger.Infow(ctx, "process-flow-remove-start", log.Fields{"device-id": dh.DeviceID}) |
| 654 | // Wait on the channel for flow handlers return value |
| 655 | retError = <-respChan |
| 656 | logger.Infow(ctx, "process-flow-remove-end", log.Fields{"device-id": dh.DeviceID, "err": retError, "totalTimeSeconds": time.Since(startTime).Seconds()}) |
| 657 | if retError != nil { |
| 658 | logger.Warnw(ctx, "flow-delete processing error: continuing on checking further flows", |
| 659 | log.Fields{"device-id": dh.DeviceID, "error": retError}) |
| 660 | errorsList = append(errorsList, retError) |
| 661 | continue |
| 662 | } |
| 663 | } else { |
| 664 | retError = fmt.Errorf("flow-handler-routine-not-active-for-onu--device-id-%v", dh.DeviceID) |
| 665 | errorsList = append(errorsList, retError) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 666 | } |
| 667 | } |
| 668 | } |
| 669 | } |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 670 | if apOfFlowChanges.ToAdd != nil { |
| 671 | for _, flowItem := range apOfFlowChanges.ToAdd.Items { |
| 672 | if flowItem.GetCookie() == 0 { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 673 | logger.Debugw(ctx, "incremental flow-add no cookie: ignore and continuing on checking further flows", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 674 | "device-id": dh.DeviceID}) |
| 675 | retError = fmt.Errorf("flow-add no cookie, device-id %s", dh.DeviceID) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 676 | errorsList = append(errorsList, retError) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 677 | continue |
| 678 | } |
| 679 | flowInPort := flow.GetInPort(flowItem) |
| 680 | if flowInPort == uint32(of.OfpPortNo_OFPP_INVALID) { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 681 | logger.Warnw(ctx, "flow-add inPort invalid: ignore and continuing on checking further flows", log.Fields{"device-id": dh.DeviceID}) |
| 682 | retError = fmt.Errorf("flow-add inPort invalid, device-id %s", dh.DeviceID) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 683 | errorsList = append(errorsList, retError) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 684 | continue |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 685 | //return fmt.Errorf("flow inPort invalid: %s", dh.DeviceID) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 686 | } else if flowInPort == dh.ponPortNumber { |
| 687 | //this is some downstream flow |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 688 | logger.Debugw(ctx, "flow-add for downstream: ignore and continuing on checking further flows", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 689 | "device-id": dh.DeviceID, "inPort": flowInPort}) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 690 | continue |
| 691 | } else { |
| 692 | // this is the relevant upstream flow |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 693 | var loUniPort *cmn.OnuUniPort |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 694 | if uniPort, exist := dh.uniEntityMap[flowInPort]; exist { |
| 695 | loUniPort = uniPort |
| 696 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 697 | logger.Warnw(ctx, "flow-add inPort not found in UniPorts: ignore and continuing on checking further flows", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 698 | log.Fields{"device-id": dh.DeviceID, "inPort": flowInPort}) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 699 | retError = fmt.Errorf("flow-add inPort not found in UniPorts, inPort %d, device-id %s", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 700 | flowInPort, dh.DeviceID) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 701 | errorsList = append(errorsList, retError) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 702 | continue |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 703 | } |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 704 | // let's still assume that we receive the flow-add only in some 'active' device state (as so far observed) |
| 705 | // if not, we just throw some error here to have an indication about that, if we really need to support that |
| 706 | // then we would need to create some means to activate the internal stored flows |
| 707 | // after the device gets active automatically (and still with its dependency to the TechProfile) |
| 708 | // for state checking compare also code here: processInterAdapterTechProfileDownloadReqMessage |
| 709 | // also abort for the other still possible flows here |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 710 | if !dh.IsReadyForOmciConfig() { |
| 711 | logger.Errorw(ctx, "flow-add rejected: improper device state", log.Fields{"device-id": dh.DeviceID, |
| 712 | "last device-reason": dh.GetDeviceReasonString()}) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 713 | retError = fmt.Errorf("improper device state on device %s", dh.DeviceID) |
| 714 | errorsList = append(errorsList, retError) |
| 715 | continue |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 716 | } |
| 717 | |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 718 | flowOutPort := flow.GetOutPort(flowItem) |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 719 | logger.Debugw(ctx, "flow-add port indications", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 720 | "device-id": dh.DeviceID, "inPort": flowInPort, "outPort": flowOutPort, |
| 721 | "uniPortName": loUniPort.Name}) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 722 | if dh.GetFlowMonitoringIsRunning(loUniPort.UniID) { |
| 723 | // Step1 : Fill flowControlBlock |
| 724 | // Step2 : Push the flowControlBlock to ONU channel |
| 725 | // Step3 : Wait on response channel for response |
| 726 | // Step4 : Return error value |
| 727 | startTime := time.Now() |
| 728 | respChan := make(chan error) |
| 729 | flowCb := FlowCb{ |
| 730 | ctx: ctx, |
| 731 | addFlow: true, |
| 732 | flowItem: flowItem, |
| 733 | flowMetaData: apFlowMetaData, |
| 734 | uniPort: loUniPort, |
| 735 | respChan: &respChan, |
| 736 | } |
| 737 | dh.flowCbChan[loUniPort.UniID] <- flowCb |
| 738 | logger.Infow(ctx, "process-flow-add-start", log.Fields{"device-id": dh.DeviceID}) |
| 739 | // Wait on the channel for flow handlers return value |
| 740 | retError = <-respChan |
| 741 | logger.Infow(ctx, "process-flow-add-end", log.Fields{"device-id": dh.DeviceID, "err": retError, "totalTimeSeconds": time.Since(startTime).Seconds()}) |
| 742 | if retError != nil { |
| 743 | logger.Warnw(ctx, "flow-add processing error: continuing on checking further flows", |
| 744 | log.Fields{"device-id": dh.DeviceID, "error": retError}) |
| 745 | errorsList = append(errorsList, retError) |
| 746 | continue |
| 747 | } |
| 748 | } else { |
| 749 | retError = fmt.Errorf("flow-handler-routine-not-active-for-onu--device-id-%v", dh.DeviceID) |
| 750 | errorsList = append(errorsList, retError) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 751 | } |
| 752 | } |
| 753 | } |
| 754 | } |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 755 | if len(errorsList) > 0 { |
| 756 | logger.Errorw(ctx, "error-processing-flow", log.Fields{"device-id": dh.DeviceID, "errList": errorsList}) |
| 757 | return fmt.Errorf("errors-installing-one-or-more-flows-groups, errors:%v", errorsList) |
| 758 | } |
| 759 | return nil |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 760 | } |
| 761 | |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 762 | //disableDevice locks the ONU and its UNI/VEIP ports (admin lock via OMCI) |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 763 | //following are the expected device states after this activity: |
| 764 | //Device Admin-State : down (on rwCore), Port-State: UNKNOWN, Conn-State: REACHABLE, Reason: omci-admin-lock |
| 765 | // (Conn-State: REACHABLE might conflict with some previous ONU Down indication - maybe to be resolved later) |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 766 | func (dh *deviceHandler) disableDevice(ctx context.Context, device *voltha.Device) { |
| 767 | logger.Debugw(ctx, "disable-device", log.Fields{"device-id": device.Id, "SerialNumber": device.SerialNumber}) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 768 | |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 769 | //admin-lock reason can also be used uniquely for setting the DeviceState accordingly |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 770 | //note that disableDevice sequences in some 'ONU active' state may yield also |
| 771 | // "tech...delete-success" or "omci-flow-deleted" according to further received requests in the end |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 772 | // - inblock state checking to prevent possibly unneeded processing (on command repitition) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 773 | if dh.getDeviceReason() != cmn.DrOmciAdminLock { |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 774 | //disable-device shall be just a UNi/ONU-G related admin state setting |
| 775 | //all other configurations/FSM's shall not be impacted and shall execute as required by the system |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 776 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 777 | if dh.IsReadyForOmciConfig() { |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 778 | // disable UNI ports/ONU |
| 779 | // *** should generate UniDisableStateDone event - used to disable the port(s) on success |
| 780 | if dh.pLockStateFsm == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 781 | dh.createUniLockFsm(ctx, true, cmn.UniDisableStateDone) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 782 | } else { //LockStateFSM already init |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 783 | dh.pLockStateFsm.SetSuccessEvent(cmn.UniDisableStateDone) |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 784 | dh.runUniLockFsm(ctx, true) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 785 | } |
| 786 | } else { |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 787 | logger.Debugw(ctx, "DeviceStateUpdate upon disable", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 788 | "OperStatus": voltha.OperStatus_UNKNOWN, "device-id": dh.DeviceID}) |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 789 | // disable device should have no impact on ConnStatus |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 790 | if err := dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 791 | DeviceId: dh.DeviceID, |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 792 | ConnStatus: connectStatusINVALID, //use some dummy value to prevent modification of the ConnStatus |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 793 | OperStatus: voltha.OperStatus_UNKNOWN, |
| 794 | }); err != nil { |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 795 | //TODO with VOL-3045/VOL-3046: return the error and stop further processing |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 796 | logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err}) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 797 | } |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 798 | // DeviceReason to update acc.to modified py code as per beginning of Sept 2020 |
Holger Hildebrandt | 80129db | 2020-11-23 10:49:32 +0000 | [diff] [blame] | 799 | |
| 800 | //TODO with VOL-3045/VOL-3046: catch and return error, valid for all occurrences in the codebase |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 801 | _ = dh.ReasonUpdate(ctx, cmn.DrOmciAdminLock, true) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 802 | } |
ozgecanetsia | fce57b1 | 2020-05-25 14:39:35 +0300 | [diff] [blame] | 803 | } |
| 804 | } |
| 805 | |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 806 | //reEnableDevice unlocks the ONU and its UNI/VEIP ports (admin unlock via OMCI) |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 807 | func (dh *deviceHandler) reEnableDevice(ctx context.Context, device *voltha.Device) { |
| 808 | logger.Debugw(ctx, "reenable-device", log.Fields{"device-id": device.Id, "SerialNumber": device.SerialNumber}) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 809 | |
mpagenko | aa3afe9 | 2021-05-21 16:20:58 +0000 | [diff] [blame] | 810 | //setting readyForOmciConfig here is just a workaround for BBSIM testing in the sequence |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 811 | // OnuSoftReboot-disable-enable, because BBSIM does not generate a new OnuIndication-Up event after SoftReboot |
| 812 | // which is the assumption for real ONU's, where the ready-state is then set according to the following MibUpload/Download |
| 813 | // for real ONU's that should have nearly no influence |
| 814 | // Note that for real ONU's there is anyway a problematic situation with following sequence: |
| 815 | // OnuIndication-Dw (or not active at all) (- disable) - enable: here already the LockFsm may run into timeout (no OmciResponse) |
| 816 | // but that anyway is hopefully resolved by some OnuIndication-Up event (maybe to be tested) |
| 817 | // one could also argue, that a device-enable should also enable attempts for specific omci configuration |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 818 | dh.SetReadyForOmciConfig(true) //needed to allow subsequent flow/techProf config (on BBSIM) |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 819 | |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 820 | // enable ONU/UNI ports |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 821 | // *** should generate cmn.UniEnableStateDone event - used to disable the port(s) on success |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 822 | if dh.pUnlockStateFsm == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 823 | dh.createUniLockFsm(ctx, false, cmn.UniEnableStateDone) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 824 | } else { //UnlockStateFSM already init |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 825 | dh.pUnlockStateFsm.SetSuccessEvent(cmn.UniEnableStateDone) |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 826 | dh.runUniLockFsm(ctx, false) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 827 | } |
ozgecanetsia | fce57b1 | 2020-05-25 14:39:35 +0300 | [diff] [blame] | 828 | } |
| 829 | |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 830 | func (dh *deviceHandler) reconcileDeviceOnuInd(ctx context.Context) { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 831 | logger.Debugw(ctx, "reconciling - simulate onu indication", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 832 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 833 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 834 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 835 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 836 | return |
| 837 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 838 | if err := pDevEntry.RestoreDataFromOnuKvStore(log.WithSpanFromContext(context.TODO(), ctx)); err != nil { |
mpagenko | 2418ab0 | 2020-11-12 12:58:06 +0000 | [diff] [blame] | 839 | if err == fmt.Errorf("no-ONU-data-found") { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 840 | logger.Debugw(ctx, "no persistent data found - abort reconciling", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 2418ab0 | 2020-11-12 12:58:06 +0000 | [diff] [blame] | 841 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 842 | logger.Errorw(ctx, "reconciling - restoring OnuTp-data failed - abort", log.Fields{"err": err, "device-id": dh.DeviceID}) |
mpagenko | 2418ab0 | 2020-11-12 12:58:06 +0000 | [diff] [blame] | 843 | } |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 844 | dh.stopReconciling(ctx, false, cWaitReconcileFlowNoActivity) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 845 | return |
Holger Hildebrandt | 9ca8b13 | 2020-08-07 14:45:03 +0000 | [diff] [blame] | 846 | } |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 847 | var onuIndication oop.OnuIndication |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 848 | pDevEntry.MutexPersOnuConfig.RLock() |
| 849 | onuIndication.IntfId = pDevEntry.SOnuPersistentData.PersIntfID |
| 850 | onuIndication.OnuId = pDevEntry.SOnuPersistentData.PersOnuID |
| 851 | onuIndication.OperState = pDevEntry.SOnuPersistentData.PersOperState |
| 852 | onuIndication.AdminState = pDevEntry.SOnuPersistentData.PersAdminState |
| 853 | pDevEntry.MutexPersOnuConfig.RUnlock() |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 854 | _ = dh.createInterface(ctx, &onuIndication) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 855 | } |
| 856 | |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 857 | func (dh *deviceHandler) ReconcileDeviceTechProf(ctx context.Context) bool { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 858 | logger.Debugw(ctx, "reconciling - trigger tech profile config", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 859 | |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 860 | continueWithFlowConfig := false |
| 861 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 862 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 863 | if pDevEntry == nil { |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 864 | logger.Errorw(ctx, "reconciling - no valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 865 | dh.stopReconciling(ctx, false, cWaitReconcileFlowNoActivity) |
| 866 | return continueWithFlowConfig |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 867 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 868 | dh.pOnuTP.LockTpProcMutex() |
| 869 | defer dh.pOnuTP.UnlockTpProcMutex() |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 870 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 871 | pDevEntry.MutexPersOnuConfig.RLock() |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 872 | persMutexLock := true |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 873 | if len(pDevEntry.SOnuPersistentData.PersUniConfig) == 0 { |
| 874 | pDevEntry.MutexPersOnuConfig.RUnlock() |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 875 | logger.Debugw(ctx, "reconciling - no uni-configs have been stored before adapter restart - terminate reconcilement", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 876 | log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 877 | dh.stopReconciling(ctx, true, cWaitReconcileFlowNoActivity) |
| 878 | return continueWithFlowConfig |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 879 | } |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 880 | flowsFound := false |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 881 | techProfsFound := false |
| 882 | techProfInstLoadFailed := false |
| 883 | outerLoop: |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 884 | for _, uniData := range pDevEntry.SOnuPersistentData.PersUniConfig { |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 885 | uniID := uniData.PersUniID |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 886 | //TODO: check for uni-port specific reconcilement in case of multi-uni-port-per-onu-support |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 887 | if !dh.anyTpPathExists(uniData.PersTpPathMap) { |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 888 | logger.Debugw(ctx, "reconciling - no TPs stored for uniID", |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 889 | log.Fields{"uni-id": uniID, "device-id": dh.DeviceID}) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 890 | continue |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 891 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 892 | //release MutexPersOnuConfig before TechProfile (ANIConfig) processing as otherwise the reception of |
| 893 | // OMCI frames may get completely stuck due to lock request within IncrementMibDataSync() at OMCI |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 894 | // frame reception may also lock the complete OMCI reception processing based on mutexRxSchedMap |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 895 | pDevEntry.MutexPersOnuConfig.RUnlock() |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 896 | persMutexLock = false |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 897 | techProfsFound = true // set to true if we found TP once for any UNI port |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 898 | var iaTechTpInst ia.TechProfileDownloadMessage |
| 899 | var ok bool |
Girish Gowdra | 041dcb3 | 2020-11-16 16:54:30 -0800 | [diff] [blame] | 900 | for tpID := range uniData.PersTpPathMap { |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 901 | pDevEntry.MutexReconciledTpInstances.RLock() |
| 902 | if iaTechTpInst, ok = pDevEntry.ReconciledTpInstances[uniID][tpID]; !ok { |
| 903 | logger.Errorw(ctx, "reconciling - no reconciled tp instance available", |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 904 | log.Fields{"tp-id": tpID, "tpPath": uniData.PersTpPathMap[tpID], "uni-id": uniData.PersUniID, |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 905 | "device-id": dh.DeviceID}) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 906 | techProfInstLoadFailed = true // stop loading tp instance as soon as we hit failure |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 907 | pDevEntry.MutexReconciledTpInstances.RUnlock() |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 908 | break outerLoop |
| 909 | } |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 910 | pDevEntry.MutexReconciledTpInstances.RUnlock() |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 911 | continueWithFlowConfig = true // valid TP found - try flow configuration later |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 912 | var tpInst tech_profile.TechProfileInstance |
| 913 | switch techTpInst := iaTechTpInst.TechTpInstance.(type) { |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 914 | case *ia.TechProfileDownloadMessage_TpInstance: // supports only GPON, XGPON, XGS-PON |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 915 | tpInst = *techTpInst.TpInstance |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 916 | logger.Debugw(ctx, "reconciling - received-tp-instance-successfully-after-reconcile", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 917 | "tp-id": tpID, "tpPath": uniData.PersTpPathMap[tpID], "uni-id": uniData.PersUniID, "device-id": dh.DeviceID}) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 918 | default: // do not support epon or other tech |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 919 | logger.Errorw(ctx, "reconciling - unsupported-tech-profile", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 920 | "tp-id": tpID, "tpPath": uniData.PersTpPathMap[tpID], "uni-id": uniData.PersUniID, "device-id": dh.DeviceID}) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 921 | techProfInstLoadFailed = true // stop loading tp instance as soon as we hit failure |
| 922 | break outerLoop |
| 923 | } |
| 924 | |
Girish Gowdra | 041dcb3 | 2020-11-16 16:54:30 -0800 | [diff] [blame] | 925 | // deadline context to ensure completion of background routines waited for |
| 926 | //20200721: 10s proved to be less in 8*8 ONU test on local vbox machine with debug, might be further adapted |
| 927 | deadline := time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 928 | dctx, cancel := context.WithDeadline(ctx, deadline) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 929 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 930 | dh.pOnuTP.ResetTpProcessingErrorIndication(uniData.PersUniID, tpID) |
Girish Gowdra | 041dcb3 | 2020-11-16 16:54:30 -0800 | [diff] [blame] | 931 | var wg sync.WaitGroup |
| 932 | wg.Add(1) // for the 1 go routine to finish |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 933 | go dh.pOnuTP.ConfigureUniTp(log.WithSpanFromContext(dctx, ctx), uniData.PersUniID, uniData.PersTpPathMap[tpID], tpInst, &wg) |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 934 | dh.waitForCompletion(ctx, cancel, &wg, "TechProfReconcile") //wait for background process to finish |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 935 | if err := dh.pOnuTP.GetTpProcessingErrorIndication(uniData.PersUniID, tpID); err != nil { |
| 936 | logger.Errorw(ctx, err.Error(), log.Fields{"device-id": dh.DeviceID}) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 937 | techProfInstLoadFailed = true // stop loading tp instance as soon as we hit failure |
| 938 | break outerLoop |
Girish Gowdra | 041dcb3 | 2020-11-16 16:54:30 -0800 | [diff] [blame] | 939 | } |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 940 | } // for all TpPath entries for this UNI |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 941 | if len(uniData.PersFlowParams) != 0 { |
| 942 | flowsFound = true |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 943 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 944 | pDevEntry.MutexPersOnuConfig.RLock() //set protection again for loop test on SOnuPersistentData |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 945 | persMutexLock = true |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 946 | } // for all UNI entries from SOnuPersistentData |
| 947 | if persMutexLock { // if loop was left with MutexPersOnuConfig still set |
| 948 | pDevEntry.MutexPersOnuConfig.RUnlock() |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 949 | } |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 950 | |
| 951 | //had to move techProf/flow result evaluation into separate function due to SCA complexity limit |
| 952 | dh.updateReconcileStates(ctx, techProfsFound, techProfInstLoadFailed, flowsFound) |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 953 | |
| 954 | return continueWithFlowConfig |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 955 | } |
| 956 | |
| 957 | func (dh *deviceHandler) updateReconcileStates(ctx context.Context, |
| 958 | abTechProfsFound bool, abTechProfInstLoadFailed bool, abFlowsFound bool) { |
| 959 | if !abTechProfsFound { |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 960 | logger.Debugw(ctx, "reconciling - no TPs have been stored before adapter restart - terminate reconcilement", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 961 | log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 962 | dh.stopReconciling(ctx, true, cWaitReconcileFlowNoActivity) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 963 | return |
| 964 | } |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 965 | if abTechProfInstLoadFailed { |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 966 | _ = dh.ReasonUpdate(ctx, cmn.DrTechProfileConfigDownloadFailed, dh.IsReconcilingReasonUpdate()) |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 967 | dh.stopReconciling(ctx, false, cWaitReconcileFlowNoActivity) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 968 | return |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 969 | } else if dh.IsSkipOnuConfigReconciling() { |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 970 | _ = dh.ReasonUpdate(ctx, cmn.DrTechProfileConfigDownloadSuccess, dh.IsReconcilingReasonUpdate()) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 971 | } |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 972 | if !abFlowsFound { |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 973 | logger.Debugw(ctx, "reconciling - no flows have been stored before adapter restart - terminate reconcilement", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 974 | log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 975 | dh.stopReconciling(ctx, true, cWaitReconcileFlowNoActivity) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 976 | } |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 977 | } |
| 978 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 979 | func (dh *deviceHandler) ReconcileDeviceFlowConfig(ctx context.Context) { |
| 980 | logger.Debugw(ctx, "reconciling - trigger flow config", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 981 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 982 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 983 | if pDevEntry == nil { |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 984 | logger.Errorw(ctx, "reconciling - no valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 985 | dh.stopReconciling(ctx, false, cWaitReconcileFlowNoActivity) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 986 | return |
| 987 | } |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 988 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 989 | pDevEntry.MutexPersOnuConfig.RLock() |
| 990 | if len(pDevEntry.SOnuPersistentData.PersUniConfig) == 0 { |
| 991 | pDevEntry.MutexPersOnuConfig.RUnlock() |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 992 | logger.Debugw(ctx, "reconciling - no uni-configs have been stored before adapter restart - terminate reconcilement", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 993 | log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 994 | dh.stopReconciling(ctx, true, cWaitReconcileFlowNoActivity) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 995 | return |
| 996 | } |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 997 | flowsFound := false |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 998 | var uniVlanConfigEntries []uint8 |
| 999 | var loWaitGroupWTO cmn.WaitGroupWithTimeOut |
| 1000 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1001 | for _, uniData := range pDevEntry.SOnuPersistentData.PersUniConfig { |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 1002 | //TODO: check for uni-port specific reconcilement in case of multi-uni-port-per-onu-support |
| 1003 | if len(uniData.PersFlowParams) == 0 { |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 1004 | logger.Debugw(ctx, "reconciling - no flows stored for uniID", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1005 | log.Fields{"uni-id": uniData.PersUniID, "device-id": dh.DeviceID}) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 1006 | continue |
| 1007 | } |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 1008 | if !dh.anyTpPathExists(uniData.PersTpPathMap) { |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 1009 | logger.Warnw(ctx, "reconciling flows - but no TPs stored for uniID, abort", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1010 | log.Fields{"uni-id": uniData.PersUniID, "device-id": dh.DeviceID}) |
Holger Hildebrandt | 7e9de86 | 2021-03-26 14:01:49 +0000 | [diff] [blame] | 1011 | // It doesn't make sense to configure any flows if no TPs are available |
| 1012 | continue |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 1013 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1014 | //release MutexPersOnuConfig before VlanConfig processing as otherwise the reception of |
| 1015 | // OMCI frames may get completely stuck due to lock request within IncrementMibDataSync() at OMCI |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 1016 | // frame reception may also lock the complete OMCI reception processing based on mutexRxSchedMap |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1017 | pDevEntry.MutexPersOnuConfig.RUnlock() |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 1018 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1019 | var uniPort *cmn.OnuUniPort |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 1020 | var exist bool |
Mahir Gunyel | cb128ae | 2021-10-06 09:42:05 -0700 | [diff] [blame] | 1021 | uniNo := platform.MkUniPortNum(ctx, dh.pOnuIndication.GetIntfId(), dh.pOnuIndication.GetOnuId(), uint32(uniData.PersUniID)) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 1022 | if uniPort, exist = dh.uniEntityMap[uniNo]; !exist { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1023 | logger.Errorw(ctx, "reconciling - OnuUniPort data not found - terminate reconcilement", |
| 1024 | log.Fields{"uniNo": uniNo, "device-id": dh.DeviceID}) |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 1025 | dh.stopReconciling(ctx, false, cWaitReconcileFlowNoActivity) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 1026 | return |
| 1027 | } |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 1028 | //needed to split up function due to sca complexity |
| 1029 | dh.updateReconcileFlowConfig(ctx, uniPort, uniData.PersFlowParams, uniVlanConfigEntries, &loWaitGroupWTO, &flowsFound) |
| 1030 | |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 1031 | logger.Debugw(ctx, "reconciling - flows processed", log.Fields{ |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 1032 | "device-id": dh.DeviceID, "uni-id": uniData.PersUniID, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1033 | "NumUniFlows": dh.UniVlanConfigFsmMap[uniData.PersUniID].NumUniFlows, |
| 1034 | "ConfiguredUniFlow": dh.UniVlanConfigFsmMap[uniData.PersUniID].ConfiguredUniFlow}) |
Andrea Campanella | f66ac6e | 2021-05-24 17:09:20 +0200 | [diff] [blame] | 1035 | // this can't be used as global finished reconciling flag because |
| 1036 | // assumes is getting called before the state machines for the last flow is completed, |
| 1037 | // while this is not guaranteed. |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1038 | pDevEntry.MutexPersOnuConfig.RLock() //set protection again for loop test on SOnuPersistentData |
| 1039 | } // for all UNI entries from SOnuPersistentData |
| 1040 | pDevEntry.MutexPersOnuConfig.RUnlock() |
mpagenko | 2dc896e | 2021-08-02 12:03:59 +0000 | [diff] [blame] | 1041 | |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 1042 | if !flowsFound { |
| 1043 | logger.Debugw(ctx, "reconciling - no flows have been stored before adapter restart - terminate reconcilement", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1044 | log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 1045 | dh.stopReconciling(ctx, true, cWaitReconcileFlowNoActivity) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 1046 | return |
| 1047 | } |
Holger Hildebrandt | 7741f27 | 2022-01-18 08:17:39 +0000 | [diff] [blame^] | 1048 | logger.Debugw(ctx, "reconciling flows - waiting on ready indication of requested UNIs", log.Fields{ |
| 1049 | "device-id": dh.DeviceID, "expiry": dh.reconcileExpiryVlanConfig}) |
| 1050 | if executed := loWaitGroupWTO.WaitTimeout(dh.reconcileExpiryVlanConfig); executed { |
| 1051 | logger.Debugw(ctx, "reconciling flows for all UNI's has been finished in time", |
| 1052 | log.Fields{"device-id": dh.DeviceID}) |
| 1053 | dh.stopReconciling(ctx, true, cWaitReconcileFlowAbortOnSuccess) |
| 1054 | if pDevEntry != nil { |
| 1055 | pDevEntry.SendChReconcilingFlowsFinished(ctx, true) |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 1056 | } |
Holger Hildebrandt | 7741f27 | 2022-01-18 08:17:39 +0000 | [diff] [blame^] | 1057 | } else { |
| 1058 | logger.Errorw(ctx, "reconciling - timeout waiting for reconciling flows for all UNI's to be finished!", |
| 1059 | log.Fields{"device-id": dh.DeviceID}) |
| 1060 | dh.stopReconciling(ctx, false, cWaitReconcileFlowAbortOnError) |
| 1061 | if pDevEntry != nil { |
| 1062 | pDevEntry.SendChReconcilingFlowsFinished(ctx, false) |
| 1063 | } |
| 1064 | return |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 1065 | } |
Holger Hildebrandt | 7741f27 | 2022-01-18 08:17:39 +0000 | [diff] [blame^] | 1066 | _ = dh.ReasonUpdate(ctx, cmn.DrOmciFlowsPushed, dh.IsReconcilingReasonUpdate()) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 1067 | } |
| 1068 | |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 1069 | func (dh *deviceHandler) updateReconcileFlowConfig(ctx context.Context, apUniPort *cmn.OnuUniPort, |
| 1070 | aPersFlowParam []cmn.UniVlanFlowParams, aUniVlanConfigEntries []uint8, |
| 1071 | apWaitGroup *cmn.WaitGroupWithTimeOut, apFlowsFound *bool) { |
| 1072 | flowsProcessed := 0 |
| 1073 | lastFlowToReconcile := false |
| 1074 | loUniID := apUniPort.UniID |
| 1075 | for _, flowData := range aPersFlowParam { |
Holger Hildebrandt | 7741f27 | 2022-01-18 08:17:39 +0000 | [diff] [blame^] | 1076 | if !(*apFlowsFound) { |
| 1077 | *apFlowsFound = true |
| 1078 | syncChannel := make(chan struct{}) |
| 1079 | // start go routine with select() on reconciling vlan config channel before |
| 1080 | // starting vlan config reconciling process to prevent loss of any signal |
| 1081 | // this routine just collects all the received 'flow-reconciled' signals - possibly from different UNI's |
| 1082 | go dh.waitOnUniVlanConfigReconcilingReady(ctx, syncChannel, apWaitGroup) |
| 1083 | //block until the wait routine is really blocked on channel input |
| 1084 | // in order to prevent to early ready signal from VlanConfig processing |
| 1085 | <-syncChannel |
| 1086 | } |
| 1087 | if flowsProcessed == len(aPersFlowParam)-1 { |
| 1088 | var uniAdded bool |
| 1089 | lastFlowToReconcile = true |
| 1090 | if aUniVlanConfigEntries, uniAdded = dh.appendIfMissing(aUniVlanConfigEntries, loUniID); uniAdded { |
| 1091 | apWaitGroup.Add(1) //increment the waiting group |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 1092 | } |
| 1093 | } |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 1094 | logger.Debugw(ctx, "reconciling - add flow with cookie slice", log.Fields{ |
| 1095 | "device-id": dh.DeviceID, "uni-id": loUniID, |
| 1096 | "flowsProcessed": flowsProcessed, "cookies": flowData.CookieSlice}) |
| 1097 | dh.lockVlanConfig.Lock() |
| 1098 | //the CookieSlice can be passed 'by value' here, - which internally passes its reference |
| 1099 | if _, exist := dh.UniVlanConfigFsmMap[loUniID]; exist { |
| 1100 | if err := dh.UniVlanConfigFsmMap[loUniID].SetUniFlowParams(ctx, flowData.VlanRuleParams.TpID, |
| 1101 | flowData.CookieSlice, uint16(flowData.VlanRuleParams.MatchVid), uint16(flowData.VlanRuleParams.SetVid), |
| 1102 | uint8(flowData.VlanRuleParams.SetPcp), lastFlowToReconcile, flowData.Meter, nil); err != nil { |
| 1103 | logger.Errorw(ctx, err.Error(), log.Fields{"device-id": dh.DeviceID}) |
| 1104 | } |
| 1105 | } else { |
| 1106 | if err := dh.createVlanFilterFsm(ctx, apUniPort, flowData.VlanRuleParams.TpID, flowData.CookieSlice, |
| 1107 | uint16(flowData.VlanRuleParams.MatchVid), uint16(flowData.VlanRuleParams.SetVid), |
| 1108 | uint8(flowData.VlanRuleParams.SetPcp), cmn.OmciVlanFilterAddDone, lastFlowToReconcile, flowData.Meter, nil); err != nil { |
| 1109 | logger.Errorw(ctx, err.Error(), log.Fields{"device-id": dh.DeviceID}) |
| 1110 | } |
| 1111 | } |
| 1112 | dh.lockVlanConfig.Unlock() |
| 1113 | flowsProcessed++ |
| 1114 | } //for all flows of this UNI |
| 1115 | } |
| 1116 | |
| 1117 | //waitOnUniVlanConfigReconcilingReady collects all VlanConfigReady signals from VlanConfig FSM processing in reconciling |
| 1118 | // and decrements the according handler wait group waiting for these indications |
| 1119 | func (dh *deviceHandler) waitOnUniVlanConfigReconcilingReady(ctx context.Context, aSyncChannel chan<- struct{}, |
| 1120 | waitGroup *cmn.WaitGroupWithTimeOut) { |
| 1121 | var reconciledUniVlanConfigEntries []uint8 |
| 1122 | var appended bool |
| 1123 | expiry := dh.GetReconcileExpiryVlanConfigAbort() |
| 1124 | logger.Debugw(ctx, "start waiting on reconcile vlanConfig ready indications", log.Fields{ |
| 1125 | "device-id": dh.DeviceID, "expiry": expiry}) |
| 1126 | // indicate blocking on channel now to the caller |
| 1127 | aSyncChannel <- struct{}{} |
| 1128 | for { |
| 1129 | select { |
| 1130 | case uniIndication := <-dh.chUniVlanConfigReconcilingDone: |
| 1131 | switch uniIndication { |
| 1132 | // no activity requested (should normally not be received) - just continue waiting |
| 1133 | case cWaitReconcileFlowNoActivity: |
| 1134 | // waiting on channel inputs from VlanConfig for all UNI's to be aborted on error condition |
| 1135 | case cWaitReconcileFlowAbortOnError: |
| 1136 | logger.Debugw(ctx, "waitReconcileFlow aborted on error", |
| 1137 | log.Fields{"device-id": dh.DeviceID, "rxEntries": reconciledUniVlanConfigEntries}) |
| 1138 | return |
| 1139 | // waiting on channel inputs from VlanConfig for all UNI's to be aborted on success condition |
| 1140 | case cWaitReconcileFlowAbortOnSuccess: |
| 1141 | logger.Debugw(ctx, "waitReconcileFlow aborted on success", |
| 1142 | log.Fields{"device-id": dh.DeviceID, "rxEntries": reconciledUniVlanConfigEntries}) |
| 1143 | return |
| 1144 | // this should be a valid UNI vlan config done indication |
| 1145 | default: |
| 1146 | if uniIndication < platform.MaxUnisPerOnu { |
| 1147 | logger.Debugw(ctx, "reconciling flows has been finished in time for this UNI", |
| 1148 | log.Fields{"device-id": dh.DeviceID, "uni-id": uniIndication}) |
| 1149 | if reconciledUniVlanConfigEntries, appended = |
| 1150 | dh.appendIfMissing(reconciledUniVlanConfigEntries, uint8(uniIndication)); appended { |
| 1151 | waitGroup.Done() |
| 1152 | } |
| 1153 | } else { |
| 1154 | logger.Errorw(ctx, "received unexpected UNI flowConfig done indication - is ignored", |
| 1155 | log.Fields{"device-id": dh.DeviceID, "uni-id": uniIndication}) |
| 1156 | } |
| 1157 | } //switch uniIndication |
| 1158 | |
| 1159 | case <-time.After(expiry): //a bit longer than reconcileExpiryVlanConfig |
| 1160 | logger.Errorw(ctx, "timeout waiting for reconciling all UNI flows to be finished!", |
| 1161 | log.Fields{"device-id": dh.DeviceID}) |
| 1162 | return |
| 1163 | } |
| 1164 | } |
| 1165 | } |
| 1166 | |
| 1167 | func (dh *deviceHandler) GetReconcileExpiryVlanConfigAbort() time.Duration { |
| 1168 | return dh.reconcileExpiryVlanConfig + (500 * time.Millisecond) |
| 1169 | } |
| 1170 | |
| 1171 | func (dh *deviceHandler) appendIfMissing(slice []uint8, val uint8) ([]uint8, bool) { |
| 1172 | for _, ele := range slice { |
| 1173 | if ele == val { |
| 1174 | return slice, false |
| 1175 | } |
| 1176 | } |
| 1177 | return append(slice, val), true |
| 1178 | } |
| 1179 | |
| 1180 | // sendChReconcileFinished - sends true or false on reconcileFinish channel |
| 1181 | func (dh *deviceHandler) sendChReconcileFinished(success bool) { |
| 1182 | if dh != nil { //if the object still exists (might have been already deleted in background) |
| 1183 | //use asynchronous channel sending to avoid stucking on non-waiting receiver |
| 1184 | select { |
| 1185 | case dh.chReconcilingFinished <- success: |
| 1186 | default: |
| 1187 | } |
| 1188 | } |
| 1189 | } |
| 1190 | |
| 1191 | // SendChUniVlanConfigFinished - sends the Uni number on channel if the flow reconcilement for this UNI is finished |
| 1192 | func (dh *deviceHandler) SendChUniVlanConfigFinished(value uint16) { |
| 1193 | if dh != nil { //if the object still exists (might have been already deleted in background) |
| 1194 | //use asynchronous channel sending to avoid stucking on non-waiting receiver |
| 1195 | select { |
| 1196 | case dh.chUniVlanConfigReconcilingDone <- value: |
| 1197 | default: |
| 1198 | } |
| 1199 | } |
| 1200 | } |
| 1201 | |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1202 | func (dh *deviceHandler) deleteDevicePersistencyData(ctx context.Context) error { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1203 | logger.Debugw(ctx, "delete device persistency data", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 1204 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1205 | pDevEntry := dh.GetOnuDeviceEntry(ctx, false) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 1206 | if pDevEntry == nil { |
mpagenko | 2418ab0 | 2020-11-12 12:58:06 +0000 | [diff] [blame] | 1207 | //IfDevEntry does not exist here, no problem - no persistent data should have been stored |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1208 | logger.Debugw(ctx, "OnuDevice does not exist - nothing to delete", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 2418ab0 | 2020-11-12 12:58:06 +0000 | [diff] [blame] | 1209 | return nil |
Holger Hildebrandt | 9ca8b13 | 2020-08-07 14:45:03 +0000 | [diff] [blame] | 1210 | } |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 1211 | |
| 1212 | // deadline context to ensure completion of background routines waited for |
| 1213 | //20200721: 10s proved to be less in 8*8 ONU test on local vbox machine with debug, might be further adapted |
Himani Chawla | d96df18 | 2020-09-28 11:12:02 +0530 | [diff] [blame] | 1214 | deadline := time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1215 | dctx, cancel := context.WithDeadline(ctx, deadline) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 1216 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1217 | pDevEntry.ResetKvProcessingErrorIndication() |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 1218 | |
| 1219 | var wg sync.WaitGroup |
| 1220 | wg.Add(1) // for the 1 go routine to finish |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1221 | go pDevEntry.DeleteDataFromOnuKvStore(log.WithSpanFromContext(dctx, ctx), &wg) |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1222 | dh.waitForCompletion(ctx, cancel, &wg, "DeleteDevice") //wait for background process to finish |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 1223 | |
Holger Hildebrandt | 9ca8b13 | 2020-08-07 14:45:03 +0000 | [diff] [blame] | 1224 | // TODO: further actions - stop metrics and FSMs, remove device ... |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1225 | return pDevEntry.GetKvProcessingErrorIndication() |
Holger Hildebrandt | 9ca8b13 | 2020-08-07 14:45:03 +0000 | [diff] [blame] | 1226 | } |
| 1227 | |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1228 | //func (dh *deviceHandler) rebootDevice(ctx context.Context, device *voltha.Device) error { |
| 1229 | // before this change here return like this was used: |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1230 | // return fmt.Errorf("device-unreachable: %s, %s", dh.DeviceID, device.SerialNumber) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1231 | //was and is called in background - error return does not make sense |
| 1232 | func (dh *deviceHandler) rebootDevice(ctx context.Context, aCheckDeviceState bool, device *voltha.Device) { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1233 | logger.Infow(ctx, "reboot-device", log.Fields{"device-id": dh.DeviceID, "SerialNumber": dh.device.SerialNumber}) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1234 | if aCheckDeviceState && device.ConnectStatus != voltha.ConnectStatus_REACHABLE { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1235 | logger.Errorw(ctx, "device-unreachable", log.Fields{"device-id": device.Id, "SerialNumber": device.SerialNumber}) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1236 | return |
ozgecanetsia | e11479f | 2020-07-06 09:44:47 +0300 | [diff] [blame] | 1237 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1238 | if err := dh.pOnuOmciDevice.Reboot(log.WithSpanFromContext(context.TODO(), ctx)); err != nil { |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 1239 | //TODO with VOL-3045/VOL-3046: return the error and stop further processing |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1240 | logger.Errorw(ctx, "error-rebooting-device", log.Fields{"device-id": dh.DeviceID, "error": err}) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1241 | return |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 1242 | } |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 1243 | |
| 1244 | //transfer the possibly modified logical uni port state |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1245 | dh.DisableUniPortStateUpdate(ctx) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 1246 | |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 1247 | logger.Debugw(ctx, "call DeviceStateUpdate upon reboot", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1248 | "OperStatus": voltha.OperStatus_DISCOVERED, "device-id": dh.DeviceID}) |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 1249 | // do not set the ConnStatus here as it may conflict with the parallel setting from ONU down indication (updateInterface()) |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 1250 | if err := dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1251 | DeviceId: dh.DeviceID, |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 1252 | ConnStatus: connectStatusINVALID, //use some dummy value to prevent modification of the ConnStatus |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 1253 | OperStatus: voltha.OperStatus_DISCOVERED, |
| 1254 | }); err != nil { |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1255 | //TODO with VOL-3045/VOL-3046: return the error and stop further processing |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1256 | logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err}) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1257 | return |
ozgecanetsia | e11479f | 2020-07-06 09:44:47 +0300 | [diff] [blame] | 1258 | } |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 1259 | if err := dh.ReasonUpdate(ctx, cmn.DrRebooting, true); err != nil { |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1260 | return |
ozgecanetsia | e11479f | 2020-07-06 09:44:47 +0300 | [diff] [blame] | 1261 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1262 | dh.SetReadyForOmciConfig(false) |
mpagenko | 8b07c1b | 2020-11-26 10:36:31 +0000 | [diff] [blame] | 1263 | //no specific activity to synchronize any internal FSM to the 'rebooted' state is explicitly done here |
| 1264 | // the expectation ids for a real device, that it will be synced with the expected following 'down' indication |
| 1265 | // as BBSIM does not support this testing requires explicite disable/enable device calls in which sequence also |
| 1266 | // all other FSM's should be synchronized again |
ozgecanetsia | e11479f | 2020-07-06 09:44:47 +0300 | [diff] [blame] | 1267 | } |
| 1268 | |
mpagenko | c8bba41 | 2021-01-15 15:38:44 +0000 | [diff] [blame] | 1269 | //doOnuSwUpgrade initiates the SW download transfer to the ONU and on success activates the (inactive) image |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1270 | // used only for old - R2.7 style - upgrade API |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 1271 | func (dh *deviceHandler) doOnuSwUpgrade(ctx context.Context, apImageDsc *voltha.ImageDownload, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1272 | apDownloadManager *swupg.AdapterDownloadManager) error { |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 1273 | logger.Debugw(ctx, "onuSwUpgrade requested", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1274 | "device-id": dh.DeviceID, "image-name": (*apImageDsc).Name}) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 1275 | |
| 1276 | var err error |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1277 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1278 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1279 | logger.Errorw(ctx, "start Onu SW upgrade rejected: no valid OnuDevice", log.Fields{"device-id": dh.DeviceID}) |
| 1280 | return fmt.Errorf("start Onu SW upgrade rejected: no valid OnuDevice for device-id: %s", dh.DeviceID) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1281 | } |
| 1282 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1283 | if dh.IsReadyForOmciConfig() { |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1284 | var inactiveImageID uint16 |
| 1285 | if inactiveImageID, err = pDevEntry.GetInactiveImageMeID(ctx); err == nil { |
| 1286 | dh.lockUpgradeFsm.Lock() |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1287 | //lockUpgradeFsm must be release before cancellation as this may implicitly request RemoveOnuUpgradeFsm() |
| 1288 | // but must be still locked at calling createOnuUpgradeFsm |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1289 | if dh.pOnuUpradeFsm == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1290 | err = dh.createOnuUpgradeFsm(ctx, pDevEntry, cmn.OmciOnuSwUpgradeDone) |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1291 | dh.lockUpgradeFsm.Unlock() |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1292 | if err == nil { |
| 1293 | if err = dh.pOnuUpradeFsm.SetDownloadParams(ctx, inactiveImageID, apImageDsc, apDownloadManager); err != nil { |
| 1294 | logger.Errorw(ctx, "onu upgrade fsm could not set parameters", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1295 | "device-id": dh.DeviceID, "error": err}) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1296 | } |
| 1297 | } else { |
| 1298 | logger.Errorw(ctx, "onu upgrade fsm could not be created", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1299 | "device-id": dh.DeviceID, "error": err}) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 1300 | } |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1301 | } else { //OnuSw upgrade already running - restart (with possible abort of running) |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1302 | dh.lockUpgradeFsm.Unlock() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1303 | logger.Debugw(ctx, "Onu SW upgrade already running - abort", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1304 | if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation |
| 1305 | dh.upgradeCanceled = true |
| 1306 | dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_REQUEST) //complete abort |
| 1307 | } |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1308 | //no effort spent anymore for the old API to automatically cancel and restart the download |
| 1309 | // like done for the new API |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 1310 | } |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 1311 | } else { |
| 1312 | logger.Errorw(ctx, "start Onu SW upgrade rejected: no inactive image", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1313 | "device-id": dh.DeviceID, "error": err}) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 1314 | } |
| 1315 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1316 | logger.Errorw(ctx, "start Onu SW upgrade rejected: no active OMCI connection", log.Fields{"device-id": dh.DeviceID}) |
| 1317 | err = fmt.Errorf("start Onu SW upgrade rejected: no active OMCI connection for device-id: %s", dh.DeviceID) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 1318 | } |
| 1319 | return err |
mpagenko | c8bba41 | 2021-01-15 15:38:44 +0000 | [diff] [blame] | 1320 | } |
| 1321 | |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1322 | //onuSwUpgradeAfterDownload initiates the SW download transfer to the ONU with activate and commit options |
| 1323 | // after the OnuImage has been downloaded to the adapter, called in background |
| 1324 | func (dh *deviceHandler) onuSwUpgradeAfterDownload(ctx context.Context, apImageRequest *voltha.DeviceImageDownloadRequest, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1325 | apDownloadManager *swupg.FileDownloadManager, aImageIdentifier string) { |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1326 | |
| 1327 | var err error |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1328 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1329 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1330 | logger.Errorw(ctx, "start Onu SW upgrade rejected: no valid OnuDevice", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1331 | return |
| 1332 | } |
| 1333 | |
| 1334 | var inactiveImageID uint16 |
| 1335 | if inactiveImageID, err = pDevEntry.GetInactiveImageMeID(ctx); err == nil { |
| 1336 | logger.Debugw(ctx, "onuSwUpgrade requested", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1337 | "device-id": dh.DeviceID, "image-version": apImageRequest.Image.Version, "to onu-image": inactiveImageID}) |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1338 | |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1339 | dh.lockUpgradeFsm.Lock() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1340 | //lockUpgradeFsm must be release before cancellation as this may implicitly request RemoveOnuUpgradeFsm() |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1341 | // but must be still locked at calling createOnuUpgradeFsm |
| 1342 | // (and working with a local pointer copy does not work here if asynchronous request are done to fast |
| 1343 | // [e.g.leaving the local pointer on nil even though a creation is already on the way]) |
| 1344 | if dh.pOnuUpradeFsm != nil { |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1345 | //OnuSw upgrade already running on this device (e.g. with activate/commit not yet set) |
| 1346 | // abort the current processing, running upgrades are always aborted by newer request |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1347 | logger.Debugw(ctx, "Onu SW upgrade already running - abort previous activity", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1348 | //flush the remove upgradeFsmChan channel |
| 1349 | select { |
| 1350 | case <-dh.upgradeFsmChan: |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1351 | logger.Debugw(ctx, "flushed-upgrade-fsm-channel", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1352 | default: |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1353 | } |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1354 | dh.lockUpgradeFsm.Unlock() |
| 1355 | if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation |
| 1356 | dh.upgradeCanceled = true |
| 1357 | dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_REQUEST) //complete abort |
| 1358 | } |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1359 | select { |
| 1360 | case <-time.After(cTimeOutRemoveUpgrade * time.Second): |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1361 | logger.Errorw(ctx, "could not remove Upgrade FSM in time, aborting", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1362 | //should not appear, can't proceed with new upgrade, perhaps operator can retry manually later |
| 1363 | return |
| 1364 | case <-dh.upgradeFsmChan: |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1365 | logger.Debugw(ctx, "recent Upgrade FSM removed, proceed with new request", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1366 | } |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1367 | dh.lockUpgradeFsm.Lock() //lock again for following creation |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1368 | } |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1369 | |
| 1370 | //here it can be assumed that no running upgrade processing exists (anymore) |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1371 | //OmciOnuSwUpgradeDone could be used to create some event notification with information on upgrade completion, |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1372 | // but none yet defined |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1373 | err = dh.createOnuUpgradeFsm(ctx, pDevEntry, cmn.OmciOnuSwUpgradeDone) |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1374 | dh.lockUpgradeFsm.Unlock() |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1375 | if err == nil { |
| 1376 | if err = dh.pOnuUpradeFsm.SetDownloadParamsAfterDownload(ctx, inactiveImageID, |
| 1377 | apImageRequest, apDownloadManager, aImageIdentifier); err != nil { |
| 1378 | logger.Errorw(ctx, "onu upgrade fsm could not set parameters", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1379 | "device-id": dh.DeviceID, "error": err}) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1380 | return |
| 1381 | } |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1382 | } else { |
| 1383 | logger.Errorw(ctx, "onu upgrade fsm could not be created", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1384 | "device-id": dh.DeviceID, "error": err}) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1385 | } |
| 1386 | return |
| 1387 | } |
| 1388 | logger.Errorw(ctx, "start Onu SW upgrade rejected: no inactive image", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1389 | "device-id": dh.DeviceID, "error": err}) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1390 | } |
| 1391 | |
| 1392 | //onuSwActivateRequest ensures activation of the requested image with commit options |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 1393 | func (dh *deviceHandler) onuSwActivateRequest(ctx context.Context, |
| 1394 | aVersion string, aCommitRequest bool) (*voltha.ImageState, error) { |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1395 | var err error |
| 1396 | //SW activation for the ONU image may have two use cases, one of them is selected here according to following prioritization: |
| 1397 | // 1.) activation of the image for a started upgrade process (in case the running upgrade runs on the requested image) |
| 1398 | // 2.) activation of the inactive image |
| 1399 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1400 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1401 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1402 | logger.Errorw(ctx, "Onu image activation rejected: no valid OnuDevice", log.Fields{"device-id": dh.DeviceID}) |
| 1403 | return nil, fmt.Errorf("no valid OnuDevice for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1404 | } |
| 1405 | dh.lockUpgradeFsm.RLock() |
| 1406 | if dh.pOnuUpradeFsm != nil { |
| 1407 | dh.lockUpgradeFsm.RUnlock() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1408 | onuVolthaDevice, getErr := dh.getDeviceFromCore(ctx, dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1409 | if getErr != nil || onuVolthaDevice == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1410 | logger.Errorw(ctx, "Failed to fetch Onu device for image activation", log.Fields{"device-id": dh.DeviceID, "err": getErr}) |
| 1411 | return nil, fmt.Errorf("could not fetch device for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1412 | } |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1413 | if dh.upgradeCanceled { //avoid starting some new action in case it is already doing the cancelation |
| 1414 | logger.Errorw(ctx, "Some upgrade procedure still runs cancelation - abort", log.Fields{"device-id": dh.DeviceID}) |
| 1415 | return nil, fmt.Errorf("request collides with some ongoing cancelation for device-id: %s", dh.DeviceID) |
| 1416 | } |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1417 | // use the OnuVendor identification from this device for the internal unique name |
| 1418 | imageIdentifier := onuVolthaDevice.VendorId + aVersion //head on vendor ID of the ONU |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1419 | // 1.) check a started upgrade process and relay the activation request to it |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1420 | if err = dh.pOnuUpradeFsm.SetActivationParamsRunning(ctx, imageIdentifier, aCommitRequest); err != nil { |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 1421 | //if some ONU upgrade is ongoing we do not accept some explicit ONU image-version related activation |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1422 | logger.Errorw(ctx, "onu upgrade fsm did not accept activation while running", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1423 | "device-id": dh.DeviceID, "error": err}) |
| 1424 | return nil, fmt.Errorf("activation not accepted for this version for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1425 | } |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 1426 | logger.Debugw(ctx, "image activation acknowledged by onu upgrade processing", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1427 | "device-id": dh.DeviceID, "image-id": imageIdentifier}) |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1428 | pImageStates := dh.pOnuUpradeFsm.GetImageStates(ctx, "", aVersion) |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 1429 | return pImageStates, nil |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1430 | } //else |
| 1431 | dh.lockUpgradeFsm.RUnlock() |
| 1432 | |
| 1433 | // 2.) check if requested image-version equals the inactive one and start its activation |
| 1434 | // (image version is not [yet] checked - would be possible, but with increased effort ...) |
| 1435 | var inactiveImageID uint16 |
| 1436 | if inactiveImageID, err = pDevEntry.GetInactiveImageMeID(ctx); err != nil || inactiveImageID > 1 { |
| 1437 | logger.Errorw(ctx, "get inactive image failed", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1438 | "device-id": dh.DeviceID, "err": err, "image-id": inactiveImageID}) |
| 1439 | return nil, fmt.Errorf("no valid inactive image found for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1440 | } |
mpagenko | a2b288f | 2021-10-21 11:25:27 +0000 | [diff] [blame] | 1441 | dh.lockUpgradeFsm.Lock() //lock again for following creation |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1442 | err = dh.createOnuUpgradeFsm(ctx, pDevEntry, cmn.OmciOnuSwUpgradeDone) |
mpagenko | a2b288f | 2021-10-21 11:25:27 +0000 | [diff] [blame] | 1443 | dh.lockUpgradeFsm.Unlock() |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1444 | if err == nil { |
| 1445 | if err = dh.pOnuUpradeFsm.SetActivationParamsStart(ctx, aVersion, |
| 1446 | inactiveImageID, aCommitRequest); err != nil { |
| 1447 | logger.Errorw(ctx, "onu upgrade fsm did not accept activation to start", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1448 | "device-id": dh.DeviceID, "error": err}) |
| 1449 | return nil, fmt.Errorf("activation to start from scratch not accepted for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1450 | } |
| 1451 | logger.Debugw(ctx, "inactive image activation acknowledged by onu upgrade", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1452 | "device-id": dh.DeviceID, "image-version": aVersion}) |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1453 | pImageStates := dh.pOnuUpradeFsm.GetImageStates(ctx, "", aVersion) |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 1454 | return pImageStates, nil |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1455 | } //else |
| 1456 | logger.Errorw(ctx, "onu upgrade fsm could not be created", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1457 | "device-id": dh.DeviceID, "error": err}) |
| 1458 | return nil, fmt.Errorf("could not start upgradeFsm for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1459 | } |
| 1460 | |
| 1461 | //onuSwCommitRequest ensures commitment of the requested image |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 1462 | func (dh *deviceHandler) onuSwCommitRequest(ctx context.Context, |
| 1463 | aVersion string) (*voltha.ImageState, error) { |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1464 | var err error |
| 1465 | //SW commitment for the ONU image may have two use cases, one of them is selected here according to following prioritization: |
| 1466 | // 1.) commitment of the image for a started upgrade process (in case the running upgrade runs on the requested image) |
| 1467 | // 2.) commitment of the active image |
| 1468 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1469 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1470 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1471 | logger.Errorw(ctx, "Onu image commitment rejected: no valid OnuDevice", log.Fields{"device-id": dh.DeviceID}) |
| 1472 | return nil, fmt.Errorf("no valid OnuDevice for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1473 | } |
| 1474 | dh.lockUpgradeFsm.RLock() |
| 1475 | if dh.pOnuUpradeFsm != nil { |
| 1476 | dh.lockUpgradeFsm.RUnlock() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1477 | onuVolthaDevice, getErr := dh.getDeviceFromCore(ctx, dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1478 | if getErr != nil || onuVolthaDevice == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1479 | logger.Errorw(ctx, "Failed to fetch Onu device for image commitment", log.Fields{"device-id": dh.DeviceID, "err": getErr}) |
| 1480 | return nil, fmt.Errorf("could not fetch device for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1481 | } |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1482 | if dh.upgradeCanceled { //avoid starting some new action in case it is already doing the cancelation |
| 1483 | logger.Errorw(ctx, "Some upgrade procedure still runs cancelation - abort", log.Fields{"device-id": dh.DeviceID}) |
| 1484 | return nil, fmt.Errorf("request collides with some ongoing cancelation for device-id: %s", dh.DeviceID) |
| 1485 | } |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1486 | // use the OnuVendor identification from this device for the internal unique name |
| 1487 | imageIdentifier := onuVolthaDevice.VendorId + aVersion //head on vendor ID of the ONU |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1488 | // 1.) check a started upgrade process and relay the commitment request to it |
| 1489 | // the running upgrade may be based either on the imageIdentifier (started from download) |
| 1490 | // or on the imageVersion (started from pure activation) |
| 1491 | if err = dh.pOnuUpradeFsm.SetCommitmentParamsRunning(ctx, imageIdentifier, aVersion); err != nil { |
| 1492 | //if some ONU upgrade is ongoing we do not accept some explicit different ONU image-version related commitment |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1493 | logger.Errorw(ctx, "onu upgrade fsm did not accept commitment while running", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1494 | "device-id": dh.DeviceID, "error": err}) |
| 1495 | return nil, fmt.Errorf("commitment not accepted for this version for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1496 | } |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 1497 | logger.Debugw(ctx, "image commitment acknowledged by onu upgrade processing", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1498 | "device-id": dh.DeviceID, "image-id": imageIdentifier}) |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1499 | pImageStates := dh.pOnuUpradeFsm.GetImageStates(ctx, "", aVersion) |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 1500 | return pImageStates, nil |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1501 | } //else |
| 1502 | dh.lockUpgradeFsm.RUnlock() |
| 1503 | |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 1504 | // 2.) use the active image to directly commit |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1505 | var activeImageID uint16 |
| 1506 | if activeImageID, err = pDevEntry.GetActiveImageMeID(ctx); err != nil || activeImageID > 1 { |
| 1507 | logger.Errorw(ctx, "get active image failed", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1508 | "device-id": dh.DeviceID, "err": err, "image-id": activeImageID}) |
| 1509 | return nil, fmt.Errorf("no valid active image found for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1510 | } |
mpagenko | a2b288f | 2021-10-21 11:25:27 +0000 | [diff] [blame] | 1511 | dh.lockUpgradeFsm.Lock() //lock again for following creation |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1512 | err = dh.createOnuUpgradeFsm(ctx, pDevEntry, cmn.OmciOnuSwUpgradeDone) |
mpagenko | a2b288f | 2021-10-21 11:25:27 +0000 | [diff] [blame] | 1513 | dh.lockUpgradeFsm.Unlock() |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1514 | if err == nil { |
| 1515 | if err = dh.pOnuUpradeFsm.SetCommitmentParamsStart(ctx, aVersion, activeImageID); err != nil { |
| 1516 | logger.Errorw(ctx, "onu upgrade fsm did not accept commitment to start", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1517 | "device-id": dh.DeviceID, "error": err}) |
| 1518 | return nil, fmt.Errorf("commitment to start from scratch not accepted for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1519 | } |
| 1520 | logger.Debugw(ctx, "active image commitment acknowledged by onu upgrade", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1521 | "device-id": dh.DeviceID, "image-version": aVersion}) |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1522 | pImageStates := dh.pOnuUpradeFsm.GetImageStates(ctx, "", aVersion) |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 1523 | return pImageStates, nil |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1524 | } //else |
| 1525 | logger.Errorw(ctx, "onu upgrade fsm could not be created", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1526 | "device-id": dh.DeviceID, "error": err}) |
| 1527 | return nil, fmt.Errorf("could not start upgradeFsm for device-id: %s", dh.DeviceID) |
mpagenko | c26d4c0 | 2021-05-06 14:27:57 +0000 | [diff] [blame] | 1528 | } |
| 1529 | |
mpagenko | aa3afe9 | 2021-05-21 16:20:58 +0000 | [diff] [blame] | 1530 | func (dh *deviceHandler) requestOnuSwUpgradeState(ctx context.Context, aImageIdentifier string, |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1531 | aVersion string) *voltha.ImageState { |
| 1532 | var pImageState *voltha.ImageState |
mpagenko | aa3afe9 | 2021-05-21 16:20:58 +0000 | [diff] [blame] | 1533 | dh.lockUpgradeFsm.RLock() |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1534 | defer dh.lockUpgradeFsm.RUnlock() |
mpagenko | aa3afe9 | 2021-05-21 16:20:58 +0000 | [diff] [blame] | 1535 | if dh.pOnuUpradeFsm != nil { |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1536 | pImageState = dh.pOnuUpradeFsm.GetImageStates(ctx, aImageIdentifier, aVersion) |
| 1537 | } else { //use the last stored ImageState (if the requested Imageversion coincides) |
| 1538 | if aVersion == dh.pLastUpgradeImageState.Version { |
| 1539 | pImageState = dh.pLastUpgradeImageState |
| 1540 | } else { //state request for an image version different from last processed image version |
| 1541 | pImageState = &voltha.ImageState{ |
| 1542 | Version: aVersion, |
| 1543 | //we cannot state something concerning this version |
| 1544 | DownloadState: voltha.ImageState_DOWNLOAD_UNKNOWN, |
| 1545 | Reason: voltha.ImageState_NO_ERROR, |
| 1546 | ImageState: voltha.ImageState_IMAGE_UNKNOWN, |
| 1547 | } |
mpagenko | aa3afe9 | 2021-05-21 16:20:58 +0000 | [diff] [blame] | 1548 | } |
| 1549 | } |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1550 | return pImageState |
mpagenko | aa3afe9 | 2021-05-21 16:20:58 +0000 | [diff] [blame] | 1551 | } |
| 1552 | |
| 1553 | func (dh *deviceHandler) cancelOnuSwUpgrade(ctx context.Context, aImageIdentifier string, |
| 1554 | aVersion string, pDeviceImageState *voltha.DeviceImageState) { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1555 | pDeviceImageState.DeviceId = dh.DeviceID |
mpagenko | 7455fd4 | 2021-06-10 16:25:55 +0000 | [diff] [blame] | 1556 | pDeviceImageState.ImageState.Version = aVersion |
mpagenko | aa3afe9 | 2021-05-21 16:20:58 +0000 | [diff] [blame] | 1557 | dh.lockUpgradeFsm.RLock() |
| 1558 | if dh.pOnuUpradeFsm != nil { |
mpagenko | 4558676 | 2021-10-01 08:30:22 +0000 | [diff] [blame] | 1559 | dh.lockUpgradeFsm.RUnlock() |
| 1560 | // so then we cancel the upgrade operation |
mpagenko | a2b288f | 2021-10-21 11:25:27 +0000 | [diff] [blame] | 1561 | // but before we still request the actual upgrade states for the direct response |
mpagenko | 4558676 | 2021-10-01 08:30:22 +0000 | [diff] [blame] | 1562 | pImageState := dh.pOnuUpradeFsm.GetImageStates(ctx, aImageIdentifier, aVersion) |
| 1563 | pDeviceImageState.ImageState.DownloadState = pImageState.DownloadState |
| 1564 | pDeviceImageState.ImageState.Reason = voltha.ImageState_CANCELLED_ON_REQUEST |
| 1565 | pDeviceImageState.ImageState.ImageState = pImageState.ImageState |
| 1566 | if pImageState.DownloadState != voltha.ImageState_DOWNLOAD_UNKNOWN { |
| 1567 | //so here the imageIdentifier or version equals to what is used in the upgrade FSM |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 1568 | if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation |
| 1569 | dh.upgradeCanceled = true |
| 1570 | dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_REQUEST) //complete abort |
| 1571 | } |
mpagenko | 4558676 | 2021-10-01 08:30:22 +0000 | [diff] [blame] | 1572 | } //nothing to cancel (upgrade FSM for different image stays alive) |
mpagenko | aa3afe9 | 2021-05-21 16:20:58 +0000 | [diff] [blame] | 1573 | } else { |
mpagenko | 4558676 | 2021-10-01 08:30:22 +0000 | [diff] [blame] | 1574 | dh.lockUpgradeFsm.RUnlock() |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1575 | // if no upgrade is ongoing, nothing is canceled and accordingly the states of the requested image are unknown |
| 1576 | // reset also the dh handler LastUpgradeImageState (not relevant anymore/cleared) |
| 1577 | (*dh.pLastUpgradeImageState).DownloadState = voltha.ImageState_DOWNLOAD_UNKNOWN |
| 1578 | (*dh.pLastUpgradeImageState).Reason = voltha.ImageState_NO_ERROR |
| 1579 | (*dh.pLastUpgradeImageState).ImageState = voltha.ImageState_IMAGE_UNKNOWN |
| 1580 | (*dh.pLastUpgradeImageState).Version = "" //reset to 'no (relevant) upgrade done' (like initial state) |
mpagenko | aa3afe9 | 2021-05-21 16:20:58 +0000 | [diff] [blame] | 1581 | pDeviceImageState.ImageState.DownloadState = voltha.ImageState_DOWNLOAD_UNKNOWN |
| 1582 | pDeviceImageState.ImageState.Reason = voltha.ImageState_NO_ERROR |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 1583 | pDeviceImageState.ImageState.ImageState = voltha.ImageState_IMAGE_UNKNOWN |
| 1584 | //an abort request to a not active upgrade processing can be used to reset the device upgrade states completely |
mpagenko | aa3afe9 | 2021-05-21 16:20:58 +0000 | [diff] [blame] | 1585 | } |
| 1586 | } |
| 1587 | |
Holger Hildebrandt | fb402a6 | 2021-05-26 14:40:49 +0000 | [diff] [blame] | 1588 | func (dh *deviceHandler) getOnuImages(ctx context.Context) (*voltha.OnuImages, error) { |
| 1589 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1590 | var onuImageStatus *swupg.OnuImageStatus |
Holger Hildebrandt | fb402a6 | 2021-05-26 14:40:49 +0000 | [diff] [blame] | 1591 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1592 | pDevEntry := dh.GetOnuDeviceEntry(ctx, false) |
Holger Hildebrandt | fb402a6 | 2021-05-26 14:40:49 +0000 | [diff] [blame] | 1593 | if pDevEntry != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1594 | onuImageStatus = swupg.NewOnuImageStatus(dh, pDevEntry) |
| 1595 | pDevEntry.MutexOnuImageStatus.Lock() |
| 1596 | pDevEntry.POnuImageStatus = onuImageStatus |
| 1597 | pDevEntry.MutexOnuImageStatus.Unlock() |
Holger Hildebrandt | fb402a6 | 2021-05-26 14:40:49 +0000 | [diff] [blame] | 1598 | |
| 1599 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1600 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | fb402a6 | 2021-05-26 14:40:49 +0000 | [diff] [blame] | 1601 | return nil, fmt.Errorf("no-valid-OnuDevice-aborting") |
| 1602 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1603 | images, err := onuImageStatus.GetOnuImageStatus(ctx) |
| 1604 | pDevEntry.MutexOnuImageStatus.Lock() |
| 1605 | pDevEntry.POnuImageStatus = nil |
| 1606 | pDevEntry.MutexOnuImageStatus.Unlock() |
Holger Hildebrandt | fb402a6 | 2021-05-26 14:40:49 +0000 | [diff] [blame] | 1607 | return images, err |
| 1608 | } |
| 1609 | |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 1610 | // deviceHandler methods that implement the adapters interface requests## end ######### |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1611 | // ##################################################################################### |
| 1612 | |
| 1613 | // ################ to be updated acc. needs of ONU Device ######################## |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 1614 | // deviceHandler StateMachine related state transition methods ##### begin ######### |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1615 | |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1616 | func (dh *deviceHandler) logStateChange(ctx context.Context, e *fsm.Event) { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1617 | logger.Debugw(ctx, "Device FSM: ", log.Fields{"event name": string(e.Event), |
| 1618 | "src state": string(e.Src), "dst state": string(e.Dst), "device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1619 | } |
| 1620 | |
| 1621 | // doStateInit provides the device update to the core |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1622 | func (dh *deviceHandler) doStateInit(ctx context.Context, e *fsm.Event) { |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1623 | |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1624 | logger.Debugw(ctx, "doStateInit-started", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1625 | var err error |
| 1626 | |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1627 | // populate what we know. rest comes later after mib sync |
| 1628 | dh.device.Root = false |
| 1629 | dh.device.Vendor = "OpenONU" |
| 1630 | dh.device.Model = "go" |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1631 | dh.device.Reason = cmn.DeviceReasonMap[cmn.DrActivatingOnu] |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 1632 | _ = dh.ReasonUpdate(ctx, cmn.DrActivatingOnu, false) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1633 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1634 | dh.logicalDeviceID = dh.DeviceID // really needed - what for ??? //TODO!!! |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1635 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1636 | if !dh.IsReconciling() { |
| 1637 | logger.Infow(ctx, "DeviceUpdate", log.Fields{"deviceReason": dh.device.Reason, "device-id": dh.DeviceID}) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 1638 | if err := dh.updateDeviceInCore(ctx, dh.device); err != nil { |
| 1639 | logger.Errorw(ctx, "device-update-failed", log.Fields{"device-id": dh.device.Id, "error": err}) |
| 1640 | } |
Himani Chawla | c07fda0 | 2020-12-09 16:21:21 +0530 | [diff] [blame] | 1641 | //TODO Need to Update Device Reason To CORE as part of device update userstory |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1642 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1643 | logger.Debugw(ctx, "reconciling - don't notify core about DeviceUpdate", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1644 | log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1645 | } |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1646 | |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 1647 | dh.parentID = dh.device.ParentId |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 1648 | dh.ponPortNumber = dh.device.ParentPortNo |
| 1649 | |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1650 | // store proxy parameters for later communication - assumption: invariant, else they have to be requested dynamically!! |
| 1651 | dh.ProxyAddressID = dh.device.ProxyAddress.GetDeviceId() |
| 1652 | dh.ProxyAddressType = dh.device.ProxyAddress.GetDeviceType() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1653 | logger.Debugw(ctx, "device-updated", log.Fields{"device-id": dh.DeviceID, "proxyAddressID": dh.ProxyAddressID, |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1654 | "proxyAddressType": dh.ProxyAddressType, "SNR": dh.device.SerialNumber, |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 1655 | "ParentId": dh.parentID, "ParentPortNo": dh.ponPortNumber}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1656 | |
| 1657 | /* |
| 1658 | self._pon = PonPort.create(self, self._pon_port_number) |
| 1659 | self._pon.add_peer(self.parent_id, self._pon_port_number) |
| 1660 | self.logger.debug('adding-pon-port-to-agent', |
| 1661 | type=self._pon.get_port().type, |
| 1662 | admin_state=self._pon.get_port().admin_state, |
| 1663 | oper_status=self._pon.get_port().oper_status, |
| 1664 | ) |
| 1665 | */ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1666 | if !dh.IsReconciling() { |
| 1667 | logger.Debugw(ctx, "adding-pon-port", log.Fields{"device-id": dh.DeviceID, "ponPortNo": dh.ponPortNumber}) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1668 | var ponPortNo uint32 = 1 |
| 1669 | if dh.ponPortNumber != 0 { |
| 1670 | ponPortNo = dh.ponPortNumber |
| 1671 | } |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1672 | |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1673 | pPonPort := &voltha.Port{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1674 | DeviceId: dh.DeviceID, |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1675 | PortNo: ponPortNo, |
| 1676 | Label: fmt.Sprintf("pon-%d", ponPortNo), |
| 1677 | Type: voltha.Port_PON_ONU, |
| 1678 | OperStatus: voltha.OperStatus_ACTIVE, |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 1679 | Peers: []*voltha.Port_PeerPort{{DeviceId: dh.parentID, // Peer device is OLT |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1680 | PortNo: ponPortNo}}, // Peer port is parent's port number |
| 1681 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1682 | if err = dh.CreatePortInCore(ctx, pPonPort); err != nil { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1683 | logger.Fatalf(ctx, "Device FSM: PortCreated-failed-%s:%s", err, dh.DeviceID) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1684 | e.Cancel(err) |
| 1685 | return |
| 1686 | } |
| 1687 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1688 | logger.Debugw(ctx, "reconciling - pon-port already added", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1689 | } |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1690 | logger.Debugw(ctx, "doStateInit-done", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1691 | } |
| 1692 | |
| 1693 | // postInit setups the DeviceEntry for the conerned device |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1694 | func (dh *deviceHandler) postInit(ctx context.Context, e *fsm.Event) { |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1695 | |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1696 | logger.Debugw(ctx, "postInit-started", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1697 | var err error |
| 1698 | /* |
| 1699 | dh.Client = oop.NewOpenoltClient(dh.clientCon) |
| 1700 | dh.pTransitionMap.Handle(ctx, GrpcConnected) |
| 1701 | return nil |
| 1702 | */ |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1703 | if err = dh.addOnuDeviceEntry(log.WithSpanFromContext(context.TODO(), ctx)); err != nil { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1704 | logger.Fatalf(ctx, "Device FSM: addOnuDeviceEntry-failed-%s:%s", err, dh.DeviceID) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1705 | e.Cancel(err) |
| 1706 | return |
| 1707 | } |
| 1708 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1709 | if dh.IsReconciling() { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1710 | go dh.reconcileDeviceOnuInd(ctx) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1711 | // reconcilement will be continued after mib download is done |
| 1712 | } |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 1713 | |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1714 | /* |
| 1715 | ############################################################################ |
| 1716 | # Setup Alarm handler |
| 1717 | self.events = AdapterEvents(self.core_proxy, device.id, self.logical_device_id, |
| 1718 | device.serial_number) |
| 1719 | ############################################################################ |
| 1720 | # Setup PM configuration for this device |
| 1721 | # Pass in ONU specific options |
| 1722 | kwargs = { |
| 1723 | OnuPmMetrics.DEFAULT_FREQUENCY_KEY: OnuPmMetrics.DEFAULT_ONU_COLLECTION_FREQUENCY, |
| 1724 | 'heartbeat': self.heartbeat, |
| 1725 | OnuOmciPmMetrics.OMCI_DEV_KEY: self._onu_omci_device |
| 1726 | } |
| 1727 | self.logger.debug('create-pm-metrics', device_id=device.id, serial_number=device.serial_number) |
| 1728 | self._pm_metrics = OnuPmMetrics(self.events, self.core_proxy, self.device_id, |
| 1729 | self.logical_device_id, device.serial_number, |
| 1730 | grouped=True, freq_override=False, **kwargs) |
| 1731 | pm_config = self._pm_metrics.make_proto() |
| 1732 | self._onu_omci_device.set_pm_config(self._pm_metrics.omci_pm.openomci_interval_pm) |
| 1733 | self.logger.info("initial-pm-config", device_id=device.id, serial_number=device.serial_number) |
| 1734 | yield self.core_proxy.device_pm_config_update(pm_config, init=True) |
| 1735 | |
| 1736 | # Note, ONU ID and UNI intf set in add_uni_port method |
| 1737 | self._onu_omci_device.alarm_synchronizer.set_alarm_params(mgr=self.events, |
| 1738 | ani_ports=[self._pon]) |
| 1739 | |
| 1740 | # Code to Run OMCI Test Action |
| 1741 | kwargs_omci_test_action = { |
| 1742 | OmciTestRequest.DEFAULT_FREQUENCY_KEY: |
| 1743 | OmciTestRequest.DEFAULT_COLLECTION_FREQUENCY |
| 1744 | } |
| 1745 | serial_number = device.serial_number |
| 1746 | self._test_request = OmciTestRequest(self.core_proxy, |
| 1747 | self.omci_agent, self.device_id, |
| 1748 | AniG, serial_number, |
| 1749 | self.logical_device_id, |
| 1750 | exclusive=False, |
| 1751 | **kwargs_omci_test_action) |
| 1752 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1753 | self.Enabled = True |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1754 | else: |
| 1755 | self.logger.info('onu-already-activated') |
| 1756 | */ |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 1757 | |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1758 | logger.Debugw(ctx, "postInit-done", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1759 | } |
| 1760 | |
| 1761 | // doStateConnected get the device info and update to voltha core |
| 1762 | // for comparison of the original method (not that easy to uncomment): compare here: |
| 1763 | // voltha-openolt-adapter/adaptercore/device_handler.go |
| 1764 | // -> this one obviously initiates all communication interfaces of the device ...? |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1765 | func (dh *deviceHandler) doStateConnected(ctx context.Context, e *fsm.Event) { |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1766 | |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1767 | logger.Debugw(ctx, "doStateConnected-started", log.Fields{"device-id": dh.DeviceID}) |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 1768 | err := errors.New("device FSM: function not implemented yet") |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1769 | e.Cancel(err) |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1770 | logger.Debugw(ctx, "doStateConnected-done", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1771 | } |
| 1772 | |
| 1773 | // doStateUp handle the onu up indication and update to voltha core |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1774 | func (dh *deviceHandler) doStateUp(ctx context.Context, e *fsm.Event) { |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1775 | |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1776 | logger.Debugw(ctx, "doStateUp-started", log.Fields{"device-id": dh.DeviceID}) |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 1777 | err := errors.New("device FSM: function not implemented yet") |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1778 | e.Cancel(err) |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1779 | logger.Debugw(ctx, "doStateUp-done", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1780 | |
| 1781 | /* |
| 1782 | // Synchronous call to update device state - this method is run in its own go routine |
| 1783 | if err := dh.coreProxy.DeviceStateUpdate(ctx, dh.device.Id, voltha.ConnectStatus_REACHABLE, |
| 1784 | voltha.OperStatus_ACTIVE); err != nil { |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 1785 | logger.Errorw("Failed to update device with OLT UP indication", log.Fields{"device-id": dh.device.Id, "error": err}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1786 | return err |
| 1787 | } |
| 1788 | return nil |
| 1789 | */ |
| 1790 | } |
| 1791 | |
| 1792 | // doStateDown handle the onu down indication |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1793 | func (dh *deviceHandler) doStateDown(ctx context.Context, e *fsm.Event) { |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1794 | |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1795 | logger.Debugw(ctx, "doStateDown-started", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1796 | var err error |
| 1797 | |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 1798 | device := dh.device |
| 1799 | if device == nil { |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1800 | /*TODO: needs to handle error scenarios */ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1801 | logger.Errorw(ctx, "Failed to fetch handler device", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1802 | e.Cancel(err) |
| 1803 | return |
| 1804 | } |
| 1805 | |
| 1806 | cloned := proto.Clone(device).(*voltha.Device) |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1807 | logger.Debugw(ctx, "do-state-down", log.Fields{"ClonedDeviceID": cloned.Id}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1808 | /* |
| 1809 | // Update the all ports state on that device to disable |
| 1810 | if er := dh.coreProxy.PortsStateUpdate(ctx, cloned.Id, voltha.OperStatus_UNKNOWN); er != nil { |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 1811 | logger.Errorw("updating-ports-failed", log.Fields{"device-id": device.Id, "error": er}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1812 | return er |
| 1813 | } |
| 1814 | |
| 1815 | //Update the device oper state and connection status |
| 1816 | cloned.OperStatus = voltha.OperStatus_UNKNOWN |
| 1817 | cloned.ConnectStatus = common.ConnectStatus_UNREACHABLE |
| 1818 | dh.device = cloned |
| 1819 | |
| 1820 | if er := dh.coreProxy.DeviceStateUpdate(ctx, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); er != nil { |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 1821 | logger.Errorw("error-updating-device-state", log.Fields{"device-id": device.Id, "error": er}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1822 | return er |
| 1823 | } |
| 1824 | |
| 1825 | //get the child device for the parent device |
| 1826 | onuDevices, err := dh.coreProxy.GetChildDevices(ctx, dh.device.Id) |
| 1827 | if err != nil { |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 1828 | logger.Errorw("failed to get child devices information", log.Fields{"device-id": dh.device.Id, "error": err}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1829 | return err |
| 1830 | } |
| 1831 | for _, onuDevice := range onuDevices.Items { |
| 1832 | |
| 1833 | // Update onu state as down in onu adapter |
| 1834 | onuInd := oop.OnuIndication{} |
| 1835 | onuInd.OperState = "down" |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 1836 | er := dh.adapterProxy.SendInterAdapterMessage(ctx, &onuInd, ca.InterAdapterMessageType_ONU_IND_REQUEST, |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1837 | "openolt", onuDevice.Type, onuDevice.Id, onuDevice.ProxyAddress.DeviceId, "") |
| 1838 | if er != nil { |
| 1839 | logger.Errorw("Failed to send inter-adapter-message", log.Fields{"OnuInd": onuInd, |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 1840 | "From Adapter": "openolt", "DevieType": onuDevice.Type, "device-id": onuDevice.Id}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1841 | //Do not return here and continue to process other ONUs |
| 1842 | } |
| 1843 | } |
| 1844 | // * Discovered ONUs entries need to be cleared , since after OLT |
| 1845 | // is up, it starts sending discovery indications again* / |
| 1846 | dh.discOnus = sync.Map{} |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 1847 | logger.Debugw("do-state-down-end", log.Fields{"device-id": device.Id}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1848 | return nil |
| 1849 | */ |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 1850 | err = errors.New("device FSM: function not implemented yet") |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1851 | e.Cancel(err) |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1852 | logger.Debugw(ctx, "doStateDown-done", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1853 | } |
| 1854 | |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 1855 | // deviceHandler StateMachine related state transition methods ##### end ######### |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1856 | // ################################################################################# |
| 1857 | |
| 1858 | // ################################################### |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 1859 | // deviceHandler utility methods ##### begin ######### |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1860 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1861 | //GetOnuDeviceEntry gets the ONU device entry and may wait until its value is defined |
| 1862 | func (dh *deviceHandler) GetOnuDeviceEntry(ctx context.Context, aWait bool) *mib.OnuDeviceEntry { |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 1863 | dh.lockDevice.RLock() |
| 1864 | pOnuDeviceEntry := dh.pOnuOmciDevice |
| 1865 | if aWait && pOnuDeviceEntry == nil { |
| 1866 | //keep the read sema short to allow for subsequent write |
| 1867 | dh.lockDevice.RUnlock() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1868 | logger.Debugw(ctx, "Waiting for DeviceEntry to be set ...", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 1869 | // based on concurrent processing the deviceEntry setup may not yet be finished at his point |
| 1870 | // so it might be needed to wait here for that event with some timeout |
| 1871 | select { |
| 1872 | case <-time.After(60 * time.Second): //timer may be discussed ... |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1873 | logger.Errorw(ctx, "No valid DeviceEntry set after maxTime", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 1874 | return nil |
| 1875 | case <-dh.deviceEntrySet: |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1876 | logger.Debugw(ctx, "devicEntry ready now - continue", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 1877 | // if written now, we can return the written value without sema |
| 1878 | return dh.pOnuOmciDevice |
| 1879 | } |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1880 | } |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 1881 | dh.lockDevice.RUnlock() |
| 1882 | return pOnuDeviceEntry |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1883 | } |
| 1884 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1885 | //setDeviceHandlerEntries sets the ONU device entry within the handler |
| 1886 | func (dh *deviceHandler) setDeviceHandlerEntries(apDeviceEntry *mib.OnuDeviceEntry, apOnuTp *avcfg.OnuUniTechProf, |
| 1887 | apOnuMetricsMgr *pmmgr.OnuMetricsManager, apOnuAlarmMgr *almgr.OnuAlarmManager, apSelfTestHdlr *otst.SelfTestControlBlock) { |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1888 | dh.lockDevice.Lock() |
| 1889 | defer dh.lockDevice.Unlock() |
mpagenko | af80163 | 2020-07-03 10:00:42 +0000 | [diff] [blame] | 1890 | dh.pOnuOmciDevice = apDeviceEntry |
| 1891 | dh.pOnuTP = apOnuTp |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 1892 | dh.pOnuMetricsMgr = apOnuMetricsMgr |
Himani Chawla | ac1f5ad | 2021-02-04 21:21:54 +0530 | [diff] [blame] | 1893 | dh.pAlarmMgr = apOnuAlarmMgr |
Girish Gowdra | 6afb56a | 2021-04-27 17:47:57 -0700 | [diff] [blame] | 1894 | dh.pSelfTestHdlr = apSelfTestHdlr |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1895 | } |
| 1896 | |
Himani Chawla | 6d2ae15 | 2020-09-02 13:11:20 +0530 | [diff] [blame] | 1897 | //addOnuDeviceEntry creates a new ONU device or returns the existing |
| 1898 | func (dh *deviceHandler) addOnuDeviceEntry(ctx context.Context) error { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1899 | logger.Debugw(ctx, "adding-deviceEntry", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1900 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1901 | deviceEntry := dh.GetOnuDeviceEntry(ctx, false) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1902 | if deviceEntry == nil { |
| 1903 | /* costum_me_map in python code seems always to be None, |
| 1904 | we omit that here first (declaration unclear) -> todo at Adapter specialization ...*/ |
| 1905 | /* also no 'clock' argument - usage open ...*/ |
| 1906 | /* and no alarm_db yet (oo.alarm_db) */ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1907 | deviceEntry = mib.NewOnuDeviceEntry(ctx, dh.coreClient, dh, dh.pOpenOnuAc) |
| 1908 | onuTechProfProc := avcfg.NewOnuUniTechProf(ctx, dh, deviceEntry) |
| 1909 | onuMetricsMgr := pmmgr.NewOnuMetricsManager(ctx, dh, deviceEntry) |
| 1910 | onuAlarmManager := almgr.NewAlarmManager(ctx, dh, deviceEntry) |
| 1911 | selfTestHdlr := otst.NewSelfTestMsgHandlerCb(ctx, dh, deviceEntry) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1912 | //error treatment possible //TODO!!! |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1913 | dh.setDeviceHandlerEntries(deviceEntry, onuTechProfProc, onuMetricsMgr, onuAlarmManager, selfTestHdlr) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 1914 | // fire deviceEntry ready event to spread to possibly waiting processing |
| 1915 | dh.deviceEntrySet <- true |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1916 | logger.Debugw(ctx, "onuDeviceEntry-added", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1917 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1918 | logger.Debugw(ctx, "onuDeviceEntry-add: Device already exists", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1919 | } |
| 1920 | // might be updated with some error handling !!! |
| 1921 | return nil |
| 1922 | } |
| 1923 | |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1924 | func (dh *deviceHandler) createInterface(ctx context.Context, onuind *oop.OnuIndication) error { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1925 | logger.Debugw(ctx, "create_interface-started", log.Fields{"device-id": dh.DeviceID, "OnuId": onuind.GetOnuId(), |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 1926 | "OnuIntfId": onuind.GetIntfId(), "OnuSerialNumber": onuind.GetSerialNumber()}) |
| 1927 | |
| 1928 | dh.pOnuIndication = onuind // let's revise if storing the pointer is sufficient... |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1929 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1930 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 1931 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1932 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
| 1933 | return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 1934 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1935 | if !dh.IsReconciling() { |
| 1936 | if err := dh.StorePersistentData(ctx); err != nil { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1937 | logger.Warnw(ctx, "store persistent data error - continue as there will be additional write attempts", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1938 | log.Fields{"device-id": dh.DeviceID, "err": err}) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 1939 | } |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1940 | logger.Debugw(ctx, "call DeviceStateUpdate upon create interface", log.Fields{"ConnectStatus": voltha.ConnectStatus_REACHABLE, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1941 | "OperStatus": voltha.OperStatus_ACTIVATING, "device-id": dh.DeviceID}) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 1942 | |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 1943 | if err := dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1944 | DeviceId: dh.DeviceID, |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 1945 | OperStatus: voltha.OperStatus_ACTIVATING, |
| 1946 | ConnStatus: voltha.ConnectStatus_REACHABLE, |
| 1947 | }); err != nil { |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1948 | //TODO with VOL-3045/VOL-3046: return the error and stop further processing |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1949 | logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err}) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 1950 | } |
| 1951 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1952 | logger.Debugw(ctx, "reconciling - don't notify core about DeviceStateUpdate to ACTIVATING", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1953 | log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 1954 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1955 | pDevEntry.MutexPersOnuConfig.RLock() |
| 1956 | if !pDevEntry.SOnuPersistentData.PersUniUnlockDone { |
| 1957 | pDevEntry.MutexPersOnuConfig.RUnlock() |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1958 | logger.Debugw(ctx, "reconciling - uni-ports were not unlocked before adapter restart - resume with a normal start-up", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1959 | log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 1960 | dh.stopReconciling(ctx, true, cWaitReconcileFlowNoActivity) |
Holger Hildebrandt | 0da7e6f | 2021-05-12 13:08:43 +0000 | [diff] [blame] | 1961 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1962 | pDevEntry.MutexPersOnuConfig.RUnlock() |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 1963 | } |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1964 | } |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 1965 | // It does not look to me as if makes sense to work with the real core device here, (not the stored clone)? |
| 1966 | // in this code the GetDevice would just make a check if the DeviceID's Device still exists in core |
| 1967 | // 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 Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1968 | // but I would not know why, and the go code anyway does not work with the device directly anymore in the mib.OnuDeviceEntry |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 1969 | // so let's just try to keep it simple ... |
| 1970 | /* |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 1971 | device, err := dh.coreProxy.GetDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, dh.device.Id) |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 1972 | if err != nil || device == nil { |
| 1973 | //TODO: needs to handle error scenarios |
| 1974 | logger.Errorw("Failed to fetch device device at creating If", log.Fields{"err": err}) |
| 1975 | return errors.New("Voltha Device not found") |
| 1976 | } |
| 1977 | */ |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1978 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1979 | if err := pDevEntry.Start(log.WithSpanFromContext(context.TODO(), ctx)); err != nil { |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 1980 | return err |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 1981 | } |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 1982 | _ = dh.ReasonUpdate(ctx, cmn.DrStartingOpenomci, !dh.IsReconciling() || dh.IsReconcilingReasonUpdate()) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1983 | |
| 1984 | /* this might be a good time for Omci Verify message? */ |
| 1985 | verifyExec := make(chan bool) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1986 | omciVerify := otst.NewOmciTestRequest(log.WithSpanFromContext(context.TODO(), ctx), |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 1987 | dh.device.Id, pDevEntry.PDevOmciCC, |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 1988 | true, true) //exclusive and allowFailure (anyway not yet checked) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 1989 | omciVerify.PerformOmciTest(log.WithSpanFromContext(context.TODO(), ctx), verifyExec) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1990 | |
| 1991 | /* give the handler some time here to wait for the OMCi verification result |
| 1992 | after Timeout start and try MibUpload FSM anyway |
| 1993 | (to prevent stopping on just not supported OMCI verification from ONU) */ |
| 1994 | select { |
Holger Hildebrandt | 366ef19 | 2021-05-05 11:07:44 +0000 | [diff] [blame] | 1995 | case <-time.After(pDevEntry.PDevOmciCC.GetMaxOmciTimeoutWithRetries() * time.Second): |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1996 | logger.Warnw(ctx, "omci start-verification timed out (continue normal)", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1997 | case testresult := <-verifyExec: |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 1998 | logger.Infow(ctx, "Omci start verification done", log.Fields{"device-id": dh.DeviceID, "result": testresult}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 1999 | } |
| 2000 | |
| 2001 | /* In py code it looks earlier (on activate ..) |
| 2002 | # Code to Run OMCI Test Action |
| 2003 | kwargs_omci_test_action = { |
| 2004 | OmciTestRequest.DEFAULT_FREQUENCY_KEY: |
| 2005 | OmciTestRequest.DEFAULT_COLLECTION_FREQUENCY |
| 2006 | } |
| 2007 | serial_number = device.serial_number |
| 2008 | self._test_request = OmciTestRequest(self.core_proxy, |
| 2009 | self.omci_agent, self.device_id, |
| 2010 | AniG, serial_number, |
| 2011 | self.logical_device_id, |
| 2012 | exclusive=False, |
| 2013 | **kwargs_omci_test_action) |
| 2014 | ... |
| 2015 | # Start test requests after a brief pause |
| 2016 | if not self._test_request_started: |
| 2017 | self._test_request_started = True |
| 2018 | tststart = _STARTUP_RETRY_WAIT * (random.randint(1, 5)) |
| 2019 | reactor.callLater(tststart, self._test_request.start_collector) |
| 2020 | |
| 2021 | */ |
| 2022 | /* which is then: in omci_test_request.py : */ |
| 2023 | /* |
| 2024 | def start_collector(self, callback=None): |
| 2025 | """ |
| 2026 | Start the collection loop for an adapter if the frequency > 0 |
| 2027 | |
| 2028 | :param callback: (callable) Function to call to collect PM data |
| 2029 | """ |
| 2030 | self.logger.info("starting-pm-collection", device_name=self.name, default_freq=self.default_freq) |
| 2031 | if callback is None: |
| 2032 | callback = self.perform_test_omci |
| 2033 | |
| 2034 | if self.lc is None: |
| 2035 | self.lc = LoopingCall(callback) |
| 2036 | |
| 2037 | if self.default_freq > 0: |
| 2038 | self.lc.start(interval=self.default_freq / 10) |
| 2039 | |
| 2040 | def perform_test_omci(self): |
| 2041 | """ |
| 2042 | Perform the initial test request |
| 2043 | """ |
| 2044 | ani_g_entities = self._device.configuration.ani_g_entities |
| 2045 | ani_g_entities_ids = list(ani_g_entities.keys()) if ani_g_entities \ |
| 2046 | is not None else None |
| 2047 | self._entity_id = ani_g_entities_ids[0] |
| 2048 | self.logger.info('perform-test', entity_class=self._entity_class, |
| 2049 | entity_id=self._entity_id) |
| 2050 | try: |
| 2051 | frame = MEFrame(self._entity_class, self._entity_id, []).test() |
| 2052 | result = yield self._device.omci_cc.send(frame) |
| 2053 | if not result.fields['omci_message'].fields['success_code']: |
| 2054 | self.logger.info('Self-Test Submitted Successfully', |
| 2055 | code=result.fields[ |
| 2056 | 'omci_message'].fields['success_code']) |
| 2057 | else: |
| 2058 | raise TestFailure('Test Failure: {}'.format( |
| 2059 | result.fields['omci_message'].fields['success_code'])) |
| 2060 | except TimeoutError as e: |
| 2061 | self.deferred.errback(failure.Failure(e)) |
| 2062 | |
| 2063 | except Exception as e: |
| 2064 | self.logger.exception('perform-test-Error', e=e, |
| 2065 | class_id=self._entity_class, |
| 2066 | entity_id=self._entity_id) |
| 2067 | self.deferred.errback(failure.Failure(e)) |
| 2068 | |
| 2069 | */ |
| 2070 | |
| 2071 | // PM related heartbeat??? !!!TODO.... |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2072 | //self._heartbeat.Enabled = True |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 2073 | |
mpagenko | 1cc3cb4 | 2020-07-27 15:24:38 +0000 | [diff] [blame] | 2074 | /* Note: Even though FSM calls look 'synchronous' here, FSM is running in background with the effect that possible errors |
| 2075 | * within the MibUpload are not notified in the OnuIndication response, this might be acceptable here, |
| 2076 | * as further OltAdapter processing may rely on the deviceReason event 'MibUploadDone' as a result of the FSM processing |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2077 | * otherwise some processing synchronization would be required - cmp. e.g TechProfile processing |
mpagenko | 1cc3cb4 | 2020-07-27 15:24:38 +0000 | [diff] [blame] | 2078 | */ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2079 | //call MibUploadFSM - transition up to state UlStInSync |
| 2080 | pMibUlFsm := pDevEntry.PMibUploadFsm.PFsm |
Holger Hildebrandt | 9ac0d0f | 2020-05-13 11:22:02 +0000 | [diff] [blame] | 2081 | if pMibUlFsm != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2082 | if pMibUlFsm.Is(mib.UlStDisabled) { |
| 2083 | if err := pMibUlFsm.Event(mib.UlEvStart); err != nil { |
| 2084 | logger.Errorw(ctx, "MibSyncFsm: Can't go to state starting", log.Fields{"device-id": dh.DeviceID, "err": err}) |
| 2085 | return fmt.Errorf("can't go to state starting: %s", dh.DeviceID) |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2086 | } |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 2087 | logger.Debugw(ctx, "MibSyncFsm", log.Fields{"device-id": dh.DeviceID, "state": string(pMibUlFsm.Current())}) |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2088 | //Determine ONU status and start/re-start MIB Synchronization tasks |
| 2089 | //Determine if this ONU has ever synchronized |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2090 | if pDevEntry.IsNewOnu() { |
| 2091 | if err := pMibUlFsm.Event(mib.UlEvResetMib); err != nil { |
| 2092 | logger.Errorw(ctx, "MibSyncFsm: Can't go to state resetting_mib", log.Fields{"device-id": dh.DeviceID, "err": err}) |
| 2093 | return fmt.Errorf("can't go to state resetting_mib: %s", dh.DeviceID) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 2094 | } |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2095 | } else { |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 2096 | if err := pMibUlFsm.Event(mib.UlEvVerifyAndStoreTPs); err != nil { |
| 2097 | logger.Errorw(ctx, "MibSyncFsm: Can't go to state verify and store TPs", log.Fields{"device-id": dh.DeviceID, "err": err}) |
| 2098 | return fmt.Errorf("can't go to state verify and store TPs: %s", dh.DeviceID) |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2099 | } |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 2100 | logger.Debugw(ctx, "state of MibSyncFsm", log.Fields{"device-id": dh.DeviceID, "state": string(pMibUlFsm.Current())}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 2101 | } |
Holger Hildebrandt | 9ac0d0f | 2020-05-13 11:22:02 +0000 | [diff] [blame] | 2102 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2103 | logger.Errorw(ctx, "wrong state of MibSyncFsm - want: disabled", log.Fields{"have": string(pMibUlFsm.Current()), |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2104 | "device-id": dh.DeviceID}) |
| 2105 | return fmt.Errorf("wrong state of MibSyncFsm: %s", dh.DeviceID) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 2106 | } |
| 2107 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2108 | logger.Errorw(ctx, "MibSyncFsm invalid - cannot be executed!!", log.Fields{"device-id": dh.DeviceID}) |
| 2109 | return fmt.Errorf("can't execute MibSync: %s", dh.DeviceID) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 2110 | } |
| 2111 | return nil |
| 2112 | } |
| 2113 | |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2114 | func (dh *deviceHandler) updateInterface(ctx context.Context, onuind *oop.OnuIndication) error { |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2115 | //state checking to prevent unneeded processing (eg. on ONU 'unreachable' and 'down') |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 2116 | // (but note that the deviceReason may also have changed to e.g. TechProf*Delete_Success in between) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2117 | if dh.getDeviceReason() != cmn.DrStoppingOpenomci { |
| 2118 | logger.Debugw(ctx, "updateInterface-started - stopping-device", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 2418ab0 | 2020-11-12 12:58:06 +0000 | [diff] [blame] | 2119 | |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2120 | //stop all running FSM processing - make use of the DH-state as mirrored in the deviceReason |
| 2121 | //here no conflict with aborted FSM's should arise as a complete OMCI initialization is assumed on ONU-Up |
| 2122 | //but that might change with some simple MDS check on ONU-Up treatment -> attention!!! |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 2123 | if err := dh.resetFsms(ctx, true); err != nil { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2124 | logger.Errorw(ctx, "error-updateInterface at FSM stop", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2125 | log.Fields{"device-id": dh.DeviceID, "error": err}) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2126 | // abort: system behavior is just unstable ... |
| 2127 | return err |
| 2128 | } |
mpagenko | a40e99a | 2020-11-17 13:50:39 +0000 | [diff] [blame] | 2129 | //all stored persistent data are not valid anymore (loosing knowledge about the connected ONU) |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2130 | _ = dh.deleteDevicePersistencyData(ctx) //ignore possible errors here and continue, hope is that data is synchronized with new ONU-Up |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2131 | |
| 2132 | //deviceEntry stop without omciCC reset here, regarding the OMCI_CC still valid for this ONU |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 2133 | //stop the device entry to allow for all system event transfers again |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2134 | pDevEntry := dh.GetOnuDeviceEntry(ctx, false) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2135 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2136 | logger.Errorw(ctx, "No valid OnuDevice -aborting", log.Fields{"device-id": dh.DeviceID}) |
| 2137 | return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2138 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2139 | _ = pDevEntry.Stop(log.WithSpanFromContext(context.TODO(), ctx), false) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2140 | |
| 2141 | //TODO!!! remove existing traffic profiles |
| 2142 | /* from py code, if TP's exist, remove them - not yet implemented |
| 2143 | self._tp = dict() |
| 2144 | # Let TP download happen again |
| 2145 | for uni_id in self._tp_service_specific_task: |
| 2146 | self._tp_service_specific_task[uni_id].clear() |
| 2147 | for uni_id in self._tech_profile_download_done: |
| 2148 | self._tech_profile_download_done[uni_id].clear() |
| 2149 | */ |
| 2150 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2151 | dh.DisableUniPortStateUpdate(ctx) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2152 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2153 | dh.SetReadyForOmciConfig(false) |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 2154 | |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 2155 | if err := dh.ReasonUpdate(ctx, cmn.DrStoppingOpenomci, true); err != nil { |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2156 | // abort: system behavior is just unstable ... |
| 2157 | return err |
| 2158 | } |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2159 | logger.Debugw(ctx, "call DeviceStateUpdate upon update interface", log.Fields{"ConnectStatus": voltha.ConnectStatus_UNREACHABLE, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2160 | "OperStatus": voltha.OperStatus_DISCOVERED, "device-id": dh.DeviceID}) |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 2161 | if err := dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2162 | DeviceId: dh.DeviceID, |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2163 | ConnStatus: voltha.ConnectStatus_UNREACHABLE, |
| 2164 | OperStatus: voltha.OperStatus_DISCOVERED, |
| 2165 | }); err != nil { |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 2166 | //TODO with VOL-3045/VOL-3046: return the error and stop further processing |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2167 | logger.Errorw(ctx, "error-updating-device-state unreachable-discovered", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2168 | log.Fields{"device-id": dh.DeviceID, "error": err}) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2169 | // abort: system behavior is just unstable ... |
| 2170 | return err |
| 2171 | } |
| 2172 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2173 | logger.Debugw(ctx, "updateInterface - device already stopped", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2174 | } |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 2175 | return nil |
| 2176 | } |
| 2177 | |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 2178 | func (dh *deviceHandler) resetFsms(ctx context.Context, includingMibSyncFsm bool) error { |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2179 | //all possible FSM's are stopped or reset here to ensure their transition to 'disabled' |
| 2180 | //it is not sufficient to stop/reset the latest running FSM as done in previous versions |
| 2181 | // as after down/up procedures all FSM's might be active/ongoing (in theory) |
| 2182 | // and using the stop/reset event should never harm |
| 2183 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2184 | pDevEntry := dh.GetOnuDeviceEntry(ctx, false) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2185 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2186 | logger.Errorw(ctx, "No valid OnuDevice -aborting", log.Fields{"device-id": dh.DeviceID}) |
| 2187 | return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2188 | } |
Holger Hildebrandt | c8ece36 | 2021-05-17 12:01:10 +0000 | [diff] [blame] | 2189 | if pDevEntry.PDevOmciCC != nil { |
mpagenko | 8cd1bf7 | 2021-06-22 10:11:19 +0000 | [diff] [blame] | 2190 | pDevEntry.PDevOmciCC.CancelRequestMonitoring(ctx) |
Holger Hildebrandt | c8ece36 | 2021-05-17 12:01:10 +0000 | [diff] [blame] | 2191 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2192 | pDevEntry.MutexOnuImageStatus.RLock() |
| 2193 | if pDevEntry.POnuImageStatus != nil { |
| 2194 | pDevEntry.POnuImageStatus.CancelProcessing(ctx) |
Holger Hildebrandt | fb402a6 | 2021-05-26 14:40:49 +0000 | [diff] [blame] | 2195 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2196 | pDevEntry.MutexOnuImageStatus.RUnlock() |
mpagenko | aa3afe9 | 2021-05-21 16:20:58 +0000 | [diff] [blame] | 2197 | |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 2198 | if includingMibSyncFsm { |
Holger Hildebrandt | b4563ab | 2021-04-14 10:27:20 +0000 | [diff] [blame] | 2199 | pDevEntry.CancelProcessing(ctx) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2200 | } |
| 2201 | //MibDownload may run |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2202 | pMibDlFsm := pDevEntry.PMibDownloadFsm.PFsm |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2203 | if pMibDlFsm != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2204 | _ = pMibDlFsm.Event(mib.DlEvReset) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2205 | } |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 2206 | //stop any deviceHandler reconcile processing (if running) |
| 2207 | dh.stopReconciling(ctx, false, cWaitReconcileFlowAbortOnError) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2208 | //port lock/unlock FSM's may be active |
| 2209 | if dh.pUnlockStateFsm != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2210 | _ = dh.pUnlockStateFsm.PAdaptFsm.PFsm.Event(uniprt.UniEvReset) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2211 | } |
| 2212 | if dh.pLockStateFsm != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2213 | _ = dh.pLockStateFsm.PAdaptFsm.PFsm.Event(uniprt.UniEvReset) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2214 | } |
| 2215 | //techProfile related PonAniConfigFsm FSM may be active |
| 2216 | if dh.pOnuTP != nil { |
| 2217 | // should always be the case here |
| 2218 | // FSM stop maybe encapsulated as OnuTP method - perhaps later in context of module splitting |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2219 | if dh.pOnuTP.PAniConfigFsm != nil { |
| 2220 | for uniTP := range dh.pOnuTP.PAniConfigFsm { |
| 2221 | dh.pOnuTP.PAniConfigFsm[uniTP].CancelProcessing(ctx) |
Girish Gowdra | 041dcb3 | 2020-11-16 16:54:30 -0800 | [diff] [blame] | 2222 | } |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2223 | } |
| 2224 | for _, uniPort := range dh.uniEntityMap { |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2225 | // reset the possibly existing VlanConfigFsm |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 2226 | dh.lockVlanConfig.RLock() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2227 | if pVlanFilterFsm, exist := dh.UniVlanConfigFsmMap[uniPort.UniID]; exist { |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2228 | //VlanFilterFsm exists and was already started |
mpagenko | 7d6bb02 | 2021-03-11 15:07:55 +0000 | [diff] [blame] | 2229 | dh.lockVlanConfig.RUnlock() |
mpagenko | 7d6bb02 | 2021-03-11 15:07:55 +0000 | [diff] [blame] | 2230 | //ensure the FSM processing is stopped in case waiting for some response |
mpagenko | 7314399 | 2021-04-09 15:17:10 +0000 | [diff] [blame] | 2231 | pVlanFilterFsm.CancelProcessing(ctx) |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 2232 | } else { |
| 2233 | dh.lockVlanConfig.RUnlock() |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2234 | } |
| 2235 | } |
| 2236 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2237 | if dh.GetCollectorIsRunning() { |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 2238 | // Stop collector routine |
| 2239 | dh.stopCollector <- true |
| 2240 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2241 | if dh.GetAlarmManagerIsRunning(ctx) { |
Himani Chawla | 4c1d4c7 | 2021-02-18 12:14:31 +0530 | [diff] [blame] | 2242 | dh.stopAlarmManager <- true |
| 2243 | } |
Girish Gowdra | 10123c0 | 2021-08-30 11:52:06 -0700 | [diff] [blame] | 2244 | if dh.pSelfTestHdlr.GetSelfTestHandlerIsRunning() { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2245 | dh.pSelfTestHdlr.StopSelfTestModule <- true |
Girish Gowdra | 10123c0 | 2021-08-30 11:52:06 -0700 | [diff] [blame] | 2246 | } |
Himani Chawla | 4c1d4c7 | 2021-02-18 12:14:31 +0530 | [diff] [blame] | 2247 | |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 2248 | // Note: We want flow deletes to be processed on onu down, so do not stop flow monitoring routines |
| 2249 | |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2250 | //reset a possibly running upgrade FSM |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2251 | // (note the Upgrade FSM may stay alive e.g. in state UpgradeStWaitForCommit to endure the ONU reboot) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2252 | dh.lockUpgradeFsm.RLock() |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 2253 | lopOnuUpradeFsm := dh.pOnuUpradeFsm |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2254 | //lockUpgradeFsm must be release before cancellation as this may implicitly request RemoveOnuUpgradeFsm() |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2255 | dh.lockUpgradeFsm.RUnlock() |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 2256 | if lopOnuUpradeFsm != nil { |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 2257 | if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation |
| 2258 | //here we do not expect intermediate cancelation, we still allow for other commands on this FSM |
| 2259 | // (even though it may also run into direct cancellation, a bit hard to verify here) |
| 2260 | // so don't set 'dh.upgradeCanceled = true' here! |
| 2261 | lopOnuUpradeFsm.CancelProcessing(ctx, false, voltha.ImageState_CANCELLED_ON_ONU_STATE) //conditional cancel |
| 2262 | } |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 2263 | } |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2264 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2265 | logger.Infow(ctx, "resetFsms done", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2266 | return nil |
| 2267 | } |
| 2268 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2269 | func (dh *deviceHandler) processMibDatabaseSyncEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) { |
| 2270 | logger.Debugw(ctx, "MibInSync event received, adding uni ports and locking the ONU interfaces", log.Fields{"device-id": dh.DeviceID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2271 | |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2272 | // store persistent data collected during MIB upload processing |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2273 | if err := dh.StorePersistentData(ctx); err != nil { |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2274 | logger.Warnw(ctx, "store persistent data error - continue as there will be additional write attempts", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2275 | log.Fields{"device-id": dh.DeviceID, "err": err}) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2276 | } |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 2277 | _ = dh.ReasonUpdate(ctx, cmn.DrDiscoveryMibsyncComplete, !dh.IsReconciling() || dh.IsReconcilingReasonUpdate()) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2278 | dh.AddAllUniPorts(ctx) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2279 | |
mpagenko | a40e99a | 2020-11-17 13:50:39 +0000 | [diff] [blame] | 2280 | /* 200605: lock processing after initial MIBUpload removed now as the ONU should be in the lock state per default here */ |
| 2281 | /* 201117: build_dt-berlin-pod-openonugo_1T8GEM_voltha_DT_openonugo_master_test runs into error TC |
| 2282 | * 'Test Disable ONUs and OLT Then Delete ONUs and OLT for DT' with Sercom ONU, which obviously needs |
| 2283 | * disable/enable toggling here to allow traffic |
| 2284 | * but moreover it might be useful for tracking the interface operState changes if this will be implemented, |
| 2285 | * like the py comment says: |
| 2286 | * # start by locking all the unis till mib sync and initial mib is downloaded |
| 2287 | * # this way we can capture the port down/up events when we are ready |
| 2288 | */ |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2289 | |
mpagenko | a40e99a | 2020-11-17 13:50:39 +0000 | [diff] [blame] | 2290 | // Init Uni Ports to Admin locked state |
| 2291 | // *** should generate UniLockStateDone event ***** |
| 2292 | if dh.pLockStateFsm == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2293 | dh.createUniLockFsm(ctx, true, cmn.UniLockStateDone) |
mpagenko | a40e99a | 2020-11-17 13:50:39 +0000 | [diff] [blame] | 2294 | } else { //LockStateFSM already init |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2295 | dh.pLockStateFsm.SetSuccessEvent(cmn.UniLockStateDone) |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2296 | dh.runUniLockFsm(ctx, true) |
mpagenko | a40e99a | 2020-11-17 13:50:39 +0000 | [diff] [blame] | 2297 | } |
| 2298 | } |
| 2299 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2300 | func (dh *deviceHandler) processUniLockStateDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) { |
| 2301 | logger.Infow(ctx, "UniLockStateDone event: Starting MIB download", log.Fields{"device-id": dh.DeviceID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2302 | /* Mib download procedure - |
| 2303 | ***** should run over 'downloaded' state and generate MibDownloadDone event ***** |
| 2304 | */ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2305 | pDevEntry := dh.GetOnuDeviceEntry(ctx, false) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2306 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2307 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2308 | return |
| 2309 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2310 | pMibDlFsm := pDevEntry.PMibDownloadFsm.PFsm |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2311 | if pMibDlFsm != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2312 | if pMibDlFsm.Is(mib.DlStDisabled) { |
| 2313 | if err := pMibDlFsm.Event(mib.DlEvStart); err != nil { |
| 2314 | logger.Errorw(ctx, "MibDownloadFsm: Can't go to state starting", log.Fields{"device-id": dh.DeviceID, "err": err}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2315 | // maybe try a FSM reset and then again ... - TODO!!! |
| 2316 | } else { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 2317 | logger.Debugw(ctx, "MibDownloadFsm", log.Fields{"device-id": dh.DeviceID, "state": string(pMibDlFsm.Current())}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2318 | // maybe use more specific states here for the specific download steps ... |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2319 | if err := pMibDlFsm.Event(mib.DlEvCreateGal); err != nil { |
| 2320 | logger.Errorw(ctx, "MibDownloadFsm: Can't start CreateGal", log.Fields{"device-id": dh.DeviceID, "err": err}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2321 | } else { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 2322 | logger.Debugw(ctx, "state of MibDownloadFsm", log.Fields{"device-id": dh.DeviceID, "state": string(pMibDlFsm.Current())}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2323 | //Begin MIB data download (running autonomously) |
| 2324 | } |
| 2325 | } |
| 2326 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2327 | logger.Errorw(ctx, "wrong state of MibDownloadFsm - want: disabled", log.Fields{"have": string(pMibDlFsm.Current()), |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2328 | "device-id": dh.DeviceID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2329 | // maybe try a FSM reset and then again ... - TODO!!! |
| 2330 | } |
| 2331 | /***** Mib download started */ |
| 2332 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2333 | logger.Errorw(ctx, "MibDownloadFsm invalid - cannot be executed!!", log.Fields{"device-id": dh.DeviceID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2334 | } |
| 2335 | } |
| 2336 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2337 | func (dh *deviceHandler) processMibDownloadDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) { |
| 2338 | logger.Debugw(ctx, "MibDownloadDone event received, unlocking the ONU interfaces", log.Fields{"device-id": dh.DeviceID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2339 | //initiate DevStateUpdate |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2340 | if !dh.IsReconciling() { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2341 | logger.Debugw(ctx, "call DeviceStateUpdate upon mib-download done", log.Fields{"ConnectStatus": voltha.ConnectStatus_REACHABLE, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2342 | "OperStatus": voltha.OperStatus_ACTIVE, "device-id": dh.DeviceID}) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 2343 | //we allow a possible OnuSw image commit only in the normal startup, not at reconciling |
| 2344 | // in case of adapter restart connected to an ONU upgrade I would not rely on the image quality |
| 2345 | // maybe some 'forced' commitment can be done in this situation from system management (or upgrade restarted) |
| 2346 | dh.checkOnOnuImageCommit(ctx) |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 2347 | if err := dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2348 | DeviceId: dh.DeviceID, |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2349 | ConnStatus: voltha.ConnectStatus_REACHABLE, |
| 2350 | OperStatus: voltha.OperStatus_ACTIVE, |
| 2351 | }); err != nil { |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2352 | //TODO with VOL-3045/VOL-3046: return the error and stop further processing |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2353 | logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2354 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2355 | logger.Debugw(ctx, "dev state updated to 'Oper.Active'", log.Fields{"device-id": dh.DeviceID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2356 | } |
| 2357 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2358 | logger.Debugw(ctx, "reconciling - don't notify core about DeviceStateUpdate to ACTIVE", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2359 | log.Fields{"device-id": dh.DeviceID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2360 | } |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 2361 | _ = dh.ReasonUpdate(ctx, cmn.DrInitialMibDownloaded, !dh.IsReconciling() || dh.IsReconcilingReasonUpdate()) |
Girish Gowdra | e0140f0 | 2021-02-02 16:55:09 -0800 | [diff] [blame] | 2362 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2363 | if !dh.GetCollectorIsRunning() { |
Girish Gowdra | 7b0ee5c | 2021-03-19 21:48:15 -0700 | [diff] [blame] | 2364 | // Start PM collector routine |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2365 | go dh.StartCollector(ctx) |
Girish Gowdra | 7b0ee5c | 2021-03-19 21:48:15 -0700 | [diff] [blame] | 2366 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2367 | if !dh.GetAlarmManagerIsRunning(ctx) { |
| 2368 | go dh.StartAlarmManager(ctx) |
Girish Gowdra | 7b0ee5c | 2021-03-19 21:48:15 -0700 | [diff] [blame] | 2369 | } |
| 2370 | |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 2371 | // Start flow handler routines per UNI |
| 2372 | for _, uniPort := range dh.uniEntityMap { |
| 2373 | // only if this port was enabled for use by the operator at startup |
| 2374 | if (1<<uniPort.UniID)&dh.pOpenOnuAc.config.UniPortMask == (1 << uniPort.UniID) { |
| 2375 | if !dh.GetFlowMonitoringIsRunning(uniPort.UniID) { |
| 2376 | go dh.PerOnuFlowHandlerRoutine(uniPort.UniID) |
| 2377 | } |
| 2378 | } |
| 2379 | } |
| 2380 | |
Girish Gowdra | e0140f0 | 2021-02-02 16:55:09 -0800 | [diff] [blame] | 2381 | // Initialize classical L2 PM Interval Counters |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2382 | if err := dh.pOnuMetricsMgr.PAdaptFsm.PFsm.Event(pmmgr.L2PmEventInit); err != nil { |
Girish Gowdra | e0140f0 | 2021-02-02 16:55:09 -0800 | [diff] [blame] | 2383 | // There is no way we should be landing here, but if we do then |
| 2384 | // there is nothing much we can do about this other than log error |
| 2385 | logger.Errorw(ctx, "error starting l2 pm fsm", log.Fields{"device-id": dh.device.Id, "err": err}) |
| 2386 | } |
| 2387 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2388 | dh.SetReadyForOmciConfig(true) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2389 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2390 | pDevEntry := dh.GetOnuDeviceEntry(ctx, false) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2391 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2392 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2393 | return |
| 2394 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2395 | pDevEntry.MutexPersOnuConfig.RLock() |
| 2396 | if dh.IsReconciling() && pDevEntry.SOnuPersistentData.PersUniDisableDone { |
| 2397 | pDevEntry.MutexPersOnuConfig.RUnlock() |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2398 | logger.Debugw(ctx, "reconciling - uni-ports were disabled by admin before adapter restart - keep the ports locked", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2399 | log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 7741f27 | 2022-01-18 08:17:39 +0000 | [diff] [blame^] | 2400 | dh.ReconcileDeviceTechProf(ctx) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2401 | // reconcilement will be continued after ani config is done |
| 2402 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2403 | pDevEntry.MutexPersOnuConfig.RUnlock() |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2404 | // *** should generate UniUnlockStateDone event ***** |
| 2405 | if dh.pUnlockStateFsm == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2406 | dh.createUniLockFsm(ctx, false, cmn.UniUnlockStateDone) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2407 | } else { //UnlockStateFSM already init |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2408 | dh.pUnlockStateFsm.SetSuccessEvent(cmn.UniUnlockStateDone) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2409 | dh.runUniLockFsm(ctx, false) |
| 2410 | } |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2411 | } |
| 2412 | } |
| 2413 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2414 | func (dh *deviceHandler) processUniUnlockStateDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) { |
| 2415 | dh.EnableUniPortStateUpdate(ctx) //cmp python yield self.enable_ports() |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2416 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2417 | if !dh.IsReconciling() { |
| 2418 | logger.Infow(ctx, "UniUnlockStateDone event: Sending OnuUp event", log.Fields{"device-id": dh.DeviceID}) |
ozgecanetsia | 2f05ed3 | 2021-05-31 17:13:48 +0300 | [diff] [blame] | 2419 | raisedTs := time.Now().Unix() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2420 | go dh.sendOnuOperStateEvent(ctx, voltha.OperStatus_ACTIVE, dh.DeviceID, raisedTs) //cmp python onu_active_event |
| 2421 | pDevEntry := dh.GetOnuDeviceEntry(ctx, false) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2422 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2423 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2424 | return |
| 2425 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2426 | pDevEntry.MutexPersOnuConfig.Lock() |
| 2427 | pDevEntry.SOnuPersistentData.PersUniUnlockDone = true |
| 2428 | pDevEntry.MutexPersOnuConfig.Unlock() |
| 2429 | if err := dh.StorePersistentData(ctx); err != nil { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2430 | logger.Warnw(ctx, "store persistent data error - continue for now as there will be additional write attempts", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2431 | log.Fields{"device-id": dh.DeviceID, "err": err}) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2432 | } |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2433 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2434 | logger.Debugw(ctx, "reconciling - don't notify core that onu went to active but trigger tech profile config", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2435 | log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 7741f27 | 2022-01-18 08:17:39 +0000 | [diff] [blame^] | 2436 | dh.ReconcileDeviceTechProf(ctx) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 2437 | // reconcilement will be continued after ani config is done |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2438 | } |
| 2439 | } |
| 2440 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2441 | func (dh *deviceHandler) processUniDisableStateDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) { |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 2442 | logger.Debugw(ctx, "DeviceStateUpdate upon disable", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2443 | "OperStatus": voltha.OperStatus_UNKNOWN, "device-id": dh.DeviceID}) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2444 | |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 2445 | // disable device should have no impact on ConnStatus |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 2446 | if err := dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2447 | DeviceId: dh.DeviceID, |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 2448 | ConnStatus: connectStatusINVALID, //use some dummy value to prevent modification of the ConnStatus |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2449 | OperStatus: voltha.OperStatus_UNKNOWN, |
| 2450 | }); err != nil { |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2451 | //TODO with VOL-3045/VOL-3046: return the error and stop further processing |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2452 | logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err}) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2453 | } |
| 2454 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2455 | logger.Debugw(ctx, "DeviceReasonUpdate upon disable", log.Fields{"reason": cmn.DeviceReasonMap[cmn.DrOmciAdminLock], "device-id": dh.DeviceID}) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2456 | // DeviceReason to update acc.to modified py code as per beginning of Sept 2020 |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 2457 | _ = dh.ReasonUpdate(ctx, cmn.DrOmciAdminLock, true) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2458 | |
| 2459 | //transfer the modified logical uni port state |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2460 | dh.DisableUniPortStateUpdate(ctx) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2461 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2462 | pDevEntry := dh.GetOnuDeviceEntry(ctx, false) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2463 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2464 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2465 | return |
| 2466 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2467 | pDevEntry.MutexPersOnuConfig.Lock() |
| 2468 | pDevEntry.SOnuPersistentData.PersUniDisableDone = true |
| 2469 | pDevEntry.MutexPersOnuConfig.Unlock() |
| 2470 | if err := dh.StorePersistentData(ctx); err != nil { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2471 | logger.Warnw(ctx, "store persistent data error - continue for now as there will be additional write attempts", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2472 | log.Fields{"device-id": dh.DeviceID, "err": err}) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2473 | } |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2474 | } |
| 2475 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2476 | func (dh *deviceHandler) processUniEnableStateDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2477 | logger.Debugw(ctx, "DeviceStateUpdate upon re-enable", log.Fields{"ConnectStatus": voltha.ConnectStatus_REACHABLE, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2478 | "OperStatus": voltha.OperStatus_ACTIVE, "device-id": dh.DeviceID}) |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 2479 | if err := dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2480 | DeviceId: dh.DeviceID, |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2481 | ConnStatus: voltha.ConnectStatus_REACHABLE, |
| 2482 | OperStatus: voltha.OperStatus_ACTIVE, |
| 2483 | }); err != nil { |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2484 | //TODO with VOL-3045/VOL-3046: return the error and stop further processing |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2485 | logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err}) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2486 | } |
| 2487 | |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2488 | logger.Debugw(ctx, "DeviceReasonUpdate upon re-enable", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2489 | "reason": cmn.DeviceReasonMap[cmn.DrOnuReenabled], "device-id": dh.DeviceID}) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2490 | // DeviceReason to update acc.to modified py code as per beginning of Sept 2020 |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 2491 | _ = dh.ReasonUpdate(ctx, cmn.DrOnuReenabled, true) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2492 | |
| 2493 | //transfer the modified logical uni port state |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2494 | dh.EnableUniPortStateUpdate(ctx) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2495 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2496 | pDevEntry := dh.GetOnuDeviceEntry(ctx, false) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2497 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2498 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2499 | return |
| 2500 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2501 | pDevEntry.MutexPersOnuConfig.Lock() |
| 2502 | pDevEntry.SOnuPersistentData.PersUniDisableDone = false |
| 2503 | pDevEntry.MutexPersOnuConfig.Unlock() |
| 2504 | if err := dh.StorePersistentData(ctx); err != nil { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2505 | logger.Warnw(ctx, "store persistent data error - continue for now as there will be additional write attempts", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2506 | log.Fields{"device-id": dh.DeviceID, "err": err}) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 2507 | } |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2508 | } |
| 2509 | |
Mahir Gunyel | 50ddea6 | 2021-10-22 11:26:42 -0700 | [diff] [blame] | 2510 | func (dh *deviceHandler) processUniEnableStateFailedEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) { |
| 2511 | logger.Debugw(ctx, "DeviceStateUpdate upon re-enable failure. ", log.Fields{ |
| 2512 | "OperStatus": voltha.OperStatus_FAILED, "device-id": dh.DeviceID}) |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 2513 | if err := dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{ |
Mahir Gunyel | 50ddea6 | 2021-10-22 11:26:42 -0700 | [diff] [blame] | 2514 | DeviceId: dh.DeviceID, |
mpagenko | 44bd836 | 2021-11-15 11:40:05 +0000 | [diff] [blame] | 2515 | ConnStatus: connectStatusINVALID, //use some dummy value to prevent modification of the ConnStatus |
Mahir Gunyel | 50ddea6 | 2021-10-22 11:26:42 -0700 | [diff] [blame] | 2516 | OperStatus: voltha.OperStatus_FAILED, |
| 2517 | }); err != nil { |
| 2518 | logger.Errorw(ctx, "error-updating-device-state", log.Fields{"device-id": dh.DeviceID, "error": err}) |
| 2519 | } |
| 2520 | } |
| 2521 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2522 | func (dh *deviceHandler) processOmciAniConfigDoneEvent(ctx context.Context, devEvent cmn.OnuDeviceEvent) { |
| 2523 | if devEvent == cmn.OmciAniConfigDone { |
| 2524 | logger.Debugw(ctx, "OmciAniConfigDone event received", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 2525 | // attention: the device reason update is done based on ONU-UNI-Port related activity |
| 2526 | // - which may cause some inconsistency |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2527 | if dh.getDeviceReason() != cmn.DrTechProfileConfigDownloadSuccess { |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 2528 | // which may be the case from some previous activity even on this UNI Port (but also other UNI ports) |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 2529 | _ = dh.ReasonUpdate(ctx, cmn.DrTechProfileConfigDownloadSuccess, !dh.IsReconciling() || dh.IsReconcilingReasonUpdate()) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2530 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2531 | if dh.IsReconciling() { |
Holger Hildebrandt | 7741f27 | 2022-01-18 08:17:39 +0000 | [diff] [blame^] | 2532 | // during reconciling with OMCI configuration in TT multi-UNI scenario, OmciAniConfigDone is reached several times |
| 2533 | // therefore it must be ensured that reconciling of flow config is only started on the first pass of this code position |
| 2534 | dh.mutexReconcilingFirstPassFlag.Lock() |
| 2535 | if dh.reconcilingFirstPass { |
| 2536 | logger.Debugw(ctx, "reconciling - OmciAniConfigDone first pass, start flow processing", log.Fields{"device-id": dh.DeviceID}) |
| 2537 | dh.reconcilingFirstPass = false |
| 2538 | go dh.ReconcileDeviceFlowConfig(ctx) |
| 2539 | } |
| 2540 | dh.mutexReconcilingFirstPassFlag.Unlock() |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 2541 | } |
| 2542 | } else { // should be the OmciAniResourceRemoved block |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2543 | logger.Debugw(ctx, "OmciAniResourceRemoved event received", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 2544 | // attention: the device reason update is done based on ONU-UNI-Port related activity |
| 2545 | // - which may cause some inconsistency |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2546 | if dh.getDeviceReason() != cmn.DrTechProfileConfigDeleteSuccess { |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 2547 | // which may be the case from some previous activity even on this ONU port (but also other UNI ports) |
| 2548 | _ = dh.ReasonUpdate(ctx, cmn.DrTechProfileConfigDeleteSuccess, true) |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 2549 | } |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 2550 | } |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2551 | } |
| 2552 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2553 | func (dh *deviceHandler) processOmciVlanFilterDoneEvent(ctx context.Context, aDevEvent cmn.OnuDeviceEvent) { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2554 | logger.Debugw(ctx, "OmciVlanFilterDone event received", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2555 | log.Fields{"device-id": dh.DeviceID, "event": aDevEvent}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2556 | // attention: the device reason update is done based on ONU-UNI-Port related activity |
| 2557 | // - which may cause some inconsistency |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2558 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2559 | if aDevEvent == cmn.OmciVlanFilterAddDone || aDevEvent == cmn.OmciVlanFilterAddDoneNoKvStore { |
| 2560 | if dh.getDeviceReason() != cmn.DrOmciFlowsPushed { |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 2561 | // which may be the case from some previous activity on another UNI Port of the ONU |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 2562 | // or even some previous flow add activity on the same port |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 2563 | _ = dh.ReasonUpdate(ctx, cmn.DrOmciFlowsPushed, !dh.IsReconciling() || dh.IsReconcilingReasonUpdate()) |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 2564 | } |
| 2565 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2566 | if dh.getDeviceReason() != cmn.DrOmciFlowsDeleted { |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 2567 | //not relevant for reconcile |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 2568 | _ = dh.ReasonUpdate(ctx, cmn.DrOmciFlowsDeleted, true) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 2569 | } |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2570 | } |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 2571 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2572 | if aDevEvent == cmn.OmciVlanFilterAddDone || aDevEvent == cmn.OmciVlanFilterRemDone { |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 2573 | //events that request KvStore write |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2574 | if err := dh.StorePersistentData(ctx); err != nil { |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 2575 | logger.Warnw(ctx, "store persistent data error - continue for now as there will be additional write attempts", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2576 | log.Fields{"device-id": dh.DeviceID, "err": err}) |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 2577 | } |
| 2578 | } else { |
| 2579 | logger.Debugw(ctx, "OmciVlanFilter*Done* - write to KvStore not requested", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2580 | log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 2581 | } |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2582 | } |
| 2583 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2584 | //DeviceProcStatusUpdate evaluates possible processing events and initiates according next activities |
| 2585 | func (dh *deviceHandler) DeviceProcStatusUpdate(ctx context.Context, devEvent cmn.OnuDeviceEvent) { |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2586 | switch devEvent { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2587 | case cmn.MibDatabaseSync: |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2588 | { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2589 | dh.processMibDatabaseSyncEvent(ctx, devEvent) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2590 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2591 | case cmn.UniLockStateDone: |
mpagenko | a40e99a | 2020-11-17 13:50:39 +0000 | [diff] [blame] | 2592 | { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2593 | dh.processUniLockStateDoneEvent(ctx, devEvent) |
mpagenko | a40e99a | 2020-11-17 13:50:39 +0000 | [diff] [blame] | 2594 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2595 | case cmn.MibDownloadDone: |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2596 | { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2597 | dh.processMibDownloadDoneEvent(ctx, devEvent) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2598 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2599 | case cmn.UniUnlockStateDone: |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2600 | { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2601 | dh.processUniUnlockStateDoneEvent(ctx, devEvent) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2602 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2603 | case cmn.UniEnableStateDone: |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2604 | { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2605 | dh.processUniEnableStateDoneEvent(ctx, devEvent) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2606 | } |
Mahir Gunyel | 50ddea6 | 2021-10-22 11:26:42 -0700 | [diff] [blame] | 2607 | case cmn.UniEnableStateFailed: |
| 2608 | { |
| 2609 | dh.processUniEnableStateFailedEvent(ctx, devEvent) |
| 2610 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2611 | case cmn.UniDisableStateDone: |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2612 | { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2613 | dh.processUniDisableStateDoneEvent(ctx, devEvent) |
mpagenko | 900ee4b | 2020-10-12 11:56:34 +0000 | [diff] [blame] | 2614 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2615 | case cmn.OmciAniConfigDone, cmn.OmciAniResourceRemoved: |
mpagenko | 3dbcdd2 | 2020-07-22 07:38:45 +0000 | [diff] [blame] | 2616 | { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2617 | dh.processOmciAniConfigDoneEvent(ctx, devEvent) |
mpagenko | 3dbcdd2 | 2020-07-22 07:38:45 +0000 | [diff] [blame] | 2618 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2619 | case cmn.OmciVlanFilterAddDone, cmn.OmciVlanFilterAddDoneNoKvStore, cmn.OmciVlanFilterRemDone, cmn.OmciVlanFilterRemDoneNoKvStore: |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 2620 | { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2621 | dh.processOmciVlanFilterDoneEvent(ctx, devEvent) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 2622 | } |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2623 | default: |
| 2624 | { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2625 | logger.Debugw(ctx, "unhandled-device-event", log.Fields{"device-id": dh.DeviceID, "event": devEvent}) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2626 | } |
| 2627 | } //switch |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 2628 | } |
| 2629 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2630 | func (dh *deviceHandler) addUniPort(ctx context.Context, aUniInstNo uint16, aUniID uint8, aPortType cmn.UniPortType) { |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2631 | // parameters are IntfId, OnuId, uniId |
Mahir Gunyel | cb128ae | 2021-10-06 09:42:05 -0700 | [diff] [blame] | 2632 | uniNo := platform.MkUniPortNum(ctx, dh.pOnuIndication.GetIntfId(), dh.pOnuIndication.GetOnuId(), |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2633 | uint32(aUniID)) |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2634 | if _, present := dh.uniEntityMap[uniNo]; present { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 2635 | logger.Warnw(ctx, "OnuUniPort-add: Port already exists", log.Fields{"device-id": dh.DeviceID, "for InstanceId": aUniInstNo}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 2636 | } else { |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2637 | //with arguments aUniID, a_portNo, aPortType |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2638 | pUniPort := cmn.NewOnuUniPort(ctx, aUniID, uniNo, aUniInstNo, aPortType) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 2639 | if pUniPort == nil { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 2640 | logger.Warnw(ctx, "OnuUniPort-add: Could not create Port", log.Fields{"device-id": dh.DeviceID, "for InstanceId": aUniInstNo}) |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 2641 | } else { |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2642 | //store UniPort with the System-PortNumber key |
| 2643 | dh.uniEntityMap[uniNo] = pUniPort |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2644 | if !dh.IsReconciling() { |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 2645 | // create announce the UniPort to the core as VOLTHA Port object |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2646 | if err := pUniPort.CreateVolthaPort(ctx, dh); err == nil { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 2647 | logger.Infow(ctx, "OnuUniPort-added", log.Fields{"device-id": dh.DeviceID, "for PortNo": uniNo}) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 2648 | } //error logging already within UniPort method |
| 2649 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2650 | logger.Debugw(ctx, "reconciling - OnuUniPort already added", log.Fields{"for PortNo": uniNo, "device-id": dh.DeviceID}) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 2651 | } |
Holger Hildebrandt | 0f9b88d | 2020-04-20 13:33:25 +0000 | [diff] [blame] | 2652 | } |
| 2653 | } |
| 2654 | } |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2655 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2656 | func (dh *deviceHandler) AddAllUniPorts(ctx context.Context) { |
| 2657 | pDevEntry := dh.GetOnuDeviceEntry(ctx, false) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2658 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2659 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2660 | return |
| 2661 | } |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 2662 | uniCnt := uint8(0) //UNI Port limit: see MaxUnisPerOnu (by now 16) (OMCI supports max 255 p.b.) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2663 | if pptpInstKeys := pDevEntry.GetOnuDB().GetSortedInstKeys( |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2664 | ctx, me.PhysicalPathTerminationPointEthernetUniClassID); len(pptpInstKeys) > 0 { |
| 2665 | for _, mgmtEntityID := range pptpInstKeys { |
| 2666 | logger.Debugw(ctx, "Add PPTPEthUni port for MIB-stored instance:", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2667 | "device-id": dh.DeviceID, "PPTPEthUni EntityID": mgmtEntityID}) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 2668 | dh.addUniPort(ctx, mgmtEntityID, uniCnt, cmn.UniPPTP) |
| 2669 | uniCnt++ |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2670 | } |
| 2671 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2672 | logger.Debugw(ctx, "No PPTP instances found", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2673 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2674 | if veipInstKeys := pDevEntry.GetOnuDB().GetSortedInstKeys( |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2675 | ctx, me.VirtualEthernetInterfacePointClassID); len(veipInstKeys) > 0 { |
| 2676 | for _, mgmtEntityID := range veipInstKeys { |
| 2677 | logger.Debugw(ctx, "Add VEIP for MIB-stored instance:", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2678 | "device-id": dh.DeviceID, "VEIP EntityID": mgmtEntityID}) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 2679 | dh.addUniPort(ctx, mgmtEntityID, uniCnt, cmn.UniVEIP) |
| 2680 | uniCnt++ |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2681 | } |
| 2682 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2683 | logger.Debugw(ctx, "No VEIP instances found", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2684 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2685 | if potsInstKeys := pDevEntry.GetOnuDB().GetSortedInstKeys( |
ozgecanetsia | 124d973 | 2021-09-16 14:31:57 +0300 | [diff] [blame] | 2686 | ctx, me.PhysicalPathTerminationPointPotsUniClassID); len(potsInstKeys) > 0 { |
| 2687 | for _, mgmtEntityID := range potsInstKeys { |
| 2688 | logger.Debugw(ctx, "Add PPTP Pots UNI for MIB-stored instance:", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2689 | "device-id": dh.DeviceID, "PPTP Pots UNI EntityID": mgmtEntityID}) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 2690 | dh.addUniPort(ctx, mgmtEntityID, uniCnt, cmn.UniPPTPPots) |
| 2691 | uniCnt++ |
ozgecanetsia | 124d973 | 2021-09-16 14:31:57 +0300 | [diff] [blame] | 2692 | } |
| 2693 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2694 | logger.Debugw(ctx, "No PPTP Pots UNI instances found", log.Fields{"device-id": dh.DeviceID}) |
ozgecanetsia | 124d973 | 2021-09-16 14:31:57 +0300 | [diff] [blame] | 2695 | } |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 2696 | if uniCnt == 0 { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2697 | logger.Warnw(ctx, "No UniG instances found", log.Fields{"device-id": dh.DeviceID}) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 2698 | return |
| 2699 | } |
| 2700 | |
mpagenko | 2c3f6c5 | 2021-11-23 11:22:10 +0000 | [diff] [blame] | 2701 | //Note: For the moment is is not required to include the (newly added) POTS ports into the range |
| 2702 | // of flowCall or reconcile channels. But some sort of flow and reconcile processing might get necessary |
| 2703 | // also for the POTS ports, so we include them already for future usage - should anyway do no great harm |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 2704 | dh.flowCbChan = make([]chan FlowCb, uniCnt) |
| 2705 | dh.stopFlowMonitoringRoutine = make([]chan bool, uniCnt) |
| 2706 | dh.isFlowMonitoringRoutineActive = make([]bool, uniCnt) |
mpagenko | 2c3f6c5 | 2021-11-23 11:22:10 +0000 | [diff] [blame] | 2707 | //chUniVlanConfigReconcilingDone needs to have the capacity of all UniPorts as flow reconcile may run parallel for all of them |
| 2708 | dh.chUniVlanConfigReconcilingDone = make(chan uint16, uniCnt) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 2709 | for i := 0; i < int(uniCnt); i++ { |
| 2710 | dh.flowCbChan[i] = make(chan FlowCb, dh.pOpenOnuAc.config.MaxConcurrentFlowsPerUni) |
| 2711 | dh.stopFlowMonitoringRoutine[i] = make(chan bool) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2712 | } |
| 2713 | } |
| 2714 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2715 | // EnableUniPortStateUpdate enables UniPortState and update core port state accordingly |
| 2716 | func (dh *deviceHandler) EnableUniPortStateUpdate(ctx context.Context) { |
Holger Hildebrandt | be67442 | 2020-05-05 13:05:30 +0000 | [diff] [blame] | 2717 | // py code was updated 2003xx to activate the real ONU UNI ports per OMCI (VEIP or PPTP) |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2718 | // but towards core only the first port active state is signaled |
Holger Hildebrandt | be67442 | 2020-05-05 13:05:30 +0000 | [diff] [blame] | 2719 | // with following remark: |
| 2720 | // # TODO: for now only support the first UNI given no requirement for multiple uni yet. Also needed to reduce flow |
| 2721 | // # load on the core |
| 2722 | |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2723 | // lock_ports(false) as done in py code here is shifted to separate call from device event processing |
Holger Hildebrandt | be67442 | 2020-05-05 13:05:30 +0000 | [diff] [blame] | 2724 | |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2725 | for uniNo, uniPort := range dh.uniEntityMap { |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2726 | // only if this port is validated for operState transfer |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2727 | if (1<<uniPort.UniID)&dh.pOpenOnuAc.config.UniPortMask == (1 << uniPort.UniID) { |
| 2728 | logger.Infow(ctx, "OnuUniPort-forced-OperState-ACTIVE", log.Fields{"for PortNo": uniNo, "device-id": dh.DeviceID}) |
| 2729 | uniPort.SetOperState(vc.OperStatus_ACTIVE) |
| 2730 | if !dh.IsReconciling() { |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 2731 | //maybe also use getter functions on uniPort - perhaps later ... |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2732 | go func(port *cmn.OnuUniPort) { |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 2733 | if err := dh.updatePortStateInCore(ctx, &ca.PortState{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2734 | DeviceId: dh.DeviceID, |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2735 | PortType: voltha.Port_ETHERNET_UNI, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2736 | PortNo: port.PortNo, |
| 2737 | OperStatus: port.OperState, |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2738 | }); err != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2739 | logger.Errorw(ctx, "port-state-update-failed", log.Fields{"error": err, "port-no": uniPort.PortNo, "device-id": dh.DeviceID}) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2740 | } |
| 2741 | }(uniPort) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 2742 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2743 | logger.Debugw(ctx, "reconciling - don't notify core about PortStateUpdate", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | f41a160 | 2020-08-19 09:52:50 +0000 | [diff] [blame] | 2744 | } |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2745 | } |
| 2746 | } |
| 2747 | } |
| 2748 | |
| 2749 | // Disable UniPortState and update core port state accordingly |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2750 | func (dh *deviceHandler) DisableUniPortStateUpdate(ctx context.Context) { |
| 2751 | // compare EnableUniPortStateUpdate() above |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2752 | // -> use current restriction to operate only on first UNI port as inherited from actual Py code |
| 2753 | for uniNo, uniPort := range dh.uniEntityMap { |
| 2754 | // only if this port is validated for operState transfer |
Matteo Scandolo | 20d180c | 2021-06-10 17:20:21 +0200 | [diff] [blame] | 2755 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2756 | if (1<<uniPort.UniID)&dh.pOpenOnuAc.config.UniPortMask == (1 << uniPort.UniID) { |
| 2757 | logger.Infow(ctx, "OnuUniPort-forced-OperState-UNKNOWN", log.Fields{"for PortNo": uniNo, "device-id": dh.DeviceID}) |
| 2758 | uniPort.SetOperState(vc.OperStatus_UNKNOWN) |
| 2759 | if !dh.IsReconciling() { |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2760 | //maybe also use getter functions on uniPort - perhaps later ... |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2761 | go func(port *cmn.OnuUniPort) { |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 2762 | if err := dh.updatePortStateInCore(ctx, &ca.PortState{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2763 | DeviceId: dh.DeviceID, |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2764 | PortType: voltha.Port_ETHERNET_UNI, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2765 | PortNo: port.PortNo, |
| 2766 | OperStatus: port.OperState, |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2767 | }); err != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2768 | logger.Errorw(ctx, "port-state-update-failed", log.Fields{"error": err, "port-no": uniPort.PortNo, "device-id": dh.DeviceID}) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2769 | } |
| 2770 | }(uniPort) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2771 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2772 | logger.Debugw(ctx, "reconciling - don't notify core about PortStateUpdate", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 2773 | } |
| 2774 | |
Holger Hildebrandt | be67442 | 2020-05-05 13:05:30 +0000 | [diff] [blame] | 2775 | } |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2776 | } |
| 2777 | } |
| 2778 | |
| 2779 | // ONU_Active/Inactive announcement on system KAFKA bus |
| 2780 | // tried to re-use procedure of oltUpDownIndication from openolt_eventmgr.go with used values from Py code |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2781 | func (dh *deviceHandler) sendOnuOperStateEvent(ctx context.Context, aOperState vc.OperStatus_Types, aDeviceID string, raisedTs int64) { |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2782 | var de voltha.DeviceEvent |
| 2783 | eventContext := make(map[string]string) |
| 2784 | //Populating event context |
| 2785 | // assume giving ParentId in GetDevice twice really gives the ParentDevice (there is no GetParentDevice()...) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 2786 | parentDevice, err := dh.getDeviceFromCore(ctx, dh.parentID) |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2787 | if err != nil || parentDevice == nil { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2788 | logger.Errorw(ctx, "Failed to fetch parent device for OnuEvent", |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 2789 | log.Fields{"device-id": dh.DeviceID, "parentID": dh.parentID, "err": err}) |
Holger Hildebrandt | 7ec14c4 | 2021-05-28 14:21:58 +0000 | [diff] [blame] | 2790 | return //TODO with VOL-3045: rw-core is unresponsive: report error and/or perform self-initiated onu-reset? |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2791 | } |
| 2792 | oltSerialNumber := parentDevice.SerialNumber |
| 2793 | |
| 2794 | eventContext["pon-id"] = strconv.FormatUint(uint64(dh.pOnuIndication.IntfId), 10) |
| 2795 | eventContext["onu-id"] = strconv.FormatUint(uint64(dh.pOnuIndication.OnuId), 10) |
| 2796 | eventContext["serial-number"] = dh.device.SerialNumber |
ssiddiqui | 1221d1a | 2021-02-15 11:12:51 +0530 | [diff] [blame] | 2797 | eventContext["olt-serial-number"] = oltSerialNumber |
| 2798 | eventContext["device-id"] = aDeviceID |
| 2799 | eventContext["registration-id"] = aDeviceID //py: string(device_id)?? |
ozgecanetsia | f0a76b6 | 2021-05-31 17:42:09 +0300 | [diff] [blame] | 2800 | eventContext["num-of-unis"] = strconv.Itoa(len(dh.uniEntityMap)) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2801 | if deviceEntry := dh.GetOnuDeviceEntry(ctx, false); deviceEntry != nil { |
| 2802 | deviceEntry.MutexPersOnuConfig.RLock() |
| 2803 | eventContext["equipment-id"] = deviceEntry.SOnuPersistentData.PersEquipmentID |
| 2804 | deviceEntry.MutexPersOnuConfig.RUnlock() |
| 2805 | eventContext["software-version"] = deviceEntry.GetActiveImageVersion(ctx) |
| 2806 | deviceEntry.MutexPersOnuConfig.RLock() |
| 2807 | eventContext["vendor"] = deviceEntry.SOnuPersistentData.PersVendorID |
| 2808 | deviceEntry.MutexPersOnuConfig.RUnlock() |
| 2809 | eventContext["inactive-software-version"] = deviceEntry.GetInactiveImageVersion(ctx) |
ozgecanetsia | f0a76b6 | 2021-05-31 17:42:09 +0300 | [diff] [blame] | 2810 | logger.Debugw(ctx, "prepare ONU_ACTIVATED event", |
| 2811 | log.Fields{"device-id": aDeviceID, "EventContext": eventContext}) |
| 2812 | } else { |
| 2813 | logger.Errorw(ctx, "Failed to fetch device-entry. ONU_ACTIVATED event is not sent", |
| 2814 | log.Fields{"device-id": aDeviceID}) |
| 2815 | return |
| 2816 | } |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2817 | |
| 2818 | /* Populating device event body */ |
| 2819 | de.Context = eventContext |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2820 | de.ResourceId = aDeviceID |
| 2821 | if aOperState == voltha.OperStatus_ACTIVE { |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2822 | de.DeviceEventName = fmt.Sprintf("%s_%s", cOnuActivatedEvent, "RAISE_EVENT") |
| 2823 | de.Description = fmt.Sprintf("%s Event - %s - %s", |
| 2824 | cEventObjectType, cOnuActivatedEvent, "Raised") |
| 2825 | } else { |
| 2826 | de.DeviceEventName = fmt.Sprintf("%s_%s", cOnuActivatedEvent, "CLEAR_EVENT") |
| 2827 | de.Description = fmt.Sprintf("%s Event - %s - %s", |
| 2828 | cEventObjectType, cOnuActivatedEvent, "Cleared") |
| 2829 | } |
| 2830 | /* Send event to KAFKA */ |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2831 | if err := dh.EventProxy.SendDeviceEvent(ctx, &de, equipment, pon, raisedTs); err != nil { |
| 2832 | logger.Warnw(ctx, "could not send ONU_ACTIVATED event", |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2833 | log.Fields{"device-id": aDeviceID, "error": err}) |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2834 | } |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2835 | logger.Debugw(ctx, "ctx, ONU_ACTIVATED event sent to KAFKA", |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2836 | log.Fields{"device-id": aDeviceID, "with-EventName": de.DeviceEventName}) |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 2837 | } |
| 2838 | |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2839 | // createUniLockFsm initializes and runs the UniLock FSM to transfer the OMCI related commands for port lock/unlock |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2840 | func (dh *deviceHandler) createUniLockFsm(ctx context.Context, aAdminState bool, devEvent cmn.OnuDeviceEvent) { |
| 2841 | chLSFsm := make(chan cmn.Message, 2048) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2842 | var sFsmName string |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2843 | if aAdminState { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2844 | logger.Debugw(ctx, "createLockStateFSM", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2845 | sFsmName = "LockStateFSM" |
| 2846 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2847 | logger.Debugw(ctx, "createUnlockStateFSM", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2848 | sFsmName = "UnLockStateFSM" |
| 2849 | } |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2850 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2851 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2852 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2853 | logger.Errorw(ctx, "No valid OnuDevice -aborting", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 3af1f03 | 2020-06-10 08:53:41 +0000 | [diff] [blame] | 2854 | return |
| 2855 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2856 | pLSFsm := uniprt.NewLockStateFsm(ctx, aAdminState, devEvent, sFsmName, dh, pDevEntry, chLSFsm) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2857 | if pLSFsm != nil { |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2858 | if aAdminState { |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2859 | dh.pLockStateFsm = pLSFsm |
| 2860 | } else { |
| 2861 | dh.pUnlockStateFsm = pLSFsm |
| 2862 | } |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2863 | dh.runUniLockFsm(ctx, aAdminState) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2864 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2865 | logger.Errorw(ctx, "LockStateFSM could not be created - abort!!", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2866 | } |
| 2867 | } |
| 2868 | |
| 2869 | // runUniLockFsm starts the UniLock FSM to transfer the OMCI related commands for port lock/unlock |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2870 | func (dh *deviceHandler) runUniLockFsm(ctx context.Context, aAdminState bool) { |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2871 | /* Uni Port lock/unlock procedure - |
| 2872 | ***** should run via 'adminDone' state and generate the argument requested event ***** |
| 2873 | */ |
| 2874 | var pLSStatemachine *fsm.FSM |
Himani Chawla | 4d90833 | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 2875 | if aAdminState { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2876 | pLSStatemachine = dh.pLockStateFsm.PAdaptFsm.PFsm |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2877 | //make sure the opposite FSM is not running and if so, terminate it as not relevant anymore |
| 2878 | if (dh.pUnlockStateFsm != nil) && |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2879 | (dh.pUnlockStateFsm.PAdaptFsm.PFsm.Current() != uniprt.UniStDisabled) { |
| 2880 | _ = dh.pUnlockStateFsm.PAdaptFsm.PFsm.Event(uniprt.UniEvReset) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2881 | } |
| 2882 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2883 | pLSStatemachine = dh.pUnlockStateFsm.PAdaptFsm.PFsm |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2884 | //make sure the opposite FSM is not running and if so, terminate it as not relevant anymore |
| 2885 | if (dh.pLockStateFsm != nil) && |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2886 | (dh.pLockStateFsm.PAdaptFsm.PFsm.Current() != uniprt.UniStDisabled) { |
| 2887 | _ = dh.pLockStateFsm.PAdaptFsm.PFsm.Event(uniprt.UniEvReset) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2888 | } |
| 2889 | } |
| 2890 | if pLSStatemachine != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2891 | if pLSStatemachine.Is(uniprt.UniStDisabled) { |
| 2892 | if err := pLSStatemachine.Event(uniprt.UniEvStart); err != nil { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 2893 | logger.Warnw(ctx, "LockStateFSM: can't start", log.Fields{"device-id": dh.DeviceID, "err": err}) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2894 | // maybe try a FSM reset and then again ... - TODO!!! |
| 2895 | } else { |
| 2896 | /***** LockStateFSM started */ |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2897 | logger.Debugw(ctx, "LockStateFSM started", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2898 | "state": pLSStatemachine.Current(), "device-id": dh.DeviceID}) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2899 | } |
| 2900 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 2901 | logger.Warnw(ctx, "wrong state of LockStateFSM - want: disabled", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2902 | "have": pLSStatemachine.Current(), "device-id": dh.DeviceID}) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2903 | // maybe try a FSM reset and then again ... - TODO!!! |
| 2904 | } |
| 2905 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2906 | logger.Errorw(ctx, "LockStateFSM StateMachine invalid - cannot be executed!!", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | ccd390c | 2020-05-29 13:49:04 +0000 | [diff] [blame] | 2907 | // maybe try a FSM reset and then again ... - TODO!!! |
| 2908 | } |
| 2909 | } |
| 2910 | |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2911 | // createOnuUpgradeFsm initializes and runs the Onu Software upgrade FSM |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 2912 | // precondition: lockUpgradeFsm is already locked from caller of this function |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2913 | func (dh *deviceHandler) createOnuUpgradeFsm(ctx context.Context, apDevEntry *mib.OnuDeviceEntry, aDevEvent cmn.OnuDeviceEvent) error { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2914 | chUpgradeFsm := make(chan cmn.Message, 2048) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2915 | var sFsmName = "OnuSwUpgradeFSM" |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2916 | logger.Debugw(ctx, "create OnuSwUpgradeFSM", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 2917 | if apDevEntry.PDevOmciCC == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2918 | logger.Errorw(ctx, "no valid OnuDevice or omciCC - abort", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 2919 | return fmt.Errorf(fmt.Sprintf("no valid omciCC - abort for device-id: %s", dh.device.Id)) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2920 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2921 | dh.pOnuUpradeFsm = swupg.NewOnuUpgradeFsm(ctx, dh, apDevEntry, apDevEntry.GetOnuDB(), aDevEvent, |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2922 | sFsmName, chUpgradeFsm) |
| 2923 | if dh.pOnuUpradeFsm != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2924 | pUpgradeStatemachine := dh.pOnuUpradeFsm.PAdaptFsm.PFsm |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2925 | if pUpgradeStatemachine != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2926 | if pUpgradeStatemachine.Is(swupg.UpgradeStDisabled) { |
| 2927 | if err := pUpgradeStatemachine.Event(swupg.UpgradeEvStart); err != nil { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 2928 | logger.Errorw(ctx, "OnuSwUpgradeFSM: can't start", log.Fields{"device-id": dh.DeviceID, "err": err}) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2929 | // maybe try a FSM reset and then again ... - TODO!!! |
| 2930 | return fmt.Errorf(fmt.Sprintf("OnuSwUpgradeFSM could not be started for device-id: %s", dh.device.Id)) |
| 2931 | } |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 2932 | /***** Upgrade FSM started */ |
mpagenko | 4558676 | 2021-10-01 08:30:22 +0000 | [diff] [blame] | 2933 | //reset the last stored upgrade states (which anyway should be don't care as long as the newly created FSM exists) |
| 2934 | (*dh.pLastUpgradeImageState).DownloadState = voltha.ImageState_DOWNLOAD_UNKNOWN |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 2935 | (*dh.pLastUpgradeImageState).Reason = voltha.ImageState_NO_ERROR |
| 2936 | (*dh.pLastUpgradeImageState).ImageState = voltha.ImageState_IMAGE_UNKNOWN |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2937 | logger.Debugw(ctx, "OnuSwUpgradeFSM started", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2938 | "state": pUpgradeStatemachine.Current(), "device-id": dh.DeviceID}) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2939 | } else { |
| 2940 | logger.Errorw(ctx, "wrong state of OnuSwUpgradeFSM to start - want: disabled", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2941 | "have": pUpgradeStatemachine.Current(), "device-id": dh.DeviceID}) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2942 | // maybe try a FSM reset and then again ... - TODO!!! |
| 2943 | return fmt.Errorf(fmt.Sprintf("OnuSwUpgradeFSM could not be started for device-id: %s, wrong internal state", dh.device.Id)) |
| 2944 | } |
| 2945 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2946 | logger.Errorw(ctx, "OnuSwUpgradeFSM internal FSM invalid - cannot be executed!!", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2947 | // maybe try a FSM reset and then again ... - TODO!!! |
| 2948 | return fmt.Errorf(fmt.Sprintf("OnuSwUpgradeFSM internal FSM could not be created for device-id: %s", dh.device.Id)) |
| 2949 | } |
| 2950 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2951 | logger.Errorw(ctx, "OnuSwUpgradeFSM could not be created - abort", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2952 | return fmt.Errorf(fmt.Sprintf("OnuSwUpgradeFSM could not be created - abort for device-id: %s", dh.device.Id)) |
| 2953 | } |
| 2954 | return nil |
| 2955 | } |
| 2956 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2957 | // RemoveOnuUpgradeFsm clears the Onu Software upgrade FSM |
| 2958 | func (dh *deviceHandler) RemoveOnuUpgradeFsm(ctx context.Context, apImageState *voltha.ImageState) { |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2959 | logger.Debugw(ctx, "remove OnuSwUpgradeFSM StateMachine", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2960 | "device-id": dh.DeviceID}) |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2961 | dh.lockUpgradeFsm.Lock() |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 2962 | dh.pOnuUpradeFsm = nil //resource clearing is left to garbage collector |
| 2963 | dh.upgradeCanceled = false //cancelation done |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 2964 | dh.pLastUpgradeImageState = apImageState |
| 2965 | dh.lockUpgradeFsm.Unlock() |
| 2966 | //signal upgradeFsm removed using non-blocking channel send |
| 2967 | select { |
| 2968 | case dh.upgradeFsmChan <- struct{}{}: |
| 2969 | default: |
| 2970 | logger.Debugw(ctx, "removed-UpgradeFsm signal not send on upgradeFsmChan (no receiver)", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2971 | "device-id": dh.DeviceID}) |
mpagenko | 38662d0 | 2021-08-11 09:45:19 +0000 | [diff] [blame] | 2972 | } |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 2973 | } |
| 2974 | |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 2975 | // checkOnOnuImageCommit verifies if the ONU is in some upgrade state that allows for image commit and if tries to commit |
| 2976 | func (dh *deviceHandler) checkOnOnuImageCommit(ctx context.Context) { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2977 | pDevEntry := dh.GetOnuDeviceEntry(ctx, false) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 2978 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2979 | logger.Errorw(ctx, "No valid OnuDevice -aborting checkOnOnuImageCommit", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 2980 | return |
| 2981 | } |
| 2982 | |
| 2983 | dh.lockUpgradeFsm.RLock() |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 2984 | //lockUpgradeFsm must be release before cancellation as this may implicitly request RemoveOnuUpgradeFsm() |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 2985 | if dh.pOnuUpradeFsm != nil { |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 2986 | if dh.upgradeCanceled { //avoid starting some new action in case it is already doing the cancelation |
| 2987 | dh.lockUpgradeFsm.RUnlock() |
| 2988 | logger.Errorw(ctx, "Some upgrade procedure still runs cancelation - abort", log.Fields{"device-id": dh.DeviceID}) |
| 2989 | return |
| 2990 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2991 | pUpgradeStatemachine := dh.pOnuUpradeFsm.PAdaptFsm.PFsm |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 2992 | if pUpgradeStatemachine != nil { |
| 2993 | // commit is only processed in case out upgrade FSM indicates the according state (for automatic commit) |
| 2994 | // (some manual forced commit could do without) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 2995 | UpgradeState := pUpgradeStatemachine.Current() |
| 2996 | if (UpgradeState == swupg.UpgradeStWaitForCommit) || |
| 2997 | (UpgradeState == swupg.UpgradeStRequestingActivate) { |
| 2998 | // also include UpgradeStRequestingActivate as it may be left in case the ActivateResponse just got lost |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 2999 | // here no need to update the upgrade image state to activated as the state will be immediately be set to committing |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3000 | if pDevEntry.IsImageToBeCommitted(ctx, dh.pOnuUpradeFsm.InactiveImageMeID) { |
mpagenko | 1f8e882 | 2021-06-25 14:10:21 +0000 | [diff] [blame] | 3001 | activeImageID, errImg := pDevEntry.GetActiveImageMeID(ctx) |
| 3002 | if errImg != nil { |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 3003 | dh.lockUpgradeFsm.RUnlock() |
mpagenko | 1f8e882 | 2021-06-25 14:10:21 +0000 | [diff] [blame] | 3004 | logger.Errorw(ctx, "OnuSwUpgradeFSM abort - could not get active image after reboot", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3005 | log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 3006 | if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation |
| 3007 | dh.upgradeCanceled = true |
| 3008 | dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_ONU_STATE) //complete abort |
| 3009 | } |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 3010 | return |
| 3011 | } |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 3012 | dh.lockUpgradeFsm.RUnlock() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3013 | if activeImageID == dh.pOnuUpradeFsm.InactiveImageMeID { |
| 3014 | if (UpgradeState == swupg.UpgradeStRequestingActivate) && !dh.pOnuUpradeFsm.GetCommitFlag(ctx) { |
mpagenko | 1f8e882 | 2021-06-25 14:10:21 +0000 | [diff] [blame] | 3015 | // if FSM was waiting on activateResponse, new image is active, but FSM shall not commit, then: |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3016 | if err := pUpgradeStatemachine.Event(swupg.UpgradeEvActivationDone); err != nil { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 3017 | logger.Errorw(ctx, "OnuSwUpgradeFSM: can't call activate-done event", |
| 3018 | log.Fields{"device-id": dh.DeviceID, "err": err}) |
mpagenko | 1f8e882 | 2021-06-25 14:10:21 +0000 | [diff] [blame] | 3019 | return |
| 3020 | } |
| 3021 | logger.Debugw(ctx, "OnuSwUpgradeFSM activate-done after reboot", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3022 | "state": UpgradeState, "device-id": dh.DeviceID}) |
mpagenko | 1f8e882 | 2021-06-25 14:10:21 +0000 | [diff] [blame] | 3023 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3024 | //FSM in waitForCommit or (UpgradeStRequestingActivate [lost ActivateResp] and commit allowed) |
| 3025 | if err := pUpgradeStatemachine.Event(swupg.UpgradeEvCommitSw); err != nil { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 3026 | logger.Errorw(ctx, "OnuSwUpgradeFSM: can't call commit event", |
| 3027 | log.Fields{"device-id": dh.DeviceID, "err": err}) |
mpagenko | 1f8e882 | 2021-06-25 14:10:21 +0000 | [diff] [blame] | 3028 | return |
| 3029 | } |
| 3030 | logger.Debugw(ctx, "OnuSwUpgradeFSM commit image requested", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3031 | "state": UpgradeState, "device-id": dh.DeviceID}) |
mpagenko | 1f8e882 | 2021-06-25 14:10:21 +0000 | [diff] [blame] | 3032 | } |
| 3033 | } else { |
| 3034 | logger.Errorw(ctx, "OnuSwUpgradeFSM waiting to commit/on ActivateResponse, but load did not start with expected image Id", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3035 | log.Fields{"device-id": dh.DeviceID}) |
mpagenko | a2b288f | 2021-10-21 11:25:27 +0000 | [diff] [blame] | 3036 | if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation |
| 3037 | dh.upgradeCanceled = true |
| 3038 | dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_ONU_STATE) //complete abort |
| 3039 | } |
mpagenko | 1f8e882 | 2021-06-25 14:10:21 +0000 | [diff] [blame] | 3040 | } |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 3041 | return |
| 3042 | } |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 3043 | dh.lockUpgradeFsm.RUnlock() |
| 3044 | logger.Errorw(ctx, "OnuSwUpgradeFSM waiting to commit, but nothing to commit on ONU - abort upgrade", |
| 3045 | log.Fields{"device-id": dh.DeviceID}) |
mpagenko | a2b288f | 2021-10-21 11:25:27 +0000 | [diff] [blame] | 3046 | if !dh.upgradeCanceled { //avoid double cancelation in case it is already doing the cancelation |
| 3047 | dh.upgradeCanceled = true |
| 3048 | dh.pOnuUpradeFsm.CancelProcessing(ctx, true, voltha.ImageState_CANCELLED_ON_ONU_STATE) //complete abort |
| 3049 | } |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 3050 | return |
| 3051 | } |
| 3052 | //upgrade FSM is active but not waiting for commit: maybe because commit flag is not set |
| 3053 | // upgrade FSM is to be informed if the current active image is the one that was used in upgrade for the download |
| 3054 | if activeImageID, err := pDevEntry.GetActiveImageMeID(ctx); err == nil { |
| 3055 | if dh.pOnuUpradeFsm.InactiveImageMeID == activeImageID { |
| 3056 | logger.Debugw(ctx, "OnuSwUpgradeFSM image state set to activated", log.Fields{ |
| 3057 | "state": pUpgradeStatemachine.Current(), "device-id": dh.DeviceID}) |
| 3058 | dh.pOnuUpradeFsm.SetImageStateActive(ctx) |
mpagenko | 183647c | 2021-06-08 15:25:04 +0000 | [diff] [blame] | 3059 | } |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 3060 | } |
| 3061 | } |
| 3062 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3063 | logger.Debugw(ctx, "no ONU image to be committed", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 3064 | } |
mpagenko | 59862f0 | 2021-10-11 08:53:18 +0000 | [diff] [blame] | 3065 | dh.lockUpgradeFsm.RUnlock() |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 3066 | } |
| 3067 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3068 | //SetBackend provides a DB backend for the specified path on the existing KV client |
| 3069 | func (dh *deviceHandler) SetBackend(ctx context.Context, aBasePathKvStore string) *db.Backend { |
Matteo Scandolo | 127c59d | 2021-01-28 11:31:18 -0800 | [diff] [blame] | 3070 | |
| 3071 | logger.Debugw(ctx, "SetKVStoreBackend", log.Fields{"IpTarget": dh.pOpenOnuAc.KVStoreAddress, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3072 | "BasePathKvStore": aBasePathKvStore, "device-id": dh.DeviceID}) |
Girish Gowdra | 50e5642 | 2021-06-01 16:46:04 -0700 | [diff] [blame] | 3073 | // kvbackend := db.NewBackend(ctx, dh.pOpenOnuAc.KVStoreType, dh.pOpenOnuAc.KVStoreAddress, dh.pOpenOnuAc.KVStoreTimeout, aBasePathKvStore) |
mpagenko | af80163 | 2020-07-03 10:00:42 +0000 | [diff] [blame] | 3074 | kvbackend := &db.Backend{ |
| 3075 | Client: dh.pOpenOnuAc.kvClient, |
| 3076 | StoreType: dh.pOpenOnuAc.KVStoreType, |
| 3077 | /* address config update acc. to [VOL-2736] */ |
Matteo Scandolo | 127c59d | 2021-01-28 11:31:18 -0800 | [diff] [blame] | 3078 | Address: dh.pOpenOnuAc.KVStoreAddress, |
mpagenko | af80163 | 2020-07-03 10:00:42 +0000 | [diff] [blame] | 3079 | Timeout: dh.pOpenOnuAc.KVStoreTimeout, |
| 3080 | PathPrefix: aBasePathKvStore} |
Holger Hildebrandt | c54939a | 2020-06-17 08:14:27 +0000 | [diff] [blame] | 3081 | |
mpagenko | af80163 | 2020-07-03 10:00:42 +0000 | [diff] [blame] | 3082 | return kvbackend |
Holger Hildebrandt | 24d5195 | 2020-05-04 14:03:42 +0000 | [diff] [blame] | 3083 | } |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 3084 | func (dh *deviceHandler) getFlowOfbFields(ctx context.Context, apFlowItem *of.OfpFlowStats, loMatchVlan *uint16, |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3085 | loAddPcp *uint8, loIPProto *uint32) { |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3086 | |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3087 | for _, field := range flow.GetOfbFields(apFlowItem) { |
| 3088 | switch field.Type { |
| 3089 | case of.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE: |
| 3090 | { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3091 | logger.Debugw(ctx, "flow type EthType", log.Fields{"device-id": dh.DeviceID, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3092 | "EthType": strconv.FormatInt(int64(field.GetEthType()), 16)}) |
| 3093 | } |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3094 | /* TT related temporary workaround - should not be needed anymore |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3095 | case of.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO: |
| 3096 | { |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3097 | *loIPProto = field.GetIpProto() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3098 | logger.Debugw("flow type IpProto", log.Fields{"device-id": dh.DeviceID, |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3099 | "IpProto": strconv.FormatInt(int64(*loIPProto), 16)}) |
| 3100 | if *loIPProto == 2 { |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3101 | // some workaround for TT workflow at proto == 2 (IGMP trap) -> ignore the flow |
| 3102 | // avoids installing invalid EVTOCD rule |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3103 | logger.Debugw("flow type IpProto 2: TT workaround: ignore flow", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3104 | log.Fields{"device-id": dh.DeviceID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3105 | return |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3106 | } |
| 3107 | } |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3108 | */ |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3109 | case of.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID: |
| 3110 | { |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3111 | *loMatchVlan = uint16(field.GetVlanVid()) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3112 | loMatchVlanMask := uint16(field.GetVlanVidMask()) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3113 | if !(*loMatchVlan == uint16(of.OfpVlanId_OFPVID_PRESENT) && |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3114 | loMatchVlanMask == uint16(of.OfpVlanId_OFPVID_PRESENT)) { |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3115 | *loMatchVlan = *loMatchVlan & 0xFFF // not transparent: copy only ID bits |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3116 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3117 | logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID, |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3118 | "VID": strconv.FormatInt(int64(*loMatchVlan), 16)}) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3119 | } |
| 3120 | case of.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP: |
| 3121 | { |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3122 | *loAddPcp = uint8(field.GetVlanPcp()) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3123 | logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3124 | "PCP": loAddPcp}) |
| 3125 | } |
| 3126 | case of.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST: |
| 3127 | { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3128 | logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3129 | "UDP-DST": strconv.FormatInt(int64(field.GetUdpDst()), 16)}) |
| 3130 | } |
| 3131 | case of.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC: |
| 3132 | { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3133 | logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3134 | "UDP-SRC": strconv.FormatInt(int64(field.GetUdpSrc()), 16)}) |
| 3135 | } |
| 3136 | case of.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST: |
| 3137 | { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3138 | logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3139 | "IPv4-DST": field.GetIpv4Dst()}) |
| 3140 | } |
| 3141 | case of.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_SRC: |
| 3142 | { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3143 | logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3144 | "IPv4-SRC": field.GetIpv4Src()}) |
| 3145 | } |
| 3146 | case of.OxmOfbFieldTypes_OFPXMT_OFB_METADATA: |
| 3147 | { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3148 | logger.Debugw(ctx, "flow field type", log.Fields{"device-id": dh.DeviceID, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3149 | "Metadata": field.GetTableMetadata()}) |
| 3150 | } |
| 3151 | /* |
| 3152 | default: |
| 3153 | { |
| 3154 | //all other entires ignored |
| 3155 | } |
| 3156 | */ |
| 3157 | } |
| 3158 | } //for all OfbFields |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3159 | } |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3160 | |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 3161 | func (dh *deviceHandler) getFlowActions(ctx context.Context, apFlowItem *of.OfpFlowStats, loSetPcp *uint8, loSetVlan *uint16) { |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3162 | for _, action := range flow.GetActions(apFlowItem) { |
| 3163 | switch action.Type { |
| 3164 | /* not used: |
| 3165 | case of.OfpActionType_OFPAT_OUTPUT: |
| 3166 | { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3167 | logger.Debugw("flow action type", log.Fields{"device-id": dh.DeviceID, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3168 | "Output": action.GetOutput()}) |
| 3169 | } |
| 3170 | */ |
| 3171 | case of.OfpActionType_OFPAT_PUSH_VLAN: |
| 3172 | { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3173 | logger.Debugw(ctx, "flow action type", log.Fields{"device-id": dh.DeviceID, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3174 | "PushEthType": strconv.FormatInt(int64(action.GetPush().Ethertype), 16)}) |
| 3175 | } |
| 3176 | case of.OfpActionType_OFPAT_SET_FIELD: |
| 3177 | { |
| 3178 | pActionSetField := action.GetSetField() |
| 3179 | if pActionSetField.Field.OxmClass != of.OfpOxmClass_OFPXMC_OPENFLOW_BASIC { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3180 | logger.Warnw(ctx, "flow action SetField invalid OxmClass (ignored)", log.Fields{"device-id": dh.DeviceID, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3181 | "OxcmClass": pActionSetField.Field.OxmClass}) |
| 3182 | } |
| 3183 | if pActionSetField.Field.GetOfbField().Type == of.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID { |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3184 | *loSetVlan = uint16(pActionSetField.Field.GetOfbField().GetVlanVid()) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3185 | logger.Debugw(ctx, "flow Set VLAN from SetField action", log.Fields{"device-id": dh.DeviceID, |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3186 | "SetVlan": strconv.FormatInt(int64(*loSetVlan), 16)}) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3187 | } else if pActionSetField.Field.GetOfbField().Type == of.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP { |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3188 | *loSetPcp = uint8(pActionSetField.Field.GetOfbField().GetVlanPcp()) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3189 | logger.Debugw(ctx, "flow Set PCP from SetField action", log.Fields{"device-id": dh.DeviceID, |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3190 | "SetPcp": *loSetPcp}) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3191 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3192 | logger.Warnw(ctx, "flow action SetField invalid FieldType", log.Fields{"device-id": dh.DeviceID, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3193 | "Type": pActionSetField.Field.GetOfbField().Type}) |
| 3194 | } |
| 3195 | } |
| 3196 | /* |
| 3197 | default: |
| 3198 | { |
| 3199 | //all other entires ignored |
| 3200 | } |
| 3201 | */ |
| 3202 | } |
| 3203 | } //for all Actions |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3204 | } |
| 3205 | |
| 3206 | //addFlowItemToUniPort parses the actual flow item to add it to the UniPort |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3207 | func (dh *deviceHandler) addFlowItemToUniPort(ctx context.Context, apFlowItem *of.OfpFlowStats, apUniPort *cmn.OnuUniPort, |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 3208 | apFlowMetaData *of.FlowMetadata, respChan *chan error) { |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3209 | var loSetVlan uint16 = uint16(of.OfpVlanId_OFPVID_NONE) //noValidEntry |
| 3210 | var loMatchVlan uint16 = uint16(of.OfpVlanId_OFPVID_PRESENT) //reserved VLANID entry |
| 3211 | var loAddPcp, loSetPcp uint8 |
| 3212 | var loIPProto uint32 |
| 3213 | /* the TechProfileId is part of the flow Metadata - compare also comment within |
| 3214 | * OLT-Adapter:openolt_flowmgr.go |
| 3215 | * Metadata 8 bytes: |
| 3216 | * Most Significant 2 Bytes = Inner VLAN |
| 3217 | * Next 2 Bytes = Tech Profile ID(TPID) |
| 3218 | * Least Significant 4 Bytes = Port ID |
| 3219 | * Flow Metadata carries Tech-Profile (TP) ID and is mandatory in all |
| 3220 | * subscriber related flows. |
| 3221 | */ |
| 3222 | |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3223 | metadata := flow.GetMetadataFromWriteMetadataAction(ctx, apFlowItem) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3224 | if metadata == 0 { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3225 | logger.Debugw(ctx, "flow-add invalid metadata - abort", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3226 | log.Fields{"device-id": dh.DeviceID}) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3227 | *respChan <- fmt.Errorf("flow-add invalid metadata: %s", dh.DeviceID) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3228 | } |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3229 | loTpID := uint8(flow.GetTechProfileIDFromWriteMetaData(ctx, metadata)) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3230 | loCookie := apFlowItem.GetCookie() |
| 3231 | loCookieSlice := []uint64{loCookie} |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3232 | logger.Debugw(ctx, "flow-add base indications", log.Fields{"device-id": dh.DeviceID, |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3233 | "TechProf-Id": loTpID, "cookie": loCookie}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3234 | |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3235 | dh.getFlowOfbFields(ctx, apFlowItem, &loMatchVlan, &loAddPcp, &loIPProto) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3236 | /* TT related temporary workaround - should not be needed anymore |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3237 | if loIPProto == 2 { |
| 3238 | // some workaround for TT workflow at proto == 2 (IGMP trap) -> ignore the flow |
| 3239 | // avoids installing invalid EVTOCD rule |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3240 | logger.Debugw("flow-add type IpProto 2: TT workaround: ignore flow", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3241 | log.Fields{"device-id": dh.DeviceID}) |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3242 | return nil |
| 3243 | } |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3244 | */ |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3245 | dh.getFlowActions(ctx, apFlowItem, &loSetPcp, &loSetVlan) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3246 | |
| 3247 | if loSetVlan == uint16(of.OfpVlanId_OFPVID_NONE) && loMatchVlan != uint16(of.OfpVlanId_OFPVID_PRESENT) { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3248 | logger.Errorw(ctx, "flow-add aborted - SetVlanId undefined, but MatchVid set", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3249 | "device-id": dh.DeviceID, "UniPort": apUniPort.PortNo, |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3250 | "set_vid": strconv.FormatInt(int64(loSetVlan), 16), |
| 3251 | "match_vid": strconv.FormatInt(int64(loMatchVlan), 16)}) |
| 3252 | //TODO!!: Use DeviceId within the error response to rwCore |
| 3253 | // likewise also in other error response cases to calling components as requested in [VOL-3458] |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3254 | *respChan <- fmt.Errorf("flow-add Set/Match VlanId inconsistent: %s", dh.DeviceID) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3255 | } |
| 3256 | if loSetVlan == uint16(of.OfpVlanId_OFPVID_NONE) && loMatchVlan == uint16(of.OfpVlanId_OFPVID_PRESENT) { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3257 | logger.Debugw(ctx, "flow-add vlan-any/copy", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3258 | loSetVlan = loMatchVlan //both 'transparent' (copy any) |
| 3259 | } else { |
| 3260 | //looks like OMCI value 4097 (copyFromOuter - for Uni double tagged) is not supported here |
| 3261 | if loSetVlan != uint16(of.OfpVlanId_OFPVID_PRESENT) { |
| 3262 | // not set to transparent |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3263 | loSetVlan &= 0x0FFF //mask VID bits as prerequisite for vlanConfigFsm |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3264 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3265 | logger.Debugw(ctx, "flow-add vlan-set", log.Fields{"device-id": dh.DeviceID}) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3266 | } |
mpagenko | 9a304ea | 2020-12-16 15:54:01 +0000 | [diff] [blame] | 3267 | |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 3268 | var meter *of.OfpMeterConfig |
ozgecanetsia | 82b91a6 | 2021-05-21 18:54:49 +0300 | [diff] [blame] | 3269 | if apFlowMetaData != nil { |
| 3270 | meter = apFlowMetaData.Meters[0] |
| 3271 | } |
mpagenko | bc4170a | 2021-08-17 16:42:10 +0000 | [diff] [blame] | 3272 | //mutex protection as the update_flow rpc maybe running concurrently for different flows, perhaps also activities |
| 3273 | // must be set including the execution of createVlanFilterFsm() to avoid unintended creation of FSM's |
| 3274 | // when different rules are requested concurrently for the same uni |
| 3275 | // (also vlan persistency data does not support multiple FSM's on the same UNI correctly!) |
| 3276 | dh.lockVlanAdd.Lock() //prevent multiple add activities to start in parallel |
| 3277 | dh.lockVlanConfig.RLock() //read protection on UniVlanConfigFsmMap (removeFlowItemFromUniPort) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3278 | logger.Debugw(ctx, "flow-add got lock", log.Fields{"device-id": dh.DeviceID, "tpID": loTpID, "uniID": apUniPort.UniID}) |
| 3279 | if _, exist := dh.UniVlanConfigFsmMap[apUniPort.UniID]; exist { |
mpagenko | bc4170a | 2021-08-17 16:42:10 +0000 | [diff] [blame] | 3280 | //SetUniFlowParams() may block on some rule that is suspended-to-add |
| 3281 | // in order to allow for according flow removal lockVlanConfig may only be used with RLock here |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3282 | // Also the error is returned to caller via response channel |
| 3283 | _ = dh.UniVlanConfigFsmMap[apUniPort.UniID].SetUniFlowParams(ctx, loTpID, loCookieSlice, |
| 3284 | loMatchVlan, loSetVlan, loSetPcp, false, meter, respChan) |
mpagenko | bc4170a | 2021-08-17 16:42:10 +0000 | [diff] [blame] | 3285 | dh.lockVlanConfig.RUnlock() |
| 3286 | dh.lockVlanAdd.Unlock() //re-admit new Add-flow-processing |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3287 | return |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3288 | } |
mpagenko | bc4170a | 2021-08-17 16:42:10 +0000 | [diff] [blame] | 3289 | dh.lockVlanConfig.RUnlock() |
| 3290 | dh.lockVlanConfig.Lock() //createVlanFilterFsm should always be a non-blocking operation and requires r+w lock |
mpagenko | 7d14de1 | 2021-07-27 08:31:56 +0000 | [diff] [blame] | 3291 | err := dh.createVlanFilterFsm(ctx, apUniPort, loTpID, loCookieSlice, |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3292 | loMatchVlan, loSetVlan, loSetPcp, cmn.OmciVlanFilterAddDone, false, meter, respChan) |
mpagenko | 7d14de1 | 2021-07-27 08:31:56 +0000 | [diff] [blame] | 3293 | dh.lockVlanConfig.Unlock() |
mpagenko | bc4170a | 2021-08-17 16:42:10 +0000 | [diff] [blame] | 3294 | dh.lockVlanAdd.Unlock() //re-admit new Add-flow-processing |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3295 | if err != nil { |
| 3296 | *respChan <- err |
| 3297 | } |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3298 | } |
| 3299 | |
| 3300 | //removeFlowItemFromUniPort parses the actual flow item to remove it from the UniPort |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3301 | func (dh *deviceHandler) removeFlowItemFromUniPort(ctx context.Context, apFlowItem *of.OfpFlowStats, apUniPort *cmn.OnuUniPort, respChan *chan error) { |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3302 | //optimization and assumption: the flow cookie uniquely identifies the flow and with that the internal rule |
| 3303 | //hence only the cookie is used here to find the relevant flow and possibly remove the rule |
| 3304 | //no extra check is done on the rule parameters |
| 3305 | //accordingly the removal is done only once - for the first found flow with that cookie, even though |
| 3306 | // at flow creation is not assured, that the same cookie is not configured for different flows - just assumed |
| 3307 | //additionally it is assumed here, that removal can only be done for one cookie per flow in a sequence (different |
| 3308 | // from addFlow - where at reconcilement multiple cookies per flow ) can be configured in one sequence) |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 3309 | // - some possible 'delete-all' sequence would have to be implemented separately (where the cookies are don't care anyway) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3310 | loCookie := apFlowItem.GetCookie() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3311 | logger.Debugw(ctx, "flow-remove base indications", log.Fields{"device-id": dh.DeviceID, "cookie": loCookie}) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3312 | |
| 3313 | /* TT related temporary workaround - should not be needed anymore |
| 3314 | for _, field := range flow.GetOfbFields(apFlowItem) { |
| 3315 | if field.Type == of.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO { |
| 3316 | loIPProto := field.GetIpProto() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3317 | logger.Debugw(ctx, "flow type IpProto", log.Fields{"device-id": dh.DeviceID, |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3318 | "IpProto": strconv.FormatInt(int64(loIPProto), 16)}) |
| 3319 | if loIPProto == 2 { |
| 3320 | // some workaround for TT workflow on proto == 2 (IGMP trap) -> the flow was not added, no need to remove |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3321 | logger.Debugw(ctx, "flow-remove type IpProto 2: TT workaround: ignore flow", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3322 | log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3323 | return nil |
| 3324 | } |
| 3325 | } |
| 3326 | } //for all OfbFields |
| 3327 | */ |
| 3328 | |
mpagenko | 9a304ea | 2020-12-16 15:54:01 +0000 | [diff] [blame] | 3329 | //mutex protection as the update_flow rpc maybe running concurrently for different flows, perhaps also activities |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3330 | dh.lockVlanConfig.RLock() |
| 3331 | defer dh.lockVlanConfig.RUnlock() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3332 | logger.Debugw(ctx, "flow-remove got RLock", log.Fields{"device-id": dh.DeviceID, "uniID": apUniPort.UniID}) |
| 3333 | if _, exist := dh.UniVlanConfigFsmMap[apUniPort.UniID]; exist { |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3334 | _ = dh.UniVlanConfigFsmMap[apUniPort.UniID].RemoveUniFlowParams(ctx, loCookie, respChan) |
| 3335 | return |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3336 | } |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3337 | logger.Debugw(ctx, "flow-remove called, but no flow is configured (no VlanConfigFsm, flow already removed) ", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3338 | log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 01e726e | 2020-10-23 09:45:29 +0000 | [diff] [blame] | 3339 | //but as we regard the flow as not existing = removed we respond just ok |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 3340 | // and treat the reason accordingly (which in the normal removal procedure is initiated by the FSM) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3341 | // Push response on the response channel |
| 3342 | if respChan != nil { |
| 3343 | // 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 |
| 3344 | select { |
| 3345 | case *respChan <- nil: |
| 3346 | logger.Debugw(ctx, "submitted-response-for-flow", log.Fields{"device-id": dh.DeviceID, "err": nil}) |
| 3347 | default: |
| 3348 | } |
| 3349 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3350 | go dh.DeviceProcStatusUpdate(ctx, cmn.OmciVlanFilterRemDone) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3351 | } |
| 3352 | |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3353 | // createVlanFilterFsm initializes and runs the VlanFilter FSM to transfer OMCI related VLAN config |
mpagenko | 9a304ea | 2020-12-16 15:54:01 +0000 | [diff] [blame] | 3354 | // if this function is called from possibly concurrent processes it must be mutex-protected from the caller! |
mpagenko | 7d14de1 | 2021-07-27 08:31:56 +0000 | [diff] [blame] | 3355 | // precondition: dh.lockVlanConfig is locked by the caller! |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3356 | func (dh *deviceHandler) createVlanFilterFsm(ctx context.Context, apUniPort *cmn.OnuUniPort, aTpID uint8, aCookieSlice []uint64, |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 3357 | aMatchVlan uint16, aSetVlan uint16, aSetPcp uint8, aDevEvent cmn.OnuDeviceEvent, lastFlowToReconcile bool, aMeter *of.OfpMeterConfig, respChan *chan error) error { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3358 | chVlanFilterFsm := make(chan cmn.Message, 2048) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3359 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3360 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3361 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3362 | logger.Errorw(ctx, "No valid OnuDevice -aborting", log.Fields{"device-id": dh.DeviceID}) |
| 3363 | return fmt.Errorf("no valid OnuDevice for device-id %x - aborting", dh.DeviceID) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3364 | } |
| 3365 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3366 | pVlanFilterFsm := avcfg.NewUniVlanConfigFsm(ctx, dh, pDevEntry, pDevEntry.PDevOmciCC, apUniPort, dh.pOnuTP, |
| 3367 | pDevEntry.GetOnuDB(), aTpID, aDevEvent, "UniVlanConfigFsm", chVlanFilterFsm, |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3368 | dh.pOpenOnuAc.AcceptIncrementalEvto, aCookieSlice, aMatchVlan, aSetVlan, aSetPcp, lastFlowToReconcile, aMeter, respChan) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3369 | if pVlanFilterFsm != nil { |
mpagenko | 7d14de1 | 2021-07-27 08:31:56 +0000 | [diff] [blame] | 3370 | //dh.lockVlanConfig is locked (by caller) throughout the state transition to 'starting' |
| 3371 | // to prevent unintended (ignored) events to be sent there (from parallel processing) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3372 | dh.UniVlanConfigFsmMap[apUniPort.UniID] = pVlanFilterFsm |
| 3373 | pVlanFilterStatemachine := pVlanFilterFsm.PAdaptFsm.PFsm |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3374 | if pVlanFilterStatemachine != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3375 | if pVlanFilterStatemachine.Is(avcfg.VlanStDisabled) { |
| 3376 | if err := pVlanFilterStatemachine.Event(avcfg.VlanEvStart); err != nil { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 3377 | logger.Warnw(ctx, "UniVlanConfigFsm: can't start", |
| 3378 | log.Fields{"device-id": dh.DeviceID, "err": err}) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3379 | return fmt.Errorf("can't start UniVlanConfigFsm for device-id %x", dh.DeviceID) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3380 | } |
Himani Chawla | 26e555c | 2020-08-31 12:30:20 +0530 | [diff] [blame] | 3381 | /***** UniVlanConfigFsm started */ |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3382 | logger.Debugw(ctx, "UniVlanConfigFsm started", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3383 | "state": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID, |
| 3384 | "UniPort": apUniPort.PortNo}) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3385 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3386 | logger.Warnw(ctx, "wrong state of UniVlanConfigFsm - want: disabled", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3387 | "have": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID}) |
| 3388 | return fmt.Errorf("uniVlanConfigFsm not in expected disabled state for device-id %x", dh.DeviceID) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3389 | } |
| 3390 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3391 | logger.Errorw(ctx, "UniVlanConfigFsm StateMachine invalid - cannot be executed!!", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3392 | "device-id": dh.DeviceID}) |
| 3393 | return fmt.Errorf("uniVlanConfigFsm invalid for device-id %x", dh.DeviceID) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3394 | } |
| 3395 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3396 | logger.Errorw(ctx, "UniVlanConfigFsm could not be created - abort!!", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3397 | "device-id": dh.DeviceID, "UniPort": apUniPort.PortNo}) |
| 3398 | return fmt.Errorf("uniVlanConfigFsm could not be created for device-id %x", dh.DeviceID) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3399 | } |
| 3400 | return nil |
| 3401 | } |
| 3402 | |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 3403 | //VerifyVlanConfigRequest checks on existence of a given uniPort |
| 3404 | // and starts verification of flow config based on that |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3405 | func (dh *deviceHandler) VerifyVlanConfigRequest(ctx context.Context, aUniID uint8, aTpID uint8) { |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 3406 | //ensure that the given uniID is available (configured) in the UniPort class (used for OMCI entities) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3407 | var pCurrentUniPort *cmn.OnuUniPort |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 3408 | for _, uniPort := range dh.uniEntityMap { |
| 3409 | // only if this port is validated for operState transfer |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3410 | if uniPort.UniID == uint8(aUniID) { |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 3411 | pCurrentUniPort = uniPort |
| 3412 | break //found - end search loop |
| 3413 | } |
| 3414 | } |
| 3415 | if pCurrentUniPort == nil { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3416 | logger.Debugw(ctx, "VerifyVlanConfig aborted: requested uniID not found in PortDB", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3417 | log.Fields{"device-id": dh.DeviceID, "uni-id": aUniID}) |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 3418 | return |
| 3419 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3420 | dh.VerifyUniVlanConfigRequest(ctx, pCurrentUniPort, aTpID) |
mpagenko | fc4f56e | 2020-11-04 17:17:49 +0000 | [diff] [blame] | 3421 | } |
| 3422 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3423 | //VerifyUniVlanConfigRequest checks on existence of flow configuration and starts it accordingly |
| 3424 | func (dh *deviceHandler) VerifyUniVlanConfigRequest(ctx context.Context, apUniPort *cmn.OnuUniPort, aTpID uint8) { |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3425 | //TODO!! verify and start pending flow configuration |
| 3426 | //some pending config request my exist in case the UniVlanConfig FSM was already started - with internal data - |
| 3427 | //but execution was set to 'on hold' as first the TechProfile config had to be applied |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3428 | |
| 3429 | dh.lockVlanConfig.RLock() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3430 | if pVlanFilterFsm, exist := dh.UniVlanConfigFsmMap[apUniPort.UniID]; exist { |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3431 | dh.lockVlanConfig.RUnlock() |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3432 | //VlanFilterFsm exists and was already started (assumed to wait for TechProfile execution here) |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3433 | pVlanFilterStatemachine := pVlanFilterFsm.PAdaptFsm.PFsm |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3434 | if pVlanFilterStatemachine != nil { |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3435 | //if this was an event of the TP processing that was waited for in the VlanFilterFsm |
Holger Hildebrandt | c192bc4 | 2021-10-28 14:38:31 +0000 | [diff] [blame] | 3436 | if pVlanFilterFsm.GetWaitingTpID(ctx) == aTpID { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3437 | if pVlanFilterStatemachine.Is(avcfg.VlanStWaitingTechProf) { |
| 3438 | if err := pVlanFilterStatemachine.Event(avcfg.VlanEvContinueConfig); err != nil { |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3439 | logger.Warnw(ctx, "UniVlanConfigFsm: can't continue processing", log.Fields{"err": err, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3440 | "device-id": dh.DeviceID, "UniPort": apUniPort.PortNo}) |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3441 | } else { |
| 3442 | /***** UniVlanConfigFsm continued */ |
| 3443 | logger.Debugw(ctx, "UniVlanConfigFsm continued", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3444 | "state": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID, |
| 3445 | "UniPort": apUniPort.PortNo}) |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3446 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3447 | } else if pVlanFilterStatemachine.Is(avcfg.VlanStIncrFlowWaitTP) { |
| 3448 | if err := pVlanFilterStatemachine.Event(avcfg.VlanEvIncrFlowConfig); err != nil { |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3449 | logger.Warnw(ctx, "UniVlanConfigFsm: can't continue processing", log.Fields{"err": err, |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3450 | "device-id": dh.DeviceID, "UniPort": apUniPort.PortNo}) |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3451 | } else { |
| 3452 | /***** UniVlanConfigFsm continued */ |
| 3453 | logger.Debugw(ctx, "UniVlanConfigFsm continued with incremental flow", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3454 | "state": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID, |
| 3455 | "UniPort": apUniPort.PortNo}) |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3456 | } |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3457 | } else { |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3458 | logger.Debugw(ctx, "no state of UniVlanConfigFsm to be continued", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3459 | "have": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID, |
| 3460 | "UniPort": apUniPort.PortNo}) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3461 | } |
| 3462 | } else { |
mpagenko | 551a4d4 | 2020-12-08 18:09:20 +0000 | [diff] [blame] | 3463 | logger.Debugw(ctx, "TechProfile Ready event for TpId that was not waited for in the VlanConfigFsm - continue waiting", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3464 | "state": pVlanFilterStatemachine.Current(), "device-id": dh.DeviceID, |
| 3465 | "UniPort": apUniPort.PortNo, "techprofile-id (done)": aTpID}) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3466 | } |
| 3467 | } else { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3468 | logger.Debugw(ctx, "UniVlanConfigFsm StateMachine does not exist, no flow processing", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3469 | "device-id": dh.DeviceID, "UniPort": apUniPort.PortNo}) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3470 | } |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3471 | } else { |
| 3472 | dh.lockVlanConfig.RUnlock() |
| 3473 | } |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3474 | } |
| 3475 | |
| 3476 | //RemoveVlanFilterFsm deletes the stored pointer to the VlanConfigFsm |
| 3477 | // intention is to provide this method to be called from VlanConfigFsm itself, when resources (and methods!) are cleaned up |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3478 | func (dh *deviceHandler) RemoveVlanFilterFsm(ctx context.Context, apUniPort *cmn.OnuUniPort) { |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3479 | logger.Debugw(ctx, "remove UniVlanConfigFsm StateMachine", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3480 | "device-id": dh.DeviceID, "uniPort": apUniPort.PortNo}) |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3481 | //save to do, even if entry dows not exist |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3482 | dh.lockVlanConfig.Lock() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3483 | delete(dh.UniVlanConfigFsmMap, apUniPort.UniID) |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3484 | dh.lockVlanConfig.Unlock() |
mpagenko | dff5dda | 2020-08-28 11:52:01 +0000 | [diff] [blame] | 3485 | } |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 3486 | |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3487 | //startWritingOnuDataToKvStore initiates the KVStore write of ONU persistent data |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3488 | func (dh *deviceHandler) startWritingOnuDataToKvStore(ctx context.Context, aPDevEntry *mib.OnuDeviceEntry) error { |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3489 | dh.mutexKvStoreContext.Lock() //this write routine may (could) be called with the same context, |
| 3490 | defer dh.mutexKvStoreContext.Unlock() //this write routine may (could) be called with the same context, |
| 3491 | // obviously then parallel processing on the cancel must be avoided |
| 3492 | // deadline context to ensure completion of background routines waited for |
| 3493 | //20200721: 10s proved to be less in 8*8 ONU test on local vbox machine with debug, might be further adapted |
| 3494 | deadline := time.Now().Add(dh.pOpenOnuAc.maxTimeoutInterAdapterComm) //allowed run time to finish before execution |
| 3495 | dctx, cancel := context.WithDeadline(context.Background(), deadline) |
| 3496 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3497 | aPDevEntry.ResetKvProcessingErrorIndication() |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3498 | var wg sync.WaitGroup |
| 3499 | wg.Add(1) // for the 1 go routine to finish |
| 3500 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3501 | go aPDevEntry.UpdateOnuKvStore(log.WithSpanFromContext(dctx, ctx), &wg) |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3502 | dh.waitForCompletion(ctx, cancel, &wg, "UpdateKvStore") //wait for background process to finish |
| 3503 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3504 | return aPDevEntry.GetKvProcessingErrorIndication() |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3505 | } |
| 3506 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3507 | //StorePersUniFlowConfig updates local storage of OnuUniFlowConfig and writes it into kv-store afterwards to have it |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 3508 | //available for potential reconcilement |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3509 | func (dh *deviceHandler) StorePersUniFlowConfig(ctx context.Context, aUniID uint8, |
| 3510 | aUniVlanFlowParams *[]cmn.UniVlanFlowParams, aWriteToKvStore bool) error { |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 3511 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3512 | if dh.IsReconciling() { |
| 3513 | logger.Debugw(ctx, "reconciling - don't store persistent UniFlowConfig", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 3514 | return nil |
| 3515 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3516 | logger.Debugw(ctx, "Store or clear persistent UniFlowConfig", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 3517 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3518 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 3519 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3520 | logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": dh.DeviceID}) |
| 3521 | return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 3522 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3523 | pDevEntry.UpdateOnuUniFlowConfig(aUniID, aUniVlanFlowParams) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 3524 | |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3525 | if aWriteToKvStore { |
| 3526 | return dh.startWritingOnuDataToKvStore(ctx, pDevEntry) |
| 3527 | } |
| 3528 | return nil |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 3529 | } |
| 3530 | |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3531 | func (dh *deviceHandler) waitForCompletion(ctx context.Context, cancel context.CancelFunc, wg *sync.WaitGroup, aCallerIdent string) { |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 3532 | defer cancel() //ensure termination of context (may be pro forma) |
| 3533 | wg.Wait() |
dbainbri | 4d3a0dc | 2020-12-02 00:33:42 +0000 | [diff] [blame] | 3534 | logger.Debugw(ctx, "WaitGroup processing completed", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3535 | "device-id": dh.DeviceID, "called from": aCallerIdent}) |
Holger Hildebrandt | 47555e7 | 2020-09-21 11:07:24 +0000 | [diff] [blame] | 3536 | } |
| 3537 | |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 3538 | //ReasonUpdate set the internally store device reason and if requested in notifyCore updates this state in the core |
| 3539 | // (renamed from previous deviceReasonUpdate to avoid confusing with the core function DeviceReasonUpdate) |
| 3540 | func (dh *deviceHandler) ReasonUpdate(ctx context.Context, deviceReason uint8, notifyCore bool) error { |
| 3541 | // acquire the deviceReason semaphore throughout this function including the possible update processing in core |
| 3542 | // in order to avoid reversion of the state sequence within core in case of quasi-parallel calls (eg. in multi UNI processing) |
| 3543 | dh.mutexDeviceReason.Lock() |
| 3544 | defer dh.mutexDeviceReason.Unlock() |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 3545 | if notifyCore { |
Holger Hildebrandt | 80129db | 2020-11-23 10:49:32 +0000 | [diff] [blame] | 3546 | //TODO with VOL-3045/VOL-3046: return the error and stop further processing at calling position |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 3547 | if err := dh.updateDeviceReasonInCore(ctx, &ca.DeviceReason{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3548 | DeviceId: dh.DeviceID, |
| 3549 | Reason: cmn.DeviceReasonMap[deviceReason], |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 3550 | }); err != nil { |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 3551 | logger.Errorf(ctx, "updating reason in core failed for: %s", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3552 | log.Fields{"device-id": dh.DeviceID, "error": err}, cmn.DeviceReasonMap[deviceReason]) |
Holger Hildebrandt | 80129db | 2020-11-23 10:49:32 +0000 | [diff] [blame] | 3553 | return err |
| 3554 | } |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 3555 | } else { |
| 3556 | logger.Debugf(ctx, "update reason in core not requested: %s - device-id: %s", cmn.DeviceReasonMap[deviceReason], dh.DeviceID) |
Holger Hildebrandt | 80129db | 2020-11-23 10:49:32 +0000 | [diff] [blame] | 3557 | } |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 3558 | dh.deviceReason = deviceReason |
| 3559 | logger.Infof(ctx, "reason update done for: %s - device-id: %s - with core update: %v", |
| 3560 | cmn.DeviceReasonMap[deviceReason], dh.DeviceID, notifyCore) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 3561 | return nil |
| 3562 | } |
| 3563 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3564 | func (dh *deviceHandler) StorePersistentData(ctx context.Context) error { |
| 3565 | pDevEntry := dh.GetOnuDeviceEntry(ctx, true) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 3566 | if pDevEntry == nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3567 | logger.Warnw(ctx, "No valid OnuDevice", log.Fields{"device-id": dh.DeviceID}) |
| 3568 | return fmt.Errorf("no valid OnuDevice: %s", dh.DeviceID) |
Holger Hildebrandt | 3a64464 | 2020-12-02 09:46:18 +0000 | [diff] [blame] | 3569 | } |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3570 | return dh.startWritingOnuDataToKvStore(ctx, pDevEntry) |
Holger Hildebrandt | 80129db | 2020-11-23 10:49:32 +0000 | [diff] [blame] | 3571 | } |
| 3572 | |
ozgecanetsia | b5000ef | 2020-11-27 14:38:20 +0300 | [diff] [blame] | 3573 | // getUniPortMEEntityID takes uniPortNo as the input and returns the Entity ID corresponding to this UNI-G ME Instance |
ozgecanetsia | 72e1c9f | 2021-05-26 17:26:29 +0300 | [diff] [blame] | 3574 | // nolint: unused |
ozgecanetsia | b5000ef | 2020-11-27 14:38:20 +0300 | [diff] [blame] | 3575 | func (dh *deviceHandler) getUniPortMEEntityID(uniPortNo uint32) (uint16, error) { |
| 3576 | dh.lockDevice.RLock() |
| 3577 | defer dh.lockDevice.RUnlock() |
| 3578 | if uniPort, ok := dh.uniEntityMap[uniPortNo]; ok { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3579 | return uniPort.EntityID, nil |
ozgecanetsia | b5000ef | 2020-11-27 14:38:20 +0300 | [diff] [blame] | 3580 | } |
| 3581 | return 0, errors.New("error-fetching-uni-port") |
| 3582 | } |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 3583 | |
| 3584 | // updatePmConfig updates the pm metrics config. |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3585 | func (dh *deviceHandler) updatePmConfig(ctx context.Context, pmConfigs *voltha.PmConfigs) error { |
| 3586 | var errorsList []error |
| 3587 | logger.Infow(ctx, "update-pm-config", log.Fields{"device-id": dh.device.Id, "new-pm-configs": pmConfigs, "old-pm-config": dh.pmConfigs}) |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 3588 | |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3589 | errorsList = append(dh.handleGlobalPmConfigUpdates(ctx, pmConfigs), errorsList...) |
| 3590 | errorsList = append(dh.handleGroupPmConfigUpdates(ctx, pmConfigs), errorsList...) |
| 3591 | errorsList = append(dh.handleStandalonePmConfigUpdates(ctx, pmConfigs), errorsList...) |
| 3592 | |
| 3593 | // Note that if more than one pm config field is updated in a given call, it is possible that partial pm config is handled |
| 3594 | // successfully. |
| 3595 | // TODO: Although it is possible to revert to old config in case of partial failure, the code becomes quite complex. Needs more investigation |
| 3596 | // Is it possible the rw-core reverts to old config on partial failure but adapter retains a partial new config? |
| 3597 | if len(errorsList) > 0 { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3598 | logger.Errorw(ctx, "one-or-more-pm-config-failed", log.Fields{"device-id": dh.DeviceID, "pmConfig": dh.pmConfigs}) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3599 | return fmt.Errorf("errors-handling-one-or-more-pm-config, errors:%v", errorsList) |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 3600 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3601 | logger.Infow(ctx, "pm-config-updated", log.Fields{"device-id": dh.DeviceID, "pmConfig": dh.pmConfigs}) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3602 | return nil |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 3603 | } |
| 3604 | |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3605 | func (dh *deviceHandler) handleGlobalPmConfigUpdates(ctx context.Context, pmConfigs *voltha.PmConfigs) []error { |
| 3606 | var err error |
| 3607 | var errorsList []error |
Girish Gowdra | 36ccf7d | 2021-02-25 20:42:51 -0800 | [diff] [blame] | 3608 | logger.Infow(ctx, "handling-global-pm-config-params - start", log.Fields{"device-id": dh.device.Id}) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3609 | |
| 3610 | if pmConfigs.DefaultFreq != dh.pmConfigs.DefaultFreq { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3611 | if err = dh.pOnuMetricsMgr.UpdateDefaultFrequency(ctx, pmConfigs); err != nil { |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3612 | errorsList = append(errorsList, err) |
| 3613 | } |
| 3614 | } |
Girish Gowdra | 36ccf7d | 2021-02-25 20:42:51 -0800 | [diff] [blame] | 3615 | logger.Infow(ctx, "handling-global-pm-config-params - done", log.Fields{"device-id": dh.device.Id}) |
mpagenko | 15ff4a5 | 2021-03-02 10:09:20 +0000 | [diff] [blame] | 3616 | |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3617 | return errorsList |
| 3618 | } |
| 3619 | |
| 3620 | func (dh *deviceHandler) handleGroupPmConfigUpdates(ctx context.Context, pmConfigs *voltha.PmConfigs) []error { |
| 3621 | var err error |
| 3622 | var errorsList []error |
Girish Gowdra | 36ccf7d | 2021-02-25 20:42:51 -0800 | [diff] [blame] | 3623 | logger.Debugw(ctx, "handling-group-pm-config-params - start", log.Fields{"device-id": dh.device.Id}) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3624 | // Check if group metric related config is updated |
| 3625 | for _, v := range pmConfigs.Groups { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3626 | dh.pOnuMetricsMgr.OnuMetricsManagerLock.RLock() |
| 3627 | m, ok := dh.pOnuMetricsMgr.GroupMetricMap[v.GroupName] |
| 3628 | dh.pOnuMetricsMgr.OnuMetricsManagerLock.RUnlock() |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3629 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3630 | if ok && m.Frequency != v.GroupFreq { |
| 3631 | if err = dh.pOnuMetricsMgr.UpdateGroupFreq(ctx, v.GroupName, pmConfigs); err != nil { |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3632 | errorsList = append(errorsList, err) |
| 3633 | } |
| 3634 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3635 | if ok && m.Enabled != v.Enabled { |
| 3636 | if err = dh.pOnuMetricsMgr.UpdateGroupSupport(ctx, v.GroupName, pmConfigs); err != nil { |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3637 | errorsList = append(errorsList, err) |
| 3638 | } |
| 3639 | } |
| 3640 | } |
Girish Gowdra | 36ccf7d | 2021-02-25 20:42:51 -0800 | [diff] [blame] | 3641 | logger.Debugw(ctx, "handling-group-pm-config-params - done", log.Fields{"device-id": dh.device.Id}) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3642 | return errorsList |
| 3643 | } |
| 3644 | |
| 3645 | func (dh *deviceHandler) handleStandalonePmConfigUpdates(ctx context.Context, pmConfigs *voltha.PmConfigs) []error { |
| 3646 | var err error |
| 3647 | var errorsList []error |
Girish Gowdra | 36ccf7d | 2021-02-25 20:42:51 -0800 | [diff] [blame] | 3648 | logger.Debugw(ctx, "handling-individual-pm-config-params - start", log.Fields{"device-id": dh.device.Id}) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3649 | // Check if standalone metric related config is updated |
| 3650 | for _, v := range pmConfigs.Metrics { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3651 | dh.pOnuMetricsMgr.OnuMetricsManagerLock.RLock() |
| 3652 | m, ok := dh.pOnuMetricsMgr.StandaloneMetricMap[v.Name] |
| 3653 | dh.pOnuMetricsMgr.OnuMetricsManagerLock.RUnlock() |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3654 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3655 | if ok && m.Frequency != v.SampleFreq { |
| 3656 | if err = dh.pOnuMetricsMgr.UpdateMetricFreq(ctx, v.Name, pmConfigs); err != nil { |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3657 | errorsList = append(errorsList, err) |
| 3658 | } |
| 3659 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3660 | if ok && m.Enabled != v.Enabled { |
| 3661 | if err = dh.pOnuMetricsMgr.UpdateMetricSupport(ctx, v.Name, pmConfigs); err != nil { |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3662 | errorsList = append(errorsList, err) |
| 3663 | } |
| 3664 | } |
| 3665 | } |
Girish Gowdra | 36ccf7d | 2021-02-25 20:42:51 -0800 | [diff] [blame] | 3666 | logger.Debugw(ctx, "handling-individual-pm-config-params - done", log.Fields{"device-id": dh.device.Id}) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3667 | return errorsList |
| 3668 | } |
| 3669 | |
| 3670 | // nolint: gocyclo |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3671 | func (dh *deviceHandler) StartCollector(ctx context.Context) { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 3672 | logger.Debugw(ctx, "startingCollector", log.Fields{"device-id": dh.device.Id}) |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 3673 | |
| 3674 | // Start routine to process OMCI GET Responses |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3675 | go dh.pOnuMetricsMgr.ProcessOmciMessages(ctx) |
Himani Chawla | 43f95ff | 2021-06-03 00:24:12 +0530 | [diff] [blame] | 3676 | // Create Extended Frame PM ME |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3677 | go dh.pOnuMetricsMgr.CreateEthernetFrameExtendedPMME(ctx) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3678 | // Initialize the next metric collection time. |
| 3679 | // Normally done when the onu_metrics_manager is initialized the first time, but needed again later when ONU is |
| 3680 | // reset like onu rebooted. |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3681 | dh.pOnuMetricsMgr.InitializeMetricCollectionTime(ctx) |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3682 | dh.setCollectorIsRunning(true) |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 3683 | for { |
| 3684 | select { |
| 3685 | case <-dh.stopCollector: |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3686 | dh.setCollectorIsRunning(false) |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 3687 | logger.Debugw(ctx, "stopping-collector-for-onu", log.Fields{"device-id": dh.device.Id}) |
Girish Gowdra | e0140f0 | 2021-02-02 16:55:09 -0800 | [diff] [blame] | 3688 | // Stop the L2 PM FSM |
| 3689 | go func() { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3690 | if dh.pOnuMetricsMgr.PAdaptFsm != nil && dh.pOnuMetricsMgr.PAdaptFsm.PFsm != nil { |
| 3691 | if err := dh.pOnuMetricsMgr.PAdaptFsm.PFsm.Event(pmmgr.L2PmEventStop); err != nil { |
| 3692 | logger.Errorw(ctx, "error calling event", log.Fields{"device-id": dh.DeviceID, "err": err}) |
Girish Gowdra | e0140f0 | 2021-02-02 16:55:09 -0800 | [diff] [blame] | 3693 | } |
| 3694 | } else { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3695 | logger.Errorw(ctx, "metrics manager fsm not initialized", log.Fields{"device-id": dh.DeviceID}) |
Girish Gowdra | e0140f0 | 2021-02-02 16:55:09 -0800 | [diff] [blame] | 3696 | } |
| 3697 | }() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3698 | if dh.pOnuMetricsMgr.GetOmciProcessingStatus() { |
| 3699 | dh.pOnuMetricsMgr.StopProcessingOmciResponses <- true // Stop the OMCI GET response processing routine |
Girish Gowdra | 7b0ee5c | 2021-03-19 21:48:15 -0700 | [diff] [blame] | 3700 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3701 | if dh.pOnuMetricsMgr.GetTickGenerationStatus() { |
| 3702 | dh.pOnuMetricsMgr.StopTicks <- true |
Girish Gowdra | 7b0ee5c | 2021-03-19 21:48:15 -0700 | [diff] [blame] | 3703 | } |
Girish Gowdra | e0140f0 | 2021-02-02 16:55:09 -0800 | [diff] [blame] | 3704 | |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 3705 | return |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3706 | case <-time.After(time.Duration(pmmgr.FrequencyGranularity) * time.Second): // Check every FrequencyGranularity to see if it is time for collecting metrics |
| 3707 | if !dh.pmConfigs.FreqOverride { // If FreqOverride is false, then NextGlobalMetricCollectionTime applies |
| 3708 | // If the current time is eqaul to or greater than the NextGlobalMetricCollectionTime, collect the group and standalone metrics |
| 3709 | if time.Now().Equal(dh.pOnuMetricsMgr.NextGlobalMetricCollectionTime) || time.Now().After(dh.pOnuMetricsMgr.NextGlobalMetricCollectionTime) { |
| 3710 | go dh.pOnuMetricsMgr.CollectAllGroupAndStandaloneMetrics(ctx) |
Girish Gowdra | af0ad63 | 2021-01-27 13:00:01 -0800 | [diff] [blame] | 3711 | // Update the next metric collection time. |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3712 | dh.pOnuMetricsMgr.NextGlobalMetricCollectionTime = time.Now().Add(time.Duration(dh.pmConfigs.DefaultFreq) * time.Second) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3713 | } |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3714 | } else { |
| 3715 | if dh.pmConfigs.Grouped { // metrics are managed as a group |
| 3716 | // parse through the group and standalone metrics to see it is time to collect their metrics |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3717 | dh.pOnuMetricsMgr.OnuMetricsManagerLock.RLock() // Rlock as we are reading GroupMetricMap and StandaloneMetricMap |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 3718 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3719 | for n, g := range dh.pOnuMetricsMgr.GroupMetricMap { |
| 3720 | // If the group is enabled AND (current time is equal to OR after NextCollectionInterval, collect the group metric) |
Girish Gowdra | e0140f0 | 2021-02-02 16:55:09 -0800 | [diff] [blame] | 3721 | // Since the L2 PM counters are collected in a separate FSM, we should avoid those counters in the check. |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3722 | if g.Enabled && !g.IsL2PMCounter && (time.Now().Equal(g.NextCollectionInterval) || time.Now().After(g.NextCollectionInterval)) { |
| 3723 | go dh.pOnuMetricsMgr.CollectGroupMetric(ctx, n) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3724 | } |
| 3725 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3726 | for n, m := range dh.pOnuMetricsMgr.StandaloneMetricMap { |
| 3727 | // If the standalone is enabled AND (current time is equal to OR after NextCollectionInterval, collect the metric) |
| 3728 | if m.Enabled && (time.Now().Equal(m.NextCollectionInterval) || time.Now().After(m.NextCollectionInterval)) { |
| 3729 | go dh.pOnuMetricsMgr.CollectStandaloneMetric(ctx, n) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3730 | } |
| 3731 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3732 | dh.pOnuMetricsMgr.OnuMetricsManagerLock.RUnlock() |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3733 | |
| 3734 | // parse through the group and update the next metric collection time |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3735 | dh.pOnuMetricsMgr.OnuMetricsManagerLock.Lock() // Lock as we are writing the next metric collection time |
| 3736 | for _, g := range dh.pOnuMetricsMgr.GroupMetricMap { |
| 3737 | // If group enabled, and the NextCollectionInterval is old (before or equal to current time), update the next collection time stamp |
Girish Gowdra | e0140f0 | 2021-02-02 16:55:09 -0800 | [diff] [blame] | 3738 | // Since the L2 PM counters are collected and managed in a separate FSM, we should avoid those counters in the check. |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3739 | if g.Enabled && !g.IsL2PMCounter && (g.NextCollectionInterval.Before(time.Now()) || g.NextCollectionInterval.Equal(time.Now())) { |
| 3740 | g.NextCollectionInterval = time.Now().Add(time.Duration(g.Frequency) * time.Second) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3741 | } |
| 3742 | } |
| 3743 | // parse through the standalone metrics and update the next metric collection time |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3744 | for _, m := range dh.pOnuMetricsMgr.StandaloneMetricMap { |
| 3745 | // If standalone metrics enabled, and the NextCollectionInterval is old (before or equal to current time), update the next collection time stamp |
| 3746 | if m.Enabled && (m.NextCollectionInterval.Before(time.Now()) || m.NextCollectionInterval.Equal(time.Now())) { |
| 3747 | m.NextCollectionInterval = time.Now().Add(time.Duration(m.Frequency) * time.Second) |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3748 | } |
| 3749 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3750 | dh.pOnuMetricsMgr.OnuMetricsManagerLock.Unlock() |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3751 | } /* else { // metrics are not managed as a group |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 3752 | // TODO: We currently do not have standalone metrics. When available, add code here to fetch the metrca. |
Girish Gowdra | 5a7c492 | 2021-01-22 18:33:41 -0800 | [diff] [blame] | 3753 | } */ |
| 3754 | } |
Girish Gowdra | e09a620 | 2021-01-12 18:10:59 -0800 | [diff] [blame] | 3755 | } |
| 3756 | } |
| 3757 | } |
kesavand | fdf7763 | 2021-01-26 23:40:33 -0500 | [diff] [blame] | 3758 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3759 | func (dh *deviceHandler) GetUniPortStatus(ctx context.Context, uniInfo *extension.GetOnuUniInfoRequest) *extension.SingleGetValueResponse { |
kesavand | fdf7763 | 2021-01-26 23:40:33 -0500 | [diff] [blame] | 3760 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3761 | portStatus := uniprt.NewUniPortStatus(dh, dh.pOnuOmciDevice.PDevOmciCC) |
| 3762 | return portStatus.GetUniPortStatus(ctx, uniInfo.UniIndex) |
kesavand | fdf7763 | 2021-01-26 23:40:33 -0500 | [diff] [blame] | 3763 | } |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3764 | |
Himani Chawla | 43f95ff | 2021-06-03 00:24:12 +0530 | [diff] [blame] | 3765 | func (dh *deviceHandler) getOnuOMCICounters(ctx context.Context, onuInfo *extension.GetOmciEthernetFrameExtendedPmRequest) *extension.SingleGetValueResponse { |
| 3766 | if dh.pOnuMetricsMgr == nil { |
| 3767 | return &extension.SingleGetValueResponse{ |
| 3768 | Response: &extension.GetValueResponse{ |
| 3769 | Status: extension.GetValueResponse_ERROR, |
| 3770 | ErrReason: extension.GetValueResponse_INTERNAL_ERROR, |
| 3771 | }, |
| 3772 | } |
| 3773 | } |
Himani Chawla | ee10b54 | 2021-09-20 16:46:40 +0530 | [diff] [blame] | 3774 | resp := dh.pOnuMetricsMgr.CollectEthernetFrameExtendedPMCounters(ctx, onuInfo) |
Himani Chawla | 43f95ff | 2021-06-03 00:24:12 +0530 | [diff] [blame] | 3775 | return resp |
| 3776 | } |
| 3777 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3778 | func (dh *deviceHandler) isFsmInOmciIdleState(ctx context.Context, PFsm *fsm.FSM, wantedState string) bool { |
| 3779 | if PFsm == nil { |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3780 | return true //FSM not active - so there is no activity on omci |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3781 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3782 | return PFsm.Current() == wantedState |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3783 | } |
| 3784 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3785 | func (dh *deviceHandler) isFsmInOmciIdleStateDefault(ctx context.Context, omciFsm cmn.UsedOmciConfigFsms, wantedState string) bool { |
mpagenko | fbf577d | 2021-10-12 11:44:33 +0000 | [diff] [blame] | 3786 | var pAdapterFsm *cmn.AdapterFsm |
| 3787 | //note/TODO!!: might be that access to all these specific FSM pointers need a semaphore protection as well, cmp lockUpgradeFsm |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3788 | switch omciFsm { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3789 | case cmn.CUploadFsm: |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3790 | { |
mpagenko | fbf577d | 2021-10-12 11:44:33 +0000 | [diff] [blame] | 3791 | if dh.pOnuOmciDevice != nil { |
| 3792 | pAdapterFsm = dh.pOnuOmciDevice.PMibUploadFsm |
| 3793 | } else { |
| 3794 | return true //FSM not active - so there is no activity on omci |
| 3795 | } |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3796 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3797 | case cmn.CDownloadFsm: |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3798 | { |
mpagenko | fbf577d | 2021-10-12 11:44:33 +0000 | [diff] [blame] | 3799 | if dh.pOnuOmciDevice != nil { |
| 3800 | pAdapterFsm = dh.pOnuOmciDevice.PMibDownloadFsm |
| 3801 | } else { |
| 3802 | return true //FSM not active - so there is no activity on omci |
| 3803 | } |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3804 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3805 | case cmn.CUniLockFsm: |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3806 | { |
mpagenko | fbf577d | 2021-10-12 11:44:33 +0000 | [diff] [blame] | 3807 | if dh.pLockStateFsm != nil { |
| 3808 | pAdapterFsm = dh.pLockStateFsm.PAdaptFsm |
| 3809 | } else { |
| 3810 | return true //FSM not active - so there is no activity on omci |
| 3811 | } |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3812 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3813 | case cmn.CUniUnLockFsm: |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3814 | { |
mpagenko | fbf577d | 2021-10-12 11:44:33 +0000 | [diff] [blame] | 3815 | if dh.pUnlockStateFsm != nil { |
| 3816 | pAdapterFsm = dh.pUnlockStateFsm.PAdaptFsm |
| 3817 | } else { |
| 3818 | return true //FSM not active - so there is no activity on omci |
| 3819 | } |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3820 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3821 | case cmn.CL2PmFsm: |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3822 | { |
mpagenko | fbf577d | 2021-10-12 11:44:33 +0000 | [diff] [blame] | 3823 | if dh.pOnuMetricsMgr != nil { |
| 3824 | pAdapterFsm = dh.pOnuMetricsMgr.PAdaptFsm |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3825 | } else { |
| 3826 | return true //FSM not active - so there is no activity on omci |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3827 | } |
| 3828 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3829 | case cmn.COnuUpgradeFsm: |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 3830 | { |
| 3831 | dh.lockUpgradeFsm.RLock() |
| 3832 | defer dh.lockUpgradeFsm.RUnlock() |
mpagenko | fbf577d | 2021-10-12 11:44:33 +0000 | [diff] [blame] | 3833 | if dh.pOnuUpradeFsm != nil { |
| 3834 | pAdapterFsm = dh.pOnuUpradeFsm.PAdaptFsm |
| 3835 | } else { |
| 3836 | return true //FSM not active - so there is no activity on omci |
| 3837 | } |
mpagenko | 80622a5 | 2021-02-09 16:53:23 +0000 | [diff] [blame] | 3838 | } |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3839 | default: |
| 3840 | { |
| 3841 | logger.Errorw(ctx, "invalid stateMachine selected for idle check", log.Fields{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3842 | "device-id": dh.DeviceID, "selectedFsm number": omciFsm}) |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3843 | return false //logical error in FSM check, do not not indicate 'idle' - we can't be sure |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3844 | } |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3845 | } |
mpagenko | fbf577d | 2021-10-12 11:44:33 +0000 | [diff] [blame] | 3846 | if pAdapterFsm != nil && pAdapterFsm.PFsm != nil { |
| 3847 | return dh.isFsmInOmciIdleState(ctx, pAdapterFsm.PFsm, wantedState) |
| 3848 | } |
| 3849 | return true //FSM not active - so there is no activity on omci |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3850 | } |
| 3851 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3852 | func (dh *deviceHandler) isAniConfigFsmInOmciIdleState(ctx context.Context, omciFsm cmn.UsedOmciConfigFsms, idleState string) bool { |
| 3853 | for _, v := range dh.pOnuTP.PAniConfigFsm { |
| 3854 | if !dh.isFsmInOmciIdleState(ctx, v.PAdaptFsm.PFsm, idleState) { |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3855 | return false |
| 3856 | } |
| 3857 | } |
| 3858 | return true |
| 3859 | } |
| 3860 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3861 | func (dh *deviceHandler) isUniVlanConfigFsmInOmciIdleState(ctx context.Context, omciFsm cmn.UsedOmciConfigFsms, idleState string) bool { |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3862 | dh.lockVlanConfig.RLock() |
| 3863 | defer dh.lockVlanConfig.RUnlock() |
| 3864 | for _, v := range dh.UniVlanConfigFsmMap { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3865 | if !dh.isFsmInOmciIdleState(ctx, v.PAdaptFsm.PFsm, idleState) { |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3866 | return false |
| 3867 | } |
| 3868 | } |
| 3869 | return true //FSM not active - so there is no activity on omci |
| 3870 | } |
| 3871 | |
| 3872 | func (dh *deviceHandler) checkUserServiceExists(ctx context.Context) bool { |
| 3873 | dh.lockVlanConfig.RLock() |
| 3874 | defer dh.lockVlanConfig.RUnlock() |
| 3875 | for _, v := range dh.UniVlanConfigFsmMap { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3876 | if v.PAdaptFsm.PFsm != nil { |
| 3877 | if v.PAdaptFsm.PFsm.Is(avcfg.CVlanFsmConfiguredState) { |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3878 | return true //there is at least one VLAN FSM with some active configuration |
| 3879 | } |
| 3880 | } |
| 3881 | } |
| 3882 | return false //there is no VLAN FSM with some active configuration |
| 3883 | } |
| 3884 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3885 | func (dh *deviceHandler) CheckAuditStartCondition(ctx context.Context, callingFsm cmn.UsedOmciConfigFsms) bool { |
mpagenko | f1fc386 | 2021-02-16 10:09:52 +0000 | [diff] [blame] | 3886 | for fsmName, fsmStruct := range fsmOmciIdleStateFuncMap { |
| 3887 | if fsmName != callingFsm && !fsmStruct.omciIdleCheckFunc(dh, ctx, fsmName, fsmStruct.omciIdleState) { |
| 3888 | return false |
| 3889 | } |
| 3890 | } |
| 3891 | // a further check is done to identify, if at least some data traffic related configuration exists |
| 3892 | // 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]) |
| 3893 | return dh.checkUserServiceExists(ctx) |
| 3894 | } |
| 3895 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3896 | func (dh *deviceHandler) PrepareReconcilingWithActiveAdapter(ctx context.Context) { |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3897 | logger.Debugw(ctx, "prepare to reconcile the ONU with adapter using persistency data", log.Fields{"device-id": dh.device.Id}) |
| 3898 | if err := dh.resetFsms(ctx, false); err != nil { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3899 | logger.Errorw(ctx, "reset of FSMs failed!", log.Fields{"device-id": dh.DeviceID, "error": err}) |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3900 | // TODO: fatal error reset ONU, delete deviceHandler! |
| 3901 | return |
| 3902 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3903 | dh.uniEntityMap = make(map[uint32]*cmn.OnuUniPort) |
| 3904 | dh.StartReconciling(ctx, false) |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3905 | } |
| 3906 | |
| 3907 | func (dh *deviceHandler) setCollectorIsRunning(flagValue bool) { |
| 3908 | dh.mutexCollectorFlag.Lock() |
| 3909 | dh.collectorIsRunning = flagValue |
| 3910 | dh.mutexCollectorFlag.Unlock() |
| 3911 | } |
| 3912 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3913 | func (dh *deviceHandler) GetCollectorIsRunning() bool { |
Holger Hildebrandt | 10d9819 | 2021-01-27 15:29:31 +0000 | [diff] [blame] | 3914 | dh.mutexCollectorFlag.RLock() |
| 3915 | flagValue := dh.collectorIsRunning |
| 3916 | dh.mutexCollectorFlag.RUnlock() |
| 3917 | return flagValue |
| 3918 | } |
Himani Chawla | ac1f5ad | 2021-02-04 21:21:54 +0530 | [diff] [blame] | 3919 | |
Himani Chawla | 4c1d4c7 | 2021-02-18 12:14:31 +0530 | [diff] [blame] | 3920 | func (dh *deviceHandler) setAlarmManagerIsRunning(flagValue bool) { |
| 3921 | dh.mutextAlarmManagerFlag.Lock() |
| 3922 | dh.alarmManagerIsRunning = flagValue |
| 3923 | dh.mutextAlarmManagerFlag.Unlock() |
| 3924 | } |
| 3925 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3926 | func (dh *deviceHandler) GetAlarmManagerIsRunning(ctx context.Context) bool { |
Himani Chawla | 4c1d4c7 | 2021-02-18 12:14:31 +0530 | [diff] [blame] | 3927 | dh.mutextAlarmManagerFlag.RLock() |
| 3928 | flagValue := dh.alarmManagerIsRunning |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 3929 | logger.Debugw(ctx, "alarm-manager-is-running", log.Fields{"device-id": dh.device.Id, "flag": dh.alarmManagerIsRunning}) |
Himani Chawla | 4c1d4c7 | 2021-02-18 12:14:31 +0530 | [diff] [blame] | 3930 | dh.mutextAlarmManagerFlag.RUnlock() |
| 3931 | return flagValue |
| 3932 | } |
| 3933 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3934 | func (dh *deviceHandler) StartAlarmManager(ctx context.Context) { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 3935 | logger.Debugw(ctx, "startingAlarmManager", log.Fields{"device-id": dh.device.Id}) |
Himani Chawla | ac1f5ad | 2021-02-04 21:21:54 +0530 | [diff] [blame] | 3936 | |
| 3937 | // Start routine to process OMCI GET Responses |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3938 | go dh.pAlarmMgr.StartOMCIAlarmMessageProcessing(ctx) |
Himani Chawla | 4c1d4c7 | 2021-02-18 12:14:31 +0530 | [diff] [blame] | 3939 | dh.setAlarmManagerIsRunning(true) |
Himani Chawla | ac1f5ad | 2021-02-04 21:21:54 +0530 | [diff] [blame] | 3940 | if stop := <-dh.stopAlarmManager; stop { |
| 3941 | logger.Debugw(ctx, "stopping-collector-for-onu", log.Fields{"device-id": dh.device.Id}) |
Himani Chawla | 4c1d4c7 | 2021-02-18 12:14:31 +0530 | [diff] [blame] | 3942 | dh.setAlarmManagerIsRunning(false) |
Himani Chawla | d3dac42 | 2021-03-13 02:31:31 +0530 | [diff] [blame] | 3943 | go func() { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3944 | if dh.pAlarmMgr.AlarmSyncFsm != nil && dh.pAlarmMgr.AlarmSyncFsm.PFsm != nil { |
| 3945 | _ = dh.pAlarmMgr.AlarmSyncFsm.PFsm.Event(almgr.AsEvStop) |
Himani Chawla | 1472c68 | 2021-03-17 17:11:14 +0530 | [diff] [blame] | 3946 | } |
Himani Chawla | d3dac42 | 2021-03-13 02:31:31 +0530 | [diff] [blame] | 3947 | }() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3948 | dh.pAlarmMgr.StopProcessingOmciMessages <- true // Stop the OMCI routines if any(This will stop the fsms also) |
| 3949 | dh.pAlarmMgr.StopAlarmAuditTimer <- struct{}{} |
Himani Chawla | 1472c68 | 2021-03-17 17:11:14 +0530 | [diff] [blame] | 3950 | logger.Debugw(ctx, "sent-all-stop-signals-to-alarm-manager", log.Fields{"device-id": dh.device.Id}) |
Himani Chawla | ac1f5ad | 2021-02-04 21:21:54 +0530 | [diff] [blame] | 3951 | } |
| 3952 | } |
Holger Hildebrandt | 38985dc | 2021-02-18 16:25:20 +0000 | [diff] [blame] | 3953 | |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3954 | func (dh *deviceHandler) setFlowMonitoringIsRunning(uniID uint8, flag bool) { |
| 3955 | dh.mutexFlowMonitoringRoutineFlag.Lock() |
| 3956 | defer dh.mutexFlowMonitoringRoutineFlag.Unlock() |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 3957 | logger.Debugw(context.Background(), "set-flow-monitoring-routine", log.Fields{"device-id": dh.device.Id, "flag": flag}) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3958 | dh.isFlowMonitoringRoutineActive[uniID] = flag |
| 3959 | } |
| 3960 | |
| 3961 | func (dh *deviceHandler) GetFlowMonitoringIsRunning(uniID uint8) bool { |
| 3962 | dh.mutexFlowMonitoringRoutineFlag.RLock() |
| 3963 | defer dh.mutexFlowMonitoringRoutineFlag.RUnlock() |
| 3964 | logger.Debugw(context.Background(), "get-flow-monitoring-routine", |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 3965 | log.Fields{"device-id": dh.device.Id, "isFlowMonitoringRoutineActive": dh.isFlowMonitoringRoutineActive}) |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 3966 | return dh.isFlowMonitoringRoutineActive[uniID] |
| 3967 | } |
| 3968 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3969 | func (dh *deviceHandler) StartReconciling(ctx context.Context, skipOnuConfig bool) { |
| 3970 | logger.Debugw(ctx, "start reconciling", log.Fields{"skipOnuConfig": skipOnuConfig, "device-id": dh.DeviceID}) |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 3971 | |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 3972 | connectStatus := voltha.ConnectStatus_UNREACHABLE |
| 3973 | operState := voltha.OperStatus_UNKNOWN |
| 3974 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3975 | if !dh.IsReconciling() { |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 3976 | go func() { |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 3977 | logger.Debugw(ctx, "wait for channel signal or timeout", |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 3978 | log.Fields{"timeout": dh.reconcileExpiryComplete, "device-id": dh.DeviceID}) |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 3979 | select { |
Holger Hildebrandt | b4563ab | 2021-04-14 10:27:20 +0000 | [diff] [blame] | 3980 | case success := <-dh.chReconcilingFinished: |
Holger Hildebrandt | f745925 | 2022-01-03 16:10:37 +0000 | [diff] [blame] | 3981 | logger.Debugw(ctx, "reconciling finished signal received", |
| 3982 | log.Fields{"device-id": dh.DeviceID, "dh.chReconcilingFinished": dh.chReconcilingFinished}) |
| 3983 | // To guarantee that the case-branch below is completely processed before reconciling processing is continued, |
| 3984 | // dh.mutexReconcilingFlag is locked already here. Thereby it is ensured, that further reconciling processing is stopped |
| 3985 | // at next call of dh.IsReconciling() until dh.reconciling is set after informing core about finished reconciling below. |
| 3986 | // This change addresses a problem described in VOL-4533 where the flag dh.reconciling not yet reset causes the uni ports |
| 3987 | // not to be created in ONOS in function dh.addUniPort(), when reconciling was started in reason "starting-openomci". |
| 3988 | // TODO: Keeping the mutex beyond an RPC towards core seems justifiable, as the effects here are easily overseeable. |
| 3989 | // However, a later refactoring of the functionality remains unaffected. |
| 3990 | dh.mutexReconcilingFlag.Lock() |
Holger Hildebrandt | b4563ab | 2021-04-14 10:27:20 +0000 | [diff] [blame] | 3991 | if success { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3992 | if onuDevEntry := dh.GetOnuDeviceEntry(ctx, true); onuDevEntry == nil { |
Maninder | b518755 | 2021-03-23 22:23:42 +0530 | [diff] [blame] | 3993 | logger.Errorw(ctx, "No valid OnuDevice - aborting Core DeviceStateUpdate", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3994 | log.Fields{"device-id": dh.DeviceID}) |
Maninder | b518755 | 2021-03-23 22:23:42 +0530 | [diff] [blame] | 3995 | } else { |
mpagenko | 2c3f6c5 | 2021-11-23 11:22:10 +0000 | [diff] [blame] | 3996 | onuDevEntry.MutexPersOnuConfig.RLock() |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3997 | if onuDevEntry.SOnuPersistentData.PersOperState == "up" { |
Maninder | b518755 | 2021-03-23 22:23:42 +0530 | [diff] [blame] | 3998 | connectStatus = voltha.ConnectStatus_REACHABLE |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 3999 | if !onuDevEntry.SOnuPersistentData.PersUniDisableDone { |
| 4000 | if onuDevEntry.SOnuPersistentData.PersUniUnlockDone { |
Maninder | b518755 | 2021-03-23 22:23:42 +0530 | [diff] [blame] | 4001 | operState = voltha.OperStatus_ACTIVE |
| 4002 | } else { |
| 4003 | operState = voltha.OperStatus_ACTIVATING |
| 4004 | } |
| 4005 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4006 | } else if onuDevEntry.SOnuPersistentData.PersOperState == "down" || |
| 4007 | onuDevEntry.SOnuPersistentData.PersOperState == "unknown" || |
| 4008 | onuDevEntry.SOnuPersistentData.PersOperState == "" { |
Maninder | b518755 | 2021-03-23 22:23:42 +0530 | [diff] [blame] | 4009 | operState = voltha.OperStatus_DISCOVERED |
| 4010 | } |
mpagenko | 2c3f6c5 | 2021-11-23 11:22:10 +0000 | [diff] [blame] | 4011 | onuDevEntry.MutexPersOnuConfig.RUnlock() |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 4012 | logger.Debugw(ctx, "Core DeviceStateUpdate", |
| 4013 | log.Fields{"device-id": dh.device.Id, "connectStatus": connectStatus, "operState": operState}) |
Maninder | b518755 | 2021-03-23 22:23:42 +0530 | [diff] [blame] | 4014 | } |
Holger Hildebrandt | b4563ab | 2021-04-14 10:27:20 +0000 | [diff] [blame] | 4015 | logger.Debugw(ctx, "reconciling has been finished in time", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4016 | log.Fields{"device-id": dh.DeviceID}) |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 4017 | if err := dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4018 | DeviceId: dh.DeviceID, |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4019 | ConnStatus: connectStatus, |
| 4020 | OperStatus: operState, |
| 4021 | }); err != nil { |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4022 | logger.Errorw(ctx, "unable to update device state to core", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4023 | log.Fields{"device-id": dh.DeviceID, "Err": err}) |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4024 | } |
Holger Hildebrandt | b4563ab | 2021-04-14 10:27:20 +0000 | [diff] [blame] | 4025 | } else { |
Maninder | b518755 | 2021-03-23 22:23:42 +0530 | [diff] [blame] | 4026 | logger.Errorw(ctx, "wait for reconciling aborted", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4027 | log.Fields{"device-id": dh.DeviceID}) |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4028 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4029 | if onuDevEntry := dh.GetOnuDeviceEntry(ctx, true); onuDevEntry == nil { |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4030 | logger.Errorw(ctx, "No valid OnuDevice", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4031 | log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 2c3f6c5 | 2021-11-23 11:22:10 +0000 | [diff] [blame] | 4032 | } else { |
| 4033 | onuDevEntry.MutexPersOnuConfig.RLock() |
| 4034 | if onuDevEntry.SOnuPersistentData.PersOperState == "up" { |
| 4035 | connectStatus = voltha.ConnectStatus_REACHABLE |
| 4036 | } |
| 4037 | onuDevEntry.MutexPersOnuConfig.RUnlock() |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4038 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4039 | dh.deviceReconcileFailedUpdate(ctx, cmn.DrReconcileCanceled, connectStatus) |
Holger Hildebrandt | b4563ab | 2021-04-14 10:27:20 +0000 | [diff] [blame] | 4040 | } |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 4041 | case <-time.After(dh.reconcileExpiryComplete): |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 4042 | logger.Errorw(ctx, "timeout waiting for reconciling to be finished!", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4043 | log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | f745925 | 2022-01-03 16:10:37 +0000 | [diff] [blame] | 4044 | dh.mutexReconcilingFlag.Lock() |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4045 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4046 | if onuDevEntry := dh.GetOnuDeviceEntry(ctx, true); onuDevEntry == nil { |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4047 | logger.Errorw(ctx, "No valid OnuDevice", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4048 | log.Fields{"device-id": dh.DeviceID}) |
mpagenko | 2c3f6c5 | 2021-11-23 11:22:10 +0000 | [diff] [blame] | 4049 | } else { |
| 4050 | onuDevEntry.MutexPersOnuConfig.RLock() |
| 4051 | if onuDevEntry.SOnuPersistentData.PersOperState == "up" { |
| 4052 | connectStatus = voltha.ConnectStatus_REACHABLE |
| 4053 | } |
| 4054 | onuDevEntry.MutexPersOnuConfig.RUnlock() |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4055 | } |
| 4056 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4057 | dh.deviceReconcileFailedUpdate(ctx, cmn.DrReconcileMaxTimeout, connectStatus) |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4058 | |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 4059 | } |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 4060 | dh.reconciling = cNoReconciling |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 4061 | dh.mutexReconcilingFlag.Unlock() |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 4062 | dh.SetReconcilingReasonUpdate(false) |
Holger Hildebrandt | 7741f27 | 2022-01-18 08:17:39 +0000 | [diff] [blame^] | 4063 | dh.SetReconcilingFirstPass(true) |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 4064 | |
| 4065 | if onuDevEntry := dh.GetOnuDeviceEntry(ctx, true); onuDevEntry == nil { |
| 4066 | logger.Errorw(ctx, "No valid OnuDevice", log.Fields{"device-id": dh.DeviceID}) |
| 4067 | } else { |
| 4068 | onuDevEntry.MutexReconciledTpInstances.Lock() |
| 4069 | onuDevEntry.ReconciledTpInstances = make(map[uint8]map[uint8]inter_adapter.TechProfileDownloadMessage) |
| 4070 | onuDevEntry.MutexReconciledTpInstances.Unlock() |
| 4071 | } |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 4072 | }() |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 4073 | } |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 4074 | dh.mutexReconcilingFlag.Lock() |
| 4075 | if skipOnuConfig { |
| 4076 | dh.reconciling = cSkipOnuConfigReconciling |
| 4077 | } else { |
| 4078 | dh.reconciling = cOnuConfigReconciling |
| 4079 | } |
| 4080 | dh.mutexReconcilingFlag.Unlock() |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 4081 | } |
| 4082 | |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 4083 | func (dh *deviceHandler) stopReconciling(ctx context.Context, success bool, reconcileFlowResult uint16) { |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4084 | logger.Debugw(ctx, "stop reconciling", log.Fields{"device-id": dh.DeviceID, "success": success}) |
| 4085 | if dh.IsReconciling() { |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 4086 | dh.sendChReconcileFinished(success) |
| 4087 | if reconcileFlowResult != cWaitReconcileFlowNoActivity { |
| 4088 | dh.SendChUniVlanConfigFinished(reconcileFlowResult) |
| 4089 | } |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 4090 | } else { |
mpagenko | 101ac94 | 2021-11-16 15:01:29 +0000 | [diff] [blame] | 4091 | logger.Debugw(ctx, "nothing to stop - reconciling is not running", log.Fields{"device-id": dh.DeviceID}) |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 4092 | } |
| 4093 | } |
| 4094 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4095 | func (dh *deviceHandler) IsReconciling() bool { |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 4096 | dh.mutexReconcilingFlag.RLock() |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 4097 | defer dh.mutexReconcilingFlag.RUnlock() |
| 4098 | return dh.reconciling != cNoReconciling |
| 4099 | } |
| 4100 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4101 | func (dh *deviceHandler) IsSkipOnuConfigReconciling() bool { |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 4102 | dh.mutexReconcilingFlag.RLock() |
| 4103 | defer dh.mutexReconcilingFlag.RUnlock() |
| 4104 | return dh.reconciling == cSkipOnuConfigReconciling |
| 4105 | } |
| 4106 | |
Holger Hildebrandt | 7741f27 | 2022-01-18 08:17:39 +0000 | [diff] [blame^] | 4107 | func (dh *deviceHandler) SetReconcilingFirstPass(value bool) { |
| 4108 | dh.mutexReconcilingFirstPassFlag.Lock() |
| 4109 | dh.reconcilingFirstPass = value |
| 4110 | dh.mutexReconcilingFirstPassFlag.Unlock() |
| 4111 | } |
| 4112 | |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 4113 | func (dh *deviceHandler) SetReconcilingReasonUpdate(value bool) { |
| 4114 | dh.mutexReconcilingReasonUpdate.Lock() |
| 4115 | dh.reconcilingReasonUpdate = value |
| 4116 | dh.mutexReconcilingReasonUpdate.Unlock() |
| 4117 | } |
| 4118 | |
| 4119 | func (dh *deviceHandler) IsReconcilingReasonUpdate() bool { |
| 4120 | dh.mutexReconcilingReasonUpdate.RLock() |
| 4121 | defer dh.mutexReconcilingReasonUpdate.RUnlock() |
| 4122 | return dh.reconcilingReasonUpdate |
| 4123 | } |
| 4124 | |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 4125 | func (dh *deviceHandler) getDeviceReason() uint8 { |
| 4126 | dh.mutexDeviceReason.RLock() |
| 4127 | value := dh.deviceReason |
| 4128 | dh.mutexDeviceReason.RUnlock() |
Holger Hildebrandt | f37b3d7 | 2021-02-17 10:25:22 +0000 | [diff] [blame] | 4129 | return value |
| 4130 | } |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 4131 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4132 | func (dh *deviceHandler) GetDeviceReasonString() string { |
| 4133 | return cmn.DeviceReasonMap[dh.getDeviceReason()] |
Holger Hildebrandt | be52384 | 2021-03-10 10:47:18 +0000 | [diff] [blame] | 4134 | } |
Holger Hildebrandt | b4563ab | 2021-04-14 10:27:20 +0000 | [diff] [blame] | 4135 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4136 | func (dh *deviceHandler) SetReadyForOmciConfig(flagValue bool) { |
Holger Hildebrandt | 0da7e6f | 2021-05-12 13:08:43 +0000 | [diff] [blame] | 4137 | dh.mutexReadyForOmciConfig.Lock() |
| 4138 | dh.readyForOmciConfig = flagValue |
| 4139 | dh.mutexReadyForOmciConfig.Unlock() |
| 4140 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4141 | func (dh *deviceHandler) IsReadyForOmciConfig() bool { |
Holger Hildebrandt | 0da7e6f | 2021-05-12 13:08:43 +0000 | [diff] [blame] | 4142 | dh.mutexReadyForOmciConfig.RLock() |
| 4143 | flagValue := dh.readyForOmciConfig |
| 4144 | dh.mutexReadyForOmciConfig.RUnlock() |
| 4145 | return flagValue |
| 4146 | } |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4147 | |
| 4148 | func (dh *deviceHandler) deviceReconcileFailedUpdate(ctx context.Context, deviceReason uint8, connectStatus voltha.ConnectStatus_Types) { |
mpagenko | e478208 | 2021-11-25 12:04:26 +0000 | [diff] [blame] | 4149 | if err := dh.ReasonUpdate(ctx, deviceReason, true); err != nil { |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4150 | logger.Errorw(ctx, "unable to update device reason to core", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4151 | log.Fields{"device-id": dh.DeviceID, "Err": err}) |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4152 | } |
| 4153 | |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 4154 | logger.Debugw(ctx, "Core DeviceStateUpdate", |
| 4155 | log.Fields{"device-id": dh.device.Id, "connectStatus": connectStatus, "operState": voltha.OperStatus_RECONCILING_FAILED}) |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 4156 | if err := dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{ |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4157 | DeviceId: dh.DeviceID, |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4158 | ConnStatus: connectStatus, |
| 4159 | OperStatus: voltha.OperStatus_RECONCILING_FAILED, |
| 4160 | }); err != nil { |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4161 | logger.Errorw(ctx, "unable to update device state to core", |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4162 | log.Fields{"device-id": dh.DeviceID, "Err": err}) |
Maninder | 7961d72 | 2021-06-16 22:10:28 +0530 | [diff] [blame] | 4163 | } |
| 4164 | } |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4165 | |
| 4166 | /* |
| 4167 | Helper functions to communicate with Core |
| 4168 | */ |
| 4169 | |
| 4170 | func (dh *deviceHandler) getDeviceFromCore(ctx context.Context, deviceID string) (*voltha.Device, error) { |
| 4171 | cClient, err := dh.coreClient.GetCoreServiceClient() |
| 4172 | if err != nil || cClient == nil { |
| 4173 | return nil, err |
| 4174 | } |
| 4175 | subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout) |
| 4176 | defer cancel() |
| 4177 | logger.Debugw(subCtx, "get-device-from-core", log.Fields{"device-id": deviceID}) |
| 4178 | return cClient.GetDevice(subCtx, &vc.ID{Id: deviceID}) |
| 4179 | } |
| 4180 | |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 4181 | func (dh *deviceHandler) updateDeviceStateInCore(ctx context.Context, deviceStateFilter *ca.DeviceStateFilter) error { |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4182 | cClient, err := dh.coreClient.GetCoreServiceClient() |
| 4183 | if err != nil || cClient == nil { |
| 4184 | return err |
| 4185 | } |
| 4186 | subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout) |
| 4187 | defer cancel() |
| 4188 | _, err = cClient.DeviceStateUpdate(subCtx, deviceStateFilter) |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 4189 | logger.Debugw(subCtx, "device-updated-in-core", |
| 4190 | log.Fields{"device-id": dh.device.Id, "device-state": deviceStateFilter, "error": err}) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4191 | return err |
| 4192 | } |
| 4193 | |
| 4194 | func (dh *deviceHandler) updatePMConfigInCore(ctx context.Context, pmConfigs *voltha.PmConfigs) error { |
| 4195 | cClient, err := dh.coreClient.GetCoreServiceClient() |
| 4196 | if err != nil || cClient == nil { |
| 4197 | return err |
| 4198 | } |
| 4199 | subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout) |
| 4200 | defer cancel() |
| 4201 | _, err = cClient.DevicePMConfigUpdate(subCtx, pmConfigs) |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 4202 | logger.Debugw(subCtx, "pmconfig-updated-in-core", |
| 4203 | log.Fields{"device-id": dh.device.Id, "pm-configs": pmConfigs, "error": err}) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4204 | return err |
| 4205 | } |
| 4206 | |
| 4207 | func (dh *deviceHandler) updateDeviceInCore(ctx context.Context, device *voltha.Device) error { |
| 4208 | cClient, err := dh.coreClient.GetCoreServiceClient() |
| 4209 | if err != nil || cClient == nil { |
| 4210 | return err |
| 4211 | } |
| 4212 | subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout) |
| 4213 | defer cancel() |
| 4214 | _, err = cClient.DeviceUpdate(subCtx, device) |
| 4215 | logger.Debugw(subCtx, "device-updated-in-core", log.Fields{"device-id": device.Id, "error": err}) |
| 4216 | return err |
| 4217 | } |
| 4218 | |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4219 | func (dh *deviceHandler) CreatePortInCore(ctx context.Context, port *voltha.Port) error { |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4220 | cClient, err := dh.coreClient.GetCoreServiceClient() |
| 4221 | if err != nil || cClient == nil { |
| 4222 | return err |
| 4223 | } |
| 4224 | subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout) |
| 4225 | defer cancel() |
| 4226 | _, err = cClient.PortCreated(subCtx, port) |
| 4227 | logger.Debugw(subCtx, "port-created-in-core", log.Fields{"port": port, "error": err}) |
| 4228 | return err |
| 4229 | } |
| 4230 | |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 4231 | func (dh *deviceHandler) updatePortStateInCore(ctx context.Context, portState *ca.PortState) error { |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4232 | cClient, err := dh.coreClient.GetCoreServiceClient() |
| 4233 | if err != nil || cClient == nil { |
| 4234 | return err |
| 4235 | } |
| 4236 | subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout) |
| 4237 | defer cancel() |
| 4238 | _, err = cClient.PortStateUpdate(subCtx, portState) |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 4239 | logger.Debugw(subCtx, "port-state-updated-in-core", log.Fields{"device-id": dh.device.Id, "port-state": portState, "error": err}) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4240 | return err |
| 4241 | } |
| 4242 | |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 4243 | func (dh *deviceHandler) updateDeviceReasonInCore(ctx context.Context, reason *ca.DeviceReason) error { |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4244 | cClient, err := dh.coreClient.GetCoreServiceClient() |
| 4245 | if err != nil || cClient == nil { |
| 4246 | return err |
| 4247 | } |
| 4248 | subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.RPCTimeout) |
| 4249 | defer cancel() |
| 4250 | _, err = cClient.DeviceReasonUpdate(subCtx, reason) |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 4251 | logger.Debugw(subCtx, "device-reason-updated-in-core", log.Fields{"device-id": dh.device.Id, "reason": reason, "error": err}) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4252 | return err |
| 4253 | } |
| 4254 | |
| 4255 | /* |
| 4256 | Helper functions to communicate with parent adapter |
| 4257 | */ |
| 4258 | |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 4259 | func (dh *deviceHandler) GetTechProfileInstanceFromParentAdapter(ctx context.Context, aUniID uint8, |
| 4260 | aTpPath string) (*ia.TechProfileDownloadMessage, error) { |
| 4261 | |
| 4262 | var request = ia.TechProfileInstanceRequestMessage{ |
| 4263 | DeviceId: dh.DeviceID, |
| 4264 | TpInstancePath: aTpPath, |
| 4265 | ParentDeviceId: dh.parentID, |
| 4266 | ParentPonPort: dh.device.ParentPortNo, |
| 4267 | OnuId: dh.device.ProxyAddress.OnuId, |
| 4268 | UniId: uint32(aUniID), |
| 4269 | } |
| 4270 | |
| 4271 | pgClient, err := dh.pOpenOnuAc.getParentAdapterServiceClient(dh.device.ProxyAddress.AdapterEndpoint) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4272 | if err != nil || pgClient == nil { |
| 4273 | return nil, err |
| 4274 | } |
| 4275 | subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.MaxTimeoutInterAdapterComm) |
| 4276 | defer cancel() |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 4277 | logger.Debugw(subCtx, "get-tech-profile-instance", |
| 4278 | log.Fields{"device-id": dh.device.Id, "request": request, "parent-endpoint": dh.device.ProxyAddress.AdapterEndpoint}) |
Holger Hildebrandt | 9afc158 | 2021-11-30 16:10:19 +0000 | [diff] [blame] | 4279 | return pgClient.GetTechProfileInstance(subCtx, &request) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4280 | } |
| 4281 | |
Girish Gowdra | e95687a | 2021-09-08 16:30:58 -0700 | [diff] [blame] | 4282 | // This routine is unique per ONU ID and blocks on flowControlBlock channel for incoming flows |
| 4283 | // Each incoming flow is processed in a synchronous manner, i.e., the flow is processed to completion before picking another |
| 4284 | func (dh *deviceHandler) PerOnuFlowHandlerRoutine(uniID uint8) { |
| 4285 | logger.Infow(context.Background(), "starting-flow-handler-routine", log.Fields{"device-id": dh.DeviceID}) |
| 4286 | dh.setFlowMonitoringIsRunning(uniID, true) |
| 4287 | for { |
| 4288 | select { |
| 4289 | // block on the channel to receive an incoming flow |
| 4290 | // process the flow completely before proceeding to handle the next flow |
| 4291 | case flowCb := <-dh.flowCbChan[uniID]: |
| 4292 | startTime := time.Now() |
| 4293 | logger.Debugw(flowCb.ctx, "serial-flow-processor--start", log.Fields{"device-id": dh.DeviceID}) |
| 4294 | respChan := make(chan error) |
| 4295 | if flowCb.addFlow { |
| 4296 | go dh.addFlowItemToUniPort(flowCb.ctx, flowCb.flowItem, flowCb.uniPort, flowCb.flowMetaData, &respChan) |
| 4297 | } else { |
| 4298 | go dh.removeFlowItemFromUniPort(flowCb.ctx, flowCb.flowItem, flowCb.uniPort, &respChan) |
| 4299 | } |
| 4300 | // Block on response and tunnel it back to the caller |
| 4301 | *flowCb.respChan <- <-respChan |
| 4302 | logger.Debugw(flowCb.ctx, "serial-flow-processor--end", |
| 4303 | log.Fields{"device-id": dh.DeviceID, "absoluteTimeForFlowProcessingInSecs": time.Since(startTime).Seconds()}) |
| 4304 | case <-dh.stopFlowMonitoringRoutine[uniID]: |
| 4305 | logger.Infow(context.Background(), "stopping-flow-handler-routine", log.Fields{"device-id": dh.DeviceID}) |
| 4306 | dh.setFlowMonitoringIsRunning(uniID, false) |
| 4307 | return |
| 4308 | } |
| 4309 | } |
| 4310 | } |
| 4311 | |
khenaidoo | 42dcdfd | 2021-10-19 17:34:12 -0400 | [diff] [blame] | 4312 | func (dh *deviceHandler) SendOMCIRequest(ctx context.Context, parentEndpoint string, request *ia.OmciMessage) error { |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4313 | pgClient, err := dh.pOpenOnuAc.getParentAdapterServiceClient(parentEndpoint) |
| 4314 | if err != nil || pgClient == nil { |
| 4315 | return err |
| 4316 | } |
| 4317 | subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.config.MaxTimeoutInterAdapterComm) |
| 4318 | defer cancel() |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 4319 | logger.Debugw(subCtx, "send-omci-request", log.Fields{"device-id": dh.device.Id, "request": request, "parent-endpoint": parentEndpoint}) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4320 | _, err = pgClient.ProxyOmciRequest(subCtx, request) |
| 4321 | if err != nil { |
Holger Hildebrandt | ba6fbe8 | 2021-12-03 14:29:42 +0000 | [diff] [blame] | 4322 | logger.Errorw(ctx, "omci-failure", |
| 4323 | log.Fields{"device-id": dh.device.Id, "request": request, "error": err, "request-parent": request.ParentDeviceId, |
| 4324 | "request-child": request.ChildDeviceId, "request-proxy": request.ProxyAddress}) |
khenaidoo | 7d3c558 | 2021-08-11 18:09:44 -0400 | [diff] [blame] | 4325 | } |
| 4326 | return err |
| 4327 | } |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4328 | |
| 4329 | // GetDeviceID - TODO: add comment |
| 4330 | func (dh *deviceHandler) GetDeviceID() string { |
| 4331 | return dh.DeviceID |
| 4332 | } |
| 4333 | |
| 4334 | // GetProxyAddressID - TODO: add comment |
| 4335 | func (dh *deviceHandler) GetProxyAddressID() string { |
| 4336 | return dh.device.ProxyAddress.GetDeviceId() |
| 4337 | } |
| 4338 | |
| 4339 | // GetProxyAddressType - TODO: add comment |
| 4340 | func (dh *deviceHandler) GetProxyAddressType() string { |
| 4341 | return dh.device.ProxyAddress.GetDeviceType() |
| 4342 | } |
| 4343 | |
| 4344 | // GetProxyAddress - TODO: add comment |
| 4345 | func (dh *deviceHandler) GetProxyAddress() *voltha.Device_ProxyAddress { |
| 4346 | return dh.device.ProxyAddress |
| 4347 | } |
| 4348 | |
| 4349 | // GetEventProxy - TODO: add comment |
| 4350 | func (dh *deviceHandler) GetEventProxy() eventif.EventProxy { |
| 4351 | return dh.EventProxy |
| 4352 | } |
| 4353 | |
| 4354 | // GetOmciTimeout - TODO: add comment |
| 4355 | func (dh *deviceHandler) GetOmciTimeout() int { |
| 4356 | return dh.pOpenOnuAc.omciTimeout |
| 4357 | } |
| 4358 | |
| 4359 | // GetAlarmAuditInterval - TODO: add comment |
| 4360 | func (dh *deviceHandler) GetAlarmAuditInterval() time.Duration { |
| 4361 | return dh.pOpenOnuAc.alarmAuditInterval |
| 4362 | } |
| 4363 | |
| 4364 | // GetDlToOnuTimeout4M - TODO: add comment |
| 4365 | func (dh *deviceHandler) GetDlToOnuTimeout4M() time.Duration { |
| 4366 | return dh.pOpenOnuAc.dlToOnuTimeout4M |
| 4367 | } |
| 4368 | |
| 4369 | // GetUniEntityMap - TODO: add comment |
| 4370 | func (dh *deviceHandler) GetUniEntityMap() *cmn.OnuUniPortMap { |
| 4371 | return &dh.uniEntityMap |
| 4372 | } |
| 4373 | |
| 4374 | // GetPonPortNumber - TODO: add comment |
| 4375 | func (dh *deviceHandler) GetPonPortNumber() *uint32 { |
| 4376 | return &dh.ponPortNumber |
| 4377 | } |
| 4378 | |
| 4379 | // GetUniVlanConfigFsm - TODO: add comment |
| 4380 | func (dh *deviceHandler) GetUniVlanConfigFsm(uniID uint8) cmn.IuniVlanConfigFsm { |
Holger Hildebrandt | c192bc4 | 2021-10-28 14:38:31 +0000 | [diff] [blame] | 4381 | dh.lockVlanConfig.RLock() |
| 4382 | value := dh.UniVlanConfigFsmMap[uniID] |
| 4383 | dh.lockVlanConfig.RUnlock() |
| 4384 | return value |
Holger Hildebrandt | 4b5e73f | 2021-08-19 06:51:21 +0000 | [diff] [blame] | 4385 | } |
| 4386 | |
| 4387 | // GetOnuAlarmManager - TODO: add comment |
| 4388 | func (dh *deviceHandler) GetOnuAlarmManager() cmn.IonuAlarmManager { |
| 4389 | return dh.pAlarmMgr |
| 4390 | } |
| 4391 | |
| 4392 | // GetOnuMetricsManager - TODO: add comment |
| 4393 | func (dh *deviceHandler) GetOnuMetricsManager() cmn.IonuMetricsManager { |
| 4394 | return dh.pOnuMetricsMgr |
| 4395 | } |
| 4396 | |
| 4397 | // GetOnuTP - TODO: add comment |
| 4398 | func (dh *deviceHandler) GetOnuTP() cmn.IonuUniTechProf { |
| 4399 | return dh.pOnuTP |
| 4400 | } |
| 4401 | |
| 4402 | // GetBackendPathPrefix - TODO: add comment |
| 4403 | func (dh *deviceHandler) GetBackendPathPrefix() string { |
| 4404 | return dh.pOpenOnuAc.cm.Backend.PathPrefix |
| 4405 | } |
| 4406 | |
| 4407 | // GetOnuIndication - TODO: add comment |
| 4408 | func (dh *deviceHandler) GetOnuIndication() *openolt.OnuIndication { |
| 4409 | return dh.pOnuIndication |
| 4410 | } |
| 4411 | |
| 4412 | // RLockMutexDeletionInProgressFlag - TODO: add comment |
| 4413 | func (dh *deviceHandler) RLockMutexDeletionInProgressFlag() { |
| 4414 | dh.mutexDeletionInProgressFlag.RLock() |
| 4415 | } |
| 4416 | |
| 4417 | // RUnlockMutexDeletionInProgressFlag - TODO: add comment |
| 4418 | func (dh *deviceHandler) RUnlockMutexDeletionInProgressFlag() { |
| 4419 | dh.mutexDeletionInProgressFlag.RUnlock() |
| 4420 | } |
| 4421 | |
| 4422 | // GetDeletionInProgress - TODO: add comment |
| 4423 | func (dh *deviceHandler) GetDeletionInProgress() bool { |
| 4424 | return dh.deletionInProgress |
| 4425 | } |
| 4426 | |
| 4427 | // GetPmConfigs - TODO: add comment |
| 4428 | func (dh *deviceHandler) GetPmConfigs() *voltha.PmConfigs { |
| 4429 | return dh.pmConfigs |
| 4430 | } |
| 4431 | |
| 4432 | // GetDeviceType - TODO: add comment |
| 4433 | func (dh *deviceHandler) GetDeviceType() string { |
| 4434 | return dh.DeviceType |
| 4435 | } |
| 4436 | |
| 4437 | // GetLogicalDeviceID - TODO: add comment |
| 4438 | func (dh *deviceHandler) GetLogicalDeviceID() string { |
| 4439 | return dh.logicalDeviceID |
| 4440 | } |
| 4441 | |
| 4442 | // GetDevice - TODO: add comment |
| 4443 | func (dh *deviceHandler) GetDevice() *voltha.Device { |
| 4444 | return dh.device |
| 4445 | } |
| 4446 | |
| 4447 | // GetMetricsEnabled - TODO: add comment |
| 4448 | func (dh *deviceHandler) GetMetricsEnabled() bool { |
| 4449 | return dh.pOpenOnuAc.MetricsEnabled |
| 4450 | } |
| 4451 | |
| 4452 | // InitPmConfigs - TODO: add comment |
| 4453 | func (dh *deviceHandler) InitPmConfigs() { |
| 4454 | dh.pmConfigs = &voltha.PmConfigs{} |
| 4455 | } |
| 4456 | |
| 4457 | // GetUniPortMask - TODO: add comment |
| 4458 | func (dh *deviceHandler) GetUniPortMask() int { |
| 4459 | return dh.pOpenOnuAc.config.UniPortMask |
| 4460 | } |
Holger Hildebrandt | b314f44 | 2021-11-24 12:03:10 +0000 | [diff] [blame] | 4461 | |
| 4462 | func (dh *deviceHandler) anyTpPathExists(aTpPathMap map[uint8]string) bool { |
| 4463 | tpPathFound := false |
| 4464 | for _, tpPath := range aTpPathMap { |
| 4465 | if tpPath != "" { |
| 4466 | tpPathFound = true |
| 4467 | } |
| 4468 | } |
| 4469 | return tpPathFound |
| 4470 | } |