VOL-4028: Support ANI-G test message at openonu-go adapter
Change-Id: Ibcdcf67e3f80fc30d673c1d8cc657bff654e9ee6
diff --git a/go.mod b/go.mod
index c06a88f..b2343b8 100644
--- a/go.mod
+++ b/go.mod
@@ -9,9 +9,9 @@
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 v0.17.0
+ github.com/opencord/omci-lib-go v1.1.0
github.com/opencord/voltha-lib-go/v4 v4.3.1
- github.com/opencord/voltha-protos/v4 v4.1.1
+ github.com/opencord/voltha-protos/v4 v4.1.4
github.com/stretchr/testify v1.6.1
google.golang.org/grpc v1.25.1 // indirect
)
diff --git a/go.sum b/go.sum
index 84e6203..15abc56 100644
--- a/go.sum
+++ b/go.sum
@@ -150,12 +150,13 @@
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 v0.17.0 h1:mSRtsWQ+y+mLUzLDrMNsQaMUb1fxKSXxXfl6sz3tgtA=
-github.com/opencord/omci-lib-go v0.17.0/go.mod h1:moNk4j00XaM3olsu4a8lRAqGmcZJoyIbxtSr+VERLq4=
+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/voltha-lib-go/v4 v4.3.1 h1:z2CgB3un53IgbYTsz+pdRtmQ3E6e6+PieGQDyHaQN1A=
github.com/opencord/voltha-lib-go/v4 v4.3.1/go.mod h1:65GN71j4os0ApBRR+xbJ93iAMJMKIwVi/npG/hbPt8w=
-github.com/opencord/voltha-protos/v4 v4.1.1 h1:yovQHC+JQSrw5zxj0UeQqmyFUBQ+487JdG5w5ttrRyc=
github.com/opencord/voltha-protos/v4 v4.1.1/go.mod h1:W/OIFIyvFh/C0vchRUuarIsMylEhzCRM9pNxLvkPtKc=
+github.com/opencord/voltha-protos/v4 v4.1.4 h1:mpE4y7zRmoEXMX4seurWBWQ97u2a4rAf8gY2qONjz8I=
+github.com/opencord/voltha-protos/v4 v4.1.4/go.mod h1:W/OIFIyvFh/C0vchRUuarIsMylEhzCRM9pNxLvkPtKc=
github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU=
github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
github.com/phayes/freeport v0.0.0-20180830031419-95f893ade6f2 h1:JhzVVoYvbOACxoUmOs6V/G4D5nPVUW73rKvXxP4XUJc=
diff --git a/internal/pkg/onuadaptercore/device_handler.go b/internal/pkg/onuadaptercore/device_handler.go
index 54e778b..67fccc7 100644
--- a/internal/pkg/onuadaptercore/device_handler.go
+++ b/internal/pkg/onuadaptercore/device_handler.go
@@ -185,6 +185,7 @@
pOnuTP *onuUniTechProf
pOnuMetricsMgr *onuMetricsManager
pAlarmMgr *onuAlarmManager
+ pSelfTestHdlr *selfTestControlBlock
exitChannel chan int
lockDevice sync.RWMutex
pOnuIndication *oop.OnuIndication
@@ -1369,13 +1370,14 @@
//setOnuDeviceEntry sets the ONU device entry within the handler
func (dh *deviceHandler) setOnuDeviceEntry(
- apDeviceEntry *OnuDeviceEntry, apOnuTp *onuUniTechProf, apOnuMetricsMgr *onuMetricsManager, apOnuAlarmMgr *onuAlarmManager) {
+ apDeviceEntry *OnuDeviceEntry, apOnuTp *onuUniTechProf, apOnuMetricsMgr *onuMetricsManager, apOnuAlarmMgr *onuAlarmManager, apSelfTestHdlr *selfTestControlBlock) {
dh.lockDevice.Lock()
defer dh.lockDevice.Unlock()
dh.pOnuOmciDevice = apDeviceEntry
dh.pOnuTP = apOnuTp
dh.pOnuMetricsMgr = apOnuMetricsMgr
dh.pAlarmMgr = apOnuAlarmMgr
+ dh.pSelfTestHdlr = apSelfTestHdlr
}
//addOnuDeviceEntry creates a new ONU device or returns the existing
@@ -1392,8 +1394,9 @@
onuTechProfProc := newOnuUniTechProf(ctx, dh)
onuMetricsMgr := newonuMetricsManager(ctx, dh)
onuAlarmManager := newAlarmManager(ctx, dh)
+ selfTestHdlr := newSelfTestMsgHandlerCb(ctx, dh)
//error treatment possible //TODO!!!
- dh.setOnuDeviceEntry(deviceEntry, onuTechProfProc, onuMetricsMgr, onuAlarmManager)
+ dh.setOnuDeviceEntry(deviceEntry, onuTechProfProc, onuMetricsMgr, onuAlarmManager, selfTestHdlr)
// fire deviceEntry ready event to spread to possibly waiting processing
dh.deviceEntrySet <- true
logger.Debugw(ctx, "onuDeviceEntry-added", log.Fields{"device-id": dh.deviceID})
diff --git a/internal/pkg/onuadaptercore/omci_cc.go b/internal/pkg/onuadaptercore/omci_cc.go
index 7d28169..b37230b 100644
--- a/internal/pkg/onuadaptercore/omci_cc.go
+++ b/internal/pkg/onuadaptercore/omci_cc.go
@@ -329,7 +329,9 @@
}
logger.Debugw(ctx, "omci-message-decoded:", log.Fields{"omciMsgType": omciMsg.MessageType,
"transCorrId": strconv.FormatInt(int64(omciMsg.TransactionID), 16), "DeviceIdent": omciMsg.DeviceIdentifier})
- if byte(omciMsg.MessageType)&me.AK == 0 {
+ // TestResult is asynchronous indication that carries the same TID as the TestResponse.
+ // We expect to find the TID in the oo.rxSchedulerMap
+ if byte(omciMsg.MessageType)&me.AK == 0 && omciMsg.MessageType != omci.TestResultType {
// Not a response
oo.printRxMessage(ctx, rxMsg)
logger.Debug(ctx, "RxMsg is no Omci Response Message")
@@ -340,7 +342,6 @@
log.Fields{"msgType": omciMsg.MessageType, "payload": hex.EncodeToString(omciMsg.Payload),
"device-id": oo.deviceID})
return fmt.Errorf("autonomous Omci Message with TranSCorrId != 0 not acccepted %s", oo.deviceID)
-
}
//logger.Debug(ctx,"RxMsg is a Omci Response Message: try to schedule it to the requester")
oo.mutexRxSchedMap.Lock()
@@ -356,8 +357,12 @@
oo.pOnuDeviceEntry.incrementMibDataSync(ctx)
}
- // having posted the response the request is regarded as 'done'
- delete(oo.rxSchedulerMap, omciMsg.TransactionID)
+ // If omciMsg.MessageType is omci.TestResponseType, we still expect the TestResult OMCI message,
+ // so do not clean up the TransactionID in that case.
+ if omciMsg.MessageType != omci.TestResponseType {
+ // having posted the response the request is regarded as 'done'
+ delete(oo.rxSchedulerMap, omciMsg.TransactionID)
+ }
oo.mutexRxSchedMap.Unlock()
return nil
}
@@ -476,6 +481,12 @@
}
*/
+// ReleaseTid releases OMCI transaction identifier from rxSchedulerMap
+func (oo *omciCC) ReleaseTid(ctx context.Context, tid uint16) {
+ logger.Debugw(ctx, "releasing tid from rxSchedulerMap", log.Fields{"tid": tid})
+ delete(oo.rxSchedulerMap, tid)
+}
+
//Queue the OMCI Frame for a transmit to the ONU via the proxy_channel
func (oo *omciCC) send(ctx context.Context, txFrame []byte, timeout int, retry int, highPrio bool,
receiveCallbackPair callbackPair) error {
@@ -2892,10 +2903,64 @@
return nil
}
+func (oo *omciCC) sendSelfTestReq(ctx context.Context, classID me.ClassID, instdID uint16, timeout int, highPrio bool, rxChan chan Message) error {
+ tid := oo.getNextTid(highPrio)
+ logger.Debugw(ctx, "send self test request:", log.Fields{"device-id": oo.deviceID,
+ "SequNo": strconv.FormatInt(int64(tid), 16),
+ "InstId": strconv.FormatInt(int64(instdID), 16)})
+ omciLayer := &omci.OMCI{
+ TransactionID: tid,
+ MessageType: omci.TestRequestType,
+ // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
+ // Length: 0x28, // Optional, defaults to 40 octets
+ }
+
+ var request *omci.OpticalLineSupervisionTestRequest
+ switch classID {
+ case aniGClassID:
+ request = &omci.OpticalLineSupervisionTestRequest{
+ MeBasePacket: omci.MeBasePacket{
+ EntityClass: classID,
+ EntityInstance: instdID,
+ },
+ SelectTest: uint8(7), // self test
+ GeneralPurposeBuffer: uint16(0),
+ VendorSpecificParameters: uint16(0),
+ }
+ default:
+ logger.Errorw(ctx, "unsupported class id for self test request", log.Fields{"device-id": oo.deviceID, "classID": classID})
+ return fmt.Errorf("unsupported-class-id-for-self-test-request-%v", classID)
+ }
+ // Test serialization back to former string
+ var options gopacket.SerializeOptions
+ options.FixLengths = true
+
+ buffer := gopacket.NewSerializeBuffer()
+ err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+ if err != nil {
+ logger.Errorw(ctx, "Cannot serialize self test request", log.Fields{"Err": err,
+ "device-id": oo.deviceID})
+ return err
+ }
+ outgoingPacket := buffer.Bytes()
+
+ omciRxCallbackPair := callbackPair{cbKey: tid,
+ cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
+ }
+ err = oo.send(ctx, outgoingPacket, timeout, 0, highPrio, omciRxCallbackPair)
+ if err != nil {
+ logger.Errorw(ctx, "Cannot send self test request", log.Fields{"Err": err,
+ "device-id": oo.deviceID})
+ return err
+ }
+ logger.Debug(ctx, "send self test request done")
+ return nil
+}
+
func isSuccessfulResponseWithMibDataSync(omciMsg *omci.OMCI, packet *gp.Packet) bool {
for _, v := range responsesWithMibDataSync {
if v == omciMsg.MessageType {
- nextLayer, _ := omci.MsgTypeToNextLayer(v)
+ nextLayer, _ := omci.MsgTypeToNextLayer(v, false)
msgLayer := (*packet).Layer(nextLayer)
switch nextLayer {
case omci.LayerTypeCreateResponse:
diff --git a/internal/pkg/onuadaptercore/omci_self_test_handler.go b/internal/pkg/onuadaptercore/omci_self_test_handler.go
new file mode 100644
index 0000000..c38e89b
--- /dev/null
+++ b/internal/pkg/onuadaptercore/omci_self_test_handler.go
@@ -0,0 +1,383 @@
+/*
+ * Copyright 2021-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package adaptercoreonu provides the utility for onu devices, flows and statistics
+package adaptercoreonu
+
+import (
+ "context"
+ "fmt"
+ "github.com/looplab/fsm"
+ "github.com/opencord/omci-lib-go"
+ "github.com/opencord/omci-lib-go/generated"
+ "github.com/opencord/voltha-lib-go/v4/pkg/log"
+ "github.com/opencord/voltha-protos/v4/go/extension"
+ "sync"
+ "time"
+)
+
+const (
+ // events of Self Test FSM
+ selfTestEventTestRequest = "selfTestEventTestRequest"
+ selfTestEventTestResponseSuccess = "selfTestEventTestResponseSuccess"
+ selfTestEventTestResultSuccess = "selfTestEventTestResultSuccess"
+ selfTestEventAbort = "selfTestEventAbort"
+)
+const (
+ // states of Self Test FSM
+ selfTestStNull = "selfTestStNull"
+ selfTestStHandleSelfTestReq = "selfTestStHandleSelfTestReq"
+ selfTestStHandleSelfTestResp = "selfTestStHandleSelfTestResp"
+ selfTestStHandleTestResult = "selfTestStHandleTestResult"
+)
+
+const (
+ //SelfTestResponseWaitTimeout specifies timeout value waiting for self test response. Unit in seconds
+ SelfTestResponseWaitTimeout = 2
+)
+
+// We initiate an fsmCb per Self Test Request
+type fsmCb struct {
+ fsm *AdapterFsm
+ reqMsg extension.SingleGetValueRequest
+ respChan chan extension.SingleGetValueResponse
+ stopOmciChan chan bool
+}
+
+type selfTestControlBlock struct {
+ pDeviceHandler *deviceHandler
+ deviceID string
+
+ selfTestFsmMap map[generated.ClassID]*fsmCb // The fsmCb is indexed by ME Class ID of the Test Action procedure
+ selfTestFsmLock sync.RWMutex
+
+ stopSelfTestModule chan bool
+}
+
+// newSelfTestMsgHandlerCb creates the selfTestControlBlock
+// Self Test Handler module supports sending SelfTestRequest and handling of SelfTestResponse/SelfTestResults
+// An ephemeral Self Test FSM is initiated for every Self Test request and multiple Self Tests on different
+// MEs (that support it) can be handled in parallel.
+// At the time of creating this module, only ANI-G self-test is supported.
+func newSelfTestMsgHandlerCb(ctx context.Context, dh *deviceHandler) *selfTestControlBlock {
+ selfTestCb := selfTestControlBlock{pDeviceHandler: dh}
+ selfTestCb.selfTestFsmMap = make(map[generated.ClassID]*fsmCb)
+ selfTestCb.deviceID = selfTestCb.pDeviceHandler.deviceID
+ selfTestCb.stopSelfTestModule = make(chan bool)
+
+ go selfTestCb.waitForStopSelfTestModuleSignal(ctx)
+
+ return &selfTestCb
+}
+
+func (selfTestCb *selfTestControlBlock) initiateNewSelfTestFsm(ctx context.Context, reqMsg extension.SingleGetValueRequest, commChan chan Message, classID generated.ClassID, respChan chan extension.SingleGetValueResponse) error {
+ aFsm := NewAdapterFsm("selfTestFsm", selfTestCb.deviceID, commChan)
+
+ if aFsm == nil {
+ logger.Errorw(ctx, "selfTestFsm AdapterFsm could not be instantiated!!", log.Fields{
+ "device-id": selfTestCb.deviceID})
+ return fmt.Errorf("nil-adapter-fsm")
+ }
+ // Self Test FSM related state machine
+ aFsm.pFsm = fsm.NewFSM(
+
+ selfTestStNull,
+ fsm.Events{
+ {Name: selfTestEventTestRequest, Src: []string{selfTestStNull}, Dst: selfTestStHandleSelfTestReq},
+ {Name: selfTestEventTestResponseSuccess, Src: []string{selfTestStHandleSelfTestReq}, Dst: selfTestStHandleSelfTestResp},
+ {Name: selfTestEventTestResultSuccess, Src: []string{selfTestStHandleSelfTestResp}, Dst: selfTestStNull},
+ {Name: selfTestEventAbort, Src: []string{selfTestStHandleSelfTestReq, selfTestStHandleSelfTestReq, selfTestStHandleTestResult, selfTestStNull}, Dst: selfTestStNull},
+ },
+ fsm.Callbacks{
+ "enter_state": func(e *fsm.Event) { aFsm.logFsmStateChange(ctx, e) },
+ "enter_" + selfTestStHandleSelfTestReq: func(e *fsm.Event) { selfTestCb.selfTestFsmHandleSelfTestRequest(ctx, e) },
+ "enter_" + selfTestStHandleSelfTestResp: func(e *fsm.Event) { selfTestCb.selfTestFsmHandleSelfTestResponse(ctx, e) },
+ },
+ )
+ selfTestCb.selfTestFsmLock.Lock()
+ selfTestCb.selfTestFsmMap[classID] = &fsmCb{fsm: aFsm, reqMsg: reqMsg, respChan: respChan, stopOmciChan: make(chan bool)}
+ // Initiate the selfTestEventTestRequest on the FSM. Also pass the additional argument - classID.
+ // This is useful for the the FSM handler function to pull out fsmCb from the selfTestCb.selfTestFsmMap map.
+ selfTestCb.triggerFsmEvent(aFsm, selfTestEventTestRequest, classID)
+ selfTestCb.selfTestFsmLock.Unlock()
+
+ return nil
+}
+
+///// FSM Handlers
+
+func (selfTestCb *selfTestControlBlock) selfTestFsmHandleSelfTestRequest(ctx context.Context, e *fsm.Event) {
+ classID := e.Args[0].(generated.ClassID)
+ selfTestCb.selfTestFsmLock.RLock()
+ pFsmCb, ok := selfTestCb.selfTestFsmMap[classID]
+ selfTestCb.selfTestFsmLock.RUnlock()
+ if !ok {
+ // This case is impossible. Would be curious to see if this happens
+ logger.Fatalw(ctx, "class-id-not-found", log.Fields{"device-id": selfTestCb.deviceID, "classID": classID})
+ }
+ instKeys := selfTestCb.pDeviceHandler.pOnuOmciDevice.pOnuDB.getSortedInstKeys(ctx, classID)
+
+ // TODO: Choosing the first index from the instance keys. For ANI-G, this is fine as there is only one ANI-G instance. How do we handle and report self test for multiple instances?
+ if err := selfTestCb.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendSelfTestReq(ctx, classID, instKeys[0], selfTestCb.pDeviceHandler.pOpenOnuAc.omciTimeout, false, pFsmCb.fsm.commChan); err != nil {
+ logger.Errorw(ctx, "error sending self test request", log.Fields{"device-id": selfTestCb.deviceID, "classID": classID})
+ selfTestCb.triggerFsmEvent(pFsmCb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, pFsmCb.respChan, extension.GetValueResponse_INTERNAL_ERROR, extension.GetValueResponse_ERROR)
+ return
+ }
+
+ go selfTestCb.handleOmciResponse(ctx, classID)
+}
+
+func (selfTestCb *selfTestControlBlock) selfTestFsmHandleSelfTestResponse(ctx context.Context, e *fsm.Event) {
+ classID := e.Args[0].(generated.ClassID)
+ // Pass the test result processing to another routine
+ go selfTestCb.handleOmciResponse(ctx, classID)
+
+}
+
+///// Utility functions
+
+func (selfTestCb *selfTestControlBlock) getMeClassID(ctx context.Context, reqMsg extension.SingleGetValueRequest) (generated.ClassID, error) {
+ switch reqMsg.GetRequest().GetRequest().(type) {
+ case *extension.GetValueRequest_OnuOpticalInfo:
+ return aniGClassID, nil
+ default:
+ logger.Warnw(ctx, "unsupported me class id for self test", log.Fields{"device-id": selfTestCb.deviceID})
+ return 0, fmt.Errorf("unsupported me class id for self test %v", selfTestCb.deviceID)
+ }
+}
+
+func (selfTestCb *selfTestControlBlock) triggerFsmEvent(pSelfTestFsm *AdapterFsm, event string, args ...generated.ClassID) {
+ go func() {
+ if len(args) > 0 {
+ _ = pSelfTestFsm.pFsm.Event(event, args[0])
+ } else {
+ _ = pSelfTestFsm.pFsm.Event(event)
+ }
+ }()
+}
+
+func (selfTestCb *selfTestControlBlock) submitFailureGetValueResponse(ctx context.Context, respChan chan extension.SingleGetValueResponse, errorCode extension.GetValueResponse_ErrorReason, statusCode extension.GetValueResponse_Status) {
+ singleValResp := extension.SingleGetValueResponse{
+ Response: &extension.GetValueResponse{
+ Status: statusCode,
+ ErrReason: errorCode,
+ },
+ }
+ logger.Infow(ctx, "OMCI test response failure - pushing failure response", log.Fields{"device-id": selfTestCb.deviceID})
+ respChan <- singleValResp
+ logger.Infow(ctx, "OMCI test response failure - pushing failure response complete", log.Fields{"device-id": selfTestCb.deviceID})
+}
+
+func (selfTestCb *selfTestControlBlock) handleOmciMessage(ctx context.Context, msg OmciMessage, cb *fsmCb, classID generated.ClassID) {
+ logger.Debugw(ctx, "omci Msg", log.Fields{"device-id": selfTestCb.deviceID, "msgType": msg.OmciMsg.MessageType, "msg": msg})
+ switch msg.OmciMsg.MessageType {
+ case omci.TestResponseType:
+ selfTestCb.handleOmciTestResponse(ctx, msg, cb, classID)
+ case omci.TestResultType:
+ selfTestCb.handleOmciTestResult(ctx, msg, cb, classID)
+ default:
+ logger.Warnw(ctx, "Unknown Message Type", log.Fields{"msgType": msg.OmciMsg.MessageType})
+ selfTestCb.triggerFsmEvent(cb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, cb.respChan, extension.GetValueResponse_UNSUPPORTED, extension.GetValueResponse_ERROR)
+ }
+}
+
+func (selfTestCb *selfTestControlBlock) handleOmciTestResponse(ctx context.Context, msg OmciMessage, cb *fsmCb, classID generated.ClassID) {
+ msgLayer := (*msg.OmciPacket).Layer(omci.LayerTypeTestResponse)
+ if msgLayer == nil {
+ logger.Errorw(ctx, "omci Msg layer nil self test response", log.Fields{"device-id": selfTestCb.deviceID, "classID": classID})
+ selfTestCb.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.ReleaseTid(ctx, msg.OmciMsg.TransactionID)
+ selfTestCb.triggerFsmEvent(cb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, cb.respChan, extension.GetValueResponse_INTERNAL_ERROR, extension.GetValueResponse_ERROR)
+ return
+ }
+ msgObj, msgOk := msgLayer.(*omci.TestResponse)
+ if !msgOk {
+ logger.Errorw(ctx, "omci Msg layer could not be detected for self test response", log.Fields{"device-id": selfTestCb.deviceID, "classID": classID})
+ selfTestCb.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.ReleaseTid(ctx, msg.OmciMsg.TransactionID)
+ selfTestCb.triggerFsmEvent(cb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, cb.respChan, extension.GetValueResponse_INTERNAL_ERROR, extension.GetValueResponse_ERROR)
+ return
+ }
+ logger.Debugw(ctx, "OMCI test response Data", log.Fields{"device-id": selfTestCb.deviceID, "data-fields": msgObj})
+ if msgObj.Result == generated.Success && msgObj.EntityClass == classID {
+ logger.Infow(ctx, "OMCI test response success", log.Fields{"device-id": selfTestCb.deviceID, "classID": classID})
+ selfTestCb.triggerFsmEvent(cb.fsm, selfTestEventTestResponseSuccess, classID)
+ return
+ }
+
+ logger.Infow(ctx, "OMCI test response failure", log.Fields{"device-id": selfTestCb.deviceID, "classID": classID})
+ selfTestCb.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.ReleaseTid(ctx, msg.OmciMsg.TransactionID)
+ selfTestCb.triggerFsmEvent(cb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, cb.respChan, extension.GetValueResponse_UNSUPPORTED, extension.GetValueResponse_ERROR)
+}
+
+func (selfTestCb *selfTestControlBlock) handleOmciTestResult(ctx context.Context, msg OmciMessage, cb *fsmCb, classID generated.ClassID) {
+ msgLayer := (*msg.OmciPacket).Layer(omci.LayerTypeTestResult)
+ if msgLayer == nil {
+ logger.Errorw(ctx, "omci Msg layer nil self test result", log.Fields{"device-id": selfTestCb.deviceID, "classID": classID})
+ selfTestCb.triggerFsmEvent(cb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, cb.respChan, extension.GetValueResponse_INTERNAL_ERROR, extension.GetValueResponse_ERROR)
+ return
+ }
+ var msgObj *omci.OpticalLineSupervisionTestResult
+ var msgOk bool
+ switch classID {
+ case aniGClassID:
+ msgObj, msgOk = msgLayer.(*omci.OpticalLineSupervisionTestResult)
+ default:
+ // We should not really land here
+ selfTestCb.triggerFsmEvent(cb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, cb.respChan, extension.GetValueResponse_INTERNAL_ERROR, extension.GetValueResponse_ERROR)
+ return
+ }
+ if !msgOk {
+ logger.Errorw(ctx, "omci Msg layer could not be detected for self test result", log.Fields{"device-id": selfTestCb.deviceID, "classID": classID})
+ selfTestCb.triggerFsmEvent(cb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, cb.respChan, extension.GetValueResponse_INTERNAL_ERROR, extension.GetValueResponse_ERROR)
+ return
+ }
+ logger.Debugw(ctx, "raw omci values of ani-g test result",
+ log.Fields{"device-id": selfTestCb.deviceID,
+ "power-feed-voltage": msgObj.PowerFeedVoltage,
+ "rx-power": msgObj.ReceivedOpticalPower,
+ "tx-power": msgObj.MeanOpticalLaunch,
+ "laser-bias-current": msgObj.LaserBiasCurrent,
+ "temperature": msgObj.Temperature})
+ singleValResp := extension.SingleGetValueResponse{
+ Response: &extension.GetValueResponse{
+ Status: extension.GetValueResponse_OK,
+ Response: &extension.GetValueResponse_OnuOpticalInfo{
+ OnuOpticalInfo: &extension.GetOnuPonOpticalInfoResponse{
+ // OMCI representation is Volts, 2s compliment, 20mV resolution
+ PowerFeedVoltage: float32(TwosComplementToSignedInt16(msgObj.PowerFeedVoltage)) * 0.02,
+ // OMCI representation is Decibel-microwatts, 2s compliment, 0.002dB resolution
+ // Note: The OMCI table A.3.39.5 seems to be wrong about resolution. While it says the units are
+ // in Decibel-microwatts, 2s complement, 0.002 dB resolution, it actually seems to be
+ // Decibel-milliwatts, 2s complement, 0.002 dB resolution after analyzing the results from the ONUs
+ ReceivedOpticalPower: float32(TwosComplementToSignedInt16(msgObj.ReceivedOpticalPower)) * 0.002,
+ // OMCI representation is Decibel-microwatts, 2s compliment, 0.002dB resolution
+ // Same comments as in the case of ReceivedOpticalPower about resolution.
+ MeanOpticalLaunchPower: float32(TwosComplementToSignedInt16(msgObj.MeanOpticalLaunch)) * 0.002,
+ // OMCI representation is unsigned int, 2uA resolution
+ // units of gRPC interface is mA.
+ LaserBiasCurrent: float32(msgObj.LaserBiasCurrent) * 0.000002 * 1000, // multiply by 1000 to get units in mA
+ // OMCI representation is 2s complement, 1/256 degree Celsius resolution
+ Temperature: float32(TwosComplementToSignedInt16(msgObj.Temperature)) / 256.0,
+ },
+ },
+ },
+ }
+ logger.Debugw(ctx, "ani-g test result after type/value conversion",
+ log.Fields{"device-id": selfTestCb.deviceID,
+ "power-feed-voltage": singleValResp.Response.GetOnuOpticalInfo().PowerFeedVoltage,
+ "rx-power": singleValResp.Response.GetOnuOpticalInfo().ReceivedOpticalPower,
+ "tx-power": singleValResp.Response.GetOnuOpticalInfo().MeanOpticalLaunchPower,
+ "laser-bias-current": singleValResp.Response.GetOnuOpticalInfo().LaserBiasCurrent,
+ "temperature": singleValResp.Response.GetOnuOpticalInfo().Temperature})
+ selfTestCb.triggerFsmEvent(cb.fsm, selfTestEventTestResultSuccess)
+ logger.Infow(ctx, "OMCI test result success - pushing results", log.Fields{"device-id": selfTestCb.deviceID, "classID": classID})
+ cb.respChan <- singleValResp
+ selfTestCb.selfTestRequestComplete(ctx, cb.reqMsg)
+ logger.Infow(ctx, "OMCI test result success - pushing results complete", log.Fields{"device-id": selfTestCb.deviceID, "classID": classID})
+}
+
+func (selfTestCb *selfTestControlBlock) handleOmciResponse(ctx context.Context, classID generated.ClassID) {
+ selfTestCb.selfTestFsmLock.RLock()
+ pFsmCb, ok := selfTestCb.selfTestFsmMap[classID]
+ selfTestCb.selfTestFsmLock.RUnlock()
+ if !ok {
+ logger.Errorw(ctx, "fsb control block unavailable", log.Fields{"device-id": selfTestCb.deviceID, "class-id": classID})
+ return
+ }
+ select {
+ case <-pFsmCb.stopOmciChan:
+ logger.Infow(ctx, "omci processing stopped", log.Fields{"device-id": selfTestCb.deviceID, "class-id": classID})
+ selfTestCb.triggerFsmEvent(pFsmCb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, pFsmCb.respChan, extension.GetValueResponse_REASON_UNDEFINED, extension.GetValueResponse_ERROR)
+ case message, ok := <-pFsmCb.fsm.commChan:
+ if !ok {
+ logger.Errorw(ctx, "Message couldn't be read from channel", log.Fields{"device-id": selfTestCb.deviceID})
+ selfTestCb.triggerFsmEvent(pFsmCb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, pFsmCb.respChan, extension.GetValueResponse_INTERNAL_ERROR, extension.GetValueResponse_ERROR)
+ }
+ logger.Debugw(ctx, "Received message on self test result channel", log.Fields{"device-id": selfTestCb.deviceID})
+
+ switch message.Type {
+ case OMCI:
+ msg, _ := message.Data.(OmciMessage)
+ selfTestCb.handleOmciMessage(ctx, msg, pFsmCb, classID)
+ default:
+ logger.Errorw(ctx, "Unknown message type received", log.Fields{"device-id": selfTestCb.deviceID, "message.Type": message.Type})
+ selfTestCb.submitFailureGetValueResponse(ctx, pFsmCb.respChan, extension.GetValueResponse_UNSUPPORTED, extension.GetValueResponse_ERROR)
+ }
+ case <-time.After(time.Duration(SelfTestResponseWaitTimeout) * time.Second):
+ logger.Errorw(ctx, "timeout waiting for test result", log.Fields{"device-id": selfTestCb.deviceID, "classID": classID})
+ selfTestCb.triggerFsmEvent(pFsmCb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, pFsmCb.respChan, extension.GetValueResponse_TIMEOUT, extension.GetValueResponse_ERROR)
+ }
+}
+
+// selfTestRequestComplete removes the fsmCb from the local cache if found
+func (selfTestCb *selfTestControlBlock) selfTestRequestComplete(ctx context.Context, reqMsg extension.SingleGetValueRequest) {
+ meClassID, err := selfTestCb.getMeClassID(ctx, reqMsg)
+ if err != nil {
+ return
+ }
+ logger.Infow(ctx, "self test req handling complete", log.Fields{"device-id": selfTestCb.deviceID, "meClassID": meClassID})
+ // Clear the fsmCb from the map
+ delete(selfTestCb.selfTestFsmMap, meClassID)
+}
+
+func (selfTestCb *selfTestControlBlock) waitForStopSelfTestModuleSignal(ctx context.Context) {
+
+ <-selfTestCb.stopSelfTestModule // block on stop signal
+
+ logger.Infow(ctx, "received stop signal - clean up start", log.Fields{"device-id": selfTestCb.deviceID})
+ selfTestCb.selfTestFsmLock.Lock()
+ for classID, fsmCb := range selfTestCb.selfTestFsmMap {
+ select {
+ case fsmCb.stopOmciChan <- true: // stop omci processing routine if one was active. It eventually aborts the fsm
+ logger.Debugw(ctx, "stopped omci processing", log.Fields{"device-id": selfTestCb.deviceID, "meClassID": classID})
+ default:
+ selfTestCb.triggerFsmEvent(fsmCb.fsm, selfTestEventAbort)
+ selfTestCb.submitFailureGetValueResponse(ctx, fsmCb.respChan, extension.GetValueResponse_REASON_UNDEFINED, extension.GetValueResponse_ERROR)
+ }
+ }
+ selfTestCb.selfTestFsmMap = make(map[generated.ClassID]*fsmCb) // reset map
+ selfTestCb.selfTestFsmLock.Unlock()
+ logger.Infow(ctx, "received stop signal - clean up end", log.Fields{"device-id": selfTestCb.deviceID})
+}
+
+//// Exported functions
+
+// selfTestRequest initiate Test Request handling procedure. The results are asynchronously conveyed on the respChan.
+// If the return from selfTestRequest is NOT nil, the caller shall not wait for async response.
+func (selfTestCb *selfTestControlBlock) SelfTestRequestStart(ctx context.Context, reqMsg extension.SingleGetValueRequest, commChan chan Message, respChan chan extension.SingleGetValueResponse) error {
+ meClassID, err := selfTestCb.getMeClassID(ctx, reqMsg)
+ if err != nil {
+ return err
+ }
+ if _, ok := selfTestCb.selfTestFsmMap[meClassID]; ok {
+ logger.Errorw(ctx, "self test already in progress for class id", log.Fields{"device-id": selfTestCb.deviceID, "class-id": meClassID})
+ return fmt.Errorf("self-test-already-in-progress-for-class-id-%v-device-id-%v", meClassID, selfTestCb.deviceID)
+ }
+ logger.Infow(ctx, "self test request initiated", log.Fields{"device-id": selfTestCb.deviceID, "meClassID": meClassID})
+ // indicates only if the FSM was initiated correctly. Response is asynchronous on respChan.
+ // If the return from here is NOT nil, the caller shall not wait for async response.
+ return selfTestCb.initiateNewSelfTestFsm(ctx, reqMsg, commChan, meClassID, respChan)
+}
diff --git a/internal/pkg/onuadaptercore/onu_metrics_manager.go b/internal/pkg/onuadaptercore/onu_metrics_manager.go
index 198d85a..8781f91 100644
--- a/internal/pkg/onuadaptercore/onu_metrics_manager.go
+++ b/internal/pkg/onuadaptercore/onu_metrics_manager.go
@@ -698,11 +698,11 @@
}
case "transmit_power_dBm":
if val, ok := meAttributes["TransmitOpticalLevel"]; ok && val != nil {
- opticalMetrics[k] = float32(math.Round((float64(mm.twosComplementToSignedInt16(val.(uint16)))/500.0)*10) / 10) // convert to dBm rounded of to single decimal place
+ opticalMetrics[k] = float32(math.Round((float64(TwosComplementToSignedInt16(val.(uint16)))/500.0)*10) / 10) // convert to dBm rounded of to single decimal place
}
case "receive_power_dBm":
if val, ok := meAttributes["OpticalSignalLevel"]; ok && val != nil {
- opticalMetrics[k] = float32(math.Round((float64(mm.twosComplementToSignedInt16(val.(uint16)))/500.0)*10) / 10) // convert to dBm rounded of to single decimal place
+ opticalMetrics[k] = float32(math.Round((float64(TwosComplementToSignedInt16(val.(uint16)))/500.0)*10) / 10) // convert to dBm rounded of to single decimal place
}
default:
// do nothing
@@ -2832,34 +2832,3 @@
}
return slice
}
-
-func (mm *onuMetricsManager) twosComplementToSignedInt16(val uint16) int16 {
- var uint16MsbMask uint16 = 0x8000
- if val&uint16MsbMask == uint16MsbMask {
- return int16(^val+1) * -1
- }
-
- return int16(val)
-}
-
-/* // These are need in the future
-
-func (mm *onuMetricsManager) twosComplementToSignedInt32(val uint32) int32 {
- var uint32MsbMask uint32 = 0x80000000
- if val & uint32MsbMask == uint32MsbMask {
- return int32(^val + 1) * -1
- }
-
- return int32(val)
-}
-
-func (mm *onuMetricsManager) twosComplementToSignedInt64(val uint64) int64 {
- var uint64MsbMask uint64 = 0x8000000000000000
- if val & uint64MsbMask == uint64MsbMask {
- return int64(^val + 1) * -1
- }
-
- return int64(val)
-}
-
-*/
diff --git a/internal/pkg/onuadaptercore/openonu.go b/internal/pkg/onuadaptercore/openonu.go
index 5cc805e..d1d6b09 100644
--- a/internal/pkg/onuadaptercore/openonu.go
+++ b/internal/pkg/onuadaptercore/openonu.go
@@ -392,13 +392,29 @@
if err := handler.deleteDevicePersistencyData(ctx); err != nil {
errorsList = append(errorsList, err)
}
- handler.stopCollector <- true // stop the metric collector routine
- handler.stopAlarmManager <- true //stop the alarm manager.
+ select {
+ case handler.stopCollector <- true: // stop the metric collector routine
+ logger.Debugw(ctx, "sent stop signal to metric collector routine", log.Fields{"device-id": device.Id})
+ default:
+ logger.Warnw(ctx, "metric collector routine not waiting on stop signal", log.Fields{"device-id": device.Id})
+ }
+ select {
+ case handler.stopAlarmManager <- true: //stop the alarm manager.
+ logger.Debugw(ctx, "sent stop signal to alarm manager", log.Fields{"device-id": device.Id})
+ default:
+ logger.Warnw(ctx, "alarm manager not waiting on stop signal", log.Fields{"device-id": device.Id})
+ }
if handler.pOnuMetricsMgr != nil {
if err := handler.pOnuMetricsMgr.clearAllPmData(ctx); err != nil {
errorsList = append(errorsList, err)
}
}
+ select {
+ case handler.pSelfTestHdlr.stopSelfTestModule <- true:
+ logger.Debugw(ctx, "sent stop signal to self test handler module", log.Fields{"device-id": device.Id})
+ default:
+ logger.Warnw(ctx, "self test handler module not waiting on stop signal", log.Fields{"device-id": device.Id})
+ }
//don't leave any garbage - even in error case
oo.deleteDeviceHandlerToMap(handler)
if len(errorsList) > 0 {
@@ -565,6 +581,21 @@
switch reqType := request.GetRequest().GetRequest().(type) {
case *extension.GetValueRequest_UniInfo:
return handler.getUniPortStatus(ctx, reqType.UniInfo), nil
+ case *extension.GetValueRequest_OnuOpticalInfo:
+ commChan := make(chan Message)
+ respChan := make(chan extension.SingleGetValueResponse)
+ // Initiate the self test request
+ if err := handler.pSelfTestHdlr.SelfTestRequestStart(ctx, request, commChan, respChan); err != nil {
+ return &extension.SingleGetValueResponse{
+ Response: &extension.GetValueResponse{
+ Status: extension.GetValueResponse_ERROR,
+ ErrReason: extension.GetValueResponse_INTERNAL_ERROR,
+ },
+ }, err
+ }
+ // The timeout handling is already implemented in omci_self_test_handler module
+ resp := <-respChan
+ return &resp, nil
default:
return postUniStatusErrResponse(extension.GetValueResponse_UNSUPPORTED), nil
diff --git a/internal/pkg/onuadaptercore/openonu_utils.go b/internal/pkg/onuadaptercore/openonu_utils.go
index 32eeed8..2d17b05 100644
--- a/internal/pkg/onuadaptercore/openonu_utils.go
+++ b/internal/pkg/onuadaptercore/openonu_utils.go
@@ -71,3 +71,13 @@
}
return out
}
+
+// TwosComplementToSignedInt16 convert 2s complement to signed int16
+func TwosComplementToSignedInt16(val uint16) int16 {
+ var uint16MsbMask uint16 = 0x8000
+ if val&uint16MsbMask == uint16MsbMask {
+ return int16(^val+1) * -1
+ }
+
+ return int16(val)
+}
diff --git a/vendor/github.com/opencord/omci-lib-go/README.md b/vendor/github.com/opencord/omci-lib-go/README.md
index fa5499f..959990a 100644
--- a/vendor/github.com/opencord/omci-lib-go/README.md
+++ b/vendor/github.com/opencord/omci-lib-go/README.md
@@ -1,7 +1,8 @@
# OMCI
OMCI gopacket library supports the encoding and decoding of ITU G.988 OMCI
-messages.
+messages. Support for the Baseline Message Set has been completed and work
+is underway to support the Extended Message Set format.
## Message Types supported and under unit test
The following OMCI message types currently have been coded and are covered
@@ -22,6 +23,13 @@
- MibResetRequest
- MibResetResponse
- SynchronizeTimeRequest
+ - DownloadSectionRequest
+ - DownloadSectionResponse
+ - EndSoftwareDownloadRequest
+ - EndSoftwareDownloadResponse
+ - CommitSoftwareRequest
+ - CommitSoftwareResponse
+ - AlarmNotification
## Message Types supported but lacking full unit test
The following OMCI message types currently have been coded and are partially covered
@@ -38,46 +46,80 @@
- StartSoftwareDownloadRequest
- GetNextRequest
- GetNextResponse
+ - TestResult
+ - TestRequest
+ - TestResponse
## Message Types supported but lacking any unit test
The following OMCI message types currently have been coded but do not
have any unit test coverage.
- StartSoftwareDownloadResponse
- - DownloadSectionRequest
- - DownloadSectionResponse
- - EndSoftwareDownloadRequest
- - EndSoftwareDownloadResponse
- ActivateSoftwareRequest
- ActivateSoftwareResponse
- - CommitSoftwareRequest
- - CommitSoftwareResponse
- GetCurrentDataRequest
- GetCurrentDataResponse
- - AlarmNotification
## Message Types not yet supported
The following OMCI message types currently have not been coded.
- - TestResult
- - TestRequest
- - TestResponse
- SetTableRequest
- SetTableResponse
+## Extended Message Set Support
+
+As mentioned earlier, support for the Extended Message Set is underway. Currently,
+the following Message Types have this support and are covered by unit tests:
+
+ - GetRequest
+ - GetResponse
+
+### Upcoming message types that will be supported
+
+The following provides a list of message types that will eventually support the _Extended Message Set_
+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
+ - SynchronizeTimeRequest/Response
+ - CreateRequest/Response
+ - DeleteRequest/Response
+ - SetRequest/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
-The _coverage.sh_ and _coverage.cmd_ scripts can be used to create code coverage support for the
-library. The current coverage (as of 2/11/2020) is:
+The _**make** test_ command can be used to create code coverage support for the
+library. The current coverage for version 1.0.0 (as of 4/21/2021) is:
| File | Statement Coverage |
| --------------: | :---: |
| layers.go | 100% |
-| mebase.go | 87.5% |
-| meframe.go | 54.8% |
-| messagetypes.go | 48.1% |
-| omci.go | 81.6% |
+| mebase.go | 91.7% |
+| meframe.go | 50.8% |
+| messagetypes.go | 59.1% |
+| omci.go | 79.0% |
## Other outstanding items
@@ -85,26 +127,12 @@
would be needed or useful in a first official release of this library. Some changes are
to be done in the generated OMCI ME code as well.
- - Specific examples of how to use this library (expand upon DecodeEncode.go examples)
- Include unknown ME examples and how to catch various common or expected errors. Until
- this is available, please take a look at how this library is used in my
- [onumock](https://github.com/cboling/onumock/README.md). There is a utilities subdirectory
- in the _onumock_ project that has some examples. One is a **very** crude OLT simulator that
- I wrote to help test the ONU Mock.
- - Support optional msg-types. (This was very recently fixed in the code generator).
- Constraint checking (these are not yet fully parsed/provided by the OMCI code generated
structs). This feature will hopefully be available in the near future.
- - Add Alarm Table Support (generated MEs also)
- Add AVC flag for appropriate attributes
- - Support of the extended message format
- - For serialization, check early for message size exceeded
- Add some type of logging support
-The following would be 'nice' to have but are not necessary for initial code release
- - Extended message support
- - MIC Encode/Decode support
-
-Also searching through the code for _TODO_ statements will also yeild additional areas of
+Also searching through the code for _TODO_ statements will also yield additional areas of
work to be performed.
## What is not provided by this library
@@ -114,7 +142,7 @@
the creation of OMCI frames and handling decoded frames from the PON.
For an OLT-side OMCI stack, you would still need to write:
- - OMCI CC sender & receiver with appropriate timeout support
+ - OMCI CC sender & receiver (stop & wait protocol) with appropriate timeout support
- OLT State machines to support
- MIB Uploads/Audits/Resynchronization (and a MIB database implemention),
- More sophisticated get & get-next support to make handle of MEs with
@@ -123,7 +151,7 @@
- OMCI ME/Msg-Type capabilities inquiry,
- Performance Monitoring collection (and initial time synchronization),
- Service implementation
-
+
For an ONU-side OMCI stack, you would still need to write:
- OMCC implementation,
- MIB Database,
diff --git a/vendor/github.com/opencord/omci-lib-go/VERSION b/vendor/github.com/opencord/omci-lib-go/VERSION
index c5523bd..9084fa2 100644
--- a/vendor/github.com/opencord/omci-lib-go/VERSION
+++ b/vendor/github.com/opencord/omci-lib-go/VERSION
@@ -1 +1 @@
-0.17.0
+1.1.0
diff --git a/vendor/github.com/opencord/omci-lib-go/generated/medef.go b/vendor/github.com/opencord/omci-lib-go/generated/medef.go
index 767e27b..4e91db6 100644
--- a/vendor/github.com/opencord/omci-lib-go/generated/medef.go
+++ b/vendor/github.com/opencord/omci-lib-go/generated/medef.go
@@ -141,7 +141,7 @@
data = data[len(valueBuffer):]
case byte(Set) | AR: // Set Request
- fmt.Println("TODO")
+ // TODO: No support at this time
case byte(SetTable) | AR: // Set Table Request
// TODO: Only baseline supported at this time
diff --git a/vendor/github.com/opencord/omci-lib-go/generated/omcidefs.go b/vendor/github.com/opencord/omci-lib-go/generated/omcidefs.go
index 8924e7d..5e845ff2 100644
--- a/vendor/github.com/opencord/omci-lib-go/generated/omcidefs.go
+++ b/vendor/github.com/opencord/omci-lib-go/generated/omcidefs.go
@@ -105,6 +105,7 @@
TestResult MsgType = 27
GetCurrentData MsgType = 28
SetTable MsgType = 29 // Defined in Extended Message Set Only
+ ExtendedOffset MsgType = 0x80
)
func (mt MsgType) String() string {
diff --git a/vendor/github.com/opencord/omci-lib-go/layers.go b/vendor/github.com/opencord/omci-lib-go/layers.go
index 1bac6b3..aa49e8c 100644
--- a/vendor/github.com/opencord/omci-lib-go/layers.go
+++ b/vendor/github.com/opencord/omci-lib-go/layers.go
@@ -26,6 +26,7 @@
var nextLayerMapping map[MessageType]gopacket.LayerType
var (
+ // Baseline Message Types
LayerTypeCreateRequest gopacket.LayerType
LayerTypeDeleteRequest gopacket.LayerType
LayerTypeSetRequest gopacket.LayerType
@@ -47,8 +48,12 @@
LayerTypeGetNextRequest gopacket.LayerType
LayerTypeGetCurrentDataRequest gopacket.LayerType
LayerTypeSetTableRequest gopacket.LayerType
+
+ // Extended Message Types
+ LayerTypeGetRequestExtended gopacket.LayerType
)
var (
+ // Baseline Message Types
LayerTypeCreateResponse gopacket.LayerType
LayerTypeDeleteResponse gopacket.LayerType
LayerTypeSetResponse gopacket.LayerType
@@ -72,6 +77,9 @@
LayerTypeTestResult gopacket.LayerType
LayerTypeGetCurrentDataResponse gopacket.LayerType
LayerTypeSetTableResponse gopacket.LayerType
+
+ // Extended Message Types
+ LayerTypeGetResponseExtended gopacket.LayerType
)
func mkReqLayer(mt me.MsgType, mts string, decode gopacket.DecodeFunc) gopacket.LayerType {
@@ -139,6 +147,11 @@
LayerTypeGetCurrentDataResponse = mkRespLayer(me.GetCurrentData, "GetCurrentDataResponse", gopacket.DecodeFunc(decodeGetCurrentDataResponse))
LayerTypeSetTableResponse = mkRespLayer(me.SetTable, "SetTableResponse", gopacket.DecodeFunc(decodeSetTableResponse))
+ // Extended message set support
+
+ LayerTypeGetRequestExtended = mkReqLayer(me.Get|me.ExtendedOffset, "GetRequest-Ext", gopacket.DecodeFunc(decodeGetRequestExtended))
+ LayerTypeGetResponseExtended = mkRespLayer(me.Get|me.ExtendedOffset, "GetResponse-Ext", gopacket.DecodeFunc(decodeGetResponseExtended))
+
// Map message_type and action to layer
nextLayerMapping = make(map[MessageType]gopacket.LayerType)
@@ -188,12 +201,19 @@
nextLayerMapping[AttributeValueChangeType] = LayerTypeAttributeValueChange
nextLayerMapping[AlarmNotificationType] = LayerTypeAlarmNotification
nextLayerMapping[TestResultType] = LayerTypeTestResult
+
+ // Extended message support
+ nextLayerMapping[GetRequestType+ExtendedTypeDecodeOffset] = LayerTypeGetRequestExtended
+ nextLayerMapping[GetResponseType+ExtendedTypeDecodeOffset] = LayerTypeGetResponseExtended
}
-func MsgTypeToNextLayer(mt MessageType) (gopacket.LayerType, error) {
+func MsgTypeToNextLayer(mt MessageType, isExtended bool) (gopacket.LayerType, error) {
+ if isExtended {
+ mt |= ExtendedTypeDecodeOffset
+ }
nextLayer, ok := nextLayerMapping[mt]
if ok {
return nextLayer, nil
}
- return gopacket.LayerTypeZero, errors.New("unknown message type")
+ return gopacket.LayerTypeZero, errors.New("unknown/unsupported message type")
}
diff --git a/vendor/github.com/opencord/omci-lib-go/mebase.go b/vendor/github.com/opencord/omci-lib-go/mebase.go
index 955e610..41f7a1f 100644
--- a/vendor/github.com/opencord/omci-lib-go/mebase.go
+++ b/vendor/github.com/opencord/omci-lib-go/mebase.go
@@ -32,6 +32,7 @@
gopacket.Layer
layers.BaseLayer
MsgLayerType gopacket.LayerType
+ Extended bool
}
func (msg *MeBasePacket) String() string {
diff --git a/vendor/github.com/opencord/omci-lib-go/meframe.go b/vendor/github.com/opencord/omci-lib-go/meframe.go
index 3c5ab53..c13554c 100644
--- a/vendor/github.com/opencord/omci-lib-go/meframe.go
+++ b/vendor/github.com/opencord/omci-lib-go/meframe.go
@@ -43,7 +43,7 @@
encoderMap[MibUploadRequestType] = MibUploadRequestFrame
encoderMap[MibUploadNextRequestType] = MibUploadNextRequestFrame
encoderMap[MibResetRequestType] = MibResetRequestFrame
- encoderMap[TestRequestType] = TestRequestFrame
+ //encoderMap[TestRequestType] = TestRequestFrame
encoderMap[StartSoftwareDownloadRequestType] = StartSoftwareDownloadRequestFrame
encoderMap[DownloadSectionRequestType] = DownloadSectionRequestFrame
encoderMap[EndSoftwareDownloadRequestType] = EndSoftwareDownloadRequestFrame
@@ -63,7 +63,7 @@
encoderMap[MibUploadResponseType] = MibUploadResponseFrame
encoderMap[MibUploadNextResponseType] = MibUploadNextResponseFrame
encoderMap[MibResetResponseType] = MibResetResponseFrame
- encoderMap[TestResponseType] = TestResponseFrame
+ //encoderMap[TestResponseType] = TestResponseFrame
encoderMap[StartSoftwareDownloadResponseType] = StartSoftwareDownloadResponseFrame
encoderMap[DownloadSectionResponseType] = DownloadSectionResponseFrame
encoderMap[EndSoftwareDownloadResponseType] = EndSoftwareDownloadResponseFrame
@@ -76,7 +76,7 @@
encoderMap[SetTableResponseType] = SetTableResponseFrame
encoderMap[AlarmNotificationType] = AlarmNotificationFrame
encoderMap[AttributeValueChangeType] = AttributeValueChangeFrame
- encoderMap[TestResultType] = TestResultFrame
+ //encoderMap[TestResultType] = TestResultFrame
}
type options struct {
@@ -414,6 +414,9 @@
}
func CreateRequestFrame(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")
+ }
// NOTE: The OMCI parser does not extract the default values of set-by-create attributes
// and are the zero 'default' (or nil) at this time. For this reason, make sure
// you specify all non-zero default values and pass them in appropriate
@@ -421,6 +424,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
Attributes: m.GetAttributeValueMap(),
}
@@ -443,10 +447,14 @@
}
func CreateResponseFrame(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")
+ }
meLayer := &CreateResponse{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
Result: opt.result,
}
@@ -457,20 +465,28 @@
}
func DeleteRequestFrame(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")
+ }
meLayer := &DeleteRequest{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
return meLayer, nil
}
func DeleteResponseFrame(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")
+ }
meLayer := &DeleteResponse{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
Result: opt.result,
}
@@ -493,11 +509,15 @@
// Get payload space available
maxPayload := maxPacketAvailable(m, opt)
payloadAvailable := int(maxPayload) - 2 // Less attribute mask
-
+ if opt.frameFormat == ExtendedIdent {
+ return nil, errors.New("Extended message set for this message type is not supported")
+ // payloadAvailable -= 2 // Less length
+ }
meLayer := &SetRequest{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
AttributeMask: 0,
Attributes: make(me.AttributeValueMap),
@@ -546,10 +566,14 @@
}
func SetResponseFrame(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")
+ }
meLayer := &SetResponse{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
Result: opt.result,
}
@@ -582,6 +606,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
AttributeMask: mask,
}
@@ -601,6 +626,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
Result: opt.result,
AttributeMask: 0,
@@ -666,11 +692,15 @@
}
func GetAllAlarmsRequestFrame(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")
+ }
// Common for all MEs
meLayer := &GetAllAlarmsRequest{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
AlarmRetrievalMode: opt.mode,
}
@@ -678,11 +708,15 @@
}
func GetAllAlarmsResponseFrame(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")
+ }
// Common for all MEs
meLayer := &GetAllAlarmsResponse{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
NumberOfCommands: opt.sequenceNumberCountOrSize,
}
@@ -690,11 +724,15 @@
}
func GetAllAlarmsNextRequestFrame(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")
+ }
// Common for all MEs
meLayer := &GetAllAlarmsNextRequest{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
CommandSequenceNumber: opt.sequenceNumberCountOrSize,
}
@@ -702,11 +740,15 @@
}
func GetAllAlarmsNextResponseFrame(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")
+ }
// Common for all MEs
meLayer := &GetAllAlarmsNextResponse{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
AlarmEntityClass: opt.alarm.AlarmClassID,
AlarmEntityInstance: opt.alarm.AlarmInstance,
@@ -724,22 +766,30 @@
}
func MibUploadRequestFrame(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")
+ }
// Common for all MEs
meLayer := &MibUploadRequest{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: 0,
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
return meLayer, nil
}
func MibUploadResponseFrame(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")
+ }
// Common for all MEs
meLayer := &MibUploadResponse{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: 0,
+ Extended: opt.frameFormat == ExtendedIdent,
},
NumberOfCommands: opt.sequenceNumberCountOrSize,
}
@@ -747,11 +797,15 @@
}
func MibUploadNextRequestFrame(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")
+ }
// Common for all MEs
meLayer := &MibUploadNextRequest{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: 0,
+ Extended: opt.frameFormat == ExtendedIdent,
},
CommandSequenceNumber: opt.sequenceNumberCountOrSize,
}
@@ -759,11 +813,15 @@
}
func MibUploadNextResponseFrame(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")
+ }
// Common for all MEs
meLayer := &MibUploadNextResponse{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
if opt.payload == nil {
@@ -792,22 +850,30 @@
}
func MibResetRequestFrame(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")
+ }
// Common for all MEs
meLayer := &MibResetRequest{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
return meLayer, nil
}
func MibResetResponseFrame(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")
+ }
// Common for all MEs
meLayer := &MibResetResponse{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
Result: opt.result,
}
@@ -815,6 +881,9 @@
}
func AlarmNotificationFrame(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
@@ -824,6 +893,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -837,6 +907,9 @@
}
func AttributeValueChangeFrame(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
@@ -846,6 +919,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
AttributeMask: 0,
Attributes: make(me.AttributeValueMap),
@@ -860,54 +934,66 @@
return meLayer, errors.New("todo: Not implemented")
}
-func TestRequestFrame(m *me.ManagedEntity, opt options) (gopacket.SerializableLayer, error) {
- mask, err := checkAttributeMask(m, opt.attributeMask)
- if err != nil {
- return nil, err
- }
- // Common for all MEs
- meLayer := &TestRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: m.GetClassID(),
- EntityInstance: m.GetEntityID(),
- },
- }
- // Get payload space available
- maxPayload := maxPacketAvailable(m, opt)
+//func TestRequestFrame(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 := &TestRequest{
+// MeBasePacket: MeBasePacket{
+// EntityClass: m.GetClassID(),
+// EntityInstance: m.GetEntityID(),
+// Extended: opt.frameFormat == ExtendedIdent,
+// },
+// }
+// // 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")
+//}
- // TODO: Lots of work to do
-
- fmt.Println(mask, maxPayload)
- return meLayer, errors.New("todo: Not implemented")
-}
-
-func TestResponseFrame(m *me.ManagedEntity, opt options) (gopacket.SerializableLayer, error) {
- mask, err := checkAttributeMask(m, opt.attributeMask)
- if err != nil {
- return nil, err
- }
- // Common for all MEs
- meLayer := &TestResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: m.GetClassID(),
- EntityInstance: m.GetEntityID(),
- },
- }
- // 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")
-}
+//func TestResponseFrame(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 := &TestResponse{
+// MeBasePacket: MeBasePacket{
+// EntityClass: m.GetClassID(),
+// EntityInstance: m.GetEntityID(),
+// Extended: opt.frameFormat == ExtendedIdent,
+// },
+// }
+// // 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")
+//}
func StartSoftwareDownloadRequestFrame(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")
+ }
// Common for all MEs
meLayer := &StartSoftwareDownloadRequest{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
WindowSize: opt.software.WindowSize,
ImageSize: opt.software.ImageSize,
@@ -927,11 +1013,15 @@
}
func StartSoftwareDownloadResponseFrame(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")
+ }
// Common for all MEs
meLayer := &StartSoftwareDownloadResponse{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
WindowSize: opt.software.WindowSize,
NumberOfInstances: byte(len(opt.software.CircuitPacks)),
@@ -950,6 +1040,9 @@
}
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
@@ -959,6 +1052,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -971,6 +1065,9 @@
}
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
@@ -980,6 +1077,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -992,6 +1090,9 @@
}
func EndSoftwareDownloadRequestFrame(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
@@ -1001,6 +1102,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -1013,6 +1115,9 @@
}
func EndSoftwareDownloadResponseFrame(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
@@ -1022,6 +1127,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -1034,6 +1140,9 @@
}
func ActivateSoftwareRequestFrame(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
@@ -1043,6 +1152,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -1055,6 +1165,9 @@
}
func ActivateSoftwareResponseFrame(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
@@ -1064,6 +1177,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -1076,6 +1190,9 @@
}
func CommitSoftwareRequestFrame(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
@@ -1085,6 +1202,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -1097,6 +1215,9 @@
}
func CommitSoftwareResponseFrame(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
@@ -1106,6 +1227,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -1118,11 +1240,15 @@
}
func SynchronizeTimeRequestFrame(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")
+ }
// Common for all MEs
meLayer := &SynchronizeTimeRequest{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Decode payload option. If nil, no timestamp provided
@@ -1139,11 +1265,15 @@
}
func SynchronizeTimeResponseFrame(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")
+ }
// Common for all MEs
meLayer := &SynchronizeTimeResponse{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
Result: opt.result,
SuccessResults: opt.mode,
@@ -1152,11 +1282,15 @@
}
func RebootRequestFrame(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")
+ }
// Common for all MEs
meLayer := &RebootRequest{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
RebootCondition: opt.mode,
}
@@ -1164,11 +1298,15 @@
}
func RebootResponseFrame(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")
+ }
// Common for all MEs
meLayer := &RebootResponse{
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
Result: opt.result,
}
@@ -1176,6 +1314,9 @@
}
func GetNextRequestFrame(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")
+ }
// Validate attribute mask
mask, err := checkAttributeMask(m, opt.attributeMask)
if err != nil {
@@ -1195,6 +1336,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
AttributeMask: mask,
SequenceNumber: opt.sequenceNumberCountOrSize,
@@ -1203,6 +1345,9 @@
}
func GetNextResponseFrame(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")
+ }
// Validate attribute mask
mask, err := checkAttributeMask(m, opt.attributeMask)
if err != nil {
@@ -1218,6 +1363,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
Result: opt.result,
AttributeMask: 0,
@@ -1273,28 +1419,35 @@
return meLayer, nil
}
-func TestResultFrame(m *me.ManagedEntity, opt options) (gopacket.SerializableLayer, error) {
- mask, err := checkAttributeMask(m, opt.attributeMask)
- if err != nil {
- return nil, err
- }
- // Common for all MEs
- meLayer := &TestResultMsg{
- MeBasePacket: MeBasePacket{
- EntityClass: m.GetClassID(),
- EntityInstance: m.GetEntityID(),
- },
- }
- // 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")
-}
+//func TestResultFrame(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 := &TestResultNotification{
+// MeBasePacket: MeBasePacket{
+// EntityClass: m.GetClassID(),
+// EntityInstance: m.GetEntityID(),
+// Extended: opt.frameFormat == ExtendedIdent,
+// },
+// }
+// // 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")
+//}
func GetCurrentDataRequestFrame(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
@@ -1304,6 +1457,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -1316,6 +1470,9 @@
}
func GetCurrentDataResponseFrame(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
@@ -1325,6 +1482,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -1340,6 +1498,9 @@
if opt.frameFormat != ExtendedIdent {
return nil, errors.New("SetTable message type only supported with Extended OMCI Messaging")
}
+ 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
@@ -1349,6 +1510,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: opt.frameFormat == ExtendedIdent,
},
}
// Get payload space available
@@ -1362,7 +1524,10 @@
func SetTableResponseFrame(m *me.ManagedEntity, opt options) (gopacket.SerializableLayer, error) {
if opt.frameFormat != ExtendedIdent {
- return nil, errors.New("SetTable message type only supported with Extended OMCI Messaging")
+ return nil, errors.New("SetTable message type only supported with Extended OMCI Message Set")
+ }
+ 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 {
@@ -1373,6 +1538,7 @@
MeBasePacket: MeBasePacket{
EntityClass: m.GetClassID(),
EntityInstance: m.GetEntityID(),
+ Extended: true,
},
}
// Get payload space available
diff --git a/vendor/github.com/opencord/omci-lib-go/messagetypes.go b/vendor/github.com/opencord/omci-lib-go/messagetypes.go
index f0ff447..456bef8 100644
--- a/vendor/github.com/opencord/omci-lib-go/messagetypes.go
+++ b/vendor/github.com/opencord/omci-lib-go/messagetypes.go
@@ -70,10 +70,14 @@
GetCurrentDataResponseType = MessageType(byte(me.GetCurrentData) | me.AK)
SetTableRequestType = MessageType(byte(me.SetTable) | me.AR)
SetTableResponseType = MessageType(byte(me.SetTable) | me.AK)
+
// Autonomous ONU messages
AlarmNotificationType = MessageType(byte(me.AlarmNotification))
AttributeValueChangeType = MessageType(byte(me.AttributeValueChange))
TestResultType = MessageType(byte(me.TestResult))
+
+ // Support mapping of extended format types (use MSB reserved bit)
+ ExtendedTypeDecodeOffset = MessageType(byte(0x80))
)
func (mt MessageType) String() string {
@@ -125,7 +129,7 @@
return "Start Software Download Request"
case StartSoftwareDownloadResponseType:
return "Start Software Download Response"
- case DownloadSectionRequestType:
+ case DownloadSectionRequestType, DownloadSectionRequestWithResponseType:
return "Download Section Request"
case DownloadSectionResponseType:
return "Download Section Response"
@@ -649,7 +653,15 @@
if !me.SupportsMsgType(meDefinition, me.Get) {
return me.NewProcessingError("managed entity does not support Get Message-Type")
}
- omci.AttributeMask = binary.BigEndian.Uint16(data[4:6])
+ if omci.Extended {
+ if len(data) < 8 {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ omci.AttributeMask = binary.BigEndian.Uint16(data[6:])
+ } else {
+ omci.AttributeMask = binary.BigEndian.Uint16(data[4:])
+ }
return nil
}
@@ -659,6 +671,13 @@
return decodingLayerDecoder(omci, data, p)
}
+func decodeGetRequestExtended(data []byte, p gopacket.PacketBuilder) error {
+ omci := &GetRequest{}
+ omci.MsgLayerType = LayerTypeGetRequest
+ omci.Extended = true
+ return decodingLayerDecoder(omci, data, p)
+}
+
// SerializeTo provides serialization of an Get Request message
func (omci *GetRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
// Basic (common) OMCI Header is 8 octets, 10
@@ -675,11 +694,22 @@
if !me.SupportsMsgType(meDefinition, me.Get) {
return me.NewProcessingError("managed entity does not support Get Message-Type")
}
- bytes, err := b.AppendBytes(2)
+ maskOffset := 0
+ if omci.Extended {
+ maskOffset = 2
+ }
+ bytes, err := b.AppendBytes(2 + maskOffset)
if err != nil {
return err
}
- binary.BigEndian.PutUint16(bytes, omci.AttributeMask)
+ if omci.Extended {
+ binary.BigEndian.PutUint16(bytes, uint16(2))
+ }
+ binary.BigEndian.PutUint16(bytes[maskOffset:], omci.AttributeMask)
+ return nil
+}
+
+func (omci *GetRequest) SerializeToExtended(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
return nil
}
@@ -716,33 +746,56 @@
if !me.SupportsMsgType(meDefinition, me.Get) {
return me.NewProcessingError("managed entity does not support Get Message-Type")
}
- omci.Result = me.Results(data[4])
- omci.AttributeMask = binary.BigEndian.Uint16(data[5:7])
+ if omci.Extended {
+ if len(data) < 13 {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ omci.Result = me.Results(data[6])
+ omci.AttributeMask = binary.BigEndian.Uint16(data[7:])
+ // If Attribute failed or Unknown, decode optional attribute mask
+ if omci.Result == me.AttributeFailure {
+ omci.UnsupportedAttributeMask = binary.BigEndian.Uint16(data[9:])
+ omci.FailedAttributeMask = binary.BigEndian.Uint16(data[11:])
+ }
+ } else {
+ omci.Result = me.Results(data[4])
+ omci.AttributeMask = binary.BigEndian.Uint16(data[5:])
+
+ // If Attribute failed or Unknown, decode optional attribute mask
+ if omci.Result == me.AttributeFailure {
+ omci.UnsupportedAttributeMask = binary.BigEndian.Uint16(data[32:34])
+ omci.FailedAttributeMask = binary.BigEndian.Uint16(data[34:36])
+ }
+ }
// 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. So accommodate
// this behaviour in favor of greater interoperability.
+ firstOctet := 7
lastOctet := 36
+ if omci.Extended {
+ firstOctet = 13
+ lastOctet = len(data)
+ }
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:
- lastOctet = 32
+ if !omci.Extended {
+ lastOctet = 32
+ }
}
- omci.Attributes, err = meDefinition.DecodeAttributes(omci.AttributeMask, data[7:lastOctet], p, byte(GetResponseType))
+ omci.Attributes, err = meDefinition.DecodeAttributes(omci.AttributeMask,
+ data[firstOctet:lastOctet], p, byte(GetResponseType))
if err != nil {
return err
}
- // If Attribute failed or Unknown, decode optional attribute mask
- if omci.Result == me.AttributeFailure {
- omci.UnsupportedAttributeMask = binary.BigEndian.Uint16(data[32:34])
- omci.FailedAttributeMask = binary.BigEndian.Uint16(data[34:36])
- }
// Validate all attributes support read
for attrName := range omci.Attributes {
attr, err := me.GetAttributeDefinitionByName(meDefinition.GetAttributeDefinitions(), attrName)
@@ -767,6 +820,13 @@
return decodingLayerDecoder(omci, data, p)
}
+func decodeGetResponseExtended(data []byte, p gopacket.PacketBuilder) error {
+ omci := &GetResponse{}
+ omci.MsgLayerType = LayerTypeGetResponse
+ omci.Extended = true
+ return decodingLayerDecoder(omci, data, p)
+}
+
// SerializeTo provides serialization of an Get Response message
func (omci *GetResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
// Basic (common) OMCI Header is 8 octets, 10
@@ -783,16 +843,27 @@
if !me.SupportsMsgType(meDefinition, me.Get) {
return me.NewProcessingError("managed entity does not support the Get Message-Type")
}
- bytes, err := b.AppendBytes(3)
+ resultOffset := 0
+ attributeErrExtra := 0
+
+ if omci.Extended {
+ resultOffset = 2
+ attributeErrExtra = 4 // Attribute mask + attribute error masks
+ }
+ // Space for result + mask (both types) + (len & error masks if extended)
+ buffer, err := b.AppendBytes(3 + resultOffset + attributeErrExtra)
if err != nil {
return err
}
- bytes[0] = byte(omci.Result)
- binary.BigEndian.PutUint16(bytes[1:3], omci.AttributeMask)
+ // Save result and initial mask. Other header fields updated after
+ // attribute copy
+ buffer[resultOffset] = byte(omci.Result)
+ binary.BigEndian.PutUint16(buffer[resultOffset+1:], omci.AttributeMask)
// Validate all attributes support read
for attrName := range omci.Attributes {
- attr, err := me.GetAttributeDefinitionByName(meDefinition.GetAttributeDefinitions(), attrName)
+ var attr *me.AttributeDefinition
+ attr, err = me.GetAttributeDefinitionByName(meDefinition.GetAttributeDefinitions(), attrName)
if err != nil {
return err
}
@@ -804,52 +875,77 @@
// Attribute serialization
switch omci.Result {
default:
+ if omci.Extended {
+ // Minimum length is 7 for extended an need to write error masks
+ binary.BigEndian.PutUint16(buffer, uint16(7))
+ binary.BigEndian.PutUint32(buffer[resultOffset+3:], 0)
+ }
break
case me.Success, me.AttributeFailure:
// TODO: Baseline only supported at this time)
- available := MaxBaselineLength - 11 - 4 - 8
-
+ var available int
+ if omci.Extended {
+ available = MaxExtendedLength - 18 - 4 // Less: header, mic
+ } else {
+ available = MaxBaselineLength - 11 - 4 - 8 // Less: header, failed attributes, length, mic
+ }
// Serialize to temporary buffer if we may need to reset values due to
// recoverable truncation errors
- origBuffer := b
- b := gopacket.NewSerializeBuffer()
+ attributeBuffer := gopacket.NewSerializeBuffer()
+ var failedMask uint16
+ err, failedMask = meDefinition.SerializeAttributes(omci.Attributes, omci.AttributeMask,
+ attributeBuffer, byte(GetResponseType), available, opts.FixLengths)
- err, failedMask := meDefinition.SerializeAttributes(omci.Attributes, omci.AttributeMask, b, byte(GetResponseType),
- available, opts.FixLengths)
-
- if err == nil && failedMask != 0 && opts.FixLengths {
+ 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[0] = byte(omci.Result)
- binary.BigEndian.PutUint16(bytes[1:3], omci.AttributeMask)
- } else if err != nil {
- return err
+ buffer[resultOffset] = byte(omci.Result)
+ binary.BigEndian.PutUint16(buffer[resultOffset+1:], omci.AttributeMask)
+ }
+ if omci.Extended {
+ // Set length and any failure masks
+ binary.BigEndian.PutUint16(buffer, uint16(len(attributeBuffer.Bytes())+7))
+
+ if omci.Result == me.AttributeFailure {
+ binary.BigEndian.PutUint16(buffer[resultOffset+3:], omci.UnsupportedAttributeMask)
+ binary.BigEndian.PutUint16(buffer[resultOffset+5:], omci.FailedAttributeMask)
+ } else {
+ binary.BigEndian.PutUint32(buffer[resultOffset+3:], 0)
+ }
}
// Copy over attributes to the original serialization buffer
- newSpace, err := origBuffer.AppendBytes(len(b.Bytes()))
+ var newSpace []byte
+
+ newSpace, err = b.AppendBytes(len(attributeBuffer.Bytes()))
if err != nil {
return err
}
- copy(newSpace, b.Bytes())
- b = origBuffer
+ copy(newSpace, attributeBuffer.Bytes())
- // Calculate space left. Max - msgType header - OMCI trailer - spacedUsedSoFar
- bytesLeft := MaxBaselineLength - 4 - 8 - len(b.Bytes())
+ if !omci.Extended {
+ // Calculate space left. Max - msgType header - OMCI trailer - spacedUsedSoFar
+ bytesLeft := MaxBaselineLength - 4 - 8 - len(b.Bytes())
- remainingBytes, err := b.AppendBytes(bytesLeft + 4)
- if err != nil {
- return me.NewMessageTruncatedError(err.Error())
- }
- copy(remainingBytes, lotsOfZeros[:])
+ var remainingBytes []byte
+ remainingBytes, err = b.AppendBytes(bytesLeft + 4)
- if omci.Result == me.AttributeFailure {
- binary.BigEndian.PutUint16(remainingBytes[bytesLeft-4:bytesLeft-2], omci.UnsupportedAttributeMask)
- binary.BigEndian.PutUint16(remainingBytes[bytesLeft-2:bytesLeft], omci.FailedAttributeMask)
+ 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
@@ -1534,7 +1630,7 @@
}
omci.Result = me.Results(data[4])
if omci.Result > me.DeviceBusy {
- msg := fmt.Sprintf("invalid results code: %v, must be 0..8", omci.Result)
+ msg := fmt.Sprintf("invalid results code: %v, must be 0..6", omci.Result)
return errors.New(msg)
}
return nil
@@ -1842,30 +1938,54 @@
return err
}
-/////////////////////////////////////////////////////////////////////////////
-// TestRequest: TODO: Not yet implemented
+func decodeTestRequest(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 := &TestRequest{}
+ omci.MsgLayerType = LayerTypeTestResult
+ return decodingLayerDecoder(omci, data, p)
+
+ case me.AniGClassID, me.ReAniGClassID, me.PhysicalPathTerminationPointReUniClassID,
+ me.ReUpstreamAmplifierClassID, me.ReDownstreamAmplifierClassID:
+ omci := &OpticalLineSupervisionTestRequest{}
+ omci.MsgLayerType = LayerTypeTestResult
+ return decodingLayerDecoder(omci, data, p)
+ }
+}
+
+// TestRequest message
type TestRequest struct {
MeBasePacket
+ Payload []byte
}
func (omci *TestRequest) String() string {
- return fmt.Sprintf("%v", omci.MeBasePacket.String())
+ return fmt.Sprintf("%v, Request: %v octets", omci.MeBasePacket.String(), len(omci.Payload))
+}
+
+func (omci *TestRequest) TestRequest() []byte {
+ return omci.Payload
}
// DecodeFromBytes decodes the given bytes of a Test Request into this layer
func (omci *TestRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
// Common ClassID/EntityID decode in msgBase
- err := omci.MeBasePacket.DecodeFromBytes(data, p, 4+5)
+ err := omci.MeBasePacket.DecodeFromBytes(data, p, 4)
if err != nil {
return err
}
- return errors.New("need to implement") // TODO: Fix me) // return nil
-}
-func decodeTestRequest(data []byte, p gopacket.PacketBuilder) error {
- omci := &TestRequest{}
- omci.MsgLayerType = LayerTypeTestRequest
- return decodingLayerDecoder(omci, data, p)
+ omci.Payload = make([]byte, MaxTestRequestLength)
+ copy(omci.Payload, omci.MeBasePacket.Payload)
+ return nil
}
// SerializeTo provides serialization of an Test Request message
@@ -1875,17 +1995,81 @@
if err != nil {
return err
}
- return errors.New("need to implement") // TODO: Fix me) // omci.cachedME.SerializeTo(mask, b)
+ if omci.Payload == nil {
+ return errors.New("Test Results payload is missing")
+ }
+
+ if len(omci.Payload) > MaxTestRequestLength {
+ msg := fmt.Sprintf("Invalid Test Request payload size. Received %v bytes, expected %v",
+ len(omci.Payload), MaxTestRequestLength)
+ return errors.New(msg)
+ }
+ bytes, err := b.AppendBytes(len(omci.Payload))
+ if err != nil {
+ return err
+ }
+
+ copy(bytes, omci.Payload)
+ return nil
}
-/////////////////////////////////////////////////////////////////////////////
-// TestResponse: TODO: Not yet implemented
+type OpticalLineSupervisionTestRequest struct {
+ MeBasePacket
+ SelectTest uint8 // Bitfield
+ GeneralPurposeBuffer uint16 // Pointer to General Purpose Buffer ME
+ VendorSpecificParameters uint16 // Pointer to Octet String ME
+}
+
+func (omci *OpticalLineSupervisionTestRequest) String() string {
+ return fmt.Sprintf("Optical Line Supervision Test Result: SelectTest: %#x, Buffer: %#x, Params: %#x",
+ omci.SelectTest, omci.GeneralPurposeBuffer, omci.VendorSpecificParameters)
+}
+
+func (omci *OpticalLineSupervisionTestRequest) TestRequest() []byte {
+ return omci.Payload
+}
+
+// DecodeFromBytes decodes the given bytes of a Test Result Notification into this layer
+func (omci *OpticalLineSupervisionTestRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
+ // Common ClassID/EntityID decode in msgBase
+ err := omci.MeBasePacket.DecodeFromBytes(data, p, 4+5)
+ if err != nil {
+ return err
+ }
+
+ omci.SelectTest = data[4]
+ omci.GeneralPurposeBuffer = binary.BigEndian.Uint16(data[5:])
+ omci.VendorSpecificParameters = binary.BigEndian.Uint16(data[7:])
+ return nil
+}
+
+// SerializeTo provides serialization of an Test Result notification message
+func (omci *OpticalLineSupervisionTestRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+ // Basic (common) OMCI Header is 8 octets, 10
+ err := omci.MeBasePacket.SerializeTo(b)
+ if err != nil {
+ return err
+ }
+
+ bytes, err := b.AppendBytes(8)
+ if err != nil {
+ return err
+ }
+
+ bytes[0] = omci.SelectTest
+ binary.BigEndian.PutUint16(bytes[1:], omci.GeneralPurposeBuffer)
+ binary.BigEndian.PutUint16(bytes[3:], omci.VendorSpecificParameters)
+ return nil
+}
+
+// TestResponse message
type TestResponse struct {
MeBasePacket
+ Result me.Results
}
func (omci *TestResponse) String() string {
- return fmt.Sprintf("%v", omci.MeBasePacket.String())
+ return fmt.Sprintf("%v, Results: %d (%v)", omci.MeBasePacket.String(), omci.Result, omci.Result)
}
// DecodeFromBytes decodes the given bytes of a Test Response into this layer
@@ -1895,7 +2079,18 @@
if err != nil {
return err
}
- return errors.New("need to implement") // TODO: Fix me) // return nil
+ meDefinition, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
+ me.ParamData{EntityID: omci.EntityInstance})
+ if omciErr.StatusCode() != me.Success {
+ return omciErr.GetError()
+ }
+
+ // ME needs to support Test requests
+ if !me.SupportsMsgType(meDefinition, me.Test) {
+ return me.NewProcessingError("managed entity does not support Test Message-Type")
+ }
+ omci.Result = me.Results(data[4])
+ return nil
}
func decodeTestResponse(data []byte, p gopacket.PacketBuilder) error {
@@ -1911,7 +2106,26 @@
if err != nil {
return err
}
- return errors.New("need to implement") // TODO: Fix me) // omci.cachedME.SerializeTo(mask, b)
+ entity, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
+ me.ParamData{EntityID: omci.EntityInstance})
+ if omciErr.StatusCode() != me.Success {
+ return omciErr.GetError()
+ }
+ // ME needs to support Set
+ if !me.SupportsMsgType(entity, me.Test) {
+ return me.NewProcessingError("managed entity does not support the Test Message-Type")
+ }
+ bytes, err := b.AppendBytes(1)
+ if err != nil {
+ return err
+ }
+ bytes[0] = byte(omci.Result)
+
+ if omci.Result > me.DeviceBusy {
+ msg := fmt.Sprintf("invalid results code: %v, must be 0..6", omci.Result)
+ return errors.New(msg)
+ }
+ return nil
}
/////////////////////////////////////////////////////////////////////////////
@@ -2932,7 +3146,7 @@
}
omci.Result = me.Results(data[4])
if omci.Result > me.DeviceBusy {
- msg := fmt.Sprintf("invalid results code: %v, must be 0..8", omci.Result)
+ msg := fmt.Sprintf("invalid results code: %v, must be 0..6", omci.Result)
return errors.New(msg)
}
omci.SuccessResults = data[5]
@@ -3316,40 +3530,204 @@
return nil
}
-/////////////////////////////////////////////////////////////////////////////
-//
-type TestResultMsg struct {
- MeBasePacket
+func decodeTestResult(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
+ return decodingLayerDecoder(omci, data, p)
+
+ case me.AniGClassID, me.ReAniGClassID, me.PhysicalPathTerminationPointReUniClassID,
+ me.ReUpstreamAmplifierClassID, me.ReDownstreamAmplifierClassID:
+ omci := &OpticalLineSupervisionTestResult{}
+ omci.MsgLayerType = LayerTypeTestResult
+ return decodingLayerDecoder(omci, data, p)
+ }
}
-func (omci *TestResultMsg) String() string {
- return fmt.Sprintf("%v", omci.MeBasePacket.String())
+type TestResultNotification struct {
+ MeBasePacket
+ Payload []byte
+}
+
+func (omci *TestResultNotification) TestResults() []byte {
+ return omci.Payload
+}
+
+func (omci *TestResultNotification) String() string {
+ return fmt.Sprintf("%v, Payload: %v octets", omci.MeBasePacket.String(), len(omci.Payload))
}
// DecodeFromBytes decodes the given bytes of a Test Result Notification into this layer
-func (omci *TestResultMsg) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
+func (omci *TestResultNotification) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
// Common ClassID/EntityID decode in msgBase
err := omci.MeBasePacket.DecodeFromBytes(data, p, 4)
if err != nil {
return err
}
- return errors.New("need to implement") // TODO: Fix me) // return nil
-}
-func decodeTestResult(data []byte, p gopacket.PacketBuilder) error {
- omci := &TestResultMsg{}
- omci.MsgLayerType = LayerTypeTestResult
- return decodingLayerDecoder(omci, data, p)
+ meDefinition, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
+ me.ParamData{EntityID: omci.EntityInstance})
+ if omciErr.StatusCode() != me.Success {
+ return omciErr.GetError()
+ }
+
+ // ME needs to support Test requests
+ 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)
+ return nil
}
// SerializeTo provides serialization of an Test Result notification message
-func (omci *TestResultMsg) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+func (omci *TestResultNotification) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+ // Basic (common) OMCI Header is 8 octets
+ err := omci.MeBasePacket.SerializeTo(b)
+ if err != nil {
+ return err
+ }
+
+ meDefinition, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
+ me.ParamData{EntityID: omci.EntityInstance})
+ if omciErr.StatusCode() != me.Success {
+ return omciErr.GetError()
+ }
+
+ // ME needs to support Test requests
+ if !me.SupportsMsgType(meDefinition, me.Test) {
+ return me.NewProcessingError("managed entity does not support Test Message-Type")
+ }
+ 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)
+ return errors.New(msg)
+ }
+ bytes, err := b.AppendBytes(len(omci.Payload))
+ if err != nil {
+ return err
+ }
+
+ copy(bytes, omci.Payload)
+ return nil
+}
+
+// OpticalLineSupervisionTestResult provides a Optical Specific test results
+// message decode for the associated Managed Entities
+type OpticalLineSupervisionTestResult struct {
+ MeBasePacket
+ PowerFeedVoltageType uint8 // Type = 1
+ PowerFeedVoltage uint16 // value
+ ReceivedOpticalPowerType uint8 // Type = 3
+ ReceivedOpticalPower uint16 // value
+ MeanOpticalLaunchType uint8 // Type = 5
+ MeanOpticalLaunch uint16 // value
+ LaserBiasCurrentType uint8 // Type = 9
+ LaserBiasCurrent uint16 // value
+ TemperatureType uint8 // Type = 12
+ Temperature uint16 // value
+
+ GeneralPurposeBuffer uint16 // Pointer to General Purpose Buffer ME
+}
+
+func (omci *OpticalLineSupervisionTestResult) String() string {
+ return fmt.Sprintf("Optical Line Supervision Test Result")
+}
+
+func (omci *OpticalLineSupervisionTestResult) TestResults() []byte {
+ return omci.MeBasePacket.Payload
+}
+
+// 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)
+ if err != nil {
+ return err
+ }
+
+ meDefinition, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
+ me.ParamData{EntityID: omci.EntityInstance})
+ if omciErr.StatusCode() != me.Success {
+ return omciErr.GetError()
+ }
+
+ // ME needs to support Test requests
+ if !me.SupportsMsgType(meDefinition, me.Test) {
+ return me.NewProcessingError("managed entity does not support Test Message-Type")
+ }
+ // 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:])
+
+ // Type = 3
+ omci.ReceivedOpticalPowerType = data[7]
+ omci.ReceivedOpticalPower = binary.BigEndian.Uint16(data[8:])
+
+ // Type = 5
+ omci.MeanOpticalLaunchType = data[10]
+ omci.MeanOpticalLaunch = binary.BigEndian.Uint16(data[11:])
+
+ // Type = 9
+ omci.LaserBiasCurrentType = data[13]
+ omci.LaserBiasCurrent = binary.BigEndian.Uint16(data[14:])
+
+ // Type = 12
+ omci.TemperatureType = data[16]
+ omci.Temperature = binary.BigEndian.Uint16(data[17:])
+
+ omci.GeneralPurposeBuffer = binary.BigEndian.Uint16(data[19:])
+ return nil
+}
+
+// SerializeTo provides serialization of an Test Result notification message
+func (omci *OpticalLineSupervisionTestResult) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
// Basic (common) OMCI Header is 8 octets, 10
err := omci.MeBasePacket.SerializeTo(b)
if err != nil {
return err
}
- return errors.New("need to implement") // TODO: Fix me) // omci.cachedME.SerializeTo(mask, b)
+ meDefinition, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
+ me.ParamData{EntityID: omci.EntityInstance})
+ if omciErr.StatusCode() != me.Success {
+ return omciErr.GetError()
+ }
+
+ // ME needs to support Test requests
+ if !me.SupportsMsgType(meDefinition, me.Test) {
+ return me.NewProcessingError("managed entity does not support Test Message-Type")
+ }
+ bytes, err := b.AppendBytes(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)
+ 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 9b7f881..b2995d0 100644
--- a/vendor/github.com/opencord/omci-lib-go/omci.go
+++ b/vendor/github.com/opencord/omci-lib-go/omci.go
@@ -86,10 +86,18 @@
const MaxAttributeMibUploadNextBaselineLength = MaxBaselineLength - 14 - 8
// MaxAttributeGetNextBaselineLength is the maximum payload size for attributes for
-// a Baseline MIB Get Next message. This is just the attribute portion of the
-// message contents and does not include the Result Code & Attribute Mask.
+// a Baseline MIB Get Next message for the baseline message set. This is just the
+// attribute portion of the message contents and does not include the Result Code & Attribute Mask.
const MaxAttributeGetNextBaselineLength = MaxBaselineLength - 11 - 8
+// MaxTestRequestLength is the maximum payload size for test request message
+// for the baseline message set.
+const MaxTestRequestLength = MaxBaselineLength - 8 - 8
+
+// MaxTestResultsLength is the maximum payload size for test results message
+// for the baseline message set.
+const MaxTestResultsLength = MaxBaselineLength - 8 - 8
+
// MaxManagedEntityMibUploadNextExtendedLength is the maximum payload size for ME
// entries for an Extended MIB Upload Next message. Extended messages differ from
// the baseline as multiple MEs can be reported in a single frame, just not multiple
@@ -115,7 +123,6 @@
DeviceIdentifier DeviceIdent
ResponseExpected bool // Significant for Download Section Request only
Payload []byte // TODO: Deprecated. Use layers.BaseLayer.Payload
- padding []byte // TODO: Deprecated. Never Used
Length uint16
MIC uint32
}
@@ -157,21 +164,24 @@
func decodeOMCI(data []byte, p gopacket.PacketBuilder) error {
// Allow baseline messages without Length & MIC, but no less
- if len(data) < MaxBaselineLength-8 {
+ if len(data) < 10 {
+ p.SetTruncated()
return errors.New("frame header too small")
}
+ omci := &OMCI{}
+
switch DeviceIdent(data[3]) {
default:
- return errors.New("unsupported message type")
+ return errors.New("unsupported message set/device identifier")
case BaselineIdent:
- //omci := &BaselineMessage{}
- omci := &OMCI{}
+ if len(data) < MaxBaselineLength-8 {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
return omci.DecodeFromBytes(data, p)
case ExtendedIdent:
- //omci := &ExtendedMessage{}
- omci := &OMCI{}
return omci.DecodeFromBytes(data, p)
}
}
@@ -217,10 +227,12 @@
// Decode length
var payloadOffset int
var micOffset int
+ var eomOffset int
if omci.DeviceIdentifier == BaselineIdent {
omci.Length = MaxBaselineLength - 8
payloadOffset = 8
micOffset = MaxBaselineLength - 4
+ eomOffset = MaxBaselineLength - 8
if len(data) >= micOffset {
length := binary.BigEndian.Uint32(data[micOffset-4:])
@@ -232,14 +244,13 @@
payloadOffset = 10
omci.Length = binary.BigEndian.Uint16(data[8:10])
micOffset = int(omci.Length) + payloadOffset
+ eomOffset = micOffset
- if omci.Length > MaxExtendedLength {
+ if omci.Length > uint16(MaxExtendedLength-payloadOffset) {
return me.NewProcessingError("extended frame exceeds maximum allowed")
}
- if int(omci.Length) != micOffset {
- if int(omci.Length) < micOffset {
- p.SetTruncated()
- }
+ if len(data) < micOffset {
+ p.SetTruncated()
return me.NewProcessingError("extended frame too small")
}
}
@@ -253,9 +264,9 @@
//return errors.New(msg)
}
}
- omci.BaseLayer = layers.BaseLayer{Contents: data[:4], Payload: data[4:omci.Length]}
+ omci.BaseLayer = layers.BaseLayer{data[:4], data[4:eomOffset]}
p.AddLayer(omci)
- nextLayer, err := MsgTypeToNextLayer(omci.MessageType)
+ nextLayer, err := MsgTypeToNextLayer(omci.MessageType, omci.DeviceIdentifier == ExtendedIdent)
if err != nil {
return err
}
@@ -266,8 +277,6 @@
// SerializationBuffer, implementing gopacket.SerializableLayer.
// See the docs for gopacket.SerializableLayer for more info.
func (omci *OMCI) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
- // TODO: Hardcoded for baseline message format for now. Will eventually need to support
- // the extended message format.
bytes, err := b.PrependBytes(4)
if err != nil {
return err
@@ -288,11 +297,11 @@
return errors.New(msg)
}
} else if omci.DeviceIdentifier == ExtendedIdent {
- if omci.Length == 0 {
- omci.Length = uint16(len(bytes) - 10) // Allow uninitialized length
- }
- if omci.Length > MaxExtendedLength {
- msg := fmt.Sprintf("invalid Baseline message length: %v", omci.Length)
+ omci.Length = uint16(len(b.Bytes()) - 10)
+
+ // Is length larger than maximum packet (less header and trailing MIC)
+ if omci.Length > MaxExtendedLength-10-4 {
+ msg := fmt.Sprintf("invalid Extended message length: %v", omci.Length)
return errors.New(msg)
}
} else {
@@ -311,17 +320,20 @@
bytes[3] = byte(omci.DeviceIdentifier)
b.PushLayer(LayerTypeOMCI)
- bufLen := len(b.Bytes())
- padSize := int(omci.Length) - bufLen + 4
- if padSize < 0 {
- msg := fmt.Sprintf("invalid OMCI Message Type length, exceeded allowed frame size by %d bytes",
- -padSize)
- return errors.New(msg)
- }
- padding, err := b.AppendBytes(padSize)
- copy(padding, lotsOfZeros[:])
-
if omci.DeviceIdentifier == BaselineIdent {
+ bufLen := len(b.Bytes())
+ padSize := int(omci.Length) - bufLen + 4
+ if padSize < 0 {
+ msg := fmt.Sprintf("invalid OMCI Message Type length, exceeded allowed frame size by %d bytes",
+ -padSize)
+ return errors.New(msg)
+ }
+ padding, err := b.AppendBytes(padSize)
+ if err != nil {
+ return err
+ }
+ copy(padding, lotsOfZeros[:])
+
// For baseline, always provide the length
binary.BigEndian.PutUint32(b.Bytes()[MaxBaselineLength-8:], 40)
}
diff --git a/vendor/github.com/opencord/voltha-protos/v4/go/extension/extensions.pb.go b/vendor/github.com/opencord/voltha-protos/v4/go/extension/extensions.pb.go
index ea6b404..bd962dc 100644
--- a/vendor/github.com/opencord/voltha-protos/v4/go/extension/extensions.pb.go
+++ b/vendor/github.com/opencord/voltha-protos/v4/go/extension/extensions.pb.go
@@ -727,21 +727,17 @@
return nil
}
-// The types are from Table 11.2.10-1 in G.988
+// These values correspond to the Optical Line Supervision Test results
+// described in section A3.39.5 of ITU-T G.988 (11/2017) specification.
type GetOnuPonOpticalInfoResponse struct {
- LaserBiasCurrent int32 `protobuf:"varint,1,opt,name=laserBiasCurrent,proto3" json:"laserBiasCurrent,omitempty"`
- LaserBiasCurrentTypeId int32 `protobuf:"varint,2,opt,name=laserBiasCurrentTypeId,proto3" json:"laserBiasCurrentTypeId,omitempty"`
- MeanOpticalLaunchPower int32 `protobuf:"varint,3,opt,name=meanOpticalLaunchPower,proto3" json:"meanOpticalLaunchPower,omitempty"`
- MeanOpticalLaunchPowerTypeId int32 `protobuf:"varint,4,opt,name=meanOpticalLaunchPowerTypeId,proto3" json:"meanOpticalLaunchPowerTypeId,omitempty"`
- PowerFeedTypeId int32 `protobuf:"varint,5,opt,name=powerFeedTypeId,proto3" json:"powerFeedTypeId,omitempty"`
- PowerFeedVoltage int32 `protobuf:"varint,6,opt,name=powerFeedVoltage,proto3" json:"powerFeedVoltage,omitempty"`
- ReceivedOpticalPower int32 `protobuf:"varint,7,opt,name=receivedOpticalPower,proto3" json:"receivedOpticalPower,omitempty"`
- ReceivedOpticalPowerTypeId int32 `protobuf:"varint,8,opt,name=receivedOpticalPowerTypeId,proto3" json:"receivedOpticalPowerTypeId,omitempty"`
- Temperature int32 `protobuf:"varint,9,opt,name=temperature,proto3" json:"temperature,omitempty"`
- TemperatureTypeId int32 `protobuf:"varint,10,opt,name=temperatureTypeId,proto3" json:"temperatureTypeId,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
+ PowerFeedVoltage float32 `protobuf:"fixed32,1,opt,name=powerFeedVoltage,proto3" json:"powerFeedVoltage,omitempty"`
+ ReceivedOpticalPower float32 `protobuf:"fixed32,2,opt,name=receivedOpticalPower,proto3" json:"receivedOpticalPower,omitempty"`
+ MeanOpticalLaunchPower float32 `protobuf:"fixed32,3,opt,name=meanOpticalLaunchPower,proto3" json:"meanOpticalLaunchPower,omitempty"`
+ LaserBiasCurrent float32 `protobuf:"fixed32,4,opt,name=laserBiasCurrent,proto3" json:"laserBiasCurrent,omitempty"`
+ Temperature float32 `protobuf:"fixed32,5,opt,name=temperature,proto3" json:"temperature,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
func (m *GetOnuPonOpticalInfoResponse) Reset() { *m = GetOnuPonOpticalInfoResponse{} }
@@ -769,76 +765,41 @@
var xxx_messageInfo_GetOnuPonOpticalInfoResponse proto.InternalMessageInfo
-func (m *GetOnuPonOpticalInfoResponse) GetLaserBiasCurrent() int32 {
- if m != nil {
- return m.LaserBiasCurrent
- }
- return 0
-}
-
-func (m *GetOnuPonOpticalInfoResponse) GetLaserBiasCurrentTypeId() int32 {
- if m != nil {
- return m.LaserBiasCurrentTypeId
- }
- return 0
-}
-
-func (m *GetOnuPonOpticalInfoResponse) GetMeanOpticalLaunchPower() int32 {
- if m != nil {
- return m.MeanOpticalLaunchPower
- }
- return 0
-}
-
-func (m *GetOnuPonOpticalInfoResponse) GetMeanOpticalLaunchPowerTypeId() int32 {
- if m != nil {
- return m.MeanOpticalLaunchPowerTypeId
- }
- return 0
-}
-
-func (m *GetOnuPonOpticalInfoResponse) GetPowerFeedTypeId() int32 {
- if m != nil {
- return m.PowerFeedTypeId
- }
- return 0
-}
-
-func (m *GetOnuPonOpticalInfoResponse) GetPowerFeedVoltage() int32 {
+func (m *GetOnuPonOpticalInfoResponse) GetPowerFeedVoltage() float32 {
if m != nil {
return m.PowerFeedVoltage
}
return 0
}
-func (m *GetOnuPonOpticalInfoResponse) GetReceivedOpticalPower() int32 {
+func (m *GetOnuPonOpticalInfoResponse) GetReceivedOpticalPower() float32 {
if m != nil {
return m.ReceivedOpticalPower
}
return 0
}
-func (m *GetOnuPonOpticalInfoResponse) GetReceivedOpticalPowerTypeId() int32 {
+func (m *GetOnuPonOpticalInfoResponse) GetMeanOpticalLaunchPower() float32 {
if m != nil {
- return m.ReceivedOpticalPowerTypeId
+ return m.MeanOpticalLaunchPower
}
return 0
}
-func (m *GetOnuPonOpticalInfoResponse) GetTemperature() int32 {
+func (m *GetOnuPonOpticalInfoResponse) GetLaserBiasCurrent() float32 {
+ if m != nil {
+ return m.LaserBiasCurrent
+ }
+ return 0
+}
+
+func (m *GetOnuPonOpticalInfoResponse) GetTemperature() float32 {
if m != nil {
return m.Temperature
}
return 0
}
-func (m *GetOnuPonOpticalInfoResponse) GetTemperatureTypeId() int32 {
- if m != nil {
- return m.TemperatureTypeId
- }
- return 0
-}
-
type GetOnuEthernetBridgePortHistory struct {
Direction GetOnuEthernetBridgePortHistory_Direction `protobuf:"varint,1,opt,name=direction,proto3,enum=extension.GetOnuEthernetBridgePortHistory_Direction" json:"direction,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -1748,124 +1709,121 @@
func init() { proto.RegisterFile("voltha_protos/extensions.proto", fileDescriptor_7ecf6e9799a9202d) }
var fileDescriptor_7ecf6e9799a9202d = []byte{
- // 1872 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xdd, 0x72, 0x1a, 0xc9,
- 0x15, 0x16, 0x48, 0x20, 0x38, 0x48, 0xf2, 0xb8, 0x6d, 0x69, 0x55, 0xb2, 0xd7, 0xeb, 0x4c, 0x2a,
- 0xf6, 0xd6, 0xd6, 0x06, 0x2d, 0xac, 0xe4, 0x55, 0x65, 0x37, 0xa9, 0x80, 0x18, 0x49, 0x94, 0xa4,
- 0x01, 0xf7, 0x80, 0xbc, 0xc9, 0x0d, 0x35, 0x62, 0xda, 0x88, 0x0a, 0x9a, 0x26, 0x3d, 0x8d, 0x22,
- 0xe7, 0x35, 0x72, 0x93, 0x3c, 0x45, 0x2e, 0x72, 0xe1, 0xfb, 0x5c, 0xe7, 0x25, 0xf2, 0x0a, 0x79,
- 0x80, 0x54, 0xaa, 0x7f, 0x66, 0x98, 0x19, 0x40, 0xb2, 0x9d, 0xbd, 0xa3, 0xcf, 0xf9, 0xbe, 0xaf,
- 0x9b, 0x3e, 0x5f, 0x9f, 0x99, 0x1e, 0x78, 0x76, 0x43, 0x47, 0xfc, 0xca, 0xed, 0x8d, 0x19, 0xe5,
- 0x34, 0xd8, 0x25, 0xb7, 0x9c, 0xf8, 0xc1, 0x90, 0xfa, 0x41, 0x59, 0x46, 0x50, 0x31, 0x8a, 0xec,
- 0xcc, 0x42, 0x7b, 0x7d, 0xea, 0xbf, 0x1d, 0x0e, 0x14, 0x74, 0xe7, 0xc9, 0x80, 0xd2, 0xc1, 0x88,
- 0xec, 0xca, 0xd1, 0xe5, 0xe4, 0xed, 0x2e, 0xb9, 0x1e, 0xf3, 0x77, 0x2a, 0x69, 0xbe, 0x02, 0x74,
- 0x4c, 0x78, 0x63, 0x18, 0x70, 0xd7, 0xef, 0x13, 0x4c, 0xfe, 0x38, 0x21, 0x01, 0x47, 0xcf, 0xa1,
- 0x44, 0xfd, 0x49, 0x83, 0xdc, 0x0c, 0xfb, 0xa4, 0xe9, 0x6d, 0x67, 0x9e, 0x67, 0xbe, 0x2c, 0xe2,
- 0x78, 0xc8, 0xac, 0xc0, 0xa3, 0x04, 0x2f, 0x18, 0x53, 0x3f, 0x20, 0x68, 0x07, 0x0a, 0x9e, 0x8e,
- 0x49, 0xd6, 0x3a, 0x8e, 0xc6, 0x66, 0x15, 0x1e, 0x1f, 0x13, 0xde, 0xf2, 0x27, 0x5d, 0x7f, 0xd8,
- 0xf4, 0xdf, 0xd2, 0x70, 0xb2, 0x1d, 0x28, 0x4c, 0x44, 0xc4, 0x23, 0xb7, 0x21, 0x27, 0x1c, 0x9b,
- 0xff, 0x5e, 0x81, 0xcd, 0x14, 0x49, 0xcf, 0xd4, 0x86, 0x82, 0xeb, 0x5d, 0x3b, 0xdc, 0xe5, 0x6a,
- 0xa6, 0x8d, 0xea, 0x5e, 0x39, 0xda, 0x93, 0xf2, 0x5c, 0x4e, 0xb9, 0xe6, 0x5d, 0x0f, 0xfd, 0x61,
- 0xc0, 0x99, 0xcb, 0x87, 0x37, 0x44, 0x72, 0x71, 0xa4, 0x82, 0x5a, 0x50, 0xa4, 0x63, 0xc2, 0x94,
- 0x64, 0x56, 0x4a, 0x56, 0xee, 0x95, 0x6c, 0x8d, 0x89, 0x50, 0xa3, 0xbe, 0x3b, 0x52, 0x7a, 0x53,
- 0x0d, 0x21, 0xa8, 0x0a, 0xd1, 0xf4, 0xbd, 0xed, 0xe5, 0x0f, 0x14, 0x3c, 0x94, 0x8c, 0x89, 0x12,
- 0x6d, 0xfa, 0x1e, 0x9e, 0x6a, 0x98, 0xff, 0xcc, 0x80, 0x91, 0xce, 0x23, 0x80, 0x7c, 0xd7, 0x3e,
- 0x6d, 0xbd, 0xb1, 0x8d, 0x25, 0x84, 0x60, 0xa3, 0x63, 0xd9, 0xbd, 0x7a, 0xcd, 0xb1, 0x7a, 0x9d,
- 0xde, 0x51, 0xe3, 0x47, 0x23, 0x83, 0xb6, 0x00, 0x9d, 0x74, 0xed, 0x06, 0xb6, 0x1a, 0xf1, 0x78,
- 0x16, 0x6d, 0xc3, 0xe3, 0xe3, 0xe6, 0x71, 0xad, 0xde, 0xec, 0xf4, 0xac, 0xce, 0x89, 0x85, 0x6d,
- 0x4b, 0x65, 0x96, 0x05, 0x43, 0xa8, 0x1c, 0x27, 0xe3, 0x2b, 0x29, 0xf5, 0x93, 0xc6, 0x8f, 0x46,
- 0x6e, 0x8e, 0xba, 0x88, 0xe7, 0xe7, 0xaa, 0x8b, 0xcc, 0xaa, 0x79, 0x0c, 0x8f, 0xe6, 0xd4, 0x41,
- 0x08, 0xd5, 0x1a, 0xe7, 0x4e, 0xa7, 0xd6, 0xb1, 0x7a, 0x5d, 0xbb, 0x61, 0x1d, 0x35, 0x6d, 0xab,
- 0x61, 0x2c, 0x89, 0xbf, 0x77, 0xd6, 0x3a, 0x3c, 0xb5, 0x1a, 0x46, 0x06, 0xad, 0x41, 0xa1, 0x6b,
- 0xeb, 0x51, 0xd6, 0x3c, 0x02, 0x23, 0xbd, 0xfb, 0xe8, 0x33, 0x78, 0xd4, 0x6a, 0x5b, 0x78, 0x56,
- 0xa6, 0x04, 0xab, 0x96, 0x5d, 0xab, 0x9f, 0x85, 0x3a, 0x8d, 0xa6, 0xa3, 0x46, 0x59, 0xf3, 0x7d,
- 0x46, 0x9e, 0x81, 0xd6, 0x88, 0xb7, 0x29, 0xe3, 0x87, 0x74, 0xe2, 0x73, 0xc2, 0x02, 0xb4, 0x05,
- 0xf9, 0x31, 0x65, 0xdc, 0xa6, 0xda, 0x94, 0x7a, 0x84, 0xea, 0x50, 0x10, 0xbf, 0x3a, 0xef, 0xc6,
- 0xa1, 0x4b, 0x5e, 0xa4, 0x8a, 0x9a, 0x14, 0x2a, 0xb7, 0x35, 0x1a, 0x47, 0x3c, 0xd3, 0x82, 0x42,
- 0x18, 0x45, 0x06, 0xac, 0x89, 0xdf, 0xbd, 0xae, 0x7d, 0x6a, 0xab, 0x2a, 0x6e, 0xc2, 0x43, 0x19,
- 0x89, 0x36, 0xce, 0xb6, 0x9b, 0x46, 0x26, 0x02, 0xb6, 0x5b, 0x76, 0xaf, 0x75, 0xd6, 0x31, 0xb2,
- 0xe6, 0xbf, 0x96, 0x61, 0x67, 0x76, 0xc2, 0xe8, 0x88, 0x6c, 0xc3, 0x2a, 0xbf, 0xad, 0xbf, 0xe3,
- 0x24, 0x90, 0x7f, 0x61, 0x05, 0x87, 0x43, 0x91, 0x61, 0x3a, 0x93, 0x55, 0x19, 0x3d, 0x44, 0x4f,
- 0xa1, 0xc8, 0x6f, 0xdb, 0x6e, 0xff, 0x0f, 0x84, 0x07, 0xd2, 0xb3, 0x2b, 0x78, 0x1a, 0x10, 0x59,
- 0x16, 0x65, 0x57, 0x54, 0x36, 0x0a, 0xa0, 0x17, 0xb0, 0xc1, 0x6f, 0x2d, 0xc6, 0x28, 0x0b, 0x21,
- 0x39, 0x09, 0x49, 0x45, 0x05, 0x8e, 0x25, 0x71, 0x79, 0x85, 0x63, 0x33, 0x38, 0x7e, 0x5b, 0xef,
- 0xbb, 0x01, 0x0f, 0x71, 0xab, 0xa1, 0x5e, 0x3c, 0xaa, 0xf4, 0x12, 0xb8, 0x42, 0xa8, 0x97, 0xc6,
- 0xf1, 0xdb, 0x6e, 0x1c, 0x57, 0x0c, 0xf5, 0xba, 0x33, 0x7a, 0x09, 0x1c, 0x84, 0x7a, 0xdd, 0x19,
- 0xbd, 0xf3, 0x38, 0xae, 0x14, 0xea, 0x9d, 0xcf, 0xe8, 0x25, 0x70, 0x6b, 0xa1, 0x5e, 0x3c, 0x6a,
- 0x36, 0xc2, 0x06, 0xd9, 0xa6, 0x7e, 0x6b, 0xcc, 0x87, 0x7d, 0x77, 0x24, 0x5a, 0x03, 0xfa, 0x1a,
- 0x72, 0xb2, 0x65, 0xcb, 0x2a, 0x96, 0xaa, 0x5b, 0x65, 0xd5, 0xd0, 0xcb, 0x61, 0x43, 0x2f, 0x5b,
- 0x22, 0x8b, 0x15, 0xc8, 0xfc, 0xeb, 0x0a, 0x3c, 0x9d, 0x27, 0x13, 0xd9, 0xe2, 0x2b, 0x30, 0x46,
- 0x6e, 0x40, 0x58, 0x7d, 0xe8, 0x06, 0x87, 0x13, 0xc6, 0x88, 0xcf, 0xa5, 0x72, 0x0e, 0xcf, 0xc4,
- 0xd1, 0x2b, 0xd8, 0x4a, 0xc7, 0x84, 0x69, 0x9b, 0x9e, 0xf4, 0x4d, 0x0e, 0x2f, 0xc8, 0x0a, 0xde,
- 0x35, 0x71, 0xc3, 0xe9, 0xcf, 0xdc, 0x89, 0xdf, 0xbf, 0x6a, 0xd3, 0x3f, 0x11, 0x26, 0x3d, 0x95,
- 0xc3, 0x0b, 0xb2, 0xa8, 0x0e, 0x4f, 0xe7, 0x67, 0xf4, 0xac, 0x2b, 0x92, 0x7d, 0x27, 0x06, 0x7d,
- 0x09, 0x0f, 0xc6, 0x62, 0x78, 0x44, 0x88, 0xa7, 0x69, 0x39, 0x49, 0x4b, 0x87, 0xc5, 0x4e, 0x44,
- 0xa1, 0x0b, 0x3a, 0xe2, 0xee, 0x80, 0x48, 0x2b, 0xe6, 0xf0, 0x4c, 0x1c, 0x55, 0xe1, 0x31, 0x23,
- 0x7d, 0x32, 0xbc, 0x21, 0x9e, 0x9e, 0x59, 0xfd, 0x9f, 0x55, 0x89, 0x9f, 0x9b, 0x43, 0xbf, 0x81,
- 0x9d, 0x79, 0x71, 0xbd, 0xa8, 0x82, 0x64, 0xde, 0x81, 0x10, 0x8f, 0x61, 0x4e, 0xae, 0x65, 0x8f,
- 0x9b, 0x30, 0x22, 0xdd, 0x9a, 0xc3, 0xf1, 0x10, 0xfa, 0x1a, 0x1e, 0xc6, 0x86, 0x5a, 0x18, 0x24,
- 0x6e, 0x36, 0x61, 0xfe, 0x3d, 0x03, 0x5f, 0x28, 0x6b, 0x58, 0xfc, 0x8a, 0x30, 0x9f, 0xf0, 0x3a,
- 0x1b, 0x7a, 0x03, 0x22, 0xba, 0xc7, 0xc9, 0x30, 0xe0, 0x94, 0xbd, 0x43, 0x18, 0x8a, 0xde, 0x90,
- 0x91, 0xbe, 0xe8, 0xaa, 0x0b, 0x1f, 0xac, 0x0b, 0xe9, 0xe5, 0x46, 0xc8, 0xc5, 0x53, 0x19, 0xf3,
- 0x00, 0x8a, 0x51, 0x1c, 0xad, 0x43, 0x31, 0xde, 0x98, 0x45, 0x4f, 0x6f, 0x3b, 0x1d, 0x6c, 0xd5,
- 0xce, 0x8d, 0x0c, 0xda, 0x00, 0x68, 0xb4, 0xde, 0xd8, 0x7a, 0x9c, 0x35, 0xff, 0x92, 0x83, 0x97,
- 0xf7, 0x4c, 0x19, 0xf9, 0xfa, 0x19, 0x80, 0xc7, 0xe8, 0xd8, 0xba, 0x21, 0x3e, 0x0f, 0x74, 0xd3,
- 0x8e, 0x45, 0x44, 0x43, 0xa7, 0x7d, 0x2e, 0x8e, 0x5f, 0x56, 0x35, 0x74, 0x35, 0x12, 0xcd, 0x70,
- 0x1c, 0x6b, 0x78, 0xeb, 0x38, 0x1c, 0x0a, 0x7f, 0x5c, 0x32, 0xea, 0x7a, 0xf1, 0xa3, 0xbb, 0x22,
- 0x21, 0x33, 0x71, 0x81, 0xbd, 0x9e, 0x8c, 0x44, 0x09, 0xa7, 0xd8, 0x9c, 0xc2, 0xa6, 0xe3, 0xa2,
- 0x6a, 0x7d, 0xd6, 0x97, 0xbd, 0x8e, 0x78, 0xf1, 0x1e, 0xb8, 0x8e, 0x67, 0x13, 0x42, 0x79, 0xe2,
- 0x7b, 0x84, 0x05, 0xc3, 0x3f, 0x93, 0x78, 0x23, 0x5c, 0xc7, 0x33, 0x71, 0xe1, 0x7d, 0x7a, 0x93,
- 0x84, 0x16, 0x24, 0x34, 0x1d, 0x96, 0xa7, 0x44, 0xfd, 0x7c, 0xb5, 0xa7, 0xb7, 0xa5, 0xa8, 0x90,
- 0xa9, 0xb0, 0x70, 0x7e, 0x18, 0xda, 0xef, 0xd0, 0x4a, 0xf5, 0x3b, 0x0d, 0x07, 0x09, 0x9f, 0x9b,
- 0x43, 0x7b, 0xb0, 0xa9, 0xe3, 0x95, 0xea, 0x41, 0x87, 0x56, 0xf7, 0xf7, 0x5b, 0x8a, 0x54, 0x92,
- 0xa4, 0xf9, 0xc9, 0x18, 0xab, 0xba, 0xff, 0xaa, 0x43, 0xf7, 0x2b, 0x15, 0x3d, 0xd5, 0x5a, 0x82,
- 0x95, 0x4c, 0x8a, 0x5e, 0xa3, 0x13, 0xfb, 0x95, 0x6a, 0x87, 0x56, 0xbe, 0xa9, 0x7e, 0xab, 0x69,
- 0xeb, 0x92, 0xb6, 0x20, 0x8b, 0x0e, 0xe0, 0xb3, 0x70, 0x19, 0xdf, 0x54, 0xf7, 0x3a, 0xb4, 0xb2,
- 0x5f, 0x39, 0xd0, 0xc4, 0x0d, 0x49, 0x5c, 0x94, 0x36, 0x7f, 0x0b, 0x86, 0x32, 0xe5, 0x11, 0xe9,
- 0x87, 0xe7, 0xe6, 0xe3, 0x9a, 0xf4, 0x7f, 0x32, 0xb0, 0x9d, 0x96, 0x88, 0x8c, 0xfc, 0x02, 0x36,
- 0xfa, 0x94, 0x89, 0xf3, 0x42, 0xbc, 0xe9, 0xe3, 0x7b, 0x1d, 0xa7, 0xa2, 0xa8, 0x0c, 0x28, 0x8a,
- 0x1c, 0x52, 0x8f, 0xbc, 0xa1, 0xcc, 0x0b, 0xcd, 0x3d, 0x27, 0x23, 0x0e, 0xc8, 0x5b, 0xd2, 0x77,
- 0x48, 0x9f, 0xfa, 0x5e, 0xe8, 0xf5, 0x58, 0x44, 0x3e, 0xcf, 0x28, 0x77, 0x47, 0x53, 0x2d, 0x65,
- 0xf6, 0x54, 0x54, 0x6c, 0xf8, 0xc4, 0xd7, 0xfa, 0xee, 0xe5, 0x88, 0x4c, 0xf1, 0xca, 0xf0, 0x0b,
- 0xb2, 0xe6, 0xfb, 0x65, 0x78, 0x70, 0x4c, 0xf8, 0x85, 0x3b, 0x9a, 0x44, 0x37, 0x8d, 0xef, 0x53,
- 0x17, 0x86, 0x52, 0xf5, 0xf3, 0x64, 0xb7, 0x49, 0x5d, 0x4d, 0x4e, 0x96, 0xa6, 0x37, 0x0a, 0xf4,
- 0x3d, 0xac, 0x4e, 0xd4, 0xeb, 0xb3, 0xfc, 0xd7, 0xa5, 0xea, 0x17, 0x8b, 0x5f, 0xaf, 0x43, 0x76,
- 0xc8, 0x40, 0x35, 0x28, 0x51, 0xf5, 0xe2, 0x24, 0x05, 0x96, 0xe7, 0x4d, 0x9e, 0x7a, 0xb3, 0x3a,
- 0x59, 0xc2, 0x71, 0x0e, 0x6a, 0xc2, 0x06, 0xf5, 0x27, 0xb1, 0x67, 0xac, 0xdc, 0xb0, 0x79, 0xcb,
- 0x48, 0x3e, 0x8a, 0x4f, 0x96, 0x70, 0x8a, 0x88, 0x30, 0xac, 0x13, 0x7e, 0x35, 0x6d, 0x6e, 0x72,
- 0x2b, 0x4b, 0xd5, 0xaf, 0x3e, 0xbc, 0xf5, 0x9e, 0x2c, 0xe1, 0xa4, 0x04, 0xfa, 0xb5, 0xac, 0xb7,
- 0x4e, 0xcb, 0xfe, 0x52, 0xaa, 0x3e, 0x99, 0x11, 0x9c, 0x1a, 0xf0, 0x64, 0x09, 0xc7, 0x08, 0xf5,
- 0x22, 0xac, 0x32, 0xb5, 0x6d, 0xe6, 0xfb, 0xbc, 0x74, 0xbc, 0xae, 0x9c, 0xb6, 0xe9, 0xaf, 0x20,
- 0x1f, 0x70, 0x97, 0x4f, 0x02, 0xfd, 0x98, 0x30, 0x93, 0xd2, 0x09, 0x70, 0xd9, 0x91, 0x48, 0xac,
- 0x19, 0xc8, 0x82, 0x22, 0x61, 0x0c, 0x13, 0x37, 0xa0, 0xbe, 0x7e, 0x8b, 0x7e, 0x79, 0x17, 0x5d,
- 0xb6, 0x44, 0x05, 0xc7, 0x53, 0x26, 0xfa, 0x21, 0xe6, 0x1e, 0x55, 0xc0, 0x67, 0x8b, 0xdc, 0xa3,
- 0x84, 0x12, 0xf6, 0xf9, 0x61, 0x6a, 0x1f, 0x55, 0xb7, 0xe7, 0xf7, 0xdd, 0xce, 0xe2, 0xfe, 0x39,
- 0x85, 0xb5, 0xb1, 0xf2, 0x06, 0xf7, 0x09, 0x0b, 0x74, 0xc1, 0x7e, 0x71, 0xa7, 0x81, 0x62, 0x3a,
- 0x09, 0x32, 0x7a, 0x3d, 0xe3, 0x24, 0x55, 0xae, 0x97, 0xf7, 0x38, 0x29, 0x26, 0x98, 0x76, 0xd4,
- 0x25, 0x3c, 0x4c, 0xd8, 0x41, 0xaa, 0xae, 0x4a, 0xd5, 0xea, 0x87, 0xbb, 0x2a, 0x36, 0xc1, 0xac,
- 0x1c, 0xb2, 0x12, 0x0e, 0x2b, 0x48, 0xf1, 0x9f, 0xdf, 0xe1, 0xb0, 0x98, 0x5a, 0x8c, 0x68, 0x56,
- 0x20, 0xaf, 0xfc, 0x81, 0x1e, 0x83, 0x21, 0xee, 0x6e, 0x5d, 0x27, 0x71, 0x79, 0xcb, 0x43, 0xb6,
- 0x75, 0x6a, 0x64, 0x50, 0x11, 0x72, 0x16, 0xc6, 0x2d, 0x6c, 0x64, 0xcd, 0xbf, 0x65, 0xa0, 0x14,
- 0x33, 0x85, 0x20, 0x62, 0xab, 0xe6, 0xb4, 0xec, 0x04, 0xf1, 0x01, 0x94, 0xba, 0xb6, 0xd3, 0x6d,
- 0xb7, 0x5b, 0xb8, 0x23, 0x6f, 0x7e, 0x9b, 0xf0, 0xb0, 0x69, 0x5f, 0xd4, 0xce, 0x9a, 0x8d, 0x5e,
- 0xc3, 0xba, 0x68, 0x1e, 0x5a, 0xbd, 0x66, 0xc3, 0xc8, 0xc6, 0xc3, 0x02, 0xda, 0xeb, 0xfc, 0xae,
- 0x6d, 0x19, 0xcb, 0xe2, 0xd2, 0xd8, 0x69, 0x9e, 0x5b, 0xad, 0x6e, 0xc7, 0x58, 0x11, 0x33, 0x84,
- 0x18, 0x6c, 0xbd, 0x56, 0x90, 0x9c, 0xb8, 0x13, 0x37, 0xed, 0x8e, 0x85, 0xed, 0xda, 0x59, 0x4f,
- 0xad, 0x2d, 0x5f, 0x07, 0x28, 0x30, 0xfd, 0x47, 0xcd, 0x0b, 0x78, 0xe0, 0xa4, 0x5a, 0xde, 0x01,
- 0xac, 0xb9, 0x23, 0x97, 0x5d, 0xeb, 0xaf, 0x34, 0xba, 0xed, 0x3d, 0x2a, 0xeb, 0x8f, 0x36, 0x35,
- 0x91, 0x53, 0xb7, 0x7c, 0xd1, 0x6f, 0xdc, 0xe9, 0x30, 0x7e, 0x22, 0xff, 0x9b, 0x01, 0xc3, 0xf9,
- 0x98, 0x13, 0xe9, 0xfc, 0x7f, 0x27, 0xd2, 0xf9, 0xb0, 0x13, 0xf9, 0x29, 0xa5, 0xdc, 0xfb, 0x94,
- 0x4a, 0x9a, 0x43, 0xd8, 0x74, 0x86, 0xfe, 0x60, 0x44, 0xd2, 0x4f, 0x94, 0x1d, 0x28, 0x70, 0x97,
- 0x0d, 0x08, 0x8f, 0x3e, 0x5c, 0x45, 0x63, 0xb4, 0x17, 0x6d, 0xa0, 0x7e, 0x60, 0xec, 0xcc, 0x6d,
- 0x3a, 0x12, 0x81, 0xa3, 0xbd, 0x7e, 0x0d, 0x5b, 0xe9, 0xa9, 0xf4, 0x86, 0x7f, 0x37, 0xad, 0xb4,
- 0x2e, 0xe3, 0x93, 0x3b, 0xba, 0x18, 0x9e, 0xda, 0x22, 0x5a, 0xbd, 0xf3, 0x53, 0xad, 0xde, 0xb9,
- 0x77, 0xf5, 0xce, 0xc7, 0xad, 0xde, 0x59, 0xb8, 0xfa, 0xea, 0x3f, 0x32, 0x50, 0xb4, 0x42, 0x20,
- 0xc2, 0x50, 0x3a, 0x26, 0xdc, 0xba, 0x55, 0x70, 0x14, 0x6f, 0xa2, 0x73, 0x2b, 0xb4, 0xf3, 0xb3,
- 0x3b, 0x10, 0x7a, 0x69, 0x18, 0x4a, 0xce, 0x9d, 0x9a, 0xce, 0xbd, 0x9a, 0xe9, 0xf5, 0xd7, 0x31,
- 0x7c, 0x4e, 0xd9, 0xa0, 0x4c, 0xc7, 0x44, 0xbc, 0x9e, 0x78, 0x65, 0xf5, 0xd9, 0x74, 0xca, 0xfb,
- 0x7d, 0x65, 0x30, 0xe4, 0x57, 0x93, 0xcb, 0x72, 0x9f, 0x5e, 0xef, 0x86, 0xa8, 0x5d, 0x85, 0xfa,
- 0xa5, 0xfe, 0xb8, 0x7a, 0xb3, 0xb7, 0x3b, 0xa0, 0xd3, 0xaf, 0xb1, 0xed, 0xa5, 0xcb, 0xbc, 0xcc,
- 0x7c, 0xfb, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe7, 0x8e, 0x67, 0xd3, 0xb1, 0x15, 0x00, 0x00,
+ // 1816 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xdd, 0x52, 0xe3, 0xc8,
+ 0x15, 0xc6, 0x06, 0x8c, 0x7d, 0x0c, 0x8c, 0xa6, 0x67, 0x60, 0x29, 0x76, 0x77, 0x76, 0xa2, 0x54,
+ 0x66, 0xb6, 0xb6, 0x36, 0x66, 0xed, 0x85, 0x59, 0x2a, 0xbb, 0xa9, 0x8a, 0x8d, 0x05, 0xb8, 0x00,
+ 0xd9, 0xd3, 0x92, 0x99, 0x4d, 0x6e, 0x5c, 0xc2, 0xea, 0x31, 0xae, 0x18, 0xb5, 0xd3, 0x6a, 0x13,
+ 0x26, 0xd7, 0x79, 0x83, 0x5c, 0xe5, 0x29, 0x72, 0x91, 0x8b, 0xb9, 0xcf, 0x75, 0x5e, 0x22, 0xaf,
+ 0x90, 0x07, 0x48, 0xa5, 0xfa, 0x47, 0xb2, 0x24, 0xdb, 0x30, 0xb3, 0xc9, 0x9d, 0xfb, 0x9c, 0xef,
+ 0xfb, 0xba, 0xdd, 0xe7, 0xeb, 0xa3, 0x96, 0xe0, 0xd9, 0x2d, 0x1d, 0xf1, 0x6b, 0xaf, 0x37, 0x66,
+ 0x94, 0xd3, 0x70, 0x8f, 0xdc, 0x71, 0x12, 0x84, 0x43, 0x1a, 0x84, 0x15, 0x19, 0x41, 0xa5, 0x38,
+ 0xb2, 0x3b, 0x0b, 0xed, 0xf5, 0x69, 0xf0, 0x76, 0x38, 0x50, 0xd0, 0xdd, 0x4f, 0x07, 0x94, 0x0e,
+ 0x46, 0x64, 0x4f, 0x8e, 0xae, 0x26, 0x6f, 0xf7, 0xc8, 0xcd, 0x98, 0xbf, 0x53, 0x49, 0xf3, 0x15,
+ 0xa0, 0x13, 0xc2, 0x9b, 0xc3, 0x90, 0x7b, 0x41, 0x9f, 0x60, 0xf2, 0x87, 0x09, 0x09, 0x39, 0x7a,
+ 0x0e, 0x65, 0x1a, 0x4c, 0x9a, 0xe4, 0x76, 0xd8, 0x27, 0x2d, 0x7f, 0x27, 0xf7, 0x3c, 0xf7, 0x65,
+ 0x09, 0x27, 0x43, 0x66, 0x15, 0x9e, 0xa4, 0x78, 0xe1, 0x98, 0x06, 0x21, 0x41, 0xbb, 0x50, 0xf4,
+ 0x75, 0x4c, 0xb2, 0x36, 0x70, 0x3c, 0x36, 0x6b, 0xf0, 0xf4, 0x84, 0xf0, 0x76, 0x30, 0xe9, 0x06,
+ 0xc3, 0x56, 0xf0, 0x96, 0x46, 0x93, 0xed, 0x42, 0x71, 0x22, 0x22, 0x3e, 0xb9, 0x8b, 0x38, 0xd1,
+ 0xd8, 0xfc, 0xd7, 0x0a, 0x6c, 0x65, 0x48, 0x7a, 0xa6, 0x0e, 0x14, 0x3d, 0xff, 0xc6, 0xe1, 0x1e,
+ 0x57, 0x33, 0x6d, 0xd6, 0xf6, 0x2b, 0xf1, 0x9e, 0x54, 0xe6, 0x72, 0x2a, 0x75, 0xff, 0x66, 0x18,
+ 0x0c, 0x43, 0xce, 0x3c, 0x3e, 0xbc, 0x25, 0x92, 0x8b, 0x63, 0x15, 0xd4, 0x86, 0x12, 0x1d, 0x13,
+ 0xa6, 0x24, 0xf3, 0x52, 0xb2, 0xfa, 0xa0, 0x64, 0x7b, 0x4c, 0x84, 0x1a, 0x0d, 0xbc, 0x91, 0xd2,
+ 0x9b, 0x6a, 0x08, 0x41, 0x55, 0x88, 0x56, 0xe0, 0xef, 0x2c, 0x7f, 0xa0, 0xe0, 0x91, 0x64, 0x4c,
+ 0x94, 0x68, 0x2b, 0xf0, 0xf1, 0x54, 0xc3, 0xfc, 0x47, 0x0e, 0x8c, 0x6c, 0x1e, 0x01, 0x14, 0xba,
+ 0xf6, 0x59, 0xfb, 0x8d, 0x6d, 0x2c, 0x21, 0x04, 0x9b, 0xae, 0x65, 0xf7, 0x1a, 0x75, 0xc7, 0xea,
+ 0xb9, 0xbd, 0xe3, 0xe6, 0x8f, 0x46, 0x0e, 0x6d, 0x03, 0x3a, 0xed, 0xda, 0x4d, 0x6c, 0x35, 0x93,
+ 0xf1, 0x3c, 0xda, 0x81, 0xa7, 0x27, 0xad, 0x93, 0x7a, 0xa3, 0xe5, 0xf6, 0x2c, 0xf7, 0xd4, 0xc2,
+ 0xb6, 0xa5, 0x32, 0xcb, 0x82, 0x21, 0x54, 0x4e, 0xd2, 0xf1, 0x95, 0x8c, 0xfa, 0x69, 0xf3, 0x47,
+ 0x63, 0x75, 0x8e, 0xba, 0x88, 0x17, 0xe6, 0xaa, 0x8b, 0xcc, 0x9a, 0x79, 0x02, 0x4f, 0xe6, 0xd4,
+ 0x41, 0x08, 0xd5, 0x9b, 0x17, 0x8e, 0x5b, 0x77, 0xad, 0x5e, 0xd7, 0x6e, 0x5a, 0xc7, 0x2d, 0xdb,
+ 0x6a, 0x1a, 0x4b, 0xe2, 0xef, 0x9d, 0xb7, 0x8f, 0xce, 0xac, 0xa6, 0x91, 0x43, 0xeb, 0x50, 0xec,
+ 0xda, 0x7a, 0x94, 0x37, 0x8f, 0xc1, 0xc8, 0xee, 0x3e, 0xfa, 0x04, 0x9e, 0xb4, 0x3b, 0x16, 0x9e,
+ 0x95, 0x29, 0xc3, 0x9a, 0x65, 0xd7, 0x1b, 0xe7, 0x91, 0x4e, 0xb3, 0xe5, 0xa8, 0x51, 0xde, 0x7c,
+ 0x9f, 0x93, 0x67, 0xa0, 0x3d, 0xe2, 0x1d, 0xca, 0xf8, 0x11, 0x9d, 0x04, 0x9c, 0xb0, 0x10, 0x6d,
+ 0x43, 0x61, 0x4c, 0x19, 0xb7, 0xa9, 0x36, 0xa5, 0x1e, 0xa1, 0x06, 0x14, 0xc5, 0x2f, 0xf7, 0xdd,
+ 0x38, 0x72, 0xc9, 0x8b, 0x4c, 0x51, 0xd3, 0x42, 0x95, 0x8e, 0x46, 0xe3, 0x98, 0x67, 0x5a, 0x50,
+ 0x8c, 0xa2, 0xc8, 0x80, 0x75, 0xf1, 0xbb, 0xd7, 0xb5, 0xcf, 0x6c, 0x55, 0xc5, 0x2d, 0x78, 0x2c,
+ 0x23, 0xf1, 0xc6, 0xd9, 0x76, 0xcb, 0xc8, 0xc5, 0xc0, 0x4e, 0xdb, 0xee, 0xb5, 0xcf, 0x5d, 0x23,
+ 0x6f, 0xfe, 0x73, 0x19, 0x76, 0x67, 0x27, 0x8c, 0x8f, 0xc8, 0x0e, 0xac, 0xf1, 0xbb, 0xc6, 0x3b,
+ 0x4e, 0x42, 0xf9, 0x17, 0x56, 0x70, 0x34, 0x14, 0x19, 0xa6, 0x33, 0x79, 0x95, 0xd1, 0x43, 0xf4,
+ 0x19, 0x94, 0xf8, 0x5d, 0xc7, 0xeb, 0xff, 0x9e, 0xf0, 0x50, 0x7a, 0x76, 0x05, 0x4f, 0x03, 0x22,
+ 0xcb, 0xe2, 0xec, 0x8a, 0xca, 0xc6, 0x01, 0xf4, 0x02, 0x36, 0xf9, 0x9d, 0xc5, 0x18, 0x65, 0x11,
+ 0x64, 0x55, 0x42, 0x32, 0x51, 0x81, 0x63, 0x69, 0x5c, 0x41, 0xe1, 0xd8, 0x0c, 0x8e, 0xdf, 0x35,
+ 0xfa, 0x5e, 0xc8, 0x23, 0xdc, 0x5a, 0xa4, 0x97, 0x8c, 0x2a, 0xbd, 0x14, 0xae, 0x18, 0xe9, 0x65,
+ 0x71, 0xfc, 0xae, 0x9b, 0xc4, 0x95, 0x22, 0xbd, 0xee, 0x8c, 0x5e, 0x0a, 0x07, 0x91, 0x5e, 0x77,
+ 0x46, 0xef, 0x22, 0x89, 0x2b, 0x47, 0x7a, 0x17, 0x33, 0x7a, 0x29, 0xdc, 0x7a, 0xa4, 0x97, 0x8c,
+ 0x9a, 0xcd, 0xa8, 0x41, 0x76, 0x68, 0xd0, 0x1e, 0xf3, 0x61, 0xdf, 0x1b, 0x89, 0xd6, 0x80, 0xbe,
+ 0x86, 0x55, 0xd9, 0xb2, 0x65, 0x15, 0xcb, 0xb5, 0xed, 0x8a, 0x6a, 0xe8, 0x95, 0xa8, 0xa1, 0x57,
+ 0x2c, 0x91, 0xc5, 0x0a, 0x64, 0xfe, 0x39, 0x0f, 0x9f, 0xcd, 0x93, 0x89, 0x6d, 0xf1, 0x15, 0x18,
+ 0x63, 0xfa, 0x47, 0xc2, 0x8e, 0x09, 0xf1, 0x2f, 0xe9, 0x88, 0x7b, 0x03, 0xd5, 0x41, 0xf3, 0x78,
+ 0x26, 0x8e, 0x6a, 0xf0, 0x94, 0x91, 0x3e, 0x19, 0xde, 0x12, 0x5f, 0x4b, 0x75, 0x04, 0x44, 0xba,
+ 0x26, 0x8f, 0xe7, 0xe6, 0xd0, 0x2b, 0xd8, 0xbe, 0x21, 0x5e, 0x34, 0xf5, 0xb9, 0x37, 0x09, 0xfa,
+ 0xd7, 0x8a, 0xb5, 0x2c, 0x59, 0x0b, 0xb2, 0x62, 0x5d, 0x23, 0x2f, 0x24, 0xac, 0x31, 0xf4, 0xc2,
+ 0xa3, 0x09, 0x63, 0x24, 0xe0, 0xd2, 0x63, 0x79, 0x3c, 0x13, 0x17, 0x0f, 0x28, 0x4e, 0x6e, 0xe4,
+ 0xe9, 0x9f, 0x30, 0x22, 0x7d, 0x96, 0xc7, 0xc9, 0x90, 0xf9, 0xb7, 0x1c, 0x7c, 0xa1, 0xb6, 0xc1,
+ 0xe2, 0xd7, 0x84, 0x05, 0x84, 0x37, 0xd8, 0xd0, 0x1f, 0x10, 0x71, 0x52, 0x4e, 0x87, 0x21, 0xa7,
+ 0xec, 0x1d, 0xc2, 0x50, 0xf2, 0x87, 0x8c, 0xf4, 0x45, 0x07, 0x59, 0xf8, 0x10, 0x59, 0x48, 0xaf,
+ 0x34, 0x23, 0x2e, 0x9e, 0xca, 0x98, 0x87, 0x50, 0x8a, 0xe3, 0x68, 0x03, 0x4a, 0xc9, 0x26, 0x24,
+ 0xfa, 0x57, 0xc7, 0x71, 0xb1, 0x55, 0xbf, 0x30, 0x72, 0x68, 0x13, 0xa0, 0xd9, 0x7e, 0x63, 0xeb,
+ 0x71, 0xde, 0xfc, 0xcb, 0x2a, 0xbc, 0x7c, 0x60, 0xca, 0xb8, 0x86, 0xcf, 0x00, 0x7c, 0x46, 0xc7,
+ 0xd6, 0x2d, 0x09, 0x78, 0xa8, 0x1b, 0x54, 0x22, 0x22, 0x9a, 0x17, 0xed, 0x73, 0x61, 0xb5, 0xbc,
+ 0x6a, 0x5e, 0x6a, 0x24, 0x0e, 0xfe, 0x38, 0x71, 0xb8, 0x37, 0x70, 0x34, 0x14, 0xbb, 0x7f, 0xc5,
+ 0xa8, 0xe7, 0x27, 0x6d, 0xba, 0x22, 0x21, 0x33, 0x71, 0x81, 0xbd, 0x99, 0x8c, 0x44, 0x01, 0xa7,
+ 0xd8, 0x55, 0x85, 0xcd, 0xc6, 0xd1, 0xd7, 0xf0, 0xb8, 0xcf, 0xfa, 0xf2, 0x5c, 0x13, 0x3f, 0x79,
+ 0xde, 0x37, 0xf0, 0x6c, 0x42, 0x28, 0x4f, 0x02, 0x9f, 0xb0, 0x70, 0xf8, 0x27, 0x92, 0x3c, 0xf4,
+ 0x1b, 0x78, 0x26, 0x8e, 0xbe, 0x84, 0x47, 0xf4, 0x36, 0x0d, 0x2d, 0x4a, 0x68, 0x36, 0x2c, 0x90,
+ 0xfa, 0x6f, 0xbe, 0xda, 0xd7, 0xdb, 0x52, 0x52, 0xc8, 0x4c, 0x58, 0xf8, 0x3d, 0x0a, 0x1d, 0xb8,
+ 0xb4, 0x5a, 0xfb, 0x4e, 0xc3, 0x41, 0xc2, 0xe7, 0xe6, 0xd0, 0x3e, 0x6c, 0xe9, 0x78, 0xb5, 0x76,
+ 0xe8, 0xd2, 0xda, 0xc1, 0x41, 0x5b, 0x91, 0xca, 0x92, 0x34, 0x3f, 0x99, 0x60, 0xd5, 0x0e, 0x5e,
+ 0xb9, 0xf4, 0xa0, 0x5a, 0xd5, 0x53, 0xad, 0xa7, 0x58, 0xe9, 0xa4, 0x38, 0x5b, 0x3a, 0x71, 0x50,
+ 0xad, 0xb9, 0xb4, 0xfa, 0x4d, 0xed, 0x5b, 0x4d, 0xdb, 0x90, 0xb4, 0x05, 0x59, 0x74, 0x08, 0x9f,
+ 0x44, 0xcb, 0xf8, 0xa6, 0xb6, 0xef, 0xd2, 0xea, 0x41, 0xf5, 0x50, 0x13, 0x37, 0x25, 0x71, 0x51,
+ 0xda, 0xfc, 0x0d, 0x18, 0xca, 0x94, 0xc7, 0xa4, 0x1f, 0x9d, 0x9b, 0x8f, 0x6b, 0x48, 0xff, 0xce,
+ 0xc1, 0x4e, 0x56, 0x22, 0x36, 0xf2, 0x0b, 0xd8, 0xec, 0x53, 0x26, 0xce, 0x0b, 0xf1, 0xa7, 0x8f,
+ 0xaa, 0x0d, 0x9c, 0x89, 0xa2, 0x0a, 0xa0, 0x38, 0x72, 0x44, 0x7d, 0xf2, 0x86, 0x32, 0x3f, 0x32,
+ 0xf7, 0x9c, 0x8c, 0x38, 0x20, 0x6f, 0x49, 0xdf, 0x21, 0x7d, 0x1a, 0xf8, 0x91, 0xd7, 0x13, 0x11,
+ 0xd9, 0xbb, 0x29, 0xf7, 0x46, 0x53, 0x2d, 0x65, 0xf6, 0x4c, 0x54, 0x6c, 0xf8, 0x24, 0xd0, 0xfa,
+ 0xde, 0xd5, 0x88, 0x4c, 0xf1, 0xca, 0xf0, 0x0b, 0xb2, 0xe6, 0xfb, 0x65, 0x78, 0x74, 0x42, 0xf8,
+ 0xa5, 0x37, 0x9a, 0xc4, 0xb7, 0xea, 0xef, 0x33, 0x97, 0xe3, 0x72, 0xed, 0xf3, 0x74, 0xb7, 0xc9,
+ 0x5c, 0xc3, 0x4f, 0x97, 0xa6, 0xb7, 0x67, 0xf4, 0x3d, 0xac, 0x4d, 0xd4, 0x55, 0x51, 0xfe, 0xeb,
+ 0x72, 0xed, 0x8b, 0xc5, 0x57, 0xc9, 0x88, 0x1d, 0x31, 0x50, 0x1d, 0xca, 0x54, 0x5d, 0x12, 0xa4,
+ 0xc0, 0xf2, 0xbc, 0xc9, 0x33, 0xb7, 0x88, 0xd3, 0x25, 0x9c, 0xe4, 0xa0, 0x16, 0x6c, 0xd2, 0x60,
+ 0x92, 0x78, 0x9e, 0xc8, 0x0d, 0x9b, 0xb7, 0x8c, 0xf4, 0x63, 0xe7, 0x74, 0x09, 0x67, 0x88, 0x08,
+ 0xc3, 0x06, 0xe1, 0xd7, 0xd3, 0xe6, 0x26, 0xb7, 0xb2, 0x5c, 0xfb, 0xea, 0xc3, 0x5b, 0xef, 0xe9,
+ 0x12, 0x4e, 0x4b, 0xa0, 0x5f, 0xcb, 0x7a, 0xeb, 0xb4, 0xec, 0x2f, 0xe5, 0xda, 0xa7, 0x33, 0x82,
+ 0x53, 0x03, 0x9e, 0x2e, 0xe1, 0x04, 0xa1, 0x51, 0x82, 0x35, 0xa6, 0xb6, 0xcd, 0x7c, 0x5f, 0x90,
+ 0x8e, 0xd7, 0x95, 0xd3, 0x36, 0xfd, 0x15, 0x14, 0x42, 0xee, 0xf1, 0x49, 0xa8, 0x1f, 0x13, 0x66,
+ 0x5a, 0x3a, 0x05, 0xae, 0x38, 0x12, 0x89, 0x35, 0x03, 0x59, 0x50, 0x22, 0x8c, 0x61, 0xe2, 0x85,
+ 0x34, 0xd0, 0x37, 0xc6, 0x97, 0xf7, 0xd1, 0x65, 0x4b, 0x54, 0x70, 0x3c, 0x65, 0xa2, 0x1f, 0x12,
+ 0xee, 0x51, 0x05, 0x7c, 0xb6, 0xc8, 0x3d, 0x4a, 0x28, 0x65, 0x9f, 0x1f, 0xa6, 0xf6, 0x51, 0x75,
+ 0x7b, 0xfe, 0xd0, 0x9b, 0x48, 0xd2, 0x3f, 0x67, 0xb0, 0x3e, 0x56, 0xde, 0xe0, 0x01, 0x61, 0xa1,
+ 0x2e, 0xd8, 0x2f, 0xee, 0x35, 0x50, 0x42, 0x27, 0x45, 0x46, 0xaf, 0x67, 0x9c, 0xa4, 0xca, 0xf5,
+ 0xf2, 0x01, 0x27, 0x25, 0x04, 0xb3, 0x8e, 0xba, 0x82, 0xc7, 0x29, 0x3b, 0x48, 0xd5, 0x35, 0xa9,
+ 0x5a, 0xfb, 0x70, 0x57, 0x25, 0x26, 0x98, 0x95, 0x43, 0x56, 0xca, 0x61, 0x45, 0x29, 0xfe, 0xf3,
+ 0x7b, 0x1c, 0x96, 0x50, 0x4b, 0x10, 0xcd, 0x2a, 0x14, 0x94, 0x3f, 0xd0, 0x53, 0x30, 0xc4, 0x7b,
+ 0x4a, 0xd7, 0x49, 0xbd, 0xa8, 0x14, 0x20, 0xdf, 0x3e, 0x33, 0x72, 0xa8, 0x04, 0xab, 0x16, 0xc6,
+ 0x6d, 0x6c, 0xe4, 0xcd, 0xbf, 0xe6, 0xa0, 0x9c, 0x30, 0x85, 0x20, 0x62, 0xab, 0xee, 0xb4, 0xed,
+ 0x14, 0xf1, 0x11, 0x94, 0xbb, 0xb6, 0xd3, 0xed, 0x74, 0xda, 0xd8, 0x95, 0x6f, 0x39, 0x5b, 0xf0,
+ 0xb8, 0x65, 0x5f, 0xd6, 0xcf, 0x5b, 0xcd, 0x5e, 0xd3, 0xba, 0x6c, 0x1d, 0x59, 0xbd, 0x56, 0xd3,
+ 0xc8, 0x27, 0xc3, 0x02, 0xda, 0x73, 0x7f, 0xdb, 0xb1, 0x8c, 0x65, 0xf1, 0x82, 0xe4, 0xb6, 0x2e,
+ 0xac, 0x76, 0xd7, 0x35, 0x56, 0xc4, 0x0c, 0x11, 0x06, 0x5b, 0xaf, 0x15, 0x64, 0x55, 0xbc, 0xff,
+ 0xb5, 0x6c, 0xd7, 0xc2, 0x76, 0xfd, 0xbc, 0xa7, 0xd6, 0x56, 0x68, 0x00, 0x14, 0x99, 0xfe, 0xa3,
+ 0xe6, 0x25, 0x3c, 0x72, 0x32, 0x2d, 0xef, 0x10, 0xd6, 0xbd, 0x91, 0xc7, 0x6e, 0xf4, 0x17, 0x09,
+ 0xdd, 0xf6, 0x9e, 0x54, 0xf4, 0x07, 0x8a, 0xba, 0xc8, 0xa9, 0x37, 0x5a, 0xd1, 0x6f, 0xbc, 0xe9,
+ 0x30, 0x79, 0x22, 0xff, 0x93, 0x03, 0xc3, 0xf9, 0x98, 0x13, 0xe9, 0xfc, 0x6f, 0x27, 0xd2, 0xf9,
+ 0xb0, 0x13, 0xf9, 0x53, 0x4a, 0xb9, 0xff, 0x53, 0x2a, 0x69, 0x0e, 0x61, 0xcb, 0x19, 0x06, 0x83,
+ 0x11, 0xc9, 0x3e, 0x51, 0x76, 0xa1, 0xc8, 0x3d, 0x36, 0x20, 0x3c, 0xfe, 0x48, 0x13, 0x8f, 0xd1,
+ 0x7e, 0xbc, 0x81, 0xfa, 0x81, 0xb1, 0x3b, 0xb7, 0xe9, 0x48, 0x04, 0x8e, 0xf7, 0xfa, 0x35, 0x6c,
+ 0x67, 0xa7, 0xd2, 0x1b, 0xfe, 0xdd, 0xb4, 0xd2, 0xba, 0x8c, 0x9f, 0xde, 0xd3, 0xc5, 0xf0, 0xd4,
+ 0x16, 0xf1, 0xea, 0x9d, 0xff, 0xd7, 0xea, 0x9d, 0x07, 0x57, 0xef, 0x7c, 0xdc, 0xea, 0x9d, 0x85,
+ 0xab, 0xaf, 0xfd, 0x3d, 0x07, 0x25, 0x2b, 0x02, 0x22, 0x0c, 0xe5, 0x13, 0xc2, 0xad, 0x3b, 0x05,
+ 0x47, 0xc9, 0x26, 0x3a, 0xb7, 0x42, 0xbb, 0x3f, 0xbb, 0x07, 0xa1, 0x97, 0x86, 0xa1, 0xec, 0xdc,
+ 0xab, 0xe9, 0x3c, 0xa8, 0x99, 0x5d, 0x7f, 0x03, 0xc3, 0xe7, 0x94, 0x0d, 0x2a, 0x74, 0x4c, 0xc4,
+ 0xf5, 0xc4, 0xaf, 0xa8, 0x4f, 0x84, 0x53, 0xde, 0xef, 0xaa, 0x83, 0x21, 0xbf, 0x9e, 0x5c, 0x55,
+ 0xfa, 0xf4, 0x66, 0x2f, 0x42, 0xed, 0x29, 0xd4, 0x2f, 0xf5, 0x87, 0xc4, 0xdb, 0xfd, 0xbd, 0x01,
+ 0x9d, 0x7e, 0x79, 0xec, 0x2c, 0x5d, 0x15, 0x64, 0xe6, 0xdb, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff,
+ 0x04, 0xc2, 0xa6, 0x22, 0x9d, 0x14, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
diff --git a/vendor/github.com/opencord/voltha-protos/v4/go/voltha/core.pb.go b/vendor/github.com/opencord/voltha-protos/v4/go/voltha/core.pb.go
index 4c92095..64d42d0 100644
--- a/vendor/github.com/opencord/voltha-protos/v4/go/voltha/core.pb.go
+++ b/vendor/github.com/opencord/voltha-protos/v4/go/voltha/core.pb.go
@@ -37,6 +37,8 @@
DeviceTransientState_DELETING_POST_ADAPTER_RESPONSE DeviceTransientState_Types = 4
// State to represent that the device deletion is failed
DeviceTransientState_DELETE_FAILED DeviceTransientState_Types = 5
+ // State to represent that reconcile is in progress
+ DeviceTransientState_RECONCILE_IN_PROGRESS DeviceTransientState_Types = 6
)
var DeviceTransientState_Types_name = map[int32]string{
@@ -46,6 +48,7 @@
3: "DELETING_FROM_ADAPTER",
4: "DELETING_POST_ADAPTER_RESPONSE",
5: "DELETE_FAILED",
+ 6: "RECONCILE_IN_PROGRESS",
}
var DeviceTransientState_Types_value = map[string]int32{
@@ -55,6 +58,7 @@
"DELETING_FROM_ADAPTER": 3,
"DELETING_POST_ADAPTER_RESPONSE": 4,
"DELETE_FAILED": 5,
+ "RECONCILE_IN_PROGRESS": 6,
}
func (x DeviceTransientState_Types) String() string {
@@ -112,22 +116,23 @@
func init() { proto.RegisterFile("voltha_protos/core.proto", fileDescriptor_39634f15fb8a505e) }
var fileDescriptor_39634f15fb8a505e = []byte{
- // 264 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x4d, 0x4b, 0xc4, 0x30,
- 0x10, 0x86, 0xad, 0xfb, 0xa1, 0x0c, 0x58, 0x63, 0x54, 0x58, 0x2f, 0x22, 0x3d, 0x79, 0x31, 0x05,
- 0xf5, 0x0f, 0x54, 0x3b, 0x95, 0xc5, 0xb5, 0x2d, 0x6d, 0x2e, 0x7a, 0x09, 0xdd, 0x1a, 0xba, 0x05,
- 0x6d, 0x4a, 0x1a, 0x0b, 0xde, 0xfc, 0xb5, 0xfe, 0x0e, 0xb1, 0x1f, 0x82, 0xb0, 0xb7, 0x99, 0xe7,
- 0x99, 0xf7, 0x30, 0x2f, 0x2c, 0x5a, 0xf5, 0x66, 0x36, 0x99, 0xa8, 0xb5, 0x32, 0xaa, 0x71, 0x73,
- 0xa5, 0x25, 0xeb, 0x66, 0x3a, 0xef, 0x8d, 0xf3, 0x6d, 0xc1, 0x89, 0x2f, 0xdb, 0x32, 0x97, 0x5c,
- 0x67, 0x55, 0x53, 0xca, 0xca, 0xa4, 0x26, 0x33, 0x92, 0x3e, 0xc2, 0xa1, 0x19, 0x89, 0x68, 0x7e,
- 0xd1, 0xc2, 0xba, 0xb0, 0x2e, 0xed, 0x6b, 0x87, 0xf5, 0x51, 0xb6, 0x2d, 0xc6, 0xf8, 0x67, 0x2d,
- 0x9b, 0xc4, 0x36, 0xff, 0xa8, 0xf3, 0x65, 0xc1, 0xac, 0x33, 0x74, 0x1f, 0xa6, 0x61, 0x14, 0x22,
- 0xd9, 0xa1, 0x7b, 0x30, 0xf1, 0xc2, 0x67, 0x62, 0x51, 0x0a, 0x76, 0x10, 0x25, 0xf7, 0x28, 0x7c,
- 0x5c, 0x21, 0x5f, 0x86, 0x0f, 0x64, 0x97, 0x9e, 0xc1, 0xe9, 0xb8, 0x89, 0x20, 0x89, 0x9e, 0x84,
- 0xe7, 0x7b, 0x31, 0xc7, 0x84, 0x4c, 0xa8, 0x03, 0xe7, 0x7f, 0x2a, 0x8e, 0x52, 0x3e, 0x2a, 0x91,
- 0x60, 0x1a, 0x47, 0x61, 0x8a, 0x64, 0x4a, 0x8f, 0xe0, 0xa0, 0xbb, 0x41, 0x11, 0x78, 0xcb, 0x15,
- 0xfa, 0x64, 0x76, 0x87, 0x70, 0xac, 0x74, 0xc1, 0x54, 0x2d, 0xab, 0x5c, 0xe9, 0xd7, 0xe1, 0x89,
- 0x17, 0x56, 0x94, 0x66, 0xf3, 0xb1, 0x66, 0xb9, 0x7a, 0x77, 0x47, 0xe7, 0xf6, 0xee, 0x6a, 0x68,
- 0xad, 0xbd, 0x75, 0x0b, 0x35, 0xb0, 0xf5, 0xbc, 0x83, 0x37, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff,
- 0xe3, 0x06, 0xbc, 0xa1, 0x5a, 0x01, 0x00, 0x00,
+ // 284 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x4d, 0x4b, 0xf4, 0x30,
+ 0x10, 0xc7, 0x9f, 0xee, 0xdb, 0x23, 0x01, 0xd7, 0x18, 0x15, 0xd6, 0x8b, 0x48, 0x4f, 0x5e, 0x4c,
+ 0x41, 0xfd, 0x02, 0x75, 0x3b, 0xbb, 0x14, 0xd7, 0xa4, 0x24, 0xbd, 0xe8, 0x25, 0x74, 0x6b, 0xe8,
+ 0x16, 0xb4, 0x29, 0x6d, 0x2c, 0x78, 0xf4, 0x73, 0xf8, 0x65, 0x65, 0xfb, 0x22, 0x08, 0xde, 0x66,
+ 0x7e, 0xbf, 0xf9, 0x0f, 0xcc, 0xa0, 0x45, 0x63, 0x5e, 0xed, 0x2e, 0x51, 0x65, 0x65, 0xac, 0xa9,
+ 0xbd, 0xd4, 0x54, 0x9a, 0xb6, 0x35, 0x99, 0x75, 0xc6, 0xfd, 0x1c, 0xa1, 0xd3, 0x40, 0x37, 0x79,
+ 0xaa, 0xe3, 0x2a, 0x29, 0xea, 0x5c, 0x17, 0x56, 0xda, 0xc4, 0x6a, 0xf2, 0x80, 0x8e, 0xec, 0x40,
+ 0x54, 0xbd, 0x47, 0x0b, 0xe7, 0xd2, 0xb9, 0x9a, 0xdf, 0xb8, 0xb4, 0x8b, 0xd2, 0xbf, 0x62, 0x34,
+ 0xfe, 0x28, 0x75, 0x2d, 0xe6, 0xf6, 0x17, 0x75, 0xbf, 0x1c, 0x34, 0x6d, 0x0d, 0x39, 0x40, 0x13,
+ 0xc6, 0x19, 0xe0, 0x7f, 0xe4, 0x3f, 0x1a, 0xfb, 0xec, 0x09, 0x3b, 0x84, 0xa0, 0xf9, 0x8a, 0x8b,
+ 0x25, 0xa8, 0x00, 0x36, 0x10, 0x87, 0x6c, 0x8d, 0x47, 0xe4, 0x1c, 0x9d, 0x0d, 0x9d, 0x5a, 0x09,
+ 0xfe, 0xa8, 0xfc, 0xc0, 0x8f, 0x62, 0x10, 0x78, 0x4c, 0x5c, 0x74, 0xf1, 0xa3, 0x22, 0x2e, 0xe3,
+ 0x41, 0x29, 0x01, 0x32, 0xe2, 0x4c, 0x02, 0x9e, 0x90, 0x63, 0x74, 0xd8, 0xce, 0x80, 0x5a, 0xf9,
+ 0xe1, 0x06, 0x02, 0x3c, 0xdd, 0x6f, 0x14, 0xb0, 0xe4, 0x6c, 0x19, 0x6e, 0x40, 0x85, 0x4c, 0x45,
+ 0x82, 0xaf, 0x05, 0x48, 0x89, 0x67, 0xf7, 0x80, 0x4e, 0x4c, 0x95, 0x51, 0x53, 0xea, 0x22, 0x35,
+ 0xd5, 0x4b, 0x7f, 0xdf, 0x33, 0xcd, 0x72, 0xbb, 0x7b, 0xdf, 0xd2, 0xd4, 0xbc, 0x79, 0x83, 0xf3,
+ 0x3a, 0x77, 0xdd, 0x3f, 0xb4, 0xb9, 0xf3, 0x32, 0xd3, 0xb3, 0xed, 0xac, 0x85, 0xb7, 0xdf, 0x01,
+ 0x00, 0x00, 0xff, 0xff, 0x1a, 0x0c, 0x99, 0x87, 0x75, 0x01, 0x00, 0x00,
}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index a8fc3e8..e0360fb 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 v0.17.0
+# github.com/opencord/omci-lib-go v1.1.0
## explicit
github.com/opencord/omci-lib-go
github.com/opencord/omci-lib-go/generated
@@ -81,7 +81,7 @@
github.com/opencord/voltha-lib-go/v4/pkg/probe
github.com/opencord/voltha-lib-go/v4/pkg/techprofile
github.com/opencord/voltha-lib-go/v4/pkg/version
-# github.com/opencord/voltha-protos/v4 v4.1.1
+# github.com/opencord/voltha-protos/v4 v4.1.4
## explicit
github.com/opencord/voltha-protos/v4/go/common
github.com/opencord/voltha-protos/v4/go/ext/config