VOL-4029 code changes for extended pm counters
Change-Id: Id3c1a310b7eb7718776dd1391fd79c0bb7fc25e8
diff --git a/PM_Notes.md b/PM_Notes.md
index cc05163..f8674cb 100644
--- a/PM_Notes.md
+++ b/PM_Notes.md
@@ -265,10 +265,77 @@
```
Note: For more `event listen` options, check `voltctl event listen --help` command.
+## On Demand Counters
+voltha supports following on demand counters:
+- Ethernet frame extended PM
+- Onu Pon Interface stats
+
+### _Ethernet frame extended pm_
+Ethernet frame extended pm me collects PM data at a point where an Ethernet flow can be observed.Currently, only
+Physical path termination point Ethernet UNI and Virtual Ethernet interface point ME are supported as parent ME.
+The protobuf message [protomessage](https://github.com/opencord/voltha-protos/blob/master/protos/voltha_protos/extensions.proto#L259)
+reports the pm with below counters for each direction(upstream as well as downstream):
+
+```
+uint64 drop_events
+uint64 octets
+uint64 frames
+uint64 broadcast_frames
+uint64 multicast_frames
+uint64 crc_errored_frames
+uint64 undersize_frames
+uint64 oversize_frames
+uint64 frames_64_octets
+uint64 frames_65_to_127_octets
+uint64 frames_128_to_255_octets
+uint64 frames_256_to_511_octets
+uint64 frames_512_to_1023_octets
+uint64 frames_1024_to_1518_octets
+```
+Note :For the fields which are not supported by onu, the counter value is equivalent to either
+2^32 -2 for 32 bit Me or 2^64 - 2 for 64bit Me.
+### _Onu Pon Interface stats_
+Onu Pon interface stats are collected from olt. The protobuf message [protomessage](https://github.com/opencord/voltha-protos/blob/master/protos/voltha_protos/extensions.proto#L157) reports the ith pon interface stats on demand.
+
+Note : The fields in onu stats are optional as the some counters may or may not be supported
+by some vendors.
+
+### Useful voltcl commands to fetch on demand stats
+
+#### Get Ethernet frame extended pm
+
+```
+voltctl device getextval ethernet_frame_extended_pm <onu-device-id>
+```
+#### Get Onu stats
+
+```
+voltctl device getextval onu_stats <pon-interface-id> <onu-id>
+```
+Note : The pon interface id and onu id are of type uint32. Hence the input should be respective
+pon interface id and onu id in an integer.
+
+## ANI-G Test report
+
+Use below command to pull the report from ANI-G self test command
+
+```
+voltctl device getextval onu_pon_optical_info <onu-device-id>
+```
+
+Below is sample output.
+
+```
+ POWER_FEED_VOLTAGE__VOLTS: 3.26
+ RECEIVED_OPTICAL_POWER__dBm: -16.02
+ MEAN_OPTICAL_LAUNCH_POWER__dBm: 5.5660005
+ LASER_BIAS_CURRENT__mA: 0.01648
+ TEMPERATURE__Celsius: 59.5
+```
+
## Future work
The following Metrics could be supported in the future.
-- ANI-G Test report on demand
- EthernetBridgeHistory and EthernetUniHistory counters on demand
- xgPON_TC_History
- xgPON_Downstream_History
diff --git a/go.mod b/go.mod
index 6438888..5e45035 100644
--- a/go.mod
+++ b/go.mod
@@ -9,7 +9,7 @@
github.com/golang/protobuf v1.3.2
github.com/google/gopacket v1.1.17
github.com/looplab/fsm v0.2.0
- github.com/opencord/omci-lib-go v1.1.0
+ github.com/opencord/omci-lib-go v1.3.1
github.com/opencord/voltha-lib-go/v5 v5.0.2
github.com/opencord/voltha-protos/v4 v4.2.0
github.com/stretchr/testify v1.6.1
diff --git a/go.sum b/go.sum
index a794265..2f6536f 100644
--- a/go.sum
+++ b/go.sum
@@ -150,8 +150,8 @@
github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/gomega v1.4.2 h1:3mYCb7aPxS/RU7TI1y4rkEn1oKmPRjNJLNEXgw7MH2I=
github.com/onsi/gomega v1.4.2/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/opencord/omci-lib-go v1.1.0 h1:ICc29xMslz9fNqtvnN9tzS0yxRlugzKx0fUGABlwHNM=
-github.com/opencord/omci-lib-go v1.1.0/go.mod h1:moNk4j00XaM3olsu4a8lRAqGmcZJoyIbxtSr+VERLq4=
+github.com/opencord/omci-lib-go v1.3.1 h1:1fzWpfwdWemjzmQf5oZRwN71xYOGn+WXsSKFiZTm0yk=
+github.com/opencord/omci-lib-go v1.3.1/go.mod h1:moNk4j00XaM3olsu4a8lRAqGmcZJoyIbxtSr+VERLq4=
github.com/opencord/voltha-lib-go/v5 v5.0.2 h1:nLs42QM75BhKt4eXLdHhQwRPLrI2V2BjWJJlzGMUixg=
github.com/opencord/voltha-lib-go/v5 v5.0.2/go.mod h1:i1fwPMicFccG38L200+IQAlfHSbszWg//jF1pDQxTPQ=
github.com/opencord/voltha-protos/v4 v4.2.0 h1:QJZqHPRKa1E1xh40F3UA4xSjBI+6EmW7OfIcJqPNc4A=
diff --git a/internal/pkg/onuadaptercore/device_handler.go b/internal/pkg/onuadaptercore/device_handler.go
index ff18216..65051f6 100644
--- a/internal/pkg/onuadaptercore/device_handler.go
+++ b/internal/pkg/onuadaptercore/device_handler.go
@@ -3368,6 +3368,8 @@
// Start routine to process OMCI GET Responses
go dh.pOnuMetricsMgr.processOmciMessages(ctx)
+ // Create Extended Frame PM ME
+ go dh.pOnuMetricsMgr.createEthernetFrameExtendedPMME(ctx)
// Initialize the next metric collection time.
// Normally done when the onu_metrics_manager is initialized the first time, but needed again later when ONU is
// reset like onu rebooted.
@@ -3455,6 +3457,19 @@
return portStatus.getUniPortStatus(ctx, uniInfo.UniIndex)
}
+func (dh *deviceHandler) getOnuOMCICounters(ctx context.Context, onuInfo *extension.GetOmciEthernetFrameExtendedPmRequest) *extension.SingleGetValueResponse {
+ if dh.pOnuMetricsMgr == nil {
+ return &extension.SingleGetValueResponse{
+ Response: &extension.GetValueResponse{
+ Status: extension.GetValueResponse_ERROR,
+ ErrReason: extension.GetValueResponse_INTERNAL_ERROR,
+ },
+ }
+ }
+ resp := dh.pOnuMetricsMgr.collectEthernetFrameExtendedPMCounters(ctx)
+ return resp
+}
+
func (dh *deviceHandler) isFsmInOmciIdleState(ctx context.Context, pFsm *fsm.FSM, wantedState string) bool {
if pFsm == nil {
return true //FSM not active - so there is no activity on omci
diff --git a/internal/pkg/onuadaptercore/omci_cc.go b/internal/pkg/onuadaptercore/omci_cc.go
index df13717..4006283 100644
--- a/internal/pkg/onuadaptercore/omci_cc.go
+++ b/internal/pkg/onuadaptercore/omci_cc.go
@@ -50,7 +50,6 @@
//const defaultTPID = uint16(0x8100)
//const broadComDefaultVID = uint16(4091)
-
const unusedTcontAllocID = uint16(0xFFFF) //common unused AllocId for G.984 and G.987 systems
const cOmciBaseMessageTrailerLen = 40
@@ -1346,6 +1345,39 @@
return nil, omciErr.GetError()
}
+func (oo *omciCC) sendGetMeWithAttributeMask(ctx context.Context, classID me.ClassID, entityID uint16, requestedAttributesMask uint16,
+ timeout int, highPrio bool, rxChan chan Message) error {
+
+ tid := oo.getNextTid(highPrio)
+ logger.Debugw(ctx, "send get-request-msg", log.Fields{"classID": classID, "device-id": oo.deviceID,
+ "SequNo": strconv.FormatInt(int64(tid), 16)})
+
+ request := &omci.GetRequest{
+ MeBasePacket: omci.MeBasePacket{
+ EntityInstance: entityID,
+ EntityClass: classID,
+ },
+ AttributeMask: requestedAttributesMask,
+ }
+
+ pkt, err := serialize(ctx, omci.GetRequestType, request, tid)
+ if err != nil {
+ logger.Errorw(ctx, "Cannot serialize get-request", log.Fields{"meClassIDName": classID, "Err": err, "device-id": oo.deviceID})
+ return err
+ }
+ omciRxCallbackPair := callbackPair{
+ cbKey: tid,
+ cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
+ }
+ err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
+ if err != nil {
+ logger.Errorw(ctx, "Cannot send get-request-msg", log.Fields{"meClassIDName": classID, "Err": err, "device-id": oo.deviceID})
+ return err
+ }
+ logger.Debugw(ctx, "send get-request-msg done", log.Fields{"meClassIDName": classID, "device-id": oo.deviceID})
+ return nil
+}
+
func (oo *omciCC) sendCreateDot1PMapper(ctx context.Context, timeout int, highPrio bool,
aInstID uint16, rxChan chan Message) (*me.ManagedEntity, error) {
tid := oo.getNextTid(highPrio)
@@ -2774,7 +2806,8 @@
// DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
// Length: 0x28, // Optional, defaults to 40 octets
}
- var localSectionData [31]byte
+ localSectionData := make([]byte, len(aSection))
+
copy(localSectionData[:], aSection) // as long as DownloadSectionRequest defines array for SectionData we need to copy into the array
request := &omci.DownloadSectionRequest{
MeBasePacket: omci.MeBasePacket{
@@ -3145,3 +3178,62 @@
func (oo *omciCC) GetMaxOmciTimeoutWithRetries() time.Duration {
return time.Duration((cDefaultRetries+1)*oo.pOnuDeviceEntry.pOpenOnuAc.omciTimeout + 1)
}
+
+func (oo *omciCC) sendCreateOrDeleteEthernetFrameExtendedPMME(ctx context.Context, timeout int, highPrio bool,
+ upstream bool, create bool, rxChan chan Message, entityID uint16, classID me.ClassID, controlBlock []uint16) (*me.ManagedEntity, error) {
+ tid := oo.getNextTid(highPrio)
+ logger.Debugw(ctx, "send-ethernet-frame-extended-pm-me-msg:", log.Fields{"device-id": oo.deviceID,
+ "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create, "upstream": upstream})
+
+ meParam := me.ParamData{EntityID: entityID,
+ Attributes: me.AttributeValueMap{"ControlBlock": controlBlock},
+ }
+ var meInstance *me.ManagedEntity
+ var omciErr me.OmciErrors
+ if classID == me.EthernetFrameExtendedPmClassID {
+ meInstance, omciErr = me.NewEthernetFrameExtendedPm(meParam)
+ } else {
+ meInstance, omciErr = me.NewEthernetFrameExtendedPm64Bit(meParam)
+ }
+
+ if omciErr.GetError() == nil {
+ var omciLayer *omci.OMCI
+ var msgLayer gopacket.SerializableLayer
+ var err error
+ if create {
+ omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
+ omci.AddDefaults(true))
+ } else {
+ omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid),
+ omci.AddDefaults(true))
+ }
+ if err != nil {
+ logger.Errorw(ctx, "cannot-encode-ethernet-frame-extended-pm-me",
+ log.Fields{"err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "inst-id": strconv.FormatInt(int64(entityID), 16)})
+ return nil, err
+ }
+
+ pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
+ if err != nil {
+ logger.Errorw(ctx, "cannot-serialize-ethernet-frame-extended-pm-me",
+ log.Fields{"err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "inst-id": strconv.FormatInt(int64(entityID), 16)})
+ return nil, err
+ }
+
+ omciRxCallbackPair := callbackPair{cbKey: tid,
+ cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
+ }
+ err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
+ if err != nil {
+ logger.Errorw(ctx, "Cannot send ethernet-frame-extended-pm-me",
+ log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "inst-id": strconv.FormatInt(int64(entityID), 16)})
+ return nil, err
+ }
+ logger.Debugw(ctx, "send-ethernet-frame-extended-pm-me-done",
+ log.Fields{"device-id": oo.deviceID, "upstream": upstream, "create": create, "inst-id": strconv.FormatInt(int64(entityID), 16)})
+ return meInstance, nil
+ }
+ logger.Errorw(ctx, "cannot-generate-ethernet-frame-extended-pm-me-instance",
+ log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "upstream": upstream, "create": create, "inst-id": strconv.FormatInt(int64(entityID), 16)})
+ return nil, omciErr.GetError()
+}
diff --git a/internal/pkg/onuadaptercore/onu_metrics_manager.go b/internal/pkg/onuadaptercore/onu_metrics_manager.go
index 3276882..d122951 100644
--- a/internal/pkg/onuadaptercore/onu_metrics_manager.go
+++ b/internal/pkg/onuadaptercore/onu_metrics_manager.go
@@ -31,6 +31,7 @@
"github.com/opencord/voltha-lib-go/v5/pkg/db"
"github.com/opencord/voltha-lib-go/v5/pkg/db/kvstore"
"github.com/opencord/voltha-lib-go/v5/pkg/log"
+ "github.com/opencord/voltha-protos/v4/go/extension"
"github.com/opencord/voltha-protos/v4/go/voltha"
)
@@ -65,6 +66,27 @@
FrequencyGranularity = 5 // The frequency (in seconds) has to be multiple of 5. This setting cannot changed later.
)
+// constants for ethernet frame extended pm collection
+const (
+ ExtendedPmCreateAttempts = 3
+ UnsupportedCounterValue32bit uint64 = 4294967294
+ UnsupportedCounterValue64bit uint64 = 18446744073709551614
+ dropEvents = "DropEvents"
+ octets = "Octets"
+ frames = "Frames"
+ broadcastFrames = "BroadcastFrames"
+ multicastFrames = "MulticastFrames"
+ crcErroredFrames = "CrcErroredFrames"
+ undersizeFrames = "UndersizeFrames"
+ oversizeFrames = "OversizeFrames"
+ frames64Octets = "Frames64Octets"
+ frames65To127Octets = "Frames65To127Octets"
+ frames128To255Octets = "Frames128To255Octets"
+ frames256To511Octets = "Frames256To511Octets"
+ frames512To1023Octets = "Frames512To1023Octets"
+ frames1024To1518Octets = "Frames1024To1518Octets"
+)
+
// OpticalPowerGroupMetrics are supported optical pm names
var OpticalPowerGroupMetrics = map[string]voltha.PmConfig_PmType{
"ani_g_instance_id": voltha.PmConfig_CONTEXT,
@@ -174,6 +196,20 @@
"encryption_key_errors": voltha.PmConfig_COUNTER,
}
+var maskToEthernetFrameExtendedPM32Bit = map[uint16][]string{
+ 0x3F00: {"drop_events", "octets", "frames", "broadcast_frames", "multicast_frames", "crc_errored_frames"},
+ 0x00FC: {"undersize_frames", "oversize_frames", "64_octets", "65_to_127_octets", "128_to_255_octets", "256_to_511_octets"},
+ 0x0003: {"512_to_1023_octets", "1024_to_1518_octets"},
+}
+
+var maskToEthernetFrameExtendedPM64Bit = map[uint16][]string{
+ 0x3800: {"drop_events", "octets", "frames"},
+ 0x0700: {"broadcast_frames", "multicast_frames", "crc_errored_frames"},
+ 0x00E0: {"undersize_frames", "oversize_frames", "64_octets"},
+ 0x001C: {"65_to_127_octets", "128_to_255_octets", "256_to_511_octets"},
+ 0x0003: {"512_to_1023_octets", "1024_to_1518_octets"},
+}
+
// Constants specific for L2 PM collection
const (
L2PmCollectionInterval = 15 * 60 // Unit in seconds. Do not change this as this fixed by OMCI specification for L2 PM counters
@@ -184,7 +220,8 @@
// Per Table 11.2.9-1 – OMCI baseline message limitations in G.988 spec, the max GET Response
// payload size is 25. We define 24 (one less) to allow for dynamic insertion of IntervalEndTime
// attribute (1 byte) in L2 PM GET Requests.
- MaxL2PMGetPayLoadSize = 24
+ MaxL2PMGetPayLoadSize = 24
+ MaxEthernetFrameExtPmPayloadSize = 25
)
// EthernetUniHistoryName specific constants
@@ -217,11 +254,12 @@
// KV Store related constants
const (
- cPmKvStorePrefix = "%s/openonu/pm-data/%s" // <some-base-path>/openonu/pm-data/<onu-device-id>
- cPmAdd = "add"
- cPmAdded = "added"
- cPmRemove = "remove"
- cPmRemoved = "removed"
+ cPmKvStorePrefix = "%s/openonu/pm-data/%s" // <some-base-path>/openonu/pm-data/<onu-device-id>
+ cPmAdd = "add"
+ cPmAdded = "added"
+ cPmRemove = "remove"
+ cPmRemoved = "removed"
+ cExtPmKvStorePrefix = "%s/omci_me" //<some-base-path>/omci_me/<onu_vendor>/<onu_equipment_id>/<onu_sw_version>
)
// Defines the type for generic metric population function
@@ -257,11 +295,13 @@
pDeviceHandler *deviceHandler
pAdaptFsm *AdapterFsm
- opticalMetricsChan chan me.AttributeValueMap
- uniStatusMetricsChan chan me.AttributeValueMap
- l2PmChan chan me.AttributeValueMap
- syncTimeResponseChan chan bool // true is success, false is fail
- l2PmCreateOrDeleteResponseChan chan bool // true is success, false is fail
+ opticalMetricsChan chan me.AttributeValueMap
+ uniStatusMetricsChan chan me.AttributeValueMap
+ l2PmChan chan me.AttributeValueMap
+ extendedPmMeChan chan me.AttributeValueMap
+ syncTimeResponseChan chan bool // true is success, false is fail
+ l2PmCreateOrDeleteResponseChan chan bool // true is success, false is fail
+ extendedPMCreateOrDeleteResponseChan chan me.Results // true is sucesss, false is fail
activeL2Pms []string // list of active l2 pm MEs created on the ONU.
l2PmToDelete []string // list of L2 PMs to delete
@@ -281,6 +321,13 @@
onuMetricsManagerLock sync.RWMutex
pmKvStore *db.Backend
+
+ supportedEthernetFrameExtendedPMClass me.ClassID
+ ethernetFrameExtendedPmUpStreamMEToEntityID map[*me.ManagedEntity]uint16
+ ethernetFrameExtendedPmDownStreamMEToEntityID map[*me.ManagedEntity]uint16
+ extPmKvStore *db.Backend
+ onuEthernetFrameExtendedPmLock sync.RWMutex
+ isDeviceReadyToCollectExtendedPmStats bool
}
// newonuMetricsManager returns a new instance of the newonuMetricsManager
@@ -300,9 +347,11 @@
metricsManager.opticalMetricsChan = make(chan me.AttributeValueMap)
metricsManager.uniStatusMetricsChan = make(chan me.AttributeValueMap)
metricsManager.l2PmChan = make(chan me.AttributeValueMap)
+ metricsManager.extendedPmMeChan = make(chan me.AttributeValueMap)
metricsManager.syncTimeResponseChan = make(chan bool)
metricsManager.l2PmCreateOrDeleteResponseChan = make(chan bool)
+ metricsManager.extendedPMCreateOrDeleteResponseChan = make(chan me.Results)
metricsManager.stopProcessingOmciResponses = make(chan bool)
metricsManager.stopTicks = make(chan bool)
@@ -310,6 +359,9 @@
metricsManager.groupMetricMap = make(map[string]*groupMetric)
metricsManager.standaloneMetricMap = make(map[string]*standaloneMetric)
+ metricsManager.ethernetFrameExtendedPmUpStreamMEToEntityID = make(map[*me.ManagedEntity]uint16)
+ metricsManager.ethernetFrameExtendedPmDownStreamMEToEntityID = make(map[*me.ManagedEntity]uint16)
+
if dh.pmConfigs == nil { // dh.pmConfigs is NOT nil if adapter comes back from a restart. We should NOT go back to defaults in this case
metricsManager.initializeAllGroupMetrics()
}
@@ -338,6 +390,14 @@
// the actual PM config and what is present on the device).
}
+ baseExtPmKvStorePath := fmt.Sprintf(cExtPmKvStorePrefix, dh.pOpenOnuAc.cm.Backend.PathPrefix)
+ metricsManager.extPmKvStore = dh.setBackend(ctx, baseExtPmKvStorePath)
+ if metricsManager.extPmKvStore == nil {
+ logger.Errorw(ctx, "Can't initialize extPmKvStore - no backend connection to PM module",
+ log.Fields{"device-id": dh.deviceID, "service": baseExtPmKvStorePath})
+ return nil
+ }
+
logger.Info(ctx, "init-onuMetricsManager completed", log.Fields{"device-id": dh.deviceID})
return &metricsManager
}
@@ -998,6 +1058,8 @@
_ = mm.handleOmciCreateResponseMessage(ctx, msg)
case omci.DeleteResponseType:
_ = mm.handleOmciDeleteResponseMessage(ctx, msg)
+ case omci.GetCurrentDataResponseType:
+ _ = mm.handleOmciGetCurrentDataResponseMessage(ctx, msg)
default:
logger.Warnw(ctx, "Unknown Message Type", log.Fields{"msgType": msg.OmciMsg.MessageType})
@@ -1015,7 +1077,7 @@
logger.Errorw(ctx, "omci Msg layer could not be assigned for GetResponse - handling stopped", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
return fmt.Errorf("omci Msg layer could not be assigned for GetResponse - handling stopped: %s", mm.pDeviceHandler.deviceID)
}
- logger.Debugw(ctx, "OMCI GetResponse Data", log.Fields{"device-id": mm.pDeviceHandler.deviceID, "data-fields": msgObj})
+ logger.Debugw(ctx, "OMCI GetResponse Data", log.Fields{"device-id": mm.pDeviceHandler.deviceID, "data-fields": msgObj, "result": msgObj.Result})
if msgObj.Result == me.Success {
meAttributes := msgObj.Attributes
switch msgObj.EntityClass {
@@ -1037,15 +1099,72 @@
me.FecPerformanceMonitoringHistoryDataClassID,
me.GemPortNetworkCtpPerformanceMonitoringHistoryDataClassID:
mm.l2PmChan <- meAttributes
+ return nil
+ case me.EthernetFrameExtendedPmClassID,
+ me.EthernetFrameExtendedPm64BitClassID:
+ mm.extendedPmMeChan <- meAttributes
+ return nil
+ default:
+ logger.Errorw(ctx, "unhandled omci get response message",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID, "class-id": msgObj.EntityClass})
+ }
+ } else {
+ meAttributes := msgObj.Attributes
+ switch msgObj.EntityClass {
+ case me.EthernetFrameExtendedPmClassID,
+ me.EthernetFrameExtendedPm64BitClassID:
+ // not all counters may be supported in which case we have seen some ONUs throwing
+ // AttributeFailure error code, while correctly populating other counters it supports
+ mm.extendedPmMeChan <- meAttributes
+ return nil
default:
logger.Errorw(ctx, "unhandled omci get response message",
log.Fields{"device-id": mm.pDeviceHandler.deviceID, "class-id": msgObj.EntityClass})
}
}
-
return fmt.Errorf("unhandled-omci-get-response-message")
}
+func (mm *onuMetricsManager) handleOmciGetCurrentDataResponseMessage(ctx context.Context, msg OmciMessage) error {
+ msgLayer := (*msg.OmciPacket).Layer(omci.LayerTypeGetCurrentDataResponse)
+ if msgLayer == nil {
+ logger.Errorw(ctx, "omci Msg layer could not be detected for GetCurrentDataResponse - handling stopped", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ return fmt.Errorf("omci Msg layer could not be detected for GetCurrentDataResponse - handling stopped: %s", mm.pDeviceHandler.deviceID)
+ }
+ msgObj, msgOk := msgLayer.(*omci.GetCurrentDataResponse)
+ if !msgOk {
+ logger.Errorw(ctx, "omci Msg layer could not be assigned for GetCurrentDataResponse - handling stopped", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ return fmt.Errorf("omci Msg layer could not be assigned for GetCurrentDataResponse - handling stopped: %s", mm.pDeviceHandler.deviceID)
+ }
+ logger.Debugw(ctx, "OMCI GetCurrentDataResponse Data", log.Fields{"device-id": mm.pDeviceHandler.deviceID, "data-fields": msgObj, "result": msgObj.Result})
+ if msgObj.Result == me.Success {
+ meAttributes := msgObj.Attributes
+ switch msgObj.EntityClass {
+ case me.EthernetFrameExtendedPmClassID,
+ me.EthernetFrameExtendedPm64BitClassID:
+ mm.extendedPmMeChan <- meAttributes
+ return nil
+ default:
+ logger.Errorw(ctx, "unhandled omci get current data response message",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID, "class-id": msgObj.EntityClass})
+ }
+ } else {
+ meAttributes := msgObj.Attributes
+ switch msgObj.EntityClass {
+ case me.EthernetFrameExtendedPmClassID,
+ me.EthernetFrameExtendedPm64BitClassID:
+ // not all counters may be supported in which case we have seen some ONUs throwing
+ // AttributeFailure error code, while correctly populating other counters it supports
+ mm.extendedPmMeChan <- meAttributes
+ return nil
+ default:
+ logger.Errorw(ctx, "unhandled omci get current data response message",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID, "class-id": msgObj.EntityClass})
+ }
+ }
+ return fmt.Errorf("unhandled-omci-get-current-data-response-message")
+}
+
func (mm *onuMetricsManager) handleOmciSynchronizeTimeResponseMessage(ctx context.Context, msg OmciMessage) error {
msgLayer := (*msg.OmciPacket).Layer(omci.LayerTypeSynchronizeTimeResponse)
if msgLayer == nil {
@@ -2194,6 +2313,10 @@
mm.l2PmCreateOrDeleteResponseChan <- false
}
return nil
+ case me.EthernetFrameExtendedPmClassID,
+ me.EthernetFrameExtendedPm64BitClassID:
+ mm.extendedPMCreateOrDeleteResponseChan <- msgObj.Result
+ return nil
default:
logger.Errorw(ctx, "unhandled omci create response message",
log.Fields{"device-id": mm.pDeviceHandler.deviceID, "class-id": msgObj.EntityClass})
@@ -2832,3 +2955,716 @@
}
return slice
}
+
+func (mm *onuMetricsManager) getEthernetFrameExtendedMETypeFromKvStore(ctx context.Context) (bool, error) {
+ // Check if the data is already available in KV store, if yes, do not send the request for get me.
+ var data me.ClassID
+ key := fmt.Sprintf("%s/%s/%s", mm.pDeviceHandler.pOnuOmciDevice.sOnuPersistentData.PersVendorID,
+ mm.pDeviceHandler.pOnuOmciDevice.sOnuPersistentData.PersEquipmentID,
+ mm.pDeviceHandler.pOnuOmciDevice.sOnuPersistentData.PersActiveSwVersion)
+ Value, err := mm.extPmKvStore.Get(ctx, key)
+ if err == nil {
+ if Value != nil {
+ logger.Debugw(ctx, "me-type-read",
+ log.Fields{"key": Value.Key, "device-id": mm.pDeviceHandler.deviceID})
+ tmpBytes, _ := kvstore.ToByte(Value.Value)
+
+ if err = json.Unmarshal(tmpBytes, &data); err != nil {
+ logger.Errorw(ctx, "unable-to-unmarshal-data", log.Fields{"error": err, "device-id": mm.pDeviceHandler.deviceID})
+ return false, err
+ }
+ logger.Debugw(ctx, "me-ext-pm-class-data", log.Fields{"class-id": data, "device-id": mm.pDeviceHandler.deviceID})
+ // We have found the data from db, no need to get through omci get message.
+ mm.supportedEthernetFrameExtendedPMClass = data
+ return true, nil
+ }
+ logger.Debugw(ctx, "no-me-ext-pm-class-data-found", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ return false, nil
+ }
+ logger.Errorw(ctx, "unable-to-read-from-kv-store", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ return false, err
+}
+
+func (mm *onuMetricsManager) waitForEthernetFrameCreateOrDeleteResponseOrTimeout(ctx context.Context, create bool, instID uint16, meClassID me.ClassID, upstream bool) (bool, error) {
+ logger.Debugw(ctx, "wait-for-ethernet-frame-create-or-delete-response-or-timeout", log.Fields{"create": create, "instID": instID, "meClassID": meClassID})
+ select {
+ case resp := <-mm.extendedPMCreateOrDeleteResponseChan:
+ logger.Debugw(ctx, "received-extended-pm-me-response",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID, "resp": resp, "create": create, "meClassID": meClassID, "instID": instID, "upstream": upstream})
+ // If the result is me.InstanceExists it means the entity was already created. It is ok handled that as success
+ if resp == me.Success || resp == me.InstanceExists {
+ return true, nil
+ } else if resp == me.UnknownEntity || resp == me.ParameterError ||
+ resp == me.ProcessingError || resp == me.NotSupported || resp == me.AttributeFailure {
+ return false, fmt.Errorf("not-supported-me--resp-code-%v", resp)
+ } else {
+ logger.Warnw(ctx, "failed to create me", log.Fields{"device-id": mm.pDeviceHandler.deviceID, "resp": resp, "class-id": meClassID, "instID": instID, "upstream": upstream})
+ return true, fmt.Errorf("error-while-creating-me--resp-code-%v", resp)
+ }
+ case <-time.After(mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.GetMaxOmciTimeoutWithRetries() * time.Second):
+ logger.Errorw(ctx, "timeout-waiting-for-ext-pm-me-response",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID, "resp": false, "create": create, "meClassID": meClassID, "instID": instID, "upstream": upstream})
+ }
+ return false, fmt.Errorf("timeout-while-waiting-for-response")
+}
+
+func (mm *onuMetricsManager) tryCreateExtPmMe(ctx context.Context, meType me.ClassID) (bool, error) {
+ cnt := 0
+ boolForDirection := make([]bool, 2) // stores true and false to indicate upstream and downstream directions.
+ boolForDirection = append(boolForDirection, true, false)
+ // Create ME twice, one for each direction. Boolean true is used to indicate upstream and false for downstream.
+ for _, direction := range boolForDirection {
+ for _, uniPort := range mm.pDeviceHandler.uniEntityMap {
+ var entityID uint16
+ if direction {
+ entityID = uniPort.entityID + 0x100
+ } else {
+ entityID = uniPort.entityID
+ }
+
+ // parent entity id will be same for both direction
+ controlBlock := mm.getControlBlockForExtendedPMDirection(ctx, direction, uniPort.entityID)
+
+ inner1:
+ // retry ExtendedPmCreateAttempts times to create the instance of PM
+ for cnt = 0; cnt < ExtendedPmCreateAttempts; cnt++ {
+ meEnt, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetFrameExtendedPMME(
+ ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, direction, true,
+ mm.pAdaptFsm.commChan, entityID, meType, controlBlock)
+ if err != nil {
+ logger.Errorw(ctx, "EthernetFrameExtendedPMME-create-or-delete-failed",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+ return false, err
+ }
+ if supported, err := mm.waitForEthernetFrameCreateOrDeleteResponseOrTimeout(ctx, true, entityID, meType, direction); err == nil && supported {
+ if direction {
+ mm.ethernetFrameExtendedPmUpStreamMEToEntityID[meEnt] = entityID
+ } else {
+ mm.ethernetFrameExtendedPmDownStreamMEToEntityID[meEnt] = entityID
+ }
+ break inner1
+ } else if err != nil {
+ if !supported {
+ // Need to return immediately
+ return false, err
+ }
+ //In case of failure, go for a retry
+ }
+ }
+ if cnt == ExtendedPmCreateAttempts {
+ logger.Error(ctx, "exceeded-attempts-while-creating-me-for-ethernet-frame-extended-pm")
+ return true, fmt.Errorf("unable-to-create-me")
+ }
+ }
+ }
+ return true, nil
+}
+
+func (mm *onuMetricsManager) putExtPmMeKvStore(ctx context.Context) {
+ key := fmt.Sprintf("%s/%s/%s", mm.pDeviceHandler.pOnuOmciDevice.sOnuPersistentData.PersVendorID,
+ mm.pDeviceHandler.pOnuOmciDevice.sOnuPersistentData.PersEquipmentID,
+ mm.pDeviceHandler.pOnuOmciDevice.sOnuPersistentData.PersActiveSwVersion)
+ // check if we get the supported type me for ethernet frame extended pm class id
+ if mm.supportedEthernetFrameExtendedPMClass == 0 {
+ logger.Error(ctx, "unable-to-get-any-supported-extended-pm-me-class")
+ }
+ classSupported, err := json.Marshal(mm.supportedEthernetFrameExtendedPMClass)
+ if err != nil {
+ logger.Errorw(ctx, "unable-to-marshal-data", log.Fields{"err": err})
+ }
+ if err := mm.extPmKvStore.Put(ctx, key, classSupported); err != nil {
+ logger.Errorw(ctx, "unable-to-add-data-in-db", log.Fields{"err": err})
+ }
+}
+
+func (mm *onuMetricsManager) setAllExtPmMeCreatedFlag() {
+ mm.onuEthernetFrameExtendedPmLock.Lock()
+ mm.isDeviceReadyToCollectExtendedPmStats = true
+ mm.onuEthernetFrameExtendedPmLock.Unlock()
+}
+func (mm *onuMetricsManager) createEthernetFrameExtendedPMME(ctx context.Context) {
+ //get the type of extended frame pm me supported by onu first
+ exist, err := mm.getEthernetFrameExtendedMETypeFromKvStore(ctx)
+ if err != nil {
+ logger.Error(ctx, "unable-to-get-supported-me-for-ethernet-frame-extended-pm")
+ return
+ }
+ if exist {
+ // we have the me type, go ahead with the me type supported.
+ if _, err := mm.tryCreateExtPmMe(ctx, mm.supportedEthernetFrameExtendedPMClass); err != nil {
+ logger.Errorw(ctx, "unable-to-create-me-type", log.Fields{"device-id": mm.pDeviceHandler.deviceID,
+ "meClassID": mm.supportedEthernetFrameExtendedPMClass})
+ return
+ }
+ mm.setAllExtPmMeCreatedFlag()
+ return
+ }
+ // First try with 64 bit me
+ // we have the me type, go ahead with the me type supported.
+ supported64Bit, err := mm.tryCreateExtPmMe(ctx, me.EthernetFrameExtendedPm64BitClassID)
+ if err != nil && !supported64Bit {
+ logger.Errorw(ctx, "unable-to-create-me-type-as-it-is-not-supported",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID, "meClassID": me.EthernetFrameExtendedPm64BitClassID,
+ "supported": supported64Bit})
+ // Then Try with 32 bit type
+ if supported32Bit, err := mm.tryCreateExtPmMe(ctx, me.EthernetFrameExtendedPmClassID); err != nil {
+ logger.Errorw(ctx, "unable-to-create-me-type", log.Fields{"device-id": mm.pDeviceHandler.deviceID,
+ "meClassID": me.EthernetFrameExtendedPmClassID, "supported": supported32Bit})
+ } else if supported32Bit {
+ mm.supportedEthernetFrameExtendedPMClass = me.EthernetFrameExtendedPmClassID
+ mm.putExtPmMeKvStore(ctx)
+ mm.setAllExtPmMeCreatedFlag()
+ }
+ } else if err == nil && supported64Bit {
+ mm.supportedEthernetFrameExtendedPMClass = me.EthernetFrameExtendedPm64BitClassID
+ mm.putExtPmMeKvStore(ctx)
+ mm.setAllExtPmMeCreatedFlag()
+ }
+}
+
+func (mm *onuMetricsManager) collectEthernetFrameExtendedPMCounters(ctx context.Context) *extension.SingleGetValueResponse {
+ errFunc := func(reason extension.GetValueResponse_ErrorReason) *extension.SingleGetValueResponse {
+ return &extension.SingleGetValueResponse{
+ Response: &extension.GetValueResponse{
+ Status: extension.GetValueResponse_ERROR,
+ ErrReason: reason,
+ },
+ }
+ }
+ mm.onuEthernetFrameExtendedPmLock.RLock()
+ if !mm.isDeviceReadyToCollectExtendedPmStats {
+ mm.onuEthernetFrameExtendedPmLock.RUnlock()
+ return errFunc(extension.GetValueResponse_INTERNAL_ERROR)
+ }
+ mm.onuEthernetFrameExtendedPmLock.RUnlock()
+ // Collect metrics for upstream for all the PM Mes per uni port and aggregate
+ var pmUpstream extension.OmciEthernetFrameExtendedPm
+ var pmDownstream extension.OmciEthernetFrameExtendedPm
+ for meEnt, entityID := range mm.ethernetFrameExtendedPmUpStreamMEToEntityID {
+ var receivedMask uint16
+ if metricInfo, errResp := mm.collectEthernetFrameExtendedPMData(ctx, meEnt, entityID, true, &receivedMask); metricInfo != nil { // upstream
+ if receivedMask == 0 {
+ pmUpstream = mm.aggregateEthernetFrameExtendedPM(metricInfo, pmUpstream, false)
+ logger.Error(ctx, "all-the-attributes-of-ethernet-frame-extended-pm-counters-are-unsupported")
+ pmDownstream = pmUpstream
+ singleValResp := extension.SingleGetValueResponse{
+ Response: &extension.GetValueResponse{
+ Status: extension.GetValueResponse_OK,
+ Response: &extension.GetValueResponse_OnuCounters{
+ OnuCounters: &extension.GetOmciEthernetFrameExtendedPmResponse{
+ Upstream: &pmUpstream,
+ Downstream: &pmDownstream,
+ },
+ },
+ },
+ }
+ return &singleValResp
+ }
+ // Aggregate the result for upstream
+ pmUpstream = mm.aggregateEthernetFrameExtendedPM(metricInfo, pmUpstream, true)
+ } else {
+ return errFunc(errResp)
+ }
+ }
+
+ for meEnt, entityID := range mm.ethernetFrameExtendedPmDownStreamMEToEntityID {
+ var receivedMask uint16
+ if metricInfo, errResp := mm.collectEthernetFrameExtendedPMData(ctx, meEnt, entityID, false, &receivedMask); metricInfo != nil { // downstream
+ // Aggregate the result for downstream
+ pmDownstream = mm.aggregateEthernetFrameExtendedPM(metricInfo, pmDownstream, true)
+ } else {
+ return errFunc(errResp)
+ }
+ }
+ singleValResp := extension.SingleGetValueResponse{
+ Response: &extension.GetValueResponse{
+ Status: extension.GetValueResponse_OK,
+ Response: &extension.GetValueResponse_OnuCounters{
+ OnuCounters: &extension.GetOmciEthernetFrameExtendedPmResponse{
+ Upstream: &pmUpstream,
+ Downstream: &pmDownstream,
+ },
+ },
+ },
+ }
+ return &singleValResp
+}
+
+func (mm *onuMetricsManager) collectEthernetFrameExtendedPMData(ctx context.Context, meEnt *me.ManagedEntity, entityID uint16, upstream bool, receivedMask *uint16) (map[string]uint64, extension.GetValueResponse_ErrorReason) {
+ var classID me.ClassID
+ logger.Debugw(ctx, "collecting-data-for-ethernet-frame-extended-pm", log.Fields{"device-id": mm.pDeviceHandler.deviceID, "entityID": entityID, "upstream": upstream})
+
+ classID = mm.supportedEthernetFrameExtendedPMClass
+ attributeMaskList := maskToEthernetFrameExtendedPM64Bit
+ if classID == me.EthernetFrameExtendedPmClassID {
+ attributeMaskList = maskToEthernetFrameExtendedPM32Bit
+ }
+ ethPMData := make(map[string]uint64)
+ var sumReceivedMask uint16
+ for mask := range attributeMaskList {
+ if errResp, err := mm.populateEthernetFrameExtendedPMMetrics(ctx, classID, entityID, mask, ethPMData, upstream, &sumReceivedMask); err != nil {
+ logger.Errorw(ctx, "error-during-metric-collection",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID, "entityID": entityID, "err": err})
+ return nil, errResp
+ }
+ if (mask == 0x3F00 || mask == 0x3800) && sumReceivedMask == 0 {
+ //It means the first attributes fetch was a failure, hence instead of sending multiple failure get requests
+ //populate all counters as failure and return
+ mm.fillAllErrorCountersEthernetFrameExtendedPM(ethPMData)
+ break
+ }
+ }
+ *receivedMask = sumReceivedMask
+ return ethPMData, extension.GetValueResponse_REASON_UNDEFINED
+}
+
+// nolint: gocyclo
+func (mm *onuMetricsManager) populateEthernetFrameExtendedPMMetrics(ctx context.Context, classID me.ClassID, entityID uint16,
+ requestedAttributesMask uint16, ethFrameExtPMData map[string]uint64, upstream bool, sumReceivedMask *uint16) (extension.GetValueResponse_ErrorReason, error) {
+ var meAttributes me.AttributeValueMap
+ logger.Debugw(ctx, "requesting-attributes", log.Fields{"attributes-mask": requestedAttributesMask, "entityID": entityID, "classID": classID})
+ err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMeWithAttributeMask(ctx, classID, entityID, requestedAttributesMask, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+ if err != nil {
+ logger.Errorw(ctx, "get-me-failed", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+ return extension.GetValueResponse_INTERNAL_ERROR, err
+ }
+ select {
+ case meAttributes = <-mm.extendedPmMeChan:
+ logger.Debugw(ctx, "received-extended-pm-data",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID, "upstream": upstream, "entityID": entityID})
+ case <-time.After(mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.GetMaxOmciTimeoutWithRetries() * time.Second):
+ logger.Errorw(ctx, "timeout-waiting-for-omci-get-response-for-received-extended-pm-data",
+ log.Fields{"device-id": mm.pDeviceHandler.deviceID, "upstream": upstream, "entityID": entityID})
+ return extension.GetValueResponse_TIMEOUT, fmt.Errorf("timeout-waiting-for-omci-get-response-for-received-extended-pm-data")
+ }
+ if mm.supportedEthernetFrameExtendedPMClass == me.EthernetFrameExtendedPmClassID {
+ mask := mm.getEthFrameExtPMDataFromResponse(ctx, ethFrameExtPMData, meAttributes, requestedAttributesMask)
+ *sumReceivedMask += mask
+ logger.Debugw(ctx, "data-received-for-ethernet-frame-ext-pm", log.Fields{"data": ethFrameExtPMData, "entityID": entityID})
+ } else {
+ mask := mm.getEthFrameExtPM64BitDataFromResponse(ctx, ethFrameExtPMData, meAttributes, requestedAttributesMask)
+ *sumReceivedMask += mask
+ logger.Debugw(ctx, "data-received-for-ethernet-frame-ext-pm", log.Fields{"data": ethFrameExtPMData, "entityID": entityID})
+ }
+
+ return extension.GetValueResponse_REASON_UNDEFINED, nil
+}
+
+func (mm *onuMetricsManager) fillAllErrorCountersEthernetFrameExtendedPM(ethFrameExtPMData map[string]uint64) {
+ sourceMap := maskToEthernetFrameExtendedPM64Bit
+ errorCounterValue := UnsupportedCounterValue64bit
+ if mm.supportedEthernetFrameExtendedPMClass == me.EthernetFrameExtendedPmClassID {
+ sourceMap = maskToEthernetFrameExtendedPM32Bit
+ errorCounterValue = UnsupportedCounterValue32bit
+ }
+ for _, value := range sourceMap {
+ for _, k := range value {
+ if _, ok := ethFrameExtPMData[k]; !ok {
+ ethFrameExtPMData[k] = errorCounterValue
+ }
+ }
+ }
+}
+
+// nolint: gocyclo
+func (mm *onuMetricsManager) getEthFrameExtPMDataFromResponse(ctx context.Context, ethFrameExtPMData map[string]uint64, meAttributes me.AttributeValueMap, requestedAttributesMask uint16) uint16 {
+ receivedMask := uint16(0)
+ switch requestedAttributesMask {
+ case 0x3F00:
+ for _, k := range maskToEthernetFrameExtendedPM32Bit[requestedAttributesMask] {
+ if _, ok := ethFrameExtPMData[k]; !ok {
+ switch k {
+ case "drop_events":
+ if val, ok := meAttributes[dropEvents]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x2000
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ case "octets":
+ if val, ok := meAttributes[octets]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x1000
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ case "frames":
+ if val, ok := meAttributes[frames]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x800
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ case "broadcast_frames":
+ if val, ok := meAttributes[broadcastFrames]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x400
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ case "multicast_frames":
+ if val, ok := meAttributes[multicastFrames]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x200
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ case "crc_errored_frames":
+ if val, ok := meAttributes[crcErroredFrames]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x100
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ default:
+ //do nothing
+ }
+ }
+ }
+ case 0x00FC:
+ for _, k := range maskToEthernetFrameExtendedPM32Bit[requestedAttributesMask] {
+ if _, ok := ethFrameExtPMData[k]; !ok {
+ switch k {
+ case "undersize_frames":
+ if val, ok := meAttributes[undersizeFrames]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x80
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ case "oversize_frames":
+ if val, ok := meAttributes[oversizeFrames]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x40
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ case "64_octets":
+ if val, ok := meAttributes[frames64Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x20
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ case "65_to_127_octets":
+ if val, ok := meAttributes[frames65To127Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x10
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ case "128_to_255_octets":
+ if val, ok := meAttributes[frames128To255Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x8
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ case "256_to_511_octets":
+ if val, ok := meAttributes[frames256To511Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x4
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ default:
+ //do nothing
+ }
+ }
+ }
+ case 0x0003:
+ for _, k := range maskToEthernetFrameExtendedPM32Bit[requestedAttributesMask] {
+ if _, ok := ethFrameExtPMData[k]; !ok {
+ switch k {
+ case "512_to_1023_octets":
+ if val, ok := meAttributes[frames512To1023Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x2
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ case "1024_to_1518_octets":
+ if val, ok := meAttributes[frames1024To1518Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = uint64(val.(uint32))
+ receivedMask |= 0x1
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue32bit
+ }
+ default:
+ //do nothing
+ }
+ }
+ }
+ default:
+ //do nothing
+ }
+ return receivedMask
+}
+
+// nolint: gocyclo
+func (mm *onuMetricsManager) getEthFrameExtPM64BitDataFromResponse(ctx context.Context, ethFrameExtPMData map[string]uint64, meAttributes me.AttributeValueMap, requestedAttributesMask uint16) uint16 {
+ receivedMask := uint16(0)
+ switch requestedAttributesMask {
+ case 0x3800:
+ for _, k := range maskToEthernetFrameExtendedPM64Bit[requestedAttributesMask] {
+ if _, ok := ethFrameExtPMData[k]; !ok {
+ switch k {
+ case "drop_events":
+ if val, ok := meAttributes[dropEvents]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x2000
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ case "octets":
+ if val, ok := meAttributes[octets]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x1000
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ case "frames":
+ if val, ok := meAttributes[frames]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x800
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ }
+ }
+ }
+ case 0x0700:
+ for _, k := range maskToEthernetFrameExtendedPM64Bit[requestedAttributesMask] {
+ if _, ok := ethFrameExtPMData[k]; !ok {
+ switch k {
+ case "broadcast_frames":
+ if val, ok := meAttributes[broadcastFrames]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x400
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ case "multicast_frames":
+ if val, ok := meAttributes[multicastFrames]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x200
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ case "crc_errored_frames":
+ if val, ok := meAttributes[crcErroredFrames]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x100
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ }
+ }
+ }
+ case 0x00E0:
+ for _, k := range maskToEthernetFrameExtendedPM64Bit[requestedAttributesMask] {
+ if _, ok := ethFrameExtPMData[k]; !ok {
+ switch k {
+ case "undersize_frames":
+ if val, ok := meAttributes[undersizeFrames]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x80
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ case "oversize_frames":
+ if val, ok := meAttributes[oversizeFrames]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x40
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ case "64_octets":
+ if val, ok := meAttributes[frames64Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x20
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ }
+ }
+ }
+ case 0x001C:
+ for _, k := range maskToEthernetFrameExtendedPM64Bit[requestedAttributesMask] {
+ if _, ok := ethFrameExtPMData[k]; !ok {
+ switch k {
+ case "65_to_127_octets":
+ if val, ok := meAttributes[frames65To127Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x10
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ case "128_to_255_octets":
+ if val, ok := meAttributes[frames128To255Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x8
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ case "256_to_511_octets":
+ if val, ok := meAttributes[frames256To511Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x4
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ default:
+ //do nothing
+ }
+ }
+ }
+ case 0x0003:
+ for _, k := range maskToEthernetFrameExtendedPM64Bit[requestedAttributesMask] {
+ if _, ok := ethFrameExtPMData[k]; !ok {
+ switch k {
+ case "512_to_1023_octets":
+ if val, ok := meAttributes[frames512To1023Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x2
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ case "1024_to_1518_octets":
+ if val, ok := meAttributes[frames1024To1518Octets]; ok && val != nil {
+ ethFrameExtPMData[k] = val.(uint64)
+ receivedMask |= 0x1
+ } else if !ok {
+ ethFrameExtPMData[k] = UnsupportedCounterValue64bit
+ }
+ default:
+ //do nothing
+ }
+ }
+ }
+ }
+ return receivedMask
+}
+
+func (mm *onuMetricsManager) aggregateEthernetFrameExtendedPM(pmDataIn map[string]uint64, pmData extension.OmciEthernetFrameExtendedPm, aggregate bool) extension.OmciEthernetFrameExtendedPm {
+ mm.onuEthernetFrameExtendedPmLock.Lock()
+ defer mm.onuEthernetFrameExtendedPmLock.Unlock()
+ errorCounterValue := UnsupportedCounterValue64bit
+ if mm.supportedEthernetFrameExtendedPMClass == me.EthernetFrameExtendedPmClassID {
+ errorCounterValue = UnsupportedCounterValue32bit
+ }
+ var pmDataOut extension.OmciEthernetFrameExtendedPm
+ if aggregate {
+ if pmData.DropEvents != errorCounterValue {
+ pmDataOut.DropEvents = pmData.DropEvents + pmDataIn["drop_events"]
+ } else {
+ pmDataOut.DropEvents = pmData.DropEvents
+ }
+ if pmData.Octets != errorCounterValue {
+ pmDataOut.Octets = pmData.Octets + pmDataIn["octets"]
+ } else {
+ pmDataOut.Octets = pmData.Octets
+ }
+ if pmData.Frames != errorCounterValue {
+ pmDataOut.Frames = pmData.Frames + pmDataIn["frames"]
+ } else {
+ pmDataOut.Frames = pmData.Frames
+ }
+ if pmData.BroadcastFrames != errorCounterValue {
+ pmDataOut.BroadcastFrames = pmData.BroadcastFrames + pmDataIn["broadcast_frames"]
+ } else {
+ pmDataOut.BroadcastFrames = pmData.BroadcastFrames
+ }
+ if pmData.MulticastFrames != errorCounterValue {
+ pmDataOut.MulticastFrames = pmData.MulticastFrames + pmDataIn["multicast_frames"]
+ } else {
+ pmDataOut.MulticastFrames = pmData.MulticastFrames
+ }
+ if pmData.CrcErroredFrames != errorCounterValue {
+ pmDataOut.CrcErroredFrames = pmData.CrcErroredFrames + pmDataIn["crc_errored_frames"]
+ } else {
+ pmDataOut.CrcErroredFrames = pmData.CrcErroredFrames
+ }
+ if pmData.UndersizeFrames != errorCounterValue {
+ pmDataOut.UndersizeFrames = pmData.UndersizeFrames + pmDataIn["undersize_frames"]
+ } else {
+ pmDataOut.UndersizeFrames = pmData.UndersizeFrames
+ }
+ if pmData.OversizeFrames != errorCounterValue {
+ pmDataOut.OversizeFrames = pmData.OversizeFrames + pmDataIn["oversize_frames"]
+ } else {
+ pmDataOut.OversizeFrames = pmData.OversizeFrames
+ }
+ if pmData.Frames_64Octets != errorCounterValue {
+ pmDataOut.Frames_64Octets = pmData.Frames_64Octets + pmDataIn["64_octets"]
+ } else {
+ pmDataOut.Frames_64Octets = pmData.Frames_64Octets
+ }
+ if pmData.Frames_65To_127Octets != errorCounterValue {
+ pmDataOut.Frames_65To_127Octets = pmData.Frames_65To_127Octets + pmDataIn["65_to_127_octets"]
+ } else {
+ pmDataOut.Frames_65To_127Octets = pmData.Frames_65To_127Octets
+ }
+ if pmData.Frames_128To_255Octets != errorCounterValue {
+ pmDataOut.Frames_128To_255Octets = pmData.Frames_128To_255Octets + pmDataIn["128_to_255_octets"]
+ } else {
+ pmDataOut.Frames_128To_255Octets = pmData.Frames_128To_255Octets
+ }
+ if pmData.Frames_256To_511Octets != errorCounterValue {
+ pmDataOut.Frames_256To_511Octets = pmData.Frames_256To_511Octets + pmDataIn["256_to_511_octets"]
+ } else {
+ pmDataOut.Frames_256To_511Octets = pmData.Frames_256To_511Octets
+ }
+ if pmData.Frames_512To_1023Octets != errorCounterValue {
+ pmDataOut.Frames_512To_1023Octets = pmData.Frames_512To_1023Octets + pmDataIn["512_to_1023_octets"]
+ } else {
+ pmDataOut.Frames_512To_1023Octets = pmData.Frames_512To_1023Octets
+ }
+ if pmData.Frames_1024To_1518Octets != errorCounterValue {
+ pmDataOut.Frames_1024To_1518Octets = pmData.Frames_1024To_1518Octets + pmDataIn["1024_to_1518_octets"]
+ } else {
+ pmDataOut.Frames_1024To_1518Octets = pmData.Frames_1024To_1518Octets
+ }
+ } else {
+ pmDataOut.DropEvents = pmDataIn["drop_events"]
+ pmDataOut.Octets = pmDataIn["octets"]
+ pmDataOut.Frames = pmDataIn["frames"]
+ pmDataOut.BroadcastFrames = pmDataIn["broadcast_frames"]
+ pmDataOut.MulticastFrames = pmDataIn["multicast_frames"]
+ pmDataOut.CrcErroredFrames = pmDataIn["crc_errored_frames"]
+ pmDataOut.UndersizeFrames = pmDataIn["undersize_frames"]
+ pmDataOut.OversizeFrames = pmDataIn["oversize_frames"]
+ pmDataOut.Frames_64Octets = pmDataIn["64_octets"]
+ pmDataOut.Frames_65To_127Octets = pmDataIn["65_to_127_octets"]
+ pmDataOut.Frames_128To_255Octets = pmDataIn["128_to_255_octets"]
+ pmDataOut.Frames_256To_511Octets = pmDataIn["256_to_511_octets"]
+ pmDataOut.Frames_512To_1023Octets = pmDataIn["512_to_1023_octets"]
+ pmDataOut.Frames_1024To_1518Octets = pmDataIn["1024_to_1518_octets"]
+ }
+ return pmDataOut
+}
+
+func (mm *onuMetricsManager) getControlBlockForExtendedPMDirection(ctx context.Context, upstream bool, entityID uint16) []uint16 {
+ controlBlock := make([]uint16, 8)
+ // Control Block First two bytes are for threshold data 1/2 id - does not matter here
+ controlBlock[0] = 0
+ // Next two bytes are for the parent class ID
+ controlBlock[1] = (uint16)(me.PhysicalPathTerminationPointEthernetUniClassID)
+ // Next two bytes are for the parent me instance id
+ controlBlock[2] = entityID
+ // Next two bytes are for accumulation disable
+ controlBlock[3] = 0
+ // Next two bytes are for tca disable
+ controlBlock[4] = 0x4000 //tca global disable
+ // Next two bytes are for control fields - bit 1(lsb) as 1 for continuous accumulation and bit 2(0 for upstream)
+ if upstream {
+ controlBlock[5] = 1 << 0
+ } else {
+ controlBlock[5] = (1 << 0) | (1 << 1)
+ }
+ // Next two bytes are for tci - does not matter here
+ controlBlock[6] = 0
+ // Next two bytes are for reserved bits - does not matter here
+ controlBlock[7] = 0
+ return controlBlock
+}
diff --git a/internal/pkg/onuadaptercore/openonu.go b/internal/pkg/onuadaptercore/openonu.go
index 2c77aa2..2fabadd 100644
--- a/internal/pkg/onuadaptercore/openonu.go
+++ b/internal/pkg/onuadaptercore/openonu.go
@@ -610,6 +610,8 @@
// The timeout handling is already implemented in omci_self_test_handler module
resp := <-respChan
return &resp, nil
+ case *extension.GetValueRequest_OnuInfo:
+ return handler.getOnuOMCICounters(ctx, reqType.OnuInfo), nil
default:
return postUniStatusErrResponse(extension.GetValueResponse_UNSUPPORTED), nil
diff --git a/vendor/github.com/opencord/omci-lib-go/README.md b/vendor/github.com/opencord/omci-lib-go/README.md
index 959990a..a2aa972 100644
--- a/vendor/github.com/opencord/omci-lib-go/README.md
+++ b/vendor/github.com/opencord/omci-lib-go/README.md
@@ -49,6 +49,8 @@
- TestResult
- TestRequest
- TestResponse
+ - GetCurrentDataRequest
+ - GetCurrentDataResponse
## Message Types supported but lacking any unit test
The following OMCI message types currently have been coded but do not
@@ -57,8 +59,6 @@
- StartSoftwareDownloadResponse
- ActivateSoftwareRequest
- ActivateSoftwareResponse
- - GetCurrentDataRequest
- - GetCurrentDataResponse
## Message Types not yet supported
@@ -74,6 +74,10 @@
- GetRequest
- GetResponse
+ - DownloadSectionRequest/Response
+ - AlarmNotification
+ - AttributeValueChange
+ - TestResult
### Upcoming message types that will be supported
@@ -81,11 +85,6 @@
in the expected order of implementation. The priority was chosen based on speed improvement requests
of operations and ease of implementation.
- - DownloadSectionRequest/Response
- - AlarmNotification
- - AttributeValueChange
- - TestResult
-
- GetCurrentDataRequest/Response
- MibResetRequest/Response
- RebootRequest/Response
@@ -93,19 +92,21 @@
- CreateRequest/Response
- DeleteRequest/Response
- SetRequest/Response
-
+
+ - GetNextRequest/Response
+ - SetTableRequest/Response
+
- MibUploadRequest/Response
- MibUploadNextRequest/Response
+
- GetAllAlarmsRequest/Response
- GetAllAlarmsNextRequest/Response
- - GetNextRequest/Response
-
+
- StartSoftwareDownloadRequest/Response
- EndSoftwareDownloadRequest/Response
- CommitSoftwareRequest/Response
- ActivateSoftwareRequest/Response
- - SetTableRequest/Response
- TestRequest/Response
## Current user-test coverage
diff --git a/vendor/github.com/opencord/omci-lib-go/VERSION b/vendor/github.com/opencord/omci-lib-go/VERSION
index 9084fa2..3a3cd8c 100644
--- a/vendor/github.com/opencord/omci-lib-go/VERSION
+++ b/vendor/github.com/opencord/omci-lib-go/VERSION
@@ -1 +1 @@
-1.1.0
+1.3.1
diff --git a/vendor/github.com/opencord/omci-lib-go/layers.go b/vendor/github.com/opencord/omci-lib-go/layers.go
index aa49e8c..1e0b686 100644
--- a/vendor/github.com/opencord/omci-lib-go/layers.go
+++ b/vendor/github.com/opencord/omci-lib-go/layers.go
@@ -49,8 +49,10 @@
LayerTypeGetCurrentDataRequest gopacket.LayerType
LayerTypeSetTableRequest gopacket.LayerType
- // Extended Message Types
- LayerTypeGetRequestExtended gopacket.LayerType
+ // Extended Request Message Types
+ LayerTypeGetRequestExtended gopacket.LayerType
+ LayerTypeDownloadSectionRequestExtended gopacket.LayerType
+ LayerTypeDownloadSectionLastRequestExtended gopacket.LayerType
)
var (
// Baseline Message Types
@@ -78,8 +80,12 @@
LayerTypeGetCurrentDataResponse gopacket.LayerType
LayerTypeSetTableResponse gopacket.LayerType
- // Extended Message Types
- LayerTypeGetResponseExtended gopacket.LayerType
+ // Extended Response/Notification Message Types
+ LayerTypeGetResponseExtended gopacket.LayerType
+ LayerTypeDownloadSectionResponseExtended gopacket.LayerType
+ LayerTypeAlarmNotificationExtended gopacket.LayerType
+ LayerTypeAttributeValueChangeExtended gopacket.LayerType
+ LayerTypeTestResultExtended gopacket.LayerType
)
func mkReqLayer(mt me.MsgType, mts string, decode gopacket.DecodeFunc) gopacket.LayerType {
@@ -151,6 +157,13 @@
LayerTypeGetRequestExtended = mkReqLayer(me.Get|me.ExtendedOffset, "GetRequest-Ext", gopacket.DecodeFunc(decodeGetRequestExtended))
LayerTypeGetResponseExtended = mkRespLayer(me.Get|me.ExtendedOffset, "GetResponse-Ext", gopacket.DecodeFunc(decodeGetResponseExtended))
+ LayerTypeDownloadSectionRequestExtended = mkLayer(me.DownloadSection|me.ExtendedOffset, "DownloadSectionRequest-Ext", gopacket.DecodeFunc(decodeDownloadSectionRequestExtended))
+ LayerTypeDownloadSectionLastRequestExtended = mkReqLayer(me.DownloadSection|me.ExtendedOffset, "DownloadLastSectionRequest-Ext", gopacket.DecodeFunc(decodeDownloadSectionRequestExtended))
+ LayerTypeDownloadSectionResponseExtended = mkRespLayer(me.DownloadSection|me.ExtendedOffset, "DownloadSectionResponse-Ext", gopacket.DecodeFunc(decodeDownloadSectionResponseExtended))
+
+ LayerTypeAlarmNotificationExtended = mkLayer(me.AlarmNotification|me.ExtendedOffset, "AlarmNotification-Ext", gopacket.DecodeFunc(decodeAlarmNotificationExtended))
+ LayerTypeAttributeValueChangeExtended = mkLayer(me.AttributeValueChange|me.ExtendedOffset, "AttributeValueChange-Ext", gopacket.DecodeFunc(decodeAttributeValueChangeExtended))
+ LayerTypeTestResultExtended = mkLayer(me.TestResult|me.ExtendedOffset, "TestResult-Ext", gopacket.DecodeFunc(decodeTestResultExtended))
// Map message_type and action to layer
nextLayerMapping = make(map[MessageType]gopacket.LayerType)
@@ -205,6 +218,15 @@
// Extended message support
nextLayerMapping[GetRequestType+ExtendedTypeDecodeOffset] = LayerTypeGetRequestExtended
nextLayerMapping[GetResponseType+ExtendedTypeDecodeOffset] = LayerTypeGetResponseExtended
+
+ // For Download section, AR=0 if not response expected, AR=1 if response expected (last section of a window)
+ nextLayerMapping[DownloadSectionRequestType+ExtendedTypeDecodeOffset] = LayerTypeDownloadSectionRequestExtended
+ nextLayerMapping[DownloadSectionRequestWithResponseType+ExtendedTypeDecodeOffset] = LayerTypeDownloadSectionLastRequestExtended
+ nextLayerMapping[DownloadSectionResponseType+ExtendedTypeDecodeOffset] = LayerTypeDownloadSectionResponseExtended
+
+ nextLayerMapping[AlarmNotificationType+ExtendedTypeDecodeOffset] = LayerTypeAlarmNotificationExtended
+ nextLayerMapping[AttributeValueChangeType+ExtendedTypeDecodeOffset] = LayerTypeAttributeValueChangeExtended
+ nextLayerMapping[TestResultType+ExtendedTypeDecodeOffset] = LayerTypeTestResultExtended
}
func MsgTypeToNextLayer(mt MessageType, isExtended bool) (gopacket.LayerType, error) {
diff --git a/vendor/github.com/opencord/omci-lib-go/meframe.go b/vendor/github.com/opencord/omci-lib-go/meframe.go
index c13554c..472db31 100644
--- a/vendor/github.com/opencord/omci-lib-go/meframe.go
+++ b/vendor/github.com/opencord/omci-lib-go/meframe.go
@@ -283,17 +283,21 @@
// Software related frames have a wide variety of settable values. Placing them
// in a separate struct is mainly to keep the base options simple
type SoftwareOptions struct {
- WindowSize uint8 // Window size - 1
- ImageSize uint32
- CircuitPacks []uint16 // slot (upper 8 bits) and instance (lower 8 bits)
- Results []DownloadResults
+ WindowSize uint8 // Window size - 1
+ SectionNumber uint8 // [0..Window size - 1]
+ ImageSize uint32
+ CircuitPacks []uint16 // slot (upper 8 bits) and instance (lower 8 bits)
+ Results []DownloadResults
+ Data []byte
}
var defaultSoftwareOptions = SoftwareOptions{
- WindowSize: 0,
- ImageSize: 0,
- CircuitPacks: nil,
- Results: nil,
+ WindowSize: 0,
+ SectionNumber: 0,
+ ImageSize: 0,
+ CircuitPacks: nil,
+ Results: nil,
+ Data: nil,
}
// EncodeFrame will encode the Managed Entity specific protocol struct and an
@@ -364,9 +368,9 @@
}
// OMCI Header - 4 octets
// Class ID/Instance ID - 4 octets
- // Length field - 4 octets
+ // Length field - 2 octets
// MIC - 4 octets
- return MaxExtendedLength - 16
+ return MaxExtendedLength - 14
}
func calculateAttributeMask(m *me.ManagedEntity, requestedMask uint16) (uint16, error) {
@@ -1040,12 +1044,8 @@
}
func DownloadSectionRequestFrame(m *me.ManagedEntity, opt options) (gopacket.SerializableLayer, error) {
- if opt.frameFormat == ExtendedIdent {
- return nil, errors.New("Extended message set for this message type is not supported")
- }
- mask, err := checkAttributeMask(m, opt.attributeMask)
- if err != nil {
- return nil, err
+ if opt.software.Data == nil {
+ return nil, me.NewNonStatusError("Software image data missing")
}
// Common for all MEs
meLayer := &DownloadSectionRequest{
@@ -1054,24 +1054,13 @@
EntityInstance: m.GetEntityID(),
Extended: opt.frameFormat == ExtendedIdent,
},
+ SectionNumber: opt.software.SectionNumber,
+ SectionData: opt.software.Data,
}
- // Get payload space available
- maxPayload := maxPacketAvailable(m, opt)
-
- // TODO: Lots of work to do
-
- fmt.Println(mask, maxPayload)
- return meLayer, errors.New("todo: Not implemented")
+ return meLayer, nil
}
func DownloadSectionResponseFrame(m *me.ManagedEntity, opt options) (gopacket.SerializableLayer, error) {
- if opt.frameFormat == ExtendedIdent {
- return nil, errors.New("Extended message set for this message type is not supported")
- }
- mask, err := checkAttributeMask(m, opt.attributeMask)
- if err != nil {
- return nil, err
- }
// Common for all MEs
meLayer := &DownloadSectionResponse{
MeBasePacket: MeBasePacket{
@@ -1079,14 +1068,10 @@
EntityInstance: m.GetEntityID(),
Extended: opt.frameFormat == ExtendedIdent,
},
+ Result: opt.result,
+ SectionNumber: opt.software.SectionNumber,
}
- // Get payload space available
- maxPayload := maxPacketAvailable(m, opt)
-
- // TODO: Lots of work to do
-
- fmt.Println(mask, maxPayload)
- return meLayer, errors.New("todo: Not implemented")
+ return meLayer, nil
}
func EndSoftwareDownloadRequestFrame(m *me.ManagedEntity, opt options) (gopacket.SerializableLayer, error) {
diff --git a/vendor/github.com/opencord/omci-lib-go/messagetypes.go b/vendor/github.com/opencord/omci-lib-go/messagetypes.go
index 456bef8..5e5dd74 100644
--- a/vendor/github.com/opencord/omci-lib-go/messagetypes.go
+++ b/vendor/github.com/opencord/omci-lib-go/messagetypes.go
@@ -1673,7 +1673,7 @@
type AlarmNotificationMsg struct {
MeBasePacket
AlarmBitmap [AlarmBitmapSize / 8]byte
- zeroPadding [3]byte
+ zeroPadding [3]byte // Note: This zero padding is not present in the Extended Message Set
AlarmSequenceNumber byte
}
@@ -1795,17 +1795,28 @@
isUnsupported := classSupport == me.UnsupportedManagedEntity ||
classSupport == me.UnsupportedVendorSpecificManagedEntity
+ mapOffset := 4
+ if omci.Extended {
+ mapOffset = 6
+ if len(data) < 6+28+1 {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ }
// Look for a non-nil/not empty Alarm Map to determine if this ME supports alarms
if alarmMap := meDefinition.GetAlarmMap(); isUnsupported || (alarmMap != nil && len(alarmMap) > 0) {
- for index, octet := range data[4 : (AlarmBitmapSize/8)-4] {
+ for index, octet := range data[mapOffset : (AlarmBitmapSize/8)-mapOffset] {
omci.AlarmBitmap[index] = octet
}
- padOffset := 4 + (AlarmBitmapSize / 8)
- omci.zeroPadding[0] = data[padOffset]
- omci.zeroPadding[1] = data[padOffset+1]
- omci.zeroPadding[2] = data[padOffset+2]
-
- omci.AlarmSequenceNumber = data[padOffset+3]
+ if omci.Extended {
+ omci.AlarmSequenceNumber = data[mapOffset+(AlarmBitmapSize/8)]
+ } else {
+ padOffset := mapOffset + (AlarmBitmapSize / 8)
+ omci.zeroPadding[0] = data[padOffset]
+ omci.zeroPadding[1] = data[padOffset+1]
+ omci.zeroPadding[2] = data[padOffset+2]
+ omci.AlarmSequenceNumber = data[padOffset+3]
+ }
return nil
}
return me.NewProcessingError("managed entity does not support alarm notifications")
@@ -1817,6 +1828,13 @@
return decodingLayerDecoder(omci, data, p)
}
+func decodeAlarmNotificationExtended(data []byte, p gopacket.PacketBuilder) error {
+ omci := &AlarmNotificationMsg{}
+ omci.MsgLayerType = LayerTypeAlarmNotification
+ omci.Extended = true
+ return decodingLayerDecoder(omci, data, p)
+}
+
// SerializeTo provides serialization of an Alarm Notification message
func (omci *AlarmNotificationMsg) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
// Basic (common) OMCI Header is 8 octets, 10
@@ -1824,29 +1842,40 @@
if err != nil {
return err
}
- //var meDefinition me.IManagedEntityDefinition
- //meDefinition, err = me.LoadManagedEntityDefinition(omci.EntityClass,
+ // TODO: Support of encoding AlarmNotification into supported types not yet supported
+ //meDefinition, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
// me.ParamData{EntityID: omci.EntityInstance})
- //if err != nil {
- // return err
+ //if omciErr.StatusCode() != me.Success {
+ // return omciErr.GetError()
//}
- // ME needs to support Alarms
- // TODO: Add attribute to ME to specify that alarm is allowed
- //if !me.SupportsMsgType(meDefinition, me.MibReset) {
- // return me.NewProcessingError("managed entity does not support MIB Reset Message-Type")
+ //if !me.SupportsMsgType(meDefinition, me.AlarmNotification) {
+ // return me.NewProcessingError("managed entity does not support Alarm Notification Message-Type")
//}
- bytes, err := b.AppendBytes((AlarmBitmapSize / 8) + 3 + 1)
- if err != nil {
- return err
+ if omci.Extended {
+ bytes, err := b.AppendBytes(2 + (AlarmBitmapSize / 8) + 1)
+ if err != nil {
+ return err
+ }
+ binary.BigEndian.PutUint16(bytes, uint16((AlarmBitmapSize/8)+1))
+
+ for index, octet := range omci.AlarmBitmap {
+ bytes[2+index] = octet
+ }
+ bytes[2+(AlarmBitmapSize/8)] = omci.AlarmSequenceNumber
+ } else {
+ bytes, err := b.AppendBytes((AlarmBitmapSize / 8) + 3 + 1)
+ if err != nil {
+ return err
+ }
+ for index, octet := range omci.AlarmBitmap {
+ bytes[index] = octet
+ }
+ padOffset := AlarmBitmapSize / 8
+ bytes[padOffset] = 0
+ bytes[padOffset+1] = 0
+ bytes[padOffset+2] = 0
+ bytes[padOffset+3] = omci.AlarmSequenceNumber
}
- for index, octet := range omci.AlarmBitmap {
- bytes[index] = octet
- }
- padOffset := AlarmBitmapSize / 8
- bytes[padOffset] = 0
- bytes[padOffset+1] = 0
- bytes[padOffset+2] = 0
- bytes[padOffset+3] = omci.AlarmSequenceNumber
return nil
}
@@ -1875,9 +1904,18 @@
if omciErr.StatusCode() != me.Success {
return omciErr.GetError()
}
- omci.AttributeMask = binary.BigEndian.Uint16(data[4:6])
+ // TODO: Support for encoding AVC into message type support not yet supported
+ //if !me.SupportsMsgType(meDefinition, me.AlarmNotification) {
+ // return me.NewProcessingError("managed entity does not support Alarm Notification Message-Type")
+ //}
+ maskOffset := 4
+ if omci.Extended {
+ maskOffset = 6
+ }
+ omci.AttributeMask = binary.BigEndian.Uint16(data[maskOffset:])
// Attribute decode
- omci.Attributes, err = meDefinition.DecodeAttributes(omci.AttributeMask, data[6:40], p, byte(AttributeValueChangeType))
+ omci.Attributes, err = meDefinition.DecodeAttributes(omci.AttributeMask, data[maskOffset+2:],
+ p, byte(AttributeValueChangeType))
// TODO: Add support for attributes that can have an AVC associated with them and then add a check here
// Validate all attributes support AVC
//for attrName := range omci.attributes {
@@ -1899,6 +1937,13 @@
return decodingLayerDecoder(omci, data, p)
}
+func decodeAttributeValueChangeExtended(data []byte, p gopacket.PacketBuilder) error {
+ omci := &AttributeValueChangeMsg{}
+ omci.MsgLayerType = LayerTypeAttributeValueChange
+ omci.Extended = true
+ return decodingLayerDecoder(omci, data, p)
+}
+
// SerializeTo provides serialization of an Attribute Value Change Notification message
func (omci *AttributeValueChangeMsg) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
// Basic (common) OMCI Header is 8 octets, 10
@@ -1923,18 +1968,36 @@
// return me.NewProcessingError(msg)
// }
//}
- bytes, err := b.AppendBytes(2)
+ var maskOffset int
+ var bytesAvailable int
+ if omci.Extended {
+ maskOffset = 2
+ bytesAvailable = MaxExtendedLength - 12 - 4
+ } else {
+ maskOffset = 0
+ bytesAvailable = MaxBaselineLength - 10 - 8
+ }
+ bytes, err := b.AppendBytes(maskOffset + 2)
if err != nil {
return err
}
- binary.BigEndian.PutUint16(bytes, omci.AttributeMask)
+ binary.BigEndian.PutUint16(bytes[maskOffset:], omci.AttributeMask)
// Attribute serialization
- // TODO: Only Baseline supported at this time
- bytesAvailable := MaxBaselineLength - 10 - 8
+ attributeBuffer := gopacket.NewSerializeBuffer()
+ if err, _ = meDefinition.SerializeAttributes(omci.Attributes, omci.AttributeMask,
+ attributeBuffer, byte(GetResponseType), bytesAvailable, false); err != nil {
+ return err
+ }
- err, _ = meDefinition.SerializeAttributes(omci.Attributes, omci.AttributeMask, b,
- byte(AttributeValueChangeType), bytesAvailable, false)
+ if omci.Extended {
+ binary.BigEndian.PutUint16(bytes, uint16(len(attributeBuffer.Bytes())+2))
+ }
+ bytes, err = b.AppendBytes(len(attributeBuffer.Bytes()))
+ if err != nil {
+ return err
+ }
+ copy(bytes, attributeBuffer.Bytes())
return err
}
@@ -1950,13 +2013,13 @@
switch me.ClassID(classID) {
default:
omci := &TestRequest{}
- omci.MsgLayerType = LayerTypeTestResult
+ omci.MsgLayerType = LayerTypeTestRequest
return decodingLayerDecoder(omci, data, p)
case me.AniGClassID, me.ReAniGClassID, me.PhysicalPathTerminationPointReUniClassID,
me.ReUpstreamAmplifierClassID, me.ReDownstreamAmplifierClassID:
omci := &OpticalLineSupervisionTestRequest{}
- omci.MsgLayerType = LayerTypeTestResult
+ omci.MsgLayerType = LayerTypeTestRequest
return decodingLayerDecoder(omci, data, p)
}
}
@@ -2353,17 +2416,18 @@
return nil
}
-/////////////////////////////////////////////////////////////////////////////
-//
+// DownloadSectionRequest data is bound by the message set in use. For the
+// Baseline message set use MaxDownloadSectionLength and for the Extended message
+// set, MaxDownloadSectionExtendedLength is provided
type DownloadSectionRequest struct {
MeBasePacket // Note: EntityInstance for software download is two specific values
SectionNumber byte
- SectionData [31]byte // 0 padding if final transfer requires only a partial block
+ SectionData []byte // 0 padding if final transfer requires only a partial block for baseline set
}
func (omci *DownloadSectionRequest) String() string {
- return fmt.Sprintf("%v, Section #: %v",
- omci.MeBasePacket.String(), omci.SectionNumber)
+ return fmt.Sprintf("%v, Section #: %v, Data Length: %v",
+ omci.MeBasePacket.String(), omci.SectionNumber, len(omci.SectionData))
}
// DecodeFromBytes decodes the given bytes of a Download Section Request into this layer
@@ -2386,8 +2450,28 @@
if omci.EntityClass != me.SoftwareImageClassID {
return me.NewProcessingError("invalid Entity Class for Download Section request")
}
- omci.SectionNumber = data[4]
- copy(omci.SectionData[0:], data[5:])
+ if omci.Extended {
+ if len(data) < 7 {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ if len(data[7:]) > MaxDownloadSectionExtendedLength {
+ return errors.New(fmt.Sprintf("software image data too large. Received %v, Max: %v",
+ len(data[7:]), MaxDownloadSectionExtendedLength))
+ }
+ omci.SectionData = make([]byte, len(data[7:]))
+ omci.SectionNumber = data[6]
+ copy(omci.SectionData, data[7:])
+ } else {
+ if len(data[5:]) != MaxDownloadSectionLength {
+ p.SetTruncated()
+ return errors.New(fmt.Sprintf("software image size invalid. Received %v, Expected: %v",
+ len(data[5:]), MaxDownloadSectionLength))
+ }
+ omci.SectionData = make([]byte, MaxDownloadSectionLength)
+ omci.SectionNumber = data[4]
+ copy(omci.SectionData, data[5:])
+ }
return nil
}
@@ -2397,6 +2481,13 @@
return decodingLayerDecoder(omci, data, p)
}
+func decodeDownloadSectionRequestExtended(data []byte, p gopacket.PacketBuilder) error {
+ omci := &DownloadSectionRequest{}
+ omci.MsgLayerType = LayerTypeDownloadSectionRequest
+ omci.Extended = true
+ return decodingLayerDecoder(omci, data, p)
+}
+
// SerializeTo provides serialization of an Download Section Request message
func (omci *DownloadSectionRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
// Basic (common) OMCI Header is 8 octets, 10
@@ -2417,12 +2508,40 @@
if omci.EntityClass != me.SoftwareImageClassID {
return me.NewProcessingError("invalid Entity Class for Download Section response")
}
- bytes, err := b.AppendBytes(1 + len(omci.SectionData))
- if err != nil {
- return err
+ sectionLength := len(omci.SectionData)
+ if omci.Extended {
+ if sectionLength > MaxDownloadSectionExtendedLength {
+ msg := fmt.Sprintf("invalid Download Section data length, must be <= %v, received: %v",
+ MaxDownloadSectionExtendedLength, sectionLength)
+ return me.NewProcessingError(msg)
+ }
+ // Append section data
+ bytes, err := b.AppendBytes(3 + sectionLength)
+ if err != nil {
+ return err
+ }
+ binary.BigEndian.PutUint16(bytes, uint16(1+sectionLength))
+ bytes[2] = omci.SectionNumber
+ copy(bytes[3:], omci.SectionData)
+ } else {
+ if sectionLength > MaxDownloadSectionLength {
+ msg := fmt.Sprintf("invalid Download Section data length, must be <= %v, received: %v",
+ MaxDownloadSectionLength, sectionLength)
+ return me.NewProcessingError(msg)
+ }
+ // Append section data
+ bytes, err := b.AppendBytes(1 + MaxDownloadSectionLength)
+ if err != nil {
+ return err
+ }
+ bytes[0] = omci.SectionNumber
+ copy(bytes[1:], omci.SectionData)
+
+ // Zero extended if needed
+ if sectionLength < MaxDownloadSectionLength {
+ copy(omci.SectionData[sectionLength:], lotsOfZeros[:MaxDownloadSectionLength-sectionLength])
+ }
}
- bytes[0] = omci.SectionNumber
- copy(bytes[1:], omci.SectionData[0:])
return nil
}
@@ -2459,13 +2578,22 @@
if omci.EntityClass != me.SoftwareImageClassID {
return me.NewProcessingError("invalid Entity Class for Download Section response")
}
- omci.Result = me.Results(data[4])
+ if omci.Extended {
+ if len(data) < 8 {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ omci.Result = me.Results(data[6])
+ omci.SectionNumber = data[7]
+ } else {
+ omci.Result = me.Results(data[4])
+ omci.SectionNumber = data[5]
+ }
if omci.Result > me.DeviceBusy {
msg := fmt.Sprintf("invalid results for Download Section response: %v, must be 0..6",
omci.Result)
return errors.New(msg)
}
- omci.SectionNumber = data[5]
return nil
}
@@ -2475,6 +2603,13 @@
return decodingLayerDecoder(omci, data, p)
}
+func decodeDownloadSectionResponseExtended(data []byte, p gopacket.PacketBuilder) error {
+ omci := &DownloadSectionResponse{}
+ omci.MsgLayerType = LayerTypeDownloadSectionResponse
+ omci.Extended = true
+ return decodingLayerDecoder(omci, data, p)
+}
+
// SerializeTo provides serialization of an Download Section Response message
func (omci *DownloadSectionResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
// Basic (common) OMCI Header is 8 octets, 10
@@ -2495,17 +2630,27 @@
if omci.EntityClass != me.SoftwareImageClassID {
return me.NewProcessingError("invalid Entity Class for Download Section response")
}
- bytes, err := b.AppendBytes(2)
- if err != nil {
- return err
- }
if omci.Result > me.DeviceBusy {
msg := fmt.Sprintf("invalid results for Download Section response: %v, must be 0..6",
omci.Result)
return errors.New(msg)
}
- bytes[0] = byte(omci.Result)
- bytes[1] = omci.SectionNumber
+ if omci.Extended {
+ bytes, err := b.AppendBytes(4)
+ if err != nil {
+ return err
+ }
+ binary.BigEndian.PutUint16(bytes, uint16(2))
+ bytes[2] = byte(omci.Result)
+ bytes[3] = omci.SectionNumber
+ } else {
+ bytes, err := b.AppendBytes(2)
+ if err != nil {
+ return err
+ }
+ bytes[0] = byte(omci.Result)
+ bytes[1] = omci.SectionNumber
+ }
return nil
}
@@ -3553,6 +3698,31 @@
}
}
+func decodeTestResultExtended(data []byte, p gopacket.PacketBuilder) error {
+ // Peek at Managed Entity Type
+ if len(data) < 8 {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ classID := binary.BigEndian.Uint16(data)
+
+ // Is it a Managed Entity class we support customized decode of?
+ switch me.ClassID(classID) {
+ default:
+ omci := &TestResultNotification{}
+ omci.MsgLayerType = LayerTypeTestResult
+ omci.Extended = true
+ return decodingLayerDecoder(omci, data, p)
+
+ case me.AniGClassID, me.ReAniGClassID, me.PhysicalPathTerminationPointReUniClassID,
+ me.ReUpstreamAmplifierClassID, me.ReDownstreamAmplifierClassID:
+ omci := &OpticalLineSupervisionTestResult{}
+ omci.MsgLayerType = LayerTypeTestResult
+ omci.Extended = true
+ return decodingLayerDecoder(omci, data, p)
+ }
+}
+
type TestResultNotification struct {
MeBasePacket
Payload []byte
@@ -3569,7 +3739,11 @@
// DecodeFromBytes decodes the given bytes of a Test Result Notification into this layer
func (omci *TestResultNotification) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
// Common ClassID/EntityID decode in msgBase
- err := omci.MeBasePacket.DecodeFromBytes(data, p, 4)
+ payloadOffset := 4
+ if omci.Extended {
+ payloadOffset = 6
+ }
+ err := omci.MeBasePacket.DecodeFromBytes(data, p, payloadOffset)
if err != nil {
return err
}
@@ -3584,8 +3758,22 @@
if !me.SupportsMsgType(meDefinition, me.Test) {
return me.NewProcessingError("managed entity does not support Test Message-Type")
}
- omci.Payload = make([]byte, MaxTestResultsLength)
- copy(omci.Payload, omci.MeBasePacket.Payload)
+ if omci.Extended {
+ if len(data) < 6 {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ length := binary.BigEndian.Uint16(data[4:])
+ if len(data) < 6+int(length) {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ omci.Payload = make([]byte, length)
+ copy(omci.Payload, data[6:])
+ } else {
+ omci.Payload = make([]byte, MaxTestResultsLength)
+ copy(omci.Payload, omci.MeBasePacket.Payload)
+ }
return nil
}
@@ -3610,17 +3798,27 @@
if omci.Payload == nil {
return errors.New("Test Results payload is missing")
}
- if len(omci.Payload) > MaxTestResultsLength {
- msg := fmt.Sprintf("Invalid Test Results payload size. Received %v bytes, expected %v",
- len(omci.Payload), MaxTestResultsLength)
+
+ payloadOffset := 0
+ maxSize := MaxTestResultsLength
+
+ if omci.Extended {
+ payloadOffset = 2
+ maxSize = MaxExtendedLength - 10 - 4
+ }
+ if len(omci.Payload) > maxSize {
+ msg := fmt.Sprintf("Invalid Test Results payload size. Received %v bytes, max expected %v",
+ len(omci.Payload), maxSize)
return errors.New(msg)
}
- bytes, err := b.AppendBytes(len(omci.Payload))
+ bytes, err := b.AppendBytes(len(omci.Payload) + payloadOffset)
if err != nil {
return err
}
-
- copy(bytes, omci.Payload)
+ if omci.Extended {
+ binary.BigEndian.PutUint16(bytes, uint16(len(omci.Payload)))
+ }
+ copy(bytes[payloadOffset:], omci.Payload)
return nil
}
@@ -3653,7 +3851,11 @@
// DecodeFromBytes decodes the given bytes of a Test Result Notification into this layer
func (omci *OpticalLineSupervisionTestResult) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
// Common ClassID/EntityID decode in msgBase
- err := omci.MeBasePacket.DecodeFromBytes(data, p, 4+17)
+ payloadOffset := 4
+ if omci.Extended {
+ payloadOffset = 6
+ }
+ err := omci.MeBasePacket.DecodeFromBytes(data, p, payloadOffset+17)
if err != nil {
return err
}
@@ -3671,26 +3873,26 @@
// Note: Unsupported tests will have a type = 0 and the value should be zero
// as well, but that constraint is not enforced at this time.
// Type = 1
- omci.PowerFeedVoltageType = data[4]
- omci.PowerFeedVoltage = binary.BigEndian.Uint16(data[5:])
+ omci.PowerFeedVoltageType = data[payloadOffset]
+ omci.PowerFeedVoltage = binary.BigEndian.Uint16(data[payloadOffset+1:])
// Type = 3
- omci.ReceivedOpticalPowerType = data[7]
- omci.ReceivedOpticalPower = binary.BigEndian.Uint16(data[8:])
+ omci.ReceivedOpticalPowerType = data[payloadOffset+3]
+ omci.ReceivedOpticalPower = binary.BigEndian.Uint16(data[payloadOffset+4:])
// Type = 5
- omci.MeanOpticalLaunchType = data[10]
- omci.MeanOpticalLaunch = binary.BigEndian.Uint16(data[11:])
+ omci.MeanOpticalLaunchType = data[payloadOffset+6]
+ omci.MeanOpticalLaunch = binary.BigEndian.Uint16(data[payloadOffset+7:])
// Type = 9
- omci.LaserBiasCurrentType = data[13]
- omci.LaserBiasCurrent = binary.BigEndian.Uint16(data[14:])
+ omci.LaserBiasCurrentType = data[payloadOffset+9]
+ omci.LaserBiasCurrent = binary.BigEndian.Uint16(data[payloadOffset+10:])
// Type = 12
- omci.TemperatureType = data[16]
- omci.Temperature = binary.BigEndian.Uint16(data[17:])
+ omci.TemperatureType = data[payloadOffset+12]
+ omci.Temperature = binary.BigEndian.Uint16(data[payloadOffset+13:])
- omci.GeneralPurposeBuffer = binary.BigEndian.Uint16(data[19:])
+ omci.GeneralPurposeBuffer = binary.BigEndian.Uint16(data[payloadOffset+15:])
return nil
}
@@ -3711,22 +3913,30 @@
if !me.SupportsMsgType(meDefinition, me.Test) {
return me.NewProcessingError("managed entity does not support Test Message-Type")
}
- bytes, err := b.AppendBytes(17)
+ payloadOffset := 0
+
+ if omci.Extended {
+ payloadOffset = 2
+ }
+ bytes, err := b.AppendBytes(payloadOffset + 17)
if err != nil {
return err
}
- bytes[0] = omci.PowerFeedVoltageType
- binary.BigEndian.PutUint16(bytes[1:], omci.PowerFeedVoltage)
- bytes[3] = omci.ReceivedOpticalPowerType
- binary.BigEndian.PutUint16(bytes[4:], omci.ReceivedOpticalPower)
- bytes[6] = omci.MeanOpticalLaunchType
- binary.BigEndian.PutUint16(bytes[7:], omci.MeanOpticalLaunch)
- bytes[9] = omci.LaserBiasCurrentType
- binary.BigEndian.PutUint16(bytes[10:], omci.LaserBiasCurrent)
- bytes[12] = omci.TemperatureType
- binary.BigEndian.PutUint16(bytes[13:], omci.Temperature)
- binary.BigEndian.PutUint16(bytes[15:], omci.GeneralPurposeBuffer)
+ if omci.Extended {
+ binary.BigEndian.PutUint16(bytes, 17)
+ }
+ bytes[payloadOffset] = omci.PowerFeedVoltageType
+ binary.BigEndian.PutUint16(bytes[payloadOffset+1:], omci.PowerFeedVoltage)
+ bytes[payloadOffset+3] = omci.ReceivedOpticalPowerType
+ binary.BigEndian.PutUint16(bytes[payloadOffset+4:], omci.ReceivedOpticalPower)
+ bytes[payloadOffset+6] = omci.MeanOpticalLaunchType
+ binary.BigEndian.PutUint16(bytes[payloadOffset+7:], omci.MeanOpticalLaunch)
+ bytes[payloadOffset+9] = omci.LaserBiasCurrentType
+ binary.BigEndian.PutUint16(bytes[payloadOffset+10:], omci.LaserBiasCurrent)
+ bytes[payloadOffset+12] = omci.TemperatureType
+ binary.BigEndian.PutUint16(bytes[payloadOffset+13:], omci.Temperature)
+ binary.BigEndian.PutUint16(bytes[payloadOffset+15:], omci.GeneralPurposeBuffer)
return nil
}
@@ -3745,7 +3955,18 @@
// DecodeFromBytes decodes the given bytes of a Get Current Data Request into this layer
func (omci *GetCurrentDataRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
// Common ClassID/EntityID decode in msgBase
- err := omci.MeBasePacket.DecodeFromBytes(data, p, 4+2)
+ var offset int
+ if omci.Extended {
+ offset = 6
+ } else {
+ offset = 4
+ }
+ hdrSize := offset + 2
+ if len(data) < hdrSize {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ err := omci.MeBasePacket.DecodeFromBytes(data, p, hdrSize)
if err != nil {
return err
}
@@ -3760,7 +3981,7 @@
}
// Note: G.988 specifies that an error code of (3) should result if more
// than one attribute is requested
- omci.AttributeMask = binary.BigEndian.Uint16(data[4:6])
+ omci.AttributeMask = binary.BigEndian.Uint16(data[offset:])
return nil
}
@@ -3798,9 +4019,11 @@
//
type GetCurrentDataResponse struct {
MeBasePacket
- Result me.Results
- AttributeMask uint16
- Attributes me.AttributeValueMap
+ Result me.Results
+ AttributeMask uint16
+ UnsupportedAttributeMask uint16
+ FailedAttributeMask uint16
+ Attributes me.AttributeValueMap
}
func (omci *GetCurrentDataResponse) String() string {
@@ -3811,7 +4034,20 @@
// DecodeFromBytes decodes the given bytes of a Get Current Data Respnse into this layer
func (omci *GetCurrentDataResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
// Common ClassID/EntityID decode in msgBase
- err := omci.MeBasePacket.DecodeFromBytes(data, p, 4+3)
+ var offset, length int
+ if omci.Extended {
+ offset = 6
+ length = 7
+ } else {
+ offset = 4
+ length = 3
+ }
+ hdrSize := offset + length
+ if len(data) < hdrSize {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ err := omci.MeBasePacket.DecodeFromBytes(data, p, hdrSize)
if err != nil {
return err
}
@@ -3824,18 +4060,47 @@
if !me.SupportsMsgType(meDefinition, me.GetCurrentData) {
return me.NewProcessingError("managed entity does not support Get Current Data Message-Type")
}
- omci.AttributeMask = binary.BigEndian.Uint16(data[4:6])
-
+ omci.Result = me.Results(data[offset])
+ omci.AttributeMask = binary.BigEndian.Uint16(data[offset+1:])
switch omci.Result {
case me.ProcessingError, me.NotSupported, me.UnknownEntity, me.UnknownInstance, me.DeviceBusy:
return nil // Done (do not try and decode attributes)
+ case me.AttributeFailure:
+ if omci.Extended {
+ omci.UnsupportedAttributeMask = binary.BigEndian.Uint16(data[offset+3:])
+ omci.FailedAttributeMask = binary.BigEndian.Uint16(data[offset+5:])
+ } else {
+ omci.UnsupportedAttributeMask = binary.BigEndian.Uint16(data[32:])
+ omci.FailedAttributeMask = binary.BigEndian.Uint16(data[34:])
+ }
}
- // Attribute decode
- omci.Attributes, err = meDefinition.DecodeAttributes(omci.AttributeMask, data[6:], p, byte(GetCurrentDataResponseType))
+ // Attribute decode. Note that the ITU-T G.988 specification states that the
+ // Unsupported and Failed attribute masks are always present
+ // but only valid if the status code== 9. However some XGS
+ // ONUs (T&W and Alpha, perhaps more) will use these last 4
+ // octets for data if the status code == 0 in a baseline GET
+ // Response. So this behaviour is anticipated here as well
+ // and will be allowed in favor of greater interoperability.
+ omci.Attributes, err = meDefinition.DecodeAttributes(omci.AttributeMask, data[hdrSize:], p, byte(GetCurrentDataResponseType))
if err != nil {
return err
}
- return nil
+ // Validate all attributes support read
+ for attrName := range omci.Attributes {
+ attr, err := me.GetAttributeDefinitionByName(meDefinition.GetAttributeDefinitions(), attrName)
+ if err != nil {
+ return err
+ }
+ if attr.Index != 0 && !me.SupportsAttributeAccess(*attr, me.Read) {
+ msg := fmt.Sprintf("attribute '%v' does not support read access", attrName)
+ return me.NewProcessingError(msg)
+ }
+ }
+ if eidDef, eidDefOK := meDefinition.GetAttributeDefinitions()[0]; eidDefOK {
+ omci.Attributes[eidDef.GetName()] = omci.EntityInstance
+ return nil
+ }
+ return errors.New("All Managed Entities have an EntityID attribute")
}
func decodeGetCurrentDataResponse(data []byte, p gopacket.PacketBuilder) error {
@@ -3860,26 +4125,107 @@
if !me.SupportsMsgType(meDefinition, me.GetCurrentData) {
return me.NewProcessingError("managed entity does not support the Get Current Data Message-Type")
}
- bytes, err := b.AppendBytes(2)
+ var resultOffset, hdrSize int
+
+ if omci.Extended {
+ resultOffset = 2
+ hdrSize = resultOffset + 1 + 2 + 2 + 2 // length + result + masks
+ } else {
+ resultOffset = 0
+ hdrSize = resultOffset + 1 + 2 // length + result + attr-mask
+ }
+ bytes, err := b.AppendBytes(hdrSize)
if err != nil {
return err
}
- binary.BigEndian.PutUint16(bytes[0:2], omci.AttributeMask)
+ bytes[resultOffset] = byte(omci.Result)
+ binary.BigEndian.PutUint16(bytes[resultOffset+1:], omci.AttributeMask)
+ // Validate all attributes support read
+ for attrName := range omci.Attributes {
+ var attr *me.AttributeDefinition
+ attr, err = me.GetAttributeDefinitionByName(meDefinition.GetAttributeDefinitions(), attrName)
+ if err != nil {
+ return err
+ }
+ if attr.Index != 0 && !me.SupportsAttributeAccess(*attr, me.Read) {
+ msg := fmt.Sprintf("attribute '%v' does not support read access", attrName)
+ return me.NewProcessingError(msg)
+ }
+ }
// Attribute serialization
- // TODO: Only Baseline supported at this time
- bytesAvailable := MaxBaselineLength - 9 - 8
- var failedMask uint16
+ switch omci.Result {
+ default:
+ if omci.Extended {
+ binary.BigEndian.PutUint16(bytes, 7) // Length
+ binary.BigEndian.PutUint32(bytes[resultOffset+3:], 0)
+ }
+ break
- err, failedMask = meDefinition.SerializeAttributes(omci.Attributes, omci.AttributeMask, b,
- byte(GetCurrentDataResponseType), bytesAvailable, opts.FixLengths)
+ case me.Success, me.AttributeFailure:
+ var available int
+ if omci.Extended {
+ available = MaxExtendedLength - 10 - 3 - 4 - 4 // Less: header, result+mask, optional-masks mic
+ } else {
+ available = MaxBaselineLength - 8 - 3 - 4 - 8 // hdr, result+mask, optional-masks, trailer
+ }
+ // Serialize to temporary buffer if we may need to reset values due to
+ // recoverable truncation errors
+ attributeBuffer := gopacket.NewSerializeBuffer()
+ var failedMask uint16
+ err, failedMask = meDefinition.SerializeAttributes(omci.Attributes, omci.AttributeMask,
+ attributeBuffer, byte(GetCurrentDataResponseType), available, opts.FixLengths)
- if failedMask != 0 {
- // TODO: See GetResponse serialization above for the steps here
- return me.NewMessageTruncatedError("getCurrentData attribute truncation not yet supported")
- }
- if err != nil {
- return err
+ if err != nil {
+ return err
+ }
+ if failedMask != 0 {
+ // Not all attributes would fit
+ omci.FailedAttributeMask |= failedMask
+ omci.AttributeMask &= ^failedMask
+ omci.Result = me.AttributeFailure
+
+ // Adjust already recorded values
+ bytes[resultOffset] = byte(omci.Result)
+ binary.BigEndian.PutUint16(bytes[resultOffset+1:], omci.AttributeMask)
+ }
+ if omci.Extended {
+ // Set length and any failure masks
+ binary.BigEndian.PutUint16(bytes, uint16(len(attributeBuffer.Bytes())+7))
+
+ if omci.Result == me.AttributeFailure {
+ binary.BigEndian.PutUint16(bytes[resultOffset+3:], omci.UnsupportedAttributeMask)
+ binary.BigEndian.PutUint16(bytes[resultOffset+5:], omci.FailedAttributeMask)
+ } else {
+ binary.BigEndian.PutUint32(bytes[resultOffset+3:], 0)
+ }
+ }
+ // Copy over attributes to the original serialization buffer
+ var newSpace []byte
+
+ newSpace, err = b.AppendBytes(len(attributeBuffer.Bytes()))
+ if err != nil {
+ return err
+ }
+ copy(newSpace, attributeBuffer.Bytes())
+
+ if !omci.Extended {
+ // Calculate space left. Max - msgType header - OMCI trailer - spacedUsedSoFar
+ bytesLeft := MaxBaselineLength - 4 - 8 - len(b.Bytes())
+
+ var remainingBytes []byte
+ remainingBytes, err = b.AppendBytes(bytesLeft + 4)
+
+ if err != nil {
+ return me.NewMessageTruncatedError(err.Error())
+ }
+ copy(remainingBytes, lotsOfZeros[:])
+
+ if omci.Result == me.AttributeFailure {
+ binary.BigEndian.PutUint16(remainingBytes[bytesLeft-4:bytesLeft-2], omci.UnsupportedAttributeMask)
+ binary.BigEndian.PutUint16(remainingBytes[bytesLeft-2:bytesLeft], omci.FailedAttributeMask)
+ }
+ }
}
return nil
}
diff --git a/vendor/github.com/opencord/omci-lib-go/omci.go b/vendor/github.com/opencord/omci-lib-go/omci.go
index b2995d0..2f6d2d9 100644
--- a/vendor/github.com/opencord/omci-lib-go/omci.go
+++ b/vendor/github.com/opencord/omci-lib-go/omci.go
@@ -90,6 +90,10 @@
// attribute portion of the message contents and does not include the Result Code & Attribute Mask.
const MaxAttributeGetNextBaselineLength = MaxBaselineLength - 11 - 8
+// MaxDownloadSectionLength is the maximum payload size for section data of
+// a Download Section request message for the baseline message set.
+const MaxDownloadSectionLength = 31
+
// MaxTestRequestLength is the maximum payload size for test request message
// for the baseline message set.
const MaxTestRequestLength = MaxBaselineLength - 8 - 8
@@ -109,6 +113,10 @@
// message contents and does not include the Result Code & Attribute Mask.
const MaxAttributeGetNextExtendedLength = MaxExtendedLength - 13 - 4
+// MaxDownloadSectionExtendedLength is the maximum payload size for section data of
+// a Download Section request message for the extended message set.
+const MaxDownloadSectionExtendedLength = MaxExtendedLength - 11 - 4
+
// NullEntityID is often used as the Null/void Managed Entity ID for attributes
// that are used to refer to other Managed Entities but are currently not provisioned.
const NullEntityID = uint16(0xffff)
diff --git a/vendor/modules.txt b/vendor/modules.txt
index eedfe13..addc4c4 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -61,7 +61,7 @@
# github.com/looplab/fsm v0.2.0
## explicit
github.com/looplab/fsm
-# github.com/opencord/omci-lib-go v1.1.0
+# github.com/opencord/omci-lib-go v1.3.1
## explicit
github.com/opencord/omci-lib-go
github.com/opencord/omci-lib-go/generated