blob: 7b10d1295962025e1c113d4b369e983f3c58fd5b [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"
25 "errors"
Andrea Campanella6515c582020-10-05 11:25:00 +020026 "fmt"
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000027 "strconv"
Holger Hildebrandtfa074992020-03-27 15:42:06 +000028 "sync"
mpagenkodff5dda2020-08-28 11:52:01 +000029
Holger Hildebrandtfa074992020-03-27 15:42:06 +000030 //"time"
31
32 "github.com/google/gopacket"
33 // TODO!!! Some references could be resolved auto, but some need specific context ....
34 gp "github.com/google/gopacket"
35
36 "github.com/opencord/omci-lib-go"
37 me "github.com/opencord/omci-lib-go/generated"
38 "github.com/opencord/voltha-lib-go/v3/pkg/adapters/adapterif"
39
40 //"github.com/opencord/voltha-lib-go/v3/pkg/kafka"
41 "github.com/opencord/voltha-lib-go/v3/pkg/log"
42 ic "github.com/opencord/voltha-protos/v3/go/inter_container"
43 //"github.com/opencord/voltha-protos/v3/go/openflow_13"
44 //"github.com/opencord/voltha-protos/v3/go/voltha"
45)
46
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000047// ### OMCI related definitions - retrieved from Python adapter code/trace ####
Himani Chawla6d2ae152020-09-02 13:11:20 +053048
49//ConstDefaultOmciTimeout - Default OMCI Timeout
Holger Hildebrandtfa074992020-03-27 15:42:06 +000050const ConstDefaultOmciTimeout = 10 // ( 3 ?) Seconds
51
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000052const galEthernetEID = uint16(1)
53const maxGemPayloadSize = uint16(48)
54const connectivityModeValue = uint8(5)
Himani Chawla4d908332020-08-31 12:30:20 +053055
56//const defaultTPID = uint16(0x8100)
57//const broadComDefaultVID = uint16(4091)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000058const macBridgeServiceProfileEID = uint16(0x201) // TODO: most all these need better definition or tuning
59const ieeeMapperServiceProfileEID = uint16(0x8001)
60const macBridgePortAniEID = uint16(0x2102)
61
62// ### OMCI related definitions - end
63
Himani Chawla6d2ae152020-09-02 13:11:20 +053064//callbackPairEntry to be used for OMCI send/receive correlation
65type callbackPairEntry struct {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000066 cbRespChannel chan Message
67 cbFunction func(*omci.OMCI, *gp.Packet, chan Message) error
68}
69
Himani Chawla6d2ae152020-09-02 13:11:20 +053070//callbackPair to be used for ReceiveCallback init
71type callbackPair struct {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000072 cbKey uint16
Himani Chawla6d2ae152020-09-02 13:11:20 +053073 cbEntry callbackPairEntry
Holger Hildebrandtfa074992020-03-27 15:42:06 +000074}
75
76type omciTransferStructure struct {
77 txFrame []byte
78 timeout int
79 retry int
80 highPrio bool
81}
82
Himani Chawla6d2ae152020-09-02 13:11:20 +053083//omciCC structure holds information needed for OMCI communication (to/from OLT Adapter)
84type omciCC struct {
Holger Hildebrandtfa074992020-03-27 15:42:06 +000085 enabled bool
86 pOnuDeviceEntry *OnuDeviceEntry
87 deviceID string
Himani Chawla6d2ae152020-09-02 13:11:20 +053088 pBaseDeviceHandler *deviceHandler
Holger Hildebrandtfa074992020-03-27 15:42:06 +000089 coreProxy adapterif.CoreProxy
90 adapterProxy adapterif.AdapterProxy
91 supportExtMsg bool
92 //txRequest
93 //rxResponse
94 //pendingRequest
95 txFrames, txOnuFrames uint32
96 rxFrames, rxOnuFrames, rxOnuDiscards uint32
97
98 // OMCI params
99 mutexTid sync.Mutex
100 tid uint16
101 mutexHpTid sync.Mutex
102 hpTid uint16
103 uploadSequNo uint16
104 uploadNoOfCmds uint16
105
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000106 mutexTxQueue sync.Mutex
107 txQueue *list.List
108 mutexRxSchedMap sync.Mutex
Himani Chawla6d2ae152020-09-02 13:11:20 +0530109 rxSchedulerMap map[uint16]callbackPairEntry
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000110 pLastTxMeInstance *me.ManagedEntity
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000111}
112
Himani Chawla6d2ae152020-09-02 13:11:20 +0530113//newOmciCC constructor returns a new instance of a OmciCC
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000114//mib_db (as well as not inluded alarm_db not really used in this code? VERIFY!!)
Himani Chawla6d2ae152020-09-02 13:11:20 +0530115func newOmciCC(ctx context.Context, onuDeviceEntry *OnuDeviceEntry,
116 deviceID string, deviceHandler *deviceHandler,
117 coreProxy adapterif.CoreProxy, adapterProxy adapterif.AdapterProxy) *omciCC {
Himani Chawla4d908332020-08-31 12:30:20 +0530118 logger.Infow("init-omciCC", log.Fields{"device-id": deviceID})
Himani Chawla6d2ae152020-09-02 13:11:20 +0530119 var omciCC omciCC
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000120 omciCC.enabled = false
Himani Chawla4d908332020-08-31 12:30:20 +0530121 omciCC.pOnuDeviceEntry = onuDeviceEntry
122 omciCC.deviceID = deviceID
123 omciCC.pBaseDeviceHandler = deviceHandler
124 omciCC.coreProxy = coreProxy
125 omciCC.adapterProxy = adapterProxy
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000126 omciCC.supportExtMsg = false
127 omciCC.txFrames = 0
128 omciCC.txOnuFrames = 0
129 omciCC.rxFrames = 0
130 omciCC.rxOnuFrames = 0
131 omciCC.rxOnuDiscards = 0
132 omciCC.tid = 0x1
133 omciCC.hpTid = 0x8000
134 omciCC.uploadSequNo = 0
135 omciCC.uploadNoOfCmds = 0
136
137 omciCC.txQueue = list.New()
Himani Chawla6d2ae152020-09-02 13:11:20 +0530138 omciCC.rxSchedulerMap = make(map[uint16]callbackPairEntry)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000139
140 return &omciCC
141}
142
mpagenko900ee4b2020-10-12 11:56:34 +0000143//stop stops/resets the omciCC
144func (oo *omciCC) stop(ctx context.Context) error {
145 logger.Debugw("omciCC-stopping", log.Fields{"for device-id": oo.deviceID})
146 //reseting all internal data, which might also be helpful for discarding any lingering tx/rx requests
147 oo.mutexTxQueue.Lock()
148 oo.txQueue.Init() // clear the tx queue
149 oo.mutexTxQueue.Unlock()
150 oo.mutexRxSchedMap.Lock()
151 for k := range oo.rxSchedulerMap {
152 delete(oo.rxSchedulerMap, k) //clear the scheduler map
153 }
154 oo.mutexRxSchedMap.Unlock()
155 oo.mutexHpTid.Lock()
156 oo.hpTid = 0x8000 //reset the high prio transactionId
157 oo.mutexHpTid.Unlock()
158 oo.mutexTid.Lock()
159 oo.tid = 1 //reset the low prio transactionId
160 oo.mutexTid.Unlock()
161 //reset control values
162 oo.uploadSequNo = 0
163 oo.uploadNoOfCmds = 0
164 //reset the stats counter - which might be topic of discussion ...
165 oo.txFrames = 0
166 oo.txOnuFrames = 0
167 oo.rxFrames = 0
168 oo.rxOnuFrames = 0
169 oo.rxOnuDiscards = 0
170
171 return nil
172}
173
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000174// Rx handler for omci messages
Himani Chawla6d2ae152020-09-02 13:11:20 +0530175func (oo *omciCC) receiveOnuMessage(ctx context.Context, omciMsg *omci.OMCI) error {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000176 logger.Debugw("rx-onu-autonomous-message", log.Fields{"omciMsgType": omciMsg.MessageType,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000177 "payload": hex.EncodeToString(omciMsg.Payload)})
178 /*
179 msgType = rxFrame.fields["message_type"] //assumed OmciOperationsValue
180 rxOnuFrames++
181
182 switch msgType {
183 case AlarmNotification:
184 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000185 logger.Info("Unhandled: received-onu-alarm-message")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000186 // python code was:
187 //if msg_type == EntityOperations.AlarmNotification.value:
188 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.Alarm_Notification)
189 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
190 //
191 return errors.New("RxAlarmNotification unimplemented")
192 }
193 case AttributeValueChange:
194 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000195 logger.Info("Unhandled: received-attribute-value-change")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000196 // python code was:
197 //elif msg_type == EntityOperations.AttributeValueChange.value:
198 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.AVC_Notification)
199 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
200 //
201 return errors.New("RxAttributeValueChange unimplemented")
202 }
203 case TestResult:
204 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000205 logger.Info("Unhandled: received-test-result")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000206 // python code was:
207 //elif msg_type == EntityOperations.TestResult.value:
208 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.Test_Result)
209 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
210 //
211 return errors.New("RxTestResult unimplemented")
212 }
213 default:
214 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000215 logger.Errorw("rx-onu-unsupported-autonomous-message", log.Fields{"msgType": msgType})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000216 rxOnuDiscards++
217 return errors.New("RxOnuMsgType unimplemented")
218 }
219 }
220 */
Himani Chawla4d908332020-08-31 12:30:20 +0530221 return errors.New("receiveOnuMessage unimplemented")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000222}
223
224// Rx handler for onu messages
225// e.g. would call ReceiveOnuMessage() in case of TID=0 or Action=test ...
Himani Chawla6d2ae152020-09-02 13:11:20 +0530226func (oo *omciCC) receiveMessage(ctx context.Context, rxMsg []byte) error {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000227 //logger.Debugw("cc-receive-omci-message", log.Fields{"RxOmciMessage-x2s": hex.EncodeToString(rxMsg)})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000228 if len(rxMsg) >= 44 { // then it should normally include the BaseFormat trailer Len
229 // NOTE: autocorrection only valid for OmciBaseFormat, which is not specifically verified here!!!
230 // (am extendedFormat message could be destroyed this way!)
231 trailerLenData := rxMsg[42:44]
232 trailerLen := binary.BigEndian.Uint16(trailerLenData)
mpagenko1cc3cb42020-07-27 15:24:38 +0000233 //logger.Debugw("omci-received-trailer-len", log.Fields{"Length": trailerLen})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000234 if trailerLen != 40 { // invalid base Format entry -> autocorrect
235 binary.BigEndian.PutUint16(rxMsg[42:44], 40)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000236 logger.Debug("cc-corrected-omci-message: trailer len inserted")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000237 }
238 } else {
Himani Chawla4d908332020-08-31 12:30:20 +0530239 logger.Errorw("received omci-message too small for OmciBaseFormat - abort", log.Fields{"Length": len(rxMsg)})
Andrea Campanella6515c582020-10-05 11:25:00 +0200240 return fmt.Errorf("rxOmciMessage too small for BaseFormat %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000241 }
242
243 packet := gopacket.NewPacket(rxMsg, omci.LayerTypeOMCI, gopacket.NoCopy)
244 if packet == nil {
Andrea Campanella6515c582020-10-05 11:25:00 +0200245 logger.Errorw("omci-message could not be decoded", log.Fields{"deviceID": oo.deviceID})
246 return fmt.Errorf("could not decode rxMsg as OMCI %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000247 }
248 omciLayer := packet.Layer(omci.LayerTypeOMCI)
249 if omciLayer == nil {
Andrea Campanella6515c582020-10-05 11:25:00 +0200250 logger.Errorw("omci-message could not decode omci layer", log.Fields{"deviceID": oo.deviceID})
251 return fmt.Errorf("could not decode omci layer %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000252 }
253 omciMsg, ok := omciLayer.(*omci.OMCI)
254 if !ok {
Andrea Campanella6515c582020-10-05 11:25:00 +0200255 logger.Errorw("omci-message could not assign omci layer", log.Fields{"deviceID": oo.deviceID})
256 return fmt.Errorf("could not assign omci layer %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000257 }
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000258 logger.Debugw("omci-message-decoded:", log.Fields{"omciMsgType": omciMsg.MessageType,
mpagenko3dbcdd22020-07-22 07:38:45 +0000259 "transCorrId": strconv.FormatInt(int64(omciMsg.TransactionID), 16), "DeviceIdent": omciMsg.DeviceIdentifier})
Holger Hildebrandt2fb70892020-10-28 11:53:18 +0000260 if byte(omciMsg.MessageType)&me.AK == 0 {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000261 // Not a response
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000262 logger.Debug("RxMsg is no Omci Response Message")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000263 if omciMsg.TransactionID == 0 {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530264 return oo.receiveOnuMessage(ctx, omciMsg)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000265 }
Himani Chawla4d908332020-08-31 12:30:20 +0530266 logger.Errorw("Unexpected TransCorrId != 0 not accepted for autonomous messages",
Andrea Campanella6515c582020-10-05 11:25:00 +0200267 log.Fields{"msgType": omciMsg.MessageType, "payload": hex.EncodeToString(omciMsg.Payload),
268 "deviceID": oo.deviceID})
269 return fmt.Errorf("autonomous Omci Message with TranSCorrId != 0 not acccepted %s", oo.deviceID)
Himani Chawla4d908332020-08-31 12:30:20 +0530270
271 }
272 //logger.Debug("RxMsg is a Omci Response Message: try to schedule it to the requester")
273 oo.mutexRxSchedMap.Lock()
274 rxCallbackEntry, ok := oo.rxSchedulerMap[omciMsg.TransactionID]
275 if ok && rxCallbackEntry.cbFunction != nil {
276 //disadvantage of decoupling: error verification made difficult, but anyway the question is
277 // how to react on erroneous frame reception, maybe can simply be ignored
278 go rxCallbackEntry.cbFunction(omciMsg, &packet, rxCallbackEntry.cbRespChannel)
279 // having posted the response the request is regarded as 'done'
280 delete(oo.rxSchedulerMap, omciMsg.TransactionID)
281 oo.mutexRxSchedMap.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000282 } else {
Himani Chawla4d908332020-08-31 12:30:20 +0530283 oo.mutexRxSchedMap.Unlock()
Andrea Campanella6515c582020-10-05 11:25:00 +0200284 logger.Errorw("omci-message-response for not registered transCorrId", log.Fields{"deviceID": oo.deviceID})
285 return fmt.Errorf("could not find registered response handler tor transCorrId %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000286 }
287
288 return nil
289 /* py code was:
290 Receive and OMCI message from the proxy channel to the OLT.
291
292 Call this from your ONU Adapter on a new OMCI Rx on the proxy channel
293 :param msg: (str) OMCI binary message (used as input to Scapy packet decoder)
294 """
295 if not self.enabled:
296 return
297
298 try:
299 now = arrow.utcnow()
300 d = None
301
302 # NOTE: Since we may need to do an independent ME map on a per-ONU basis
303 # save the current value of the entity_id_to_class_map, then
304 # replace it with our custom one before decode, and then finally
305 # restore it later. Tried other ways but really made the code messy.
306 saved_me_map = omci_entities.entity_id_to_class_map
307 omci_entities.entity_id_to_class_map = self._me_map
308
309 try:
310 rx_frame = msg if isinstance(msg, OmciFrame) else OmciFrame(msg)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000311 self.logger.debug('recv-omci-msg', omci_msg=hexlify(msg))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000312 except KeyError as e:
313 # Unknown, Unsupported, or vendor-specific ME. Key is the unknown classID
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000314 self.logger.debug('frame-decode-key-error', omci_msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000315 rx_frame = self._decode_unknown_me(msg)
316 self._rx_unknown_me += 1
317
318 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000319 self.logger.exception('frame-decode', omci_msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000320 return
321
322 finally:
323 omci_entities.entity_id_to_class_map = saved_me_map # Always restore it.
324
325 rx_tid = rx_frame.fields['transaction_id']
326 msg_type = rx_frame.fields['message_type']
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000327 self.logger.debug('Received message for rx_tid', rx_tid = rx_tid, msg_type = msg_type)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000328 # Filter the Test Result frame and route through receive onu
329 # message method.
330 if rx_tid == 0 or msg_type == EntityOperations.TestResult.value:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000331 self.logger.debug('Receive ONU message', rx_tid=0)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000332 return self._receive_onu_message(rx_frame)
333
334 # Previously unreachable if this is the very first round-trip Rx or we
335 # have been running consecutive errors
336 if self._rx_frames == 0 or self._consecutive_errors != 0:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000337 self.logger.debug('Consecutive errors for rx', err = self._consecutive_errors)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000338 self.reactor.callLater(0, self._publish_connectivity_event, True)
339
340 self._rx_frames += 1
341 self._consecutive_errors = 0
342
343 try:
344 high_priority = self._tid_is_high_priority(rx_tid)
345 index = self._get_priority_index(high_priority)
346
347 # (timestamp, defer, frame, timeout, retry, delayedCall)
348 last_tx_tuple = self._tx_request[index]
349
350 if last_tx_tuple is None or \
351 last_tx_tuple[OMCI_CC.REQUEST_FRAME].fields.get('transaction_id') != rx_tid:
352 # Possible late Rx on a message that timed-out
353 if last_tx_tuple:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000354 self.logger.debug('Unknown message', rx_tid=rx_tid,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000355 tx_id=last_tx_tuple[OMCI_CC.REQUEST_FRAME].fields.get('transaction_id'))
356 self._rx_unknown_tid += 1
357 self._rx_late += 1
358 return
359
360 ts, d, tx_frame, timeout, retry, dc = last_tx_tuple
361 if dc is not None and not dc.cancelled and not dc.called:
362 dc.cancel()
363
364 _secs = self._update_rx_tx_stats(now, ts)
365
366 # Late arrival already serviced by a timeout?
367 if d.called:
368 self._rx_late += 1
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000369 self.logger.debug('Serviced by timeout. Late arrival', rx_late = self._rx_late)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000370 return
371
372 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000373 self.logger.exception('frame-match', msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000374 if d is not None:
375 return d.errback(failure.Failure(e))
376 return
377
378 # Publish Rx event to listeners in a different task
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000379 self.logger.debug('Publish rx event', rx_tid = rx_tid,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000380 tx_tid = tx_frame.fields['transaction_id'])
381 reactor.callLater(0, self._publish_rx_frame, tx_frame, rx_frame)
382
383 # begin success callback chain (will cancel timeout and queue next Tx message)
384 self._rx_response[index] = rx_frame
385 d.callback(rx_frame)
386
387 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000388 self.logger.exception('rx-msg', e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000389 */
390}
391
Himani Chawla6d2ae152020-09-02 13:11:20 +0530392/*
393func (oo *omciCC) publishRxResponseFrame(ctx context.Context, txFrame []byte, rxFrame []byte) error {
Himani Chawla4d908332020-08-31 12:30:20 +0530394 return errors.New("publishRxResponseFrame unimplemented")
Himani Chawla6d2ae152020-09-02 13:11:20 +0530395 //def _publish_rx_frame(self, tx_frame, rx_frame):
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000396}
Himani Chawla6d2ae152020-09-02 13:11:20 +0530397*/
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000398
399//Queue the OMCI Frame for a transmit to the ONU via the proxy_channel
Himani Chawla6d2ae152020-09-02 13:11:20 +0530400func (oo *omciCC) send(ctx context.Context, txFrame []byte, timeout int, retry int, highPrio bool,
401 receiveCallbackPair callbackPair) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000402
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000403 logger.Debugw("register-response-callback:", log.Fields{"for TansCorrId": receiveCallbackPair.cbKey})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000404 // it could be checked, if the callback keay is already registered - but simply overwrite may be acceptable ...
405 oo.mutexRxSchedMap.Lock()
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000406 oo.rxSchedulerMap[receiveCallbackPair.cbKey] = receiveCallbackPair.cbEntry
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000407 oo.mutexRxSchedMap.Unlock()
408
409 //just use a simple list for starting - might need some more effort, especially for multi source write access
410 omciTxRequest := omciTransferStructure{
411 txFrame,
412 timeout,
413 retry,
414 highPrio,
415 }
416 oo.mutexTxQueue.Lock()
417 oo.txQueue.PushBack(omciTxRequest) // enqueue
418 oo.mutexTxQueue.Unlock()
419
420 // for first test just bypass and send directly:
421 go oo.sendNextRequest(ctx)
422 return nil
423}
424
425//Pull next tx request and send it
Himani Chawla6d2ae152020-09-02 13:11:20 +0530426func (oo *omciCC) sendNextRequest(ctx context.Context) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000427 // return errors.New("sendNextRequest unimplemented")
428
429 // just try to get something transferred !!
430 // avoid accessing the txQueue from parallel send requests
431 // block parallel omci send requests at least until SendIAP is 'committed'
432 // that should be feasible for an onu instance as on OMCI anyway window size 1 is assumed
433 oo.mutexTxQueue.Lock()
mpagenkodff5dda2020-08-28 11:52:01 +0000434 defer oo.mutexTxQueue.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000435 for oo.txQueue.Len() > 0 {
436 queueElement := oo.txQueue.Front() // First element
437 omciTxRequest := queueElement.Value.(omciTransferStructure)
438 /* compare olt device handler code:
439 func (dh *DeviceHandler) omciIndication(omciInd *oop.OmciIndication) {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000440 logger.Debugw("omci indication", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000441 var deviceType string
442 var deviceID string
443 var proxyDeviceID string
444
445 onuKey := dh.formOnuKey(omciInd.IntfId, omciInd.OnuId)
446
447 if onuInCache, ok := dh.onus.Load(onuKey); !ok {
448
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000449 logger.Debugw("omci indication for a device not in cache.", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000450 ponPort := IntfIDToPortNo(omciInd.GetIntfId(), voltha.Port_PON_OLT)
451 kwargs := make(map[string]interface{})
452 kwargs["onu_id"] = omciInd.OnuId
453 kwargs["parent_port_no"] = ponPort
454
455 onuDevice, err := dh.coreProxy.GetChildDevice(context.TODO(), dh.device.Id, kwargs)
456 if err != nil {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000457 logger.Errorw("onu not found", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId, "error": err})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000458 return
459 }
460 deviceType = onuDevice.Type
461 deviceID = onuDevice.Id
462 proxyDeviceID = onuDevice.ProxyAddress.DeviceId
463 //if not exist in cache, then add to cache.
464 dh.onus.Store(onuKey, NewOnuDevice(deviceID, deviceType, onuDevice.SerialNumber, omciInd.OnuId, omciInd.IntfId, proxyDeviceID))
465 } else {
466 //found in cache
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000467 logger.Debugw("omci indication for a device in cache.", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000468 deviceType = onuInCache.(*OnuDevice).deviceType
469 deviceID = onuInCache.(*OnuDevice).deviceID
470 proxyDeviceID = onuInCache.(*OnuDevice).proxyDeviceID
471 }
472 */
473 /* and compare onu_adapter py code:
474 omci_msg = InterAdapterOmciMessage(
475 message=bytes(frame),
476 proxy_address=self._proxy_address,
477 connect_status=self._device.connect_status)
478
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000479 self.logger.debug('sent-omci-msg', tid=tx_tid, omci_msg=hexlify(bytes(frame)))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000480
481 yield self._adapter_proxy.send_inter_adapter_message(
482 msg=omci_msg,
483 type=InterAdapterMessageType.OMCI_REQUEST,
484 from_adapter=self._device.type,
485 to_adapter=self._proxy_address.device_type,
486 to_device_id=self._device_id,
487 proxy_device_id=self._proxy_address.device_id
488 )
489 */
490 device, err := oo.coreProxy.GetDevice(ctx,
491 oo.pBaseDeviceHandler.deviceID, oo.deviceID) //parent, child
492 if err != nil || device == nil {
493 /*TODO: needs to handle error scenarios */
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000494 logger.Errorw("Failed to fetch device", log.Fields{"err": err, "ParentId": oo.pBaseDeviceHandler.deviceID,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000495 "ChildId": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200496 return fmt.Errorf("failed to fetch device %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000497 }
498
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000499 logger.Debugw("omci-message-sending", log.Fields{"fromDeviceType": oo.pBaseDeviceHandler.DeviceType,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000500 "toDeviceType": oo.pBaseDeviceHandler.ProxyAddressType,
501 "onuDeviceID": oo.deviceID, "proxyDeviceID": oo.pBaseDeviceHandler.ProxyAddressID})
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000502 logger.Debugw("omci-message-to-send:",
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000503 log.Fields{"TxOmciMessage": hex.EncodeToString(omciTxRequest.txFrame)})
504
505 omciMsg := &ic.InterAdapterOmciMessage{Message: omciTxRequest.txFrame}
506 if sendErr := oo.adapterProxy.SendInterAdapterMessage(context.Background(), omciMsg,
507 ic.InterAdapterMessageType_OMCI_REQUEST,
508 //fromType,toType,toDevId, ProxyDevId
509 oo.pBaseDeviceHandler.DeviceType, oo.pBaseDeviceHandler.ProxyAddressType,
510 oo.deviceID, oo.pBaseDeviceHandler.ProxyAddressID, ""); sendErr != nil {
Andrea Campanella6515c582020-10-05 11:25:00 +0200511 logger.Errorw("send omci request error", log.Fields{"ChildId": oo.deviceID, "error": sendErr})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000512 return sendErr
513 }
514 oo.txQueue.Remove(queueElement) // Dequeue
515 }
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000516 return nil
517}
518
Himani Chawla6d2ae152020-09-02 13:11:20 +0530519func (oo *omciCC) getNextTid(highPriority bool) uint16 {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000520 var next uint16
521 if highPriority {
mpagenko900ee4b2020-10-12 11:56:34 +0000522 oo.mutexHpTid.Lock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000523 next = oo.hpTid
Himani Chawla4d908332020-08-31 12:30:20 +0530524 oo.hpTid++
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000525 if oo.hpTid < 0x8000 {
526 oo.hpTid = 0x8000
527 }
mpagenko900ee4b2020-10-12 11:56:34 +0000528 oo.mutexHpTid.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000529 } else {
mpagenko900ee4b2020-10-12 11:56:34 +0000530 oo.mutexTid.Lock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000531 next = oo.tid
Himani Chawla4d908332020-08-31 12:30:20 +0530532 oo.tid++
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000533 if oo.tid >= 0x8000 {
534 oo.tid = 1
535 }
mpagenko900ee4b2020-10-12 11:56:34 +0000536 oo.mutexTid.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000537 }
538 return next
539}
540
541// ###################################################################################
542// # utility methods provided to work on OMCI messages
543func serialize(msgType omci.MessageType, request gopacket.SerializableLayer, tid uint16) ([]byte, error) {
544 omciLayer := &omci.OMCI{
545 TransactionID: tid,
546 MessageType: msgType,
547 }
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000548 return serializeOmciLayer(omciLayer, request)
549}
550
Himani Chawla4d908332020-08-31 12:30:20 +0530551func serializeOmciLayer(aOmciLayer *omci.OMCI, aRequest gopacket.SerializableLayer) ([]byte, error) {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000552 var options gopacket.SerializeOptions
553 options.FixLengths = true
554
555 buffer := gopacket.NewSerializeBuffer()
Himani Chawla4d908332020-08-31 12:30:20 +0530556 err := gopacket.SerializeLayers(buffer, options, aOmciLayer, aRequest)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000557 if err != nil {
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000558 logger.Errorw("Could not create goPacket Omci serial buffer", log.Fields{"Err": err})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000559 return nil, err
560 }
561 return buffer.Bytes(), nil
562}
563
Himani Chawla4d908332020-08-31 12:30:20 +0530564/*
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000565func hexEncode(omciPkt []byte) ([]byte, error) {
566 dst := make([]byte, hex.EncodedLen(len(omciPkt)))
567 hex.Encode(dst, omciPkt)
568 return dst, nil
569}
Himani Chawla4d908332020-08-31 12:30:20 +0530570*/
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000571
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000572//supply a response handler for omci response messages to be transferred to the requested FSM
Himani Chawla6d2ae152020-09-02 13:11:20 +0530573func (oo *omciCC) receiveOmciResponse(omciMsg *omci.OMCI, packet *gp.Packet, respChan chan Message) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000574
mpagenko3dbcdd22020-07-22 07:38:45 +0000575 logger.Debugw("omci-message-response - transfer on omciRespChannel", log.Fields{"omciMsgType": omciMsg.MessageType,
divyadesai4d299552020-08-18 07:13:49 +0000576 "transCorrId": strconv.FormatInt(int64(omciMsg.TransactionID), 16), "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000577
578 if oo.pOnuDeviceEntry == nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000579 logger.Errorw("Abort receiving OMCI response, DeviceEntryPointer is nil", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000580 "device-id": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200581 return fmt.Errorf("deviceEntryPointer is nil %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000582 }
583
584 // no further test on SeqNo is done here, assignment from rxScheduler is trusted
585 // MibSync responses are simply transferred via deviceEntry to MibSync, no specific analysis here
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000586 omciRespMsg := Message{
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000587 Type: OMCI,
588 Data: OmciMessage{
589 OmciMsg: omciMsg,
590 OmciPacket: packet,
591 },
592 }
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000593 //logger.Debugw("Message to be sent into channel:", log.Fields{"mibSyncMsg": mibSyncMsg})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000594 respChan <- omciRespMsg
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000595
596 return nil
597}
598
Himani Chawla6d2ae152020-09-02 13:11:20 +0530599func (oo *omciCC) sendMibReset(ctx context.Context, timeout int, highPrio bool) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000600
divyadesai4d299552020-08-18 07:13:49 +0000601 logger.Debugw("send MibReset-msg to:", log.Fields{"device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000602 request := &omci.MibResetRequest{
603 MeBasePacket: omci.MeBasePacket{
604 EntityClass: me.OnuDataClassID,
605 },
606 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530607 tid := oo.getNextTid(highPrio)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000608 pkt, err := serialize(omci.MibResetRequestType, request, tid)
609 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000610 logger.Errorw("Cannot serialize MibResetRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000611 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000612 return err
613 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530614 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000615 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530616 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000617 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530618 return oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000619}
620
Himani Chawla6d2ae152020-09-02 13:11:20 +0530621func (oo *omciCC) sendReboot(ctx context.Context, timeout int, highPrio bool, responseChannel chan Message) error {
divyadesai4d299552020-08-18 07:13:49 +0000622 logger.Debugw("send Reboot-msg to:", log.Fields{"device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300623 request := &omci.RebootRequest{
624 MeBasePacket: omci.MeBasePacket{
625 EntityClass: me.OnuGClassID,
626 },
627 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530628 tid := oo.getNextTid(highPrio)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300629 pkt, err := serialize(omci.RebootRequestType, request, tid)
630 if err != nil {
631 logger.Errorw("Cannot serialize RebootRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000632 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300633 return err
634 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530635 omciRxCallbackPair := callbackPair{
ozgecanetsiae11479f2020-07-06 09:44:47 +0300636 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530637 cbEntry: callbackPairEntry{oo.pOnuDeviceEntry.omciRebootMessageReceivedChannel, oo.receiveOmciResponse},
ozgecanetsiae11479f2020-07-06 09:44:47 +0300638 }
639
Himani Chawla6d2ae152020-09-02 13:11:20 +0530640 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300641 if err != nil {
642 logger.Errorw("Cannot send RebootRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000643 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300644 return err
645 }
646 err = oo.pOnuDeviceEntry.waitForRebootResponse(responseChannel)
647 if err != nil {
Andrea Campanella6515c582020-10-05 11:25:00 +0200648 logger.Errorw("aborting ONU Reboot!", log.Fields{
649 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300650 return err
651 }
652 return nil
653}
654
Himani Chawla6d2ae152020-09-02 13:11:20 +0530655func (oo *omciCC) sendMibUpload(ctx context.Context, timeout int, highPrio bool) error {
divyadesai4d299552020-08-18 07:13:49 +0000656 logger.Debugw("send MibUpload-msg to:", log.Fields{"device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000657 request := &omci.MibUploadRequest{
658 MeBasePacket: omci.MeBasePacket{
659 EntityClass: me.OnuDataClassID,
660 },
661 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530662 tid := oo.getNextTid(highPrio)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000663 pkt, err := serialize(omci.MibUploadRequestType, request, tid)
664 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000665 logger.Errorw("Cannot serialize MibUploadRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000666 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000667 return err
668 }
669 oo.uploadSequNo = 0
670 oo.uploadNoOfCmds = 0
671
Himani Chawla6d2ae152020-09-02 13:11:20 +0530672 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000673 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530674 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000675 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530676 return oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000677}
678
Himani Chawla6d2ae152020-09-02 13:11:20 +0530679func (oo *omciCC) sendMibUploadNext(ctx context.Context, timeout int, highPrio bool) error {
divyadesai4d299552020-08-18 07:13:49 +0000680 logger.Debugw("send MibUploadNext-msg to:", log.Fields{"device-id": oo.deviceID, "uploadSequNo": oo.uploadSequNo})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000681 request := &omci.MibUploadNextRequest{
682 MeBasePacket: omci.MeBasePacket{
683 EntityClass: me.OnuDataClassID,
684 },
685 CommandSequenceNumber: oo.uploadSequNo,
686 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530687 tid := oo.getNextTid(highPrio)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000688 pkt, err := serialize(omci.MibUploadNextRequestType, request, tid)
689 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000690 logger.Errorw("Cannot serialize MibUploadNextRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000691 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000692 return err
693 }
694 oo.uploadSequNo++
695
Himani Chawla6d2ae152020-09-02 13:11:20 +0530696 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000697 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530698 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000699 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530700 return oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000701}
702
Himani Chawla6d2ae152020-09-02 13:11:20 +0530703func (oo *omciCC) sendCreateGalEthernetProfile(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
704 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +0000705 logger.Debugw("send GalEnetProfile-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000706 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000707
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000708 meParams := me.ParamData{
709 EntityID: galEthernetEID,
710 Attributes: me.AttributeValueMap{"MaximumGemPayloadSize": maxGemPayloadSize},
711 }
712 meInstance, omciErr := me.NewGalEthernetProfile(meParams)
713 if omciErr.GetError() == nil {
714 //all setByCreate parameters already set, no default option required ...
715 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
716 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000717 logger.Errorw("Cannot encode GalEnetProfileInstance for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000718 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000719 return nil
720 }
721
722 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
723 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000724 logger.Errorw("Cannot serialize GalEnetProfile create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000725 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000726 return nil
727 }
728
Himani Chawla6d2ae152020-09-02 13:11:20 +0530729 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000730 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530731 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000732 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530733 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000734 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000735 logger.Errorw("Cannot send GalEnetProfile create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000736 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000737 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000738 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000739 logger.Debug("send GalEnetProfile-Create-msg done")
740 return meInstance
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000741 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000742 logger.Errorw("Cannot generate GalEnetProfileInstance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000743 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000744 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000745}
746
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000747// might be needed to extend for parameter arguments, here just for setting the ConnectivityMode!!
Himani Chawla6d2ae152020-09-02 13:11:20 +0530748func (oo *omciCC) sendSetOnu2g(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
749 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +0000750 logger.Debugw("send ONU2-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000751 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000752
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000753 // ONU-G ME-ID is defined to be 0, but we could verify, if the ONU really supports the desired
754 // connectivity mode 5 (in ConnCap)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000755 // By now we just use fix values to fire - this is anyway what the python adapter does
756 // read ONU-2G from DB ???? //TODO!!!
757 meParams := me.ParamData{
758 EntityID: 0,
759 Attributes: me.AttributeValueMap{"CurrentConnectivityMode": connectivityModeValue},
760 }
761 meInstance, omciErr := me.NewOnu2G(meParams)
762 if omciErr.GetError() == nil {
763 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
764 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000765 logger.Errorw("Cannot encode ONU2-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000766 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000767 return nil
768 }
769
770 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
771 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000772 logger.Errorw("Cannot serialize ONU2-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000773 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000774 return nil
775 }
776
Himani Chawla6d2ae152020-09-02 13:11:20 +0530777 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000778 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530779 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000780 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530781 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000782 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000783 logger.Errorw("Cannot send ONU2-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000784 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000785 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000786 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000787 logger.Debug("send ONU2-G-Set-msg done")
788 return meInstance
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000789 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000790 logger.Errorw("Cannot generate ONU2-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000791 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000792 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000793}
794
Himani Chawla6d2ae152020-09-02 13:11:20 +0530795func (oo *omciCC) sendCreateMBServiceProfile(ctx context.Context,
796 aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
797 tid := oo.getNextTid(highPrio)
Himani Chawla4d908332020-08-31 12:30:20 +0530798 instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
divyadesai4d299552020-08-18 07:13:49 +0000799 logger.Debugw("send MBSP-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000800 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000801
802 meParams := me.ParamData{
803 EntityID: instID,
804 Attributes: me.AttributeValueMap{
805 "Priority": 0x8000,
806 "MaxAge": 20 * 256, //20s
807 "HelloTime": 2 * 256, //2s
808 "ForwardDelay": 15 * 256, //15s
809 //note: DynamicFilteringAgeingTime is taken from omci lib default as
810 // which is obviously different from default value used in python lib,
811 // where the value seems to be 0 (ONU defined) - to be considered in case of test artifacts ...
812 },
813 }
814
815 meInstance, omciErr := me.NewMacBridgeServiceProfile(meParams)
816 if omciErr.GetError() == nil {
817 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
818 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
819 omci.TransactionID(tid), omci.AddDefaults(true))
820 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000821 logger.Errorw("Cannot encode MBSP for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000822 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000823 return nil
824 }
825
826 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
827 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000828 logger.Errorw("Cannot serialize MBSP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000829 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000830 return nil
831 }
832
Himani Chawla6d2ae152020-09-02 13:11:20 +0530833 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000834 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530835 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000836 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530837 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000838 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000839 logger.Errorw("Cannot send MBSP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000840 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000841 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000842 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000843 logger.Debug("send MBSP-Create-msg done")
844 return meInstance
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000845 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000846 logger.Errorw("Cannot generate MBSP Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000847 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000848 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000849}
850
Himani Chawla6d2ae152020-09-02 13:11:20 +0530851func (oo *omciCC) sendCreateMBPConfigData(ctx context.Context,
852 aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
853 tid := oo.getNextTid(highPrio)
Himani Chawla26e555c2020-08-31 12:30:20 +0530854 instID := macBridgePortAniEID + aPUniPort.entityID
divyadesai4d299552020-08-18 07:13:49 +0000855 logger.Debugw("send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000856 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000857
858 meParams := me.ParamData{
859 EntityID: instID,
860 Attributes: me.AttributeValueMap{
Himani Chawla4d908332020-08-31 12:30:20 +0530861 "BridgeIdPointer": macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo),
862 "PortNum": aPUniPort.macBpNo,
863 "TpType": uint8(aPUniPort.portType),
Himani Chawla26e555c2020-08-31 12:30:20 +0530864 "TpPointer": aPUniPort.entityID,
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000865 },
866 }
867 meInstance, omciErr := me.NewMacBridgePortConfigurationData(meParams)
868 if omciErr.GetError() == nil {
869 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
870 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
871 omci.TransactionID(tid), omci.AddDefaults(true))
872 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000873 logger.Errorw("Cannot encode MBPCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000874 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000875 return nil
876 }
877
878 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
879 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000880 logger.Errorw("Cannot serialize MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000881 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000882 return nil
883 }
884
Himani Chawla6d2ae152020-09-02 13:11:20 +0530885 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000886 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530887 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000888 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530889 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000890 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000891 logger.Errorw("Cannot send MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000892 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000893 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000894 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000895 logger.Debug("send MBPCD-Create-msg done")
896 return meInstance
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000897 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000898 logger.Errorw("Cannot generate MBPCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000899 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000900 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000901}
902
Himani Chawla6d2ae152020-09-02 13:11:20 +0530903func (oo *omciCC) sendCreateEVTOConfigData(ctx context.Context,
904 aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
905 tid := oo.getNextTid(highPrio)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000906 //same entityId is used as for MBSP (see there), but just arbitrary ...
Himani Chawla4d908332020-08-31 12:30:20 +0530907 instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
divyadesai4d299552020-08-18 07:13:49 +0000908 logger.Debugw("send EVTOCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000909 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000910
911 // compare python adapter code WA VOL-1311: this is not done here!
912 // (setting TPID values for the create would probably anyway be ignored by the omci lib)
913 // but perhaps we have to be aware of possible problems at get(Next) Request handling for EVTOOCD tables later ...
914 assType := uint8(2) // default AssociationType is PPTPEthUni
Himani Chawla6d2ae152020-09-02 13:11:20 +0530915 if aPUniPort.portType == uniVEIP {
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000916 assType = uint8(10) // for VEIP
917 }
918 meParams := me.ParamData{
919 EntityID: instID,
920 Attributes: me.AttributeValueMap{
921 "AssociationType": assType,
Himani Chawla26e555c2020-08-31 12:30:20 +0530922 "AssociatedMePointer": aPUniPort.entityID,
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000923 },
924 }
925 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(meParams)
926 if omciErr.GetError() == nil {
927 //all setByCreate parameters already set, no default option required ...
928 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
929 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000930 logger.Errorw("Cannot encode EVTOCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000931 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000932 return nil
933 }
934
935 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
936 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000937 logger.Errorw("Cannot serialize EVTOCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000938 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000939 return nil
940 }
941
Himani Chawla6d2ae152020-09-02 13:11:20 +0530942 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000943 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530944 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000945 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530946 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000947 if err != nil {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000948 logger.Errorw("Cannot send EVTOCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000949 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000950 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000951 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000952 logger.Debug("send EVTOCD-Create-msg done")
953 return meInstance
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000954 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000955 logger.Errorw("Cannot generate EVTOCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000956 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000957 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000958}
959
Himani Chawla6d2ae152020-09-02 13:11:20 +0530960func (oo *omciCC) sendSetOnuGLS(ctx context.Context, timeout int,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000961 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530962 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +0000963 logger.Debugw("send ONU-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000964 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000965
966 // ONU-G ME-ID is defined to be 0, no need to perform a DB lookup
967 meParams := me.ParamData{
968 EntityID: 0,
969 Attributes: requestedAttributes,
970 }
971 meInstance, omciErr := me.NewOnuG(meParams)
972 if omciErr.GetError() == nil {
973 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
974 if err != nil {
975 logger.Errorw("Cannot encode ONU-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000976 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000977 return nil
978 }
979
980 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
981 if err != nil {
982 logger.Errorw("Cannot serialize ONU-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000983 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000984 return nil
985 }
986
Himani Chawla6d2ae152020-09-02 13:11:20 +0530987 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000988 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530989 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000990 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530991 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000992 if err != nil {
993 logger.Errorw("Cannot send ONU-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000994 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000995 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000996 }
mpagenko3dbcdd22020-07-22 07:38:45 +0000997 logger.Debug("send ONU-G-Set-msg done")
998 return meInstance
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000999 }
mpagenko3dbcdd22020-07-22 07:38:45 +00001000 logger.Errorw("Cannot generate ONU-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001001 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001002 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001003}
1004
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001005func (oo *omciCC) sendSetPptpEthUniLS(ctx context.Context, aInstNo uint16, timeout int,
1006 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
1007 tid := oo.getNextTid(highPrio)
1008 logger.Debugw("send PPTPEthUni-Set-msg:", log.Fields{"device-id": oo.deviceID,
1009 "SequNo": strconv.FormatInt(int64(tid), 16)})
1010
1011 // PPTPEthUni ME-ID is taken from Mib Upload stored OnuUniPort instance (argument)
1012 meParams := me.ParamData{
1013 EntityID: aInstNo,
1014 Attributes: requestedAttributes,
1015 }
1016 meInstance, omciErr := me.NewPhysicalPathTerminationPointEthernetUni(meParams)
1017 if omciErr.GetError() == nil {
1018 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1019 if err != nil {
1020 logger.Errorw("Cannot encode PPTPEthUni instance for set", log.Fields{
1021 "Err": err, "device-id": oo.deviceID})
1022 return nil
1023 }
1024
1025 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1026 if err != nil {
1027 logger.Errorw("Cannot serialize PPTPEthUni-Set", log.Fields{
1028 "Err": err, "device-id": oo.deviceID})
1029 return nil
1030 }
1031
1032 omciRxCallbackPair := callbackPair{
1033 cbKey: tid,
1034 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1035 }
1036 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1037 if err != nil {
1038 logger.Errorw("Cannot send PPTPEthUni-Set", log.Fields{
1039 "Err": err, "device-id": oo.deviceID})
1040 return nil
1041 }
1042 logger.Debug("send PPTPEthUni-Set-msg done")
1043 return meInstance
1044 }
1045 logger.Errorw("Cannot generate PPTPEthUni", log.Fields{
1046 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1047 return nil
1048}
1049
1050/* UniG obsolete by now, left here in case it should be needed once again
1051 UniG AdminState anyway should be ignored by ONU acc. to G988
Himani Chawla6d2ae152020-09-02 13:11:20 +05301052func (oo *omciCC) sendSetUniGLS(ctx context.Context, aInstNo uint16, timeout int,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001053 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301054 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001055 logger.Debugw("send UNI-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001056 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001057
1058 // UNI-G ME-ID is taken from Mib Upload stored OnuUniPort instance (argument)
1059 meParams := me.ParamData{
1060 EntityID: aInstNo,
1061 Attributes: requestedAttributes,
1062 }
1063 meInstance, omciErr := me.NewUniG(meParams)
1064 if omciErr.GetError() == nil {
1065 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1066 if err != nil {
1067 logger.Errorw("Cannot encode UNI-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001068 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001069 return nil
1070 }
1071
1072 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1073 if err != nil {
1074 logger.Errorw("Cannot serialize UNI-G-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001075 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001076 return nil
1077 }
1078
Himani Chawla6d2ae152020-09-02 13:11:20 +05301079 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001080 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301081 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001082 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301083 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001084 if err != nil {
1085 logger.Errorw("Cannot send UNIG-G-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001086 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001087 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001088 }
mpagenko3dbcdd22020-07-22 07:38:45 +00001089 logger.Debug("send UNI-G-Set-msg done")
1090 return meInstance
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001091 }
mpagenko3dbcdd22020-07-22 07:38:45 +00001092 logger.Errorw("Cannot generate UNI-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001093 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001094 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001095}
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001096*/
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001097
Himani Chawla6d2ae152020-09-02 13:11:20 +05301098func (oo *omciCC) sendSetVeipLS(ctx context.Context, aInstNo uint16, timeout int,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001099 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301100 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001101 logger.Debugw("send VEIP-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001102 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001103
1104 // ONU-G ME-ID is defined to be 0, no need to perform a DB lookup
1105 meParams := me.ParamData{
1106 EntityID: aInstNo,
1107 Attributes: requestedAttributes,
1108 }
1109 meInstance, omciErr := me.NewVirtualEthernetInterfacePoint(meParams)
1110 if omciErr.GetError() == nil {
1111 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1112 if err != nil {
1113 logger.Errorw("Cannot encode VEIP instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001114 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001115 return nil
1116 }
1117
1118 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1119 if err != nil {
1120 logger.Errorw("Cannot serialize VEIP-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001121 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001122 return nil
1123 }
1124
Himani Chawla6d2ae152020-09-02 13:11:20 +05301125 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001126 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301127 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001128 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301129 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001130 if err != nil {
1131 logger.Errorw("Cannot send VEIP-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001132 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001133 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001134 }
mpagenko3dbcdd22020-07-22 07:38:45 +00001135 logger.Debug("send VEIP-Set-msg done")
1136 return meInstance
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001137 }
mpagenko3dbcdd22020-07-22 07:38:45 +00001138 logger.Errorw("Cannot generate VEIP", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001139 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001140 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001141}
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001142
Himani Chawla6d2ae152020-09-02 13:11:20 +05301143func (oo *omciCC) sendGetMe(ctx context.Context, classID me.ClassID, entityID uint16, requestedAttributes me.AttributeValueMap,
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001144 timeout int, highPrio bool) *me.ManagedEntity {
1145
Himani Chawla6d2ae152020-09-02 13:11:20 +05301146 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001147 logger.Debugw("send get-request-msg", log.Fields{"classID": classID, "device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001148 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001149
1150 meParams := me.ParamData{
1151 EntityID: entityID,
1152 Attributes: requestedAttributes,
1153 }
1154 meInstance, omciErr := me.LoadManagedEntityDefinition(classID, meParams)
1155 if omciErr.GetError() == nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301156 meClassIDName := meInstance.GetName()
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001157 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.GetRequestType, omci.TransactionID(tid))
1158 if err != nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301159 logger.Errorf("Cannot encode instance for get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001160 return nil
1161 }
1162 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1163 if err != nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301164 logger.Errorw("Cannot serialize get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001165 return nil
1166 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301167 omciRxCallbackPair := callbackPair{
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001168 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301169 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001170 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301171 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001172 if err != nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301173 logger.Errorw("Cannot send get-request-msg", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001174 return nil
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001175 }
Himani Chawla4d908332020-08-31 12:30:20 +05301176 logger.Debugw("send get-request-msg done", log.Fields{"meClassIDName": meClassIDName, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001177 return meInstance
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001178 }
divyadesai4d299552020-08-18 07:13:49 +00001179 logger.Errorw("Cannot generate meDefinition", log.Fields{"classID": classID, "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001180 return nil
1181}
1182
Himani Chawla6d2ae152020-09-02 13:11:20 +05301183func (oo *omciCC) sendCreateDot1PMapper(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001184 aInstID uint16, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301185 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001186 logger.Debugw("send .1pMapper-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001187 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(aInstID), 16)})
1188
1189 meParams := me.ParamData{
1190 EntityID: aInstID,
1191 Attributes: me.AttributeValueMap{},
1192 }
1193 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(meParams)
1194 if omciErr.GetError() == nil {
1195 //we have to set all 'untouched' parameters to default by some additional option parameter!!
1196 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1197 omci.TransactionID(tid), omci.AddDefaults(true))
1198 if err != nil {
1199 logger.Errorw("Cannot encode .1pMapper for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001200 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001201 return nil
1202 }
1203
1204 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1205 if err != nil {
1206 logger.Errorw("Cannot serialize .1pMapper create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001207 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001208 return nil
1209 }
1210
Himani Chawla6d2ae152020-09-02 13:11:20 +05301211 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001212 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301213 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001214 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301215 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001216 if err != nil {
1217 logger.Errorw("Cannot send .1pMapper create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001218 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001219 return nil
1220 }
1221 logger.Debug("send .1pMapper-create-msg done")
1222 return meInstance
1223 }
1224 logger.Errorw("Cannot generate .1pMapper", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001225 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001226 return nil
1227}
1228
Himani Chawla6d2ae152020-09-02 13:11:20 +05301229func (oo *omciCC) sendCreateMBPConfigDataVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001230 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301231 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001232 logger.Debugw("send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001233 "SequNo": strconv.FormatInt(int64(tid), 16),
1234 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1235
1236 meInstance, omciErr := me.NewMacBridgePortConfigurationData(params[0])
1237 if omciErr.GetError() == nil {
1238 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1239 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1240 omci.TransactionID(tid), omci.AddDefaults(true))
1241 if err != nil {
1242 logger.Errorw("Cannot encode MBPCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001243 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001244 return nil
1245 }
1246
1247 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1248 if err != nil {
1249 logger.Errorw("Cannot serialize MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001250 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001251 return nil
1252 }
1253
Himani Chawla6d2ae152020-09-02 13:11:20 +05301254 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001255 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301256 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001257 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301258 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001259 if err != nil {
1260 logger.Errorw("Cannot send MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001261 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001262 return nil
1263 }
1264 logger.Debug("send MBPCD-Create-msg done")
1265 return meInstance
1266 }
1267 logger.Errorw("Cannot generate MBPCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001268 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001269 return nil
1270}
1271
Himani Chawla6d2ae152020-09-02 13:11:20 +05301272func (oo *omciCC) sendCreateGemNCTPVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001273 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301274 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001275 logger.Debugw("send GemNCTP-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001276 "SequNo": strconv.FormatInt(int64(tid), 16),
1277 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1278
1279 meInstance, omciErr := me.NewGemPortNetworkCtp(params[0])
1280 if omciErr.GetError() == nil {
1281 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1282 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1283 omci.TransactionID(tid), omci.AddDefaults(true))
1284 if err != nil {
1285 logger.Errorw("Cannot encode GemNCTP for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001286 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001287 return nil
1288 }
1289
1290 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1291 if err != nil {
1292 logger.Errorw("Cannot serialize GemNCTP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001293 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001294 return nil
1295 }
1296
Himani Chawla6d2ae152020-09-02 13:11:20 +05301297 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001298 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301299 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001300 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301301 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001302 if err != nil {
1303 logger.Errorw("Cannot send GemNCTP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001304 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001305 return nil
1306 }
1307 logger.Debug("send GemNCTP-Create-msg done")
1308 return meInstance
1309 }
1310 logger.Errorw("Cannot generate GemNCTP Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001311 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001312 return nil
1313}
1314
Himani Chawla6d2ae152020-09-02 13:11:20 +05301315func (oo *omciCC) sendCreateGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001316 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301317 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001318 logger.Debugw("send GemIwTp-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001319 "SequNo": strconv.FormatInt(int64(tid), 16),
1320 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1321
1322 meInstance, omciErr := me.NewGemInterworkingTerminationPoint(params[0])
1323 if omciErr.GetError() == nil {
1324 //all SetByCreate Parameters (assumed to be) set here, for optimisation no 'AddDefaults'
1325 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1326 omci.TransactionID(tid))
1327 if err != nil {
1328 logger.Errorw("Cannot encode GemIwTp for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001329 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001330 return nil
1331 }
1332
1333 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1334 if err != nil {
1335 logger.Errorw("Cannot serialize GemIwTp create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001336 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001337 return nil
1338 }
1339
Himani Chawla6d2ae152020-09-02 13:11:20 +05301340 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001341 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301342 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001343 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301344 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001345 if err != nil {
1346 logger.Errorw("Cannot send GemIwTp create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001347 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001348 return nil
1349 }
1350 logger.Debug("send GemIwTp-Create-msg done")
1351 return meInstance
1352 }
1353 logger.Errorw("Cannot generate GemIwTp Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001354 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001355 return nil
1356}
1357
Himani Chawla6d2ae152020-09-02 13:11:20 +05301358func (oo *omciCC) sendSetTcontVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001359 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301360 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001361 logger.Debugw("send TCont-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001362 "SequNo": strconv.FormatInt(int64(tid), 16),
1363 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1364
1365 meInstance, omciErr := me.NewTCont(params[0])
1366 if omciErr.GetError() == nil {
1367 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1368 if err != nil {
1369 logger.Errorw("Cannot encode TCont for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001370 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001371 return nil
1372 }
1373
1374 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1375 if err != nil {
1376 logger.Errorw("Cannot serialize TCont set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001377 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001378 return nil
1379 }
1380
Himani Chawla6d2ae152020-09-02 13:11:20 +05301381 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001382 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301383 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001384 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301385 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001386 if err != nil {
1387 logger.Errorw("Cannot send TCont set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001388 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001389 return nil
1390 }
1391 logger.Debug("send TCont-set msg done")
1392 return meInstance
1393 }
1394 logger.Errorw("Cannot generate TCont Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001395 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001396 return nil
1397}
1398
Himani Chawla6d2ae152020-09-02 13:11:20 +05301399func (oo *omciCC) sendSetPrioQueueVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001400 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301401 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001402 logger.Debugw("send PrioQueue-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001403 "SequNo": strconv.FormatInt(int64(tid), 16),
1404 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1405
1406 meInstance, omciErr := me.NewPriorityQueue(params[0])
1407 if omciErr.GetError() == nil {
1408 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1409 if err != nil {
1410 logger.Errorw("Cannot encode PrioQueue for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001411 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001412 return nil
1413 }
1414
1415 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1416 if err != nil {
1417 logger.Errorw("Cannot serialize PrioQueue set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001418 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001419 return nil
1420 }
1421
Himani Chawla6d2ae152020-09-02 13:11:20 +05301422 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001423 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301424 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001425 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301426 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001427 if err != nil {
1428 logger.Errorw("Cannot send PrioQueue set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001429 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001430 return nil
1431 }
1432 logger.Debug("send PrioQueue-set msg done")
1433 return meInstance
1434 }
1435 logger.Errorw("Cannot generate PrioQueue Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001436 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001437 return nil
1438}
1439
Himani Chawla6d2ae152020-09-02 13:11:20 +05301440func (oo *omciCC) sendSetDot1PMapperVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001441 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301442 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001443 logger.Debugw("send 1PMapper-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001444 "SequNo": strconv.FormatInt(int64(tid), 16),
1445 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1446
1447 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(params[0])
1448 if omciErr.GetError() == nil {
1449 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1450 if err != nil {
1451 logger.Errorw("Cannot encode 1PMapper for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001452 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001453 return nil
1454 }
1455
1456 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1457 if err != nil {
1458 logger.Errorw("Cannot serialize 1PMapper set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001459 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001460 return nil
1461 }
1462
Himani Chawla6d2ae152020-09-02 13:11:20 +05301463 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001464 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301465 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001466 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301467 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001468 if err != nil {
1469 logger.Errorw("Cannot send 1PMapper set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001470 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001471 return nil
1472 }
1473 logger.Debug("send 1PMapper-set msg done")
1474 return meInstance
1475 }
1476 logger.Errorw("Cannot generate 1PMapper Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001477 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001478 return nil
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001479}
mpagenkodff5dda2020-08-28 11:52:01 +00001480
Himani Chawla6d2ae152020-09-02 13:11:20 +05301481func (oo *omciCC) sendCreateVtfdVar(ctx context.Context, timeout int, highPrio bool,
mpagenkodff5dda2020-08-28 11:52:01 +00001482 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301483 tid := oo.getNextTid(highPrio)
mpagenkodff5dda2020-08-28 11:52:01 +00001484 logger.Debugw("send VTFD-Create-msg:", log.Fields{"device-id": oo.deviceID,
1485 "SequNo": strconv.FormatInt(int64(tid), 16),
1486 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1487
1488 meInstance, omciErr := me.NewVlanTaggingFilterData(params[0])
1489 if omciErr.GetError() == nil {
1490 //all SetByCreate Parameters (assumed to be) set here, for optimisation no 'AddDefaults'
1491 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1492 omci.TransactionID(tid))
1493 if err != nil {
1494 logger.Errorw("Cannot encode VTFD for create", log.Fields{
1495 "Err": err, "device-id": oo.deviceID})
1496 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1497 // return (dual format) error code that can be used at caller for immediate error treatment
1498 // (relevant to all used sendXX() methods and their error conditions)
1499 return nil
1500 }
1501
1502 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1503 if err != nil {
1504 logger.Errorw("Cannot serialize VTFD create", log.Fields{
1505 "Err": err, "device-id": oo.deviceID})
1506 return nil
1507 }
1508
Himani Chawla6d2ae152020-09-02 13:11:20 +05301509 omciRxCallbackPair := callbackPair{
mpagenkodff5dda2020-08-28 11:52:01 +00001510 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301511 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenkodff5dda2020-08-28 11:52:01 +00001512 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301513 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenkodff5dda2020-08-28 11:52:01 +00001514 if err != nil {
1515 logger.Errorw("Cannot send VTFD create", log.Fields{
1516 "Err": err, "device-id": oo.deviceID})
1517 return nil
1518 }
1519 logger.Debug("send VTFD-Create-msg done")
1520 return meInstance
1521 }
1522 logger.Errorw("Cannot generate VTFD Instance", log.Fields{
1523 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1524 return nil
1525}
1526
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001527func (oo *omciCC) sendSetVtfdVar(ctx context.Context, timeout int, highPrio bool,
1528 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
1529 tid := oo.getNextTid(highPrio)
1530 logger.Debugw("send VTFD-Set-msg:", log.Fields{"device-id": oo.deviceID,
1531 "SequNo": strconv.FormatInt(int64(tid), 16),
1532 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1533
1534 meInstance, omciErr := me.NewVlanTaggingFilterData(params[0])
1535 if omciErr.GetError() == nil {
1536 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType,
1537 omci.TransactionID(tid))
1538 if err != nil {
1539 logger.Errorw("Cannot encode VTFD for set", log.Fields{
1540 "Err": err, "device-id": oo.deviceID})
1541 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1542 // return (dual format) error code that can be used at caller for immediate error treatment
1543 // (relevant to all used sendXX() methods and their error conditions)
1544 return nil
1545 }
1546
1547 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1548 if err != nil {
1549 logger.Errorw("Cannot serialize VTFD set", log.Fields{
1550 "Err": err, "device-id": oo.deviceID})
1551 return nil
1552 }
1553
1554 omciRxCallbackPair := callbackPair{
1555 cbKey: tid,
1556 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1557 }
1558 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1559 if err != nil {
1560 logger.Errorw("Cannot send VTFD set", log.Fields{
1561 "Err": err, "device-id": oo.deviceID})
1562 return nil
1563 }
1564 logger.Debug("send VTFD-Set-msg done")
1565 return meInstance
1566 }
1567 logger.Errorw("Cannot generate VTFD Instance", log.Fields{
1568 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1569 return nil
1570}
1571
Himani Chawla6d2ae152020-09-02 13:11:20 +05301572func (oo *omciCC) sendSetEvtocdVar(ctx context.Context, timeout int, highPrio bool,
mpagenkodff5dda2020-08-28 11:52:01 +00001573 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301574 tid := oo.getNextTid(highPrio)
mpagenkodff5dda2020-08-28 11:52:01 +00001575 logger.Debugw("send EVTOCD-Set-msg:", log.Fields{"device-id": oo.deviceID,
1576 "SequNo": strconv.FormatInt(int64(tid), 16),
1577 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1578
1579 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(params[0])
1580 if omciErr.GetError() == nil {
1581 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1582 if err != nil {
1583 logger.Errorw("Cannot encode EVTOCD for set", log.Fields{
1584 "Err": err, "device-id": oo.deviceID})
1585 return nil
1586 }
1587
1588 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1589 if err != nil {
1590 logger.Errorw("Cannot serialize EVTOCD set", log.Fields{
1591 "Err": err, "device-id": oo.deviceID})
1592 return nil
1593 }
1594
Himani Chawla6d2ae152020-09-02 13:11:20 +05301595 omciRxCallbackPair := callbackPair{
mpagenkodff5dda2020-08-28 11:52:01 +00001596 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301597 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenkodff5dda2020-08-28 11:52:01 +00001598 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301599 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenkodff5dda2020-08-28 11:52:01 +00001600 if err != nil {
1601 logger.Errorw("Cannot send EVTOCD set", log.Fields{
1602 "Err": err, "device-id": oo.deviceID})
1603 return nil
1604 }
1605 logger.Debug("send EVTOCD-set msg done")
1606 return meInstance
1607 }
1608 logger.Errorw("Cannot generate EVTOCD Instance", log.Fields{
1609 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1610 return nil
1611}
mpagenko01e726e2020-10-23 09:45:29 +00001612
1613func (oo *omciCC) sendDeleteVtfd(ctx context.Context, timeout int, highPrio bool,
1614 rxChan chan Message, aInstID uint16) *me.ManagedEntity {
1615 tid := oo.getNextTid(highPrio)
1616 logger.Debugw("send VTFD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
1617 "SequNo": strconv.FormatInt(int64(tid), 16),
1618 "InstId": strconv.FormatInt(int64(aInstID), 16)})
1619
1620 meParams := me.ParamData{EntityID: aInstID}
1621 meInstance, omciErr := me.NewVlanTaggingFilterData(meParams)
1622 if omciErr.GetError() == nil {
1623 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
1624 omci.TransactionID(tid))
1625 if err != nil {
1626 logger.Errorw("Cannot encode VTFD for delete", log.Fields{
1627 "Err": err, "device-id": oo.deviceID})
1628 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1629 // return (dual format) error code that can be used at caller for immediate error treatment
1630 // (relevant to all used sendXX() methods and their error conditions)
1631 return nil
1632 }
1633
1634 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1635 if err != nil {
1636 logger.Errorw("Cannot serialize VTFD delete", log.Fields{
1637 "Err": err, "device-id": oo.deviceID})
1638 return nil
1639 }
1640
1641 omciRxCallbackPair := callbackPair{
1642 cbKey: tid,
1643 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1644 }
1645 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1646 if err != nil {
1647 logger.Errorw("Cannot send VTFD delete", log.Fields{
1648 "Err": err, "device-id": oo.deviceID})
1649 return nil
1650 }
1651 logger.Debug("send VTFD-Delete-msg done")
1652 return meInstance
1653 }
1654 logger.Errorw("Cannot generate VTFD Instance for delete", log.Fields{
1655 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1656 return nil
1657}
ozgecanetsia422dbf32020-10-28 14:07:19 +03001658
1659func (oo *omciCC) sendCreateMulticastGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
1660 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
1661 tid := oo.getNextTid(highPrio)
1662 logger.Debugw("send MulticastGemIWTP-create-msg:", log.Fields{"device-id": oo.deviceID,
1663 "SequNo": strconv.FormatInt(int64(tid), 16),
1664 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1665
1666 meInstance, omciErr := me.NewMulticastGemInterworkingTerminationPoint(params[0])
1667 if omciErr.GetError() == nil {
1668 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
1669 omci.AddDefaults(true))
1670 if err != nil {
1671 logger.Errorw("Cannot encode MulticastGEMIWTP for create", log.Fields{"Err": err, "device-id": oo.deviceID})
1672 return nil
1673 }
1674
1675 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1676 if err != nil {
1677 logger.Errorw("Cannot serialize MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
1678 return nil
1679 }
1680
1681 omciRxCallbackPair := callbackPair{cbKey: tid,
1682 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1683 }
1684 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1685 if err != nil {
1686 logger.Errorw("Cannot send MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
1687 return nil
1688 }
1689 logger.Debug("send MulticastGEMIWTP-create-msg done")
1690 return meInstance
1691 }
1692 logger.Errorw("Cannot generate MulticastGEMIWTP Instance", log.Fields{"Err": omciErr.GetError(),
1693 "device-id": oo.deviceID})
1694 return nil
1695}
1696
1697func (oo *omciCC) sendCreateMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
1698 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
1699 tid := oo.getNextTid(highPrio)
1700 logger.Debugw("send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
1701 "SequNo": strconv.FormatInt(int64(tid), 16),
1702 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1703
1704 meInstance, omciErr := me.NewMulticastOperationsProfile(params[0])
1705 if omciErr.GetError() == nil {
1706 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
1707 omci.AddDefaults(true))
1708 if err != nil {
1709 logger.Errorw("Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
1710 "device-id": oo.deviceID})
1711 return nil
1712 }
1713
1714 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1715 if err != nil {
1716 logger.Errorw("Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
1717 "device-id": oo.deviceID})
1718 return nil
1719 }
1720
1721 omciRxCallbackPair := callbackPair{cbKey: tid,
1722 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1723 }
1724 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1725 if err != nil {
1726 logger.Errorw("Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
1727 "device-id": oo.deviceID})
1728 return nil
1729 }
1730 logger.Debug("send MulticastOperationProfile-create-msg done")
1731 return meInstance
1732 }
1733 logger.Errorw("Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
1734 "device-id": oo.deviceID})
1735 return nil
1736}
1737
1738func (oo *omciCC) sendSetMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
1739 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
1740 tid := oo.getNextTid(highPrio)
1741 logger.Debugw("send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
1742 "SequNo": strconv.FormatInt(int64(tid), 16),
1743 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1744
1745 meInstance, omciErr := me.NewMulticastOperationsProfile(params[0])
1746 if omciErr.GetError() == nil {
1747 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid),
1748 omci.AddDefaults(true))
1749 if err != nil {
1750 logger.Errorw("Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
1751 "device-id": oo.deviceID})
1752 return nil
1753 }
1754
1755 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1756 if err != nil {
1757 logger.Errorw("Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
1758 "device-id": oo.deviceID})
1759 return nil
1760 }
1761
1762 omciRxCallbackPair := callbackPair{cbKey: tid,
1763 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1764 }
1765 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1766 if err != nil {
1767 logger.Errorw("Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
1768 "device-id": oo.deviceID})
1769 return nil
1770 }
1771 logger.Debug("send MulticastOperationProfile-create-msg done")
1772 return meInstance
1773 }
1774 logger.Errorw("Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
1775 "device-id": oo.deviceID})
1776 return nil
1777}
1778
1779func (oo *omciCC) sendCreateMulticastSubConfigInfoVar(ctx context.Context, timeout int, highPrio bool,
1780 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
1781 tid := oo.getNextTid(highPrio)
1782 logger.Debugw("send MulticastSubConfigInfo-create-msg:", log.Fields{"device-id": oo.deviceID,
1783 "SequNo": strconv.FormatInt(int64(tid), 16),
1784 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1785
1786 meInstance, omciErr := me.NewMulticastSubscriberConfigInfo(params[0])
1787 if omciErr.GetError() == nil {
1788 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
1789 omci.AddDefaults(true))
1790 if err != nil {
1791 logger.Errorw("Cannot encode MulticastSubConfigInfo for create", log.Fields{"Err": err,
1792 "device-id": oo.deviceID})
1793 return nil
1794 }
1795
1796 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1797 if err != nil {
1798 logger.Errorw("Cannot serialize MulticastSubConfigInfo create", log.Fields{"Err": err,
1799 "device-id": oo.deviceID})
1800 return nil
1801 }
1802
1803 omciRxCallbackPair := callbackPair{cbKey: tid,
1804 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1805 }
1806 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1807 if err != nil {
1808 logger.Errorw("Cannot send MulticastSubConfigInfo create", log.Fields{"Err": err,
1809 "device-id": oo.deviceID})
1810 return nil
1811 }
1812 logger.Debug("send MulticastSubConfigInfo-create-msg done")
1813 return meInstance
1814 }
1815 logger.Errorw("Cannot generate MulticastSubConfigInfo Instance", log.Fields{"Err": omciErr.GetError(),
1816 "device-id": oo.deviceID})
1817 return nil
1818}