blob: edeab97ed0da938d0e6c35947a0b5f3917a612fa [file] [log] [blame]
Holger Hildebrandtfa074992020-03-27 15:42:06 +00001/*
2 * Copyright 2020-present Open Networking Foundation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000017//Package adaptercoreonu provides the utility for onu devices, flows and statistics
18package adaptercoreonu
Holger Hildebrandtfa074992020-03-27 15:42:06 +000019
20import (
21 "container/list"
22 "context"
23 "encoding/binary"
24 "encoding/hex"
Andrea Campanella6515c582020-10-05 11:25:00 +020025 "fmt"
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000026 "strconv"
Holger Hildebrandtfa074992020-03-27 15:42:06 +000027 "sync"
mpagenko80622a52021-02-09 16:53:23 +000028 "time" //by now for testing
Holger Hildebrandtfa074992020-03-27 15:42:06 +000029
30 "github.com/google/gopacket"
31 // TODO!!! Some references could be resolved auto, but some need specific context ....
32 gp "github.com/google/gopacket"
33
34 "github.com/opencord/omci-lib-go"
35 me "github.com/opencord/omci-lib-go/generated"
dbainbri4d3a0dc2020-12-02 00:33:42 +000036 "github.com/opencord/voltha-lib-go/v4/pkg/adapters/adapterif"
Holger Hildebrandtfa074992020-03-27 15:42:06 +000037
dbainbri4d3a0dc2020-12-02 00:33:42 +000038 //"github.com/opencord/voltha-lib-go/v4/pkg/kafka"
39 "github.com/opencord/voltha-lib-go/v4/pkg/log"
amit.ghosh58b704b2021-06-18 03:45:52 +020040 "github.com/opencord/voltha-protos/v4/go/common"
dbainbri4d3a0dc2020-12-02 00:33:42 +000041 ic "github.com/opencord/voltha-protos/v4/go/inter_container"
42 //"github.com/opencord/voltha-protos/v4/go/openflow_13"
43 //"github.com/opencord/voltha-protos/v4/go/voltha"
Holger Hildebrandtfa074992020-03-27 15:42:06 +000044)
45
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000046// ### OMCI related definitions - retrieved from Python adapter code/trace ####
Himani Chawla6d2ae152020-09-02 13:11:20 +053047
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000048const maxGemPayloadSize = uint16(48)
49const connectivityModeValue = uint8(5)
Himani Chawla4d908332020-08-31 12:30:20 +053050
51//const defaultTPID = uint16(0x8100)
52//const broadComDefaultVID = uint16(4091)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000053
mpagenko8b07c1b2020-11-26 10:36:31 +000054const unusedTcontAllocID = uint16(0xFFFF) //common unused AllocId for G.984 and G.987 systems
55
mpagenkoc8bba412021-01-15 15:38:44 +000056const cOmciBaseMessageTrailerLen = 40
57
58// tOmciReceiveError - enum type for detected problems/errors in the received OMCI message (format)
59type tOmciReceiveError uint8
60
61const (
62 // cOmciMessageReceiveNoError - default start state
63 cOmciMessageReceiveNoError tOmciReceiveError = iota
64 // Error indication wrong trailer length within the message
65 cOmciMessageReceiveErrorTrailerLen
66 // Error indication missing trailer within the message
67 cOmciMessageReceiveErrorMissTrailer
68)
69
Holger Hildebrandt366ef192021-05-05 11:07:44 +000070const cDefaultRetries = 2
71
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000072// ### OMCI related definitions - end
73
Himani Chawla6d2ae152020-09-02 13:11:20 +053074//callbackPairEntry to be used for OMCI send/receive correlation
75type callbackPairEntry struct {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000076 cbRespChannel chan Message
dbainbri4d3a0dc2020-12-02 00:33:42 +000077 cbFunction func(context.Context, *omci.OMCI, *gp.Packet, chan Message) error
mpagenko80622a52021-02-09 16:53:23 +000078 framePrint bool //true for printing
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000079}
80
Himani Chawla6d2ae152020-09-02 13:11:20 +053081//callbackPair to be used for ReceiveCallback init
82type callbackPair struct {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000083 cbKey uint16
Himani Chawla6d2ae152020-09-02 13:11:20 +053084 cbEntry callbackPairEntry
Holger Hildebrandtfa074992020-03-27 15:42:06 +000085}
86
87type omciTransferStructure struct {
mpagenko80622a52021-02-09 16:53:23 +000088 txFrame []byte
89 timeout int
Holger Hildebrandt366ef192021-05-05 11:07:44 +000090 retries int
mpagenko80622a52021-02-09 16:53:23 +000091 highPrio bool
92 withFramePrint bool
Holger Hildebrandt366ef192021-05-05 11:07:44 +000093 cbPair callbackPair
94 chSuccess chan bool
Holger Hildebrandtfa074992020-03-27 15:42:06 +000095}
96
Himani Chawla6d2ae152020-09-02 13:11:20 +053097//omciCC structure holds information needed for OMCI communication (to/from OLT Adapter)
98type omciCC struct {
Holger Hildebrandtfa074992020-03-27 15:42:06 +000099 enabled bool
100 pOnuDeviceEntry *OnuDeviceEntry
101 deviceID string
Himani Chawla6d2ae152020-09-02 13:11:20 +0530102 pBaseDeviceHandler *deviceHandler
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000103 coreProxy adapterif.CoreProxy
104 adapterProxy adapterif.AdapterProxy
105 supportExtMsg bool
mpagenkoc8bba412021-01-15 15:38:44 +0000106 rxOmciFrameError tOmciReceiveError
107
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000108 txFrames, txOnuFrames uint32
109 rxFrames, rxOnuFrames, rxOnuDiscards uint32
110
111 // OMCI params
112 mutexTid sync.Mutex
113 tid uint16
114 mutexHpTid sync.Mutex
115 hpTid uint16
116 uploadSequNo uint16
117 uploadNoOfCmds uint16
118
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000119 mutexTxQueue sync.Mutex
120 txQueue *list.List
121 mutexRxSchedMap sync.Mutex
122 rxSchedulerMap map[uint16]callbackPairEntry
123 mutexMonReq sync.RWMutex
124 monitoredRequests map[uint16]omciTransferStructure
125 mutexPLastTxMeInstance sync.RWMutex
126 pLastTxMeInstance *me.ManagedEntity
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000127}
128
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +0000129var responsesWithMibDataSync = []omci.MessageType{
130 omci.CreateResponseType,
131 omci.DeleteResponseType,
132 omci.SetResponseType,
133 omci.StartSoftwareDownloadResponseType,
134 omci.EndSoftwareDownloadResponseType,
135 omci.ActivateSoftwareResponseType,
136 omci.CommitSoftwareResponseType,
137}
138
Himani Chawla6d2ae152020-09-02 13:11:20 +0530139//newOmciCC constructor returns a new instance of a OmciCC
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000140//mib_db (as well as not inluded alarm_db not really used in this code? VERIFY!!)
Himani Chawla6d2ae152020-09-02 13:11:20 +0530141func newOmciCC(ctx context.Context, onuDeviceEntry *OnuDeviceEntry,
142 deviceID string, deviceHandler *deviceHandler,
143 coreProxy adapterif.CoreProxy, adapterProxy adapterif.AdapterProxy) *omciCC {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000144 logger.Debugw(ctx, "init-omciCC", log.Fields{"device-id": deviceID})
Himani Chawla6d2ae152020-09-02 13:11:20 +0530145 var omciCC omciCC
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000146 omciCC.enabled = false
Himani Chawla4d908332020-08-31 12:30:20 +0530147 omciCC.pOnuDeviceEntry = onuDeviceEntry
148 omciCC.deviceID = deviceID
149 omciCC.pBaseDeviceHandler = deviceHandler
150 omciCC.coreProxy = coreProxy
151 omciCC.adapterProxy = adapterProxy
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000152 omciCC.supportExtMsg = false
mpagenkoc8bba412021-01-15 15:38:44 +0000153 omciCC.rxOmciFrameError = cOmciMessageReceiveNoError
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000154 omciCC.txFrames = 0
155 omciCC.txOnuFrames = 0
156 omciCC.rxFrames = 0
157 omciCC.rxOnuFrames = 0
158 omciCC.rxOnuDiscards = 0
159 omciCC.tid = 0x1
160 omciCC.hpTid = 0x8000
161 omciCC.uploadSequNo = 0
162 omciCC.uploadNoOfCmds = 0
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000163 omciCC.txQueue = list.New()
Himani Chawla6d2ae152020-09-02 13:11:20 +0530164 omciCC.rxSchedulerMap = make(map[uint16]callbackPairEntry)
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000165 omciCC.monitoredRequests = make(map[uint16]omciTransferStructure)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000166
167 return &omciCC
168}
169
mpagenko900ee4b2020-10-12 11:56:34 +0000170//stop stops/resets the omciCC
171func (oo *omciCC) stop(ctx context.Context) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000172 logger.Debugw(ctx, "omciCC-stopping", log.Fields{"device-id": oo.deviceID})
mpagenko900ee4b2020-10-12 11:56:34 +0000173 //reseting all internal data, which might also be helpful for discarding any lingering tx/rx requests
mpagenko8cd1bf72021-06-22 10:11:19 +0000174 oo.CancelRequestMonitoring(ctx)
mpagenko900ee4b2020-10-12 11:56:34 +0000175 oo.mutexTxQueue.Lock()
176 oo.txQueue.Init() // clear the tx queue
177 oo.mutexTxQueue.Unlock()
178 oo.mutexRxSchedMap.Lock()
179 for k := range oo.rxSchedulerMap {
180 delete(oo.rxSchedulerMap, k) //clear the scheduler map
181 }
182 oo.mutexRxSchedMap.Unlock()
183 oo.mutexHpTid.Lock()
184 oo.hpTid = 0x8000 //reset the high prio transactionId
185 oo.mutexHpTid.Unlock()
186 oo.mutexTid.Lock()
187 oo.tid = 1 //reset the low prio transactionId
188 oo.mutexTid.Unlock()
189 //reset control values
190 oo.uploadSequNo = 0
191 oo.uploadNoOfCmds = 0
mpagenkoc8bba412021-01-15 15:38:44 +0000192 oo.rxOmciFrameError = cOmciMessageReceiveNoError
mpagenko900ee4b2020-10-12 11:56:34 +0000193 //reset the stats counter - which might be topic of discussion ...
194 oo.txFrames = 0
195 oo.txOnuFrames = 0
196 oo.rxFrames = 0
197 oo.rxOnuFrames = 0
198 oo.rxOnuDiscards = 0
199
200 return nil
201}
202
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000203// Rx handler for omci messages
Himani Chawlaac1f5ad2021-02-04 21:21:54 +0530204func (oo *omciCC) receiveOnuMessage(ctx context.Context, omciMsg *omci.OMCI, packet *gp.Packet) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000205 logger.Debugw(ctx, "rx-onu-autonomous-message", log.Fields{"omciMsgType": omciMsg.MessageType,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000206 "payload": hex.EncodeToString(omciMsg.Payload)})
Himani Chawlaac1f5ad2021-02-04 21:21:54 +0530207 switch omciMsg.MessageType {
208 case omci.AlarmNotificationType:
209 data := OmciMessage{
210 OmciMsg: omciMsg,
211 OmciPacket: packet,
212 }
213 go oo.pBaseDeviceHandler.pAlarmMgr.handleOmciAlarmNotificationMessage(ctx, data)
214 return nil
215 default:
216 return fmt.Errorf("receiveOnuMessageType %s unimplemented", omciMsg.MessageType.String())
217 }
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000218 /*
219 msgType = rxFrame.fields["message_type"] //assumed OmciOperationsValue
220 rxOnuFrames++
221
222 switch msgType {
223 case AlarmNotification:
224 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000225 logger.Info("Unhandled: received-onu-alarm-message")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000226 // python code was:
227 //if msg_type == EntityOperations.AlarmNotification.value:
228 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.Alarm_Notification)
229 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
230 //
231 return errors.New("RxAlarmNotification unimplemented")
232 }
233 case AttributeValueChange:
234 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000235 logger.Info("Unhandled: received-attribute-value-change")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000236 // python code was:
237 //elif msg_type == EntityOperations.AttributeValueChange.value:
238 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.AVC_Notification)
239 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
240 //
241 return errors.New("RxAttributeValueChange unimplemented")
242 }
243 case TestResult:
244 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000245 logger.Info("Unhandled: received-test-result")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000246 // python code was:
247 //elif msg_type == EntityOperations.TestResult.value:
248 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.Test_Result)
249 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
250 //
251 return errors.New("RxTestResult unimplemented")
252 }
253 default:
254 {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000255 logger.Errorw(ctx,"rx-onu-unsupported-autonomous-message", log.Fields{"msgType": msgType})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000256 rxOnuDiscards++
257 return errors.New("RxOnuMsgType unimplemented")
258 }
259 }
260 */
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000261}
262
mpagenko80622a52021-02-09 16:53:23 +0000263func (oo *omciCC) printRxMessage(ctx context.Context, rxMsg []byte) {
264 //assuming omci message content is hex coded!
265 // with restricted output of 16bytes would be ...rxMsg[:16]
266 logger.Debugw(ctx, "omci-message-received:", log.Fields{
267 "RxOmciMessage": hex.EncodeToString(rxMsg),
268 "device-id": oo.deviceID})
269}
270
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000271// Rx handler for onu messages
272// e.g. would call ReceiveOnuMessage() in case of TID=0 or Action=test ...
Himani Chawla6d2ae152020-09-02 13:11:20 +0530273func (oo *omciCC) receiveMessage(ctx context.Context, rxMsg []byte) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000274 //logger.Debugw(ctx,"cc-receive-omci-message", log.Fields{"RxOmciMessage-x2s": hex.EncodeToString(rxMsg)})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000275 if len(rxMsg) >= 44 { // then it should normally include the BaseFormat trailer Len
276 // NOTE: autocorrection only valid for OmciBaseFormat, which is not specifically verified here!!!
mpagenkoc8bba412021-01-15 15:38:44 +0000277 // (an extendedFormat message could be destroyed this way!)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000278 trailerLenData := rxMsg[42:44]
279 trailerLen := binary.BigEndian.Uint16(trailerLenData)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000280 //logger.Debugw(ctx,"omci-received-trailer-len", log.Fields{"Length": trailerLen})
mpagenkoc8bba412021-01-15 15:38:44 +0000281 if trailerLen != cOmciBaseMessageTrailerLen { // invalid base Format entry -> autocorrect
282 binary.BigEndian.PutUint16(rxMsg[42:44], cOmciBaseMessageTrailerLen)
283 if oo.rxOmciFrameError != cOmciMessageReceiveErrorTrailerLen {
284 //do just one error log, expectation is: if seen once it should appear regularly - avoid to many log entries
285 logger.Errorw(ctx, "wrong omci-message trailer length: trailer len auto-corrected",
286 log.Fields{"trailer-length": trailerLen, "device-id": oo.deviceID})
287 oo.rxOmciFrameError = cOmciMessageReceiveErrorTrailerLen
288 }
289 }
290 } else if len(rxMsg) >= cOmciBaseMessageTrailerLen { // workaround for Adtran OLT Sim, which currently does not send trailer bytes at all!
291 // NOTE: autocorrection only valid for OmciBaseFormat, which is not specifically verified here!!!
292 // (an extendedFormat message could be destroyed this way!)
293 // extend/overwrite with trailer
294 trailer := make([]byte, 8)
295 binary.BigEndian.PutUint16(trailer[2:], cOmciBaseMessageTrailerLen) //set the defined baseline length
296 rxMsg = append(rxMsg[:cOmciBaseMessageTrailerLen], trailer...)
297 if oo.rxOmciFrameError != cOmciMessageReceiveErrorMissTrailer {
298 //do just one error log, expectation is: if seen once it should appear regularly - avoid to many log entries
299 logger.Errorw(ctx, "omci-message to short to include trailer len: trailer auto-corrected (added)",
300 log.Fields{"message-length": len(rxMsg), "device-id": oo.deviceID})
301 oo.rxOmciFrameError = cOmciMessageReceiveErrorMissTrailer
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000302 }
303 } else {
mpagenkoc8bba412021-01-15 15:38:44 +0000304 logger.Errorw(ctx, "received omci-message too small for OmciBaseFormat - abort",
305 log.Fields{"Length": len(rxMsg), "device-id": oo.deviceID})
mpagenko80622a52021-02-09 16:53:23 +0000306 oo.printRxMessage(ctx, rxMsg)
Andrea Campanella6515c582020-10-05 11:25:00 +0200307 return fmt.Errorf("rxOmciMessage too small for BaseFormat %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000308 }
309
310 packet := gopacket.NewPacket(rxMsg, omci.LayerTypeOMCI, gopacket.NoCopy)
311 if packet == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000312 logger.Errorw(ctx, "omci-message could not be decoded", log.Fields{"device-id": oo.deviceID})
mpagenko80622a52021-02-09 16:53:23 +0000313 oo.printRxMessage(ctx, rxMsg)
Andrea Campanella6515c582020-10-05 11:25:00 +0200314 return fmt.Errorf("could not decode rxMsg as OMCI %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000315 }
316 omciLayer := packet.Layer(omci.LayerTypeOMCI)
317 if omciLayer == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000318 logger.Errorw(ctx, "omci-message could not decode omci layer", log.Fields{"device-id": oo.deviceID})
mpagenko80622a52021-02-09 16:53:23 +0000319 oo.printRxMessage(ctx, rxMsg)
Andrea Campanella6515c582020-10-05 11:25:00 +0200320 return fmt.Errorf("could not decode omci layer %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000321 }
322 omciMsg, ok := omciLayer.(*omci.OMCI)
323 if !ok {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000324 logger.Errorw(ctx, "omci-message could not assign omci layer", log.Fields{"device-id": oo.deviceID})
mpagenko80622a52021-02-09 16:53:23 +0000325 oo.printRxMessage(ctx, rxMsg)
Andrea Campanella6515c582020-10-05 11:25:00 +0200326 return fmt.Errorf("could not assign omci layer %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000327 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000328 logger.Debugw(ctx, "omci-message-decoded:", log.Fields{"omciMsgType": omciMsg.MessageType,
mpagenko3dbcdd22020-07-22 07:38:45 +0000329 "transCorrId": strconv.FormatInt(int64(omciMsg.TransactionID), 16), "DeviceIdent": omciMsg.DeviceIdentifier})
Girish Gowdra6afb56a2021-04-27 17:47:57 -0700330 // TestResult is asynchronous indication that carries the same TID as the TestResponse.
331 // We expect to find the TID in the oo.rxSchedulerMap
332 if byte(omciMsg.MessageType)&me.AK == 0 && omciMsg.MessageType != omci.TestResultType {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000333 // Not a response
mpagenko80622a52021-02-09 16:53:23 +0000334 oo.printRxMessage(ctx, rxMsg)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000335 logger.Debug(ctx, "RxMsg is no Omci Response Message")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000336 if omciMsg.TransactionID == 0 {
Himani Chawlaac1f5ad2021-02-04 21:21:54 +0530337 return oo.receiveOnuMessage(ctx, omciMsg, &packet)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000338 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000339 logger.Errorw(ctx, "Unexpected TransCorrId != 0 not accepted for autonomous messages",
Andrea Campanella6515c582020-10-05 11:25:00 +0200340 log.Fields{"msgType": omciMsg.MessageType, "payload": hex.EncodeToString(omciMsg.Payload),
mpagenko8b07c1b2020-11-26 10:36:31 +0000341 "device-id": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200342 return fmt.Errorf("autonomous Omci Message with TranSCorrId != 0 not acccepted %s", oo.deviceID)
Himani Chawla4d908332020-08-31 12:30:20 +0530343 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000344 //logger.Debug(ctx,"RxMsg is a Omci Response Message: try to schedule it to the requester")
Himani Chawla4d908332020-08-31 12:30:20 +0530345 oo.mutexRxSchedMap.Lock()
346 rxCallbackEntry, ok := oo.rxSchedulerMap[omciMsg.TransactionID]
347 if ok && rxCallbackEntry.cbFunction != nil {
mpagenko80622a52021-02-09 16:53:23 +0000348 if rxCallbackEntry.framePrint {
349 oo.printRxMessage(ctx, rxMsg)
350 }
Himani Chawla4d908332020-08-31 12:30:20 +0530351 //disadvantage of decoupling: error verification made difficult, but anyway the question is
352 // how to react on erroneous frame reception, maybe can simply be ignored
dbainbri4d3a0dc2020-12-02 00:33:42 +0000353 go rxCallbackEntry.cbFunction(ctx, omciMsg, &packet, rxCallbackEntry.cbRespChannel)
Holger Hildebrandt3124e302021-03-23 12:47:03 +0000354 if isSuccessfulResponseWithMibDataSync(omciMsg, &packet) {
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +0000355 oo.pOnuDeviceEntry.incrementMibDataSync(ctx)
356 }
mpagenkoc8bba412021-01-15 15:38:44 +0000357
Girish Gowdra6afb56a2021-04-27 17:47:57 -0700358 // If omciMsg.MessageType is omci.TestResponseType, we still expect the TestResult OMCI message,
359 // so do not clean up the TransactionID in that case.
360 if omciMsg.MessageType != omci.TestResponseType {
361 // having posted the response the request is regarded as 'done'
362 delete(oo.rxSchedulerMap, omciMsg.TransactionID)
363 }
Himani Chawla4d908332020-08-31 12:30:20 +0530364 oo.mutexRxSchedMap.Unlock()
mpagenko80622a52021-02-09 16:53:23 +0000365 return nil
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000366 }
mpagenko80622a52021-02-09 16:53:23 +0000367 oo.mutexRxSchedMap.Unlock()
368 logger.Errorw(ctx, "omci-message-response for not registered transCorrId", log.Fields{"device-id": oo.deviceID})
369 oo.printRxMessage(ctx, rxMsg)
370 return fmt.Errorf("could not find registered response handler tor transCorrId %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000371
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000372 /* py code was:
373 Receive and OMCI message from the proxy channel to the OLT.
374
375 Call this from your ONU Adapter on a new OMCI Rx on the proxy channel
376 :param msg: (str) OMCI binary message (used as input to Scapy packet decoder)
377 """
378 if not self.enabled:
379 return
380
381 try:
382 now = arrow.utcnow()
383 d = None
384
385 # NOTE: Since we may need to do an independent ME map on a per-ONU basis
386 # save the current value of the entity_id_to_class_map, then
387 # replace it with our custom one before decode, and then finally
388 # restore it later. Tried other ways but really made the code messy.
389 saved_me_map = omci_entities.entity_id_to_class_map
390 omci_entities.entity_id_to_class_map = self._me_map
391
392 try:
393 rx_frame = msg if isinstance(msg, OmciFrame) else OmciFrame(msg)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000394 self.logger.debug('recv-omci-msg', omci_msg=hexlify(msg))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000395 except KeyError as e:
396 # Unknown, Unsupported, or vendor-specific ME. Key is the unknown classID
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000397 self.logger.debug('frame-decode-key-error', omci_msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000398 rx_frame = self._decode_unknown_me(msg)
399 self._rx_unknown_me += 1
400
401 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000402 self.logger.exception('frame-decode', omci_msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000403 return
404
405 finally:
406 omci_entities.entity_id_to_class_map = saved_me_map # Always restore it.
407
408 rx_tid = rx_frame.fields['transaction_id']
409 msg_type = rx_frame.fields['message_type']
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000410 self.logger.debug('Received message for rx_tid', rx_tid = rx_tid, msg_type = msg_type)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000411 # Filter the Test Result frame and route through receive onu
412 # message method.
413 if rx_tid == 0 or msg_type == EntityOperations.TestResult.value:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000414 self.logger.debug('Receive ONU message', rx_tid=0)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000415 return self._receive_onu_message(rx_frame)
416
417 # Previously unreachable if this is the very first round-trip Rx or we
418 # have been running consecutive errors
419 if self._rx_frames == 0 or self._consecutive_errors != 0:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000420 self.logger.debug('Consecutive errors for rx', err = self._consecutive_errors)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000421 self.reactor.callLater(0, self._publish_connectivity_event, True)
422
423 self._rx_frames += 1
424 self._consecutive_errors = 0
425
426 try:
427 high_priority = self._tid_is_high_priority(rx_tid)
428 index = self._get_priority_index(high_priority)
429
430 # (timestamp, defer, frame, timeout, retry, delayedCall)
431 last_tx_tuple = self._tx_request[index]
432
433 if last_tx_tuple is None or \
434 last_tx_tuple[OMCI_CC.REQUEST_FRAME].fields.get('transaction_id') != rx_tid:
435 # Possible late Rx on a message that timed-out
436 if last_tx_tuple:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000437 self.logger.debug('Unknown message', rx_tid=rx_tid,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000438 tx_id=last_tx_tuple[OMCI_CC.REQUEST_FRAME].fields.get('transaction_id'))
439 self._rx_unknown_tid += 1
440 self._rx_late += 1
441 return
442
443 ts, d, tx_frame, timeout, retry, dc = last_tx_tuple
444 if dc is not None and not dc.cancelled and not dc.called:
445 dc.cancel()
446
447 _secs = self._update_rx_tx_stats(now, ts)
448
449 # Late arrival already serviced by a timeout?
450 if d.called:
451 self._rx_late += 1
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000452 self.logger.debug('Serviced by timeout. Late arrival', rx_late = self._rx_late)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000453 return
454
455 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000456 self.logger.exception('frame-match', msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000457 if d is not None:
458 return d.errback(failure.Failure(e))
459 return
460
461 # Publish Rx event to listeners in a different task
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000462 self.logger.debug('Publish rx event', rx_tid = rx_tid,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000463 tx_tid = tx_frame.fields['transaction_id'])
464 reactor.callLater(0, self._publish_rx_frame, tx_frame, rx_frame)
465
466 # begin success callback chain (will cancel timeout and queue next Tx message)
467 self._rx_response[index] = rx_frame
468 d.callback(rx_frame)
469
470 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000471 self.logger.exception('rx-msg', e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000472 */
473}
474
Himani Chawla6d2ae152020-09-02 13:11:20 +0530475/*
476func (oo *omciCC) publishRxResponseFrame(ctx context.Context, txFrame []byte, rxFrame []byte) error {
Himani Chawla4d908332020-08-31 12:30:20 +0530477 return errors.New("publishRxResponseFrame unimplemented")
Himani Chawla6d2ae152020-09-02 13:11:20 +0530478 //def _publish_rx_frame(self, tx_frame, rx_frame):
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000479}
Himani Chawla6d2ae152020-09-02 13:11:20 +0530480*/
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000481
Girish Gowdra6afb56a2021-04-27 17:47:57 -0700482// ReleaseTid releases OMCI transaction identifier from rxSchedulerMap
483func (oo *omciCC) ReleaseTid(ctx context.Context, tid uint16) {
484 logger.Debugw(ctx, "releasing tid from rxSchedulerMap", log.Fields{"tid": tid})
485 delete(oo.rxSchedulerMap, tid)
486}
487
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000488//Queue the OMCI Frame for a transmit to the ONU via the proxy_channel
Himani Chawla6d2ae152020-09-02 13:11:20 +0530489func (oo *omciCC) send(ctx context.Context, txFrame []byte, timeout int, retry int, highPrio bool,
490 receiveCallbackPair callbackPair) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000491
mpagenkoc26d4c02021-05-06 14:27:57 +0000492 if timeout != 0 {
493 logger.Debugw(ctx, "register-response-callback:", log.Fields{"for TansCorrId": receiveCallbackPair.cbKey})
494 oo.mutexRxSchedMap.Lock()
495 // it could be checked, if the callback key is already registered - but simply overwrite may be acceptable ...
496 oo.rxSchedulerMap[receiveCallbackPair.cbKey] = receiveCallbackPair.cbEntry
497 oo.mutexRxSchedMap.Unlock()
498 } //else timeout 0 indicates that no response is expected - fire and forget
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000499
mpagenkoc26d4c02021-05-06 14:27:57 +0000500 printFrame := receiveCallbackPair.cbEntry.framePrint //printFrame true means debug print of frame is requested
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000501 //just use a simple list for starting - might need some more effort, especially for multi source write access
502 omciTxRequest := omciTransferStructure{
503 txFrame,
504 timeout,
505 retry,
506 highPrio,
mpagenko80622a52021-02-09 16:53:23 +0000507 printFrame,
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000508 receiveCallbackPair,
509 nil,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000510 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000511 oo.mutexMonReq.Lock()
512 defer oo.mutexMonReq.Unlock()
513 if _, exist := oo.monitoredRequests[receiveCallbackPair.cbKey]; !exist {
mpagenko7455fd42021-06-10 16:25:55 +0000514 // do not call processRequestMonitoring in background here to ensure correct sequencing
515 // of requested messages into txQueue (especially for non-response-supervised messages)
516 oo.processRequestMonitoring(ctx, omciTxRequest)
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000517 return nil
518 }
519 logger.Errorw(ctx, "A message with this tid is processed already!",
520 log.Fields{"tid": receiveCallbackPair.cbKey, "device-id": oo.deviceID})
521 return fmt.Errorf("message with tid is processed already %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000522}
523
524//Pull next tx request and send it
Himani Chawla6d2ae152020-09-02 13:11:20 +0530525func (oo *omciCC) sendNextRequest(ctx context.Context) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000526 // return errors.New("sendNextRequest unimplemented")
527
528 // just try to get something transferred !!
529 // avoid accessing the txQueue from parallel send requests
530 // block parallel omci send requests at least until SendIAP is 'committed'
531 // that should be feasible for an onu instance as on OMCI anyway window size 1 is assumed
532 oo.mutexTxQueue.Lock()
mpagenkodff5dda2020-08-28 11:52:01 +0000533 defer oo.mutexTxQueue.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000534 for oo.txQueue.Len() > 0 {
535 queueElement := oo.txQueue.Front() // First element
536 omciTxRequest := queueElement.Value.(omciTransferStructure)
537 /* compare olt device handler code:
538 func (dh *DeviceHandler) omciIndication(omciInd *oop.OmciIndication) {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000539 logger.Debugw(ctx,"omci indication", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000540 var deviceType string
541 var deviceID string
542 var proxyDeviceID string
543
544 onuKey := dh.formOnuKey(omciInd.IntfId, omciInd.OnuId)
545
546 if onuInCache, ok := dh.onus.Load(onuKey); !ok {
547
dbainbri4d3a0dc2020-12-02 00:33:42 +0000548 logger.Debugw(ctx,"omci indication for a device not in cache.", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000549 ponPort := IntfIDToPortNo(omciInd.GetIntfId(), voltha.Port_PON_OLT)
550 kwargs := make(map[string]interface{})
551 kwargs["onu_id"] = omciInd.OnuId
552 kwargs["parent_port_no"] = ponPort
553
dbainbri4d3a0dc2020-12-02 00:33:42 +0000554 onuDevice, err := dh.coreProxy.GetChildDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, kwargs)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000555 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000556 logger.Errorw(ctx,"onu not found", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId, "error": err})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000557 return
558 }
559 deviceType = onuDevice.Type
560 deviceID = onuDevice.Id
561 proxyDeviceID = onuDevice.ProxyAddress.DeviceId
562 //if not exist in cache, then add to cache.
563 dh.onus.Store(onuKey, NewOnuDevice(deviceID, deviceType, onuDevice.SerialNumber, omciInd.OnuId, omciInd.IntfId, proxyDeviceID))
564 } else {
565 //found in cache
dbainbri4d3a0dc2020-12-02 00:33:42 +0000566 logger.Debugw(ctx,"omci indication for a device in cache.", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000567 deviceType = onuInCache.(*OnuDevice).deviceType
568 deviceID = onuInCache.(*OnuDevice).deviceID
569 proxyDeviceID = onuInCache.(*OnuDevice).proxyDeviceID
570 }
571 */
572 /* and compare onu_adapter py code:
573 omci_msg = InterAdapterOmciMessage(
574 message=bytes(frame),
575 proxy_address=self._proxy_address,
576 connect_status=self._device.connect_status)
577
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000578 self.logger.debug('sent-omci-msg', tid=tx_tid, omci_msg=hexlify(bytes(frame)))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000579
580 yield self._adapter_proxy.send_inter_adapter_message(
581 msg=omci_msg,
582 type=InterAdapterMessageType.OMCI_REQUEST,
583 from_adapter=self._device.type,
584 to_adapter=self._proxy_address.device_type,
585 to_device_id=self._device_id,
586 proxy_device_id=self._proxy_address.device_id
587 )
588 */
mpagenko80622a52021-02-09 16:53:23 +0000589 if omciTxRequest.withFramePrint {
590 logger.Debugw(ctx, "omci-message-to-send:", log.Fields{
591 "TxOmciMessage": hex.EncodeToString(omciTxRequest.txFrame),
592 "device-id": oo.deviceID,
593 "toDeviceType": oo.pBaseDeviceHandler.ProxyAddressType,
594 "proxyDeviceID": oo.pBaseDeviceHandler.ProxyAddressID})
595 }
amit.ghosh58b704b2021-06-18 03:45:52 +0200596 omciMsg := &ic.InterAdapterOmciMessage{
597 Message: omciTxRequest.txFrame,
598 ProxyAddress: oo.pBaseDeviceHandler.device.ProxyAddress,
599 ConnectStatus: common.ConnectStatus_REACHABLE, // If we are sending OMCI messages means we are connected, else we should not be here
600 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000601 if sendErr := oo.adapterProxy.SendInterAdapterMessage(log.WithSpanFromContext(context.Background(), ctx), omciMsg,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000602 ic.InterAdapterMessageType_OMCI_REQUEST,
Matteo Scandoloefbec272020-11-17 10:33:09 -0800603 //fromTopic,toType,toDevId, ProxyDevId
604 oo.pOnuDeviceEntry.baseDeviceHandler.pOpenOnuAc.config.Topic, oo.pBaseDeviceHandler.ProxyAddressType,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000605 oo.deviceID, oo.pBaseDeviceHandler.ProxyAddressID, ""); sendErr != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000606 logger.Errorw(ctx, "send omci request error", log.Fields{"ChildId": oo.deviceID, "error": sendErr})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000607 return sendErr
608 }
609 oo.txQueue.Remove(queueElement) // Dequeue
610 }
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000611 return nil
612}
613
Himani Chawla6d2ae152020-09-02 13:11:20 +0530614func (oo *omciCC) getNextTid(highPriority bool) uint16 {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000615 var next uint16
616 if highPriority {
mpagenko900ee4b2020-10-12 11:56:34 +0000617 oo.mutexHpTid.Lock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000618 next = oo.hpTid
Himani Chawla4d908332020-08-31 12:30:20 +0530619 oo.hpTid++
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000620 if oo.hpTid < 0x8000 {
621 oo.hpTid = 0x8000
622 }
mpagenko900ee4b2020-10-12 11:56:34 +0000623 oo.mutexHpTid.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000624 } else {
mpagenko900ee4b2020-10-12 11:56:34 +0000625 oo.mutexTid.Lock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000626 next = oo.tid
Himani Chawla4d908332020-08-31 12:30:20 +0530627 oo.tid++
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000628 if oo.tid >= 0x8000 {
629 oo.tid = 1
630 }
mpagenko900ee4b2020-10-12 11:56:34 +0000631 oo.mutexTid.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000632 }
633 return next
634}
635
636// ###################################################################################
637// # utility methods provided to work on OMCI messages
dbainbri4d3a0dc2020-12-02 00:33:42 +0000638func serialize(ctx context.Context, msgType omci.MessageType, request gopacket.SerializableLayer, tid uint16) ([]byte, error) {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000639 omciLayer := &omci.OMCI{
640 TransactionID: tid,
641 MessageType: msgType,
642 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000643 return serializeOmciLayer(ctx, omciLayer, request)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000644}
645
dbainbri4d3a0dc2020-12-02 00:33:42 +0000646func serializeOmciLayer(ctx context.Context, aOmciLayer *omci.OMCI, aRequest gopacket.SerializableLayer) ([]byte, error) {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000647 var options gopacket.SerializeOptions
648 options.FixLengths = true
649
650 buffer := gopacket.NewSerializeBuffer()
Himani Chawla4d908332020-08-31 12:30:20 +0530651 err := gopacket.SerializeLayers(buffer, options, aOmciLayer, aRequest)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000652 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000653 logger.Errorw(ctx, "Could not create goPacket Omci serial buffer", log.Fields{"Err": err})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000654 return nil, err
655 }
656 return buffer.Bytes(), nil
657}
658
Himani Chawla4d908332020-08-31 12:30:20 +0530659/*
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000660func hexEncode(omciPkt []byte) ([]byte, error) {
661 dst := make([]byte, hex.EncodedLen(len(omciPkt)))
662 hex.Encode(dst, omciPkt)
663 return dst, nil
664}
Himani Chawla4d908332020-08-31 12:30:20 +0530665*/
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000666
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000667//supply a response handler for omci response messages to be transferred to the requested FSM
dbainbri4d3a0dc2020-12-02 00:33:42 +0000668func (oo *omciCC) receiveOmciResponse(ctx context.Context, omciMsg *omci.OMCI, packet *gp.Packet, respChan chan Message) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000669
dbainbri4d3a0dc2020-12-02 00:33:42 +0000670 logger.Debugw(ctx, "omci-message-response - transfer on omciRespChannel", log.Fields{"omciMsgType": omciMsg.MessageType,
divyadesai4d299552020-08-18 07:13:49 +0000671 "transCorrId": strconv.FormatInt(int64(omciMsg.TransactionID), 16), "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000672
673 if oo.pOnuDeviceEntry == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000674 logger.Errorw(ctx, "Abort receiving OMCI response, DeviceEntryPointer is nil", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000675 "device-id": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200676 return fmt.Errorf("deviceEntryPointer is nil %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000677 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000678 oo.mutexMonReq.RLock()
679 if _, exist := oo.monitoredRequests[omciMsg.TransactionID]; exist {
mpagenko8cd1bf72021-06-22 10:11:19 +0000680 //implement non-blocking channel send to avoid blocking on mutexMonReq later
681 select {
682 case oo.monitoredRequests[omciMsg.TransactionID].chSuccess <- true:
683 default:
684 logger.Debugw(ctx, "response not send on omciRespChannel (no receiver)", log.Fields{
685 "transCorrId": strconv.FormatInt(int64(omciMsg.TransactionID), 16), "device-id": oo.deviceID})
686 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000687 } else {
688 logger.Infow(ctx, "reqMon: map entry does not exist!",
689 log.Fields{"tid": omciMsg.TransactionID, "device-id": oo.deviceID})
690 }
691 oo.mutexMonReq.RUnlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000692
693 // no further test on SeqNo is done here, assignment from rxScheduler is trusted
694 // MibSync responses are simply transferred via deviceEntry to MibSync, no specific analysis here
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000695 omciRespMsg := Message{
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000696 Type: OMCI,
697 Data: OmciMessage{
698 OmciMsg: omciMsg,
699 OmciPacket: packet,
700 },
701 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000702 //logger.Debugw(ctx,"Message to be sent into channel:", log.Fields{"mibSyncMsg": mibSyncMsg})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000703 respChan <- omciRespMsg
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000704
705 return nil
706}
707
Himani Chawla6d2ae152020-09-02 13:11:20 +0530708func (oo *omciCC) sendMibReset(ctx context.Context, timeout int, highPrio bool) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000709
dbainbri4d3a0dc2020-12-02 00:33:42 +0000710 logger.Debugw(ctx, "send MibReset-msg to:", log.Fields{"device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000711 request := &omci.MibResetRequest{
712 MeBasePacket: omci.MeBasePacket{
713 EntityClass: me.OnuDataClassID,
714 },
715 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530716 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000717 pkt, err := serialize(ctx, omci.MibResetRequestType, request, tid)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000718 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000719 logger.Errorw(ctx, "Cannot serialize MibResetRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000720 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000721 return err
722 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530723 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000724 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000725 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000726 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000727 return oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000728}
729
Himani Chawla6d2ae152020-09-02 13:11:20 +0530730func (oo *omciCC) sendReboot(ctx context.Context, timeout int, highPrio bool, responseChannel chan Message) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000731 logger.Debugw(ctx, "send Reboot-msg to:", log.Fields{"device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300732 request := &omci.RebootRequest{
733 MeBasePacket: omci.MeBasePacket{
734 EntityClass: me.OnuGClassID,
735 },
736 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530737 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000738 pkt, err := serialize(ctx, omci.RebootRequestType, request, tid)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300739 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000740 logger.Errorw(ctx, "Cannot serialize RebootRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000741 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300742 return err
743 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530744 omciRxCallbackPair := callbackPair{
ozgecanetsiae11479f2020-07-06 09:44:47 +0300745 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000746 cbEntry: callbackPairEntry{oo.pOnuDeviceEntry.omciRebootMessageReceivedChannel, oo.receiveOmciResponse, true},
ozgecanetsiae11479f2020-07-06 09:44:47 +0300747 }
748
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000749 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300750 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000751 logger.Errorw(ctx, "Cannot send RebootRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000752 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300753 return err
754 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000755 err = oo.pOnuDeviceEntry.waitForRebootResponse(ctx, responseChannel)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300756 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000757 logger.Errorw(ctx, "aborting ONU Reboot!", log.Fields{
Andrea Campanella6515c582020-10-05 11:25:00 +0200758 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300759 return err
760 }
761 return nil
762}
763
Himani Chawla6d2ae152020-09-02 13:11:20 +0530764func (oo *omciCC) sendMibUpload(ctx context.Context, timeout int, highPrio bool) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000765 logger.Debugw(ctx, "send MibUpload-msg to:", log.Fields{"device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000766 request := &omci.MibUploadRequest{
767 MeBasePacket: omci.MeBasePacket{
768 EntityClass: me.OnuDataClassID,
769 },
770 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530771 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000772 pkt, err := serialize(ctx, omci.MibUploadRequestType, request, tid)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000773 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000774 logger.Errorw(ctx, "Cannot serialize MibUploadRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000775 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000776 return err
777 }
778 oo.uploadSequNo = 0
779 oo.uploadNoOfCmds = 0
780
Himani Chawla6d2ae152020-09-02 13:11:20 +0530781 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000782 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000783 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000784 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000785 return oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000786}
787
Himani Chawla6d2ae152020-09-02 13:11:20 +0530788func (oo *omciCC) sendMibUploadNext(ctx context.Context, timeout int, highPrio bool) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000789 logger.Debugw(ctx, "send MibUploadNext-msg to:", log.Fields{"device-id": oo.deviceID, "uploadSequNo": oo.uploadSequNo})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000790 request := &omci.MibUploadNextRequest{
791 MeBasePacket: omci.MeBasePacket{
792 EntityClass: me.OnuDataClassID,
793 },
794 CommandSequenceNumber: oo.uploadSequNo,
795 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530796 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000797 pkt, err := serialize(ctx, omci.MibUploadNextRequestType, request, tid)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000798 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000799 logger.Errorw(ctx, "Cannot serialize MibUploadNextRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000800 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000801 return err
802 }
803 oo.uploadSequNo++
804
Himani Chawla6d2ae152020-09-02 13:11:20 +0530805 omciRxCallbackPair := callbackPair{
mpagenko80622a52021-02-09 16:53:23 +0000806 cbKey: tid,
807 //frame printing for MibUpload frames disabled now per default to avoid log file abort situations (size/speed?)
808 // if wanted, rx frame printing should be specifically done within the MibUpload FSM or controlled via extra parameter
809 // compare also software upgrade download section handling
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000810 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000811 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000812 return oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000813}
814
Himani Chawlad3dac422021-03-13 02:31:31 +0530815func (oo *omciCC) sendGetAllAlarm(ctx context.Context, alarmRetreivalMode uint8, timeout int, highPrio bool) error {
816 logger.Debugw(ctx, "send GetAllAlarms-msg to:", log.Fields{"device-id": oo.deviceID})
817 request := &omci.GetAllAlarmsRequest{
818 MeBasePacket: omci.MeBasePacket{
819 EntityClass: me.OnuDataClassID,
820 },
821 AlarmRetrievalMode: byte(alarmRetreivalMode),
822 }
823 tid := oo.getNextTid(highPrio)
824 pkt, err := serialize(ctx, omci.GetAllAlarmsRequestType, request, tid)
825 if err != nil {
826 logger.Errorw(ctx, "Cannot serialize GetAllAlarmsRequest", log.Fields{
827 "Err": err, "device-id": oo.deviceID})
828 return err
829 }
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000830 oo.pBaseDeviceHandler.pAlarmMgr.ResetAlarmUploadCounters()
Himani Chawlad3dac422021-03-13 02:31:31 +0530831
832 omciRxCallbackPair := callbackPair{
833 cbKey: tid,
834 cbEntry: callbackPairEntry{(*oo.pBaseDeviceHandler.pAlarmMgr).eventChannel,
835 oo.receiveOmciResponse, true},
836 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000837 return oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Himani Chawlad3dac422021-03-13 02:31:31 +0530838}
839
840func (oo *omciCC) sendGetAllAlarmNext(ctx context.Context, timeout int, highPrio bool) error {
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000841 alarmUploadSeqNo := oo.pBaseDeviceHandler.pAlarmMgr.GetAlarmUploadSeqNo()
Himani Chawlad3dac422021-03-13 02:31:31 +0530842 logger.Debugw(ctx, "send sendGetAllAlarmNext-msg to:", log.Fields{"device-id": oo.deviceID,
843 "alarmUploadSeqNo": alarmUploadSeqNo})
844 request := &omci.GetAllAlarmsNextRequest{
845 MeBasePacket: omci.MeBasePacket{
846 EntityClass: me.OnuDataClassID,
847 },
848 CommandSequenceNumber: alarmUploadSeqNo,
849 }
850 tid := oo.getNextTid(highPrio)
851 pkt, err := serialize(ctx, omci.GetAllAlarmsNextRequestType, request, tid)
852 if err != nil {
853 logger.Errorw(ctx, "Cannot serialize GetAllAlarmsNextRequest", log.Fields{
854 "Err": err, "device-id": oo.deviceID})
855 return err
856 }
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000857 oo.pBaseDeviceHandler.pAlarmMgr.IncrementAlarmUploadSeqNo()
Himani Chawlad3dac422021-03-13 02:31:31 +0530858
859 omciRxCallbackPair := callbackPair{
860 cbKey: tid,
861 cbEntry: callbackPairEntry{(*oo.pBaseDeviceHandler.pAlarmMgr).eventChannel, oo.receiveOmciResponse, true},
862 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000863 return oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Himani Chawlad3dac422021-03-13 02:31:31 +0530864}
865
ozgecanetsiab36ed572021-04-01 10:38:48 +0300866func (oo *omciCC) sendCreateGalEthernetProfile(ctx context.Context, timeout int, highPrio bool) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530867 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000868 logger.Debugw(ctx, "send GalEnetProfile-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000869 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000870
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000871 meParams := me.ParamData{
872 EntityID: galEthernetEID,
873 Attributes: me.AttributeValueMap{"MaximumGemPayloadSize": maxGemPayloadSize},
874 }
875 meInstance, omciErr := me.NewGalEthernetProfile(meParams)
876 if omciErr.GetError() == nil {
877 //all setByCreate parameters already set, no default option required ...
878 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
879 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000880 logger.Errorw(ctx, "Cannot encode GalEnetProfileInstance for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000881 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300882 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000883 }
884
dbainbri4d3a0dc2020-12-02 00:33:42 +0000885 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000886 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000887 logger.Errorw(ctx, "Cannot serialize GalEnetProfile create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000888 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300889 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000890 }
891
Himani Chawla6d2ae152020-09-02 13:11:20 +0530892 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000893 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000894 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000895 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000896 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000897 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000898 logger.Errorw(ctx, "Cannot send GalEnetProfile create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000899 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300900 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000901 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000902 logger.Debug(ctx, "send GalEnetProfile-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +0300903 return meInstance, nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000904 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000905 logger.Errorw(ctx, "Cannot generate GalEnetProfileInstance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000906 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300907 return nil, omciErr.GetError()
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000908}
909
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000910// might be needed to extend for parameter arguments, here just for setting the ConnectivityMode!!
ozgecanetsiab36ed572021-04-01 10:38:48 +0300911func (oo *omciCC) sendSetOnu2g(ctx context.Context, timeout int, highPrio bool) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530912 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000913 logger.Debugw(ctx, "send ONU2-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000914 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000915
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000916 // ONU-G ME-ID is defined to be 0, but we could verify, if the ONU really supports the desired
917 // connectivity mode 5 (in ConnCap)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000918 // By now we just use fix values to fire - this is anyway what the python adapter does
919 // read ONU-2G from DB ???? //TODO!!!
920 meParams := me.ParamData{
921 EntityID: 0,
922 Attributes: me.AttributeValueMap{"CurrentConnectivityMode": connectivityModeValue},
923 }
924 meInstance, omciErr := me.NewOnu2G(meParams)
925 if omciErr.GetError() == nil {
926 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
927 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000928 logger.Errorw(ctx, "Cannot encode ONU2-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000929 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300930 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000931 }
932
dbainbri4d3a0dc2020-12-02 00:33:42 +0000933 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000934 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000935 logger.Errorw(ctx, "Cannot serialize ONU2-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000936 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300937 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000938 }
939
Himani Chawla6d2ae152020-09-02 13:11:20 +0530940 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000941 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000942 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000943 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000944 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000945 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000946 logger.Errorw(ctx, "Cannot send ONU2-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000947 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300948 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000949 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000950 logger.Debug(ctx, "send ONU2-G-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +0300951 return meInstance, nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000952 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000953 logger.Errorw(ctx, "Cannot generate ONU2-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000954 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300955 return nil, omciErr.GetError()
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000956}
957
Himani Chawla6d2ae152020-09-02 13:11:20 +0530958func (oo *omciCC) sendCreateMBServiceProfile(ctx context.Context,
ozgecanetsiab36ed572021-04-01 10:38:48 +0300959 aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530960 tid := oo.getNextTid(highPrio)
Himani Chawla4d908332020-08-31 12:30:20 +0530961 instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000962 logger.Debugw(ctx, "send MBSP-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000963 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000964
965 meParams := me.ParamData{
966 EntityID: instID,
967 Attributes: me.AttributeValueMap{
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300968 "Priority": 0x8000,
969 "MaxAge": 20 * 256, //20s
970 "HelloTime": 2 * 256, //2s
971 "ForwardDelay": 15 * 256, //15s
972 "DynamicFilteringAgeingTime": 0,
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000973 },
974 }
975
976 meInstance, omciErr := me.NewMacBridgeServiceProfile(meParams)
977 if omciErr.GetError() == nil {
978 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
979 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
980 omci.TransactionID(tid), omci.AddDefaults(true))
981 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000982 logger.Errorw(ctx, "Cannot encode MBSP for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000983 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300984 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000985 }
986
dbainbri4d3a0dc2020-12-02 00:33:42 +0000987 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000988 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000989 logger.Errorw(ctx, "Cannot serialize MBSP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000990 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300991 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000992 }
993
Himani Chawla6d2ae152020-09-02 13:11:20 +0530994 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000995 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000996 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000997 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000998 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000999 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001000 logger.Errorw(ctx, "Cannot send MBSP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001001 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001002 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001003 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001004 logger.Debug(ctx, "send MBSP-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001005 return meInstance, nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001006 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001007 logger.Errorw(ctx, "Cannot generate MBSP Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001008 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001009 return nil, omciErr.GetError()
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001010}
1011
Mahir Gunyel6781f962021-05-16 23:30:08 -07001012func (oo *omciCC) sendCreateMBPConfigDataUniSide(ctx context.Context,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001013 aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301014 tid := oo.getNextTid(highPrio)
Mahir Gunyel6781f962021-05-16 23:30:08 -07001015 instID, idErr := generateUNISideMBPCDEID(uint16(aPUniPort.macBpNo))
1016 if idErr != nil {
1017 logger.Errorw(ctx, "Cannot generate MBPCD entity id", log.Fields{
1018 "Err": idErr, "device-id": oo.deviceID})
1019 return nil, idErr
1020 }
1021 logger.Debugw(ctx, "send MBPCD-Create-msg for uni side:", log.Fields{"device-id": oo.deviceID,
1022 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16), "macBpNo": aPUniPort.macBpNo})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001023
1024 meParams := me.ParamData{
1025 EntityID: instID,
1026 Attributes: me.AttributeValueMap{
Himani Chawla4d908332020-08-31 12:30:20 +05301027 "BridgeIdPointer": macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo),
1028 "PortNum": aPUniPort.macBpNo,
1029 "TpType": uint8(aPUniPort.portType),
Himani Chawla26e555c2020-08-31 12:30:20 +05301030 "TpPointer": aPUniPort.entityID,
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001031 },
1032 }
1033 meInstance, omciErr := me.NewMacBridgePortConfigurationData(meParams)
1034 if omciErr.GetError() == nil {
1035 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1036 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1037 omci.TransactionID(tid), omci.AddDefaults(true))
1038 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001039 logger.Errorw(ctx, "Cannot encode MBPCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001040 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001041 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001042 }
1043
dbainbri4d3a0dc2020-12-02 00:33:42 +00001044 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001045 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001046 logger.Errorw(ctx, "Cannot serialize MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001047 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001048 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001049 }
1050
Himani Chawla6d2ae152020-09-02 13:11:20 +05301051 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001052 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001053 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001054 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001055 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001056 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001057 logger.Errorw(ctx, "Cannot send MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001058 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001059 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001060 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001061 logger.Debug(ctx, "send MBPCD-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001062 return meInstance, nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001063 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001064 logger.Errorw(ctx, "Cannot generate MBPCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001065 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001066 return nil, omciErr.GetError()
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001067}
1068
Himani Chawla6d2ae152020-09-02 13:11:20 +05301069func (oo *omciCC) sendCreateEVTOConfigData(ctx context.Context,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001070 aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301071 tid := oo.getNextTid(highPrio)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001072 //same entityId is used as for MBSP (see there), but just arbitrary ...
Himani Chawla4d908332020-08-31 12:30:20 +05301073 instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001074 logger.Debugw(ctx, "send EVTOCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001075 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001076
1077 // compare python adapter code WA VOL-1311: this is not done here!
1078 // (setting TPID values for the create would probably anyway be ignored by the omci lib)
1079 // but perhaps we have to be aware of possible problems at get(Next) Request handling for EVTOOCD tables later ...
1080 assType := uint8(2) // default AssociationType is PPTPEthUni
Himani Chawla6d2ae152020-09-02 13:11:20 +05301081 if aPUniPort.portType == uniVEIP {
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001082 assType = uint8(10) // for VEIP
1083 }
1084 meParams := me.ParamData{
1085 EntityID: instID,
1086 Attributes: me.AttributeValueMap{
1087 "AssociationType": assType,
Himani Chawla26e555c2020-08-31 12:30:20 +05301088 "AssociatedMePointer": aPUniPort.entityID,
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001089 },
1090 }
1091 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(meParams)
1092 if omciErr.GetError() == nil {
1093 //all setByCreate parameters already set, no default option required ...
1094 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
1095 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001096 logger.Errorw(ctx, "Cannot encode EVTOCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001097 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001098 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001099 }
1100
dbainbri4d3a0dc2020-12-02 00:33:42 +00001101 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001102 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001103 logger.Errorw(ctx, "Cannot serialize EVTOCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001104 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001105 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001106 }
1107
Himani Chawla6d2ae152020-09-02 13:11:20 +05301108 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001109 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001110 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001111 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001112 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001113 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001114 logger.Errorw(ctx, "Cannot send EVTOCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001115 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001116 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001117 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001118 logger.Debug(ctx, "send EVTOCD-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001119 return meInstance, nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001120 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001121 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001122 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001123 return nil, omciErr.GetError()
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001124}
1125
Himani Chawla6d2ae152020-09-02 13:11:20 +05301126func (oo *omciCC) sendSetOnuGLS(ctx context.Context, timeout int,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001127 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301128 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001129 logger.Debugw(ctx, "send ONU-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001130 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001131
1132 // ONU-G ME-ID is defined to be 0, no need to perform a DB lookup
1133 meParams := me.ParamData{
1134 EntityID: 0,
1135 Attributes: requestedAttributes,
1136 }
1137 meInstance, omciErr := me.NewOnuG(meParams)
1138 if omciErr.GetError() == nil {
1139 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1140 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001141 logger.Errorw(ctx, "Cannot encode ONU-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001142 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001143 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001144 }
1145
dbainbri4d3a0dc2020-12-02 00:33:42 +00001146 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001147 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001148 logger.Errorw(ctx, "Cannot serialize ONU-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001149 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001150 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001151 }
1152
Himani Chawla6d2ae152020-09-02 13:11:20 +05301153 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001154 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001155 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001156 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001157 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001158 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001159 logger.Errorw(ctx, "Cannot send ONU-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001160 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001161 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001162 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001163 logger.Debug(ctx, "send ONU-G-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001164 return meInstance, nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001165 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001166 logger.Errorw(ctx, "Cannot generate ONU-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001167 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001168 return nil, omciErr.GetError()
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001169}
1170
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001171func (oo *omciCC) sendSetPptpEthUniLS(ctx context.Context, aInstNo uint16, timeout int,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001172 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001173 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001174 logger.Debugw(ctx, "send PPTPEthUni-Set-msg:", log.Fields{"device-id": oo.deviceID,
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001175 "SequNo": strconv.FormatInt(int64(tid), 16)})
1176
1177 // PPTPEthUni ME-ID is taken from Mib Upload stored OnuUniPort instance (argument)
1178 meParams := me.ParamData{
1179 EntityID: aInstNo,
1180 Attributes: requestedAttributes,
1181 }
1182 meInstance, omciErr := me.NewPhysicalPathTerminationPointEthernetUni(meParams)
1183 if omciErr.GetError() == nil {
1184 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1185 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001186 logger.Errorw(ctx, "Cannot encode PPTPEthUni instance for set", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001187 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001188 return nil, err
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001189 }
1190
dbainbri4d3a0dc2020-12-02 00:33:42 +00001191 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001192 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001193 logger.Errorw(ctx, "Cannot serialize PPTPEthUni-Set", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001194 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001195 return nil, err
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001196 }
1197
1198 omciRxCallbackPair := callbackPair{
1199 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001200 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001201 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001202 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001203 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001204 logger.Errorw(ctx, "Cannot send PPTPEthUni-Set", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001205 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001206 return nil, err
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001207 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001208 logger.Debug(ctx, "send PPTPEthUni-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001209 return meInstance, nil
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001210 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001211 logger.Errorw(ctx, "Cannot generate PPTPEthUni", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001212 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001213 return nil, omciErr.GetError()
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001214}
1215
1216/* UniG obsolete by now, left here in case it should be needed once again
1217 UniG AdminState anyway should be ignored by ONU acc. to G988
Himani Chawla6d2ae152020-09-02 13:11:20 +05301218func (oo *omciCC) sendSetUniGLS(ctx context.Context, aInstNo uint16, timeout int,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001219 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301220 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001221 logger.Debugw(ctx,"send UNI-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001222 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001223
1224 // UNI-G ME-ID is taken from Mib Upload stored OnuUniPort instance (argument)
1225 meParams := me.ParamData{
1226 EntityID: aInstNo,
1227 Attributes: requestedAttributes,
1228 }
1229 meInstance, omciErr := me.NewUniG(meParams)
1230 if omciErr.GetError() == nil {
1231 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1232 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001233 logger.Errorw(ctx,"Cannot encode UNI-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001234 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001235 return nil
1236 }
1237
1238 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1239 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001240 logger.Errorw(ctx,"Cannot serialize UNI-G-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001241 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001242 return nil
1243 }
1244
Himani Chawla6d2ae152020-09-02 13:11:20 +05301245 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001246 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001247 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001248 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001249 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001250 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001251 logger.Errorw(ctx,"Cannot send UNIG-G-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001252 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001253 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001254 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001255 logger.Debug(ctx,"send UNI-G-Set-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001256 return meInstance
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001257 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001258 logger.Errorw(ctx,"Cannot generate UNI-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001259 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001260 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001261}
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001262*/
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001263
Himani Chawla6d2ae152020-09-02 13:11:20 +05301264func (oo *omciCC) sendSetVeipLS(ctx context.Context, aInstNo uint16, timeout int,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001265 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301266 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001267 logger.Debugw(ctx, "send VEIP-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001268 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001269
1270 // ONU-G ME-ID is defined to be 0, no need to perform a DB lookup
1271 meParams := me.ParamData{
1272 EntityID: aInstNo,
1273 Attributes: requestedAttributes,
1274 }
1275 meInstance, omciErr := me.NewVirtualEthernetInterfacePoint(meParams)
1276 if omciErr.GetError() == nil {
1277 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1278 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001279 logger.Errorw(ctx, "Cannot encode VEIP instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001280 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001281 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001282 }
1283
dbainbri4d3a0dc2020-12-02 00:33:42 +00001284 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001285 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001286 logger.Errorw(ctx, "Cannot serialize VEIP-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001287 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001288 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001289 }
1290
Himani Chawla6d2ae152020-09-02 13:11:20 +05301291 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001292 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001293 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001294 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001295 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001296 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001297 logger.Errorw(ctx, "Cannot send VEIP-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001298 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001299 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001300 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001301 logger.Debug(ctx, "send VEIP-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001302 return meInstance, nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001303 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001304 logger.Errorw(ctx, "Cannot generate VEIP", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001305 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001306 return nil, omciErr.GetError()
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001307}
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001308
Himani Chawla6d2ae152020-09-02 13:11:20 +05301309func (oo *omciCC) sendGetMe(ctx context.Context, classID me.ClassID, entityID uint16, requestedAttributes me.AttributeValueMap,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001310 timeout int, highPrio bool, rxChan chan Message) (*me.ManagedEntity, error) {
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001311
Himani Chawla6d2ae152020-09-02 13:11:20 +05301312 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001313 logger.Debugw(ctx, "send get-request-msg", log.Fields{"classID": classID, "device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001314 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001315
1316 meParams := me.ParamData{
1317 EntityID: entityID,
1318 Attributes: requestedAttributes,
1319 }
1320 meInstance, omciErr := me.LoadManagedEntityDefinition(classID, meParams)
1321 if omciErr.GetError() == nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301322 meClassIDName := meInstance.GetName()
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001323 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.GetRequestType, omci.TransactionID(tid))
1324 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001325 logger.Errorf(ctx, "Cannot encode instance for get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001326 return nil, err
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001327 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001328 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001329 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001330 logger.Errorw(ctx, "Cannot serialize get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001331 return nil, err
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001332 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301333 omciRxCallbackPair := callbackPair{
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001334 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001335 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001336 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001337 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001338 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001339 logger.Errorw(ctx, "Cannot send get-request-msg", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001340 return nil, err
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001341 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001342 logger.Debugw(ctx, "send get-request-msg done", log.Fields{"meClassIDName": meClassIDName, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001343 return meInstance, nil
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001344 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001345 logger.Errorw(ctx, "Cannot generate meDefinition", log.Fields{"classID": classID, "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001346 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001347}
1348
Himani Chawla6d2ae152020-09-02 13:11:20 +05301349func (oo *omciCC) sendCreateDot1PMapper(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001350 aInstID uint16, rxChan chan Message) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301351 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001352 logger.Debugw(ctx, "send .1pMapper-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001353 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(aInstID), 16)})
1354
1355 meParams := me.ParamData{
mpagenko8b5fdd22020-12-17 17:58:32 +00001356 EntityID: aInstID,
1357 Attributes: me.AttributeValueMap{
1358 //workaround for unsuitable omci-lib default values, cmp VOL-3729
1359 "TpPointer": 0xFFFF,
1360 "InterworkTpPointerForPBitPriority0": 0xFFFF,
1361 "InterworkTpPointerForPBitPriority1": 0xFFFF,
1362 "InterworkTpPointerForPBitPriority2": 0xFFFF,
1363 "InterworkTpPointerForPBitPriority3": 0xFFFF,
1364 "InterworkTpPointerForPBitPriority4": 0xFFFF,
1365 "InterworkTpPointerForPBitPriority5": 0xFFFF,
1366 "InterworkTpPointerForPBitPriority6": 0xFFFF,
1367 "InterworkTpPointerForPBitPriority7": 0xFFFF,
1368 },
mpagenko3dbcdd22020-07-22 07:38:45 +00001369 }
1370 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(meParams)
1371 if omciErr.GetError() == nil {
1372 //we have to set all 'untouched' parameters to default by some additional option parameter!!
1373 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1374 omci.TransactionID(tid), omci.AddDefaults(true))
1375 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001376 logger.Errorw(ctx, "Cannot encode .1pMapper for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001377 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001378 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001379 }
1380
dbainbri4d3a0dc2020-12-02 00:33:42 +00001381 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001382 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001383 logger.Errorw(ctx, "Cannot serialize .1pMapper create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001384 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001385 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001386 }
1387
Himani Chawla6d2ae152020-09-02 13:11:20 +05301388 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001389 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001390 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001391 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001392 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001393 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001394 logger.Errorw(ctx, "Cannot send .1pMapper create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001395 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001396 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001397 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001398 logger.Debug(ctx, "send .1pMapper-create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001399 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001400 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001401 logger.Errorw(ctx, "Cannot generate .1pMapper", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001402 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001403 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001404}
1405
Himani Chawla6d2ae152020-09-02 13:11:20 +05301406func (oo *omciCC) sendCreateMBPConfigDataVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001407 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301408 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001409 logger.Debugw(ctx, "send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001410 "SequNo": strconv.FormatInt(int64(tid), 16),
1411 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1412
1413 meInstance, omciErr := me.NewMacBridgePortConfigurationData(params[0])
1414 if omciErr.GetError() == nil {
1415 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1416 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1417 omci.TransactionID(tid), omci.AddDefaults(true))
1418 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001419 logger.Errorw(ctx, "Cannot encode MBPCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001420 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001421 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001422 }
1423
dbainbri4d3a0dc2020-12-02 00:33:42 +00001424 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001425 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001426 logger.Errorw(ctx, "Cannot serialize MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001427 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001428 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001429 }
1430
Himani Chawla6d2ae152020-09-02 13:11:20 +05301431 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001432 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001433 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001434 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001435 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001436 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001437 logger.Errorw(ctx, "Cannot send MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001438 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001439 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001440 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001441 logger.Debug(ctx, "send MBPCD-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001442 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001443 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001444 logger.Errorw(ctx, "Cannot generate MBPCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001445 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001446 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001447}
1448
Himani Chawla6d2ae152020-09-02 13:11:20 +05301449func (oo *omciCC) sendCreateGemNCTPVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001450 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301451 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001452 logger.Debugw(ctx, "send GemNCTP-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001453 "SequNo": strconv.FormatInt(int64(tid), 16),
1454 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1455
1456 meInstance, omciErr := me.NewGemPortNetworkCtp(params[0])
1457 if omciErr.GetError() == nil {
1458 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1459 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1460 omci.TransactionID(tid), omci.AddDefaults(true))
1461 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001462 logger.Errorw(ctx, "Cannot encode GemNCTP for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001463 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001464 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001465 }
1466
dbainbri4d3a0dc2020-12-02 00:33:42 +00001467 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001468 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001469 logger.Errorw(ctx, "Cannot serialize GemNCTP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001470 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001471 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001472 }
1473
Himani Chawla6d2ae152020-09-02 13:11:20 +05301474 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001475 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001476 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001477 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001478 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001479 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001480 logger.Errorw(ctx, "Cannot send GemNCTP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001481 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001482 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001483 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001484 logger.Debug(ctx, "send GemNCTP-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001485 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001486 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001487 logger.Errorw(ctx, "Cannot generate GemNCTP Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001488 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001489 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001490}
1491
Himani Chawla6d2ae152020-09-02 13:11:20 +05301492func (oo *omciCC) sendCreateGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001493 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301494 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001495 logger.Debugw(ctx, "send GemIwTp-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001496 "SequNo": strconv.FormatInt(int64(tid), 16),
1497 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1498
1499 meInstance, omciErr := me.NewGemInterworkingTerminationPoint(params[0])
1500 if omciErr.GetError() == nil {
1501 //all SetByCreate Parameters (assumed to be) set here, for optimisation no 'AddDefaults'
1502 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1503 omci.TransactionID(tid))
1504 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001505 logger.Errorw(ctx, "Cannot encode GemIwTp for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001506 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001507 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001508 }
1509
dbainbri4d3a0dc2020-12-02 00:33:42 +00001510 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001511 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001512 logger.Errorw(ctx, "Cannot serialize GemIwTp create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001513 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001514 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001515 }
1516
Himani Chawla6d2ae152020-09-02 13:11:20 +05301517 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001518 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001519 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001520 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001521 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001522 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001523 logger.Errorw(ctx, "Cannot send GemIwTp create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001524 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001525 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001526 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001527 logger.Debug(ctx, "send GemIwTp-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001528 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001529 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001530 logger.Errorw(ctx, "Cannot generate GemIwTp Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001531 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001532 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001533}
1534
Himani Chawla6d2ae152020-09-02 13:11:20 +05301535func (oo *omciCC) sendSetTcontVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001536 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301537 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001538 logger.Debugw(ctx, "send TCont-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001539 "SequNo": strconv.FormatInt(int64(tid), 16),
1540 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1541
1542 meInstance, omciErr := me.NewTCont(params[0])
1543 if omciErr.GetError() == nil {
1544 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1545 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001546 logger.Errorw(ctx, "Cannot encode TCont for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001547 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001548 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001549 }
1550
dbainbri4d3a0dc2020-12-02 00:33:42 +00001551 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001552 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001553 logger.Errorw(ctx, "Cannot serialize TCont set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001554 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001555 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001556 }
1557
Himani Chawla6d2ae152020-09-02 13:11:20 +05301558 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001559 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001560 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001561 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001562 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001563 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001564 logger.Errorw(ctx, "Cannot send TCont set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001565 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001566 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001567 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001568 logger.Debug(ctx, "send TCont-set msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001569 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001570 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001571 logger.Errorw(ctx, "Cannot generate TCont Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001572 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001573 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001574}
1575
Himani Chawla6d2ae152020-09-02 13:11:20 +05301576func (oo *omciCC) sendSetPrioQueueVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001577 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301578 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001579 logger.Debugw(ctx, "send PrioQueue-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001580 "SequNo": strconv.FormatInt(int64(tid), 16),
1581 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1582
1583 meInstance, omciErr := me.NewPriorityQueue(params[0])
1584 if omciErr.GetError() == nil {
1585 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1586 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001587 logger.Errorw(ctx, "Cannot encode PrioQueue for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001588 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001589 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001590 }
1591
dbainbri4d3a0dc2020-12-02 00:33:42 +00001592 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001593 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001594 logger.Errorw(ctx, "Cannot serialize PrioQueue set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001595 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001596 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001597 }
1598
Himani Chawla6d2ae152020-09-02 13:11:20 +05301599 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001600 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001601 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001602 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001603 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001604 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001605 logger.Errorw(ctx, "Cannot send PrioQueue set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001606 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001607 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001608 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001609 logger.Debug(ctx, "send PrioQueue-set msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001610 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001611 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001612 logger.Errorw(ctx, "Cannot generate PrioQueue Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001613 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001614 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001615}
1616
Himani Chawla6d2ae152020-09-02 13:11:20 +05301617func (oo *omciCC) sendSetDot1PMapperVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001618 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301619 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001620 logger.Debugw(ctx, "send 1PMapper-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001621 "SequNo": strconv.FormatInt(int64(tid), 16),
1622 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1623
1624 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(params[0])
1625 if omciErr.GetError() == nil {
1626 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1627 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001628 logger.Errorw(ctx, "Cannot encode 1PMapper for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001629 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001630 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001631 }
1632
dbainbri4d3a0dc2020-12-02 00:33:42 +00001633 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001634 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001635 logger.Errorw(ctx, "Cannot serialize 1PMapper set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001636 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001637 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001638 }
1639
Himani Chawla6d2ae152020-09-02 13:11:20 +05301640 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001641 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001642 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001643 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001644 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001645 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001646 logger.Errorw(ctx, "Cannot send 1PMapper set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001647 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001648 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001649 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001650 logger.Debug(ctx, "send 1PMapper-set msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001651 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001652 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001653 logger.Errorw(ctx, "Cannot generate 1PMapper Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001654 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001655 return nil, omciErr.GetError()
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001656}
mpagenkodff5dda2020-08-28 11:52:01 +00001657
Himani Chawla6d2ae152020-09-02 13:11:20 +05301658func (oo *omciCC) sendCreateVtfdVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001659 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301660 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001661 logger.Debugw(ctx, "send VTFD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00001662 "SequNo": strconv.FormatInt(int64(tid), 16),
1663 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1664
1665 meInstance, omciErr := me.NewVlanTaggingFilterData(params[0])
1666 if omciErr.GetError() == nil {
1667 //all SetByCreate Parameters (assumed to be) set here, for optimisation no 'AddDefaults'
1668 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1669 omci.TransactionID(tid))
1670 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001671 logger.Errorw(ctx, "Cannot encode VTFD for create", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001672 "Err": err, "device-id": oo.deviceID})
1673 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1674 // return (dual format) error code that can be used at caller for immediate error treatment
1675 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03001676 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001677 }
1678
dbainbri4d3a0dc2020-12-02 00:33:42 +00001679 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenkodff5dda2020-08-28 11:52:01 +00001680 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001681 logger.Errorw(ctx, "Cannot serialize VTFD create", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001682 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001683 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001684 }
1685
Himani Chawla6d2ae152020-09-02 13:11:20 +05301686 omciRxCallbackPair := callbackPair{
mpagenkodff5dda2020-08-28 11:52:01 +00001687 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001688 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenkodff5dda2020-08-28 11:52:01 +00001689 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001690 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenkodff5dda2020-08-28 11:52:01 +00001691 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001692 logger.Errorw(ctx, "Cannot send VTFD create", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001693 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001694 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001695 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001696 logger.Debug(ctx, "send VTFD-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001697 return meInstance, nil
mpagenkodff5dda2020-08-28 11:52:01 +00001698 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001699 logger.Errorw(ctx, "Cannot generate VTFD Instance", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001700 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001701 return nil, omciErr.GetError()
mpagenkodff5dda2020-08-28 11:52:01 +00001702}
1703
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001704// nolint: unused
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001705func (oo *omciCC) sendSetVtfdVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001706 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001707 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001708 logger.Debugw(ctx, "send VTFD-Set-msg:", log.Fields{"device-id": oo.deviceID,
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001709 "SequNo": strconv.FormatInt(int64(tid), 16),
1710 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1711
1712 meInstance, omciErr := me.NewVlanTaggingFilterData(params[0])
1713 if omciErr.GetError() == nil {
1714 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType,
1715 omci.TransactionID(tid))
1716 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001717 logger.Errorw(ctx, "Cannot encode VTFD for set", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001718 "Err": err, "device-id": oo.deviceID})
1719 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1720 // return (dual format) error code that can be used at caller for immediate error treatment
1721 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03001722 return nil, err
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001723 }
1724
dbainbri4d3a0dc2020-12-02 00:33:42 +00001725 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001726 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001727 logger.Errorw(ctx, "Cannot serialize VTFD set", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001728 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001729 return nil, err
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001730 }
1731
1732 omciRxCallbackPair := callbackPair{
1733 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001734 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001735 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001736 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001737 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001738 logger.Errorw(ctx, "Cannot send VTFD set", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001739 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001740 return nil, err
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001741 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001742 logger.Debug(ctx, "send VTFD-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001743 return meInstance, nil
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001744 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001745 logger.Errorw(ctx, "Cannot generate VTFD Instance", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001746 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001747 return nil, omciErr.GetError()
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001748}
1749
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001750func (oo *omciCC) sendCreateEvtocdVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001751 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001752 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001753 logger.Debugw(ctx, "send EVTOCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001754 "SequNo": strconv.FormatInt(int64(tid), 16),
1755 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1756
1757 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(params[0])
1758 if omciErr.GetError() == nil {
1759 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
1760 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001761 logger.Errorw(ctx, "Cannot encode EVTOCD for create", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001762 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001763 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001764 }
1765
dbainbri4d3a0dc2020-12-02 00:33:42 +00001766 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001767 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001768 logger.Errorw(ctx, "Cannot serialize EVTOCD create", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001769 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001770 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001771 }
1772
1773 omciRxCallbackPair := callbackPair{
1774 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001775 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001776 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001777 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001778 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001779 logger.Errorw(ctx, "Cannot send EVTOCD create", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001780 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001781 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001782 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001783 logger.Debug(ctx, "send EVTOCD-set msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001784 return meInstance, nil
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001785 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001786 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001787 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001788 return nil, omciErr.GetError()
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001789}
1790
Himani Chawla6d2ae152020-09-02 13:11:20 +05301791func (oo *omciCC) sendSetEvtocdVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001792 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301793 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001794 logger.Debugw(ctx, "send EVTOCD-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00001795 "SequNo": strconv.FormatInt(int64(tid), 16),
1796 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1797
1798 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(params[0])
1799 if omciErr.GetError() == nil {
1800 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1801 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001802 logger.Errorw(ctx, "Cannot encode EVTOCD for set", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001803 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001804 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001805 }
1806
dbainbri4d3a0dc2020-12-02 00:33:42 +00001807 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenkodff5dda2020-08-28 11:52:01 +00001808 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001809 logger.Errorw(ctx, "Cannot serialize EVTOCD set", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001810 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001811 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001812 }
1813
Himani Chawla6d2ae152020-09-02 13:11:20 +05301814 omciRxCallbackPair := callbackPair{
mpagenkodff5dda2020-08-28 11:52:01 +00001815 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001816 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenkodff5dda2020-08-28 11:52:01 +00001817 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001818 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenkodff5dda2020-08-28 11:52:01 +00001819 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001820 logger.Errorw(ctx, "Cannot send EVTOCD set", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001821 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001822 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001823 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001824 logger.Debug(ctx, "send EVTOCD-set msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001825 return meInstance, nil
mpagenkodff5dda2020-08-28 11:52:01 +00001826 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001827 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001828 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001829 return nil, omciErr.GetError()
mpagenkodff5dda2020-08-28 11:52:01 +00001830}
mpagenko01e726e2020-10-23 09:45:29 +00001831
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001832func (oo *omciCC) sendDeleteEvtocd(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001833 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001834 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001835 logger.Debugw(ctx, "send EVTOCD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001836 "SequNo": strconv.FormatInt(int64(tid), 16),
1837 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1838
1839 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(params[0])
1840 if omciErr.GetError() == nil {
1841 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid))
1842 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001843 logger.Errorw(ctx, "Cannot encode EVTOCD for delete", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001844 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001845 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001846 }
1847
dbainbri4d3a0dc2020-12-02 00:33:42 +00001848 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001849 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001850 logger.Errorw(ctx, "Cannot serialize EVTOCD delete", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001851 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001852 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001853 }
1854
1855 omciRxCallbackPair := callbackPair{
1856 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001857 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001858 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001859 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001860 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001861 logger.Errorw(ctx, "Cannot send EVTOCD delete", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001862 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001863 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001864 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001865 logger.Debug(ctx, "send EVTOCD-delete msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001866 return meInstance, nil
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001867 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001868 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001869 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001870 return nil, omciErr.GetError()
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001871}
1872
mpagenko01e726e2020-10-23 09:45:29 +00001873func (oo *omciCC) sendDeleteVtfd(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001874 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
mpagenko01e726e2020-10-23 09:45:29 +00001875 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001876 logger.Debugw(ctx, "send VTFD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko01e726e2020-10-23 09:45:29 +00001877 "SequNo": strconv.FormatInt(int64(tid), 16),
1878 "InstId": strconv.FormatInt(int64(aInstID), 16)})
1879
1880 meParams := me.ParamData{EntityID: aInstID}
1881 meInstance, omciErr := me.NewVlanTaggingFilterData(meParams)
1882 if omciErr.GetError() == nil {
1883 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
1884 omci.TransactionID(tid))
1885 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001886 logger.Errorw(ctx, "Cannot encode VTFD for delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001887 "Err": err, "device-id": oo.deviceID})
1888 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1889 // return (dual format) error code that can be used at caller for immediate error treatment
1890 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03001891 return nil, err
mpagenko01e726e2020-10-23 09:45:29 +00001892 }
1893
dbainbri4d3a0dc2020-12-02 00:33:42 +00001894 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko01e726e2020-10-23 09:45:29 +00001895 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001896 logger.Errorw(ctx, "Cannot serialize VTFD delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001897 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001898 return nil, err
mpagenko01e726e2020-10-23 09:45:29 +00001899 }
1900
1901 omciRxCallbackPair := callbackPair{
1902 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001903 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko01e726e2020-10-23 09:45:29 +00001904 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001905 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko01e726e2020-10-23 09:45:29 +00001906 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001907 logger.Errorw(ctx, "Cannot send VTFD delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001908 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001909 return nil, err
mpagenko01e726e2020-10-23 09:45:29 +00001910 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001911 logger.Debug(ctx, "send VTFD-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001912 return meInstance, nil
mpagenko01e726e2020-10-23 09:45:29 +00001913 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001914 logger.Errorw(ctx, "Cannot generate VTFD Instance for delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001915 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001916 return nil, omciErr.GetError()
mpagenko01e726e2020-10-23 09:45:29 +00001917}
ozgecanetsia422dbf32020-10-28 14:07:19 +03001918
ozgecanetsiab6441962021-03-10 10:58:48 +03001919// nolint: unused
1920func (oo *omciCC) sendCreateTDVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001921 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsiab6441962021-03-10 10:58:48 +03001922 tid := oo.getNextTid(highPrio)
1923 logger.Debugw(ctx, "send TD-Create-msg:", log.Fields{"device-id": oo.deviceID,
1924 "SequNo": strconv.FormatInt(int64(tid), 16),
1925 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1926 meInstance, omciErr := me.NewTrafficDescriptor(params[0])
1927 if omciErr.GetError() == nil {
1928 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
1929 if err != nil {
1930 logger.Errorw(ctx, "Cannot encode TD for create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001931 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001932 }
1933 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
1934 if err != nil {
1935 logger.Errorw(ctx, "Cannot serialize TD create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001936 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001937 }
1938 omciRxCallbackPair := callbackPair{
1939 cbKey: tid,
1940 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
1941 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001942 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab6441962021-03-10 10:58:48 +03001943 if err != nil {
1944 logger.Errorw(ctx, "Cannot send TD create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001945 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001946 }
1947 logger.Debug(ctx, "send TD-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001948 return meInstance, nil
ozgecanetsiab6441962021-03-10 10:58:48 +03001949 }
1950 logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001951 return nil, omciErr.GetError()
ozgecanetsiab6441962021-03-10 10:58:48 +03001952}
1953
1954// nolint: unused
1955func (oo *omciCC) sendSetTDVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001956 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsiab6441962021-03-10 10:58:48 +03001957 tid := oo.getNextTid(highPrio)
1958 logger.Debugw(ctx, "send TD-Set-msg:", log.Fields{"device-id": oo.deviceID,
1959 "SequNo": strconv.FormatInt(int64(tid), 16),
1960 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1961
1962 meInstance, omciErr := me.NewTrafficDescriptor(params[0])
1963 if omciErr.GetError() == nil {
1964 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1965 if err != nil {
1966 logger.Errorw(ctx, "Cannot encode TD for set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001967 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001968 }
1969 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
1970 if err != nil {
1971 logger.Errorw(ctx, "Cannot serialize TD set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001972 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001973 }
1974 omciRxCallbackPair := callbackPair{
1975 cbKey: tid,
1976 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
1977 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001978 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab6441962021-03-10 10:58:48 +03001979 if err != nil {
1980 logger.Errorw(ctx, "Cannot send TD set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001981 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001982 }
1983 logger.Debug(ctx, "send TD-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001984 return meInstance, nil
ozgecanetsiab6441962021-03-10 10:58:48 +03001985 }
1986 logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001987 return nil, omciErr.GetError()
ozgecanetsiab6441962021-03-10 10:58:48 +03001988
1989}
1990
1991// nolint: unused
1992func (oo *omciCC) sendDeleteTD(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001993 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
ozgecanetsiab6441962021-03-10 10:58:48 +03001994 tid := oo.getNextTid(highPrio)
1995 logger.Debugw(ctx, "send TD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
1996 "SequNo": strconv.FormatInt(int64(tid), 16),
1997 "InstId": strconv.FormatInt(int64(aInstID), 16)})
1998
1999 meParams := me.ParamData{EntityID: aInstID}
2000 meInstance, omciErr := me.NewTrafficDescriptor(meParams)
2001 if omciErr.GetError() == nil {
2002 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid))
2003 if err != nil {
2004 logger.Errorw(ctx, "Cannot encode TD for delete", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002005 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03002006 }
2007 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
2008 if err != nil {
2009 logger.Errorw(ctx, "Cannot serialize TD delete", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002010 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03002011 }
2012 omciRxCallbackPair := callbackPair{
2013 cbKey: tid,
2014 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2015 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002016 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab6441962021-03-10 10:58:48 +03002017 if err != nil {
2018 logger.Errorw(ctx, "Cannot send TD delete", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002019 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03002020 }
2021 logger.Debug(ctx, "send TD-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002022 return meInstance, nil
ozgecanetsiab6441962021-03-10 10:58:48 +03002023 }
2024 logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002025 return nil, omciErr.GetError()
ozgecanetsiab6441962021-03-10 10:58:48 +03002026
2027}
2028
mpagenko8b07c1b2020-11-26 10:36:31 +00002029func (oo *omciCC) sendDeleteGemIWTP(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002030 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
mpagenko8b07c1b2020-11-26 10:36:31 +00002031 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002032 logger.Debugw(ctx, "send GemIwTp-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00002033 "SequNo": strconv.FormatInt(int64(tid), 16),
2034 "InstId": strconv.FormatInt(int64(aInstID), 16)})
2035
2036 meParams := me.ParamData{EntityID: aInstID}
2037 meInstance, omciErr := me.NewGemInterworkingTerminationPoint(meParams)
2038 if omciErr.GetError() == nil {
2039 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
2040 omci.TransactionID(tid))
2041 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002042 logger.Errorw(ctx, "Cannot encode GemIwTp for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002043 "Err": err, "device-id": oo.deviceID})
2044 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
2045 // return (dual format) error code that can be used at caller for immediate error treatment
2046 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03002047 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002048 }
2049
dbainbri4d3a0dc2020-12-02 00:33:42 +00002050 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00002051 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002052 logger.Errorw(ctx, "Cannot serialize GemIwTp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002053 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002054 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002055 }
2056
2057 omciRxCallbackPair := callbackPair{
2058 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002059 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko8b07c1b2020-11-26 10:36:31 +00002060 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002061 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko8b07c1b2020-11-26 10:36:31 +00002062 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002063 logger.Errorw(ctx, "Cannot send GemIwTp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002064 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002065 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002066 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002067 logger.Debug(ctx, "send GemIwTp-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002068 return meInstance, nil
mpagenko8b07c1b2020-11-26 10:36:31 +00002069 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002070 logger.Errorw(ctx, "Cannot generate GemIwTp Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002071 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002072 return nil, omciErr.GetError()
mpagenko8b07c1b2020-11-26 10:36:31 +00002073}
2074
2075func (oo *omciCC) sendDeleteGemNCTP(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002076 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
mpagenko8b07c1b2020-11-26 10:36:31 +00002077 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002078 logger.Debugw(ctx, "send GemNCtp-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00002079 "SequNo": strconv.FormatInt(int64(tid), 16),
2080 "InstId": strconv.FormatInt(int64(aInstID), 16)})
2081
2082 meParams := me.ParamData{EntityID: aInstID}
2083 meInstance, omciErr := me.NewGemPortNetworkCtp(meParams)
2084 if omciErr.GetError() == nil {
2085 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
2086 omci.TransactionID(tid))
2087 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002088 logger.Errorw(ctx, "Cannot encode GemNCtp for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002089 "Err": err, "device-id": oo.deviceID})
2090 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
2091 // return (dual format) error code that can be used at caller for immediate error treatment
2092 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03002093 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002094 }
2095
dbainbri4d3a0dc2020-12-02 00:33:42 +00002096 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00002097 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002098 logger.Errorw(ctx, "Cannot serialize GemNCtp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002099 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002100 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002101 }
2102
2103 omciRxCallbackPair := callbackPair{
2104 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002105 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko8b07c1b2020-11-26 10:36:31 +00002106 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002107 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko8b07c1b2020-11-26 10:36:31 +00002108 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002109 logger.Errorw(ctx, "Cannot send GemNCtp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002110 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002111 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002112 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002113 logger.Debug(ctx, "send GemNCtp-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002114 return meInstance, nil
mpagenko8b07c1b2020-11-26 10:36:31 +00002115 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002116 logger.Errorw(ctx, "Cannot generate GemNCtp Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002117 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002118 return nil, omciErr.GetError()
mpagenko8b07c1b2020-11-26 10:36:31 +00002119}
2120
2121func (oo *omciCC) sendDeleteDot1PMapper(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002122 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
mpagenko8b07c1b2020-11-26 10:36:31 +00002123 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002124 logger.Debugw(ctx, "send .1pMapper-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00002125 "SequNo": strconv.FormatInt(int64(tid), 16),
2126 "InstId": strconv.FormatInt(int64(aInstID), 16)})
2127
2128 meParams := me.ParamData{EntityID: aInstID}
2129 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(meParams)
2130 if omciErr.GetError() == nil {
2131 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
2132 omci.TransactionID(tid))
2133 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002134 logger.Errorw(ctx, "Cannot encode .1pMapper for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002135 "Err": err, "device-id": oo.deviceID})
2136 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
2137 // return (dual format) error code that can be used at caller for immediate error treatment
2138 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03002139 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002140 }
2141
dbainbri4d3a0dc2020-12-02 00:33:42 +00002142 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00002143 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002144 logger.Errorw(ctx, "Cannot serialize .1pMapper delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002145 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002146 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002147 }
2148
2149 omciRxCallbackPair := callbackPair{
2150 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002151 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko8b07c1b2020-11-26 10:36:31 +00002152 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002153 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko8b07c1b2020-11-26 10:36:31 +00002154 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002155 logger.Errorw(ctx, "Cannot send .1pMapper delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002156 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002157 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002158 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002159 logger.Debug(ctx, "send .1pMapper-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002160 return meInstance, nil
mpagenko8b07c1b2020-11-26 10:36:31 +00002161 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002162 logger.Errorw(ctx, "Cannot generate .1pMapper Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002163 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002164 return nil, omciErr.GetError()
mpagenko8b07c1b2020-11-26 10:36:31 +00002165}
2166
2167func (oo *omciCC) sendDeleteMBPConfigData(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002168 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
mpagenko8b07c1b2020-11-26 10:36:31 +00002169 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002170 logger.Debugw(ctx, "send MBPCD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00002171 "SequNo": strconv.FormatInt(int64(tid), 16),
2172 "InstId": strconv.FormatInt(int64(aInstID), 16)})
2173
2174 meParams := me.ParamData{EntityID: aInstID}
2175 meInstance, omciErr := me.NewMacBridgePortConfigurationData(meParams)
2176 if omciErr.GetError() == nil {
2177 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
2178 omci.TransactionID(tid))
2179 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002180 logger.Errorw(ctx, "Cannot encode MBPCD for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002181 "Err": err, "device-id": oo.deviceID})
2182 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
2183 // return (dual format) error code that can be used at caller for immediate error treatment
2184 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03002185 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002186 }
2187
dbainbri4d3a0dc2020-12-02 00:33:42 +00002188 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00002189 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002190 logger.Errorw(ctx, "Cannot serialize MBPCD delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002191 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002192 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002193 }
2194
2195 omciRxCallbackPair := callbackPair{
2196 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002197 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko8b07c1b2020-11-26 10:36:31 +00002198 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002199 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko8b07c1b2020-11-26 10:36:31 +00002200 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002201 logger.Errorw(ctx, "Cannot send MBPCD delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002202 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002203 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002204 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002205 logger.Debug(ctx, "send MBPCD-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002206 return meInstance, nil
mpagenko8b07c1b2020-11-26 10:36:31 +00002207 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002208 logger.Errorw(ctx, "Cannot generate MBPCD Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002209 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002210 return nil, omciErr.GetError()
mpagenko8b07c1b2020-11-26 10:36:31 +00002211}
2212
ozgecanetsia422dbf32020-10-28 14:07:19 +03002213func (oo *omciCC) sendCreateMulticastGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002214 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsia422dbf32020-10-28 14:07:19 +03002215 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002216 logger.Debugw(ctx, "send MulticastGemIWTP-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002217 "SequNo": strconv.FormatInt(int64(tid), 16),
2218 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2219
2220 meInstance, omciErr := me.NewMulticastGemInterworkingTerminationPoint(params[0])
2221 if omciErr.GetError() == nil {
2222 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2223 omci.AddDefaults(true))
2224 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002225 logger.Errorw(ctx, "Cannot encode MulticastGEMIWTP for create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002226 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002227 }
2228
dbainbri4d3a0dc2020-12-02 00:33:42 +00002229 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002230 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002231 logger.Errorw(ctx, "Cannot serialize MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002232 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002233 }
2234
2235 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002236 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsia422dbf32020-10-28 14:07:19 +03002237 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002238 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002239 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002240 logger.Errorw(ctx, "Cannot send MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002241 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002242 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002243 logger.Debug(ctx, "send MulticastGEMIWTP-create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002244 return meInstance, nil
ozgecanetsia422dbf32020-10-28 14:07:19 +03002245 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002246 logger.Errorw(ctx, "Cannot generate MulticastGEMIWTP Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03002247 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002248 return nil, omciErr.GetError()
ozgecanetsia422dbf32020-10-28 14:07:19 +03002249}
2250
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002251func (oo *omciCC) sendSetMulticastGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002252 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002253 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002254 logger.Debugw(ctx, "send MulticastGemIWTP-set-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002255 "SequNo": strconv.FormatInt(int64(tid), 16),
2256 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2257
2258 meInstance, omciErr := me.NewMulticastGemInterworkingTerminationPoint(params[0])
2259 if omciErr.GetError() == nil {
2260 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid),
2261 omci.AddDefaults(true))
2262 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002263 logger.Errorw(ctx, "Cannot encode MulticastGEMIWTP for set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002264 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002265 }
2266
dbainbri4d3a0dc2020-12-02 00:33:42 +00002267 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002268 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002269 logger.Errorw(ctx, "Cannot serialize MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002270 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002271 }
2272
2273 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002274 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002275 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002276 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002277 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002278 logger.Errorw(ctx, "Cannot send MulticastGEMIWTP set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002279 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002280 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002281 logger.Debug(ctx, "send MulticastGEMIWTP-set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002282 return meInstance, nil
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002283 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002284 logger.Errorw(ctx, "Cannot generate MulticastGEMIWTP Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002285 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002286 return nil, omciErr.GetError()
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002287}
2288
ozgecanetsia422dbf32020-10-28 14:07:19 +03002289func (oo *omciCC) sendCreateMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002290 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsia422dbf32020-10-28 14:07:19 +03002291 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002292 logger.Debugw(ctx, "send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002293 "SequNo": strconv.FormatInt(int64(tid), 16),
2294 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2295
2296 meInstance, omciErr := me.NewMulticastOperationsProfile(params[0])
2297 if omciErr.GetError() == nil {
2298 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2299 omci.AddDefaults(true))
2300 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002301 logger.Errorw(ctx, "Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002302 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002303 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002304 }
2305
dbainbri4d3a0dc2020-12-02 00:33:42 +00002306 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002307 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002308 logger.Errorw(ctx, "Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002309 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002310 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002311 }
2312
2313 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002314 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsia422dbf32020-10-28 14:07:19 +03002315 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002316 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002317 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002318 logger.Errorw(ctx, "Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002319 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002320 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002321 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002322 logger.Debug(ctx, "send MulticastOperationProfile-create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002323 return meInstance, nil
ozgecanetsia422dbf32020-10-28 14:07:19 +03002324 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002325 logger.Errorw(ctx, "Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03002326 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002327 return nil, omciErr.GetError()
ozgecanetsia422dbf32020-10-28 14:07:19 +03002328}
2329
2330func (oo *omciCC) sendSetMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002331 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsia422dbf32020-10-28 14:07:19 +03002332 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002333 logger.Debugw(ctx, "send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002334 "SequNo": strconv.FormatInt(int64(tid), 16),
2335 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2336
2337 meInstance, omciErr := me.NewMulticastOperationsProfile(params[0])
2338 if omciErr.GetError() == nil {
2339 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid),
2340 omci.AddDefaults(true))
2341 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002342 logger.Errorw(ctx, "Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002343 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002344 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002345 }
2346
dbainbri4d3a0dc2020-12-02 00:33:42 +00002347 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002348 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002349 logger.Errorw(ctx, "Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002350 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002351 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002352 }
2353
2354 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002355 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsia422dbf32020-10-28 14:07:19 +03002356 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002357 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002358 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002359 logger.Errorw(ctx, "Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002360 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002361 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002362 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002363 logger.Debug(ctx, "send MulticastOperationProfile-create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002364 return meInstance, nil
ozgecanetsia422dbf32020-10-28 14:07:19 +03002365 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002366 logger.Errorw(ctx, "Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03002367 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002368 return nil, omciErr.GetError()
ozgecanetsia422dbf32020-10-28 14:07:19 +03002369}
2370
2371func (oo *omciCC) sendCreateMulticastSubConfigInfoVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002372 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsia422dbf32020-10-28 14:07:19 +03002373 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002374 logger.Debugw(ctx, "send MulticastSubConfigInfo-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002375 "SequNo": strconv.FormatInt(int64(tid), 16),
2376 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2377
2378 meInstance, omciErr := me.NewMulticastSubscriberConfigInfo(params[0])
2379 if omciErr.GetError() == nil {
2380 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2381 omci.AddDefaults(true))
2382 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002383 logger.Errorw(ctx, "Cannot encode MulticastSubConfigInfo for create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002384 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002385 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002386 }
2387
dbainbri4d3a0dc2020-12-02 00:33:42 +00002388 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002389 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002390 logger.Errorw(ctx, "Cannot serialize MulticastSubConfigInfo create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002391 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002392 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002393 }
2394
2395 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002396 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsia422dbf32020-10-28 14:07:19 +03002397 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002398 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002399 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002400 logger.Errorw(ctx, "Cannot send MulticastSubConfigInfo create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002401 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002402 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002403 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002404 logger.Debug(ctx, "send MulticastSubConfigInfo-create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002405 return meInstance, nil
ozgecanetsia422dbf32020-10-28 14:07:19 +03002406 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002407 logger.Errorw(ctx, "Cannot generate MulticastSubConfigInfo Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03002408 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002409 return nil, omciErr.GetError()
ozgecanetsia422dbf32020-10-28 14:07:19 +03002410}
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +00002411
Girish Gowdrae0140f02021-02-02 16:55:09 -08002412func (oo *omciCC) sendSyncTime(ctx context.Context, timeout int, highPrio bool, rxChan chan Message) error {
2413 tid := oo.getNextTid(highPrio)
2414 logger.Debugw(ctx, "send synchronize time request:", log.Fields{"device-id": oo.deviceID,
2415 "SequNo": strconv.FormatInt(int64(tid), 16)})
2416
2417 omciLayer := &omci.OMCI{
2418 TransactionID: tid,
2419 MessageType: omci.SynchronizeTimeRequestType,
2420 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2421 // Length: 0x28, // Optional, defaults to 40 octets
2422 }
2423 utcTime := time.Now().UTC()
2424 request := &omci.SynchronizeTimeRequest{
2425 MeBasePacket: omci.MeBasePacket{
2426 EntityClass: me.OnuGClassID,
2427 // Default Instance ID is 0
2428 },
2429 Year: uint16(utcTime.Year()),
2430 Month: uint8(utcTime.Month()),
2431 Day: uint8(utcTime.Day()),
2432 Hour: uint8(utcTime.Hour()),
2433 Minute: uint8(utcTime.Minute()),
2434 Second: uint8(utcTime.Second()),
2435 }
2436
2437 pkt, err := serializeOmciLayer(ctx, omciLayer, request)
2438 if err != nil {
2439 logger.Errorw(ctx, "Cannot serialize synchronize time request", log.Fields{"Err": err,
2440 "device-id": oo.deviceID})
2441 return err
2442 }
2443
2444 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002445 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Girish Gowdrae0140f02021-02-02 16:55:09 -08002446 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002447 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Girish Gowdrae0140f02021-02-02 16:55:09 -08002448 if err != nil {
2449 logger.Errorw(ctx, "Cannot send synchronize time request", log.Fields{"Err": err,
2450 "device-id": oo.deviceID})
2451 return err
2452 }
2453 logger.Debug(ctx, "send synchronize time request done")
2454 return nil
2455}
2456
2457func (oo *omciCC) sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002458 upstream bool, create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
Girish Gowdrae0140f02021-02-02 16:55:09 -08002459 tid := oo.getNextTid(highPrio)
2460 logger.Debugw(ctx, "send ethernet-performance-monitoring-history-me-msg:", log.Fields{"device-id": oo.deviceID,
2461 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create, "upstream": upstream})
2462 meParam := me.ParamData{EntityID: entityID}
2463 var meInstance *me.ManagedEntity
2464 var omciErr me.OmciErrors
2465 if upstream {
2466 meInstance, omciErr = me.NewEthernetFramePerformanceMonitoringHistoryDataUpstream(meParam)
2467 } else {
2468 meInstance, omciErr = me.NewEthernetFramePerformanceMonitoringHistoryDataDownstream(meParam)
2469 }
2470 if omciErr.GetError() == nil {
2471 var omciLayer *omci.OMCI
2472 var msgLayer gopacket.SerializableLayer
2473 var err error
2474 if create {
2475 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2476 omci.AddDefaults(true))
2477 } else {
2478 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid),
2479 omci.AddDefaults(true))
2480 }
2481 if err != nil {
2482 logger.Errorw(ctx, "Cannot encode ethernet frame performance monitoring history data ME",
2483 log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002484 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002485 }
2486
2487 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
2488 if err != nil {
2489 logger.Errorw(ctx, "Cannot serialize ethernet frame performance monitoring history data ME",
2490 log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002491 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002492 }
2493
2494 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002495 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Girish Gowdrae0140f02021-02-02 16:55:09 -08002496 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002497 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Girish Gowdrae0140f02021-02-02 16:55:09 -08002498 if err != nil {
2499 logger.Errorw(ctx, "Cannot send ethernet frame performance monitoring history data ME",
2500 log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002501 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002502 }
2503 logger.Debugw(ctx, "send ethernet frame performance monitoring history data ME done",
2504 log.Fields{"device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002505 return meInstance, nil
Girish Gowdrae0140f02021-02-02 16:55:09 -08002506 }
2507 logger.Errorw(ctx, "Cannot generate ethernet frame performance monitoring history data ME Instance",
2508 log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002509 return nil, omciErr.GetError()
Girish Gowdrae0140f02021-02-02 16:55:09 -08002510}
2511
2512func (oo *omciCC) sendCreateOrDeleteEthernetUniHistoryME(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002513 create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
Girish Gowdrae0140f02021-02-02 16:55:09 -08002514 tid := oo.getNextTid(highPrio)
2515 logger.Debugw(ctx, "send ethernet-uni-history-me-msg:", log.Fields{"device-id": oo.deviceID,
2516 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
2517 meParam := me.ParamData{EntityID: entityID}
2518 var meInstance *me.ManagedEntity
2519 var omciErr me.OmciErrors
2520 meInstance, omciErr = me.NewEthernetPerformanceMonitoringHistoryData(meParam)
2521
2522 if omciErr.GetError() == nil {
2523 var omciLayer *omci.OMCI
2524 var msgLayer gopacket.SerializableLayer
2525 var err error
2526 if create {
2527 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2528 omci.AddDefaults(true))
2529 } else {
2530 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid),
2531 omci.AddDefaults(true))
2532 }
2533 if err != nil {
2534 logger.Errorw(ctx, "Cannot encode ethernet uni history data ME",
2535 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002536 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002537 }
2538
2539 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
2540 if err != nil {
2541 logger.Errorw(ctx, "Cannot serialize ethernet uni history data ME",
2542 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002543 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002544 }
2545
2546 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002547 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Girish Gowdrae0140f02021-02-02 16:55:09 -08002548 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002549 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Girish Gowdrae0140f02021-02-02 16:55:09 -08002550 if err != nil {
2551 logger.Errorw(ctx, "Cannot send ethernet uni history data ME",
2552 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002553 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002554 }
2555 logger.Debugw(ctx, "send ethernet uni history data ME done",
2556 log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002557 return meInstance, nil
Girish Gowdrae0140f02021-02-02 16:55:09 -08002558 }
2559 logger.Errorw(ctx, "Cannot generate ethernet uni history data ME Instance",
2560 log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002561 return nil, omciErr.GetError()
Girish Gowdrae0140f02021-02-02 16:55:09 -08002562}
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002563
2564func (oo *omciCC) sendCreateOrDeleteFecHistoryME(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002565 create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002566 tid := oo.getNextTid(highPrio)
2567 logger.Debugw(ctx, "send fec-history-me-msg:", log.Fields{"device-id": oo.deviceID,
2568 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
2569 meParam := me.ParamData{EntityID: entityID}
2570 var meInstance *me.ManagedEntity
2571 var omciErr me.OmciErrors
2572 meInstance, omciErr = me.NewFecPerformanceMonitoringHistoryData(meParam)
2573
2574 if omciErr.GetError() == nil {
2575 var omciLayer *omci.OMCI
2576 var msgLayer gopacket.SerializableLayer
2577 var err error
2578 if create {
2579 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2580 omci.AddDefaults(true))
2581 } else {
2582 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid),
2583 omci.AddDefaults(true))
2584 }
2585 if err != nil {
2586 logger.Errorw(ctx, "Cannot encode fec history data ME",
2587 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002588 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002589 }
2590
2591 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
2592 if err != nil {
2593 logger.Errorw(ctx, "Cannot serialize fec history data ME",
2594 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002595 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002596 }
2597
2598 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002599 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002600 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002601 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002602 if err != nil {
2603 logger.Errorw(ctx, "Cannot send fec history data ME",
2604 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002605 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002606 }
2607 logger.Debugw(ctx, "send fec history data ME done",
2608 log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002609 return meInstance, nil
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002610 }
2611 logger.Errorw(ctx, "Cannot generate fec history data ME Instance",
2612 log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002613 return nil, omciErr.GetError()
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002614}
2615
2616func (oo *omciCC) sendCreateOrDeleteGemPortHistoryME(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002617 create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002618 tid := oo.getNextTid(highPrio)
2619 logger.Debugw(ctx, "send gemport-history-me-msg:", log.Fields{"device-id": oo.deviceID,
2620 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
2621 meParam := me.ParamData{EntityID: entityID}
2622 var meInstance *me.ManagedEntity
2623 var omciErr me.OmciErrors
2624 meInstance, omciErr = me.NewGemPortNetworkCtpPerformanceMonitoringHistoryData(meParam)
2625
2626 if omciErr.GetError() == nil {
2627 var omciLayer *omci.OMCI
2628 var msgLayer gopacket.SerializableLayer
2629 var err error
2630 if create {
2631 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2632 omci.AddDefaults(true))
2633 } else {
2634 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid),
2635 omci.AddDefaults(true))
2636 }
2637 if err != nil {
2638 logger.Errorw(ctx, "Cannot encode gemport history data ME",
2639 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002640 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002641 }
2642
2643 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
2644 if err != nil {
2645 logger.Errorw(ctx, "Cannot serialize gemport history data ME",
2646 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002647 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002648 }
2649
2650 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002651 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002652 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002653 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002654 if err != nil {
2655 logger.Errorw(ctx, "Cannot send gemport history data ME",
2656 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002657 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002658 }
2659 logger.Debugw(ctx, "send gemport history data ME done",
2660 log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002661 return meInstance, nil
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002662 }
2663 logger.Errorw(ctx, "Cannot generate gemport history data ME Instance",
2664 log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002665 return nil, omciErr.GetError()
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002666}
2667
mpagenko80622a52021-02-09 16:53:23 +00002668func (oo *omciCC) sendStartSoftwareDownload(ctx context.Context, timeout int, highPrio bool,
2669 rxChan chan Message, aImageMeID uint16, aDownloadWindowSize uint8, aFileLen uint32) error {
2670 tid := oo.getNextTid(highPrio)
2671 logger.Debugw(ctx, "send StartSwDlRequest:", log.Fields{"device-id": oo.deviceID,
2672 "SequNo": strconv.FormatInt(int64(tid), 16),
2673 "InstId": strconv.FormatInt(int64(aImageMeID), 16)})
2674
2675 omciLayer := &omci.OMCI{
2676 TransactionID: tid,
2677 MessageType: omci.StartSoftwareDownloadRequestType,
2678 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2679 // Length: 0x28, // Optional, defaults to 40 octets
2680 }
2681 request := &omci.StartSoftwareDownloadRequest{
2682 MeBasePacket: omci.MeBasePacket{
2683 EntityClass: me.SoftwareImageClassID,
2684 EntityInstance: aImageMeID, //inactive image
2685 },
2686 WindowSize: aDownloadWindowSize,
2687 ImageSize: aFileLen,
2688 NumberOfCircuitPacks: 1, //parallel download to multiple circuit packs not supported
2689 CircuitPacks: []uint16{0}, //circuit pack indication don't care for NumberOfCircuitPacks=1, but needed by omci-lib
2690 }
2691
2692 var options gopacket.SerializeOptions
2693 options.FixLengths = true
2694 buffer := gopacket.NewSerializeBuffer()
2695 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2696 if err != nil {
2697 logger.Errorw(ctx, "Cannot serialize StartSwDlRequest", log.Fields{"Err": err,
2698 "device-id": oo.deviceID})
2699 return err
2700 }
2701 outgoingPacket := buffer.Bytes()
2702
2703 omciRxCallbackPair := callbackPair{cbKey: tid,
2704 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2705 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002706 err = oo.send(ctx, outgoingPacket, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko80622a52021-02-09 16:53:23 +00002707 if err != nil {
2708 logger.Errorw(ctx, "Cannot send StartSwDlRequest", log.Fields{"Err": err,
2709 "device-id": oo.deviceID})
2710 return err
2711 }
2712 logger.Debug(ctx, "send StartSwDlRequest done")
mpagenko80622a52021-02-09 16:53:23 +00002713 return nil
2714}
2715
mpagenkoc26d4c02021-05-06 14:27:57 +00002716func (oo *omciCC) sendDownloadSection(ctx context.Context, aTimeout int, highPrio bool,
mpagenko80622a52021-02-09 16:53:23 +00002717 rxChan chan Message, aImageMeID uint16, aAckRequest uint8, aDownloadSectionNo uint8, aSection []byte, aPrint bool) error {
2718 tid := oo.getNextTid(highPrio)
2719 logger.Debugw(ctx, "send DlSectionRequest:", log.Fields{"device-id": oo.deviceID,
2720 "SequNo": strconv.FormatInt(int64(tid), 16),
mpagenko15ff4a52021-03-02 10:09:20 +00002721 "InstId": strconv.FormatInt(int64(aImageMeID), 16), "omci-ack": aAckRequest})
mpagenko80622a52021-02-09 16:53:23 +00002722
2723 //TODO!!!: don't know by now on how to generate the possibly needed AR (or enforce it to 0) with current omci-lib
2724 // by now just try to send it as defined by omci-lib
mpagenko15ff4a52021-03-02 10:09:20 +00002725 msgType := omci.DownloadSectionRequestType
mpagenkoc26d4c02021-05-06 14:27:57 +00002726 var timeout int = 0 //default value for no response expected
mpagenko15ff4a52021-03-02 10:09:20 +00002727 if aAckRequest > 0 {
2728 msgType = omci.DownloadSectionRequestWithResponseType
mpagenkoc26d4c02021-05-06 14:27:57 +00002729 timeout = aTimeout
mpagenko15ff4a52021-03-02 10:09:20 +00002730 }
mpagenko80622a52021-02-09 16:53:23 +00002731 omciLayer := &omci.OMCI{
2732 TransactionID: tid,
mpagenko15ff4a52021-03-02 10:09:20 +00002733 MessageType: msgType,
mpagenko80622a52021-02-09 16:53:23 +00002734 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2735 // Length: 0x28, // Optional, defaults to 40 octets
2736 }
Girish Gowdra8a7b4562021-02-23 16:27:42 -08002737 var localSectionData [31]byte
mpagenko15ff4a52021-03-02 10:09:20 +00002738 copy(localSectionData[:], aSection) // as long as DownloadSectionRequest defines array for SectionData we need to copy into the array
mpagenko80622a52021-02-09 16:53:23 +00002739 request := &omci.DownloadSectionRequest{
2740 MeBasePacket: omci.MeBasePacket{
2741 EntityClass: me.SoftwareImageClassID,
2742 EntityInstance: aImageMeID, //inactive image
2743 },
2744 SectionNumber: aDownloadSectionNo,
2745 SectionData: localSectionData,
2746 }
2747
2748 var options gopacket.SerializeOptions
2749 options.FixLengths = true
2750 buffer := gopacket.NewSerializeBuffer()
2751 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2752 if err != nil {
2753 logger.Errorw(ctx, "Cannot serialize DlSectionRequest", log.Fields{"Err": err,
2754 "device-id": oo.deviceID})
2755 return err
2756 }
2757 outgoingPacket := buffer.Bytes()
2758
mpagenko15ff4a52021-03-02 10:09:20 +00002759 //for initial debug purpose overrule the requested print state for some frames
2760 printFrame := aPrint
2761 if aAckRequest > 0 || aDownloadSectionNo == 0 {
2762 printFrame = true
2763 }
2764
mpagenko80622a52021-02-09 16:53:23 +00002765 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenkoc26d4c02021-05-06 14:27:57 +00002766 // the callback is set even though no response might be required here, the tid (key) setting is needed here anyway
2767 // (used to avoid retransmission of frames with the same TID)
mpagenko15ff4a52021-03-02 10:09:20 +00002768 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, printFrame /*aPrint*/},
mpagenko80622a52021-02-09 16:53:23 +00002769 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002770 err = oo.send(ctx, outgoingPacket, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko80622a52021-02-09 16:53:23 +00002771 if err != nil {
2772 logger.Errorw(ctx, "Cannot send DlSectionRequest", log.Fields{"Err": err,
2773 "device-id": oo.deviceID})
2774 return err
2775 }
2776 logger.Debug(ctx, "send DlSectionRequest done")
mpagenko80622a52021-02-09 16:53:23 +00002777 return nil
2778}
2779
2780func (oo *omciCC) sendEndSoftwareDownload(ctx context.Context, timeout int, highPrio bool,
2781 rxChan chan Message, aImageMeID uint16, aFileLen uint32, aImageCrc uint32) error {
2782 tid := oo.getNextTid(highPrio)
2783 logger.Debugw(ctx, "send EndSwDlRequest:", log.Fields{"device-id": oo.deviceID,
2784 "SequNo": strconv.FormatInt(int64(tid), 16),
2785 "InstId": strconv.FormatInt(int64(aImageMeID), 16)})
2786
mpagenko15ff4a52021-03-02 10:09:20 +00002787 omciLayer := &omci.OMCI{
mpagenko80622a52021-02-09 16:53:23 +00002788 TransactionID: tid,
mpagenko15ff4a52021-03-02 10:09:20 +00002789 MessageType: omci.EndSoftwareDownloadRequestType,
mpagenko80622a52021-02-09 16:53:23 +00002790 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2791 // Length: 0x28, // Optional, defaults to 40 octets
2792 }
mpagenko15ff4a52021-03-02 10:09:20 +00002793 request := &omci.EndSoftwareDownloadRequest{
mpagenko80622a52021-02-09 16:53:23 +00002794 MeBasePacket: omci.MeBasePacket{
2795 EntityClass: me.SoftwareImageClassID,
2796 EntityInstance: aImageMeID, //inactive image
2797 },
mpagenko15ff4a52021-03-02 10:09:20 +00002798 CRC32: aImageCrc,
2799 ImageSize: aFileLen,
2800 NumberOfInstances: 1, //parallel download to multiple circuit packs not supported
2801 ImageInstances: []uint16{0}, //don't care for NumberOfInstances=1, but probably needed by omci-lib as in startSwDlRequest
mpagenko80622a52021-02-09 16:53:23 +00002802 }
mpagenko15ff4a52021-03-02 10:09:20 +00002803
2804 var options gopacket.SerializeOptions
2805 options.FixLengths = true
2806 buffer := gopacket.NewSerializeBuffer()
2807 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2808 if err != nil {
2809 logger.Errorw(ctx, "Cannot serialize EndSwDlRequest", log.Fields{"Err": err,
mpagenko80622a52021-02-09 16:53:23 +00002810 "device-id": oo.deviceID})
mpagenko15ff4a52021-03-02 10:09:20 +00002811 return err
mpagenko80622a52021-02-09 16:53:23 +00002812 }
mpagenko15ff4a52021-03-02 10:09:20 +00002813 outgoingPacket := buffer.Bytes()
2814
2815 omciRxCallbackPair := callbackPair{cbKey: tid,
2816 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2817 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002818 err = oo.send(ctx, outgoingPacket, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko15ff4a52021-03-02 10:09:20 +00002819 if err != nil {
2820 logger.Errorw(ctx, "Cannot send EndSwDlRequest", log.Fields{"Err": err,
2821 "device-id": oo.deviceID})
2822 return err
2823 }
2824 logger.Debug(ctx, "send EndSwDlRequest done")
mpagenko80622a52021-02-09 16:53:23 +00002825 return nil
2826}
2827
2828func (oo *omciCC) sendActivateSoftware(ctx context.Context, timeout int, highPrio bool,
2829 rxChan chan Message, aImageMeID uint16) error {
2830 tid := oo.getNextTid(highPrio)
2831 logger.Debugw(ctx, "send ActivateSwRequest:", log.Fields{"device-id": oo.deviceID,
2832 "SequNo": strconv.FormatInt(int64(tid), 16),
2833 "InstId": strconv.FormatInt(int64(aImageMeID), 16)})
2834
2835 omciLayer := &omci.OMCI{
2836 TransactionID: tid,
2837 MessageType: omci.ActivateSoftwareRequestType,
2838 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2839 // Length: 0x28, // Optional, defaults to 40 octets
2840 }
2841 request := &omci.ActivateSoftwareRequest{
2842 MeBasePacket: omci.MeBasePacket{
2843 EntityClass: me.SoftwareImageClassID,
2844 EntityInstance: aImageMeID, //inactive image
2845 },
2846 ActivateFlags: 0, //unconditionally reset as the only relevant option here (regardless of VOIP)
2847 }
2848
2849 var options gopacket.SerializeOptions
2850 options.FixLengths = true
2851 buffer := gopacket.NewSerializeBuffer()
2852 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2853 if err != nil {
2854 logger.Errorw(ctx, "Cannot serialize ActivateSwRequest", log.Fields{"Err": err,
2855 "device-id": oo.deviceID})
2856 return err
2857 }
2858 outgoingPacket := buffer.Bytes()
2859
2860 omciRxCallbackPair := callbackPair{cbKey: tid,
2861 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2862 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002863 err = oo.send(ctx, outgoingPacket, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko80622a52021-02-09 16:53:23 +00002864 if err != nil {
2865 logger.Errorw(ctx, "Cannot send ActivateSwRequest", log.Fields{"Err": err,
2866 "device-id": oo.deviceID})
2867 return err
2868 }
2869 logger.Debug(ctx, "send ActivateSwRequest done")
mpagenko15ff4a52021-03-02 10:09:20 +00002870 return nil
2871}
mpagenko80622a52021-02-09 16:53:23 +00002872
mpagenko15ff4a52021-03-02 10:09:20 +00002873func (oo *omciCC) sendCommitSoftware(ctx context.Context, timeout int, highPrio bool,
2874 rxChan chan Message, aImageMeID uint16) error {
2875 tid := oo.getNextTid(highPrio)
2876 logger.Debugw(ctx, "send CommitSwRequest:", log.Fields{"device-id": oo.deviceID,
2877 "SequNo": strconv.FormatInt(int64(tid), 16),
2878 "InstId": strconv.FormatInt(int64(aImageMeID), 16)})
2879
2880 omciLayer := &omci.OMCI{
mpagenko80622a52021-02-09 16:53:23 +00002881 TransactionID: tid,
mpagenko15ff4a52021-03-02 10:09:20 +00002882 MessageType: omci.CommitSoftwareRequestType,
mpagenko80622a52021-02-09 16:53:23 +00002883 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2884 // Length: 0x28, // Optional, defaults to 40 octets
2885 }
mpagenko15ff4a52021-03-02 10:09:20 +00002886 request := &omci.CommitSoftwareRequest{
mpagenko80622a52021-02-09 16:53:23 +00002887 MeBasePacket: omci.MeBasePacket{
2888 EntityClass: me.SoftwareImageClassID,
2889 EntityInstance: aImageMeID, //inactive image
2890 },
mpagenko80622a52021-02-09 16:53:23 +00002891 }
mpagenko15ff4a52021-03-02 10:09:20 +00002892
2893 var options gopacket.SerializeOptions
2894 options.FixLengths = true
2895 buffer := gopacket.NewSerializeBuffer()
2896 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2897 if err != nil {
2898 logger.Errorw(ctx, "Cannot serialize CommitSwRequest", log.Fields{"Err": err,
mpagenko80622a52021-02-09 16:53:23 +00002899 "device-id": oo.deviceID})
mpagenko15ff4a52021-03-02 10:09:20 +00002900 return err
mpagenko80622a52021-02-09 16:53:23 +00002901 }
mpagenko15ff4a52021-03-02 10:09:20 +00002902 outgoingPacket := buffer.Bytes()
2903
2904 omciRxCallbackPair := callbackPair{cbKey: tid,
2905 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2906 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002907 err = oo.send(ctx, outgoingPacket, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko15ff4a52021-03-02 10:09:20 +00002908 if err != nil {
2909 logger.Errorw(ctx, "Cannot send CommitSwRequest", log.Fields{"Err": err,
2910 "device-id": oo.deviceID})
2911 return err
2912 }
2913 logger.Debug(ctx, "send CommitSwRequest done")
mpagenko80622a52021-02-09 16:53:23 +00002914 return nil
2915}
2916
Girish Gowdra6afb56a2021-04-27 17:47:57 -07002917func (oo *omciCC) sendSelfTestReq(ctx context.Context, classID me.ClassID, instdID uint16, timeout int, highPrio bool, rxChan chan Message) error {
2918 tid := oo.getNextTid(highPrio)
2919 logger.Debugw(ctx, "send self test request:", log.Fields{"device-id": oo.deviceID,
2920 "SequNo": strconv.FormatInt(int64(tid), 16),
2921 "InstId": strconv.FormatInt(int64(instdID), 16)})
2922 omciLayer := &omci.OMCI{
2923 TransactionID: tid,
2924 MessageType: omci.TestRequestType,
2925 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2926 // Length: 0x28, // Optional, defaults to 40 octets
2927 }
2928
2929 var request *omci.OpticalLineSupervisionTestRequest
2930 switch classID {
2931 case aniGClassID:
2932 request = &omci.OpticalLineSupervisionTestRequest{
2933 MeBasePacket: omci.MeBasePacket{
2934 EntityClass: classID,
2935 EntityInstance: instdID,
2936 },
2937 SelectTest: uint8(7), // self test
2938 GeneralPurposeBuffer: uint16(0),
2939 VendorSpecificParameters: uint16(0),
2940 }
2941 default:
2942 logger.Errorw(ctx, "unsupported class id for self test request", log.Fields{"device-id": oo.deviceID, "classID": classID})
2943 return fmt.Errorf("unsupported-class-id-for-self-test-request-%v", classID)
2944 }
2945 // Test serialization back to former string
2946 var options gopacket.SerializeOptions
2947 options.FixLengths = true
2948
2949 buffer := gopacket.NewSerializeBuffer()
2950 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2951 if err != nil {
2952 logger.Errorw(ctx, "Cannot serialize self test request", log.Fields{"Err": err,
2953 "device-id": oo.deviceID})
2954 return err
2955 }
2956 outgoingPacket := buffer.Bytes()
2957
2958 omciRxCallbackPair := callbackPair{cbKey: tid,
2959 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2960 }
2961 err = oo.send(ctx, outgoingPacket, timeout, 0, highPrio, omciRxCallbackPair)
2962 if err != nil {
2963 logger.Errorw(ctx, "Cannot send self test request", log.Fields{"Err": err,
2964 "device-id": oo.deviceID})
2965 return err
2966 }
2967 logger.Debug(ctx, "send self test request done")
2968 return nil
2969}
2970
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002971//nolint: gocyclo
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002972func isSuccessfulResponseWithMibDataSync(omciMsg *omci.OMCI, packet *gp.Packet) bool {
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +00002973 for _, v := range responsesWithMibDataSync {
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002974 if v == omciMsg.MessageType {
Girish Gowdra6afb56a2021-04-27 17:47:57 -07002975 nextLayer, _ := omci.MsgTypeToNextLayer(v, false)
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002976 msgLayer := (*packet).Layer(nextLayer)
2977 switch nextLayer {
2978 case omci.LayerTypeCreateResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002979 if resp := msgLayer.(*omci.CreateResponse); resp != nil {
2980 if resp.Result == me.Success {
2981 return true
2982 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002983 }
2984 case omci.LayerTypeDeleteResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002985 if resp := msgLayer.(*omci.DeleteResponse); resp != nil {
2986 if resp.Result == me.Success {
2987 return true
2988 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002989 }
2990 case omci.LayerTypeSetResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002991 if resp := msgLayer.(*omci.SetResponse); resp != nil {
2992 if resp.Result == me.Success {
2993 return true
2994 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002995 }
2996 case omci.LayerTypeStartSoftwareDownloadResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002997 if resp := msgLayer.(*omci.StartSoftwareDownloadResponse); resp != nil {
2998 if resp.Result == me.Success {
2999 return true
3000 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00003001 }
3002 case omci.LayerTypeEndSoftwareDownloadResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00003003 if resp := msgLayer.(*omci.EndSoftwareDownloadResponse); resp != nil {
3004 if resp.Result == me.Success {
3005 return true
3006 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00003007 }
3008 case omci.LayerTypeActivateSoftwareResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00003009 if resp := msgLayer.(*omci.ActivateSoftwareResponse); resp != nil {
3010 if resp.Result == me.Success {
3011 return true
3012 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00003013 }
3014 case omci.LayerTypeCommitSoftwareResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00003015 if resp := msgLayer.(*omci.CommitSoftwareResponse); resp != nil {
3016 if resp.Result == me.Success {
3017 return true
3018 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00003019 }
3020 }
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +00003021 }
3022 }
3023 return false
3024}
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003025
3026func (oo *omciCC) processRequestMonitoring(ctx context.Context, aOmciTxRequest omciTransferStructure) {
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003027 timeout := aOmciTxRequest.timeout
mpagenkoc26d4c02021-05-06 14:27:57 +00003028 if timeout == 0 {
3029 //timeout 0 indicates that no response is expected - fire and forget
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003030 oo.mutexTxQueue.Lock()
3031 oo.txQueue.PushBack(aOmciTxRequest) // enqueue
3032 oo.mutexTxQueue.Unlock()
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003033 go oo.sendNextRequest(ctx)
mpagenkoc26d4c02021-05-06 14:27:57 +00003034 } else {
mpagenko7455fd42021-06-10 16:25:55 +00003035 //the supervised sending with waiting on the response (based on TID) is called in background
3036 // to avoid blocking of the sender for the complete OMCI handshake procedure
3037 // to stay consistent with the processing tested so far, sending of next messages of the same control procedure
3038 // is ensured by the according control instances (FSM's etc.) (by waiting for the respective responses there)
3039 go oo.sendWithRxSupervision(ctx, aOmciTxRequest, timeout)
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003040 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003041}
3042
mpagenko7455fd42021-06-10 16:25:55 +00003043func (oo *omciCC) sendWithRxSupervision(ctx context.Context, aOmciTxRequest omciTransferStructure, aTimeout int) {
3044 chSuccess := make(chan bool)
3045 aOmciTxRequest.chSuccess = chSuccess
3046 tid := aOmciTxRequest.cbPair.cbKey
3047 oo.mutexMonReq.Lock()
3048 oo.monitoredRequests[tid] = aOmciTxRequest
3049 oo.mutexMonReq.Unlock()
3050
3051 retries := aOmciTxRequest.retries
3052 retryCounter := 0
3053loop:
3054 for retryCounter <= retries {
3055
3056 oo.mutexTxQueue.Lock()
3057 oo.txQueue.PushBack(aOmciTxRequest) // enqueue
3058 oo.mutexTxQueue.Unlock()
3059 go oo.sendNextRequest(ctx)
3060
3061 select {
3062 case success := <-chSuccess:
3063 if success {
3064 logger.Debugw(ctx, "reqMon: response received in time",
3065 log.Fields{"tid": tid, "device-id": oo.deviceID})
3066 } else {
3067 logger.Debugw(ctx, "reqMon: wait for response aborted",
3068 log.Fields{"tid": tid, "device-id": oo.deviceID})
3069 }
3070 break loop
3071 case <-time.After(time.Duration(aTimeout) * time.Second):
3072 if retryCounter == retries {
3073 logger.Errorw(ctx, "reqMon: timeout waiting for response - no of max retries reached!",
3074 log.Fields{"tid": tid, "retries": retryCounter, "device-id": oo.deviceID})
3075 break loop
3076 } else {
3077 logger.Infow(ctx, "reqMon: timeout waiting for response - retry",
3078 log.Fields{"tid": tid, "retries": retryCounter, "device-id": oo.deviceID})
3079 }
3080 }
3081 retryCounter++
3082 }
3083 oo.mutexMonReq.Lock()
3084 delete(oo.monitoredRequests, tid)
3085 oo.mutexMonReq.Unlock()
3086}
3087
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003088//CancelRequestMonitoring terminates monitoring of outstanding omci requests
mpagenko8cd1bf72021-06-22 10:11:19 +00003089func (oo *omciCC) CancelRequestMonitoring(ctx context.Context) {
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003090 oo.mutexMonReq.RLock()
3091 for k := range oo.monitoredRequests {
mpagenko8cd1bf72021-06-22 10:11:19 +00003092 //implement non-blocking channel send to avoid blocking on mutexMonReq later
3093 select {
3094 case oo.monitoredRequests[k].chSuccess <- false:
3095 default:
3096 logger.Debugw(ctx, "cancel not send on omciRespChannel (no receiver)", log.Fields{
3097 "index": k, "device-id": oo.deviceID})
3098 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003099 }
3100 oo.mutexMonReq.RUnlock()
3101}
3102
3103//GetMaxOmciTimeoutWithRetries provides a timeout value greater than the maximum
3104//time consumed for retry processing of a particular OMCI-request
3105func (oo *omciCC) GetMaxOmciTimeoutWithRetries() time.Duration {
3106 return time.Duration((cDefaultRetries+1)*oo.pOnuDeviceEntry.pOpenOnuAc.omciTimeout + 1)
3107}