blob: 246bd9498e4a8bde70323cb5d11fa4211d5ef558 [file] [log] [blame]
mpagenkoaf801632020-07-03 10:00:42 +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"
Girish Gowdra50e56422021-06-01 16:46:04 -070023 "github.com/opencord/voltha-protos/v4/go/tech_profile"
ozgecanetsia4b232302020-11-11 10:58:10 +030024 "strconv"
mpagenko3dbcdd22020-07-22 07:38:45 +000025 "strings"
mpagenkoaf801632020-07-03 10:00:42 +000026 "sync"
27
Girish Gowdra50e56422021-06-01 16:46:04 -070028 "github.com/opencord/voltha-lib-go/v5/pkg/log"
mpagenkoaf801632020-07-03 10:00:42 +000029)
30
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +000031//definitions for TechProfileProcessing - copied from OltAdapter:openolt_flowmgr.go
32// could perhaps be defined more globally
33const (
Himani Chawla6d2ae152020-09-02 13:11:20 +053034 // binaryStringPrefix is binary string prefix
35 binaryStringPrefix = "0b"
36 // binaryBit1 is binary bit 1 expressed as a character
37 //binaryBit1 = '1'
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +000038)
mpagenkoaf801632020-07-03 10:00:42 +000039
40type resourceEntry int
41
42const (
43 cResourceGemPort resourceEntry = 1
44 cResourceTcont resourceEntry = 2
45)
46
mpagenko3dbcdd22020-07-22 07:38:45 +000047type tTechProfileIndication struct {
mpagenkodff5dda2020-08-28 11:52:01 +000048 techProfileType string
Girish Gowdra041dcb32020-11-16 16:54:30 -080049 techProfileID uint8
mpagenkodff5dda2020-08-28 11:52:01 +000050 techProfileConfigDone bool
mpagenko2418ab02020-11-12 12:58:06 +000051 techProfileToDelete bool
mpagenko3dbcdd22020-07-22 07:38:45 +000052}
53
54type tcontParamStruct struct {
55 allocID uint16
56 schedPolicy uint8
57}
58type gemPortParamStruct struct {
Himani Chawla4d908332020-08-31 12:30:20 +053059 //ponOmciCC bool
mpagenko3dbcdd22020-07-22 07:38:45 +000060 gemPortID uint16
61 direction uint8
62 gemPortEncState uint8
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +000063 prioQueueIndex uint8
64 pbitString string
mpagenko3dbcdd22020-07-22 07:38:45 +000065 discardPolicy string
Himani Chawla4d908332020-08-31 12:30:20 +053066 //could also be a queue specific parameter, not used that way here
67 //maxQueueSize uint16
mpagenko3dbcdd22020-07-22 07:38:45 +000068 queueSchedPolicy string
69 queueWeight uint8
Himani Chawla1c136902020-12-10 16:30:59 +053070 removeGemID uint16
ozgecanetsia4b232302020-11-11 10:58:10 +030071 isMulticast bool
72 //TODO check if this has any value/difference from gemPortId
73 multicastGemPortID uint16
74 staticACL string
75 dynamicACL string
mpagenko3dbcdd22020-07-22 07:38:45 +000076}
77
78//refers to one tcont and its properties and all assigned GemPorts and their properties
79type tcontGemList struct {
80 tcontParams tcontParamStruct
81 mapGemPortParams map[uint16]*gemPortParamStruct
82}
83
Girish Gowdra041dcb32020-11-16 16:54:30 -080084// refers a unique combination of uniID and tpID for a given ONU.
85type uniTP struct {
86 uniID uint8
87 tpID uint8
88}
mpagenko3dbcdd22020-07-22 07:38:45 +000089
Himani Chawla6d2ae152020-09-02 13:11:20 +053090//onuUniTechProf structure holds information about the TechProfiles attached to Uni Ports of the ONU
91type onuUniTechProf struct {
Himani Chawla6d2ae152020-09-02 13:11:20 +053092 baseDeviceHandler *deviceHandler
mpagenko01e726e2020-10-23 09:45:29 +000093 deviceID string
mpagenkodff5dda2020-08-28 11:52:01 +000094 tpProcMutex sync.RWMutex
mpagenkodff5dda2020-08-28 11:52:01 +000095 chTpConfigProcessingStep chan uint8
Girish Gowdra041dcb32020-11-16 16:54:30 -080096 mapUniTpIndication map[uniTP]*tTechProfileIndication //use pointer values to ease assignments to the map
97 mapPonAniConfig map[uniTP]*tcontGemList //per UNI: use pointer values to ease assignments to the map
98 pAniConfigFsm map[uniTP]*uniPonAniConfigFsm
99 procResult map[uniTP]error //error indication of processing
Girish Gowdra5c5aaf42021-02-17 19:40:50 -0800100 mutexTPState sync.RWMutex
Girish Gowdra041dcb32020-11-16 16:54:30 -0800101 tpProfileExists map[uniTP]bool
mpagenko73143992021-04-09 15:17:10 +0000102 tpProfileResetting map[uniTP]bool
mpagenko8b07c1b2020-11-26 10:36:31 +0000103 mapRemoveGemEntry map[uniTP]*gemPortParamStruct //per UNI: pointer to GemEntry to be removed
mpagenkoaf801632020-07-03 10:00:42 +0000104}
105
ozgecanetsia72e1c9f2021-05-26 17:26:29 +0300106func (onuTP *onuUniTechProf) multicastConfiguredForOtherUniTps(ctx context.Context, uniTpKey uniTP) bool {
107 for _, aniFsm := range onuTP.pAniConfigFsm {
108 if aniFsm.uniTpKey.uniID == uniTpKey.uniID && aniFsm.uniTpKey.tpID == uniTpKey.tpID {
109 continue
110 }
111 if aniFsm.hasMulticastGem(ctx) {
112 return true
113 }
114 }
115 return false
116}
117
Himani Chawla6d2ae152020-09-02 13:11:20 +0530118//newOnuUniTechProf returns the instance of a OnuUniTechProf
mpagenkoaf801632020-07-03 10:00:42 +0000119//(one instance per ONU/deviceHandler for all possible UNI's)
mpagenko01e726e2020-10-23 09:45:29 +0000120func newOnuUniTechProf(ctx context.Context, aDeviceHandler *deviceHandler) *onuUniTechProf {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000121 logger.Debugw(ctx, "init-OnuUniTechProf", log.Fields{"device-id": aDeviceHandler.deviceID})
Himani Chawla6d2ae152020-09-02 13:11:20 +0530122 var onuTP onuUniTechProf
mpagenkoaf801632020-07-03 10:00:42 +0000123 onuTP.baseDeviceHandler = aDeviceHandler
mpagenko01e726e2020-10-23 09:45:29 +0000124 onuTP.deviceID = aDeviceHandler.deviceID
mpagenkodff5dda2020-08-28 11:52:01 +0000125 onuTP.chTpConfigProcessingStep = make(chan uint8)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800126 onuTP.mapUniTpIndication = make(map[uniTP]*tTechProfileIndication)
127 onuTP.mapPonAniConfig = make(map[uniTP]*tcontGemList)
128 onuTP.procResult = make(map[uniTP]error)
129 onuTP.tpProfileExists = make(map[uniTP]bool)
mpagenko73143992021-04-09 15:17:10 +0000130 onuTP.tpProfileResetting = make(map[uniTP]bool)
mpagenko8b07c1b2020-11-26 10:36:31 +0000131 onuTP.mapRemoveGemEntry = make(map[uniTP]*gemPortParamStruct)
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000132
mpagenkoaf801632020-07-03 10:00:42 +0000133 return &onuTP
134}
135
136// lockTpProcMutex locks OnuUniTechProf processing mutex
Himani Chawla6d2ae152020-09-02 13:11:20 +0530137func (onuTP *onuUniTechProf) lockTpProcMutex() {
mpagenkoaf801632020-07-03 10:00:42 +0000138 onuTP.tpProcMutex.Lock()
139}
140
141// unlockTpProcMutex unlocks OnuUniTechProf processing mutex
Himani Chawla6d2ae152020-09-02 13:11:20 +0530142func (onuTP *onuUniTechProf) unlockTpProcMutex() {
mpagenkoaf801632020-07-03 10:00:42 +0000143 onuTP.tpProcMutex.Unlock()
144}
145
Holger Hildebrandt47555e72020-09-21 11:07:24 +0000146// resetTpProcessingErrorIndication resets the internal error indication
mpagenko1cc3cb42020-07-27 15:24:38 +0000147// need to be called before evaluation of any subsequent processing (given by waitForTpCompletion())
Girish Gowdra041dcb32020-11-16 16:54:30 -0800148func (onuTP *onuUniTechProf) resetTpProcessingErrorIndication(aUniID uint8, aTpID uint8) {
mpagenko73143992021-04-09 15:17:10 +0000149 onuTP.mutexTPState.Lock()
150 defer onuTP.mutexTPState.Unlock()
Girish Gowdra041dcb32020-11-16 16:54:30 -0800151 onuTP.procResult[uniTP{uniID: aUniID, tpID: aTpID}] = nil
mpagenko1cc3cb42020-07-27 15:24:38 +0000152}
153
Girish Gowdra041dcb32020-11-16 16:54:30 -0800154func (onuTP *onuUniTechProf) getTpProcessingErrorIndication(aUniID uint8, aTpID uint8) error {
mpagenko73143992021-04-09 15:17:10 +0000155 onuTP.mutexTPState.RLock()
156 defer onuTP.mutexTPState.RUnlock()
Girish Gowdra041dcb32020-11-16 16:54:30 -0800157 return onuTP.procResult[uniTP{uniID: aUniID, tpID: aTpID}]
mpagenko3dbcdd22020-07-22 07:38:45 +0000158}
159
mpagenko8b07c1b2020-11-26 10:36:31 +0000160// configureUniTp checks existing tp resources to configure and starts the corresponding OMCI configuation of the UNI port
mpagenko3dbcdd22020-07-22 07:38:45 +0000161// all possibly blocking processing must be run in background to allow for deadline supervision!
162// but take care on sequential background processing when needed (logical dependencies)
Himani Chawla4d908332020-08-31 12:30:20 +0530163// use waitForTimeoutOrCompletion(ctx, chTpConfigProcessingStep, processingStep) for internal synchronization
Himani Chawla6d2ae152020-09-02 13:11:20 +0530164func (onuTP *onuUniTechProf) configureUniTp(ctx context.Context,
Girish Gowdra50e56422021-06-01 16:46:04 -0700165 aUniID uint8, aPathString string, tpInst tech_profile.TechProfileInstance, wg *sync.WaitGroup) {
mpagenko3dbcdd22020-07-22 07:38:45 +0000166 defer wg.Done() //always decrement the waitGroup on return
dbainbri4d3a0dc2020-12-02 00:33:42 +0000167 logger.Debugw(ctx, "configure the Uni according to TpPath", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +0000168 "device-id": onuTP.deviceID, "uni-id": aUniID, "path": aPathString})
Girish Gowdra041dcb32020-11-16 16:54:30 -0800169 tpID, err := GetTpIDFromTpPath(aPathString)
170 uniTpKey := uniTP{uniID: aUniID, tpID: tpID}
171 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000172 logger.Errorw(ctx, "error-extracting-tp-id-from-tp-path", log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID, "path": aPathString})
Girish Gowdra041dcb32020-11-16 16:54:30 -0800173 return
174 }
mpagenkoaf801632020-07-03 10:00:42 +0000175
mpagenko3dbcdd22020-07-22 07:38:45 +0000176 //ensure that the given uniID is available (configured) in the UniPort class (used for OMCI entities)
Himani Chawla6d2ae152020-09-02 13:11:20 +0530177 var pCurrentUniPort *onuUniPort
mpagenko3dbcdd22020-07-22 07:38:45 +0000178 for _, uniPort := range onuTP.baseDeviceHandler.uniEntityMap {
179 // only if this port is validated for operState transfer
Girish Gowdra041dcb32020-11-16 16:54:30 -0800180 if uniPort.uniID == aUniID {
mpagenko3dbcdd22020-07-22 07:38:45 +0000181 pCurrentUniPort = uniPort
182 break //found - end search loop
183 }
184 }
185 if pCurrentUniPort == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000186 logger.Errorw(ctx, "TechProfile configuration aborted: requested uniID not found in PortDB",
mpagenko73143992021-04-09 15:17:10 +0000187 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": uniTpKey.tpID})
188 onuTP.mutexTPState.Lock()
189 defer onuTP.mutexTPState.Unlock()
Girish Gowdra041dcb32020-11-16 16:54:30 -0800190 onuTP.procResult[uniTpKey] = fmt.Errorf("techProfile config aborted: requested uniID not found %d on %s",
Andrea Campanella6515c582020-10-05 11:25:00 +0200191 aUniID, onuTP.deviceID)
mpagenko3dbcdd22020-07-22 07:38:45 +0000192 return
193 }
mpagenkoaf801632020-07-03 10:00:42 +0000194
mpagenko73143992021-04-09 15:17:10 +0000195 if onuTP.getProfileResetting(uniTpKey) {
196 logger.Debugw(ctx, "aborting TP configuration, reset requested in parallel", log.Fields{
197 "device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": uniTpKey.tpID})
198 onuTP.mutexTPState.Lock()
199 defer onuTP.mutexTPState.Unlock()
200 onuTP.procResult[uniTpKey] = fmt.Errorf(
201 "techProfile config aborted - reset requested in parallel - for uniID %d on %s",
202 aUniID, onuTP.deviceID)
203 return
204 }
mpagenkodff5dda2020-08-28 11:52:01 +0000205 var processingStep uint8 = 1 // used to synchronize the different processing steps with chTpConfigProcessingStep
mpagenkoaf801632020-07-03 10:00:42 +0000206
mpagenko3dbcdd22020-07-22 07:38:45 +0000207 //according to updateOnuUniTpPath() logic the assumption here is, that this configuration is only called
208 // in case the KVPath has changed for the given UNI,
209 // as T-Cont and Gem-Id's are dependent on TechProfile-Id this means, that possibly previously existing
210 // (ANI) configuration of this port has to be removed first
211 // (moreover in this case a possibly existing flow configuration is also not valid anymore and needs clean-up as well)
212 // existence of configuration can be detected based on tp stored TCONT's
Andrea Campanella6515c582020-10-05 11:25:00 +0200213 //TODO:
mpagenko3dbcdd22020-07-22 07:38:45 +0000214 /* if tcontMap not empty {
215 go onuTP.deleteAniSideConfig(ctx, aUniID, processingStep)
mpagenkodff5dda2020-08-28 11:52:01 +0000216 if !onuTP.waitForTimeoutOrCompletion(ctx, chTpConfigProcessingStep, processingStep) {
mpagenko3dbcdd22020-07-22 07:38:45 +0000217 //timeout or error detected
218 return
219 }
220 clear tcontMap
221 }
222
223 processingStep++
224 */
Girish Gowdra50e56422021-06-01 16:46:04 -0700225 go onuTP.readAniSideConfigFromTechProfile(ctx, aUniID, tpID, aPathString, tpInst, processingStep)
mpagenkodff5dda2020-08-28 11:52:01 +0000226 if !onuTP.waitForTimeoutOrCompletion(ctx, onuTP.chTpConfigProcessingStep, processingStep) {
mpagenko3dbcdd22020-07-22 07:38:45 +0000227 //timeout or error detected
mpagenko73143992021-04-09 15:17:10 +0000228 onuTP.mutexTPState.RLock()
229 defer onuTP.mutexTPState.RUnlock()
Girish Gowdra041dcb32020-11-16 16:54:30 -0800230 if onuTP.tpProfileExists[uniTpKey] {
mpagenko01e726e2020-10-23 09:45:29 +0000231 //ignore the internal error in case the new profile is already configured
232 // and abort the processing here
233 return
234 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000235 logger.Errorw(ctx, "tech-profile related configuration aborted on read",
mpagenko01e726e2020-10-23 09:45:29 +0000236 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID})
mpagenko73143992021-04-09 15:17:10 +0000237 onuTP.mutexTPState.Lock()
238 defer onuTP.mutexTPState.Unlock()
Girish Gowdra041dcb32020-11-16 16:54:30 -0800239 onuTP.procResult[uniTpKey] = fmt.Errorf("techProfile config aborted: tech-profile read issue for %d on %s",
Andrea Campanella6515c582020-10-05 11:25:00 +0200240 aUniID, onuTP.deviceID)
mpagenko3dbcdd22020-07-22 07:38:45 +0000241 return
242 }
mpagenko73143992021-04-09 15:17:10 +0000243 if onuTP.getProfileResetting(uniTpKey) {
244 logger.Debugw(ctx, "aborting TP configuration, reset requested in parallel", log.Fields{
245 "device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": uniTpKey.tpID})
246 onuTP.mutexTPState.Lock()
247 defer onuTP.mutexTPState.Unlock()
248 onuTP.procResult[uniTpKey] = fmt.Errorf(
249 "techProfile config aborted - reset requested in parallel - for uniID %d on %s",
250 aUniID, onuTP.deviceID)
251 return
252 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000253 processingStep++
Girish Gowdra041dcb32020-11-16 16:54:30 -0800254
mpagenko73143992021-04-09 15:17:10 +0000255 //ensure read protection for access to mapPonAniConfig
256 onuTP.mutexTPState.RLock()
Girish Gowdra041dcb32020-11-16 16:54:30 -0800257 valuePA, existPA := onuTP.mapPonAniConfig[uniTpKey]
mpagenko73143992021-04-09 15:17:10 +0000258 onuTP.mutexTPState.RUnlock()
Girish Gowdra041dcb32020-11-16 16:54:30 -0800259 if existPA {
260 if valuePA != nil {
mpagenko3dbcdd22020-07-22 07:38:45 +0000261 //Config data for this uni and and at least TCont Index 0 exist
mpagenko8b07c1b2020-11-26 10:36:31 +0000262 if err := onuTP.setAniSideConfigFromTechProfile(ctx, aUniID, tpID, pCurrentUniPort, processingStep); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000263 logger.Errorw(ctx, "tech-profile related FSM could not be started",
mpagenko8b07c1b2020-11-26 10:36:31 +0000264 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID})
mpagenko73143992021-04-09 15:17:10 +0000265 onuTP.mutexTPState.Lock()
266 defer onuTP.mutexTPState.Unlock()
mpagenko8b07c1b2020-11-26 10:36:31 +0000267 onuTP.procResult[uniTpKey] = err
268 return
269 }
mpagenkodff5dda2020-08-28 11:52:01 +0000270 if !onuTP.waitForTimeoutOrCompletion(ctx, onuTP.chTpConfigProcessingStep, processingStep) {
mpagenko73143992021-04-09 15:17:10 +0000271 //timeout or error detected (included wanted cancellation after e.g. disable device (FsmReset))
272 logger.Warnw(ctx, "tech-profile related configuration aborted on set",
mpagenko01e726e2020-10-23 09:45:29 +0000273 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID})
Girish Gowdra041dcb32020-11-16 16:54:30 -0800274
mpagenko73143992021-04-09 15:17:10 +0000275 onuTP.mutexTPState.Lock()
276 defer onuTP.mutexTPState.Unlock()
Girish Gowdra041dcb32020-11-16 16:54:30 -0800277 onuTP.procResult[uniTpKey] = fmt.Errorf("techProfile config aborted: Omci AniSideConfig failed %d on %s",
Andrea Campanella6515c582020-10-05 11:25:00 +0200278 aUniID, onuTP.deviceID)
Himani Chawla4d908332020-08-31 12:30:20 +0530279 //this issue here means that the AniConfigFsm has not finished successfully
mpagenko3dbcdd22020-07-22 07:38:45 +0000280 //which requires to reset it to allow for new usage, e.g. also on a different UNI
281 //(without that it would be reset on device down indication latest)
mpagenko73143992021-04-09 15:17:10 +0000282 if _, ok := onuTP.pAniConfigFsm[uniTpKey]; ok {
283 _ = onuTP.pAniConfigFsm[uniTpKey].pAdaptFsm.pFsm.Event(aniEvReset)
284 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000285 return
mpagenkoaf801632020-07-03 10:00:42 +0000286 }
287 } else {
mpagenko3dbcdd22020-07-22 07:38:45 +0000288 // strange: UNI entry exists, but no ANI data, maybe such situation should be cleared up (if observed)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000289 logger.Errorw(ctx, "no Tcont/Gem data for this UNI found - abort", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +0000290 "device-id": onuTP.deviceID, "uni-id": aUniID})
mpagenko73143992021-04-09 15:17:10 +0000291 onuTP.mutexTPState.Lock()
292 defer onuTP.mutexTPState.Unlock()
Girish Gowdra041dcb32020-11-16 16:54:30 -0800293 onuTP.procResult[uniTpKey] = fmt.Errorf("techProfile config aborted: no Tcont/Gem data found for this UNI %d on %s",
Andrea Campanella6515c582020-10-05 11:25:00 +0200294 aUniID, onuTP.deviceID)
mpagenko1cc3cb42020-07-27 15:24:38 +0000295 return
mpagenkoaf801632020-07-03 10:00:42 +0000296 }
297 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000298 logger.Errorw(ctx, "no PonAni data for this UNI found - abort", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +0000299 "device-id": onuTP.deviceID, "uni-id": aUniID})
Girish Gowdra041dcb32020-11-16 16:54:30 -0800300
mpagenko73143992021-04-09 15:17:10 +0000301 onuTP.mutexTPState.Lock()
302 defer onuTP.mutexTPState.Unlock()
Girish Gowdra041dcb32020-11-16 16:54:30 -0800303 onuTP.procResult[uniTpKey] = fmt.Errorf("techProfile config aborted: no AniSide data found for this UNI %d on %s",
Andrea Campanella6515c582020-10-05 11:25:00 +0200304 aUniID, onuTP.deviceID)
mpagenko1cc3cb42020-07-27 15:24:38 +0000305 return
mpagenkoaf801632020-07-03 10:00:42 +0000306 }
307}
308
mpagenko3dbcdd22020-07-22 07:38:45 +0000309/* internal methods *********************/
ozgecanetsia4b232302020-11-11 10:58:10 +0300310// nolint: gocyclo
Himani Chawla6d2ae152020-09-02 13:11:20 +0530311func (onuTP *onuUniTechProf) readAniSideConfigFromTechProfile(
Girish Gowdra50e56422021-06-01 16:46:04 -0700312 ctx context.Context, aUniID uint8, aTpID uint8, aPathString string, tpInst tech_profile.TechProfileInstance, aProcessingStep uint8) {
313 var err error
mpagenko3dbcdd22020-07-22 07:38:45 +0000314 //store profile type and identifier for later usage within the OMCI identifier and possibly ME setup
315 //pathstring is defined to be in the form of <ProfType>/<profID>/<Interface/../Identifier>
316 subStringSlice := strings.Split(aPathString, "/")
317 if len(subStringSlice) <= 2 {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000318 logger.Errorw(ctx, "invalid path name format",
mpagenko3dbcdd22020-07-22 07:38:45 +0000319 log.Fields{"path": aPathString, "device-id": onuTP.deviceID})
mpagenkodff5dda2020-08-28 11:52:01 +0000320 onuTP.chTpConfigProcessingStep <- 0 //error indication
mpagenko3dbcdd22020-07-22 07:38:45 +0000321 return
322 }
323
mpagenko73143992021-04-09 15:17:10 +0000324 //ensure write protection for access to used maps
325 onuTP.mutexTPState.Lock()
326 defer onuTP.mutexTPState.Unlock()
327
328 uniTPKey := uniTP{uniID: aUniID, tpID: aTpID}
329 onuTP.tpProfileExists[uniTP{uniID: aUniID, tpID: aTpID}] = false
330
mpagenko3dbcdd22020-07-22 07:38:45 +0000331 //at this point it is assumed that a new TechProfile is assigned to the UNI
mpagenko01e726e2020-10-23 09:45:29 +0000332 //expectation is that no TPIndication entry exists here, if exists and with the same TPId
333 // then we throw a warning, set an internal error and abort with error,
334 // which is later re-defined to success response to OLT adapter
335 // if TPId has changed, current data is removed (note that the ONU config state may be
336 // ambivalent in such a case)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800337 if _, existTP := onuTP.mapUniTpIndication[uniTPKey]; existTP {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000338 logger.Warnw(ctx, "Some active profile entry at reading new TechProfile",
mpagenko3dbcdd22020-07-22 07:38:45 +0000339 log.Fields{"path": aPathString, "device-id": onuTP.deviceID,
Girish Gowdra041dcb32020-11-16 16:54:30 -0800340 "uni-id": aUniID, "wrongProfile": onuTP.mapUniTpIndication[uniTPKey].techProfileID})
341 if aTpID == onuTP.mapUniTpIndication[uniTPKey].techProfileID {
mpagenko01e726e2020-10-23 09:45:29 +0000342 // ProfId not changed - assume profile to be still the same
343 // anyway this should not appear after full support of profile (Gem/TCont) removal
dbainbri4d3a0dc2020-12-02 00:33:42 +0000344 logger.Warnw(ctx, "New TechProfile already exists - aborting configuration",
mpagenko01e726e2020-10-23 09:45:29 +0000345 log.Fields{"device-id": onuTP.deviceID})
Girish Gowdra041dcb32020-11-16 16:54:30 -0800346 onuTP.tpProfileExists[uniTPKey] = true
mpagenko01e726e2020-10-23 09:45:29 +0000347 onuTP.chTpConfigProcessingStep <- 0 //error indication
348 return
349 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000350 //delete on the mapUniTpIndication map not needed, just overwritten later
351 //delete on the PonAniConfig map should be safe, even if not existing
Girish Gowdra041dcb32020-11-16 16:54:30 -0800352 delete(onuTP.mapPonAniConfig, uniTPKey)
mpagenko3dbcdd22020-07-22 07:38:45 +0000353 } else {
354 // this is normal processing
Girish Gowdra041dcb32020-11-16 16:54:30 -0800355 onuTP.mapUniTpIndication[uniTPKey] = &tTechProfileIndication{} //need to assign some (empty) struct memory first!
mpagenko3dbcdd22020-07-22 07:38:45 +0000356 }
357
Girish Gowdra041dcb32020-11-16 16:54:30 -0800358 onuTP.mapUniTpIndication[uniTPKey].techProfileType = subStringSlice[0]
mpagenko3dbcdd22020-07-22 07:38:45 +0000359 //note the limitation on ID range (probably even more limited) - based on usage within OMCI EntityID
Girish Gowdra041dcb32020-11-16 16:54:30 -0800360 onuTP.mapUniTpIndication[uniTPKey].techProfileID = aTpID
361 onuTP.mapUniTpIndication[uniTPKey].techProfileConfigDone = false
362 onuTP.mapUniTpIndication[uniTPKey].techProfileToDelete = false
dbainbri4d3a0dc2020-12-02 00:33:42 +0000363 logger.Debugw(ctx, "tech-profile path indications",
mpagenko01e726e2020-10-23 09:45:29 +0000364 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID,
Girish Gowdra041dcb32020-11-16 16:54:30 -0800365 "profType": onuTP.mapUniTpIndication[uniTPKey].techProfileType,
366 "profID": onuTP.mapUniTpIndication[uniTPKey].techProfileID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000367
mpagenko01e726e2020-10-23 09:45:29 +0000368 //default start with 1Tcont profile, later perhaps extend to MultiTcontMultiGem
mpagenko3dbcdd22020-07-22 07:38:45 +0000369 localMapGemPortParams := make(map[uint16]*gemPortParamStruct)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800370 onuTP.mapPonAniConfig[uniTPKey] = &tcontGemList{tcontParamStruct{}, localMapGemPortParams}
mpagenko3dbcdd22020-07-22 07:38:45 +0000371
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000372 //note: the code is currently restricted to one TCcont per Onu (index [0])
mpagenko3dbcdd22020-07-22 07:38:45 +0000373 //get the relevant values from the profile and store to mapPonAniConfig
Girish Gowdra50e56422021-06-01 16:46:04 -0700374 onuTP.mapPonAniConfig[uniTPKey].tcontParams.allocID = uint16(tpInst.UsScheduler.AllocId)
Himani Chawla4d908332020-08-31 12:30:20 +0530375 //maybe tCont scheduling not (yet) needed - just to basically have it for future
mpagenko3dbcdd22020-07-22 07:38:45 +0000376 // (would only be relevant in case of ONU-2G QOS configuration flexibility)
Girish Gowdra50e56422021-06-01 16:46:04 -0700377 if tpInst.UsScheduler.QSchedPolicy == tech_profile.SchedulingPolicy_StrictPriority {
Girish Gowdra041dcb32020-11-16 16:54:30 -0800378 onuTP.mapPonAniConfig[uniTPKey].tcontParams.schedPolicy = 1 //for the moment fixed value acc. G.988 //TODO: defines!
mpagenko3dbcdd22020-07-22 07:38:45 +0000379 } else {
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000380 //default profile defines "Hybrid" - which probably comes down to WRR with some weigthts for SP
Girish Gowdra041dcb32020-11-16 16:54:30 -0800381 onuTP.mapPonAniConfig[uniTPKey].tcontParams.schedPolicy = 2 //for G.988 WRR
mpagenko3dbcdd22020-07-22 07:38:45 +0000382 }
mpagenko1cc3cb42020-07-27 15:24:38 +0000383 loNumGemPorts := tpInst.NumGemPorts
384 loGemPortRead := false
mpagenko3dbcdd22020-07-22 07:38:45 +0000385 for pos, content := range tpInst.UpstreamGemPortAttributeList {
mpagenko1cc3cb42020-07-27 15:24:38 +0000386 if uint32(pos) == loNumGemPorts {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000387 logger.Debugw(ctx, "PonAniConfig abort GemPortList - GemList exceeds set NumberOfGemPorts",
mpagenko1cc3cb42020-07-27 15:24:38 +0000388 log.Fields{"device-id": onuTP.deviceID, "index": pos, "NumGem": loNumGemPorts})
mpagenko3dbcdd22020-07-22 07:38:45 +0000389 break
390 }
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000391 if pos == 0 {
392 //at least one upstream GemPort should always exist (else traffic profile makes no sense)
393 loGemPortRead = true
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000394 }
Himani Chawla1c136902020-12-10 16:30:59 +0530395 //for all GemPorts we need to extend the mapGemPortParams
Girish Gowdra50e56422021-06-01 16:46:04 -0700396 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[uint16(content.GemportId)] = &gemPortParamStruct{}
Himani Chawla1c136902020-12-10 16:30:59 +0530397
Girish Gowdra50e56422021-06-01 16:46:04 -0700398 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[uint16(content.GemportId)].gemPortID =
399 uint16(content.GemportId)
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000400 //direction can be correlated later with Downstream list,
401 // for now just assume bidirectional (upstream never exists alone)
Girish Gowdra50e56422021-06-01 16:46:04 -0700402 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[uint16(content.GemportId)].direction = 3 //as defined in G.988
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000403 // expected Prio-Queue values 0..7 with 7 for highest PrioQueue, QueueIndex=Prio = 0..7
Girish Gowdra50e56422021-06-01 16:46:04 -0700404 if content.PriorityQ > 7 {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000405 logger.Errorw(ctx, "PonAniConfig reject on GemPortList - PrioQueue value invalid",
Girish Gowdra50e56422021-06-01 16:46:04 -0700406 log.Fields{"device-id": onuTP.deviceID, "index": pos, "PrioQueue": content.PriorityQ})
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000407 //remove PonAniConfig as done so far, delete map should be safe, even if not existing
Girish Gowdra041dcb32020-11-16 16:54:30 -0800408 delete(onuTP.mapPonAniConfig, uniTPKey)
mpagenkodff5dda2020-08-28 11:52:01 +0000409 onuTP.chTpConfigProcessingStep <- 0 //error indication
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000410 return
411 }
Girish Gowdra50e56422021-06-01 16:46:04 -0700412 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[uint16(content.GemportId)].prioQueueIndex =
413 uint8(content.PriorityQ)
414 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[uint16(content.GemportId)].pbitString =
Himani Chawla6d2ae152020-09-02 13:11:20 +0530415 strings.TrimPrefix(content.PbitMap, binaryStringPrefix)
mpagenko3dbcdd22020-07-22 07:38:45 +0000416 if content.AesEncryption == "True" {
Girish Gowdra50e56422021-06-01 16:46:04 -0700417 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[uint16(content.GemportId)].gemPortEncState = 1
mpagenko3dbcdd22020-07-22 07:38:45 +0000418 } else {
Girish Gowdra50e56422021-06-01 16:46:04 -0700419 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[uint16(content.GemportId)].gemPortEncState = 0
mpagenko3dbcdd22020-07-22 07:38:45 +0000420 }
Girish Gowdra50e56422021-06-01 16:46:04 -0700421 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[uint16(content.GemportId)].discardPolicy =
422 content.DiscardPolicy.String()
423 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[uint16(content.GemportId)].queueSchedPolicy =
424 content.SchedulingPolicy.String()
mpagenko3dbcdd22020-07-22 07:38:45 +0000425 //'GemWeight' looks strange in default profile, for now we just copy the weight to first queue
Girish Gowdra50e56422021-06-01 16:46:04 -0700426 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[uint16(content.GemportId)].queueWeight =
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000427 uint8(content.Weight)
mpagenko3dbcdd22020-07-22 07:38:45 +0000428 }
ozgecanetsia4b232302020-11-11 10:58:10 +0300429
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300430 for _, downstreamContent := range tpInst.DownstreamGemPortAttributeList {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000431 logger.Debugw(ctx, "Operating on Downstream Gem Port", log.Fields{"downstream-gem": downstreamContent})
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300432 //Commenting this out due to faliure, needs investigation
433 //if uint32(pos) == loNumGemPorts {
434 // logger.Debugw("PonAniConfig abort GemPortList - GemList exceeds set NumberOfGemPorts",
435 // log.Fields{"device-id": onuTP.deviceID, "index": pos, "NumGem": loNumGemPorts})
436 // break
437 //}
438 isMulticast := false
ozgecanetsia4b232302020-11-11 10:58:10 +0300439 //Flag is defined as string in the TP in voltha-lib-go, parsing it from string
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300440 if downstreamContent.IsMulticast != "" {
441 isMulticast, err = strconv.ParseBool(downstreamContent.IsMulticast)
442 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000443 logger.Errorw(ctx, "multicast-error-config-unknown-flag-in-technology-profile",
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300444 log.Fields{"UniTpKey": uniTPKey, "downstream-gem": downstreamContent, "error": err})
445 continue
446 }
ozgecanetsia4b232302020-11-11 10:58:10 +0300447 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000448 logger.Infow(ctx, "Gem Port is multicast", log.Fields{"isMulticast": isMulticast})
ozgecanetsia4b232302020-11-11 10:58:10 +0300449 if isMulticast {
Girish Gowdra50e56422021-06-01 16:46:04 -0700450 mcastGemID := uint16(downstreamContent.MulticastGemId)
ozgecanetsia4b232302020-11-11 10:58:10 +0300451 _, existing := onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID]
452 if existing {
453 //GEM port was previously configured, avoid setting multicast attributes
dbainbri4d3a0dc2020-12-02 00:33:42 +0000454 logger.Errorw(ctx, "multicast-error-config-existing-gem-port-config", log.Fields{"UniTpKey": uniTPKey,
ozgecanetsia4b232302020-11-11 10:58:10 +0300455 "downstream-gem": downstreamContent, "key": mcastGemID})
456 continue
457 } else {
458 //GEM port is not configured, setting multicast attributes
dbainbri4d3a0dc2020-12-02 00:33:42 +0000459 logger.Infow(ctx, "creating-multicast-gem-port", log.Fields{"uniTpKey": uniTPKey,
ozgecanetsia4b232302020-11-11 10:58:10 +0300460 "gemPortId": mcastGemID, "key": mcastGemID})
461
462 //for all further GemPorts we need to extend the mapGemPortParams
463 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID] = &gemPortParamStruct{}
464
465 //Separate McastGemId is derived from OMCI-lib-go, if not needed first needs to be removed there.
466 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].gemPortID = mcastGemID
467 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].direction = 2 // for ANI to UNI as defined in G.988
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300468
469 if downstreamContent.AesEncryption == "True" {
470 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].gemPortEncState = 1
471 } else {
472 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].gemPortEncState = 0
473 }
474
475 // expected Prio-Queue values 0..7 with 7 for highest PrioQueue, QueueIndex=Prio = 0..7
Girish Gowdra50e56422021-06-01 16:46:04 -0700476 if downstreamContent.PriorityQ > 7 {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000477 logger.Errorw(ctx, "PonAniConfig reject on GemPortList - PrioQueue value invalid",
Girish Gowdra50e56422021-06-01 16:46:04 -0700478 log.Fields{"device-id": onuTP.deviceID, "index": mcastGemID, "PrioQueue": downstreamContent.PriorityQ})
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300479 //remove PonAniConfig as done so far, delete map should be safe, even if not existing
480 delete(onuTP.mapPonAniConfig, uniTPKey)
481 onuTP.chTpConfigProcessingStep <- 0 //error indication
482 return
ozgecanetsia4b232302020-11-11 10:58:10 +0300483 }
484 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].prioQueueIndex =
Girish Gowdra50e56422021-06-01 16:46:04 -0700485 uint8(downstreamContent.PriorityQ)
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300486 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].pbitString =
487 strings.TrimPrefix(downstreamContent.PbitMap, binaryStringPrefix)
488
489 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].discardPolicy =
Girish Gowdra50e56422021-06-01 16:46:04 -0700490 downstreamContent.DiscardPolicy.String()
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300491 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].queueSchedPolicy =
Girish Gowdra50e56422021-06-01 16:46:04 -0700492 downstreamContent.SchedulingPolicy.String()
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300493 //'GemWeight' looks strange in default profile, for now we just copy the weight to first queue
494 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].queueWeight =
495 uint8(downstreamContent.Weight)
496
ozgecanetsia4b232302020-11-11 10:58:10 +0300497 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].isMulticast = isMulticast
498 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].multicastGemPortID =
Girish Gowdra50e56422021-06-01 16:46:04 -0700499 uint16(downstreamContent.MulticastGemId)
500 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].staticACL = downstreamContent.StaticAccessControlList
501 onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams[mcastGemID].dynamicACL = downstreamContent.DynamicAccessControlList
ozgecanetsia4b232302020-11-11 10:58:10 +0300502 }
503 }
504 }
505
Himani Chawla4d908332020-08-31 12:30:20 +0530506 if !loGemPortRead {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000507 logger.Errorw(ctx, "PonAniConfig reject - no GemPort could be read from TechProfile",
mpagenko1cc3cb42020-07-27 15:24:38 +0000508 log.Fields{"path": aPathString, "device-id": onuTP.deviceID})
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000509 //remove PonAniConfig as done so far, delete map should be safe, even if not existing
Girish Gowdra041dcb32020-11-16 16:54:30 -0800510 delete(onuTP.mapPonAniConfig, uniTPKey)
mpagenkodff5dda2020-08-28 11:52:01 +0000511 onuTP.chTpConfigProcessingStep <- 0 //error indication
mpagenko1cc3cb42020-07-27 15:24:38 +0000512 return
513 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000514 //logger does not simply output the given structures, just give some example debug values
dbainbri4d3a0dc2020-12-02 00:33:42 +0000515 logger.Debugw(ctx, "PonAniConfig read from TechProfile", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +0000516 "device-id": onuTP.deviceID, "uni-id": aUniID,
517 "AllocId": onuTP.mapPonAniConfig[uniTPKey].tcontParams.allocID})
Himani Chawla1c136902020-12-10 16:30:59 +0530518 for gemPortID, gemEntry := range onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000519 logger.Debugw(ctx, "PonAniConfig read from TechProfile", log.Fields{
Himani Chawla1c136902020-12-10 16:30:59 +0530520 "GemPort": gemPortID,
Holger Hildebrandt9ca8b132020-08-07 14:45:03 +0000521 "QueueScheduling": gemEntry.queueSchedPolicy})
522 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000523
mpagenkodff5dda2020-08-28 11:52:01 +0000524 onuTP.chTpConfigProcessingStep <- aProcessingStep //done
mpagenko3dbcdd22020-07-22 07:38:45 +0000525}
526
Himani Chawla6d2ae152020-09-02 13:11:20 +0530527func (onuTP *onuUniTechProf) setAniSideConfigFromTechProfile(
mpagenko8b07c1b2020-11-26 10:36:31 +0000528 ctx context.Context, aUniID uint8, aTpID uint8, apCurrentUniPort *onuUniPort, aProcessingStep uint8) error {
mpagenko3dbcdd22020-07-22 07:38:45 +0000529
530 //OMCI transfer of ANI data acc. to mapPonAniConfig
531 // also the FSM's are running in background,
mpagenko8b07c1b2020-11-26 10:36:31 +0000532 // hence we have to make sure they indicate 'success' on chTpConfigProcessingStep with aProcessingStep
Girish Gowdra041dcb32020-11-16 16:54:30 -0800533 uniTPKey := uniTP{uniID: aUniID, tpID: aTpID}
mpagenko3dbcdd22020-07-22 07:38:45 +0000534 if onuTP.pAniConfigFsm == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000535 return onuTP.createAniConfigFsm(ctx, aUniID, aTpID, apCurrentUniPort, OmciAniConfigDone, aProcessingStep)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800536 } else if _, ok := onuTP.pAniConfigFsm[uniTPKey]; !ok {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000537 return onuTP.createAniConfigFsm(ctx, aUniID, aTpID, apCurrentUniPort, OmciAniConfigDone, aProcessingStep)
mpagenko3dbcdd22020-07-22 07:38:45 +0000538 }
mpagenko8b07c1b2020-11-26 10:36:31 +0000539 //AniConfigFsm already init
dbainbri4d3a0dc2020-12-02 00:33:42 +0000540 return onuTP.runAniConfigFsm(ctx, aniEvStart, aProcessingStep, aUniID, aTpID)
mpagenko8b07c1b2020-11-26 10:36:31 +0000541}
542
543// deleteTpResource removes Resources from the ONU's specified Uni
mpagenko73143992021-04-09 15:17:10 +0000544// nolint: gocyclo
mpagenko8b07c1b2020-11-26 10:36:31 +0000545func (onuTP *onuUniTechProf) deleteTpResource(ctx context.Context,
546 aUniID uint8, aTpID uint8, aPathString string, aResource resourceEntry, aEntryID uint32,
547 wg *sync.WaitGroup) {
548 defer wg.Done()
dbainbri4d3a0dc2020-12-02 00:33:42 +0000549 logger.Debugw(ctx, "will remove TP resources from ONU's UNI", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +0000550 "device-id": onuTP.deviceID, "uni-id": aUniID, "path": aPathString, "Resource": aResource})
551 uniTPKey := uniTP{uniID: aUniID, tpID: aTpID}
552
mpagenko7d6bb022021-03-11 15:07:55 +0000553 bDeviceProcStatusUpdate := true
mpagenko8b07c1b2020-11-26 10:36:31 +0000554 if cResourceGemPort == aResource {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000555 logger.Debugw(ctx, "remove GemPort from the list of existing ones of the TP", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +0000556 "device-id": onuTP.deviceID, "uni-id": aUniID, "path": aPathString, "GemPort": aEntryID})
557
mpagenko73143992021-04-09 15:17:10 +0000558 //ensure read protection for access to mapPonAniConfig
559 onuTP.mutexTPState.RLock()
mpagenko8b07c1b2020-11-26 10:36:31 +0000560 // check if the requested GemPort exists in the DB, indicate it to the FSM
561 // store locally to remove it from DB later on success
562 pLocAniConfigOnUni := onuTP.mapPonAniConfig[uniTPKey]
563 if pLocAniConfigOnUni == nil {
mpagenko73143992021-04-09 15:17:10 +0000564 onuTP.mutexTPState.RUnlock()
mpagenko8b07c1b2020-11-26 10:36:31 +0000565 // No relevant entry exists anymore - acknowledge success
dbainbri4d3a0dc2020-12-02 00:33:42 +0000566 logger.Debugw(ctx, "AniConfig or GemEntry do not exists in DB", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +0000567 "device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": aTpID})
568 return
569 }
mpagenko73143992021-04-09 15:17:10 +0000570 onuTP.mutexTPState.RUnlock()
571
Himani Chawla1c136902020-12-10 16:30:59 +0530572 for gemPortID, gemEntry := range pLocAniConfigOnUni.mapGemPortParams {
573 if gemPortID == uint16(aEntryID) {
mpagenko8b07c1b2020-11-26 10:36:31 +0000574 //GemEntry to be deleted found
Himani Chawla1c136902020-12-10 16:30:59 +0530575 gemEntry.removeGemID = gemPortID //store the index for later removal
576 onuTP.mapRemoveGemEntry[uniTPKey] = pLocAniConfigOnUni.mapGemPortParams[gemPortID]
dbainbri4d3a0dc2020-12-02 00:33:42 +0000577 logger.Debugw(ctx, "Remove-GemEntry stored", log.Fields{
Himani Chawla1c136902020-12-10 16:30:59 +0530578 "device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": aTpID, "GemPort": aEntryID})
mpagenko8b07c1b2020-11-26 10:36:31 +0000579 break //abort loop, always only one GemPort to remove
580 }
581 }
582 if onuTP.mapRemoveGemEntry[uniTPKey] == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000583 logger.Errorw(ctx, "GemPort removal aborted - GemPort not found",
mpagenko8b07c1b2020-11-26 10:36:31 +0000584 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": aTpID, "GemPort": aEntryID})
585 /* Do not set some error indication to the outside system interface on delete
586 assume there is nothing to be deleted internally and hope a new config request will recover the situation
587 onuTP.procResult[uniTpKey] = fmt.Errorf("GemPort removal aborted: GemPort not found %d for %d on %s",
588 aEntryID, aUniID, onuTP.deviceID)
589 */
590 return
591 }
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000592 if onuTP.baseDeviceHandler.isReadyForOmciConfig() {
mpagenko8b07c1b2020-11-26 10:36:31 +0000593 // check that the TpConfigRequest was done before
594 // -> that is implicitly done using the AniConfigFsm,
595 // which must be in the according state to remove something
mpagenko8b07c1b2020-11-26 10:36:31 +0000596 if onuTP.pAniConfigFsm == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000597 logger.Errorw(ctx, "abort GemPort removal - no AniConfigFsm available",
mpagenko8b07c1b2020-11-26 10:36:31 +0000598 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID})
599 /* Do not set some error indication to the outside system interface on delete (see above)
600 onuTP.procResult[uniTpKey] = fmt.Errorf("GemPort removal aborted: no AniConfigFsm available %d on %s",
601 aUniID, onuTP.deviceID)
602 */
603 //if the FSM is not valid, also TP related remove data should not be valid:
604 // remove GemPort from config DB
mpagenko73143992021-04-09 15:17:10 +0000605 //ensure write protection for access to mapPonAniConfig
606 onuTP.mutexTPState.Lock()
Himani Chawla1c136902020-12-10 16:30:59 +0530607 delete(onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams, onuTP.mapRemoveGemEntry[uniTPKey].removeGemID)
mpagenko8b07c1b2020-11-26 10:36:31 +0000608 // remove the removeEntry
609 delete(onuTP.mapRemoveGemEntry, uniTPKey)
mpagenko73143992021-04-09 15:17:10 +0000610 onuTP.mutexTPState.Unlock()
mpagenko8b07c1b2020-11-26 10:36:31 +0000611 return
612 }
613 if _, ok := onuTP.pAniConfigFsm[uniTPKey]; !ok {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000614 logger.Errorw(ctx, "abort GemPort removal - no AniConfigFsm available for this uni/tp",
mpagenko8b07c1b2020-11-26 10:36:31 +0000615 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": aTpID})
616 /* Do not set some error indication to the outside system interface on delete (see above)
617 onuTP.procResult[uniTpKey] = fmt.Errorf("GemPort removal aborted: no AniConfigFsm available %d on %s for tpid",
618 aUniID, onuTP.deviceID, aTpID)
619 */
620 //if the FSM is not valid, also TP related remove data should not be valid:
621 // remove GemPort from config DB
mpagenko73143992021-04-09 15:17:10 +0000622 //ensure write protection for access to mapPonAniConfig
623 onuTP.mutexTPState.Lock()
Himani Chawla1c136902020-12-10 16:30:59 +0530624 delete(onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams, onuTP.mapRemoveGemEntry[uniTPKey].removeGemID)
mpagenko8b07c1b2020-11-26 10:36:31 +0000625 // remove the removeEntry
626 delete(onuTP.mapRemoveGemEntry, uniTPKey)
mpagenko73143992021-04-09 15:17:10 +0000627 onuTP.mutexTPState.Unlock()
mpagenko8b07c1b2020-11-26 10:36:31 +0000628 return
629 }
mpagenko73143992021-04-09 15:17:10 +0000630 if onuTP.getProfileResetting(uniTPKey) {
631 logger.Debugw(ctx, "aborting GemRemoval on FSM, reset requested in parallel", log.Fields{
632 "device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": aTpID})
633 //ensure write protection for access to mapPonAniConfig
634 onuTP.mutexTPState.Lock()
635 delete(onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams, onuTP.mapRemoveGemEntry[uniTPKey].removeGemID)
636 // remove the removeEntry
637 delete(onuTP.mapRemoveGemEntry, uniTPKey)
638 onuTP.mutexTPState.Unlock()
639 return
640 }
641 // initiate OMCI GemPort related removal
642 var processingStep uint8 = 1 // used to synchronize the different processing steps with chTpConfigProcessingStep
643 // hence we have to make sure they indicate 'success' on chTpConfigProcessingStep with aProcessingStep
dbainbri4d3a0dc2020-12-02 00:33:42 +0000644 if nil != onuTP.runAniConfigFsm(ctx, aniEvRemGemiw, processingStep, aUniID, aTpID) {
mpagenko8b07c1b2020-11-26 10:36:31 +0000645 //even if the FSM invocation did not work we don't indicate a problem within procResult
646 //errors could exist also because there was nothing to delete - so we just accept that as 'deleted'
647 //TP related data cleared by FSM error treatment or re-used by FSM error-recovery (if implemented)
648 return
649 }
650 if !onuTP.waitForTimeoutOrCompletion(ctx, onuTP.chTpConfigProcessingStep, processingStep) {
mpagenko73143992021-04-09 15:17:10 +0000651 //timeout or error detected (included wanted cancellation after e.g. disable device (FsmReset))
652 logger.Warnw(ctx, "GemPort removal aborted - Omci AniSideConfig failed",
mpagenko8b07c1b2020-11-26 10:36:31 +0000653 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID})
654 //even if the FSM delete execution did not work we don't indicate a problem within procResult
655 //we should never respond to delete with error ...
656 //this issue here means that the AniConfigFsm has not finished successfully
657 //which requires to reset it to allow for new usage, e.g. also on a different UNI
658 //(without that it would be reset on device down indication latest)
mpagenko73143992021-04-09 15:17:10 +0000659 if _, ok := onuTP.pAniConfigFsm[uniTPKey]; ok {
660 _ = onuTP.pAniConfigFsm[uniTPKey].pAdaptFsm.pFsm.Event(aniEvReset)
661 }
mpagenko8b07c1b2020-11-26 10:36:31 +0000662 //TP related data cleared by FSM error treatment or re-used by FSM error-recovery (if implemented)
663 return
664 }
665 } else {
mpagenko7d6bb022021-03-11 15:07:55 +0000666 //if we can't do the OMCI processing we also suppress the ProcStatusUpdate
667 //this is needed as in the device-down case where all FSM's are getting reset and internal data gets cleared
668 //as a consequence a possible remove-flow does not see any dependency on the TechProfile anymore and is executed (pro forma) directly
669 //a later TechProfile removal would cause the device-reason to be updated to 'techProfile-delete-success' which is not the expected state
670 // and anyway is no real useful information at that stage
671 bDeviceProcStatusUpdate = false
dbainbri4d3a0dc2020-12-02 00:33:42 +0000672 logger.Debugw(ctx, "uniPonAniConfigFsm delete Gem on OMCI skipped based on device state", log.Fields{
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000673 "device-id": onuTP.deviceID, "device-state": onuTP.baseDeviceHandler.getDeviceReasonString()})
mpagenko8b07c1b2020-11-26 10:36:31 +0000674 }
675 // remove GemPort from config DB
mpagenko73143992021-04-09 15:17:10 +0000676 //ensure write protection for access to mapPonAniConfig
677 onuTP.mutexTPState.Lock()
Himani Chawla1c136902020-12-10 16:30:59 +0530678 delete(onuTP.mapPonAniConfig[uniTPKey].mapGemPortParams, onuTP.mapRemoveGemEntry[uniTPKey].removeGemID)
mpagenko8b07c1b2020-11-26 10:36:31 +0000679 // remove the removeEntry
680 delete(onuTP.mapRemoveGemEntry, uniTPKey)
mpagenko73143992021-04-09 15:17:10 +0000681 onuTP.mutexTPState.Unlock()
mpagenko8b07c1b2020-11-26 10:36:31 +0000682 // deviceHandler StatusEvent (reason update) (see end of function) is only generated in case some element really was removed
683 } else { //if cResourceTcont == aResource {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000684 logger.Debugw(ctx, "reset TCont with AllocId", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +0000685 "device-id": onuTP.deviceID, "uni-id": aUniID, "path": aPathString, "allocId": aEntryID})
686
mpagenko73143992021-04-09 15:17:10 +0000687 //ensure read protection for access to mapPonAniConfig
688 onuTP.mutexTPState.RLock()
mpagenko8b07c1b2020-11-26 10:36:31 +0000689 // check if the TCont with the indicated AllocId exists in the DB, indicate its EntityId to the FSM
690 pLocAniConfigOnUni := onuTP.mapPonAniConfig[uniTPKey]
691 if pLocAniConfigOnUni == nil {
692 // No relevant entry exists anymore - acknowledge success
mpagenko73143992021-04-09 15:17:10 +0000693 onuTP.mutexTPState.RUnlock()
dbainbri4d3a0dc2020-12-02 00:33:42 +0000694 logger.Debugw(ctx, "AniConfig or TCont entry do not exists in DB", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +0000695 "device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": aTpID})
696 return
697 }
mpagenko73143992021-04-09 15:17:10 +0000698 onuTP.mutexTPState.RUnlock()
699
mpagenko8b07c1b2020-11-26 10:36:31 +0000700 if pLocAniConfigOnUni.tcontParams.allocID != uint16(aEntryID) {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000701 logger.Errorw(ctx, "TCont removal aborted - indicated AllocId not found",
mpagenko8b07c1b2020-11-26 10:36:31 +0000702 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": aTpID, "AllocId": aEntryID})
703 /* Do not set some error indication to the outside system interface on delete
704 assume there is nothing to be deleted internally and hope a new config request will recover the situation
705 onuTP.procResult[uniTpKey] = fmt.Errorf("TCont removal aborted: AllocId not found %d for %d on %s",
706 aEntryID, aUniID, onuTP.deviceID)
707 */
708 return
709 }
710 //T-Cont to be reset found
dbainbri4d3a0dc2020-12-02 00:33:42 +0000711 logger.Debugw(ctx, "Reset-T-Cont AllocId found - valid", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +0000712 "device-id": onuTP.deviceID, "uni-id": aUniID, "AllocId": aEntryID})
713 if onuTP.pAniConfigFsm == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000714 logger.Errorw(ctx, "no TCont removal on OMCI - no AniConfigFsm available",
mpagenko8b07c1b2020-11-26 10:36:31 +0000715 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID})
716 /* Do not set some error indication to the outside system interface on delete (see above)
717 onuTP.procResult[uniTpKey] = fmt.Errorf("TCont cleanup aborted: no AniConfigFsm available %d on %s",
718 aUniID, onuTP.deviceID)
719 */
720 //if the FSM is not valid, also TP related data should not be valid - clear the internal store profile data
dbainbri4d3a0dc2020-12-02 00:33:42 +0000721 onuTP.clearAniSideConfig(ctx, aUniID, aTpID)
mpagenko8b07c1b2020-11-26 10:36:31 +0000722 return
723 }
724 if _, ok := onuTP.pAniConfigFsm[uniTPKey]; !ok {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000725 logger.Errorw(ctx, "no TCont removal on OMCI - no AniConfigFsm available for this uni/tp",
mpagenko8b07c1b2020-11-26 10:36:31 +0000726 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": aTpID})
727 //even if the FSM invocation did not work we don't indicate a problem within procResult
728 //errors could exist also because there was nothing to delete - so we just accept that as 'deleted'
729 //if the FSM is not valid, also TP related data should not be valid - clear the internal store profile data
dbainbri4d3a0dc2020-12-02 00:33:42 +0000730 onuTP.clearAniSideConfig(ctx, aUniID, aTpID)
mpagenko8b07c1b2020-11-26 10:36:31 +0000731 return
732 }
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000733 if onuTP.baseDeviceHandler.isReadyForOmciConfig() {
mpagenko8b07c1b2020-11-26 10:36:31 +0000734 // check that the TpConfigRequest was done before
735 // -> that is implicitly done using the AniConfigFsm,
736 // which must be in the according state to remove something
mpagenko73143992021-04-09 15:17:10 +0000737 if onuTP.getProfileResetting(uniTPKey) {
738 logger.Debugw(ctx, "aborting TCont removal on FSM, reset requested in parallel", log.Fields{
739 "device-id": onuTP.deviceID, "uni-id": aUniID, "tp-id": aTpID})
740 return
741 }
mpagenko8b07c1b2020-11-26 10:36:31 +0000742 // initiate OMCI TCont related cleanup
743 var processingStep uint8 = 1 // used to synchronize the different processing steps with chTpConfigProcessingStep
744 // hence we have to make sure they indicate 'success' on chTpConfigProcessingStep with aProcessingStep
dbainbri4d3a0dc2020-12-02 00:33:42 +0000745 if nil != onuTP.runAniConfigFsm(ctx, aniEvRemTcontPath, processingStep, aUniID, aTpID) {
mpagenko8b07c1b2020-11-26 10:36:31 +0000746 //even if the FSM invocation did not work we don't indicate a problem within procResult
747 //errors could exist also because there was nothing to delete - so we just accept that as 'deleted'
748 //TP related data cleared by FSM error treatment or re-used by FSM error-recovery (if implemented)
749 return
750 }
751 if !onuTP.waitForTimeoutOrCompletion(ctx, onuTP.chTpConfigProcessingStep, processingStep) {
mpagenko73143992021-04-09 15:17:10 +0000752 //timeout or error detected (included wanted cancellation after e.g. disable device (FsmReset))
753 logger.Warnw(ctx, "TCont cleanup aborted - Omci AniSideConfig failed",
mpagenko8b07c1b2020-11-26 10:36:31 +0000754 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID})
755 //even if the FSM delete execution did not work we don't indicate a problem within procResult
756 //we should never respond to delete with error ...
757 //this issue here means that the AniConfigFsm has not finished successfully
758 //which requires to reset it to allow for new usage, e.g. also on a different UNI
759 //(without that it would be reset on device down indication latest)
mpagenko73143992021-04-09 15:17:10 +0000760 if _, ok := onuTP.pAniConfigFsm[uniTPKey]; ok {
761 _ = onuTP.pAniConfigFsm[uniTPKey].pAdaptFsm.pFsm.Event(aniEvReset)
762 }
mpagenko8b07c1b2020-11-26 10:36:31 +0000763 //TP related data cleared by FSM error treatment or re-used by FSM error-recovery (if implemented)
764 return
765 }
766 } else {
mpagenko7d6bb022021-03-11 15:07:55 +0000767 //see gemPort comments
768 bDeviceProcStatusUpdate = false
dbainbri4d3a0dc2020-12-02 00:33:42 +0000769 logger.Debugw(ctx, "uniPonAniConfigFsm TCont cleanup on OMCI skipped based on device state", log.Fields{
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000770 "device-id": onuTP.deviceID, "device-state": onuTP.baseDeviceHandler.getDeviceReasonString()})
mpagenko8b07c1b2020-11-26 10:36:31 +0000771 }
772 //clear the internal store profile data
dbainbri4d3a0dc2020-12-02 00:33:42 +0000773 onuTP.clearAniSideConfig(ctx, aUniID, aTpID)
mpagenko8b07c1b2020-11-26 10:36:31 +0000774 // reset also the FSM in order to admit a new OMCI configuration in case a new profile is created
775 // FSM stop maybe encapsulated as OnuTP method - perhaps later in context of module splitting
776 _ = onuTP.pAniConfigFsm[uniTPKey].pAdaptFsm.pFsm.Event(aniEvReset)
777 }
mpagenko7d6bb022021-03-11 15:07:55 +0000778 if bDeviceProcStatusUpdate {
779 // generate deviceHandler StatusEvent in case the FSM was not invoked and OMCI processing not locked due to device state
780 go onuTP.baseDeviceHandler.deviceProcStatusUpdate(ctx, OmciAniResourceRemoved)
781 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000782}
783
Himani Chawla6d2ae152020-09-02 13:11:20 +0530784func (onuTP *onuUniTechProf) waitForTimeoutOrCompletion(
mpagenkodff5dda2020-08-28 11:52:01 +0000785 ctx context.Context, aChTpProcessingStep <-chan uint8, aProcessingStep uint8) bool {
mpagenko3dbcdd22020-07-22 07:38:45 +0000786 select {
787 case <-ctx.Done():
dbainbri4d3a0dc2020-12-02 00:33:42 +0000788 logger.Warnw(ctx, "processing not completed in-time: force release of TpProcMutex!",
divyadesai4d299552020-08-18 07:13:49 +0000789 log.Fields{"device-id": onuTP.deviceID, "error": ctx.Err()})
mpagenko3dbcdd22020-07-22 07:38:45 +0000790 return false
mpagenkodff5dda2020-08-28 11:52:01 +0000791 case rxStep := <-aChTpProcessingStep:
mpagenko3dbcdd22020-07-22 07:38:45 +0000792 if rxStep == aProcessingStep {
793 return true
794 }
795 //all other values are not accepted - including 0 for error indication
dbainbri4d3a0dc2020-12-02 00:33:42 +0000796 logger.Warnw(ctx, "Invalid processing step received: abort and force release of TpProcMutex!",
divyadesai4d299552020-08-18 07:13:49 +0000797 log.Fields{"device-id": onuTP.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000798 "wantedStep": aProcessingStep, "haveStep": rxStep})
799 return false
800 }
801}
802
Holger Hildebrandtbe523842021-03-10 10:47:18 +0000803// createAniConfigFsm initializes and runs the AniConfig FSM to transfer the OMCI related commands for ANI side configuration
dbainbri4d3a0dc2020-12-02 00:33:42 +0000804func (onuTP *onuUniTechProf) createAniConfigFsm(ctx context.Context, aUniID uint8, aTpID uint8,
mpagenko8b07c1b2020-11-26 10:36:31 +0000805 apCurrentUniPort *onuUniPort, devEvent OnuDeviceEvent, aProcessingStep uint8) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000806 logger.Debugw(ctx, "createAniConfigFsm", log.Fields{"device-id": onuTP.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000807 chAniConfigFsm := make(chan Message, 2048)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800808 uniTPKey := uniTP{uniID: aUniID, tpID: aTpID}
dbainbri4d3a0dc2020-12-02 00:33:42 +0000809 pDevEntry := onuTP.baseDeviceHandler.getOnuDeviceEntry(ctx, true)
mpagenko3dbcdd22020-07-22 07:38:45 +0000810 if pDevEntry == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000811 logger.Errorw(ctx, "No valid OnuDevice - aborting", log.Fields{"device-id": onuTP.deviceID})
mpagenko8b07c1b2020-11-26 10:36:31 +0000812 return fmt.Errorf("no valid OnuDevice: %s", onuTP.deviceID)
mpagenko3dbcdd22020-07-22 07:38:45 +0000813 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000814 pAniCfgFsm := newUniPonAniConfigFsm(ctx, pDevEntry.PDevOmciCC, apCurrentUniPort, onuTP,
Girish Gowdra041dcb32020-11-16 16:54:30 -0800815 pDevEntry.pOnuDB, aTpID, devEvent,
mpagenko01e726e2020-10-23 09:45:29 +0000816 "AniConfigFsm", onuTP.baseDeviceHandler, chAniConfigFsm)
mpagenko8b07c1b2020-11-26 10:36:31 +0000817 if pAniCfgFsm == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000818 logger.Errorw(ctx, "AniConfigFSM could not be created - abort!!", log.Fields{"device-id": onuTP.deviceID})
mpagenko8b07c1b2020-11-26 10:36:31 +0000819 return fmt.Errorf("could not create AniConfigFSM: %s", onuTP.deviceID)
mpagenko3dbcdd22020-07-22 07:38:45 +0000820 }
mpagenko8b07c1b2020-11-26 10:36:31 +0000821 if onuTP.pAniConfigFsm == nil {
822 onuTP.pAniConfigFsm = make(map[uniTP]*uniPonAniConfigFsm)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800823 }
mpagenko8b07c1b2020-11-26 10:36:31 +0000824 onuTP.pAniConfigFsm[uniTPKey] = pAniCfgFsm
dbainbri4d3a0dc2020-12-02 00:33:42 +0000825 return onuTP.runAniConfigFsm(ctx, aniEvStart, aProcessingStep, aUniID, aTpID)
mpagenkofc4f56e2020-11-04 17:17:49 +0000826}
827
mpagenko3dbcdd22020-07-22 07:38:45 +0000828// runAniConfigFsm starts the AniConfig FSM to transfer the OMCI related commands for ANI side configuration
dbainbri4d3a0dc2020-12-02 00:33:42 +0000829func (onuTP *onuUniTechProf) runAniConfigFsm(ctx context.Context, aEvent string, aProcessingStep uint8, aUniID uint8, aTpID uint8) error {
mpagenko3dbcdd22020-07-22 07:38:45 +0000830 /* Uni related ANI config procedure -
831 ***** should run via 'aniConfigDone' state and generate the argument requested event *****
832 */
Girish Gowdra041dcb32020-11-16 16:54:30 -0800833 uniTpKey := uniTP{uniID: aUniID, tpID: aTpID}
834
835 pACStatemachine := onuTP.pAniConfigFsm[uniTpKey].pAdaptFsm.pFsm
mpagenko3dbcdd22020-07-22 07:38:45 +0000836 if pACStatemachine != nil {
mpagenko8b07c1b2020-11-26 10:36:31 +0000837 if aEvent == aniEvStart {
838 if !pACStatemachine.Is(aniStDisabled) {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000839 logger.Errorw(ctx, "wrong state of AniConfigFSM to start - want: Disabled", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +0000840 "have": pACStatemachine.Current(), "device-id": onuTP.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000841 // maybe try a FSM reset and then again ... - TODO!!!
mpagenko8b07c1b2020-11-26 10:36:31 +0000842 return fmt.Errorf("wrong state of AniConfigFSM to start: %s", onuTP.deviceID)
mpagenko3dbcdd22020-07-22 07:38:45 +0000843 }
mpagenko8b07c1b2020-11-26 10:36:31 +0000844 } else if !pACStatemachine.Is(aniStConfigDone) {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000845 logger.Errorw(ctx, "wrong state of AniConfigFSM to remove - want: ConfigDone", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000846 "have": pACStatemachine.Current(), "device-id": onuTP.deviceID})
mpagenko8b07c1b2020-11-26 10:36:31 +0000847 return fmt.Errorf("wrong state of AniConfigFSM to remove: %s", onuTP.deviceID)
mpagenko3dbcdd22020-07-22 07:38:45 +0000848 }
mpagenko8b07c1b2020-11-26 10:36:31 +0000849 //FSM init requirement to get informed about FSM completion! (otherwise timeout of the TechProf config)
850 onuTP.pAniConfigFsm[uniTpKey].setFsmCompleteChannel(onuTP.chTpConfigProcessingStep, aProcessingStep)
851 if err := pACStatemachine.Event(aEvent); err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000852 logger.Errorw(ctx, "AniConfigFSM: can't trigger event", log.Fields{"err": err})
mpagenko8b07c1b2020-11-26 10:36:31 +0000853 return fmt.Errorf("can't trigger event in AniConfigFSM: %s", onuTP.deviceID)
854 }
855 /***** AniConfigFSM event notified */
dbainbri4d3a0dc2020-12-02 00:33:42 +0000856 logger.Debugw(ctx, "AniConfigFSM event notified", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +0000857 "state": pACStatemachine.Current(), "device-id": onuTP.deviceID, "event": aEvent})
858 return nil
mpagenko3dbcdd22020-07-22 07:38:45 +0000859 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000860 logger.Errorw(ctx, "AniConfigFSM StateMachine invalid - cannot be executed!!", log.Fields{"device-id": onuTP.deviceID})
mpagenko8b07c1b2020-11-26 10:36:31 +0000861 // maybe try a FSM reset and then again ... - TODO!!!
862 return fmt.Errorf("stateMachine AniConfigFSM invalid: %s", onuTP.deviceID)
mpagenkoaf801632020-07-03 10:00:42 +0000863}
mpagenkodff5dda2020-08-28 11:52:01 +0000864
Girish Gowdra041dcb32020-11-16 16:54:30 -0800865// clearAniSideConfig deletes internal TechProfile related data connected to the requested UniPort and TpID
dbainbri4d3a0dc2020-12-02 00:33:42 +0000866func (onuTP *onuUniTechProf) clearAniSideConfig(ctx context.Context, aUniID uint8, aTpID uint8) {
867 logger.Debugw(ctx, "removing TpIndication and PonAniConfig data", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +0000868 "device-id": onuTP.deviceID, "uni-id": aUniID})
Girish Gowdra041dcb32020-11-16 16:54:30 -0800869 uniTpKey := uniTP{uniID: aUniID, tpID: aTpID}
870
871 onuTP.mutexTPState.Lock()
872 defer onuTP.mutexTPState.Unlock()
mpagenko73143992021-04-09 15:17:10 +0000873 //deleting a map entry should be safe, even if not existing
Girish Gowdra041dcb32020-11-16 16:54:30 -0800874 delete(onuTP.mapUniTpIndication, uniTpKey)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800875 delete(onuTP.mapPonAniConfig, uniTpKey)
mpagenko73143992021-04-09 15:17:10 +0000876 delete(onuTP.procResult, uniTpKey)
877 delete(onuTP.tpProfileExists, uniTpKey)
878 delete(onuTP.tpProfileResetting, uniTpKey)
mpagenko01e726e2020-10-23 09:45:29 +0000879}
880
mpagenkodff5dda2020-08-28 11:52:01 +0000881// setConfigDone sets the requested techProfile config state (if possible)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800882func (onuTP *onuUniTechProf) setConfigDone(aUniID uint8, aTpID uint8, aState bool) {
883 uniTpKey := uniTP{uniID: aUniID, tpID: aTpID}
884 onuTP.mutexTPState.Lock()
885 defer onuTP.mutexTPState.Unlock()
886 if _, existTP := onuTP.mapUniTpIndication[uniTpKey]; existTP {
887 onuTP.mapUniTpIndication[uniTpKey].techProfileConfigDone = aState
mpagenkodff5dda2020-08-28 11:52:01 +0000888 } //else: the state is just ignored (does not exist)
889}
890
891// getTechProfileDone checks if the Techprofile processing with the requested TechProfile ID was done
dbainbri4d3a0dc2020-12-02 00:33:42 +0000892func (onuTP *onuUniTechProf) getTechProfileDone(ctx context.Context, aUniID uint8, aTpID uint8) bool {
Girish Gowdra041dcb32020-11-16 16:54:30 -0800893 uniTpKey := uniTP{uniID: aUniID, tpID: aTpID}
mpagenko73143992021-04-09 15:17:10 +0000894 onuTP.mutexTPState.RLock()
895 defer onuTP.mutexTPState.RUnlock()
Girish Gowdra041dcb32020-11-16 16:54:30 -0800896 if _, existTP := onuTP.mapUniTpIndication[uniTpKey]; existTP {
897 if onuTP.mapUniTpIndication[uniTpKey].techProfileID == aTpID {
898 if onuTP.mapUniTpIndication[uniTpKey].techProfileToDelete {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000899 logger.Debugw(ctx, "TechProfile not relevant for requested flow config - waiting on delete",
mpagenko2418ab02020-11-12 12:58:06 +0000900 log.Fields{"device-id": onuTP.deviceID, "uni-id": aUniID})
901 return false //still waiting for removal of this techProfile first
902 }
Girish Gowdra041dcb32020-11-16 16:54:30 -0800903 return onuTP.mapUniTpIndication[uniTpKey].techProfileConfigDone
mpagenkodff5dda2020-08-28 11:52:01 +0000904 }
905 }
906 //for all other constellations indicate false = Config not done
907 return false
908}
mpagenko2418ab02020-11-12 12:58:06 +0000909
910// setProfileToDelete sets the requested techProfile toDelete state (if possible)
Girish Gowdra041dcb32020-11-16 16:54:30 -0800911func (onuTP *onuUniTechProf) setProfileToDelete(aUniID uint8, aTpID uint8, aState bool) {
912 uniTpKey := uniTP{uniID: aUniID, tpID: aTpID}
913 onuTP.mutexTPState.Lock()
914 defer onuTP.mutexTPState.Unlock()
915 if _, existTP := onuTP.mapUniTpIndication[uniTpKey]; existTP {
916 onuTP.mapUniTpIndication[uniTpKey].techProfileToDelete = aState
mpagenko2418ab02020-11-12 12:58:06 +0000917 } //else: the state is just ignored (does not exist)
918}
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300919
920// setProfileToDelete sets the requested techProfile toDelete state (if possible)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000921func (onuTP *onuUniTechProf) getMulticastGemPorts(ctx context.Context, aUniID uint8, aTpID uint8) []uint16 {
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300922 uniTpKey := uniTP{uniID: aUniID, tpID: aTpID}
mpagenko73143992021-04-09 15:17:10 +0000923 onuTP.mutexTPState.RLock()
924 defer onuTP.mutexTPState.RUnlock()
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300925 gemPortIds := make([]uint16, 0)
926 if techProfile, existTP := onuTP.mapPonAniConfig[uniTpKey]; existTP {
927 for _, gemPortParam := range techProfile.mapGemPortParams {
928 if gemPortParam.isMulticast {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000929 logger.Debugw(ctx, "Detected multicast gemPort", log.Fields{"device-id": onuTP.deviceID,
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300930 "aUniID": aUniID, "aTPID": aTpID, "uniTPKey": uniTpKey,
931 "mcastGemId": gemPortParam.multicastGemPortID})
932 gemPortIds = append(gemPortIds, gemPortParam.multicastGemPortID)
933 }
934 }
935 } //else: the state is just ignored (does not exist)
936 return gemPortIds
937}
Girish Gowdra5c5aaf42021-02-17 19:40:50 -0800938
939func (onuTP *onuUniTechProf) GetAllBidirectionalGemPortIDsForOnu() []uint16 {
940 var gemPortInstIDs []uint16
941 onuTP.mutexTPState.RLock()
942 defer onuTP.mutexTPState.RUnlock()
943 for _, tcontGemList := range onuTP.mapPonAniConfig {
944 for gemPortID, gemPortData := range tcontGemList.mapGemPortParams {
945 if gemPortData != nil && !gemPortData.isMulticast { // only if not multicast gem port
946 gemPortInstIDs = append(gemPortInstIDs, gemPortID)
947 }
948 }
949 }
950 return gemPortInstIDs
951}
mpagenko73143992021-04-09 15:17:10 +0000952
953// setProfileResetting sets/resets the indication, that a reset of the TechProfileConfig/Removal is ongoing
954func (onuTP *onuUniTechProf) setProfileResetting(ctx context.Context, aUniID uint8, aTpID uint8, aState bool) {
955 uniTpKey := uniTP{uniID: aUniID, tpID: aTpID}
956 onuTP.mutexTPState.Lock()
957 defer onuTP.mutexTPState.Unlock()
958 onuTP.tpProfileResetting[uniTpKey] = aState
959}
960
961// getProfileResetting returns true, if the the according indication for started reset procedure is set
962func (onuTP *onuUniTechProf) getProfileResetting(aUniTpKey uniTP) bool {
963 onuTP.mutexTPState.RLock()
964 defer onuTP.mutexTPState.RUnlock()
965 if isResetting, exist := onuTP.tpProfileResetting[aUniTpKey]; exist {
966 return isResetting
967 }
968 return false
969}