blob: 185b96e45de644f5324aae65eeafc6c333f0e1e0 [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 Hildebrandtfa074992020-03-27 15:42:06 +0000260 if byte(omciMsg.MessageType) & ^me.AK == 0 {
261 // 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
Himani Chawla6d2ae152020-09-02 13:11:20 +05301005func (oo *omciCC) sendSetUniGLS(ctx context.Context, aInstNo uint16, timeout int,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001006 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301007 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001008 logger.Debugw("send UNI-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001009 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001010
1011 // UNI-G 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.NewUniG(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 UNI-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001021 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001022 return nil
1023 }
1024
1025 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1026 if err != nil {
1027 logger.Errorw("Cannot serialize UNI-G-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001028 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001029 return nil
1030 }
1031
Himani Chawla6d2ae152020-09-02 13:11:20 +05301032 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001033 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301034 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001035 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301036 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001037 if err != nil {
1038 logger.Errorw("Cannot send UNIG-G-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001039 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001040 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001041 }
mpagenko3dbcdd22020-07-22 07:38:45 +00001042 logger.Debug("send UNI-G-Set-msg done")
1043 return meInstance
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001044 }
mpagenko3dbcdd22020-07-22 07:38:45 +00001045 logger.Errorw("Cannot generate UNI-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001046 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001047 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001048}
1049
Himani Chawla6d2ae152020-09-02 13:11:20 +05301050func (oo *omciCC) sendSetVeipLS(ctx context.Context, aInstNo uint16, timeout int,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001051 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301052 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001053 logger.Debugw("send VEIP-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001054 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001055
1056 // ONU-G ME-ID is defined to be 0, no need to perform a DB lookup
1057 meParams := me.ParamData{
1058 EntityID: aInstNo,
1059 Attributes: requestedAttributes,
1060 }
1061 meInstance, omciErr := me.NewVirtualEthernetInterfacePoint(meParams)
1062 if omciErr.GetError() == nil {
1063 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1064 if err != nil {
1065 logger.Errorw("Cannot encode VEIP instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001066 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001067 return nil
1068 }
1069
1070 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1071 if err != nil {
1072 logger.Errorw("Cannot serialize VEIP-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001073 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001074 return nil
1075 }
1076
Himani Chawla6d2ae152020-09-02 13:11:20 +05301077 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001078 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301079 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001080 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301081 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001082 if err != nil {
1083 logger.Errorw("Cannot send VEIP-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001084 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001085 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001086 }
mpagenko3dbcdd22020-07-22 07:38:45 +00001087 logger.Debug("send VEIP-Set-msg done")
1088 return meInstance
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001089 }
mpagenko3dbcdd22020-07-22 07:38:45 +00001090 logger.Errorw("Cannot generate VEIP", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001091 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001092 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001093}
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001094
Himani Chawla6d2ae152020-09-02 13:11:20 +05301095func (oo *omciCC) sendGetMe(ctx context.Context, classID me.ClassID, entityID uint16, requestedAttributes me.AttributeValueMap,
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001096 timeout int, highPrio bool) *me.ManagedEntity {
1097
Himani Chawla6d2ae152020-09-02 13:11:20 +05301098 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001099 logger.Debugw("send get-request-msg", log.Fields{"classID": classID, "device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001100 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001101
1102 meParams := me.ParamData{
1103 EntityID: entityID,
1104 Attributes: requestedAttributes,
1105 }
1106 meInstance, omciErr := me.LoadManagedEntityDefinition(classID, meParams)
1107 if omciErr.GetError() == nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301108 meClassIDName := meInstance.GetName()
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001109 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.GetRequestType, omci.TransactionID(tid))
1110 if err != nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301111 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 +00001112 return nil
1113 }
1114 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1115 if err != nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301116 logger.Errorw("Cannot serialize get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001117 return nil
1118 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301119 omciRxCallbackPair := callbackPair{
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001120 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301121 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001122 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301123 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001124 if err != nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301125 logger.Errorw("Cannot send get-request-msg", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001126 return nil
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001127 }
Himani Chawla4d908332020-08-31 12:30:20 +05301128 logger.Debugw("send get-request-msg done", log.Fields{"meClassIDName": meClassIDName, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001129 return meInstance
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001130 }
divyadesai4d299552020-08-18 07:13:49 +00001131 logger.Errorw("Cannot generate meDefinition", log.Fields{"classID": classID, "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001132 return nil
1133}
1134
Himani Chawla6d2ae152020-09-02 13:11:20 +05301135func (oo *omciCC) sendCreateDot1PMapper(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001136 aInstID uint16, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301137 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001138 logger.Debugw("send .1pMapper-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001139 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(aInstID), 16)})
1140
1141 meParams := me.ParamData{
1142 EntityID: aInstID,
1143 Attributes: me.AttributeValueMap{},
1144 }
1145 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(meParams)
1146 if omciErr.GetError() == nil {
1147 //we have to set all 'untouched' parameters to default by some additional option parameter!!
1148 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1149 omci.TransactionID(tid), omci.AddDefaults(true))
1150 if err != nil {
1151 logger.Errorw("Cannot encode .1pMapper for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001152 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001153 return nil
1154 }
1155
1156 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1157 if err != nil {
1158 logger.Errorw("Cannot serialize .1pMapper create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001159 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001160 return nil
1161 }
1162
Himani Chawla6d2ae152020-09-02 13:11:20 +05301163 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001164 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301165 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001166 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301167 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001168 if err != nil {
1169 logger.Errorw("Cannot send .1pMapper create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001170 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001171 return nil
1172 }
1173 logger.Debug("send .1pMapper-create-msg done")
1174 return meInstance
1175 }
1176 logger.Errorw("Cannot generate .1pMapper", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001177 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001178 return nil
1179}
1180
Himani Chawla6d2ae152020-09-02 13:11:20 +05301181func (oo *omciCC) sendCreateMBPConfigDataVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001182 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301183 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001184 logger.Debugw("send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001185 "SequNo": strconv.FormatInt(int64(tid), 16),
1186 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1187
1188 meInstance, omciErr := me.NewMacBridgePortConfigurationData(params[0])
1189 if omciErr.GetError() == nil {
1190 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1191 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1192 omci.TransactionID(tid), omci.AddDefaults(true))
1193 if err != nil {
1194 logger.Errorw("Cannot encode MBPCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001195 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001196 return nil
1197 }
1198
1199 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1200 if err != nil {
1201 logger.Errorw("Cannot serialize MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001202 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001203 return nil
1204 }
1205
Himani Chawla6d2ae152020-09-02 13:11:20 +05301206 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001207 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301208 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001209 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301210 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001211 if err != nil {
1212 logger.Errorw("Cannot send MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001213 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001214 return nil
1215 }
1216 logger.Debug("send MBPCD-Create-msg done")
1217 return meInstance
1218 }
1219 logger.Errorw("Cannot generate MBPCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001220 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001221 return nil
1222}
1223
Himani Chawla6d2ae152020-09-02 13:11:20 +05301224func (oo *omciCC) sendCreateGemNCTPVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001225 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301226 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001227 logger.Debugw("send GemNCTP-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001228 "SequNo": strconv.FormatInt(int64(tid), 16),
1229 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1230
1231 meInstance, omciErr := me.NewGemPortNetworkCtp(params[0])
1232 if omciErr.GetError() == nil {
1233 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1234 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1235 omci.TransactionID(tid), omci.AddDefaults(true))
1236 if err != nil {
1237 logger.Errorw("Cannot encode GemNCTP for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001238 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001239 return nil
1240 }
1241
1242 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1243 if err != nil {
1244 logger.Errorw("Cannot serialize GemNCTP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001245 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001246 return nil
1247 }
1248
Himani Chawla6d2ae152020-09-02 13:11:20 +05301249 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001250 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301251 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001252 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301253 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001254 if err != nil {
1255 logger.Errorw("Cannot send GemNCTP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001256 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001257 return nil
1258 }
1259 logger.Debug("send GemNCTP-Create-msg done")
1260 return meInstance
1261 }
1262 logger.Errorw("Cannot generate GemNCTP Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001263 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001264 return nil
1265}
1266
Himani Chawla6d2ae152020-09-02 13:11:20 +05301267func (oo *omciCC) sendCreateGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001268 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301269 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001270 logger.Debugw("send GemIwTp-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001271 "SequNo": strconv.FormatInt(int64(tid), 16),
1272 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1273
1274 meInstance, omciErr := me.NewGemInterworkingTerminationPoint(params[0])
1275 if omciErr.GetError() == nil {
1276 //all SetByCreate Parameters (assumed to be) set here, for optimisation no 'AddDefaults'
1277 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1278 omci.TransactionID(tid))
1279 if err != nil {
1280 logger.Errorw("Cannot encode GemIwTp for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001281 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001282 return nil
1283 }
1284
1285 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1286 if err != nil {
1287 logger.Errorw("Cannot serialize GemIwTp create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001288 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001289 return nil
1290 }
1291
Himani Chawla6d2ae152020-09-02 13:11:20 +05301292 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001293 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301294 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001295 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301296 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001297 if err != nil {
1298 logger.Errorw("Cannot send GemIwTp create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001299 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001300 return nil
1301 }
1302 logger.Debug("send GemIwTp-Create-msg done")
1303 return meInstance
1304 }
1305 logger.Errorw("Cannot generate GemIwTp Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001306 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001307 return nil
1308}
1309
Himani Chawla6d2ae152020-09-02 13:11:20 +05301310func (oo *omciCC) sendSetTcontVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001311 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301312 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001313 logger.Debugw("send TCont-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001314 "SequNo": strconv.FormatInt(int64(tid), 16),
1315 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1316
1317 meInstance, omciErr := me.NewTCont(params[0])
1318 if omciErr.GetError() == nil {
1319 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1320 if err != nil {
1321 logger.Errorw("Cannot encode TCont for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001322 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001323 return nil
1324 }
1325
1326 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1327 if err != nil {
1328 logger.Errorw("Cannot serialize TCont set", 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
Himani Chawla6d2ae152020-09-02 13:11:20 +05301333 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001334 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301335 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001336 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301337 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001338 if err != nil {
1339 logger.Errorw("Cannot send TCont set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001340 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001341 return nil
1342 }
1343 logger.Debug("send TCont-set msg done")
1344 return meInstance
1345 }
1346 logger.Errorw("Cannot generate TCont Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001347 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001348 return nil
1349}
1350
Himani Chawla6d2ae152020-09-02 13:11:20 +05301351func (oo *omciCC) sendSetPrioQueueVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001352 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301353 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001354 logger.Debugw("send PrioQueue-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001355 "SequNo": strconv.FormatInt(int64(tid), 16),
1356 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1357
1358 meInstance, omciErr := me.NewPriorityQueue(params[0])
1359 if omciErr.GetError() == nil {
1360 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1361 if err != nil {
1362 logger.Errorw("Cannot encode PrioQueue for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001363 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001364 return nil
1365 }
1366
1367 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1368 if err != nil {
1369 logger.Errorw("Cannot serialize PrioQueue 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
Himani Chawla6d2ae152020-09-02 13:11:20 +05301374 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001375 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301376 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001377 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301378 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001379 if err != nil {
1380 logger.Errorw("Cannot send PrioQueue set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001381 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001382 return nil
1383 }
1384 logger.Debug("send PrioQueue-set msg done")
1385 return meInstance
1386 }
1387 logger.Errorw("Cannot generate PrioQueue Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001388 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001389 return nil
1390}
1391
Himani Chawla6d2ae152020-09-02 13:11:20 +05301392func (oo *omciCC) sendSetDot1PMapperVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001393 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301394 tid := oo.getNextTid(highPrio)
divyadesai4d299552020-08-18 07:13:49 +00001395 logger.Debugw("send 1PMapper-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001396 "SequNo": strconv.FormatInt(int64(tid), 16),
1397 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1398
1399 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(params[0])
1400 if omciErr.GetError() == nil {
1401 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1402 if err != nil {
1403 logger.Errorw("Cannot encode 1PMapper for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001404 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001405 return nil
1406 }
1407
1408 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1409 if err != nil {
1410 logger.Errorw("Cannot serialize 1PMapper 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
Himani Chawla6d2ae152020-09-02 13:11:20 +05301415 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001416 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301417 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001418 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301419 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001420 if err != nil {
1421 logger.Errorw("Cannot send 1PMapper set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001422 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001423 return nil
1424 }
1425 logger.Debug("send 1PMapper-set msg done")
1426 return meInstance
1427 }
1428 logger.Errorw("Cannot generate 1PMapper Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001429 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001430 return nil
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001431}
mpagenkodff5dda2020-08-28 11:52:01 +00001432
Himani Chawla6d2ae152020-09-02 13:11:20 +05301433func (oo *omciCC) sendCreateVtfdVar(ctx context.Context, timeout int, highPrio bool,
mpagenkodff5dda2020-08-28 11:52:01 +00001434 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301435 tid := oo.getNextTid(highPrio)
mpagenkodff5dda2020-08-28 11:52:01 +00001436 logger.Debugw("send VTFD-Create-msg:", log.Fields{"device-id": oo.deviceID,
1437 "SequNo": strconv.FormatInt(int64(tid), 16),
1438 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1439
1440 meInstance, omciErr := me.NewVlanTaggingFilterData(params[0])
1441 if omciErr.GetError() == nil {
1442 //all SetByCreate Parameters (assumed to be) set here, for optimisation no 'AddDefaults'
1443 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1444 omci.TransactionID(tid))
1445 if err != nil {
1446 logger.Errorw("Cannot encode VTFD for create", log.Fields{
1447 "Err": err, "device-id": oo.deviceID})
1448 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1449 // return (dual format) error code that can be used at caller for immediate error treatment
1450 // (relevant to all used sendXX() methods and their error conditions)
1451 return nil
1452 }
1453
1454 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1455 if err != nil {
1456 logger.Errorw("Cannot serialize VTFD create", log.Fields{
1457 "Err": err, "device-id": oo.deviceID})
1458 return nil
1459 }
1460
Himani Chawla6d2ae152020-09-02 13:11:20 +05301461 omciRxCallbackPair := callbackPair{
mpagenkodff5dda2020-08-28 11:52:01 +00001462 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301463 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenkodff5dda2020-08-28 11:52:01 +00001464 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301465 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenkodff5dda2020-08-28 11:52:01 +00001466 if err != nil {
1467 logger.Errorw("Cannot send VTFD create", log.Fields{
1468 "Err": err, "device-id": oo.deviceID})
1469 return nil
1470 }
1471 logger.Debug("send VTFD-Create-msg done")
1472 return meInstance
1473 }
1474 logger.Errorw("Cannot generate VTFD Instance", log.Fields{
1475 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1476 return nil
1477}
1478
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001479func (oo *omciCC) sendSetVtfdVar(ctx context.Context, timeout int, highPrio bool,
1480 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
1481 tid := oo.getNextTid(highPrio)
1482 logger.Debugw("send VTFD-Set-msg:", log.Fields{"device-id": oo.deviceID,
1483 "SequNo": strconv.FormatInt(int64(tid), 16),
1484 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1485
1486 meInstance, omciErr := me.NewVlanTaggingFilterData(params[0])
1487 if omciErr.GetError() == nil {
1488 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType,
1489 omci.TransactionID(tid))
1490 if err != nil {
1491 logger.Errorw("Cannot encode VTFD for set", log.Fields{
1492 "Err": err, "device-id": oo.deviceID})
1493 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1494 // return (dual format) error code that can be used at caller for immediate error treatment
1495 // (relevant to all used sendXX() methods and their error conditions)
1496 return nil
1497 }
1498
1499 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1500 if err != nil {
1501 logger.Errorw("Cannot serialize VTFD set", log.Fields{
1502 "Err": err, "device-id": oo.deviceID})
1503 return nil
1504 }
1505
1506 omciRxCallbackPair := callbackPair{
1507 cbKey: tid,
1508 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1509 }
1510 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1511 if err != nil {
1512 logger.Errorw("Cannot send VTFD set", log.Fields{
1513 "Err": err, "device-id": oo.deviceID})
1514 return nil
1515 }
1516 logger.Debug("send VTFD-Set-msg done")
1517 return meInstance
1518 }
1519 logger.Errorw("Cannot generate VTFD Instance", log.Fields{
1520 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1521 return nil
1522}
1523
Himani Chawla6d2ae152020-09-02 13:11:20 +05301524func (oo *omciCC) sendSetEvtocdVar(ctx context.Context, timeout int, highPrio bool,
mpagenkodff5dda2020-08-28 11:52:01 +00001525 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301526 tid := oo.getNextTid(highPrio)
mpagenkodff5dda2020-08-28 11:52:01 +00001527 logger.Debugw("send EVTOCD-Set-msg:", log.Fields{"device-id": oo.deviceID,
1528 "SequNo": strconv.FormatInt(int64(tid), 16),
1529 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1530
1531 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(params[0])
1532 if omciErr.GetError() == nil {
1533 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1534 if err != nil {
1535 logger.Errorw("Cannot encode EVTOCD for set", log.Fields{
1536 "Err": err, "device-id": oo.deviceID})
1537 return nil
1538 }
1539
1540 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1541 if err != nil {
1542 logger.Errorw("Cannot serialize EVTOCD set", log.Fields{
1543 "Err": err, "device-id": oo.deviceID})
1544 return nil
1545 }
1546
Himani Chawla6d2ae152020-09-02 13:11:20 +05301547 omciRxCallbackPair := callbackPair{
mpagenkodff5dda2020-08-28 11:52:01 +00001548 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301549 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenkodff5dda2020-08-28 11:52:01 +00001550 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301551 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenkodff5dda2020-08-28 11:52:01 +00001552 if err != nil {
1553 logger.Errorw("Cannot send EVTOCD set", log.Fields{
1554 "Err": err, "device-id": oo.deviceID})
1555 return nil
1556 }
1557 logger.Debug("send EVTOCD-set msg done")
1558 return meInstance
1559 }
1560 logger.Errorw("Cannot generate EVTOCD Instance", log.Fields{
1561 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1562 return nil
1563}
mpagenko01e726e2020-10-23 09:45:29 +00001564
1565func (oo *omciCC) sendDeleteVtfd(ctx context.Context, timeout int, highPrio bool,
1566 rxChan chan Message, aInstID uint16) *me.ManagedEntity {
1567 tid := oo.getNextTid(highPrio)
1568 logger.Debugw("send VTFD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
1569 "SequNo": strconv.FormatInt(int64(tid), 16),
1570 "InstId": strconv.FormatInt(int64(aInstID), 16)})
1571
1572 meParams := me.ParamData{EntityID: aInstID}
1573 meInstance, omciErr := me.NewVlanTaggingFilterData(meParams)
1574 if omciErr.GetError() == nil {
1575 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
1576 omci.TransactionID(tid))
1577 if err != nil {
1578 logger.Errorw("Cannot encode VTFD for delete", log.Fields{
1579 "Err": err, "device-id": oo.deviceID})
1580 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1581 // return (dual format) error code that can be used at caller for immediate error treatment
1582 // (relevant to all used sendXX() methods and their error conditions)
1583 return nil
1584 }
1585
1586 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1587 if err != nil {
1588 logger.Errorw("Cannot serialize VTFD delete", log.Fields{
1589 "Err": err, "device-id": oo.deviceID})
1590 return nil
1591 }
1592
1593 omciRxCallbackPair := callbackPair{
1594 cbKey: tid,
1595 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1596 }
1597 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1598 if err != nil {
1599 logger.Errorw("Cannot send VTFD delete", log.Fields{
1600 "Err": err, "device-id": oo.deviceID})
1601 return nil
1602 }
1603 logger.Debug("send VTFD-Delete-msg done")
1604 return meInstance
1605 }
1606 logger.Errorw("Cannot generate VTFD Instance for delete", log.Fields{
1607 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1608 return nil
1609}