blob: 4f060a2c61137577f2abacbb913cb10431fe36fc [file] [log] [blame]
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001/*
2 * Copyright 2020-present Open Networking Foundation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//Package adaptercoreonu provides the utility for onu devices, flows and statistics
18package adaptercoreonu
19
20import (
21 "context"
Andrea Campanella6515c582020-10-05 11:25:00 +020022 "fmt"
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000023 "time"
24
25 "github.com/looplab/fsm"
26
27 "github.com/opencord/omci-lib-go"
28 me "github.com/opencord/omci-lib-go/generated"
dbainbri4d3a0dc2020-12-02 00:33:42 +000029 "github.com/opencord/voltha-lib-go/v4/pkg/log"
30 //ic "github.com/opencord/voltha-protos/v4/go/inter_container"
31 //"github.com/opencord/voltha-protos/v4/go/openflow_13"
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000032)
33
Himani Chawla6d2ae152020-09-02 13:11:20 +053034//lockStateFsm defines the structure for the state machine to lock/unlock the ONU UNI ports via OMCI
35type lockStateFsm struct {
Holger Hildebrandt8165eda2020-09-24 09:39:24 +000036 pDeviceHandler *deviceHandler
mpagenko01e726e2020-10-23 09:45:29 +000037 deviceID string
Himani Chawla6d2ae152020-09-02 13:11:20 +053038 pOmciCC *omciCC
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000039 adminState bool
40 requestEvent OnuDeviceEvent
41 omciLockResponseReceived chan bool //seperate channel needed for checking UNI port OMCi message responses
42 pAdaptFsm *AdapterFsm
mpagenko01e726e2020-10-23 09:45:29 +000043 pLastTxMeInstance *me.ManagedEntity
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000044}
45
mpagenko1cc3cb42020-07-27 15:24:38 +000046const (
47 // events of lock/unlock UNI port FSM
48 uniEvStart = "uniEvStart"
49 uniEvStartAdmin = "uniEvStartAdmin"
50 uniEvRxUnisResp = "uniEvRxUnisResp"
51 uniEvRxOnugResp = "uniEvRxOnugResp"
52 uniEvTimeoutSimple = "uniEvTimeoutSimple"
53 uniEvTimeoutUnis = "uniEvTimeoutUnis"
54 uniEvReset = "uniEvReset"
55 uniEvRestart = "uniEvRestart"
56)
57const (
58 // states of lock/unlock UNI port FSM
59 uniStDisabled = "uniStDisabled"
60 uniStStarting = "uniStStarting"
61 uniStSettingUnis = "uniStSettingUnis"
62 uniStSettingOnuG = "uniStSettingOnuG"
63 uniStAdminDone = "uniStAdminDone"
64 uniStResetting = "uniStResetting"
65)
Holger Hildebrandt10d98192021-01-27 15:29:31 +000066const cUniFsmIdleState = uniStDisabled
mpagenko1cc3cb42020-07-27 15:24:38 +000067
Himani Chawla6d2ae152020-09-02 13:11:20 +053068//newLockStateFsm is the 'constructor' for the state machine to lock/unlock the ONU UNI ports via OMCI
dbainbri4d3a0dc2020-12-02 00:33:42 +000069func newLockStateFsm(ctx context.Context, apDevOmciCC *omciCC, aAdminState bool, aRequestEvent OnuDeviceEvent,
Holger Hildebrandt8165eda2020-09-24 09:39:24 +000070 aName string, apDeviceHandler *deviceHandler, aCommChannel chan Message) *lockStateFsm {
Himani Chawla6d2ae152020-09-02 13:11:20 +053071 instFsm := &lockStateFsm{
Holger Hildebrandt8165eda2020-09-24 09:39:24 +000072 pDeviceHandler: apDeviceHandler,
mpagenko01e726e2020-10-23 09:45:29 +000073 deviceID: apDeviceHandler.deviceID,
Holger Hildebrandt8165eda2020-09-24 09:39:24 +000074 pOmciCC: apDevOmciCC,
75 adminState: aAdminState,
76 requestEvent: aRequestEvent,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000077 }
mpagenko01e726e2020-10-23 09:45:29 +000078 instFsm.pAdaptFsm = NewAdapterFsm(aName, instFsm.deviceID, aCommChannel)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000079 if instFsm.pAdaptFsm == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +000080 logger.Errorw(ctx, "LockStateFsm's AdapterFsm could not be instantiated!!", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +000081 "device-id": instFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000082 return nil
83 }
Himani Chawla4d908332020-08-31 12:30:20 +053084 if aAdminState { //port locking requested
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000085 instFsm.pAdaptFsm.pFsm = fsm.NewFSM(
mpagenko1cc3cb42020-07-27 15:24:38 +000086 uniStDisabled,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000087 fsm.Events{
88
mpagenko1cc3cb42020-07-27 15:24:38 +000089 {Name: uniEvStart, Src: []string{uniStDisabled}, Dst: uniStStarting},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000090
mpagenko1cc3cb42020-07-27 15:24:38 +000091 {Name: uniEvStartAdmin, Src: []string{uniStStarting}, Dst: uniStSettingUnis},
92 // the settingUnis state is used for multi ME config for all UNI related ports
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000093 // maybe such could be reflected in the state machine as well (port number parametrized)
94 // but that looks not straightforward here - so we keep it simple here for the beginning(?)
mpagenko1cc3cb42020-07-27 15:24:38 +000095 {Name: uniEvRxUnisResp, Src: []string{uniStSettingUnis}, Dst: uniStSettingOnuG},
96 {Name: uniEvRxOnugResp, Src: []string{uniStSettingOnuG}, Dst: uniStAdminDone},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000097
mpagenko1cc3cb42020-07-27 15:24:38 +000098 {Name: uniEvTimeoutSimple, Src: []string{uniStSettingOnuG}, Dst: uniStStarting},
99 {Name: uniEvTimeoutUnis, Src: []string{uniStSettingUnis}, Dst: uniStStarting},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000100
mpagenko1cc3cb42020-07-27 15:24:38 +0000101 {Name: uniEvReset, Src: []string{uniStStarting, uniStSettingOnuG, uniStSettingUnis,
102 uniStAdminDone}, Dst: uniStResetting},
103 // exceptional treatment for all states except uniStResetting
104 {Name: uniEvRestart, Src: []string{uniStStarting, uniStSettingOnuG, uniStSettingUnis,
105 uniStAdminDone, uniStResetting}, Dst: uniStDisabled},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000106 },
107
108 fsm.Callbacks{
dbainbri4d3a0dc2020-12-02 00:33:42 +0000109 "enter_state": func(e *fsm.Event) { instFsm.pAdaptFsm.logFsmStateChange(ctx, e) },
110 ("enter_" + uniStStarting): func(e *fsm.Event) { instFsm.enterAdminStartingState(ctx, e) },
111 ("enter_" + uniStSettingOnuG): func(e *fsm.Event) { instFsm.enterSettingOnuGState(ctx, e) },
112 ("enter_" + uniStSettingUnis): func(e *fsm.Event) { instFsm.enterSettingUnisState(ctx, e) },
113 ("enter_" + uniStAdminDone): func(e *fsm.Event) { instFsm.enterAdminDoneState(ctx, e) },
114 ("enter_" + uniStResetting): func(e *fsm.Event) { instFsm.enterResettingState(ctx, e) },
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000115 },
116 )
117 } else { //port unlocking requested
118 instFsm.pAdaptFsm.pFsm = fsm.NewFSM(
mpagenko1cc3cb42020-07-27 15:24:38 +0000119 uniStDisabled,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000120 fsm.Events{
121
mpagenko1cc3cb42020-07-27 15:24:38 +0000122 {Name: uniEvStart, Src: []string{uniStDisabled}, Dst: uniStStarting},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000123
mpagenko1cc3cb42020-07-27 15:24:38 +0000124 {Name: uniEvStartAdmin, Src: []string{uniStStarting}, Dst: uniStSettingOnuG},
125 {Name: uniEvRxOnugResp, Src: []string{uniStSettingOnuG}, Dst: uniStSettingUnis},
126 // the settingUnis state is used for multi ME config for all UNI related ports
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000127 // maybe such could be reflected in the state machine as well (port number parametrized)
128 // but that looks not straightforward here - so we keep it simple here for the beginning(?)
mpagenko1cc3cb42020-07-27 15:24:38 +0000129 {Name: uniEvRxUnisResp, Src: []string{uniStSettingUnis}, Dst: uniStAdminDone},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000130
mpagenko1cc3cb42020-07-27 15:24:38 +0000131 {Name: uniEvTimeoutSimple, Src: []string{uniStSettingOnuG}, Dst: uniStStarting},
132 {Name: uniEvTimeoutUnis, Src: []string{uniStSettingUnis}, Dst: uniStStarting},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000133
mpagenko1cc3cb42020-07-27 15:24:38 +0000134 {Name: uniEvReset, Src: []string{uniStStarting, uniStSettingOnuG, uniStSettingUnis,
135 uniStAdminDone}, Dst: uniStResetting},
136 // exceptional treatment for all states except uniStResetting
137 {Name: uniEvRestart, Src: []string{uniStStarting, uniStSettingOnuG, uniStSettingUnis,
138 uniStAdminDone, uniStResetting}, Dst: uniStDisabled},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000139 },
140
141 fsm.Callbacks{
dbainbri4d3a0dc2020-12-02 00:33:42 +0000142 "enter_state": func(e *fsm.Event) { instFsm.pAdaptFsm.logFsmStateChange(ctx, e) },
143 ("enter_" + uniStStarting): func(e *fsm.Event) { instFsm.enterAdminStartingState(ctx, e) },
144 ("enter_" + uniStSettingOnuG): func(e *fsm.Event) { instFsm.enterSettingOnuGState(ctx, e) },
145 ("enter_" + uniStSettingUnis): func(e *fsm.Event) { instFsm.enterSettingUnisState(ctx, e) },
146 ("enter_" + uniStAdminDone): func(e *fsm.Event) { instFsm.enterAdminDoneState(ctx, e) },
147 ("enter_" + uniStResetting): func(e *fsm.Event) { instFsm.enterResettingState(ctx, e) },
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000148 },
149 )
150 }
151 if instFsm.pAdaptFsm.pFsm == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000152 logger.Errorw(ctx, "LockStateFsm's Base FSM could not be instantiated!!", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +0000153 "device-id": instFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000154 return nil
155 }
156
dbainbri4d3a0dc2020-12-02 00:33:42 +0000157 logger.Debugw(ctx, "LockStateFsm created", log.Fields{"device-id": instFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000158 return instFsm
159}
160
Himani Chawla6d2ae152020-09-02 13:11:20 +0530161//setSuccessEvent modifies the requested event notified on success
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000162//assumption is that this is only called in the disabled (idle) state of the FSM, hence no sem protection required
Himani Chawla6d2ae152020-09-02 13:11:20 +0530163func (oFsm *lockStateFsm) setSuccessEvent(aEvent OnuDeviceEvent) {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000164 oFsm.requestEvent = aEvent
165}
166
dbainbri4d3a0dc2020-12-02 00:33:42 +0000167func (oFsm *lockStateFsm) enterAdminStartingState(ctx context.Context, e *fsm.Event) {
168 logger.Debugw(ctx, "LockStateFSM start", log.Fields{"in state": e.FSM.Current(),
mpagenko01e726e2020-10-23 09:45:29 +0000169 "device-id": oFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000170 // in case the used channel is not yet defined (can be re-used after restarts)
171 if oFsm.omciLockResponseReceived == nil {
172 oFsm.omciLockResponseReceived = make(chan bool)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000173 logger.Debug(ctx, "LockStateFSM - OMCI UniLock RxChannel defined")
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000174 } else {
175 // as we may 're-use' this instance of FSM and the connected channel
176 // make sure there is no 'lingering' request in the already existing channel:
177 // (simple loop sufficient as we are the only receiver)
178 for len(oFsm.omciLockResponseReceived) > 0 {
179 <-oFsm.omciLockResponseReceived
180 }
181 }
182 // start go routine for processing of LockState messages
dbainbri4d3a0dc2020-12-02 00:33:42 +0000183 go oFsm.processOmciLockMessages(ctx)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000184
185 //let the state machine run forward from here directly
186 pLockStateAFsm := oFsm.pAdaptFsm
187 if pLockStateAFsm != nil {
188 // obviously calling some FSM event here directly does not work - so trying to decouple it ...
189 go func(a_pAFsm *AdapterFsm) {
190 if a_pAFsm != nil && a_pAFsm.pFsm != nil {
Himani Chawla4d908332020-08-31 12:30:20 +0530191 _ = a_pAFsm.pFsm.Event(uniEvStartAdmin)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000192 }
193 }(pLockStateAFsm)
194 }
195}
196
dbainbri4d3a0dc2020-12-02 00:33:42 +0000197func (oFsm *lockStateFsm) enterSettingOnuGState(ctx context.Context, e *fsm.Event) {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000198 var omciAdminState uint8 = 1 //default locked
Himani Chawla4d908332020-08-31 12:30:20 +0530199 if !oFsm.adminState {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000200 omciAdminState = 0
201 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000202 logger.Debugw(ctx, "LockStateFSM Tx Set::ONU-G:admin", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +0000203 "omciAdmin": omciAdminState, "in state": e.FSM.Current(), "device-id": oFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000204 requestedAttributes := me.AttributeValueMap{"AdministrativeState": omciAdminState}
Girish Gowdra0b235842021-03-09 13:06:46 -0800205 meInstance := oFsm.pOmciCC.sendSetOnuGLS(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000206 requestedAttributes, oFsm.pAdaptFsm.commChan)
207 //accept also nil as (error) return value for writing to LastTx
208 // - this avoids misinterpretation of new received OMCI messages
209 // we might already abort the processing with nil here, but maybe some auto-recovery may be tried
210 // - may be improved later, for now we just handle it with the Rx timeout or missing next event (stick in state)
mpagenko01e726e2020-10-23 09:45:29 +0000211 oFsm.pLastTxMeInstance = meInstance
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000212}
213
dbainbri4d3a0dc2020-12-02 00:33:42 +0000214func (oFsm *lockStateFsm) enterSettingUnisState(ctx context.Context, e *fsm.Event) {
mpagenko8b5fdd22020-12-17 17:58:32 +0000215 logger.Debugw(ctx, "LockStateFSM - starting UniTP adminState loop", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +0000216 "in state": e.FSM.Current(), "device-id": oFsm.deviceID, "LockState": oFsm.adminState})
dbainbri4d3a0dc2020-12-02 00:33:42 +0000217 go oFsm.performUniPortAdminSet(ctx)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000218}
219
dbainbri4d3a0dc2020-12-02 00:33:42 +0000220func (oFsm *lockStateFsm) enterAdminDoneState(ctx context.Context, e *fsm.Event) {
221 logger.Debugw(ctx, "LockStateFSM", log.Fields{"send notification to core in State": e.FSM.Current(), "device-id": oFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000222 //use DeviceHandler event notification directly, no need/support to update DeviceEntryState for lock/unlock
dbainbri4d3a0dc2020-12-02 00:33:42 +0000223 oFsm.pDeviceHandler.deviceProcStatusUpdate(ctx, oFsm.requestEvent)
Holger Hildebrandt8165eda2020-09-24 09:39:24 +0000224
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000225 //let's reset the state machine in order to release all resources now
226 pLockStateAFsm := oFsm.pAdaptFsm
227 if pLockStateAFsm != nil {
228 // obviously calling some FSM event here directly does not work - so trying to decouple it ...
229 go func(a_pAFsm *AdapterFsm) {
230 if a_pAFsm != nil && a_pAFsm.pFsm != nil {
Himani Chawla4d908332020-08-31 12:30:20 +0530231 _ = a_pAFsm.pFsm.Event(uniEvReset)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000232 }
233 }(pLockStateAFsm)
234 }
235}
236
dbainbri4d3a0dc2020-12-02 00:33:42 +0000237func (oFsm *lockStateFsm) enterResettingState(ctx context.Context, e *fsm.Event) {
238 logger.Debugw(ctx, "LockStateFSM resetting", log.Fields{"device-id": oFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000239 pLockStateAFsm := oFsm.pAdaptFsm
240 if pLockStateAFsm != nil {
241 // abort running message processing
242 fsmAbortMsg := Message{
243 Type: TestMsg,
244 Data: TestMessage{
245 TestMessageVal: AbortMessageProcessing,
246 },
247 }
248 pLockStateAFsm.commChan <- fsmAbortMsg
249
250 //try to restart the FSM to 'disabled'
251 // see DownloadedState: decouple event transfer
252 go func(a_pAFsm *AdapterFsm) {
253 if a_pAFsm != nil && a_pAFsm.pFsm != nil {
Himani Chawla4d908332020-08-31 12:30:20 +0530254 _ = a_pAFsm.pFsm.Event(uniEvRestart)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000255 }
256 }(pLockStateAFsm)
mpagenko01e726e2020-10-23 09:45:29 +0000257 oFsm.pLastTxMeInstance = nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000258 }
259}
260
dbainbri4d3a0dc2020-12-02 00:33:42 +0000261func (oFsm *lockStateFsm) processOmciLockMessages(ctx context.Context) {
262 logger.Debugw(ctx, "Start LockStateFsm Msg processing", log.Fields{"for device-id": oFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000263loop:
264 for {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000265 // case <-ctx.Done():
dbainbri4d3a0dc2020-12-02 00:33:42 +0000266 // logger.Info(ctx,"MibSync Msg", log.Fields{"Message handling canceled via context for device-id": oFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000267 // break loop
Himani Chawla4d908332020-08-31 12:30:20 +0530268 message, ok := <-oFsm.pAdaptFsm.commChan
269 if !ok {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000270 logger.Info(ctx, "LockStateFsm Rx Msg - could not read from channel", log.Fields{"device-id": oFsm.deviceID})
Himani Chawla4d908332020-08-31 12:30:20 +0530271 // but then we have to ensure a restart of the FSM as well - as exceptional procedure
272 _ = oFsm.pAdaptFsm.pFsm.Event(uniEvRestart)
273 break loop
274 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000275 logger.Debugw(ctx, "LockStateFsm Rx Msg", log.Fields{"device-id": oFsm.deviceID})
Himani Chawla4d908332020-08-31 12:30:20 +0530276
277 switch message.Type {
278 case TestMsg:
279 msg, _ := message.Data.(TestMessage)
280 if msg.TestMessageVal == AbortMessageProcessing {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000281 logger.Debugw(ctx, "LockStateFsm abort ProcessMsg", log.Fields{"for device-id": oFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000282 break loop
283 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000284 logger.Warnw(ctx, "LockStateFsm unknown TestMessage", log.Fields{"device-id": oFsm.deviceID, "MessageVal": msg.TestMessageVal})
Himani Chawla4d908332020-08-31 12:30:20 +0530285 case OMCI:
286 msg, _ := message.Data.(OmciMessage)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000287 oFsm.handleOmciLockStateMessage(ctx, msg)
Himani Chawla4d908332020-08-31 12:30:20 +0530288 default:
dbainbri4d3a0dc2020-12-02 00:33:42 +0000289 logger.Warn(ctx, "LockStateFsm Rx unknown message", log.Fields{"device-id": oFsm.deviceID,
Himani Chawla4d908332020-08-31 12:30:20 +0530290 "message.Type": message.Type})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000291 }
292 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000293 logger.Debugw(ctx, "End LockStateFsm Msg processing", log.Fields{"device-id": oFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000294}
295
dbainbri4d3a0dc2020-12-02 00:33:42 +0000296func (oFsm *lockStateFsm) handleOmciLockStateMessage(ctx context.Context, msg OmciMessage) {
297 logger.Debugw(ctx, "Rx OMCI LockStateFsm Msg", log.Fields{"device-id": oFsm.deviceID,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000298 "msgType": msg.OmciMsg.MessageType})
299
300 if msg.OmciMsg.MessageType == omci.SetResponseType {
301 msgLayer := (*msg.OmciPacket).Layer(omci.LayerTypeSetResponse)
302 if msgLayer == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000303 logger.Errorw(ctx, "LockStateFsm - Omci Msg layer could not be detected for SetResponse",
mpagenko01e726e2020-10-23 09:45:29 +0000304 log.Fields{"device-id": oFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000305 return
306 }
307 msgObj, msgOk := msgLayer.(*omci.SetResponse)
308 if !msgOk {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000309 logger.Errorw(ctx, "LockStateFsm - Omci Msg layer could not be assigned for SetResponse",
mpagenko01e726e2020-10-23 09:45:29 +0000310 log.Fields{"device-id": oFsm.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000311 return
312 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000313 logger.Debugw(ctx, "LockStateFsm SetResponse Data", log.Fields{"device-id": oFsm.deviceID, "data-fields": msgObj})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000314 if msgObj.Result != me.Success {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000315 logger.Errorw(ctx, "LockStateFsm - Omci SetResponse Error - later: drive FSM to abort state ?", log.Fields{"Error": msgObj.Result})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000316 // possibly force FSM into abort or ignore some errors for some messages? store error for mgmt display?
317 return
318 }
319 // compare comments above for CreateResponse (apply also here ...)
mpagenko01e726e2020-10-23 09:45:29 +0000320 if msgObj.EntityClass == oFsm.pLastTxMeInstance.GetClassID() &&
321 msgObj.EntityInstance == oFsm.pLastTxMeInstance.GetEntityID() {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000322 //store the created ME into DB //TODO??? obviously the Python code does not store the config ...
323 // if, then something like:
324 //oFsm.pOnuDB.StoreMe(msgObj)
325
mpagenko01e726e2020-10-23 09:45:29 +0000326 switch oFsm.pLastTxMeInstance.GetName() {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000327 case "OnuG":
328 { // let the FSM proceed ...
Himani Chawla4d908332020-08-31 12:30:20 +0530329 _ = oFsm.pAdaptFsm.pFsm.Event(uniEvRxOnugResp)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000330 }
Holger Hildebrandtd1a89222020-12-15 15:32:07 +0000331 case "PhysicalPathTerminationPointEthernetUni", "VirtualEthernetInterfacePoint":
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000332 { // let the PPTP init proceed by stopping the wait function
333 oFsm.omciLockResponseReceived <- true
334 }
335 }
Matteo Scandolob250bec2021-01-27 17:35:45 -0800336 } else {
337 logger.Warnf(ctx, "LockStateFsm - Received SetResponse Data for %s with wrong classID or entityID ",
338 log.Fields{"device-id": oFsm.deviceID, "data-fields": msgObj}, msgObj.EntityClass)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000339 }
340 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000341 logger.Errorw(ctx, "LockStateFsm - Rx OMCI unhandled MsgType", log.Fields{"omciMsgType": msg.OmciMsg.MessageType})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000342 return
343 }
344}
345
dbainbri4d3a0dc2020-12-02 00:33:42 +0000346func (oFsm *lockStateFsm) performUniPortAdminSet(ctx context.Context) {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000347 var omciAdminState uint8 = 1 //default locked
Himani Chawla4d908332020-08-31 12:30:20 +0530348 if !oFsm.adminState {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000349 omciAdminState = 0
350 }
Holger Hildebrandt2fb70892020-10-28 11:53:18 +0000351 //set PPTPEthUni or VEIP AdminState
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000352 requestedAttributes := me.AttributeValueMap{"AdministrativeState": omciAdminState}
353
354 for uniNo, uniPort := range oFsm.pOmciCC.pBaseDeviceHandler.uniEntityMap {
mpagenko8b5fdd22020-12-17 17:58:32 +0000355 // only unlock the UniPort in case it is defined for usage (R2.6 limit only one port),
356 // compare also limitation for logical voltha port in dh.enableUniPortStateUpdate()
357 if (omciAdminState == 1) || (1<<uniPort.uniID)&activeUniPortStateUpdateMask == (1<<uniPort.uniID) {
358 var meInstance *me.ManagedEntity
359 if uniPort.portType == uniPPTP {
360 logger.Debugw(ctx, "Setting PPTP admin state", log.Fields{
361 "device-id": oFsm.deviceID, "for PortNo": uniNo, "state (0-unlock)": omciAdminState})
Girish Gowdra0b235842021-03-09 13:06:46 -0800362 meInstance = oFsm.pOmciCC.sendSetPptpEthUniLS(log.WithSpanFromContext(context.TODO(), ctx), uniPort.entityID, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
mpagenko8b5fdd22020-12-17 17:58:32 +0000363 true, requestedAttributes, oFsm.pAdaptFsm.commChan)
364 oFsm.pLastTxMeInstance = meInstance
365 } else if uniPort.portType == uniVEIP {
366 logger.Debugw(ctx, "Setting VEIP admin state", log.Fields{
367 "device-id": oFsm.deviceID, "for PortNo": uniNo, "state (0-unlock)": omciAdminState})
Girish Gowdra0b235842021-03-09 13:06:46 -0800368 meInstance = oFsm.pOmciCC.sendSetVeipLS(log.WithSpanFromContext(context.TODO(), ctx), uniPort.entityID, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
mpagenko8b5fdd22020-12-17 17:58:32 +0000369 true, requestedAttributes, oFsm.pAdaptFsm.commChan)
370 oFsm.pLastTxMeInstance = meInstance
371 } else {
372 logger.Warnw(ctx, "Unsupported UniTP type - skip",
373 log.Fields{"device-id": oFsm.deviceID, "Port": uniNo})
374 continue
375 }
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000376
mpagenko8b5fdd22020-12-17 17:58:32 +0000377 //verify response
378 err := oFsm.waitforOmciResponse(ctx, meInstance)
379 if err != nil {
380 logger.Errorw(ctx, "UniTP Admin State set failed, aborting LockState set!",
381 log.Fields{"device-id": oFsm.deviceID, "Port": uniNo})
382 _ = oFsm.pAdaptFsm.pFsm.Event(uniEvReset)
383 return
384 }
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000385 }
386 } //for all UNI ports
387 // if Config has been done for all UNI related instances let the FSM proceed
388 // while we did not check here, if there is some port at all - !?
mpagenko8b5fdd22020-12-17 17:58:32 +0000389 logger.Infow(ctx, "UniTP adminState loop finished", log.Fields{"device-id": oFsm.deviceID})
Himani Chawla4d908332020-08-31 12:30:20 +0530390 _ = oFsm.pAdaptFsm.pFsm.Event(uniEvRxUnisResp)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000391}
392
dbainbri4d3a0dc2020-12-02 00:33:42 +0000393func (oFsm *lockStateFsm) waitforOmciResponse(ctx context.Context, apMeInstance *me.ManagedEntity) error {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000394 select {
Himani Chawla4d908332020-08-31 12:30:20 +0530395 // maybe be also some outside cancel (but no context modeled for the moment ...)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000396 // case <-ctx.Done():
dbainbri4d3a0dc2020-12-02 00:33:42 +0000397 // logger.Infow(ctx,"LockState-bridge-init message reception canceled", log.Fields{"for device-id": oFsm.deviceID})
mpagenko3af1f032020-06-10 08:53:41 +0000398 case <-time.After(30 * time.Second): //3s was detected to be to less in 8*8 bbsim test with debug Info/Debug
dbainbri4d3a0dc2020-12-02 00:33:42 +0000399 logger.Warnw(ctx, "LockStateFSM uni-set timeout", log.Fields{"for device-id": oFsm.deviceID})
mpagenko01e726e2020-10-23 09:45:29 +0000400 return fmt.Errorf("lockStateFsm uni-set timeout for device-id %s", oFsm.deviceID)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000401 case success := <-oFsm.omciLockResponseReceived:
Himani Chawla4d908332020-08-31 12:30:20 +0530402 if success {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000403 logger.Debug(ctx, "LockStateFSM uni-set response received")
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000404 return nil
405 }
406 // should not happen so far
dbainbri4d3a0dc2020-12-02 00:33:42 +0000407 logger.Warnw(ctx, "LockStateFSM uni-set response error", log.Fields{"for device-id": oFsm.deviceID})
mpagenko01e726e2020-10-23 09:45:29 +0000408 return fmt.Errorf("lockStateFsm uni-set responseError for device-id %s", oFsm.deviceID)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000409 }
410}