VOL-3368 Added object+error pair for funtion within error handling. This patch include modification requested for omci_cc send functions.
Change-Id: I2a8ed3123f4a2f3a33ae7a418bd9d1dbabbf103d
diff --git a/internal/pkg/onuadaptercore/mib_download.go b/internal/pkg/onuadaptercore/mib_download.go
index e79abe2..b369766 100644
--- a/internal/pkg/onuadaptercore/mib_download.go
+++ b/internal/pkg/onuadaptercore/mib_download.go
@@ -45,17 +45,40 @@
func (onuDeviceEntry *OnuDeviceEntry) enterCreatingGalState(ctx context.Context, e *fsm.Event) {
logger.Debugw(ctx, "MibDownload FSM", log.Fields{"Tx create::GAL Ethernet Profile in state": e.FSM.Current(), "device-id": onuDeviceEntry.deviceID})
- meInstance := onuDeviceEntry.PDevOmciCC.sendCreateGalEthernetProfile(log.WithSpanFromContext(context.TODO(), ctx), onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
+ meInstance, err := onuDeviceEntry.PDevOmciCC.sendCreateGalEthernetProfile(log.WithSpanFromContext(context.TODO(), ctx), onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
+ if err != nil {
+ logger.Errorw(ctx, "GalEthernetProfile create failed, aborting MibDownload FSM!",
+ log.Fields{"device-id": onuDeviceEntry.deviceID})
+ pMibDlFsm := onuDeviceEntry.pMibDownloadFsm
+ if pMibDlFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ _ = a_pAFsm.pFsm.Event(dlEvReset)
+ }(pMibDlFsm)
+ }
+ return
+ }
onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
}
func (onuDeviceEntry *OnuDeviceEntry) enterSettingOnu2gState(ctx context.Context, e *fsm.Event) {
logger.Debugw(ctx, "MibDownload FSM", log.Fields{"Tx Set::ONU2-G in state": e.FSM.Current(), "device-id": onuDeviceEntry.deviceID})
- meInstance := onuDeviceEntry.PDevOmciCC.sendSetOnu2g(log.WithSpanFromContext(context.TODO(), ctx), onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
+ meInstance, err := onuDeviceEntry.PDevOmciCC.sendSetOnu2g(log.WithSpanFromContext(context.TODO(), ctx),
+ onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
+ if err != nil {
+ logger.Errorw(ctx, "ONU2-G set failed, aborting MibDownload FSM!",
+ log.Fields{"device-id": onuDeviceEntry.deviceID})
+ pMibDlFsm := onuDeviceEntry.pMibDownloadFsm
+ if pMibDlFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ _ = a_pAFsm.pFsm.Event(dlEvReset)
+ }(pMibDlFsm)
+ }
+ return
+ }
onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
}
@@ -243,11 +266,16 @@
"device-id": onuDeviceEntry.deviceID, "for PortNo": uniNo})
//create MBSP
- meInstance := onuDeviceEntry.PDevOmciCC.sendCreateMBServiceProfile(
+ meInstance, err := onuDeviceEntry.PDevOmciCC.sendCreateMBServiceProfile(
log.WithSpanFromContext(context.TODO(), ctx), uniPort, onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
+ if err != nil {
+ logger.Errorw(ctx, "MBServiceProfile create failed, aborting MibDownload FSM!", log.Fields{"device-id": onuDeviceEntry.deviceID})
+ _ = onuDeviceEntry.pMibDownloadFsm.pFsm.Event(dlEvReset)
+ return
+ }
onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
//verify response
- err := onuDeviceEntry.waitforOmciResponse(ctx, meInstance)
+ err = onuDeviceEntry.waitforOmciResponse(ctx, meInstance)
if err != nil {
logger.Errorw(ctx, "InitialBridgeSetup failed at MBSP, aborting MIB Download!",
log.Fields{"device-id": onuDeviceEntry.deviceID})
@@ -256,8 +284,14 @@
}
//create MBPCD
- meInstance = onuDeviceEntry.PDevOmciCC.sendCreateMBPConfigData(
+ meInstance, err = onuDeviceEntry.PDevOmciCC.sendCreateMBPConfigData(
log.WithSpanFromContext(context.TODO(), ctx), uniPort, onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
+ if err != nil {
+ logger.Errorw(ctx, "MBPConfigData create failed, aborting MibDownload FSM!",
+ log.Fields{"device-id": onuDeviceEntry.deviceID})
+ _ = onuDeviceEntry.pMibDownloadFsm.pFsm.Event(dlEvReset)
+ return
+ }
onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
//verify response
err = onuDeviceEntry.waitforOmciResponse(ctx, meInstance)
@@ -269,8 +303,14 @@
}
//create EVTOCD
- meInstance = onuDeviceEntry.PDevOmciCC.sendCreateEVTOConfigData(
+ meInstance, err = onuDeviceEntry.PDevOmciCC.sendCreateEVTOConfigData(
log.WithSpanFromContext(context.TODO(), ctx), uniPort, onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
+ if err != nil {
+ logger.Errorw(ctx, "EVTOConfigData create failed, aborting MibDownload FSM!",
+ log.Fields{"device-id": onuDeviceEntry.deviceID})
+ _ = onuDeviceEntry.pMibDownloadFsm.pFsm.Event(dlEvReset)
+ return
+ }
onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
//verify response
err = onuDeviceEntry.waitforOmciResponse(ctx, meInstance)
diff --git a/internal/pkg/onuadaptercore/mib_sync.go b/internal/pkg/onuadaptercore/mib_sync.go
index 8ae5742..2191a75 100644
--- a/internal/pkg/onuadaptercore/mib_sync.go
+++ b/internal/pkg/onuadaptercore/mib_sync.go
@@ -97,9 +97,19 @@
func (oo *OnuDeviceEntry) enterGettingVendorAndSerialState(ctx context.Context, e *fsm.Event) {
logger.Debugw(ctx, "MibSync FSM", log.Fields{"Start getting VendorId and SerialNumber in State": e.FSM.Current(), "device-id": oo.deviceID})
requestedAttributes := me.AttributeValueMap{"VendorId": "", "SerialNumber": 0}
- meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.OnuGClassID, onugMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+ meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.OnuGClassID, onugMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
+ if err != nil {
+ logger.Errorw(ctx, "ONU-G get failed, aborting MibSync FSM", log.Fields{"device-id": oo.deviceID})
+ pMibUlFsm := oo.pMibUploadFsm
+ if pMibUlFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ _ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+ }(pMibUlFsm)
+ }
+ return
+ }
oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
oo.lastTxParamStruct.pLastTxMeInstance = meInstance
}
@@ -107,9 +117,19 @@
func (oo *OnuDeviceEntry) enterGettingEquipmentIDState(ctx context.Context, e *fsm.Event) {
logger.Debugw(ctx, "MibSync FSM", log.Fields{"Start getting EquipmentId in State": e.FSM.Current(), "device-id": oo.deviceID})
requestedAttributes := me.AttributeValueMap{"EquipmentId": ""}
- meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.Onu2GClassID, onu2gMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+ meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.Onu2GClassID, onu2gMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
+ if err != nil {
+ logger.Errorw(ctx, "ONU2-G get failed, aborting MibSync FSM!", log.Fields{"device-id": oo.deviceID})
+ pMibUlFsm := oo.pMibUploadFsm
+ if pMibUlFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ _ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+ }(pMibUlFsm)
+ }
+ return
+ }
oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
oo.lastTxParamStruct.pLastTxMeInstance = meInstance
}
@@ -117,9 +137,19 @@
func (oo *OnuDeviceEntry) enterGettingFirstSwVersionState(ctx context.Context, e *fsm.Event) {
logger.Debugw(ctx, "MibSync FSM", log.Fields{"Start getting IsActive and Version of first SW-image in State": e.FSM.Current(), "device-id": oo.deviceID})
requestedAttributes := me.AttributeValueMap{"IsCommitted": 0, "IsActive": 0, "Version": ""}
- meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.SoftwareImageClassID, firstSwImageMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+ meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.SoftwareImageClassID, firstSwImageMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
+ if err != nil {
+ logger.Errorw(ctx, "SoftwareImage get failed, aborting MibSync FSM", log.Fields{"device-id": oo.deviceID})
+ pMibUlFsm := oo.pMibUploadFsm
+ if pMibUlFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ _ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+ }(pMibUlFsm)
+ }
+ return
+ }
oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
oo.lastTxParamStruct.pLastTxMeInstance = meInstance
}
@@ -127,9 +157,19 @@
func (oo *OnuDeviceEntry) enterGettingSecondSwVersionState(ctx context.Context, e *fsm.Event) {
logger.Debugw(ctx, "MibSync FSM", log.Fields{"Start getting IsActive and Version of second SW-image in State": e.FSM.Current(), "device-id": oo.deviceID})
requestedAttributes := me.AttributeValueMap{"IsCommitted": 0, "IsActive": 0, "Version": ""}
- meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.SoftwareImageClassID, secondSwImageMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+ meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.SoftwareImageClassID, secondSwImageMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
+ if err != nil {
+ logger.Errorw(ctx, "SoftwareImage get failed, aborting MibSync FSM", log.Fields{"device-id": oo.deviceID})
+ pMibUlFsm := oo.pMibUploadFsm
+ if pMibUlFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ _ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+ }(pMibUlFsm)
+ }
+ return
+ }
oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
oo.lastTxParamStruct.pLastTxMeInstance = meInstance
}
@@ -137,9 +177,19 @@
func (oo *OnuDeviceEntry) enterGettingMacAddressState(ctx context.Context, e *fsm.Event) {
logger.Debugw(ctx, "MibSync FSM", log.Fields{"Start getting MacAddress in State": e.FSM.Current(), "device-id": oo.deviceID})
requestedAttributes := me.AttributeValueMap{"MacAddress": ""}
- meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.IpHostConfigDataClassID, ipHostConfigDataMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+ meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.IpHostConfigDataClassID, ipHostConfigDataMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
+ if err != nil {
+ logger.Errorw(ctx, "IpHostConfigData get failed, aborting MibSync FSM", log.Fields{"device-id": oo.deviceID})
+ pMibUlFsm := oo.pMibUploadFsm
+ if pMibUlFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ _ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+ }(pMibUlFsm)
+ }
+ return
+ }
oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
oo.lastTxParamStruct.pLastTxMeInstance = meInstance
}
@@ -383,8 +433,13 @@
if oo.lastTxParamStruct.lastTxMessageType == omci.GetRequestType && oo.lastTxParamStruct.repeatCount == 0 {
logger.Debugw(ctx, "MibSync FSM - repeat MdsGetRequest (updated SequenceNumber)", log.Fields{"device-id": oo.deviceID})
requestedAttributes := me.AttributeValueMap{"MibDataSync": ""}
- _ = oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
+ _, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
me.OnuDataClassID, onuDataMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "ONUData get failed, aborting MibSync", log.Fields{"device-id": oo.deviceID})
+ _ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+ return
+ }
//TODO: needs extra handling of timeouts
oo.lastTxParamStruct.repeatCount = 1
return
@@ -788,10 +843,20 @@
func (oo *OnuDeviceEntry) requestMdsValue(ctx context.Context) {
logger.Debugw(ctx, "Request MDS value", log.Fields{"device-id": oo.deviceID})
requestedAttributes := me.AttributeValueMap{"MibDataSync": ""}
- meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
+ meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
me.OnuDataClassID, onuDataMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
+ if err != nil {
+ logger.Errorw(ctx, "ONUData get failed, aborting MibSync FSM!", log.Fields{"device-id": oo.deviceID})
+ pMibUlFsm := oo.pMibUploadFsm
+ if pMibUlFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ _ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+ }(pMibUlFsm)
+ }
+ return
+ }
oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
oo.lastTxParamStruct.pLastTxMeInstance = meInstance
oo.lastTxParamStruct.repeatCount = 0
diff --git a/internal/pkg/onuadaptercore/omci_ani_config.go b/internal/pkg/onuadaptercore/omci_ani_config.go
index 296977d..e03eb17 100644
--- a/internal/pkg/onuadaptercore/omci_ani_config.go
+++ b/internal/pkg/onuadaptercore/omci_ani_config.go
@@ -510,12 +510,28 @@
"device-id": oFsm.deviceID, "uni-id": oFsm.pOnuUniPort.uniID})
oFsm.requestEventOffset = 0 //0 offset for last config request activity
oFsm.mutexPLastTxMeInstance.Lock()
- defer oFsm.mutexPLastTxMeInstance.Unlock()
- meInstance := oFsm.pOmciCC.sendCreateDot1PMapper(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendCreateDot1PMapper(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.mapperSP0ID, oFsm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "Dot1PMapper create failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ pConfigAniStateAFsm := oFsm.pAdaptFsm
+ if pConfigAniStateAFsm != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ // obviously calling some FSM event here directly does not work - so trying to decouple it ...
+ go func(aPAFsm *AdapterFsm) {
+ if aPAFsm != nil && aPAFsm.pFsm != nil {
+ _ = aPAFsm.pFsm.Event(aniEvReset)
+ }
+ }(pConfigAniStateAFsm)
+ return
+ }
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
+ oFsm.mutexPLastTxMeInstance.Unlock()
+
}
func (oFsm *uniPonAniConfigFsm) enterCreatingMBPCD(ctx context.Context, e *fsm.Event) {
@@ -534,12 +550,28 @@
},
}
oFsm.mutexPLastTxMeInstance.Lock()
- defer oFsm.mutexPLastTxMeInstance.Unlock()
- meInstance := oFsm.pOmciCC.sendCreateMBPConfigDataVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendCreateMBPConfigDataVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "MBPConfigDataVar create failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ pConfigAniStateAFsm := oFsm.pAdaptFsm
+ if pConfigAniStateAFsm != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ // obviously calling some FSM event here directly does not work - so trying to decouple it ...
+ go func(aPAFsm *AdapterFsm) {
+ if aPAFsm != nil && aPAFsm.pFsm != nil {
+ _ = aPAFsm.pFsm.Event(aniEvReset)
+ }
+ }(pConfigAniStateAFsm)
+ return
+ }
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
+ oFsm.mutexPLastTxMeInstance.Unlock()
+
}
func (oFsm *uniPonAniConfigFsm) enterSettingTconts(ctx context.Context, e *fsm.Event) {
@@ -554,12 +586,28 @@
},
}
oFsm.mutexPLastTxMeInstance.Lock()
- defer oFsm.mutexPLastTxMeInstance.Unlock()
- meInstance := oFsm.pOmciCC.sendSetTcontVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetTcontVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "TcontVar set failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ pConfigAniStateAFsm := oFsm.pAdaptFsm
+ if pConfigAniStateAFsm != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ // obviously calling some FSM event here directly does not work - so trying to decouple it ...
+ go func(aPAFsm *AdapterFsm) {
+ if aPAFsm != nil && aPAFsm.pFsm != nil {
+ _ = aPAFsm.pFsm.Event(aniEvReset)
+ }
+ }(pConfigAniStateAFsm)
+ return
+ }
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
+ oFsm.mutexPLastTxMeInstance.Unlock()
+
}
func (oFsm *uniPonAniConfigFsm) enterCreatingGemNCTPs(ctx context.Context, e *fsm.Event) {
@@ -674,18 +722,33 @@
// obviously calling some FSM event here directly does not work - so trying to decouple it ...
go func(aPAFsm *AdapterFsm) {
if aPAFsm != nil && aPAFsm.pFsm != nil {
- _ = oFsm.pAdaptFsm.pFsm.Event(aniEvRxDot1pmapSResp)
+ _ = aPAFsm.pFsm.Event(aniEvRxDot1pmapSResp)
}
}(pConfigAniStateAFsm)
}
} else {
oFsm.mutexPLastTxMeInstance.Lock()
- defer oFsm.mutexPLastTxMeInstance.Unlock()
- meInstance := oFsm.pOmciCC.sendSetDot1PMapperVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetDot1PMapperVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "Dot1PMapperVar set failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ pConfigAniStateAFsm := oFsm.pAdaptFsm
+ if pConfigAniStateAFsm != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ // obviously calling some FSM event here directly does not work - so trying to decouple it ...
+ go func(aPAFsm *AdapterFsm) {
+ if aPAFsm != nil && aPAFsm.pFsm != nil {
+ _ = aPAFsm.pFsm.Event(aniEvReset)
+ }
+ }(pConfigAniStateAFsm)
+ return
+ }
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
+ oFsm.mutexPLastTxMeInstance.Unlock()
}
}
@@ -734,7 +797,7 @@
// obviously calling some FSM event here directly does not work - so trying to decouple it ...
go func(aPAFsm *AdapterFsm) {
if aPAFsm != nil && aPAFsm.pFsm != nil {
- _ = oFsm.pAdaptFsm.pFsm.Event(aniEvWaitFlowRem)
+ _ = aPAFsm.pFsm.Event(aniEvWaitFlowRem)
}
}(pConfigAniStateAFsm)
} else {
@@ -753,10 +816,25 @@
// this state entry is only expected in a suitable state (checked outside in onu_uni_tp)
oFsm.mutexPLastTxMeInstance.Lock()
- defer oFsm.mutexPLastTxMeInstance.Unlock()
- meInstance := oFsm.pOmciCC.sendDeleteGemIWTP(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendDeleteGemIWTP(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, loGemPortID)
+ if err != nil {
+ logger.Errorw(ctx, "GemIWTP delete failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ pConfigAniStateAFsm := oFsm.pAdaptFsm
+ if pConfigAniStateAFsm != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ // obviously calling some FSM event here directly does not work - so trying to decouple it ...
+ go func(aPAFsm *AdapterFsm) {
+ if aPAFsm != nil && aPAFsm.pFsm != nil {
+ _ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+ }
+ }(pConfigAniStateAFsm)
+ return
+ }
+ }
oFsm.pLastTxMeInstance = meInstance
+ oFsm.mutexPLastTxMeInstance.Unlock()
}
func (oFsm *uniPonAniConfigFsm) enterWaitingFlowRem(ctx context.Context, e *fsm.Event) {
@@ -779,7 +857,7 @@
// obviously calling some FSM event here directly does not work - so trying to decouple it ...
go func(aPAFsm *AdapterFsm) {
if aPAFsm != nil && aPAFsm.pFsm != nil {
- _ = oFsm.pAdaptFsm.pFsm.Event(aniEvFlowRemDone)
+ _ = aPAFsm.pFsm.Event(aniEvFlowRemDone)
}
}(pConfigAniStateAFsm)
} else {
@@ -800,7 +878,7 @@
// obviously calling some FSM event here directly does not work - so trying to decouple it ...
go func(aPAFsm *AdapterFsm) {
if aPAFsm != nil && aPAFsm.pFsm != nil {
- _ = oFsm.pAdaptFsm.pFsm.Event(aniEvFlowRemDone)
+ _ = aPAFsm.pFsm.Event(aniEvFlowRemDone)
}
}(pConfigAniStateAFsm)
} else {
@@ -838,10 +916,26 @@
"GemNCTP-entity-id": loGemPortID})
// this state entry is only expected in a suitable state (checked outside in onu_uni_tp)
oFsm.mutexPLastTxMeInstance.Lock()
- meInstance := oFsm.pOmciCC.sendDeleteGemNCTP(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendDeleteGemNCTP(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, loGemPortID)
+ if err != nil {
+ logger.Errorw(ctx, "GemNCTP delete failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ pConfigAniStateAFsm := oFsm.pAdaptFsm
+ if pConfigAniStateAFsm != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ // obviously calling some FSM event here directly does not work - so trying to decouple it ...
+ go func(aPAFsm *AdapterFsm) {
+ if aPAFsm != nil && aPAFsm.pFsm != nil {
+ _ = aPAFsm.pFsm.Event(aniEvReset)
+ }
+ }(pConfigAniStateAFsm)
+ return
+ }
+ }
oFsm.pLastTxMeInstance = meInstance
oFsm.mutexPLastTxMeInstance.Unlock()
+
// Mark the gem port to be removed for Performance History monitoring
if oFsm.pDeviceHandler.pOnuMetricsMgr != nil {
oFsm.pDeviceHandler.pOnuMetricsMgr.RemoveGemPortForPerfMonitoring(ctx, loGemPortID)
@@ -861,10 +955,26 @@
},
}
oFsm.mutexPLastTxMeInstance.Lock()
- defer oFsm.mutexPLastTxMeInstance.Unlock()
- meInstance := oFsm.pOmciCC.sendSetTcontVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetTcontVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "TcontVar set failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ pConfigAniStateAFsm := oFsm.pAdaptFsm
+ if pConfigAniStateAFsm != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ // obviously calling some FSM event here directly does not work - so trying to decouple it ...
+ go func(aPAFsm *AdapterFsm) {
+ if aPAFsm != nil && aPAFsm.pFsm != nil {
+ _ = aPAFsm.pFsm.Event(aniEvReset)
+ }
+ }(pConfigAniStateAFsm)
+ return
+ }
+ }
oFsm.pLastTxMeInstance = meInstance
+ oFsm.mutexPLastTxMeInstance.Unlock()
+
}
func (oFsm *uniPonAniConfigFsm) enterRemoving1pMapper(ctx context.Context, e *fsm.Event) {
@@ -872,10 +982,26 @@
"device-id": oFsm.deviceID, "uni-id": oFsm.pOnuUniPort.uniID})
oFsm.mutexPLastTxMeInstance.Lock()
- defer oFsm.mutexPLastTxMeInstance.Unlock()
- meInstance := oFsm.pOmciCC.sendDeleteDot1PMapper(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendDeleteDot1PMapper(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, oFsm.mapperSP0ID)
+ if err != nil {
+ logger.Errorw(ctx, "Dot1Mapper delete failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ pConfigAniStateAFsm := oFsm.pAdaptFsm
+ if pConfigAniStateAFsm != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ // obviously calling some FSM event here directly does not work - so trying to decouple it ...
+ go func(aPAFsm *AdapterFsm) {
+ if aPAFsm != nil && aPAFsm.pFsm != nil {
+ _ = aPAFsm.pFsm.Event(aniEvReset)
+ }
+ }(pConfigAniStateAFsm)
+ return
+ }
+ }
oFsm.pLastTxMeInstance = meInstance
+ oFsm.mutexPLastTxMeInstance.Unlock()
+
}
func (oFsm *uniPonAniConfigFsm) enterRemovingAniBPCD(ctx context.Context, e *fsm.Event) {
@@ -883,10 +1009,25 @@
"device-id": oFsm.deviceID, "uni-id": oFsm.pOnuUniPort.uniID})
oFsm.mutexPLastTxMeInstance.Lock()
- defer oFsm.mutexPLastTxMeInstance.Unlock()
- meInstance := oFsm.pOmciCC.sendDeleteMBPConfigData(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendDeleteMBPConfigData(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, oFsm.macBPCD0ID)
+ if err != nil {
+ logger.Errorw(ctx, "MBPConfigData delete failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ pConfigAniStateAFsm := oFsm.pAdaptFsm
+ if pConfigAniStateAFsm != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ // obviously calling some FSM event here directly does not work - so trying to decouple it ...
+ go func(aPAFsm *AdapterFsm) {
+ if aPAFsm != nil && aPAFsm.pFsm != nil {
+ _ = aPAFsm.pFsm.Event(aniEvReset)
+ }
+ }(pConfigAniStateAFsm)
+ return
+ }
+ }
oFsm.pLastTxMeInstance = meInstance
+ oFsm.mutexPLastTxMeInstance.Unlock()
}
func (oFsm *uniPonAniConfigFsm) enterAniRemoveDone(ctx context.Context, e *fsm.Event) {
@@ -1220,15 +1361,21 @@
},
}
oFsm.mutexPLastTxMeInstance.Lock()
- meInstance := oFsm.pOmciCC.sendCreateGemNCTPVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendCreateGemNCTPVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ logger.Errorw(ctx, "GemNCTPVar create failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
oFsm.mutexPLastTxMeInstance.Unlock()
-
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "GemNWCtp create failed, aborting AniConfig FSM!",
log.Fields{"device-id": oFsm.deviceID, "GemIndex": gemIndex})
@@ -1267,14 +1414,22 @@
},
}
oFsm.mutexPLastTxMeInstance.Lock()
- meInstance := oFsm.pOmciCC.sendCreateMulticastGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
+ meInstance, err := oFsm.pOmciCC.sendCreateMulticastGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
true, oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ logger.Errorw(ctx, "MulticastGemIWTPVar create failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+ return
+
+ }
oFsm.pLastTxMeInstance = meInstance
oFsm.mutexPLastTxMeInstance.Unlock()
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
- logger.Errorw(ctx, "GemTP IW multicast create failed, aborting AniConfig FSM!",
+ logger.Errorw(ctx, "MulticastGemIWTP create failed, aborting AniConfig FSM!",
log.Fields{"device-id": oFsm.deviceID, "GemIndex": gemIndex})
_ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
return
@@ -1296,8 +1451,15 @@
},
}
oFsm.mutexPLastTxMeInstance.Lock()
- meIPV4MCTableInstance := oFsm.pOmciCC.sendSetMulticastGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
+ meIPV4MCTableInstance, err := oFsm.pOmciCC.sendSetMulticastGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
true, oFsm.pAdaptFsm.commChan, meIPV4MCTableParams)
+ if err != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ logger.Errorw(ctx, "MulticastGemIWTPVar set failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+ return
+ }
oFsm.pLastTxMeInstance = meIPV4MCTableInstance
oFsm.mutexPLastTxMeInstance.Unlock()
@@ -1313,8 +1475,15 @@
},
}
oFsm.mutexPLastTxMeInstance.Lock()
- meInstance := oFsm.pOmciCC.sendCreateGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendCreateGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ logger.Errorw(ctx, "GEMIWTPVar create failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
@@ -1389,15 +1558,22 @@
meParams.Attributes["Weight"] = uint8(kv.Value.(uint16))
}
oFsm.mutexPLastTxMeInstance.Lock()
- meInstance := oFsm.pOmciCC.sendSetPrioQueueVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetPrioQueueVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ oFsm.mutexPLastTxMeInstance.Unlock()
+ logger.Errorw(ctx, "PrioQueueVar set failed, aborting uniPonAniConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
oFsm.mutexPLastTxMeInstance.Unlock()
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "PrioQueue set failed, aborting AniConfig FSM!",
log.Fields{"device-id": oFsm.deviceID, "QueueId": strconv.FormatInt(int64(queueIndex), 16)})
diff --git a/internal/pkg/onuadaptercore/omci_cc.go b/internal/pkg/onuadaptercore/omci_cc.go
index 58082a3..d66ca20 100644
--- a/internal/pkg/onuadaptercore/omci_cc.go
+++ b/internal/pkg/onuadaptercore/omci_cc.go
@@ -830,7 +830,7 @@
return oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
}
-func (oo *omciCC) sendCreateGalEthernetProfile(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
+func (oo *omciCC) sendCreateGalEthernetProfile(ctx context.Context, timeout int, highPrio bool) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send GalEnetProfile-Create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16)})
@@ -846,14 +846,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode GalEnetProfileInstance for create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize GalEnetProfile create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -864,18 +864,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send GalEnetProfile create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send GalEnetProfile-Create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate GalEnetProfileInstance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
// might be needed to extend for parameter arguments, here just for setting the ConnectivityMode!!
-func (oo *omciCC) sendSetOnu2g(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
+func (oo *omciCC) sendSetOnu2g(ctx context.Context, timeout int, highPrio bool) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send ONU2-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16)})
@@ -894,14 +894,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode ONU2-G instance for set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize ONU2-G set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -912,18 +912,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send ONU2-G set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send ONU2-G-Set-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate ONU2-G", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateMBServiceProfile(ctx context.Context,
- aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
+ aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
logger.Debugw(ctx, "send MBSP-Create-msg:", log.Fields{"device-id": oo.deviceID,
@@ -948,14 +948,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode MBSP for create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize MBSP create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -966,18 +966,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send MBSP create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send MBSP-Create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate MBSP Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateMBPConfigData(ctx context.Context,
- aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
+ aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
instID := macBridgePortAniEID + aPUniPort.entityID
logger.Debugw(ctx, "send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
@@ -1000,14 +1000,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode MBPCD for create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize MBPCD create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1018,18 +1018,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send MBPCD create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send MBPCD-Create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate MBPCD Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateEVTOConfigData(ctx context.Context,
- aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
+ aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
//same entityId is used as for MBSP (see there), but just arbitrary ...
instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
@@ -1057,14 +1057,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode EVTOCD for create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize EVTOCD create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1075,18 +1075,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send EVTOCD create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send EVTOCD-Create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendSetOnuGLS(ctx context.Context, timeout int,
- highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
+ highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send ONU-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16)})
@@ -1102,14 +1102,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode ONU-G instance for set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize ONU-G set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1120,18 +1120,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send ONU-G set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send ONU-G-Set-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate ONU-G", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendSetPptpEthUniLS(ctx context.Context, aInstNo uint16, timeout int,
- highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
+ highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send PPTPEthUni-Set-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16)})
@@ -1147,14 +1147,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode PPTPEthUni instance for set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize PPTPEthUni-Set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1165,14 +1165,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot send PPTPEthUni-Set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send PPTPEthUni-Set-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate PPTPEthUni", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
/* UniG obsolete by now, left here in case it should be needed once again
@@ -1224,7 +1224,7 @@
*/
func (oo *omciCC) sendSetVeipLS(ctx context.Context, aInstNo uint16, timeout int,
- highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
+ highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send VEIP-Set-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16)})
@@ -1240,14 +1240,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode VEIP instance for set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize VEIP-Set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1258,18 +1258,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send VEIP-Set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send VEIP-Set-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate VEIP", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendGetMe(ctx context.Context, classID me.ClassID, entityID uint16, requestedAttributes me.AttributeValueMap,
- timeout int, highPrio bool, rxChan chan Message) *me.ManagedEntity {
+ timeout int, highPrio bool, rxChan chan Message) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send get-request-msg", log.Fields{"classID": classID, "device-id": oo.deviceID,
@@ -1285,12 +1285,12 @@
omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.GetRequestType, omci.TransactionID(tid))
if err != nil {
logger.Errorf(ctx, "Cannot encode instance for get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
cbKey: tid,
@@ -1299,17 +1299,17 @@
err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
if err != nil {
logger.Errorw(ctx, "Cannot send get-request-msg", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debugw(ctx, "send get-request-msg done", log.Fields{"meClassIDName": meClassIDName, "device-id": oo.deviceID})
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate meDefinition", log.Fields{"classID": classID, "Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateDot1PMapper(ctx context.Context, timeout int, highPrio bool,
- aInstID uint16, rxChan chan Message) *me.ManagedEntity {
+ aInstID uint16, rxChan chan Message) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send .1pMapper-Create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(aInstID), 16)})
@@ -1337,14 +1337,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode .1pMapper for create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize .1pMapper create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1355,18 +1355,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send .1pMapper create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send .1pMapper-create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate .1pMapper", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateMBPConfigDataVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1380,14 +1380,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode MBPCD for create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize MBPCD create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1398,18 +1398,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send MBPCD create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send MBPCD-Create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate MBPCD Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateGemNCTPVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send GemNCTP-Create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1423,14 +1423,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode GemNCTP for create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize GemNCTP create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1441,18 +1441,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send GemNCTP create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send GemNCTP-Create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate GemNCTP Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send GemIwTp-Create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1466,14 +1466,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode GemIwTp for create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize GemIwTp create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1484,18 +1484,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send GemIwTp create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send GemIwTp-Create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate GemIwTp Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendSetTcontVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send TCont-Set-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1507,14 +1507,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode TCont for set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize TCont set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1525,18 +1525,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send TCont set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send TCont-set msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate TCont Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendSetPrioQueueVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send PrioQueue-Set-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1548,14 +1548,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode PrioQueue for set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize PrioQueue set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1566,18 +1566,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send PrioQueue set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send PrioQueue-set msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate PrioQueue Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendSetDot1PMapperVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send 1PMapper-Set-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1589,14 +1589,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode 1PMapper for set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize 1PMapper set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1607,18 +1607,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send 1PMapper set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send 1PMapper-set msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate 1PMapper Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateVtfdVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send VTFD-Create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1635,14 +1635,14 @@
//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
// return (dual format) error code that can be used at caller for immediate error treatment
// (relevant to all used sendXX() methods and their error conditions)
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize VTFD create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1653,19 +1653,19 @@
if err != nil {
logger.Errorw(ctx, "Cannot send VTFD create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send VTFD-Create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate VTFD Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
// nolint: unused
func (oo *omciCC) sendSetVtfdVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send VTFD-Set-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1681,14 +1681,14 @@
//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
// return (dual format) error code that can be used at caller for immediate error treatment
// (relevant to all used sendXX() methods and their error conditions)
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize VTFD set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1699,18 +1699,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send VTFD set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send VTFD-Set-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate VTFD Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateEvtocdVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send EVTOCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1722,14 +1722,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode EVTOCD for create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize EVTOCD create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1740,18 +1740,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send EVTOCD create", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send EVTOCD-set msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendSetEvtocdVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send EVTOCD-Set-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1763,14 +1763,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode EVTOCD for set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize EVTOCD set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1781,18 +1781,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send EVTOCD set", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send EVTOCD-set msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendDeleteEvtocd(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send EVTOCD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1804,14 +1804,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode EVTOCD for delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize EVTOCD delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1822,18 +1822,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send EVTOCD delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send EVTOCD-delete msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendDeleteVtfd(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+ rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send VTFD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1850,14 +1850,14 @@
//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
// return (dual format) error code that can be used at caller for immediate error treatment
// (relevant to all used sendXX() methods and their error conditions)
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize VTFD delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -1868,19 +1868,19 @@
if err != nil {
logger.Errorw(ctx, "Cannot send VTFD delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send VTFD-Delete-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate VTFD Instance for delete", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
// nolint: unused
func (oo *omciCC) sendCreateTDVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send TD-Create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1890,12 +1890,12 @@
omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
if err != nil {
logger.Errorw(ctx, "Cannot encode TD for create", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize TD create", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
cbKey: tid,
@@ -1904,18 +1904,18 @@
err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
if err != nil {
logger.Errorw(ctx, "Cannot send TD create", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send TD-Create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
// nolint: unused
func (oo *omciCC) sendSetTDVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send TD-Set-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1926,12 +1926,12 @@
omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
if err != nil {
logger.Errorw(ctx, "Cannot encode TD for set", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize TD set", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
cbKey: tid,
@@ -1940,19 +1940,19 @@
err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
if err != nil {
logger.Errorw(ctx, "Cannot send TD set", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send TD-Set-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
// nolint: unused
func (oo *omciCC) sendDeleteTD(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+ rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send TD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1964,12 +1964,12 @@
omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid))
if err != nil {
logger.Errorw(ctx, "Cannot encode TD for delete", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize TD delete", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
cbKey: tid,
@@ -1978,18 +1978,18 @@
err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
if err != nil {
logger.Errorw(ctx, "Cannot send TD delete", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send TD-Delete-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendDeleteGemIWTP(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+ rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send GemIwTp-Delete-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2006,14 +2006,14 @@
//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
// return (dual format) error code that can be used at caller for immediate error treatment
// (relevant to all used sendXX() methods and their error conditions)
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize GemIwTp delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -2024,18 +2024,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send GemIwTp delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send GemIwTp-Delete-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate GemIwTp Instance for delete", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendDeleteGemNCTP(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+ rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send GemNCtp-Delete-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2052,14 +2052,14 @@
//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
// return (dual format) error code that can be used at caller for immediate error treatment
// (relevant to all used sendXX() methods and their error conditions)
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize GemNCtp delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -2070,18 +2070,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send GemNCtp delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send GemNCtp-Delete-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate GemNCtp Instance for delete", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendDeleteDot1PMapper(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+ rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send .1pMapper-Delete-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2098,14 +2098,14 @@
//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
// return (dual format) error code that can be used at caller for immediate error treatment
// (relevant to all used sendXX() methods and their error conditions)
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize .1pMapper delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -2116,18 +2116,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send .1pMapper delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send .1pMapper-Delete-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate .1pMapper Instance for delete", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendDeleteMBPConfigData(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+ rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send MBPCD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2144,14 +2144,14 @@
//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
// return (dual format) error code that can be used at caller for immediate error treatment
// (relevant to all used sendXX() methods and their error conditions)
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize MBPCD delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{
@@ -2162,18 +2162,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send MBPCD delete", log.Fields{
"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send MBPCD-Delete-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate MBPCD Instance for delete", log.Fields{
"Err": omciErr.GetError(), "device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateMulticastGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send MulticastGemIWTP-create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2185,13 +2185,13 @@
omci.AddDefaults(true))
if err != nil {
logger.Errorw(ctx, "Cannot encode MulticastGEMIWTP for create", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2200,18 +2200,18 @@
err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
if err != nil {
logger.Errorw(ctx, "Cannot send MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send MulticastGEMIWTP-create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate MulticastGEMIWTP Instance", log.Fields{"Err": omciErr.GetError(),
"device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendSetMulticastGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send MulticastGemIWTP-set-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2223,13 +2223,13 @@
omci.AddDefaults(true))
if err != nil {
logger.Errorw(ctx, "Cannot encode MulticastGEMIWTP for set", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2238,18 +2238,18 @@
err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
if err != nil {
logger.Errorw(ctx, "Cannot send MulticastGEMIWTP set", log.Fields{"Err": err, "device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send MulticastGEMIWTP-set-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate MulticastGEMIWTP Instance", log.Fields{"Err": omciErr.GetError(),
"device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2262,14 +2262,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
"device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
"device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2279,18 +2279,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
"device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send MulticastOperationProfile-create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
"device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendSetMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2303,14 +2303,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
"device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
"device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2320,18 +2320,18 @@
if err != nil {
logger.Errorw(ctx, "Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
"device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send MulticastOperationProfile-create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
"device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateMulticastSubConfigInfoVar(ctx context.Context, timeout int, highPrio bool,
- rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+ rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send MulticastSubConfigInfo-create-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2344,14 +2344,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode MulticastSubConfigInfo for create", log.Fields{"Err": err,
"device-id": oo.deviceID})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize MulticastSubConfigInfo create", log.Fields{"Err": err,
"device-id": oo.deviceID})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2361,14 +2361,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot send MulticastSubConfigInfo create", log.Fields{"Err": err,
"device-id": oo.deviceID})
- return nil
+ return nil, err
}
logger.Debug(ctx, "send MulticastSubConfigInfo-create-msg done")
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate MulticastSubConfigInfo Instance", log.Fields{"Err": omciErr.GetError(),
"device-id": oo.deviceID})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendSyncTime(ctx context.Context, timeout int, highPrio bool, rxChan chan Message) error {
@@ -2417,7 +2417,7 @@
}
func (oo *omciCC) sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(ctx context.Context, timeout int, highPrio bool,
- upstream bool, create bool, rxChan chan Message, entityID uint16) *me.ManagedEntity {
+ upstream bool, create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send ethernet-performance-monitoring-history-me-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create, "upstream": upstream})
@@ -2443,14 +2443,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode ethernet frame performance monitoring history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize ethernet frame performance monitoring history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2460,19 +2460,19 @@
if err != nil {
logger.Errorw(ctx, "Cannot send ethernet frame performance monitoring history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
logger.Debugw(ctx, "send ethernet frame performance monitoring history data ME done",
log.Fields{"device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate ethernet frame performance monitoring history data ME Instance",
log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateOrDeleteEthernetUniHistoryME(ctx context.Context, timeout int, highPrio bool,
- create bool, rxChan chan Message, entityID uint16) *me.ManagedEntity {
+ create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send ethernet-uni-history-me-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
@@ -2495,14 +2495,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode ethernet uni history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize ethernet uni history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2512,19 +2512,19 @@
if err != nil {
logger.Errorw(ctx, "Cannot send ethernet uni history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
logger.Debugw(ctx, "send ethernet uni history data ME done",
log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate ethernet uni history data ME Instance",
log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateOrDeleteFecHistoryME(ctx context.Context, timeout int, highPrio bool,
- create bool, rxChan chan Message, entityID uint16) *me.ManagedEntity {
+ create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send fec-history-me-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
@@ -2547,14 +2547,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode fec history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize fec history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2564,19 +2564,19 @@
if err != nil {
logger.Errorw(ctx, "Cannot send fec history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
logger.Debugw(ctx, "send fec history data ME done",
log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate fec history data ME Instance",
log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendCreateOrDeleteGemPortHistoryME(ctx context.Context, timeout int, highPrio bool,
- create bool, rxChan chan Message, entityID uint16) *me.ManagedEntity {
+ create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
logger.Debugw(ctx, "send gemport-history-me-msg:", log.Fields{"device-id": oo.deviceID,
"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
@@ -2599,14 +2599,14 @@
if err != nil {
logger.Errorw(ctx, "Cannot encode gemport history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
if err != nil {
logger.Errorw(ctx, "Cannot serialize gemport history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2616,15 +2616,15 @@
if err != nil {
logger.Errorw(ctx, "Cannot send gemport history data ME",
log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, err
}
logger.Debugw(ctx, "send gemport history data ME done",
log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return meInstance
+ return meInstance, nil
}
logger.Errorw(ctx, "Cannot generate gemport history data ME Instance",
log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
- return nil
+ return nil, omciErr.GetError()
}
func (oo *omciCC) sendStartSoftwareDownload(ctx context.Context, timeout int, highPrio bool,
diff --git a/internal/pkg/onuadaptercore/omci_onu_upgrade.go b/internal/pkg/onuadaptercore/omci_onu_upgrade.go
index 0158977..58e78a4 100644
--- a/internal/pkg/onuadaptercore/omci_onu_upgrade.go
+++ b/internal/pkg/onuadaptercore/omci_onu_upgrade.go
@@ -536,10 +536,21 @@
logger.Infow(ctx, "OnuUpgradeFsm checking committed SW", log.Fields{
"device-id": oFsm.deviceID, "me-id": oFsm.inactiveImageMeID})
requestedAttributes := me.AttributeValueMap{"IsCommitted": 0, "IsActive": 0, "Version": ""}
- meInstance := oFsm.pOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
+ meInstance, err := oFsm.pOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
me.SoftwareImageClassID, oFsm.inactiveImageMeID, requestedAttributes, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, false, oFsm.pAdaptFsm.commChan)
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
+ if err != nil {
+ logger.Errorw(ctx, "OnuUpgradeFsm get Software Image ME result error",
+ log.Fields{"device-id": oFsm.deviceID, "Error": err})
+ pOnuUpgradeFsm := oFsm.pAdaptFsm
+ if pOnuUpgradeFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ _ = a_pAFsm.pFsm.Event(upgradeEvReset)
+ }(pOnuUpgradeFsm)
+ }
+ return
+ }
oFsm.pLastTxMeInstance = meInstance
}
diff --git a/internal/pkg/onuadaptercore/omci_vlan_config.go b/internal/pkg/onuadaptercore/omci_vlan_config.go
index cb010c9..1fc9a5c 100644
--- a/internal/pkg/onuadaptercore/omci_vlan_config.go
+++ b/internal/pkg/onuadaptercore/omci_vlan_config.go
@@ -965,8 +965,19 @@
}
logger.Debugw(ctx, "UniVlanConfigFsm sendcreate VTFD", log.Fields{
"in state": e.FSM.Current(), "device-id": oFsm.deviceID})
- meInstance := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "VTFD create failed, aborting UniVlanConfig FSM!",
+ log.Fields{"device-id": oFsm.deviceID})
+ pConfigVlanStateAFsm := oFsm.pAdaptFsm
+ if pConfigVlanStateAFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ _ = a_pAFsm.pFsm.Event(vlanEvReset)
+ }(pConfigVlanStateAFsm)
+ }
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
@@ -1134,8 +1145,19 @@
"NumberOfEntries": oFsm.numVlanFilterEntries,
},
}
- meInstance := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "VTFD create failed, aborting UniVlanConfig FSM!",
+ log.Fields{"device-id": oFsm.deviceID})
+ pConfigVlanStateAFsm := oFsm.pAdaptFsm
+ if pConfigVlanStateAFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ _ = a_pAFsm.pFsm.Event(vlanEvReset)
+ }(pConfigVlanStateAFsm)
+ }
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
@@ -1170,8 +1192,14 @@
"NumberOfEntries": oFsm.numVlanFilterEntries,
},
}
- meInstance := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "UniVlanFsm create Vlan Tagging Filter ME result error",
+ log.Fields{"device-id": oFsm.deviceID, "Error": err})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
@@ -1257,8 +1285,14 @@
"in state": e.FSM.Current(), "device-id": oFsm.deviceID})
loVlanEntryClear = 1 //full VlanFilter clear request
if loAllowSpecificOmciConfig { //specific OMCI config is expected to work acc. to the device state
- meInstance := oFsm.pOmciCC.sendDeleteVtfd(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendDeleteVtfd(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, vtfdID)
+ if err != nil {
+ logger.Errorw(ctx, "UniVlanFsm delete Vlan Tagging Filter ME result error",
+ log.Fields{"device-id": oFsm.deviceID, "Error": err})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return
+ }
oFsm.pLastTxMeInstance = meInstance
} else {
logger.Debugw(ctx, "UniVlanConfigFsm delete VTFD OMCI handling skipped based on device state", log.Fields{
@@ -1295,8 +1329,14 @@
if loAllowSpecificOmciConfig { //specific OMCI config is expected to work acc. to the device state
// FIXME: VOL-3685: Issues with resetting a table entry in EVTOCD ME
- meInstance := oFsm.pOmciCC.sendDeleteVtfd(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendDeleteVtfd(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, vtfdID)
+ if err != nil {
+ logger.Errorw(ctx, "UniVlanFsm delete Vlan Tagging Filter ME result error",
+ log.Fields{"device-id": oFsm.deviceID, "Error": err})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return
+ }
oFsm.pLastTxMeInstance = meInstance
} else {
logger.Debugw(ctx, "UniVlanConfigFsm set VTFD OMCI handling skipped based on device state", log.Fields{
@@ -1660,14 +1700,20 @@
"AssociatedMePointer": oFsm.pOnuUniPort.entityID,
},
}
- meInstance := oFsm.pOmciCC.sendCreateEvtocdVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
- oFsm.pAdaptFsm.commChan, meParams)
+ meInstance, err := oFsm.pOmciCC.sendCreateEvtocdVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
+ true, oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "CreateEvtocdVar create failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return fmt.Errorf("evtocd instance create failed %s, error %s", oFsm.deviceID, err)
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "Evtocd create failed, aborting VlanConfig FSM!",
log.Fields{"device-id": oFsm.deviceID})
@@ -1684,8 +1730,15 @@
"DownstreamMode": uint8(cDefaultDownstreamMode),
},
}
- meInstance = oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err = oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return fmt.Errorf("evtocd instance set failed %s, error %s", oFsm.deviceID, err)
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
@@ -1736,14 +1789,21 @@
"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
},
}
- meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return fmt.Errorf("evtocd instance set failed %s, error %s", oFsm.deviceID, err)
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "Evtocd set transparent singletagged rule failed, aborting VlanConfig FSM!",
log.Fields{"device-id": oFsm.deviceID})
@@ -1792,14 +1852,21 @@
"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
},
}
- meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return fmt.Errorf("evtocd instance set failed %s, error %s", oFsm.deviceID, err)
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "Evtocd set singletagged translation rule failed, aborting VlanConfig FSM!",
log.Fields{"device-id": oFsm.deviceID})
@@ -1844,14 +1911,21 @@
"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
},
}
- meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return fmt.Errorf("evtocd instance set failed %s, error %s", oFsm.deviceID, err)
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "Evtocd set untagged->singletagged rule failed, aborting VlanConfig FSM!",
log.Fields{"device-id": oFsm.deviceID})
@@ -1897,14 +1971,21 @@
"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
},
}
- meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return fmt.Errorf("evtocd instance set failed %s, error %s", oFsm.deviceID, err)
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "Evtocd set priotagged->singletagged rule failed, aborting VlanConfig FSM!",
log.Fields{"device-id": oFsm.deviceID})
@@ -1960,14 +2041,21 @@
"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
},
}
- meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "Evtocd reset singletagged rule failed, aborting VlanConfig FSM!",
log.Fields{"device-id": oFsm.deviceID})
@@ -2003,14 +2091,21 @@
"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
},
}
- meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "Evtocd clear singletagged translation rule failed, aborting VlanConfig FSM!",
log.Fields{"device-id": oFsm.deviceID, "match-vlan": aRuleParams.MatchVid})
@@ -2035,14 +2130,21 @@
meParams := me.ParamData{
EntityID: oFsm.evtocdID,
}
- meInstance := oFsm.pOmciCC.sendDeleteEvtocd(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendDeleteEvtocd(log.WithSpanFromContext(context.TODO(), ctx),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "DeleteEvtocdVar delete failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "Evtocd delete rule failed, aborting VlanConfig FSM!",
log.Fields{"device-id": oFsm.deviceID})
@@ -2093,14 +2195,21 @@
"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
},
}
- meInstance := oFsm.pOmciCC.sendSetEvtocdVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(context.TODO(),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "Evtocd reset untagged rule to default failed, aborting VlanConfig FSM!",
log.Fields{"device-id": oFsm.deviceID})
@@ -2135,14 +2244,21 @@
"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
},
}
- meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
//verify response
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "Evtocd delete priotagged rule failed, aborting VlanConfig FSM!",
log.Fields{"device-id": oFsm.deviceID})
@@ -2232,12 +2348,18 @@
"TpPointer": multicastGemPortID,
},
}
- meInstance := oFsm.pOmciCC.sendCreateMBPConfigDataVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
- oFsm.pAdaptFsm.commChan, meParams)
+ meInstance, err := oFsm.pOmciCC.sendCreateMBPConfigDataVar(context.TODO(),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "MBPConfigDataVar create failed, aborting AniConfig FSM!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return fmt.Errorf("creatingMulticastSubscriberConfigInfo createError #{oFsm.deviceID}, error #{err}")
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
- err := oFsm.waitforOmciResponse(ctx)
+ err = oFsm.waitforOmciResponse(ctx)
if err != nil {
logger.Errorw(ctx, "CreateMBPConfigData failed, aborting AniConfig FSM!",
log.Fields{"device-id": oFsm.deviceID, "MBPConfigDataID": macBridgeServiceProfileEID})
@@ -2269,8 +2391,14 @@
"NumberOfEntries": oFsm.numVlanFilterEntries,
},
}
- meInstance = oFsm.pOmciCC.sendCreateVtfdVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
- oFsm.pAdaptFsm.commChan, meParams)
+ meInstance, err = oFsm.pOmciCC.sendCreateVtfdVar(context.TODO(),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "CreateVtfdVar create failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return fmt.Errorf("createMcastVlanFilterData creationError %s, error %s", oFsm.deviceID, err)
+ }
oFsm.pLastTxMeInstance = meInstance
err = oFsm.waitforOmciResponse(ctx)
if err != nil {
@@ -2300,8 +2428,16 @@
"MulticastOperationsProfilePointer": instID,
},
}
- meInstance := oFsm.pOmciCC.sendCreateMulticastSubConfigInfoVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendCreateMulticastSubConfigInfoVar(context.TODO(),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "CreateMulticastSubConfigInfoVar create failed, aborting UniVlanConfigFSM!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return fmt.Errorf("creatingMulticastSubscriberConfigInfo interface creationError %s, error %s",
+ oFsm.deviceID, err)
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
@@ -2339,8 +2475,15 @@
"UnauthorizedJoinBehaviour": 0,
},
}
- meInstance := oFsm.pOmciCC.sendCreateMulticastOperationProfileVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendCreateMulticastOperationProfileVar(context.TODO(),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "CreateMulticastOperationProfileVar create failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return fmt.Errorf("createMulticastOperationProfileVar responseError %s, error %s", oFsm.deviceID, err)
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
@@ -2349,7 +2492,7 @@
if err != nil {
logger.Errorw(ctx, "CreateMulticastOperationProfile create failed, aborting AniConfig FSM!",
log.Fields{"device-id": oFsm.deviceID, "MulticastOperationProfileID": instID})
- return fmt.Errorf("createMulticastOperationProfile responseError %s", oFsm.deviceID)
+ return fmt.Errorf("createMulticastOperationProfile responseError %s, error %s", oFsm.deviceID, err)
}
return nil
}
@@ -2393,8 +2536,15 @@
"DynamicAccessControlListTable": dynamicAccessCL,
},
}
- meInstance := oFsm.pOmciCC.sendSetMulticastOperationProfileVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetMulticastOperationProfileVar(context.TODO(),
+ oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
oFsm.pAdaptFsm.commChan, meParams)
+ if err != nil {
+ logger.Errorw(ctx, "SetMulticastOperationProfileVar set failed, aborting UniVlanConfigFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ return fmt.Errorf("setMulticastOperationProfile responseError %s, error %s", oFsm.deviceID, err)
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
@@ -2403,7 +2553,7 @@
if err != nil {
logger.Errorw(ctx, "CreateMulticastOperationProfile create failed, aborting AniConfig FSM!",
log.Fields{"device-id": oFsm.deviceID, "MulticastOperationProfileID": instID})
- return fmt.Errorf("createMulticastOperationProfile responseError %s", oFsm.deviceID)
+ return fmt.Errorf("createMulticastOperationProfile responseError %s, error %s", oFsm.deviceID, err)
}
return nil
}
diff --git a/internal/pkg/onuadaptercore/onu_metrics_manager.go b/internal/pkg/onuadaptercore/onu_metrics_manager.go
index 80882f6..59118ce 100644
--- a/internal/pkg/onuadaptercore/onu_metrics_manager.go
+++ b/internal/pkg/onuadaptercore/onu_metrics_manager.go
@@ -579,7 +579,12 @@
func (mm *onuMetricsManager) collectAllGroupMetrics(ctx context.Context) {
go func() {
logger.Debug(ctx, "startCollector before collecting optical metrics")
- metricInfo := mm.collectOpticalMetrics(ctx)
+ metricInfo, err := mm.collectOpticalMetrics(ctx)
+ if err != nil {
+ logger.Errorw(ctx, "collectOpticalMetrics failed",
+ log.Fields{"device-id": mm.pAdaptFsm.deviceID, "Error": err})
+ return
+ }
if metricInfo != nil {
mm.publishMetrics(ctx, metricInfo)
}
@@ -587,7 +592,12 @@
go func() {
logger.Debug(ctx, "startCollector before collecting uni metrics")
- metricInfo := mm.collectUniStatusMetrics(ctx)
+ metricInfo, err := mm.collectUniStatusMetrics(ctx)
+ if err != nil {
+ logger.Errorw(ctx, "collectOpticalMetrics failed",
+ log.Fields{"device-id": mm.pAdaptFsm.deviceID, "Error": err})
+ return
+ }
if metricInfo != nil {
mm.publishMetrics(ctx, metricInfo)
}
@@ -604,13 +614,13 @@
switch groupName {
case OpticalPowerGroupMetricName:
go func() {
- if mi := mm.collectOpticalMetrics(ctx); mm != nil {
+ if mi, _ := mm.collectOpticalMetrics(ctx); mi != nil {
mm.publishMetrics(ctx, mi)
}
}()
case UniStatusGroupMetricName:
go func() {
- if mi := mm.collectUniStatusMetrics(ctx); mm != nil {
+ if mi, _ := mm.collectUniStatusMetrics(ctx); mi != nil {
mm.publishMetrics(ctx, mi)
}
}()
@@ -628,14 +638,14 @@
}
// collectOpticalMetrics collects groups metrics related to optical power from ani-g ME.
-func (mm *onuMetricsManager) collectOpticalMetrics(ctx context.Context) []*voltha.MetricInformation {
+func (mm *onuMetricsManager) collectOpticalMetrics(ctx context.Context) ([]*voltha.MetricInformation, error) {
logger.Debugw(ctx, "collectOpticalMetrics", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
mm.onuMetricsManagerLock.RLock()
if !mm.groupMetricMap[OpticalPowerGroupMetricName].enabled {
mm.onuMetricsManagerLock.RUnlock()
logger.Debugw(ctx, "optical power group metric is not enabled", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
- return nil
+ return nil, nil
}
mm.onuMetricsManagerLock.RUnlock()
@@ -663,7 +673,14 @@
opticalMetrics := make(map[string]float32)
// Get the ANI-G instance optical power attributes
requestedAttributes := me.AttributeValueMap{"OpticalSignalLevel": 0, "TransmitOpticalLevel": 0}
- if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.AniGClassID, anigInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+ meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.AniGClassID, anigInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "GetMe failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return nil, err
+ }
+
+ if meInstance != nil {
select {
case meAttributes = <-mm.opticalMetricsChan:
logger.Debugw(ctx, "received optical metrics", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
@@ -698,18 +715,18 @@
metricInfoSlice = append(metricInfoSlice, &metricInfo)
}
- return metricInfoSlice
+ return metricInfoSlice, nil
}
// collectUniStatusMetrics collects UNI status group metric from various MEs (uni-g, pptp and veip).
// nolint: gocyclo
-func (mm *onuMetricsManager) collectUniStatusMetrics(ctx context.Context) []*voltha.MetricInformation {
+func (mm *onuMetricsManager) collectUniStatusMetrics(ctx context.Context) ([]*voltha.MetricInformation, error) {
logger.Debugw(ctx, "collectUniStatusMetrics", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
mm.onuMetricsManagerLock.RLock()
if !mm.groupMetricMap[UniStatusGroupMetricName].enabled {
mm.onuMetricsManagerLock.RUnlock()
logger.Debugw(ctx, "uni status group metric is not enabled", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
- return nil
+ return nil, nil
}
mm.onuMetricsManagerLock.RUnlock()
@@ -739,7 +756,13 @@
var meAttributes me.AttributeValueMap
// Get the UNI-G instance optical power attributes
requestedAttributes := me.AttributeValueMap{"AdministrativeState": 0}
- if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.UniGClassID, unigInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+ meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.UniGClassID, unigInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "UNI-G failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return nil, err
+ }
+ if meInstance != nil {
// Wait for metrics or timeout
select {
case meAttributes = <-mm.uniStatusMetricsChan:
@@ -789,7 +812,13 @@
pptpMetrics := make(map[string]float32)
requestedAttributes := me.AttributeValueMap{"SensedType": 0, "OperationalState": 0, "AdministrativeState": 0}
- if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.PhysicalPathTerminationPointEthernetUniClassID, pptpInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+ meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.PhysicalPathTerminationPointEthernetUniClassID, pptpInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "GetMe failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return nil, err
+ }
+ if meInstance != nil {
// Wait for metrics or timeout
select {
case meAttributes = <-mm.uniStatusMetricsChan:
@@ -848,7 +877,13 @@
veipMetrics := make(map[string]float32)
requestedAttributes := me.AttributeValueMap{"OperationalState": 0, "AdministrativeState": 0}
- if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.VirtualEthernetInterfacePointClassID, veipInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+ meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.VirtualEthernetInterfacePointClassID, veipInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "GetMe failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return nil, err
+ }
+ if meInstance != nil {
// Wait for metrics or timeout
select {
case meAttributes = <-mm.uniStatusMetricsChan:
@@ -894,7 +929,7 @@
metricInfoSlice = append(metricInfoSlice, &metricInfo)
}
- return metricInfoSlice
+ return metricInfoSlice, nil
}
// publishMetrics publishes the metrics on kafka
@@ -1260,7 +1295,7 @@
}
// nolint: gocyclo
-func (mm *onuMetricsManager) l2PmFsmCreatePM(ctx context.Context, e *fsm.Event) {
+func (mm *onuMetricsManager) l2PmFsmCreatePM(ctx context.Context, e *fsm.Event) error {
// Copy the l2PmToAdd for which we want to collect the metrics since l2PmToAdd can change dynamically
mm.onuMetricsManagerLock.RLock()
copyOfL2PmToAdd := make([]string, len(mm.l2PmToAdd))
@@ -1285,8 +1320,20 @@
inner1:
// retry L2PmCreateAttempts times to create the instance of PM
for cnt = 0; cnt < L2PmCreateAttempts; cnt++ {
- mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(
+ _, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(
ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, direction, true, mm.pAdaptFsm.commChan, entityID)
+ if err != nil {
+ logger.Errorw(ctx, "EthernetPerformanceMonitoringHistoryME create or delete failed, failure PM FSM!",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ pPMFsm := mm.pAdaptFsm
+ if pPMFsm != nil {
+ go func(p_pmFsm *AdapterFsm) {
+ _ = p_pmFsm.pFsm.Event(l2PmEventFailure)
+ }(pPMFsm)
+ }
+ return fmt.Errorf(fmt.Sprintf("CreateOrDeleteEthernetPerformanceMonitoringHistoryMe-failed-%s-%s",
+ mm.pDeviceHandler.deviceID, err))
+ }
if resp = mm.waitForResponseOrTimeout(ctx, true, entityID, "EthernetFramePerformanceMonitoringHistoryData"); resp {
atLeastOneSuccess = true
_ = mm.updatePmData(ctx, n, entityID, cPmAdded) // TODO: ignore error for now
@@ -1307,8 +1354,15 @@
inner2:
// retry L2PmCreateAttempts times to create the instance of PM
for cnt = 0; cnt < L2PmCreateAttempts; cnt++ {
- mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetUniHistoryME(
+ _, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetUniHistoryME(
ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, true, mm.pAdaptFsm.commChan, entityID)
+ if err != nil {
+ logger.Errorw(ctx, "CreateOrDeleteEthernetUNIHistoryME failed, failure PM FSM!",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return fmt.Errorf(fmt.Sprintf("CreateOrDeleteEthernetUniHistoryMe-failed-%s-%s",
+ mm.pDeviceHandler.deviceID, err))
+ }
if resp = mm.waitForResponseOrTimeout(ctx, true, entityID, "EthernetPerformanceMonitoringHistoryData"); resp {
atLeastOneSuccess = true
_ = mm.updatePmData(ctx, n, entityID, cPmAdded) // TODO: ignore error for now
@@ -1323,8 +1377,15 @@
case FecHistoryName:
for _, anigInstID := range mm.pDeviceHandler.pOnuOmciDevice.pOnuDB.getSortedInstKeys(ctx, me.AniGClassID) {
// Attach the FecPerformanceMonitoringHistoryData ME to the ANI-G ME instance
- mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteFecHistoryME(
+ _, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteFecHistoryME(
ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, true, mm.pAdaptFsm.commChan, anigInstID)
+ if err != nil {
+ logger.Errorw(ctx, "CreateOrDeleteFecHistoryME failed, failure PM FSM!",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return fmt.Errorf(fmt.Sprintf("CreateOrDeleteFecHistoryMe-failed-%s-%s",
+ mm.pDeviceHandler.deviceID, err))
+ }
_ = mm.updatePmData(ctx, n, anigInstID, cPmAdd) // TODO: ignore error for now
inner3:
// retry L2PmCreateAttempts times to create the instance of PM
@@ -1357,8 +1418,15 @@
}
for _, v := range copyOfGemPortInstIDsToAdd {
- mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteGemPortHistoryME(
+ _, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteGemPortHistoryME(
ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, true, mm.pAdaptFsm.commChan, v)
+ if err != nil {
+ logger.Errorw(ctx, "CreateOrDeleteGemPortHistoryME failed, failure PM FSM!",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return fmt.Errorf(fmt.Sprintf("CreateOrDeleteGemPortHistoryMe-failed-%s-%s",
+ mm.pDeviceHandler.deviceID, err))
+ }
_ = mm.updatePmData(ctx, n, v, cPmAdd) // TODO: ignore error for now
inner4:
// retry L2PmCreateAttempts times to create the instance of PM
@@ -1411,10 +1479,11 @@
logger.Errorw(ctx, "error calling event", log.Fields{"device-id": mm.pDeviceHandler.deviceID, "err": err})
}
}()
+ return nil
}
// nolint: gocyclo
-func (mm *onuMetricsManager) l2PmFsmDeletePM(ctx context.Context, e *fsm.Event) {
+func (mm *onuMetricsManager) l2PmFsmDeletePM(ctx context.Context, e *fsm.Event) error {
// Copy the l2PmToDelete for which we want to collect the metrics since l2PmToDelete can change dynamically
mm.onuMetricsManagerLock.RLock()
copyOfL2PmToDelete := make([]string, len(mm.l2PmToDelete))
@@ -1453,8 +1522,20 @@
inner1:
// retry L2PmDeleteAttempts times to delete the instance of PM
for cnt = 0; cnt < L2PmDeleteAttempts; cnt++ {
- mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(
+ _, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(
ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, direction, false, mm.pAdaptFsm.commChan, entityID)
+ if err != nil {
+ logger.Errorw(ctx, "CreateOrDeleteEthernetPerformanceMonitoringHistoryME failed, failure PM FSM!",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ pPMFsm := mm.pAdaptFsm
+ if pPMFsm != nil {
+ go func(p_pmFsm *AdapterFsm) {
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ }(pPMFsm)
+ }
+ return fmt.Errorf(fmt.Sprintf("CreateOrDeleteEthernetPerformanceMonitoringHistoryMe-failed-%s-%s",
+ mm.pDeviceHandler.deviceID, err))
+ }
_ = mm.updatePmData(ctx, n, entityID, cPmRemove) // TODO: ignore error for now
if resp = mm.waitForResponseOrTimeout(ctx, false, entityID, "EthernetFramePerformanceMonitoringHistoryData"); !resp {
atLeastOneDeleteFailure = true
@@ -1473,8 +1554,21 @@
inner2:
// retry L2PmDeleteAttempts times to delete the instance of PM
for cnt = 0; cnt < L2PmDeleteAttempts; cnt++ {
- mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetUniHistoryME(
+ _, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetUniHistoryME(
ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, false, mm.pAdaptFsm.commChan, entityID)
+ if err != nil {
+ logger.Errorw(ctx, "CreateOrDeleteEthernetUniHistoryME failed, failure PM FSM!",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ pmFsm := mm.pAdaptFsm
+ if pmFsm != nil {
+ go func(p_pmFsm *AdapterFsm) {
+ _ = p_pmFsm.pFsm.Event(l2PmEventFailure)
+ }(pmFsm)
+ return err
+ }
+ return fmt.Errorf(fmt.Sprintf("CreateOrDeleteEthernetUniHistoryMe-failed-%s-%s",
+ mm.pDeviceHandler.deviceID, err))
+ }
if resp = mm.waitForResponseOrTimeout(ctx, false, entityID, "EthernetPerformanceMonitoringHistoryData"); !resp {
atLeastOneDeleteFailure = true
} else {
@@ -1491,8 +1585,15 @@
inner3:
// retry L2PmDeleteAttempts times to delete the instance of PM
for cnt = 0; cnt < L2PmDeleteAttempts; cnt++ {
- mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteFecHistoryME(
+ _, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteFecHistoryME(
ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, false, mm.pAdaptFsm.commChan, entityID)
+ if err != nil {
+ logger.Errorw(ctx, "CreateOrDeleteFecHistoryME failed, failure PM FSM!",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return fmt.Errorf(fmt.Sprintf("CreateOrDeleteFecHistoryMe-failed-%s-%s",
+ mm.pDeviceHandler.deviceID, err))
+ }
if resp := mm.waitForResponseOrTimeout(ctx, false, entityID, "FecPerformanceMonitoringHistoryData"); !resp {
atLeastOneDeleteFailure = true
} else {
@@ -1509,8 +1610,15 @@
inner4:
// retry L2PmDeleteAttempts times to delete the instance of PM
for cnt = 0; cnt < L2PmDeleteAttempts; cnt++ {
- mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteGemPortHistoryME(
+ _, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteGemPortHistoryME(
ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, false, mm.pAdaptFsm.commChan, entityID)
+ if err != nil {
+ logger.Errorw(ctx, "CreateOrDeleteGemPortHistoryME failed, failure PM FSM!",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return fmt.Errorf(fmt.Sprintf("CreateOrDeleteGemPortHistoryMe-failed-%s-%s",
+ mm.pDeviceHandler.deviceID, err))
+ }
if resp = mm.waitForResponseOrTimeout(ctx, false, entityID, "GemPortNetworkCtpPerformanceMonitoringHistoryData"); !resp {
atLeastOneDeleteFailure = true
} else {
@@ -1556,6 +1664,7 @@
logger.Errorw(ctx, "error calling event", log.Fields{"device-id": mm.pDeviceHandler.deviceID, "err": err})
}
}()
+ return nil
}
// ** L2 PM FSM Handlers end **
@@ -1724,7 +1833,19 @@
}
// Insert "IntervalEndTime" as part of the requested attributes as we need this to compare the get responses when get request is multipart
requestedAttributes["IntervalEndTime"] = 0
- if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+ meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "GetME failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+ pmFsm := mm.pAdaptFsm
+ if pmFsm != nil {
+ go func(p_pmFsm *AdapterFsm) {
+ _ = p_pmFsm.pFsm.Event(l2PmEventFailure)
+ }(pmFsm)
+ return err
+ }
+ return fmt.Errorf(fmt.Sprintf("GetME-failed-%s-%s", mm.pDeviceHandler.deviceID, err))
+ }
+ if meInstance != nil {
select {
case meAttributes = <-mm.l2PmChan:
logger.Debugw(ctx, "received ethernet pm history data metrics",
@@ -1817,8 +1938,16 @@
func (mm *onuMetricsManager) populateEthernetUniHistoryMetrics(ctx context.Context, classID me.ClassID, entityID uint16,
meAttributes me.AttributeValueMap, requestedAttributes me.AttributeValueMap, ethPMUniHistData map[string]float32, intervalEndTime *int) error {
// Insert "IntervalEndTime" as part of the requested attributes as we need this to compare the get responses when get request is multipart
- requestedAttributes["IntervalEndTime"] = 0
- if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+ if _, ok := requestedAttributes["IntervalEndTime"]; !ok {
+ requestedAttributes["IntervalEndTime"] = 0
+ }
+ meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "GetMe failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return fmt.Errorf(fmt.Sprintf("GetME-failed-%s-%s", mm.pDeviceHandler.deviceID, err))
+ }
+ if meInstance != nil {
select {
case meAttributes = <-mm.l2PmChan:
logger.Debugw(ctx, "received ethernet uni history data metrics",
@@ -1911,8 +2040,16 @@
func (mm *onuMetricsManager) populateFecHistoryMetrics(ctx context.Context, classID me.ClassID, entityID uint16,
meAttributes me.AttributeValueMap, requestedAttributes me.AttributeValueMap, fecHistData map[string]float32, intervalEndTime *int) error {
// Insert "IntervalEndTime" as part of the requested attributes as we need this to compare the get responses when get request is multipart
- requestedAttributes["IntervalEndTime"] = 0
- if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+ if _, ok := requestedAttributes["IntervalEndTime"]; !ok {
+ requestedAttributes["IntervalEndTime"] = 0
+ }
+ meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "GetMe failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return fmt.Errorf(fmt.Sprintf("GetME-failed-%s-%s", mm.pDeviceHandler.deviceID, err))
+ }
+ if meInstance != nil {
select {
case meAttributes = <-mm.l2PmChan:
logger.Debugw(ctx, "received fec history data metrics",
@@ -1969,8 +2106,16 @@
func (mm *onuMetricsManager) populateGemPortMetrics(ctx context.Context, classID me.ClassID, entityID uint16,
meAttributes me.AttributeValueMap, requestedAttributes me.AttributeValueMap, gemPortHistData map[string]float32, intervalEndTime *int) error {
// Insert "IntervalEndTime" is part of the requested attributes as we need this to compare the get responses when get request is multipart
- requestedAttributes["IntervalEndTime"] = 0
- if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+ if _, ok := requestedAttributes["IntervalEndTime"]; !ok {
+ requestedAttributes["IntervalEndTime"] = 0
+ }
+ meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "GetMe failed", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+ _ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+ return fmt.Errorf(fmt.Sprintf("GetME-failed-%s-%s", mm.pDeviceHandler.deviceID, err))
+ }
+ if meInstance != nil {
select {
case meAttributes = <-mm.l2PmChan:
logger.Debugw(ctx, "received gem port history data metrics",
@@ -2281,8 +2426,8 @@
"enter_" + l2PmStStarting: func(e *fsm.Event) { mm.l2PMFsmStarting(ctx, e) },
"enter_" + l2PmStSyncTime: func(e *fsm.Event) { mm.l2PMFsmSyncTime(ctx, e) },
"enter_" + l2PmStCollectData: func(e *fsm.Event) { mm.l2PmFsmCollectData(ctx, e) },
- "enter_" + l2PmStCreatePmMe: func(e *fsm.Event) { mm.l2PmFsmCreatePM(ctx, e) },
- "enter_" + l2PmStDeletePmMe: func(e *fsm.Event) { mm.l2PmFsmDeletePM(ctx, e) },
+ "enter_" + l2PmStCreatePmMe: func(e *fsm.Event) { _ = mm.l2PmFsmCreatePM(ctx, e) },
+ "enter_" + l2PmStDeletePmMe: func(e *fsm.Event) { _ = mm.l2PmFsmDeletePM(ctx, e) },
},
)
return nil
diff --git a/internal/pkg/onuadaptercore/uniportadmin.go b/internal/pkg/onuadaptercore/uniportadmin.go
index 75e76b2..1fe0230 100644
--- a/internal/pkg/onuadaptercore/uniportadmin.go
+++ b/internal/pkg/onuadaptercore/uniportadmin.go
@@ -205,8 +205,20 @@
logger.Debugw(ctx, "LockStateFSM Tx Set::ONU-G:admin", log.Fields{
"omciAdmin": omciAdminState, "in state": e.FSM.Current(), "device-id": oFsm.deviceID})
requestedAttributes := me.AttributeValueMap{"AdministrativeState": omciAdminState}
- meInstance := oFsm.pOmciCC.sendSetOnuGLS(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+ meInstance, err := oFsm.pOmciCC.sendSetOnuGLS(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
requestedAttributes, oFsm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "OnuGLS set failed, aborting LockStateFSM", log.Fields{"device-id": oFsm.deviceID})
+ pLockStateAFsm := oFsm.pAdaptFsm
+ if pLockStateAFsm != nil {
+ go func(a_pAFsm *AdapterFsm) {
+ if a_pAFsm != nil && a_pAFsm.pFsm != nil {
+ _ = a_pAFsm.pFsm.Event(uniEvReset)
+ }
+ }(pLockStateAFsm)
+ }
+ return
+ }
//accept also nil as (error) return value for writing to LastTx
// - this avoids misinterpretation of new received OMCI messages
oFsm.pLastTxMeInstance = meInstance
@@ -381,14 +393,28 @@
if uniPort.portType == uniPPTP {
logger.Debugw(ctx, "Setting PPTP admin state", log.Fields{
"device-id": oFsm.deviceID, "for PortNo": uniNo, "state (0-unlock)": omciAdminState})
- meInstance = oFsm.pOmciCC.sendSetPptpEthUniLS(log.WithSpanFromContext(context.TODO(), ctx), uniPort.entityID, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
+ meInstance, err := oFsm.pOmciCC.sendSetPptpEthUniLS(log.WithSpanFromContext(context.TODO(), ctx),
+ uniPort.entityID, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
true, requestedAttributes, oFsm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "SetPptpEthUniLS set failed, aborting LockStateFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(uniEvReset)
+ return
+ }
oFsm.pLastTxMeInstance = meInstance
} else if uniPort.portType == uniVEIP {
logger.Debugw(ctx, "Setting VEIP admin state", log.Fields{
"device-id": oFsm.deviceID, "for PortNo": uniNo, "state (0-unlock)": omciAdminState})
- meInstance = oFsm.pOmciCC.sendSetVeipLS(log.WithSpanFromContext(context.TODO(), ctx), uniPort.entityID, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
+ meInstance, err := oFsm.pOmciCC.sendSetVeipLS(log.WithSpanFromContext(context.TODO(), ctx),
+ uniPort.entityID, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
true, requestedAttributes, oFsm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "SetVeipLS set failed, aborting LockStateFsm!",
+ log.Fields{"device-id": oFsm.deviceID})
+ _ = oFsm.pAdaptFsm.pFsm.Event(uniEvReset)
+ return
+ }
oFsm.pLastTxMeInstance = meInstance
} else {
logger.Warnw(ctx, "Unsupported UniTP type - skip",
diff --git a/internal/pkg/onuadaptercore/uniportstatus.go b/internal/pkg/onuadaptercore/uniportstatus.go
index 8378073..1674b52 100644
--- a/internal/pkg/onuadaptercore/uniportstatus.go
+++ b/internal/pkg/onuadaptercore/uniportstatus.go
@@ -56,7 +56,11 @@
requestedAttributes := me.AttributeValueMap{adminState: 0, operationalState: 0, configInd: 0}
// Note: No reference to fetch the OMCI timeout configuration value, so hard code it to 10s
- if meInstance := portStatus.pOmiCC.sendGetMe(ctx, me.PhysicalPathTerminationPointEthernetUniClassID, uniPort.entityID, requestedAttributes, 10, true, portStatus.omciRespChn); meInstance != nil {
+ meInstance, err := portStatus.pOmiCC.sendGetMe(ctx, me.PhysicalPathTerminationPointEthernetUniClassID, uniPort.entityID, requestedAttributes, 10, true, portStatus.omciRespChn)
+ if err != nil {
+ return postUniStatusErrResponse(extension.GetValueResponse_INTERNAL_ERROR)
+ }
+ if meInstance != nil {
portStatus.pLastTxMeInstance = meInstance
//verify response