blob: 6d336f420ce7a34168a5f4886b94843cd0e11561 [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"
dbainbri4d3a0dc2020-12-02 00:33:42 +000038 "github.com/opencord/voltha-lib-go/v4/pkg/adapters/adapterif"
Holger Hildebrandtfa074992020-03-27 15:42:06 +000039
dbainbri4d3a0dc2020-12-02 00:33:42 +000040 //"github.com/opencord/voltha-lib-go/v4/pkg/kafka"
41 "github.com/opencord/voltha-lib-go/v4/pkg/log"
42 ic "github.com/opencord/voltha-protos/v4/go/inter_container"
43 //"github.com/opencord/voltha-protos/v4/go/openflow_13"
44 //"github.com/opencord/voltha-protos/v4/go/voltha"
Holger Hildebrandtfa074992020-03-27 15:42:06 +000045)
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
mpagenko8b07c1b2020-11-26 10:36:31 +000062const unusedTcontAllocID = uint16(0xFFFF) //common unused AllocId for G.984 and G.987 systems
63
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000064// ### OMCI related definitions - end
65
Himani Chawla6d2ae152020-09-02 13:11:20 +053066//callbackPairEntry to be used for OMCI send/receive correlation
67type callbackPairEntry struct {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000068 cbRespChannel chan Message
dbainbri4d3a0dc2020-12-02 00:33:42 +000069 cbFunction func(context.Context, *omci.OMCI, *gp.Packet, chan Message) error
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000070}
71
Himani Chawla6d2ae152020-09-02 13:11:20 +053072//callbackPair to be used for ReceiveCallback init
73type callbackPair struct {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000074 cbKey uint16
Himani Chawla6d2ae152020-09-02 13:11:20 +053075 cbEntry callbackPairEntry
Holger Hildebrandtfa074992020-03-27 15:42:06 +000076}
77
78type omciTransferStructure struct {
79 txFrame []byte
80 timeout int
81 retry int
82 highPrio bool
83}
84
Himani Chawla6d2ae152020-09-02 13:11:20 +053085//omciCC structure holds information needed for OMCI communication (to/from OLT Adapter)
86type omciCC struct {
Holger Hildebrandtfa074992020-03-27 15:42:06 +000087 enabled bool
88 pOnuDeviceEntry *OnuDeviceEntry
89 deviceID string
Himani Chawla6d2ae152020-09-02 13:11:20 +053090 pBaseDeviceHandler *deviceHandler
Holger Hildebrandtfa074992020-03-27 15:42:06 +000091 coreProxy adapterif.CoreProxy
92 adapterProxy adapterif.AdapterProxy
93 supportExtMsg bool
94 //txRequest
95 //rxResponse
96 //pendingRequest
97 txFrames, txOnuFrames uint32
98 rxFrames, rxOnuFrames, rxOnuDiscards uint32
99
100 // OMCI params
101 mutexTid sync.Mutex
102 tid uint16
103 mutexHpTid sync.Mutex
104 hpTid uint16
105 uploadSequNo uint16
106 uploadNoOfCmds uint16
107
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000108 mutexTxQueue sync.Mutex
109 txQueue *list.List
110 mutexRxSchedMap sync.Mutex
Himani Chawla6d2ae152020-09-02 13:11:20 +0530111 rxSchedulerMap map[uint16]callbackPairEntry
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000112 pLastTxMeInstance *me.ManagedEntity
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000113}
114
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +0000115var responsesWithMibDataSync = []omci.MessageType{
116 omci.CreateResponseType,
117 omci.DeleteResponseType,
118 omci.SetResponseType,
119 omci.StartSoftwareDownloadResponseType,
120 omci.EndSoftwareDownloadResponseType,
121 omci.ActivateSoftwareResponseType,
122 omci.CommitSoftwareResponseType,
123}
124
Himani Chawla6d2ae152020-09-02 13:11:20 +0530125//newOmciCC constructor returns a new instance of a OmciCC
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000126//mib_db (as well as not inluded alarm_db not really used in this code? VERIFY!!)
Himani Chawla6d2ae152020-09-02 13:11:20 +0530127func newOmciCC(ctx context.Context, onuDeviceEntry *OnuDeviceEntry,
128 deviceID string, deviceHandler *deviceHandler,
129 coreProxy adapterif.CoreProxy, adapterProxy adapterif.AdapterProxy) *omciCC {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000130 logger.Debugw(ctx, "init-omciCC", log.Fields{"device-id": deviceID})
Himani Chawla6d2ae152020-09-02 13:11:20 +0530131 var omciCC omciCC
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000132 omciCC.enabled = false
Himani Chawla4d908332020-08-31 12:30:20 +0530133 omciCC.pOnuDeviceEntry = onuDeviceEntry
134 omciCC.deviceID = deviceID
135 omciCC.pBaseDeviceHandler = deviceHandler
136 omciCC.coreProxy = coreProxy
137 omciCC.adapterProxy = adapterProxy
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000138 omciCC.supportExtMsg = false
139 omciCC.txFrames = 0
140 omciCC.txOnuFrames = 0
141 omciCC.rxFrames = 0
142 omciCC.rxOnuFrames = 0
143 omciCC.rxOnuDiscards = 0
144 omciCC.tid = 0x1
145 omciCC.hpTid = 0x8000
146 omciCC.uploadSequNo = 0
147 omciCC.uploadNoOfCmds = 0
148
149 omciCC.txQueue = list.New()
Himani Chawla6d2ae152020-09-02 13:11:20 +0530150 omciCC.rxSchedulerMap = make(map[uint16]callbackPairEntry)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000151
152 return &omciCC
153}
154
mpagenko900ee4b2020-10-12 11:56:34 +0000155//stop stops/resets the omciCC
156func (oo *omciCC) stop(ctx context.Context) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000157 logger.Debugw(ctx, "omciCC-stopping", log.Fields{"device-id": oo.deviceID})
mpagenko900ee4b2020-10-12 11:56:34 +0000158 //reseting all internal data, which might also be helpful for discarding any lingering tx/rx requests
159 oo.mutexTxQueue.Lock()
160 oo.txQueue.Init() // clear the tx queue
161 oo.mutexTxQueue.Unlock()
162 oo.mutexRxSchedMap.Lock()
163 for k := range oo.rxSchedulerMap {
164 delete(oo.rxSchedulerMap, k) //clear the scheduler map
165 }
166 oo.mutexRxSchedMap.Unlock()
167 oo.mutexHpTid.Lock()
168 oo.hpTid = 0x8000 //reset the high prio transactionId
169 oo.mutexHpTid.Unlock()
170 oo.mutexTid.Lock()
171 oo.tid = 1 //reset the low prio transactionId
172 oo.mutexTid.Unlock()
173 //reset control values
174 oo.uploadSequNo = 0
175 oo.uploadNoOfCmds = 0
176 //reset the stats counter - which might be topic of discussion ...
177 oo.txFrames = 0
178 oo.txOnuFrames = 0
179 oo.rxFrames = 0
180 oo.rxOnuFrames = 0
181 oo.rxOnuDiscards = 0
182
183 return nil
184}
185
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000186// Rx handler for omci messages
Himani Chawla6d2ae152020-09-02 13:11:20 +0530187func (oo *omciCC) receiveOnuMessage(ctx context.Context, omciMsg *omci.OMCI) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000188 logger.Debugw(ctx, "rx-onu-autonomous-message", log.Fields{"omciMsgType": omciMsg.MessageType,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000189 "payload": hex.EncodeToString(omciMsg.Payload)})
190 /*
191 msgType = rxFrame.fields["message_type"] //assumed OmciOperationsValue
192 rxOnuFrames++
193
194 switch msgType {
195 case AlarmNotification:
196 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000197 logger.Info("Unhandled: received-onu-alarm-message")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000198 // python code was:
199 //if msg_type == EntityOperations.AlarmNotification.value:
200 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.Alarm_Notification)
201 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
202 //
203 return errors.New("RxAlarmNotification unimplemented")
204 }
205 case AttributeValueChange:
206 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000207 logger.Info("Unhandled: received-attribute-value-change")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000208 // python code was:
209 //elif msg_type == EntityOperations.AttributeValueChange.value:
210 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.AVC_Notification)
211 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
212 //
213 return errors.New("RxAttributeValueChange unimplemented")
214 }
215 case TestResult:
216 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000217 logger.Info("Unhandled: received-test-result")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000218 // python code was:
219 //elif msg_type == EntityOperations.TestResult.value:
220 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.Test_Result)
221 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
222 //
223 return errors.New("RxTestResult unimplemented")
224 }
225 default:
226 {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000227 logger.Errorw(ctx,"rx-onu-unsupported-autonomous-message", log.Fields{"msgType": msgType})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000228 rxOnuDiscards++
229 return errors.New("RxOnuMsgType unimplemented")
230 }
231 }
232 */
Himani Chawla4d908332020-08-31 12:30:20 +0530233 return errors.New("receiveOnuMessage unimplemented")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000234}
235
236// Rx handler for onu messages
237// e.g. would call ReceiveOnuMessage() in case of TID=0 or Action=test ...
Himani Chawla6d2ae152020-09-02 13:11:20 +0530238func (oo *omciCC) receiveMessage(ctx context.Context, rxMsg []byte) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000239 //logger.Debugw(ctx,"cc-receive-omci-message", log.Fields{"RxOmciMessage-x2s": hex.EncodeToString(rxMsg)})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000240 if len(rxMsg) >= 44 { // then it should normally include the BaseFormat trailer Len
241 // NOTE: autocorrection only valid for OmciBaseFormat, which is not specifically verified here!!!
242 // (am extendedFormat message could be destroyed this way!)
243 trailerLenData := rxMsg[42:44]
244 trailerLen := binary.BigEndian.Uint16(trailerLenData)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000245 //logger.Debugw(ctx,"omci-received-trailer-len", log.Fields{"Length": trailerLen})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000246 if trailerLen != 40 { // invalid base Format entry -> autocorrect
247 binary.BigEndian.PutUint16(rxMsg[42:44], 40)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000248 logger.Debug(ctx, "cc-corrected-omci-message: trailer len inserted")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000249 }
250 } else {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000251 logger.Errorw(ctx, "received omci-message too small for OmciBaseFormat - abort", log.Fields{"Length": len(rxMsg)})
Andrea Campanella6515c582020-10-05 11:25:00 +0200252 return fmt.Errorf("rxOmciMessage too small for BaseFormat %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000253 }
254
255 packet := gopacket.NewPacket(rxMsg, omci.LayerTypeOMCI, gopacket.NoCopy)
256 if packet == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000257 logger.Errorw(ctx, "omci-message could not be decoded", log.Fields{"device-id": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200258 return fmt.Errorf("could not decode rxMsg as OMCI %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000259 }
260 omciLayer := packet.Layer(omci.LayerTypeOMCI)
261 if omciLayer == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000262 logger.Errorw(ctx, "omci-message could not decode omci layer", log.Fields{"device-id": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200263 return fmt.Errorf("could not decode omci layer %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000264 }
265 omciMsg, ok := omciLayer.(*omci.OMCI)
266 if !ok {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000267 logger.Errorw(ctx, "omci-message could not assign omci layer", log.Fields{"device-id": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200268 return fmt.Errorf("could not assign omci layer %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000269 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000270 logger.Debugw(ctx, "omci-message-decoded:", log.Fields{"omciMsgType": omciMsg.MessageType,
mpagenko3dbcdd22020-07-22 07:38:45 +0000271 "transCorrId": strconv.FormatInt(int64(omciMsg.TransactionID), 16), "DeviceIdent": omciMsg.DeviceIdentifier})
Holger Hildebrandt2fb70892020-10-28 11:53:18 +0000272 if byte(omciMsg.MessageType)&me.AK == 0 {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000273 // Not a response
dbainbri4d3a0dc2020-12-02 00:33:42 +0000274 logger.Debug(ctx, "RxMsg is no Omci Response Message")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000275 if omciMsg.TransactionID == 0 {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530276 return oo.receiveOnuMessage(ctx, omciMsg)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000277 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000278 logger.Errorw(ctx, "Unexpected TransCorrId != 0 not accepted for autonomous messages",
Andrea Campanella6515c582020-10-05 11:25:00 +0200279 log.Fields{"msgType": omciMsg.MessageType, "payload": hex.EncodeToString(omciMsg.Payload),
mpagenko8b07c1b2020-11-26 10:36:31 +0000280 "device-id": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200281 return fmt.Errorf("autonomous Omci Message with TranSCorrId != 0 not acccepted %s", oo.deviceID)
Himani Chawla4d908332020-08-31 12:30:20 +0530282
283 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000284 //logger.Debug(ctx,"RxMsg is a Omci Response Message: try to schedule it to the requester")
Himani Chawla4d908332020-08-31 12:30:20 +0530285 oo.mutexRxSchedMap.Lock()
286 rxCallbackEntry, ok := oo.rxSchedulerMap[omciMsg.TransactionID]
287 if ok && rxCallbackEntry.cbFunction != nil {
288 //disadvantage of decoupling: error verification made difficult, but anyway the question is
289 // how to react on erroneous frame reception, maybe can simply be ignored
dbainbri4d3a0dc2020-12-02 00:33:42 +0000290 go rxCallbackEntry.cbFunction(ctx, omciMsg, &packet, rxCallbackEntry.cbRespChannel)
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +0000291 if isResponseWithMibDataSync(omciMsg.MessageType) {
292 oo.pOnuDeviceEntry.incrementMibDataSync(ctx)
293 }
Himani Chawla4d908332020-08-31 12:30:20 +0530294 // having posted the response the request is regarded as 'done'
295 delete(oo.rxSchedulerMap, omciMsg.TransactionID)
296 oo.mutexRxSchedMap.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000297 } else {
Himani Chawla4d908332020-08-31 12:30:20 +0530298 oo.mutexRxSchedMap.Unlock()
dbainbri4d3a0dc2020-12-02 00:33:42 +0000299 logger.Errorw(ctx, "omci-message-response for not registered transCorrId", log.Fields{"device-id": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200300 return fmt.Errorf("could not find registered response handler tor transCorrId %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000301 }
302
303 return nil
304 /* py code was:
305 Receive and OMCI message from the proxy channel to the OLT.
306
307 Call this from your ONU Adapter on a new OMCI Rx on the proxy channel
308 :param msg: (str) OMCI binary message (used as input to Scapy packet decoder)
309 """
310 if not self.enabled:
311 return
312
313 try:
314 now = arrow.utcnow()
315 d = None
316
317 # NOTE: Since we may need to do an independent ME map on a per-ONU basis
318 # save the current value of the entity_id_to_class_map, then
319 # replace it with our custom one before decode, and then finally
320 # restore it later. Tried other ways but really made the code messy.
321 saved_me_map = omci_entities.entity_id_to_class_map
322 omci_entities.entity_id_to_class_map = self._me_map
323
324 try:
325 rx_frame = msg if isinstance(msg, OmciFrame) else OmciFrame(msg)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000326 self.logger.debug('recv-omci-msg', omci_msg=hexlify(msg))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000327 except KeyError as e:
328 # Unknown, Unsupported, or vendor-specific ME. Key is the unknown classID
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000329 self.logger.debug('frame-decode-key-error', omci_msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000330 rx_frame = self._decode_unknown_me(msg)
331 self._rx_unknown_me += 1
332
333 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000334 self.logger.exception('frame-decode', omci_msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000335 return
336
337 finally:
338 omci_entities.entity_id_to_class_map = saved_me_map # Always restore it.
339
340 rx_tid = rx_frame.fields['transaction_id']
341 msg_type = rx_frame.fields['message_type']
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000342 self.logger.debug('Received message for rx_tid', rx_tid = rx_tid, msg_type = msg_type)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000343 # Filter the Test Result frame and route through receive onu
344 # message method.
345 if rx_tid == 0 or msg_type == EntityOperations.TestResult.value:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000346 self.logger.debug('Receive ONU message', rx_tid=0)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000347 return self._receive_onu_message(rx_frame)
348
349 # Previously unreachable if this is the very first round-trip Rx or we
350 # have been running consecutive errors
351 if self._rx_frames == 0 or self._consecutive_errors != 0:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000352 self.logger.debug('Consecutive errors for rx', err = self._consecutive_errors)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000353 self.reactor.callLater(0, self._publish_connectivity_event, True)
354
355 self._rx_frames += 1
356 self._consecutive_errors = 0
357
358 try:
359 high_priority = self._tid_is_high_priority(rx_tid)
360 index = self._get_priority_index(high_priority)
361
362 # (timestamp, defer, frame, timeout, retry, delayedCall)
363 last_tx_tuple = self._tx_request[index]
364
365 if last_tx_tuple is None or \
366 last_tx_tuple[OMCI_CC.REQUEST_FRAME].fields.get('transaction_id') != rx_tid:
367 # Possible late Rx on a message that timed-out
368 if last_tx_tuple:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000369 self.logger.debug('Unknown message', rx_tid=rx_tid,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000370 tx_id=last_tx_tuple[OMCI_CC.REQUEST_FRAME].fields.get('transaction_id'))
371 self._rx_unknown_tid += 1
372 self._rx_late += 1
373 return
374
375 ts, d, tx_frame, timeout, retry, dc = last_tx_tuple
376 if dc is not None and not dc.cancelled and not dc.called:
377 dc.cancel()
378
379 _secs = self._update_rx_tx_stats(now, ts)
380
381 # Late arrival already serviced by a timeout?
382 if d.called:
383 self._rx_late += 1
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000384 self.logger.debug('Serviced by timeout. Late arrival', rx_late = self._rx_late)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000385 return
386
387 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000388 self.logger.exception('frame-match', msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000389 if d is not None:
390 return d.errback(failure.Failure(e))
391 return
392
393 # Publish Rx event to listeners in a different task
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000394 self.logger.debug('Publish rx event', rx_tid = rx_tid,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000395 tx_tid = tx_frame.fields['transaction_id'])
396 reactor.callLater(0, self._publish_rx_frame, tx_frame, rx_frame)
397
398 # begin success callback chain (will cancel timeout and queue next Tx message)
399 self._rx_response[index] = rx_frame
400 d.callback(rx_frame)
401
402 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000403 self.logger.exception('rx-msg', e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000404 */
405}
406
Himani Chawla6d2ae152020-09-02 13:11:20 +0530407/*
408func (oo *omciCC) publishRxResponseFrame(ctx context.Context, txFrame []byte, rxFrame []byte) error {
Himani Chawla4d908332020-08-31 12:30:20 +0530409 return errors.New("publishRxResponseFrame unimplemented")
Himani Chawla6d2ae152020-09-02 13:11:20 +0530410 //def _publish_rx_frame(self, tx_frame, rx_frame):
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000411}
Himani Chawla6d2ae152020-09-02 13:11:20 +0530412*/
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000413
414//Queue the OMCI Frame for a transmit to the ONU via the proxy_channel
Himani Chawla6d2ae152020-09-02 13:11:20 +0530415func (oo *omciCC) send(ctx context.Context, txFrame []byte, timeout int, retry int, highPrio bool,
416 receiveCallbackPair callbackPair) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000417
dbainbri4d3a0dc2020-12-02 00:33:42 +0000418 logger.Debugw(ctx, "register-response-callback:", log.Fields{"for TansCorrId": receiveCallbackPair.cbKey})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000419 // it could be checked, if the callback keay is already registered - but simply overwrite may be acceptable ...
420 oo.mutexRxSchedMap.Lock()
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000421 oo.rxSchedulerMap[receiveCallbackPair.cbKey] = receiveCallbackPair.cbEntry
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000422 oo.mutexRxSchedMap.Unlock()
423
424 //just use a simple list for starting - might need some more effort, especially for multi source write access
425 omciTxRequest := omciTransferStructure{
426 txFrame,
427 timeout,
428 retry,
429 highPrio,
430 }
431 oo.mutexTxQueue.Lock()
432 oo.txQueue.PushBack(omciTxRequest) // enqueue
433 oo.mutexTxQueue.Unlock()
434
435 // for first test just bypass and send directly:
436 go oo.sendNextRequest(ctx)
437 return nil
438}
439
440//Pull next tx request and send it
Himani Chawla6d2ae152020-09-02 13:11:20 +0530441func (oo *omciCC) sendNextRequest(ctx context.Context) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000442 // return errors.New("sendNextRequest unimplemented")
443
444 // just try to get something transferred !!
445 // avoid accessing the txQueue from parallel send requests
446 // block parallel omci send requests at least until SendIAP is 'committed'
447 // that should be feasible for an onu instance as on OMCI anyway window size 1 is assumed
448 oo.mutexTxQueue.Lock()
mpagenkodff5dda2020-08-28 11:52:01 +0000449 defer oo.mutexTxQueue.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000450 for oo.txQueue.Len() > 0 {
451 queueElement := oo.txQueue.Front() // First element
452 omciTxRequest := queueElement.Value.(omciTransferStructure)
453 /* compare olt device handler code:
454 func (dh *DeviceHandler) omciIndication(omciInd *oop.OmciIndication) {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000455 logger.Debugw(ctx,"omci indication", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000456 var deviceType string
457 var deviceID string
458 var proxyDeviceID string
459
460 onuKey := dh.formOnuKey(omciInd.IntfId, omciInd.OnuId)
461
462 if onuInCache, ok := dh.onus.Load(onuKey); !ok {
463
dbainbri4d3a0dc2020-12-02 00:33:42 +0000464 logger.Debugw(ctx,"omci indication for a device not in cache.", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000465 ponPort := IntfIDToPortNo(omciInd.GetIntfId(), voltha.Port_PON_OLT)
466 kwargs := make(map[string]interface{})
467 kwargs["onu_id"] = omciInd.OnuId
468 kwargs["parent_port_no"] = ponPort
469
dbainbri4d3a0dc2020-12-02 00:33:42 +0000470 onuDevice, err := dh.coreProxy.GetChildDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, kwargs)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000471 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000472 logger.Errorw(ctx,"onu not found", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId, "error": err})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000473 return
474 }
475 deviceType = onuDevice.Type
476 deviceID = onuDevice.Id
477 proxyDeviceID = onuDevice.ProxyAddress.DeviceId
478 //if not exist in cache, then add to cache.
479 dh.onus.Store(onuKey, NewOnuDevice(deviceID, deviceType, onuDevice.SerialNumber, omciInd.OnuId, omciInd.IntfId, proxyDeviceID))
480 } else {
481 //found in cache
dbainbri4d3a0dc2020-12-02 00:33:42 +0000482 logger.Debugw(ctx,"omci indication for a device in cache.", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000483 deviceType = onuInCache.(*OnuDevice).deviceType
484 deviceID = onuInCache.(*OnuDevice).deviceID
485 proxyDeviceID = onuInCache.(*OnuDevice).proxyDeviceID
486 }
487 */
488 /* and compare onu_adapter py code:
489 omci_msg = InterAdapterOmciMessage(
490 message=bytes(frame),
491 proxy_address=self._proxy_address,
492 connect_status=self._device.connect_status)
493
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000494 self.logger.debug('sent-omci-msg', tid=tx_tid, omci_msg=hexlify(bytes(frame)))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000495
496 yield self._adapter_proxy.send_inter_adapter_message(
497 msg=omci_msg,
498 type=InterAdapterMessageType.OMCI_REQUEST,
499 from_adapter=self._device.type,
500 to_adapter=self._proxy_address.device_type,
501 to_device_id=self._device_id,
502 proxy_device_id=self._proxy_address.device_id
503 )
504 */
505 device, err := oo.coreProxy.GetDevice(ctx,
506 oo.pBaseDeviceHandler.deviceID, oo.deviceID) //parent, child
507 if err != nil || device == nil {
508 /*TODO: needs to handle error scenarios */
dbainbri4d3a0dc2020-12-02 00:33:42 +0000509 logger.Errorw(ctx, "Failed to fetch device", log.Fields{"err": err, "ParentId": oo.pBaseDeviceHandler.deviceID,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000510 "ChildId": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200511 return fmt.Errorf("failed to fetch device %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000512 }
513
dbainbri4d3a0dc2020-12-02 00:33:42 +0000514 logger.Debugw(ctx, "omci-message-to-send:", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +0000515 "TxOmciMessage": hex.EncodeToString(omciTxRequest.txFrame),
516 "device-id": oo.deviceID,
517 "toDeviceType": oo.pBaseDeviceHandler.ProxyAddressType,
518 "proxyDeviceID": oo.pBaseDeviceHandler.ProxyAddressID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000519
520 omciMsg := &ic.InterAdapterOmciMessage{Message: omciTxRequest.txFrame}
dbainbri4d3a0dc2020-12-02 00:33:42 +0000521 if sendErr := oo.adapterProxy.SendInterAdapterMessage(log.WithSpanFromContext(context.Background(), ctx), omciMsg,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000522 ic.InterAdapterMessageType_OMCI_REQUEST,
Matteo Scandoloefbec272020-11-17 10:33:09 -0800523 //fromTopic,toType,toDevId, ProxyDevId
524 oo.pOnuDeviceEntry.baseDeviceHandler.pOpenOnuAc.config.Topic, oo.pBaseDeviceHandler.ProxyAddressType,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000525 oo.deviceID, oo.pBaseDeviceHandler.ProxyAddressID, ""); sendErr != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000526 logger.Errorw(ctx, "send omci request error", log.Fields{"ChildId": oo.deviceID, "error": sendErr})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000527 return sendErr
528 }
529 oo.txQueue.Remove(queueElement) // Dequeue
530 }
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000531 return nil
532}
533
Himani Chawla6d2ae152020-09-02 13:11:20 +0530534func (oo *omciCC) getNextTid(highPriority bool) uint16 {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000535 var next uint16
536 if highPriority {
mpagenko900ee4b2020-10-12 11:56:34 +0000537 oo.mutexHpTid.Lock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000538 next = oo.hpTid
Himani Chawla4d908332020-08-31 12:30:20 +0530539 oo.hpTid++
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000540 if oo.hpTid < 0x8000 {
541 oo.hpTid = 0x8000
542 }
mpagenko900ee4b2020-10-12 11:56:34 +0000543 oo.mutexHpTid.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000544 } else {
mpagenko900ee4b2020-10-12 11:56:34 +0000545 oo.mutexTid.Lock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000546 next = oo.tid
Himani Chawla4d908332020-08-31 12:30:20 +0530547 oo.tid++
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000548 if oo.tid >= 0x8000 {
549 oo.tid = 1
550 }
mpagenko900ee4b2020-10-12 11:56:34 +0000551 oo.mutexTid.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000552 }
553 return next
554}
555
556// ###################################################################################
557// # utility methods provided to work on OMCI messages
dbainbri4d3a0dc2020-12-02 00:33:42 +0000558func serialize(ctx context.Context, msgType omci.MessageType, request gopacket.SerializableLayer, tid uint16) ([]byte, error) {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000559 omciLayer := &omci.OMCI{
560 TransactionID: tid,
561 MessageType: msgType,
562 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000563 return serializeOmciLayer(ctx, omciLayer, request)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000564}
565
dbainbri4d3a0dc2020-12-02 00:33:42 +0000566func serializeOmciLayer(ctx context.Context, aOmciLayer *omci.OMCI, aRequest gopacket.SerializableLayer) ([]byte, error) {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000567 var options gopacket.SerializeOptions
568 options.FixLengths = true
569
570 buffer := gopacket.NewSerializeBuffer()
Himani Chawla4d908332020-08-31 12:30:20 +0530571 err := gopacket.SerializeLayers(buffer, options, aOmciLayer, aRequest)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000572 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000573 logger.Errorw(ctx, "Could not create goPacket Omci serial buffer", log.Fields{"Err": err})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000574 return nil, err
575 }
576 return buffer.Bytes(), nil
577}
578
Himani Chawla4d908332020-08-31 12:30:20 +0530579/*
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000580func hexEncode(omciPkt []byte) ([]byte, error) {
581 dst := make([]byte, hex.EncodedLen(len(omciPkt)))
582 hex.Encode(dst, omciPkt)
583 return dst, nil
584}
Himani Chawla4d908332020-08-31 12:30:20 +0530585*/
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000586
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000587//supply a response handler for omci response messages to be transferred to the requested FSM
dbainbri4d3a0dc2020-12-02 00:33:42 +0000588func (oo *omciCC) receiveOmciResponse(ctx context.Context, omciMsg *omci.OMCI, packet *gp.Packet, respChan chan Message) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000589
dbainbri4d3a0dc2020-12-02 00:33:42 +0000590 logger.Debugw(ctx, "omci-message-response - transfer on omciRespChannel", log.Fields{"omciMsgType": omciMsg.MessageType,
divyadesai4d299552020-08-18 07:13:49 +0000591 "transCorrId": strconv.FormatInt(int64(omciMsg.TransactionID), 16), "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000592
593 if oo.pOnuDeviceEntry == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000594 logger.Errorw(ctx, "Abort receiving OMCI response, DeviceEntryPointer is nil", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000595 "device-id": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200596 return fmt.Errorf("deviceEntryPointer is nil %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000597 }
598
599 // no further test on SeqNo is done here, assignment from rxScheduler is trusted
600 // MibSync responses are simply transferred via deviceEntry to MibSync, no specific analysis here
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000601 omciRespMsg := Message{
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000602 Type: OMCI,
603 Data: OmciMessage{
604 OmciMsg: omciMsg,
605 OmciPacket: packet,
606 },
607 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000608 //logger.Debugw(ctx,"Message to be sent into channel:", log.Fields{"mibSyncMsg": mibSyncMsg})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000609 respChan <- omciRespMsg
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000610
611 return nil
612}
613
Himani Chawla6d2ae152020-09-02 13:11:20 +0530614func (oo *omciCC) sendMibReset(ctx context.Context, timeout int, highPrio bool) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000615
dbainbri4d3a0dc2020-12-02 00:33:42 +0000616 logger.Debugw(ctx, "send MibReset-msg to:", log.Fields{"device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000617 request := &omci.MibResetRequest{
618 MeBasePacket: omci.MeBasePacket{
619 EntityClass: me.OnuDataClassID,
620 },
621 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530622 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000623 pkt, err := serialize(ctx, omci.MibResetRequestType, request, tid)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000624 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000625 logger.Errorw(ctx, "Cannot serialize MibResetRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000626 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000627 return err
628 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530629 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000630 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530631 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000632 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530633 return oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000634}
635
Himani Chawla6d2ae152020-09-02 13:11:20 +0530636func (oo *omciCC) sendReboot(ctx context.Context, timeout int, highPrio bool, responseChannel chan Message) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000637 logger.Debugw(ctx, "send Reboot-msg to:", log.Fields{"device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300638 request := &omci.RebootRequest{
639 MeBasePacket: omci.MeBasePacket{
640 EntityClass: me.OnuGClassID,
641 },
642 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530643 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000644 pkt, err := serialize(ctx, omci.RebootRequestType, request, tid)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300645 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000646 logger.Errorw(ctx, "Cannot serialize RebootRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000647 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300648 return err
649 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530650 omciRxCallbackPair := callbackPair{
ozgecanetsiae11479f2020-07-06 09:44:47 +0300651 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530652 cbEntry: callbackPairEntry{oo.pOnuDeviceEntry.omciRebootMessageReceivedChannel, oo.receiveOmciResponse},
ozgecanetsiae11479f2020-07-06 09:44:47 +0300653 }
654
Himani Chawla6d2ae152020-09-02 13:11:20 +0530655 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300656 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000657 logger.Errorw(ctx, "Cannot send RebootRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000658 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300659 return err
660 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000661 err = oo.pOnuDeviceEntry.waitForRebootResponse(ctx, responseChannel)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300662 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000663 logger.Errorw(ctx, "aborting ONU Reboot!", log.Fields{
Andrea Campanella6515c582020-10-05 11:25:00 +0200664 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300665 return err
666 }
667 return nil
668}
669
Himani Chawla6d2ae152020-09-02 13:11:20 +0530670func (oo *omciCC) sendMibUpload(ctx context.Context, timeout int, highPrio bool) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000671 logger.Debugw(ctx, "send MibUpload-msg to:", log.Fields{"device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000672 request := &omci.MibUploadRequest{
673 MeBasePacket: omci.MeBasePacket{
674 EntityClass: me.OnuDataClassID,
675 },
676 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530677 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000678 pkt, err := serialize(ctx, omci.MibUploadRequestType, request, tid)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000679 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000680 logger.Errorw(ctx, "Cannot serialize MibUploadRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000681 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000682 return err
683 }
684 oo.uploadSequNo = 0
685 oo.uploadNoOfCmds = 0
686
Himani Chawla6d2ae152020-09-02 13:11:20 +0530687 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000688 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530689 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000690 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530691 return oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000692}
693
Himani Chawla6d2ae152020-09-02 13:11:20 +0530694func (oo *omciCC) sendMibUploadNext(ctx context.Context, timeout int, highPrio bool) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000695 logger.Debugw(ctx, "send MibUploadNext-msg to:", log.Fields{"device-id": oo.deviceID, "uploadSequNo": oo.uploadSequNo})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000696 request := &omci.MibUploadNextRequest{
697 MeBasePacket: omci.MeBasePacket{
698 EntityClass: me.OnuDataClassID,
699 },
700 CommandSequenceNumber: oo.uploadSequNo,
701 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530702 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000703 pkt, err := serialize(ctx, omci.MibUploadNextRequestType, request, tid)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000704 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000705 logger.Errorw(ctx, "Cannot serialize MibUploadNextRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000706 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000707 return err
708 }
709 oo.uploadSequNo++
710
Himani Chawla6d2ae152020-09-02 13:11:20 +0530711 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000712 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530713 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000714 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530715 return oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000716}
717
Himani Chawla6d2ae152020-09-02 13:11:20 +0530718func (oo *omciCC) sendCreateGalEthernetProfile(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
719 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000720 logger.Debugw(ctx, "send GalEnetProfile-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000721 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000722
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000723 meParams := me.ParamData{
724 EntityID: galEthernetEID,
725 Attributes: me.AttributeValueMap{"MaximumGemPayloadSize": maxGemPayloadSize},
726 }
727 meInstance, omciErr := me.NewGalEthernetProfile(meParams)
728 if omciErr.GetError() == nil {
729 //all setByCreate parameters already set, no default option required ...
730 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
731 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000732 logger.Errorw(ctx, "Cannot encode GalEnetProfileInstance for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000733 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000734 return nil
735 }
736
dbainbri4d3a0dc2020-12-02 00:33:42 +0000737 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000738 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000739 logger.Errorw(ctx, "Cannot serialize GalEnetProfile create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000740 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000741 return nil
742 }
743
Himani Chawla6d2ae152020-09-02 13:11:20 +0530744 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000745 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530746 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000747 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530748 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000749 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000750 logger.Errorw(ctx, "Cannot send GalEnetProfile create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000751 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000752 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000753 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000754 logger.Debug(ctx, "send GalEnetProfile-Create-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +0000755 return meInstance
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000756 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000757 logger.Errorw(ctx, "Cannot generate GalEnetProfileInstance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000758 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000759 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000760}
761
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000762// might be needed to extend for parameter arguments, here just for setting the ConnectivityMode!!
Himani Chawla6d2ae152020-09-02 13:11:20 +0530763func (oo *omciCC) sendSetOnu2g(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
764 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000765 logger.Debugw(ctx, "send ONU2-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000766 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000767
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000768 // ONU-G ME-ID is defined to be 0, but we could verify, if the ONU really supports the desired
769 // connectivity mode 5 (in ConnCap)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000770 // By now we just use fix values to fire - this is anyway what the python adapter does
771 // read ONU-2G from DB ???? //TODO!!!
772 meParams := me.ParamData{
773 EntityID: 0,
774 Attributes: me.AttributeValueMap{"CurrentConnectivityMode": connectivityModeValue},
775 }
776 meInstance, omciErr := me.NewOnu2G(meParams)
777 if omciErr.GetError() == nil {
778 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
779 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000780 logger.Errorw(ctx, "Cannot encode ONU2-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000781 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000782 return nil
783 }
784
dbainbri4d3a0dc2020-12-02 00:33:42 +0000785 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000786 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000787 logger.Errorw(ctx, "Cannot serialize ONU2-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000788 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000789 return nil
790 }
791
Himani Chawla6d2ae152020-09-02 13:11:20 +0530792 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000793 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530794 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000795 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530796 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000797 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000798 logger.Errorw(ctx, "Cannot send ONU2-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000799 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000800 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000801 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000802 logger.Debug(ctx, "send ONU2-G-Set-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +0000803 return meInstance
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000804 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000805 logger.Errorw(ctx, "Cannot generate ONU2-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000806 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000807 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000808}
809
Himani Chawla6d2ae152020-09-02 13:11:20 +0530810func (oo *omciCC) sendCreateMBServiceProfile(ctx context.Context,
811 aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
812 tid := oo.getNextTid(highPrio)
Himani Chawla4d908332020-08-31 12:30:20 +0530813 instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000814 logger.Debugw(ctx, "send MBSP-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000815 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000816
817 meParams := me.ParamData{
818 EntityID: instID,
819 Attributes: me.AttributeValueMap{
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300820 "Priority": 0x8000,
821 "MaxAge": 20 * 256, //20s
822 "HelloTime": 2 * 256, //2s
823 "ForwardDelay": 15 * 256, //15s
824 "DynamicFilteringAgeingTime": 0,
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000825 },
826 }
827
828 meInstance, omciErr := me.NewMacBridgeServiceProfile(meParams)
829 if omciErr.GetError() == nil {
830 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
831 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
832 omci.TransactionID(tid), omci.AddDefaults(true))
833 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000834 logger.Errorw(ctx, "Cannot encode MBSP for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000835 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000836 return nil
837 }
838
dbainbri4d3a0dc2020-12-02 00:33:42 +0000839 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000840 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000841 logger.Errorw(ctx, "Cannot serialize MBSP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000842 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000843 return nil
844 }
845
Himani Chawla6d2ae152020-09-02 13:11:20 +0530846 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000847 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530848 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000849 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530850 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000851 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000852 logger.Errorw(ctx, "Cannot send MBSP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000853 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000854 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000855 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000856 logger.Debug(ctx, "send MBSP-Create-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +0000857 return meInstance
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000858 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000859 logger.Errorw(ctx, "Cannot generate MBSP Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000860 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000861 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000862}
863
Himani Chawla6d2ae152020-09-02 13:11:20 +0530864func (oo *omciCC) sendCreateMBPConfigData(ctx context.Context,
865 aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
866 tid := oo.getNextTid(highPrio)
Himani Chawla26e555c2020-08-31 12:30:20 +0530867 instID := macBridgePortAniEID + aPUniPort.entityID
dbainbri4d3a0dc2020-12-02 00:33:42 +0000868 logger.Debugw(ctx, "send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000869 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000870
871 meParams := me.ParamData{
872 EntityID: instID,
873 Attributes: me.AttributeValueMap{
Himani Chawla4d908332020-08-31 12:30:20 +0530874 "BridgeIdPointer": macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo),
875 "PortNum": aPUniPort.macBpNo,
876 "TpType": uint8(aPUniPort.portType),
Himani Chawla26e555c2020-08-31 12:30:20 +0530877 "TpPointer": aPUniPort.entityID,
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000878 },
879 }
880 meInstance, omciErr := me.NewMacBridgePortConfigurationData(meParams)
881 if omciErr.GetError() == nil {
882 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
883 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
884 omci.TransactionID(tid), omci.AddDefaults(true))
885 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000886 logger.Errorw(ctx, "Cannot encode MBPCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000887 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000888 return nil
889 }
890
dbainbri4d3a0dc2020-12-02 00:33:42 +0000891 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000892 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000893 logger.Errorw(ctx, "Cannot serialize MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000894 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000895 return nil
896 }
897
Himani Chawla6d2ae152020-09-02 13:11:20 +0530898 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000899 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530900 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000901 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530902 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000903 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000904 logger.Errorw(ctx, "Cannot send MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000905 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000906 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000907 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000908 logger.Debug(ctx, "send MBPCD-Create-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +0000909 return meInstance
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000910 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000911 logger.Errorw(ctx, "Cannot generate MBPCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000912 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000913 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000914}
915
Himani Chawla6d2ae152020-09-02 13:11:20 +0530916func (oo *omciCC) sendCreateEVTOConfigData(ctx context.Context,
917 aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
918 tid := oo.getNextTid(highPrio)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000919 //same entityId is used as for MBSP (see there), but just arbitrary ...
Himani Chawla4d908332020-08-31 12:30:20 +0530920 instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000921 logger.Debugw(ctx, "send EVTOCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000922 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000923
924 // compare python adapter code WA VOL-1311: this is not done here!
925 // (setting TPID values for the create would probably anyway be ignored by the omci lib)
926 // but perhaps we have to be aware of possible problems at get(Next) Request handling for EVTOOCD tables later ...
927 assType := uint8(2) // default AssociationType is PPTPEthUni
Himani Chawla6d2ae152020-09-02 13:11:20 +0530928 if aPUniPort.portType == uniVEIP {
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000929 assType = uint8(10) // for VEIP
930 }
931 meParams := me.ParamData{
932 EntityID: instID,
933 Attributes: me.AttributeValueMap{
934 "AssociationType": assType,
Himani Chawla26e555c2020-08-31 12:30:20 +0530935 "AssociatedMePointer": aPUniPort.entityID,
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000936 },
937 }
938 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(meParams)
939 if omciErr.GetError() == nil {
940 //all setByCreate parameters already set, no default option required ...
941 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
942 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000943 logger.Errorw(ctx, "Cannot encode EVTOCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000944 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000945 return nil
946 }
947
dbainbri4d3a0dc2020-12-02 00:33:42 +0000948 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000949 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000950 logger.Errorw(ctx, "Cannot serialize EVTOCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000951 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000952 return nil
953 }
954
Himani Chawla6d2ae152020-09-02 13:11:20 +0530955 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000956 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +0530957 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000958 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530959 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000960 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000961 logger.Errorw(ctx, "Cannot send EVTOCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000962 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000963 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000964 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000965 logger.Debug(ctx, "send EVTOCD-Create-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +0000966 return meInstance
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000967 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000968 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000969 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +0000970 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000971}
972
Himani Chawla6d2ae152020-09-02 13:11:20 +0530973func (oo *omciCC) sendSetOnuGLS(ctx context.Context, timeout int,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000974 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530975 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000976 logger.Debugw(ctx, "send ONU-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000977 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000978
979 // ONU-G ME-ID is defined to be 0, no need to perform a DB lookup
980 meParams := me.ParamData{
981 EntityID: 0,
982 Attributes: requestedAttributes,
983 }
984 meInstance, omciErr := me.NewOnuG(meParams)
985 if omciErr.GetError() == nil {
986 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
987 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000988 logger.Errorw(ctx, "Cannot encode ONU-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000989 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000990 return nil
991 }
992
dbainbri4d3a0dc2020-12-02 00:33:42 +0000993 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000994 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000995 logger.Errorw(ctx, "Cannot serialize ONU-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000996 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000997 return nil
998 }
999
Himani Chawla6d2ae152020-09-02 13:11:20 +05301000 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001001 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301002 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001003 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301004 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001005 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001006 logger.Errorw(ctx, "Cannot send ONU-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001007 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001008 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001009 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001010 logger.Debug(ctx, "send ONU-G-Set-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001011 return meInstance
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001012 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001013 logger.Errorw(ctx, "Cannot generate ONU-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001014 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001015 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001016}
1017
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001018func (oo *omciCC) sendSetPptpEthUniLS(ctx context.Context, aInstNo uint16, timeout int,
1019 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
1020 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001021 logger.Debugw(ctx, "send PPTPEthUni-Set-msg:", log.Fields{"device-id": oo.deviceID,
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001022 "SequNo": strconv.FormatInt(int64(tid), 16)})
1023
1024 // PPTPEthUni ME-ID is taken from Mib Upload stored OnuUniPort instance (argument)
1025 meParams := me.ParamData{
1026 EntityID: aInstNo,
1027 Attributes: requestedAttributes,
1028 }
1029 meInstance, omciErr := me.NewPhysicalPathTerminationPointEthernetUni(meParams)
1030 if omciErr.GetError() == nil {
1031 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1032 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001033 logger.Errorw(ctx, "Cannot encode PPTPEthUni instance for set", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001034 "Err": err, "device-id": oo.deviceID})
1035 return nil
1036 }
1037
dbainbri4d3a0dc2020-12-02 00:33:42 +00001038 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001039 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001040 logger.Errorw(ctx, "Cannot serialize PPTPEthUni-Set", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001041 "Err": err, "device-id": oo.deviceID})
1042 return nil
1043 }
1044
1045 omciRxCallbackPair := callbackPair{
1046 cbKey: tid,
1047 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1048 }
1049 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1050 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001051 logger.Errorw(ctx, "Cannot send PPTPEthUni-Set", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001052 "Err": err, "device-id": oo.deviceID})
1053 return nil
1054 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001055 logger.Debug(ctx, "send PPTPEthUni-Set-msg done")
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001056 return meInstance
1057 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001058 logger.Errorw(ctx, "Cannot generate PPTPEthUni", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001059 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1060 return nil
1061}
1062
1063/* UniG obsolete by now, left here in case it should be needed once again
1064 UniG AdminState anyway should be ignored by ONU acc. to G988
Himani Chawla6d2ae152020-09-02 13:11:20 +05301065func (oo *omciCC) sendSetUniGLS(ctx context.Context, aInstNo uint16, timeout int,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001066 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301067 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001068 logger.Debugw(ctx,"send UNI-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001069 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001070
1071 // UNI-G ME-ID is taken from Mib Upload stored OnuUniPort instance (argument)
1072 meParams := me.ParamData{
1073 EntityID: aInstNo,
1074 Attributes: requestedAttributes,
1075 }
1076 meInstance, omciErr := me.NewUniG(meParams)
1077 if omciErr.GetError() == nil {
1078 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1079 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001080 logger.Errorw(ctx,"Cannot encode UNI-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001081 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001082 return nil
1083 }
1084
1085 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1086 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001087 logger.Errorw(ctx,"Cannot serialize UNI-G-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001088 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001089 return nil
1090 }
1091
Himani Chawla6d2ae152020-09-02 13:11:20 +05301092 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001093 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301094 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001095 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301096 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001097 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001098 logger.Errorw(ctx,"Cannot send UNIG-G-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001099 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001100 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001101 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001102 logger.Debug(ctx,"send UNI-G-Set-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001103 return meInstance
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001104 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001105 logger.Errorw(ctx,"Cannot generate UNI-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001106 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001107 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001108}
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001109*/
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001110
Himani Chawla6d2ae152020-09-02 13:11:20 +05301111func (oo *omciCC) sendSetVeipLS(ctx context.Context, aInstNo uint16, timeout int,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001112 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301113 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001114 logger.Debugw(ctx, "send VEIP-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001115 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001116
1117 // ONU-G ME-ID is defined to be 0, no need to perform a DB lookup
1118 meParams := me.ParamData{
1119 EntityID: aInstNo,
1120 Attributes: requestedAttributes,
1121 }
1122 meInstance, omciErr := me.NewVirtualEthernetInterfacePoint(meParams)
1123 if omciErr.GetError() == nil {
1124 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1125 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001126 logger.Errorw(ctx, "Cannot encode VEIP instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001127 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001128 return nil
1129 }
1130
dbainbri4d3a0dc2020-12-02 00:33:42 +00001131 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001132 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001133 logger.Errorw(ctx, "Cannot serialize VEIP-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001134 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001135 return nil
1136 }
1137
Himani Chawla6d2ae152020-09-02 13:11:20 +05301138 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001139 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301140 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001141 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301142 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001143 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001144 logger.Errorw(ctx, "Cannot send VEIP-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001145 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001146 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001147 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001148 logger.Debug(ctx, "send VEIP-Set-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001149 return meInstance
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001150 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001151 logger.Errorw(ctx, "Cannot generate VEIP", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001152 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001153 return nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001154}
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001155
Himani Chawla6d2ae152020-09-02 13:11:20 +05301156func (oo *omciCC) sendGetMe(ctx context.Context, classID me.ClassID, entityID uint16, requestedAttributes me.AttributeValueMap,
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001157 timeout int, highPrio bool) *me.ManagedEntity {
1158
Himani Chawla6d2ae152020-09-02 13:11:20 +05301159 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001160 logger.Debugw(ctx, "send get-request-msg", log.Fields{"classID": classID, "device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001161 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001162
1163 meParams := me.ParamData{
1164 EntityID: entityID,
1165 Attributes: requestedAttributes,
1166 }
1167 meInstance, omciErr := me.LoadManagedEntityDefinition(classID, meParams)
1168 if omciErr.GetError() == nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301169 meClassIDName := meInstance.GetName()
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001170 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.GetRequestType, omci.TransactionID(tid))
1171 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001172 logger.Errorf(ctx, "Cannot encode instance for get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001173 return nil
1174 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001175 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001176 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001177 logger.Errorw(ctx, "Cannot serialize get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001178 return nil
1179 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301180 omciRxCallbackPair := callbackPair{
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001181 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301182 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001183 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301184 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001185 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001186 logger.Errorw(ctx, "Cannot send get-request-msg", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001187 return nil
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001188 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001189 logger.Debugw(ctx, "send get-request-msg done", log.Fields{"meClassIDName": meClassIDName, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001190 return meInstance
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001191 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001192 logger.Errorw(ctx, "Cannot generate meDefinition", log.Fields{"classID": classID, "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001193 return nil
1194}
1195
Himani Chawla6d2ae152020-09-02 13:11:20 +05301196func (oo *omciCC) sendCreateDot1PMapper(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001197 aInstID uint16, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301198 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001199 logger.Debugw(ctx, "send .1pMapper-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001200 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(aInstID), 16)})
1201
1202 meParams := me.ParamData{
mpagenko8b5fdd22020-12-17 17:58:32 +00001203 EntityID: aInstID,
1204 Attributes: me.AttributeValueMap{
1205 //workaround for unsuitable omci-lib default values, cmp VOL-3729
1206 "TpPointer": 0xFFFF,
1207 "InterworkTpPointerForPBitPriority0": 0xFFFF,
1208 "InterworkTpPointerForPBitPriority1": 0xFFFF,
1209 "InterworkTpPointerForPBitPriority2": 0xFFFF,
1210 "InterworkTpPointerForPBitPriority3": 0xFFFF,
1211 "InterworkTpPointerForPBitPriority4": 0xFFFF,
1212 "InterworkTpPointerForPBitPriority5": 0xFFFF,
1213 "InterworkTpPointerForPBitPriority6": 0xFFFF,
1214 "InterworkTpPointerForPBitPriority7": 0xFFFF,
1215 },
mpagenko3dbcdd22020-07-22 07:38:45 +00001216 }
1217 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(meParams)
1218 if omciErr.GetError() == nil {
1219 //we have to set all 'untouched' parameters to default by some additional option parameter!!
1220 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1221 omci.TransactionID(tid), omci.AddDefaults(true))
1222 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001223 logger.Errorw(ctx, "Cannot encode .1pMapper for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001224 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001225 return nil
1226 }
1227
dbainbri4d3a0dc2020-12-02 00:33:42 +00001228 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001229 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001230 logger.Errorw(ctx, "Cannot serialize .1pMapper create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001231 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001232 return nil
1233 }
1234
Himani Chawla6d2ae152020-09-02 13:11:20 +05301235 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001236 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301237 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001238 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301239 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001240 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001241 logger.Errorw(ctx, "Cannot send .1pMapper create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001242 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001243 return nil
1244 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001245 logger.Debug(ctx, "send .1pMapper-create-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001246 return meInstance
1247 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001248 logger.Errorw(ctx, "Cannot generate .1pMapper", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001249 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001250 return nil
1251}
1252
Himani Chawla6d2ae152020-09-02 13:11:20 +05301253func (oo *omciCC) sendCreateMBPConfigDataVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001254 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301255 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001256 logger.Debugw(ctx, "send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001257 "SequNo": strconv.FormatInt(int64(tid), 16),
1258 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1259
1260 meInstance, omciErr := me.NewMacBridgePortConfigurationData(params[0])
1261 if omciErr.GetError() == nil {
1262 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1263 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1264 omci.TransactionID(tid), omci.AddDefaults(true))
1265 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001266 logger.Errorw(ctx, "Cannot encode MBPCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001267 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001268 return nil
1269 }
1270
dbainbri4d3a0dc2020-12-02 00:33:42 +00001271 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001272 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001273 logger.Errorw(ctx, "Cannot serialize MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001274 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001275 return nil
1276 }
1277
Himani Chawla6d2ae152020-09-02 13:11:20 +05301278 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001279 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301280 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001281 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301282 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001283 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001284 logger.Errorw(ctx, "Cannot send MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001285 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001286 return nil
1287 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001288 logger.Debug(ctx, "send MBPCD-Create-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001289 return meInstance
1290 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001291 logger.Errorw(ctx, "Cannot generate MBPCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001292 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001293 return nil
1294}
1295
Himani Chawla6d2ae152020-09-02 13:11:20 +05301296func (oo *omciCC) sendCreateGemNCTPVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001297 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301298 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001299 logger.Debugw(ctx, "send GemNCTP-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001300 "SequNo": strconv.FormatInt(int64(tid), 16),
1301 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1302
1303 meInstance, omciErr := me.NewGemPortNetworkCtp(params[0])
1304 if omciErr.GetError() == nil {
1305 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1306 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1307 omci.TransactionID(tid), omci.AddDefaults(true))
1308 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001309 logger.Errorw(ctx, "Cannot encode GemNCTP for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001310 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001311 return nil
1312 }
1313
dbainbri4d3a0dc2020-12-02 00:33:42 +00001314 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001315 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001316 logger.Errorw(ctx, "Cannot serialize GemNCTP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001317 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001318 return nil
1319 }
1320
Himani Chawla6d2ae152020-09-02 13:11:20 +05301321 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001322 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301323 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001324 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301325 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001326 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001327 logger.Errorw(ctx, "Cannot send GemNCTP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001328 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001329 return nil
1330 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001331 logger.Debug(ctx, "send GemNCTP-Create-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001332 return meInstance
1333 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001334 logger.Errorw(ctx, "Cannot generate GemNCTP Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001335 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001336 return nil
1337}
1338
Himani Chawla6d2ae152020-09-02 13:11:20 +05301339func (oo *omciCC) sendCreateGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001340 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301341 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001342 logger.Debugw(ctx, "send GemIwTp-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001343 "SequNo": strconv.FormatInt(int64(tid), 16),
1344 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1345
1346 meInstance, omciErr := me.NewGemInterworkingTerminationPoint(params[0])
1347 if omciErr.GetError() == nil {
1348 //all SetByCreate Parameters (assumed to be) set here, for optimisation no 'AddDefaults'
1349 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1350 omci.TransactionID(tid))
1351 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001352 logger.Errorw(ctx, "Cannot encode GemIwTp for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001353 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001354 return nil
1355 }
1356
dbainbri4d3a0dc2020-12-02 00:33:42 +00001357 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001358 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001359 logger.Errorw(ctx, "Cannot serialize GemIwTp create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001360 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001361 return nil
1362 }
1363
Himani Chawla6d2ae152020-09-02 13:11:20 +05301364 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001365 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301366 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001367 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301368 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001369 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001370 logger.Errorw(ctx, "Cannot send GemIwTp create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001371 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001372 return nil
1373 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001374 logger.Debug(ctx, "send GemIwTp-Create-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001375 return meInstance
1376 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001377 logger.Errorw(ctx, "Cannot generate GemIwTp Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001378 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001379 return nil
1380}
1381
Himani Chawla6d2ae152020-09-02 13:11:20 +05301382func (oo *omciCC) sendSetTcontVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001383 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301384 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001385 logger.Debugw(ctx, "send TCont-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001386 "SequNo": strconv.FormatInt(int64(tid), 16),
1387 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1388
1389 meInstance, omciErr := me.NewTCont(params[0])
1390 if omciErr.GetError() == nil {
1391 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1392 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001393 logger.Errorw(ctx, "Cannot encode TCont for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001394 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001395 return nil
1396 }
1397
dbainbri4d3a0dc2020-12-02 00:33:42 +00001398 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001399 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001400 logger.Errorw(ctx, "Cannot serialize TCont set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001401 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001402 return nil
1403 }
1404
Himani Chawla6d2ae152020-09-02 13:11:20 +05301405 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001406 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301407 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001408 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301409 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001410 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001411 logger.Errorw(ctx, "Cannot send TCont set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001412 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001413 return nil
1414 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001415 logger.Debug(ctx, "send TCont-set msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001416 return meInstance
1417 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001418 logger.Errorw(ctx, "Cannot generate TCont Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001419 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001420 return nil
1421}
1422
Himani Chawla6d2ae152020-09-02 13:11:20 +05301423func (oo *omciCC) sendSetPrioQueueVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001424 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301425 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001426 logger.Debugw(ctx, "send PrioQueue-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001427 "SequNo": strconv.FormatInt(int64(tid), 16),
1428 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1429
1430 meInstance, omciErr := me.NewPriorityQueue(params[0])
1431 if omciErr.GetError() == nil {
1432 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1433 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001434 logger.Errorw(ctx, "Cannot encode PrioQueue for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001435 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001436 return nil
1437 }
1438
dbainbri4d3a0dc2020-12-02 00:33:42 +00001439 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001440 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001441 logger.Errorw(ctx, "Cannot serialize PrioQueue set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001442 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001443 return nil
1444 }
1445
Himani Chawla6d2ae152020-09-02 13:11:20 +05301446 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001447 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301448 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001449 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301450 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001451 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001452 logger.Errorw(ctx, "Cannot send PrioQueue set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001453 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001454 return nil
1455 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001456 logger.Debug(ctx, "send PrioQueue-set msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001457 return meInstance
1458 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001459 logger.Errorw(ctx, "Cannot generate PrioQueue Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001460 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001461 return nil
1462}
1463
Himani Chawla6d2ae152020-09-02 13:11:20 +05301464func (oo *omciCC) sendSetDot1PMapperVar(ctx context.Context, timeout int, highPrio bool,
mpagenko3dbcdd22020-07-22 07:38:45 +00001465 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301466 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001467 logger.Debugw(ctx, "send 1PMapper-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001468 "SequNo": strconv.FormatInt(int64(tid), 16),
1469 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1470
1471 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(params[0])
1472 if omciErr.GetError() == nil {
1473 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1474 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001475 logger.Errorw(ctx, "Cannot encode 1PMapper for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001476 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001477 return nil
1478 }
1479
dbainbri4d3a0dc2020-12-02 00:33:42 +00001480 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001481 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001482 logger.Errorw(ctx, "Cannot serialize 1PMapper set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001483 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001484 return nil
1485 }
1486
Himani Chawla6d2ae152020-09-02 13:11:20 +05301487 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001488 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301489 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenko3dbcdd22020-07-22 07:38:45 +00001490 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301491 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001492 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001493 logger.Errorw(ctx, "Cannot send 1PMapper set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001494 "Err": err, "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001495 return nil
1496 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001497 logger.Debug(ctx, "send 1PMapper-set msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001498 return meInstance
1499 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001500 logger.Errorw(ctx, "Cannot generate 1PMapper Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001501 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001502 return nil
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001503}
mpagenkodff5dda2020-08-28 11:52:01 +00001504
Himani Chawla6d2ae152020-09-02 13:11:20 +05301505func (oo *omciCC) sendCreateVtfdVar(ctx context.Context, timeout int, highPrio bool,
mpagenkodff5dda2020-08-28 11:52:01 +00001506 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301507 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001508 logger.Debugw(ctx, "send VTFD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00001509 "SequNo": strconv.FormatInt(int64(tid), 16),
1510 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1511
1512 meInstance, omciErr := me.NewVlanTaggingFilterData(params[0])
1513 if omciErr.GetError() == nil {
1514 //all SetByCreate Parameters (assumed to be) set here, for optimisation no 'AddDefaults'
1515 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1516 omci.TransactionID(tid))
1517 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001518 logger.Errorw(ctx, "Cannot encode VTFD for create", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001519 "Err": err, "device-id": oo.deviceID})
1520 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1521 // return (dual format) error code that can be used at caller for immediate error treatment
1522 // (relevant to all used sendXX() methods and their error conditions)
1523 return nil
1524 }
1525
dbainbri4d3a0dc2020-12-02 00:33:42 +00001526 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenkodff5dda2020-08-28 11:52:01 +00001527 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001528 logger.Errorw(ctx, "Cannot serialize VTFD create", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001529 "Err": err, "device-id": oo.deviceID})
1530 return nil
1531 }
1532
Himani Chawla6d2ae152020-09-02 13:11:20 +05301533 omciRxCallbackPair := callbackPair{
mpagenkodff5dda2020-08-28 11:52:01 +00001534 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301535 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenkodff5dda2020-08-28 11:52:01 +00001536 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301537 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenkodff5dda2020-08-28 11:52:01 +00001538 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001539 logger.Errorw(ctx, "Cannot send VTFD create", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001540 "Err": err, "device-id": oo.deviceID})
1541 return nil
1542 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001543 logger.Debug(ctx, "send VTFD-Create-msg done")
mpagenkodff5dda2020-08-28 11:52:01 +00001544 return meInstance
1545 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001546 logger.Errorw(ctx, "Cannot generate VTFD Instance", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001547 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1548 return nil
1549}
1550
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001551// nolint: unused
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001552func (oo *omciCC) sendSetVtfdVar(ctx context.Context, timeout int, highPrio bool,
1553 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
1554 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001555 logger.Debugw(ctx, "send VTFD-Set-msg:", log.Fields{"device-id": oo.deviceID,
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001556 "SequNo": strconv.FormatInt(int64(tid), 16),
1557 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1558
1559 meInstance, omciErr := me.NewVlanTaggingFilterData(params[0])
1560 if omciErr.GetError() == nil {
1561 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType,
1562 omci.TransactionID(tid))
1563 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001564 logger.Errorw(ctx, "Cannot encode VTFD for set", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001565 "Err": err, "device-id": oo.deviceID})
1566 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1567 // return (dual format) error code that can be used at caller for immediate error treatment
1568 // (relevant to all used sendXX() methods and their error conditions)
1569 return nil
1570 }
1571
dbainbri4d3a0dc2020-12-02 00:33:42 +00001572 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001573 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001574 logger.Errorw(ctx, "Cannot serialize VTFD set", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001575 "Err": err, "device-id": oo.deviceID})
1576 return nil
1577 }
1578
1579 omciRxCallbackPair := callbackPair{
1580 cbKey: tid,
1581 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1582 }
1583 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1584 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001585 logger.Errorw(ctx, "Cannot send VTFD set", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001586 "Err": err, "device-id": oo.deviceID})
1587 return nil
1588 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001589 logger.Debug(ctx, "send VTFD-Set-msg done")
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001590 return meInstance
1591 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001592 logger.Errorw(ctx, "Cannot generate VTFD Instance", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001593 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1594 return nil
1595}
1596
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001597func (oo *omciCC) sendCreateEvtocdVar(ctx context.Context, timeout int, highPrio bool,
1598 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
1599 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001600 logger.Debugw(ctx, "send EVTOCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001601 "SequNo": strconv.FormatInt(int64(tid), 16),
1602 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1603
1604 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(params[0])
1605 if omciErr.GetError() == nil {
1606 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
1607 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001608 logger.Errorw(ctx, "Cannot encode EVTOCD for create", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001609 "Err": err, "device-id": oo.deviceID})
1610 return nil
1611 }
1612
dbainbri4d3a0dc2020-12-02 00:33:42 +00001613 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001614 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001615 logger.Errorw(ctx, "Cannot serialize EVTOCD create", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001616 "Err": err, "device-id": oo.deviceID})
1617 return nil
1618 }
1619
1620 omciRxCallbackPair := callbackPair{
1621 cbKey: tid,
1622 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1623 }
1624 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1625 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001626 logger.Errorw(ctx, "Cannot send EVTOCD create", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001627 "Err": err, "device-id": oo.deviceID})
1628 return nil
1629 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001630 logger.Debug(ctx, "send EVTOCD-set msg done")
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001631 return meInstance
1632 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001633 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001634 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1635 return nil
1636}
1637
Himani Chawla6d2ae152020-09-02 13:11:20 +05301638func (oo *omciCC) sendSetEvtocdVar(ctx context.Context, timeout int, highPrio bool,
mpagenkodff5dda2020-08-28 11:52:01 +00001639 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301640 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001641 logger.Debugw(ctx, "send EVTOCD-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00001642 "SequNo": strconv.FormatInt(int64(tid), 16),
1643 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1644
1645 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(params[0])
1646 if omciErr.GetError() == nil {
1647 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1648 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001649 logger.Errorw(ctx, "Cannot encode EVTOCD for set", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001650 "Err": err, "device-id": oo.deviceID})
1651 return nil
1652 }
1653
dbainbri4d3a0dc2020-12-02 00:33:42 +00001654 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenkodff5dda2020-08-28 11:52:01 +00001655 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001656 logger.Errorw(ctx, "Cannot serialize EVTOCD set", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001657 "Err": err, "device-id": oo.deviceID})
1658 return nil
1659 }
1660
Himani Chawla6d2ae152020-09-02 13:11:20 +05301661 omciRxCallbackPair := callbackPair{
mpagenkodff5dda2020-08-28 11:52:01 +00001662 cbKey: tid,
Himani Chawla6d2ae152020-09-02 13:11:20 +05301663 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
mpagenkodff5dda2020-08-28 11:52:01 +00001664 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301665 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
mpagenkodff5dda2020-08-28 11:52:01 +00001666 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001667 logger.Errorw(ctx, "Cannot send EVTOCD set", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001668 "Err": err, "device-id": oo.deviceID})
1669 return nil
1670 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001671 logger.Debug(ctx, "send EVTOCD-set msg done")
mpagenkodff5dda2020-08-28 11:52:01 +00001672 return meInstance
1673 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001674 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001675 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1676 return nil
1677}
mpagenko01e726e2020-10-23 09:45:29 +00001678
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001679func (oo *omciCC) sendDeleteEvtocd(ctx context.Context, timeout int, highPrio bool,
1680 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
1681 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001682 logger.Debugw(ctx, "send EVTOCD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001683 "SequNo": strconv.FormatInt(int64(tid), 16),
1684 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1685
1686 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(params[0])
1687 if omciErr.GetError() == nil {
1688 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid))
1689 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001690 logger.Errorw(ctx, "Cannot encode EVTOCD for delete", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001691 "Err": err, "device-id": oo.deviceID})
1692 return nil
1693 }
1694
dbainbri4d3a0dc2020-12-02 00:33:42 +00001695 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001696 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001697 logger.Errorw(ctx, "Cannot serialize EVTOCD delete", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001698 "Err": err, "device-id": oo.deviceID})
1699 return nil
1700 }
1701
1702 omciRxCallbackPair := callbackPair{
1703 cbKey: tid,
1704 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1705 }
1706 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1707 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001708 logger.Errorw(ctx, "Cannot send EVTOCD delete", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001709 "Err": err, "device-id": oo.deviceID})
1710 return nil
1711 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001712 logger.Debug(ctx, "send EVTOCD-delete msg done")
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001713 return meInstance
1714 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001715 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001716 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1717 return nil
1718}
1719
mpagenko01e726e2020-10-23 09:45:29 +00001720func (oo *omciCC) sendDeleteVtfd(ctx context.Context, timeout int, highPrio bool,
1721 rxChan chan Message, aInstID uint16) *me.ManagedEntity {
1722 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001723 logger.Debugw(ctx, "send VTFD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko01e726e2020-10-23 09:45:29 +00001724 "SequNo": strconv.FormatInt(int64(tid), 16),
1725 "InstId": strconv.FormatInt(int64(aInstID), 16)})
1726
1727 meParams := me.ParamData{EntityID: aInstID}
1728 meInstance, omciErr := me.NewVlanTaggingFilterData(meParams)
1729 if omciErr.GetError() == nil {
1730 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
1731 omci.TransactionID(tid))
1732 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001733 logger.Errorw(ctx, "Cannot encode VTFD for delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001734 "Err": err, "device-id": oo.deviceID})
1735 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1736 // return (dual format) error code that can be used at caller for immediate error treatment
1737 // (relevant to all used sendXX() methods and their error conditions)
1738 return nil
1739 }
1740
dbainbri4d3a0dc2020-12-02 00:33:42 +00001741 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko01e726e2020-10-23 09:45:29 +00001742 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001743 logger.Errorw(ctx, "Cannot serialize VTFD delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001744 "Err": err, "device-id": oo.deviceID})
1745 return nil
1746 }
1747
1748 omciRxCallbackPair := callbackPair{
1749 cbKey: tid,
1750 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1751 }
1752 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1753 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001754 logger.Errorw(ctx, "Cannot send VTFD delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001755 "Err": err, "device-id": oo.deviceID})
1756 return nil
1757 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001758 logger.Debug(ctx, "send VTFD-Delete-msg done")
mpagenko01e726e2020-10-23 09:45:29 +00001759 return meInstance
1760 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001761 logger.Errorw(ctx, "Cannot generate VTFD Instance for delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001762 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1763 return nil
1764}
ozgecanetsia422dbf32020-10-28 14:07:19 +03001765
mpagenko8b07c1b2020-11-26 10:36:31 +00001766func (oo *omciCC) sendDeleteGemIWTP(ctx context.Context, timeout int, highPrio bool,
1767 rxChan chan Message, aInstID uint16) *me.ManagedEntity {
1768 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001769 logger.Debugw(ctx, "send GemIwTp-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00001770 "SequNo": strconv.FormatInt(int64(tid), 16),
1771 "InstId": strconv.FormatInt(int64(aInstID), 16)})
1772
1773 meParams := me.ParamData{EntityID: aInstID}
1774 meInstance, omciErr := me.NewGemInterworkingTerminationPoint(meParams)
1775 if omciErr.GetError() == nil {
1776 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
1777 omci.TransactionID(tid))
1778 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001779 logger.Errorw(ctx, "Cannot encode GemIwTp for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001780 "Err": err, "device-id": oo.deviceID})
1781 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1782 // return (dual format) error code that can be used at caller for immediate error treatment
1783 // (relevant to all used sendXX() methods and their error conditions)
1784 return nil
1785 }
1786
dbainbri4d3a0dc2020-12-02 00:33:42 +00001787 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00001788 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001789 logger.Errorw(ctx, "Cannot serialize GemIwTp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001790 "Err": err, "device-id": oo.deviceID})
1791 return nil
1792 }
1793
1794 omciRxCallbackPair := callbackPair{
1795 cbKey: tid,
1796 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1797 }
1798 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1799 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001800 logger.Errorw(ctx, "Cannot send GemIwTp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001801 "Err": err, "device-id": oo.deviceID})
1802 return nil
1803 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001804 logger.Debug(ctx, "send GemIwTp-Delete-msg done")
mpagenko8b07c1b2020-11-26 10:36:31 +00001805 return meInstance
1806 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001807 logger.Errorw(ctx, "Cannot generate GemIwTp Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001808 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1809 return nil
1810}
1811
1812func (oo *omciCC) sendDeleteGemNCTP(ctx context.Context, timeout int, highPrio bool,
1813 rxChan chan Message, aInstID uint16) *me.ManagedEntity {
1814 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001815 logger.Debugw(ctx, "send GemNCtp-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00001816 "SequNo": strconv.FormatInt(int64(tid), 16),
1817 "InstId": strconv.FormatInt(int64(aInstID), 16)})
1818
1819 meParams := me.ParamData{EntityID: aInstID}
1820 meInstance, omciErr := me.NewGemPortNetworkCtp(meParams)
1821 if omciErr.GetError() == nil {
1822 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
1823 omci.TransactionID(tid))
1824 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001825 logger.Errorw(ctx, "Cannot encode GemNCtp for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001826 "Err": err, "device-id": oo.deviceID})
1827 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1828 // return (dual format) error code that can be used at caller for immediate error treatment
1829 // (relevant to all used sendXX() methods and their error conditions)
1830 return nil
1831 }
1832
dbainbri4d3a0dc2020-12-02 00:33:42 +00001833 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00001834 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001835 logger.Errorw(ctx, "Cannot serialize GemNCtp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001836 "Err": err, "device-id": oo.deviceID})
1837 return nil
1838 }
1839
1840 omciRxCallbackPair := callbackPair{
1841 cbKey: tid,
1842 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1843 }
1844 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1845 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001846 logger.Errorw(ctx, "Cannot send GemNCtp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001847 "Err": err, "device-id": oo.deviceID})
1848 return nil
1849 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001850 logger.Debug(ctx, "send GemNCtp-Delete-msg done")
mpagenko8b07c1b2020-11-26 10:36:31 +00001851 return meInstance
1852 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001853 logger.Errorw(ctx, "Cannot generate GemNCtp Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001854 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1855 return nil
1856}
1857
1858func (oo *omciCC) sendDeleteDot1PMapper(ctx context.Context, timeout int, highPrio bool,
1859 rxChan chan Message, aInstID uint16) *me.ManagedEntity {
1860 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001861 logger.Debugw(ctx, "send .1pMapper-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00001862 "SequNo": strconv.FormatInt(int64(tid), 16),
1863 "InstId": strconv.FormatInt(int64(aInstID), 16)})
1864
1865 meParams := me.ParamData{EntityID: aInstID}
1866 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(meParams)
1867 if omciErr.GetError() == nil {
1868 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
1869 omci.TransactionID(tid))
1870 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001871 logger.Errorw(ctx, "Cannot encode .1pMapper for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001872 "Err": err, "device-id": oo.deviceID})
1873 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1874 // return (dual format) error code that can be used at caller for immediate error treatment
1875 // (relevant to all used sendXX() methods and their error conditions)
1876 return nil
1877 }
1878
dbainbri4d3a0dc2020-12-02 00:33:42 +00001879 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00001880 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001881 logger.Errorw(ctx, "Cannot serialize .1pMapper delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001882 "Err": err, "device-id": oo.deviceID})
1883 return nil
1884 }
1885
1886 omciRxCallbackPair := callbackPair{
1887 cbKey: tid,
1888 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1889 }
1890 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1891 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001892 logger.Errorw(ctx, "Cannot send .1pMapper delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001893 "Err": err, "device-id": oo.deviceID})
1894 return nil
1895 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001896 logger.Debug(ctx, "send .1pMapper-Delete-msg done")
mpagenko8b07c1b2020-11-26 10:36:31 +00001897 return meInstance
1898 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001899 logger.Errorw(ctx, "Cannot generate .1pMapper Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001900 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1901 return nil
1902}
1903
1904func (oo *omciCC) sendDeleteMBPConfigData(ctx context.Context, timeout int, highPrio bool,
1905 rxChan chan Message, aInstID uint16) *me.ManagedEntity {
1906 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001907 logger.Debugw(ctx, "send MBPCD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00001908 "SequNo": strconv.FormatInt(int64(tid), 16),
1909 "InstId": strconv.FormatInt(int64(aInstID), 16)})
1910
1911 meParams := me.ParamData{EntityID: aInstID}
1912 meInstance, omciErr := me.NewMacBridgePortConfigurationData(meParams)
1913 if omciErr.GetError() == nil {
1914 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
1915 omci.TransactionID(tid))
1916 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001917 logger.Errorw(ctx, "Cannot encode MBPCD for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001918 "Err": err, "device-id": oo.deviceID})
1919 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1920 // return (dual format) error code that can be used at caller for immediate error treatment
1921 // (relevant to all used sendXX() methods and their error conditions)
1922 return nil
1923 }
1924
dbainbri4d3a0dc2020-12-02 00:33:42 +00001925 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00001926 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001927 logger.Errorw(ctx, "Cannot serialize MBPCD delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001928 "Err": err, "device-id": oo.deviceID})
1929 return nil
1930 }
1931
1932 omciRxCallbackPair := callbackPair{
1933 cbKey: tid,
1934 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1935 }
1936 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1937 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001938 logger.Errorw(ctx, "Cannot send MBPCD delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001939 "Err": err, "device-id": oo.deviceID})
1940 return nil
1941 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001942 logger.Debug(ctx, "send MBPCD-Delete-msg done")
mpagenko8b07c1b2020-11-26 10:36:31 +00001943 return meInstance
1944 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001945 logger.Errorw(ctx, "Cannot generate MBPCD Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00001946 "Err": omciErr.GetError(), "device-id": oo.deviceID})
1947 return nil
1948}
1949
mpagenkofc4f56e2020-11-04 17:17:49 +00001950// nolint: unused
ozgecanetsia422dbf32020-10-28 14:07:19 +03001951func (oo *omciCC) sendCreateMulticastGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
1952 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
1953 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001954 logger.Debugw(ctx, "send MulticastGemIWTP-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03001955 "SequNo": strconv.FormatInt(int64(tid), 16),
1956 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1957
1958 meInstance, omciErr := me.NewMulticastGemInterworkingTerminationPoint(params[0])
1959 if omciErr.GetError() == nil {
1960 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
1961 omci.AddDefaults(true))
1962 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001963 logger.Errorw(ctx, "Cannot encode MulticastGEMIWTP for create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsia422dbf32020-10-28 14:07:19 +03001964 return nil
1965 }
1966
dbainbri4d3a0dc2020-12-02 00:33:42 +00001967 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03001968 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001969 logger.Errorw(ctx, "Cannot serialize MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsia422dbf32020-10-28 14:07:19 +03001970 return nil
1971 }
1972
1973 omciRxCallbackPair := callbackPair{cbKey: tid,
1974 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
1975 }
1976 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
1977 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001978 logger.Errorw(ctx, "Cannot send MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsia422dbf32020-10-28 14:07:19 +03001979 return nil
1980 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001981 logger.Debug(ctx, "send MulticastGEMIWTP-create-msg done")
ozgecanetsia422dbf32020-10-28 14:07:19 +03001982 return meInstance
1983 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001984 logger.Errorw(ctx, "Cannot generate MulticastGEMIWTP Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03001985 "device-id": oo.deviceID})
1986 return nil
1987}
1988
mpagenkofc4f56e2020-11-04 17:17:49 +00001989// nolint: unused
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001990func (oo *omciCC) sendSetMulticastGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
1991 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
1992 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001993 logger.Debugw(ctx, "send MulticastGemIWTP-set-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001994 "SequNo": strconv.FormatInt(int64(tid), 16),
1995 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1996
1997 meInstance, omciErr := me.NewMulticastGemInterworkingTerminationPoint(params[0])
1998 if omciErr.GetError() == nil {
1999 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid),
2000 omci.AddDefaults(true))
2001 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002002 logger.Errorw(ctx, "Cannot encode MulticastGEMIWTP for set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002003 return nil
2004 }
2005
dbainbri4d3a0dc2020-12-02 00:33:42 +00002006 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002007 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002008 logger.Errorw(ctx, "Cannot serialize MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002009 return nil
2010 }
2011
2012 omciRxCallbackPair := callbackPair{cbKey: tid,
2013 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
2014 }
2015 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
2016 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002017 logger.Errorw(ctx, "Cannot send MulticastGEMIWTP set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002018 return nil
2019 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002020 logger.Debug(ctx, "send MulticastGEMIWTP-set-msg done")
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002021 return meInstance
2022 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002023 logger.Errorw(ctx, "Cannot generate MulticastGEMIWTP Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002024 "device-id": oo.deviceID})
2025 return nil
2026}
2027
2028// nolint: unused
ozgecanetsia422dbf32020-10-28 14:07:19 +03002029func (oo *omciCC) sendCreateMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
2030 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
2031 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002032 logger.Debugw(ctx, "send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002033 "SequNo": strconv.FormatInt(int64(tid), 16),
2034 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2035
2036 meInstance, omciErr := me.NewMulticastOperationsProfile(params[0])
2037 if omciErr.GetError() == nil {
2038 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2039 omci.AddDefaults(true))
2040 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002041 logger.Errorw(ctx, "Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002042 "device-id": oo.deviceID})
2043 return nil
2044 }
2045
dbainbri4d3a0dc2020-12-02 00:33:42 +00002046 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002047 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002048 logger.Errorw(ctx, "Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002049 "device-id": oo.deviceID})
2050 return nil
2051 }
2052
2053 omciRxCallbackPair := callbackPair{cbKey: tid,
2054 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
2055 }
2056 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
2057 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002058 logger.Errorw(ctx, "Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002059 "device-id": oo.deviceID})
2060 return nil
2061 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002062 logger.Debug(ctx, "send MulticastOperationProfile-create-msg done")
ozgecanetsia422dbf32020-10-28 14:07:19 +03002063 return meInstance
2064 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002065 logger.Errorw(ctx, "Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03002066 "device-id": oo.deviceID})
2067 return nil
2068}
2069
mpagenkofc4f56e2020-11-04 17:17:49 +00002070// nolint: unused
ozgecanetsia422dbf32020-10-28 14:07:19 +03002071func (oo *omciCC) sendSetMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
2072 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
2073 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002074 logger.Debugw(ctx, "send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002075 "SequNo": strconv.FormatInt(int64(tid), 16),
2076 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2077
2078 meInstance, omciErr := me.NewMulticastOperationsProfile(params[0])
2079 if omciErr.GetError() == nil {
2080 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid),
2081 omci.AddDefaults(true))
2082 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002083 logger.Errorw(ctx, "Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002084 "device-id": oo.deviceID})
2085 return nil
2086 }
2087
dbainbri4d3a0dc2020-12-02 00:33:42 +00002088 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002089 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002090 logger.Errorw(ctx, "Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002091 "device-id": oo.deviceID})
2092 return nil
2093 }
2094
2095 omciRxCallbackPair := callbackPair{cbKey: tid,
2096 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
2097 }
2098 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
2099 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002100 logger.Errorw(ctx, "Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002101 "device-id": oo.deviceID})
2102 return nil
2103 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002104 logger.Debug(ctx, "send MulticastOperationProfile-create-msg done")
ozgecanetsia422dbf32020-10-28 14:07:19 +03002105 return meInstance
2106 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002107 logger.Errorw(ctx, "Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03002108 "device-id": oo.deviceID})
2109 return nil
2110}
2111
mpagenkofc4f56e2020-11-04 17:17:49 +00002112// nolint: unused
ozgecanetsia422dbf32020-10-28 14:07:19 +03002113func (oo *omciCC) sendCreateMulticastSubConfigInfoVar(ctx context.Context, timeout int, highPrio bool,
2114 rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
2115 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002116 logger.Debugw(ctx, "send MulticastSubConfigInfo-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002117 "SequNo": strconv.FormatInt(int64(tid), 16),
2118 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2119
2120 meInstance, omciErr := me.NewMulticastSubscriberConfigInfo(params[0])
2121 if omciErr.GetError() == nil {
2122 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2123 omci.AddDefaults(true))
2124 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002125 logger.Errorw(ctx, "Cannot encode MulticastSubConfigInfo for create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002126 "device-id": oo.deviceID})
2127 return nil
2128 }
2129
dbainbri4d3a0dc2020-12-02 00:33:42 +00002130 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002131 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002132 logger.Errorw(ctx, "Cannot serialize MulticastSubConfigInfo create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002133 "device-id": oo.deviceID})
2134 return nil
2135 }
2136
2137 omciRxCallbackPair := callbackPair{cbKey: tid,
2138 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
2139 }
2140 err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
2141 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002142 logger.Errorw(ctx, "Cannot send MulticastSubConfigInfo create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002143 "device-id": oo.deviceID})
2144 return nil
2145 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002146 logger.Debug(ctx, "send MulticastSubConfigInfo-create-msg done")
ozgecanetsia422dbf32020-10-28 14:07:19 +03002147 return meInstance
2148 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002149 logger.Errorw(ctx, "Cannot generate MulticastSubConfigInfo Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03002150 "device-id": oo.deviceID})
2151 return nil
2152}
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +00002153
2154func isResponseWithMibDataSync(msgType omci.MessageType) bool {
2155 for _, v := range responsesWithMibDataSync {
2156 if v == msgType {
2157 return true
2158 }
2159 }
2160 return false
2161}