blob: 0e3b8a5a3671ddccc778b51b24dde79eaae5482b [file] [log] [blame]
Holger Hildebrandtfa074992020-03-27 15:42:06 +00001/*
2 * Copyright 2020-present Open Networking Foundation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +000017//Package adaptercoreonu provides the utility for onu devices, flows and statistics
18package adaptercoreonu
Holger Hildebrandtfa074992020-03-27 15:42:06 +000019
20import (
21 "container/list"
22 "context"
23 "encoding/binary"
24 "encoding/hex"
Andrea Campanella6515c582020-10-05 11:25:00 +020025 "fmt"
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000026 "strconv"
Holger Hildebrandtfa074992020-03-27 15:42:06 +000027 "sync"
mpagenko80622a52021-02-09 16:53:23 +000028 "time" //by now for testing
Holger Hildebrandtfa074992020-03-27 15:42:06 +000029
30 "github.com/google/gopacket"
31 // TODO!!! Some references could be resolved auto, but some need specific context ....
32 gp "github.com/google/gopacket"
33
34 "github.com/opencord/omci-lib-go"
35 me "github.com/opencord/omci-lib-go/generated"
dbainbri4d3a0dc2020-12-02 00:33:42 +000036 "github.com/opencord/voltha-lib-go/v4/pkg/adapters/adapterif"
Holger Hildebrandtfa074992020-03-27 15:42:06 +000037
dbainbri4d3a0dc2020-12-02 00:33:42 +000038 //"github.com/opencord/voltha-lib-go/v4/pkg/kafka"
39 "github.com/opencord/voltha-lib-go/v4/pkg/log"
40 ic "github.com/opencord/voltha-protos/v4/go/inter_container"
41 //"github.com/opencord/voltha-protos/v4/go/openflow_13"
42 //"github.com/opencord/voltha-protos/v4/go/voltha"
Holger Hildebrandtfa074992020-03-27 15:42:06 +000043)
44
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000045// ### OMCI related definitions - retrieved from Python adapter code/trace ####
Himani Chawla6d2ae152020-09-02 13:11:20 +053046
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000047const galEthernetEID = uint16(1)
48const maxGemPayloadSize = uint16(48)
49const connectivityModeValue = uint8(5)
Himani Chawla4d908332020-08-31 12:30:20 +053050
51//const defaultTPID = uint16(0x8100)
52//const broadComDefaultVID = uint16(4091)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000053const macBridgeServiceProfileEID = uint16(0x201) // TODO: most all these need better definition or tuning
54const ieeeMapperServiceProfileEID = uint16(0x8001)
55const macBridgePortAniEID = uint16(0x2102)
56
mpagenko8b07c1b2020-11-26 10:36:31 +000057const unusedTcontAllocID = uint16(0xFFFF) //common unused AllocId for G.984 and G.987 systems
58
mpagenkoc8bba412021-01-15 15:38:44 +000059const cOmciBaseMessageTrailerLen = 40
60
61// tOmciReceiveError - enum type for detected problems/errors in the received OMCI message (format)
62type tOmciReceiveError uint8
63
64const (
65 // cOmciMessageReceiveNoError - default start state
66 cOmciMessageReceiveNoError tOmciReceiveError = iota
67 // Error indication wrong trailer length within the message
68 cOmciMessageReceiveErrorTrailerLen
69 // Error indication missing trailer within the message
70 cOmciMessageReceiveErrorMissTrailer
71)
72
Holger Hildebrandt366ef192021-05-05 11:07:44 +000073const cDefaultRetries = 2
74
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +000075// ### OMCI related definitions - end
76
Himani Chawla6d2ae152020-09-02 13:11:20 +053077//callbackPairEntry to be used for OMCI send/receive correlation
78type callbackPairEntry struct {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000079 cbRespChannel chan Message
dbainbri4d3a0dc2020-12-02 00:33:42 +000080 cbFunction func(context.Context, *omci.OMCI, *gp.Packet, chan Message) error
mpagenko80622a52021-02-09 16:53:23 +000081 framePrint bool //true for printing
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000082}
83
Himani Chawla6d2ae152020-09-02 13:11:20 +053084//callbackPair to be used for ReceiveCallback init
85type callbackPair struct {
Holger Hildebrandtccd390c2020-05-29 13:49:04 +000086 cbKey uint16
Himani Chawla6d2ae152020-09-02 13:11:20 +053087 cbEntry callbackPairEntry
Holger Hildebrandtfa074992020-03-27 15:42:06 +000088}
89
90type omciTransferStructure struct {
mpagenko80622a52021-02-09 16:53:23 +000091 txFrame []byte
92 timeout int
Holger Hildebrandt366ef192021-05-05 11:07:44 +000093 retries int
mpagenko80622a52021-02-09 16:53:23 +000094 highPrio bool
95 withFramePrint bool
Holger Hildebrandt366ef192021-05-05 11:07:44 +000096 cbPair callbackPair
97 chSuccess chan bool
Holger Hildebrandtfa074992020-03-27 15:42:06 +000098}
99
Himani Chawla6d2ae152020-09-02 13:11:20 +0530100//omciCC structure holds information needed for OMCI communication (to/from OLT Adapter)
101type omciCC struct {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000102 enabled bool
103 pOnuDeviceEntry *OnuDeviceEntry
104 deviceID string
Himani Chawla6d2ae152020-09-02 13:11:20 +0530105 pBaseDeviceHandler *deviceHandler
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000106 coreProxy adapterif.CoreProxy
107 adapterProxy adapterif.AdapterProxy
108 supportExtMsg bool
mpagenkoc8bba412021-01-15 15:38:44 +0000109 rxOmciFrameError tOmciReceiveError
110
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000111 txFrames, txOnuFrames uint32
112 rxFrames, rxOnuFrames, rxOnuDiscards uint32
113
114 // OMCI params
115 mutexTid sync.Mutex
116 tid uint16
117 mutexHpTid sync.Mutex
118 hpTid uint16
119 uploadSequNo uint16
120 uploadNoOfCmds uint16
121
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000122 mutexTxQueue sync.Mutex
123 txQueue *list.List
124 mutexRxSchedMap sync.Mutex
125 rxSchedulerMap map[uint16]callbackPairEntry
126 mutexMonReq sync.RWMutex
127 monitoredRequests map[uint16]omciTransferStructure
128 mutexPLastTxMeInstance sync.RWMutex
129 pLastTxMeInstance *me.ManagedEntity
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000130}
131
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +0000132var responsesWithMibDataSync = []omci.MessageType{
133 omci.CreateResponseType,
134 omci.DeleteResponseType,
135 omci.SetResponseType,
136 omci.StartSoftwareDownloadResponseType,
137 omci.EndSoftwareDownloadResponseType,
138 omci.ActivateSoftwareResponseType,
139 omci.CommitSoftwareResponseType,
140}
141
Himani Chawla6d2ae152020-09-02 13:11:20 +0530142//newOmciCC constructor returns a new instance of a OmciCC
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000143//mib_db (as well as not inluded alarm_db not really used in this code? VERIFY!!)
Himani Chawla6d2ae152020-09-02 13:11:20 +0530144func newOmciCC(ctx context.Context, onuDeviceEntry *OnuDeviceEntry,
145 deviceID string, deviceHandler *deviceHandler,
146 coreProxy adapterif.CoreProxy, adapterProxy adapterif.AdapterProxy) *omciCC {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000147 logger.Debugw(ctx, "init-omciCC", log.Fields{"device-id": deviceID})
Himani Chawla6d2ae152020-09-02 13:11:20 +0530148 var omciCC omciCC
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000149 omciCC.enabled = false
Himani Chawla4d908332020-08-31 12:30:20 +0530150 omciCC.pOnuDeviceEntry = onuDeviceEntry
151 omciCC.deviceID = deviceID
152 omciCC.pBaseDeviceHandler = deviceHandler
153 omciCC.coreProxy = coreProxy
154 omciCC.adapterProxy = adapterProxy
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000155 omciCC.supportExtMsg = false
mpagenkoc8bba412021-01-15 15:38:44 +0000156 omciCC.rxOmciFrameError = cOmciMessageReceiveNoError
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000157 omciCC.txFrames = 0
158 omciCC.txOnuFrames = 0
159 omciCC.rxFrames = 0
160 omciCC.rxOnuFrames = 0
161 omciCC.rxOnuDiscards = 0
162 omciCC.tid = 0x1
163 omciCC.hpTid = 0x8000
164 omciCC.uploadSequNo = 0
165 omciCC.uploadNoOfCmds = 0
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000166 omciCC.txQueue = list.New()
Himani Chawla6d2ae152020-09-02 13:11:20 +0530167 omciCC.rxSchedulerMap = make(map[uint16]callbackPairEntry)
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000168 omciCC.monitoredRequests = make(map[uint16]omciTransferStructure)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000169
170 return &omciCC
171}
172
mpagenko900ee4b2020-10-12 11:56:34 +0000173//stop stops/resets the omciCC
174func (oo *omciCC) stop(ctx context.Context) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000175 logger.Debugw(ctx, "omciCC-stopping", log.Fields{"device-id": oo.deviceID})
mpagenko900ee4b2020-10-12 11:56:34 +0000176 //reseting all internal data, which might also be helpful for discarding any lingering tx/rx requests
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000177 oo.CancelRequestMonitoring()
mpagenko900ee4b2020-10-12 11:56:34 +0000178 oo.mutexTxQueue.Lock()
179 oo.txQueue.Init() // clear the tx queue
180 oo.mutexTxQueue.Unlock()
181 oo.mutexRxSchedMap.Lock()
182 for k := range oo.rxSchedulerMap {
183 delete(oo.rxSchedulerMap, k) //clear the scheduler map
184 }
185 oo.mutexRxSchedMap.Unlock()
186 oo.mutexHpTid.Lock()
187 oo.hpTid = 0x8000 //reset the high prio transactionId
188 oo.mutexHpTid.Unlock()
189 oo.mutexTid.Lock()
190 oo.tid = 1 //reset the low prio transactionId
191 oo.mutexTid.Unlock()
192 //reset control values
193 oo.uploadSequNo = 0
194 oo.uploadNoOfCmds = 0
mpagenkoc8bba412021-01-15 15:38:44 +0000195 oo.rxOmciFrameError = cOmciMessageReceiveNoError
mpagenko900ee4b2020-10-12 11:56:34 +0000196 //reset the stats counter - which might be topic of discussion ...
197 oo.txFrames = 0
198 oo.txOnuFrames = 0
199 oo.rxFrames = 0
200 oo.rxOnuFrames = 0
201 oo.rxOnuDiscards = 0
202
203 return nil
204}
205
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000206// Rx handler for omci messages
Himani Chawlaac1f5ad2021-02-04 21:21:54 +0530207func (oo *omciCC) receiveOnuMessage(ctx context.Context, omciMsg *omci.OMCI, packet *gp.Packet) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000208 logger.Debugw(ctx, "rx-onu-autonomous-message", log.Fields{"omciMsgType": omciMsg.MessageType,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000209 "payload": hex.EncodeToString(omciMsg.Payload)})
Himani Chawlaac1f5ad2021-02-04 21:21:54 +0530210 switch omciMsg.MessageType {
211 case omci.AlarmNotificationType:
212 data := OmciMessage{
213 OmciMsg: omciMsg,
214 OmciPacket: packet,
215 }
216 go oo.pBaseDeviceHandler.pAlarmMgr.handleOmciAlarmNotificationMessage(ctx, data)
217 return nil
218 default:
219 return fmt.Errorf("receiveOnuMessageType %s unimplemented", omciMsg.MessageType.String())
220 }
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000221 /*
222 msgType = rxFrame.fields["message_type"] //assumed OmciOperationsValue
223 rxOnuFrames++
224
225 switch msgType {
226 case AlarmNotification:
227 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000228 logger.Info("Unhandled: received-onu-alarm-message")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000229 // python code was:
230 //if msg_type == EntityOperations.AlarmNotification.value:
231 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.Alarm_Notification)
232 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
233 //
234 return errors.New("RxAlarmNotification unimplemented")
235 }
236 case AttributeValueChange:
237 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000238 logger.Info("Unhandled: received-attribute-value-change")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000239 // python code was:
240 //elif msg_type == EntityOperations.AttributeValueChange.value:
241 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.AVC_Notification)
242 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
243 //
244 return errors.New("RxAttributeValueChange unimplemented")
245 }
246 case TestResult:
247 {
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000248 logger.Info("Unhandled: received-test-result")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000249 // python code was:
250 //elif msg_type == EntityOperations.TestResult.value:
251 // topic = OMCI_CC.event_bus_topic(self._device_id, RxEvent.Test_Result)
252 // self.reactor.callLater(0, self.event_bus.publish, topic, msg)
253 //
254 return errors.New("RxTestResult unimplemented")
255 }
256 default:
257 {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000258 logger.Errorw(ctx,"rx-onu-unsupported-autonomous-message", log.Fields{"msgType": msgType})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000259 rxOnuDiscards++
260 return errors.New("RxOnuMsgType unimplemented")
261 }
262 }
263 */
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000264}
265
mpagenko80622a52021-02-09 16:53:23 +0000266func (oo *omciCC) printRxMessage(ctx context.Context, rxMsg []byte) {
267 //assuming omci message content is hex coded!
268 // with restricted output of 16bytes would be ...rxMsg[:16]
269 logger.Debugw(ctx, "omci-message-received:", log.Fields{
270 "RxOmciMessage": hex.EncodeToString(rxMsg),
271 "device-id": oo.deviceID})
272}
273
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000274// Rx handler for onu messages
275// e.g. would call ReceiveOnuMessage() in case of TID=0 or Action=test ...
Himani Chawla6d2ae152020-09-02 13:11:20 +0530276func (oo *omciCC) receiveMessage(ctx context.Context, rxMsg []byte) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000277 //logger.Debugw(ctx,"cc-receive-omci-message", log.Fields{"RxOmciMessage-x2s": hex.EncodeToString(rxMsg)})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000278 if len(rxMsg) >= 44 { // then it should normally include the BaseFormat trailer Len
279 // NOTE: autocorrection only valid for OmciBaseFormat, which is not specifically verified here!!!
mpagenkoc8bba412021-01-15 15:38:44 +0000280 // (an extendedFormat message could be destroyed this way!)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000281 trailerLenData := rxMsg[42:44]
282 trailerLen := binary.BigEndian.Uint16(trailerLenData)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000283 //logger.Debugw(ctx,"omci-received-trailer-len", log.Fields{"Length": trailerLen})
mpagenkoc8bba412021-01-15 15:38:44 +0000284 if trailerLen != cOmciBaseMessageTrailerLen { // invalid base Format entry -> autocorrect
285 binary.BigEndian.PutUint16(rxMsg[42:44], cOmciBaseMessageTrailerLen)
286 if oo.rxOmciFrameError != cOmciMessageReceiveErrorTrailerLen {
287 //do just one error log, expectation is: if seen once it should appear regularly - avoid to many log entries
288 logger.Errorw(ctx, "wrong omci-message trailer length: trailer len auto-corrected",
289 log.Fields{"trailer-length": trailerLen, "device-id": oo.deviceID})
290 oo.rxOmciFrameError = cOmciMessageReceiveErrorTrailerLen
291 }
292 }
293 } else if len(rxMsg) >= cOmciBaseMessageTrailerLen { // workaround for Adtran OLT Sim, which currently does not send trailer bytes at all!
294 // NOTE: autocorrection only valid for OmciBaseFormat, which is not specifically verified here!!!
295 // (an extendedFormat message could be destroyed this way!)
296 // extend/overwrite with trailer
297 trailer := make([]byte, 8)
298 binary.BigEndian.PutUint16(trailer[2:], cOmciBaseMessageTrailerLen) //set the defined baseline length
299 rxMsg = append(rxMsg[:cOmciBaseMessageTrailerLen], trailer...)
300 if oo.rxOmciFrameError != cOmciMessageReceiveErrorMissTrailer {
301 //do just one error log, expectation is: if seen once it should appear regularly - avoid to many log entries
302 logger.Errorw(ctx, "omci-message to short to include trailer len: trailer auto-corrected (added)",
303 log.Fields{"message-length": len(rxMsg), "device-id": oo.deviceID})
304 oo.rxOmciFrameError = cOmciMessageReceiveErrorMissTrailer
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000305 }
306 } else {
mpagenkoc8bba412021-01-15 15:38:44 +0000307 logger.Errorw(ctx, "received omci-message too small for OmciBaseFormat - abort",
308 log.Fields{"Length": len(rxMsg), "device-id": oo.deviceID})
mpagenko80622a52021-02-09 16:53:23 +0000309 oo.printRxMessage(ctx, rxMsg)
Andrea Campanella6515c582020-10-05 11:25:00 +0200310 return fmt.Errorf("rxOmciMessage too small for BaseFormat %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000311 }
312
313 packet := gopacket.NewPacket(rxMsg, omci.LayerTypeOMCI, gopacket.NoCopy)
314 if packet == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000315 logger.Errorw(ctx, "omci-message could not be decoded", log.Fields{"device-id": oo.deviceID})
mpagenko80622a52021-02-09 16:53:23 +0000316 oo.printRxMessage(ctx, rxMsg)
Andrea Campanella6515c582020-10-05 11:25:00 +0200317 return fmt.Errorf("could not decode rxMsg as OMCI %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000318 }
319 omciLayer := packet.Layer(omci.LayerTypeOMCI)
320 if omciLayer == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000321 logger.Errorw(ctx, "omci-message could not decode omci layer", log.Fields{"device-id": oo.deviceID})
mpagenko80622a52021-02-09 16:53:23 +0000322 oo.printRxMessage(ctx, rxMsg)
Andrea Campanella6515c582020-10-05 11:25:00 +0200323 return fmt.Errorf("could not decode omci layer %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000324 }
325 omciMsg, ok := omciLayer.(*omci.OMCI)
326 if !ok {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000327 logger.Errorw(ctx, "omci-message could not assign omci layer", log.Fields{"device-id": oo.deviceID})
mpagenko80622a52021-02-09 16:53:23 +0000328 oo.printRxMessage(ctx, rxMsg)
Andrea Campanella6515c582020-10-05 11:25:00 +0200329 return fmt.Errorf("could not assign omci layer %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000330 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000331 logger.Debugw(ctx, "omci-message-decoded:", log.Fields{"omciMsgType": omciMsg.MessageType,
mpagenko3dbcdd22020-07-22 07:38:45 +0000332 "transCorrId": strconv.FormatInt(int64(omciMsg.TransactionID), 16), "DeviceIdent": omciMsg.DeviceIdentifier})
Girish Gowdra6afb56a2021-04-27 17:47:57 -0700333 // TestResult is asynchronous indication that carries the same TID as the TestResponse.
334 // We expect to find the TID in the oo.rxSchedulerMap
335 if byte(omciMsg.MessageType)&me.AK == 0 && omciMsg.MessageType != omci.TestResultType {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000336 // Not a response
mpagenko80622a52021-02-09 16:53:23 +0000337 oo.printRxMessage(ctx, rxMsg)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000338 logger.Debug(ctx, "RxMsg is no Omci Response Message")
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000339 if omciMsg.TransactionID == 0 {
Himani Chawlaac1f5ad2021-02-04 21:21:54 +0530340 return oo.receiveOnuMessage(ctx, omciMsg, &packet)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000341 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000342 logger.Errorw(ctx, "Unexpected TransCorrId != 0 not accepted for autonomous messages",
Andrea Campanella6515c582020-10-05 11:25:00 +0200343 log.Fields{"msgType": omciMsg.MessageType, "payload": hex.EncodeToString(omciMsg.Payload),
mpagenko8b07c1b2020-11-26 10:36:31 +0000344 "device-id": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200345 return fmt.Errorf("autonomous Omci Message with TranSCorrId != 0 not acccepted %s", oo.deviceID)
Himani Chawla4d908332020-08-31 12:30:20 +0530346 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000347 //logger.Debug(ctx,"RxMsg is a Omci Response Message: try to schedule it to the requester")
Himani Chawla4d908332020-08-31 12:30:20 +0530348 oo.mutexRxSchedMap.Lock()
349 rxCallbackEntry, ok := oo.rxSchedulerMap[omciMsg.TransactionID]
350 if ok && rxCallbackEntry.cbFunction != nil {
mpagenko80622a52021-02-09 16:53:23 +0000351 if rxCallbackEntry.framePrint {
352 oo.printRxMessage(ctx, rxMsg)
353 }
Himani Chawla4d908332020-08-31 12:30:20 +0530354 //disadvantage of decoupling: error verification made difficult, but anyway the question is
355 // how to react on erroneous frame reception, maybe can simply be ignored
dbainbri4d3a0dc2020-12-02 00:33:42 +0000356 go rxCallbackEntry.cbFunction(ctx, omciMsg, &packet, rxCallbackEntry.cbRespChannel)
Holger Hildebrandt3124e302021-03-23 12:47:03 +0000357 if isSuccessfulResponseWithMibDataSync(omciMsg, &packet) {
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +0000358 oo.pOnuDeviceEntry.incrementMibDataSync(ctx)
359 }
mpagenkoc8bba412021-01-15 15:38:44 +0000360
Girish Gowdra6afb56a2021-04-27 17:47:57 -0700361 // If omciMsg.MessageType is omci.TestResponseType, we still expect the TestResult OMCI message,
362 // so do not clean up the TransactionID in that case.
363 if omciMsg.MessageType != omci.TestResponseType {
364 // having posted the response the request is regarded as 'done'
365 delete(oo.rxSchedulerMap, omciMsg.TransactionID)
366 }
Himani Chawla4d908332020-08-31 12:30:20 +0530367 oo.mutexRxSchedMap.Unlock()
mpagenko80622a52021-02-09 16:53:23 +0000368 return nil
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000369 }
mpagenko80622a52021-02-09 16:53:23 +0000370 oo.mutexRxSchedMap.Unlock()
371 logger.Errorw(ctx, "omci-message-response for not registered transCorrId", log.Fields{"device-id": oo.deviceID})
372 oo.printRxMessage(ctx, rxMsg)
373 return fmt.Errorf("could not find registered response handler tor transCorrId %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000374
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000375 /* py code was:
376 Receive and OMCI message from the proxy channel to the OLT.
377
378 Call this from your ONU Adapter on a new OMCI Rx on the proxy channel
379 :param msg: (str) OMCI binary message (used as input to Scapy packet decoder)
380 """
381 if not self.enabled:
382 return
383
384 try:
385 now = arrow.utcnow()
386 d = None
387
388 # NOTE: Since we may need to do an independent ME map on a per-ONU basis
389 # save the current value of the entity_id_to_class_map, then
390 # replace it with our custom one before decode, and then finally
391 # restore it later. Tried other ways but really made the code messy.
392 saved_me_map = omci_entities.entity_id_to_class_map
393 omci_entities.entity_id_to_class_map = self._me_map
394
395 try:
396 rx_frame = msg if isinstance(msg, OmciFrame) else OmciFrame(msg)
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000397 self.logger.debug('recv-omci-msg', omci_msg=hexlify(msg))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000398 except KeyError as e:
399 # Unknown, Unsupported, or vendor-specific ME. Key is the unknown classID
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000400 self.logger.debug('frame-decode-key-error', omci_msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000401 rx_frame = self._decode_unknown_me(msg)
402 self._rx_unknown_me += 1
403
404 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000405 self.logger.exception('frame-decode', omci_msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000406 return
407
408 finally:
409 omci_entities.entity_id_to_class_map = saved_me_map # Always restore it.
410
411 rx_tid = rx_frame.fields['transaction_id']
412 msg_type = rx_frame.fields['message_type']
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000413 self.logger.debug('Received message for rx_tid', rx_tid = rx_tid, msg_type = msg_type)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000414 # Filter the Test Result frame and route through receive onu
415 # message method.
416 if rx_tid == 0 or msg_type == EntityOperations.TestResult.value:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000417 self.logger.debug('Receive ONU message', rx_tid=0)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000418 return self._receive_onu_message(rx_frame)
419
420 # Previously unreachable if this is the very first round-trip Rx or we
421 # have been running consecutive errors
422 if self._rx_frames == 0 or self._consecutive_errors != 0:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000423 self.logger.debug('Consecutive errors for rx', err = self._consecutive_errors)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000424 self.reactor.callLater(0, self._publish_connectivity_event, True)
425
426 self._rx_frames += 1
427 self._consecutive_errors = 0
428
429 try:
430 high_priority = self._tid_is_high_priority(rx_tid)
431 index = self._get_priority_index(high_priority)
432
433 # (timestamp, defer, frame, timeout, retry, delayedCall)
434 last_tx_tuple = self._tx_request[index]
435
436 if last_tx_tuple is None or \
437 last_tx_tuple[OMCI_CC.REQUEST_FRAME].fields.get('transaction_id') != rx_tid:
438 # Possible late Rx on a message that timed-out
439 if last_tx_tuple:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000440 self.logger.debug('Unknown message', rx_tid=rx_tid,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000441 tx_id=last_tx_tuple[OMCI_CC.REQUEST_FRAME].fields.get('transaction_id'))
442 self._rx_unknown_tid += 1
443 self._rx_late += 1
444 return
445
446 ts, d, tx_frame, timeout, retry, dc = last_tx_tuple
447 if dc is not None and not dc.cancelled and not dc.called:
448 dc.cancel()
449
450 _secs = self._update_rx_tx_stats(now, ts)
451
452 # Late arrival already serviced by a timeout?
453 if d.called:
454 self._rx_late += 1
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000455 self.logger.debug('Serviced by timeout. Late arrival', rx_late = self._rx_late)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000456 return
457
458 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000459 self.logger.exception('frame-match', msg=hexlify(msg), e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000460 if d is not None:
461 return d.errback(failure.Failure(e))
462 return
463
464 # Publish Rx event to listeners in a different task
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000465 self.logger.debug('Publish rx event', rx_tid = rx_tid,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000466 tx_tid = tx_frame.fields['transaction_id'])
467 reactor.callLater(0, self._publish_rx_frame, tx_frame, rx_frame)
468
469 # begin success callback chain (will cancel timeout and queue next Tx message)
470 self._rx_response[index] = rx_frame
471 d.callback(rx_frame)
472
473 except Exception as e:
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000474 self.logger.exception('rx-msg', e=e)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000475 */
476}
477
Himani Chawla6d2ae152020-09-02 13:11:20 +0530478/*
479func (oo *omciCC) publishRxResponseFrame(ctx context.Context, txFrame []byte, rxFrame []byte) error {
Himani Chawla4d908332020-08-31 12:30:20 +0530480 return errors.New("publishRxResponseFrame unimplemented")
Himani Chawla6d2ae152020-09-02 13:11:20 +0530481 //def _publish_rx_frame(self, tx_frame, rx_frame):
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000482}
Himani Chawla6d2ae152020-09-02 13:11:20 +0530483*/
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000484
Girish Gowdra6afb56a2021-04-27 17:47:57 -0700485// ReleaseTid releases OMCI transaction identifier from rxSchedulerMap
486func (oo *omciCC) ReleaseTid(ctx context.Context, tid uint16) {
487 logger.Debugw(ctx, "releasing tid from rxSchedulerMap", log.Fields{"tid": tid})
488 delete(oo.rxSchedulerMap, tid)
489}
490
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000491//Queue the OMCI Frame for a transmit to the ONU via the proxy_channel
Himani Chawla6d2ae152020-09-02 13:11:20 +0530492func (oo *omciCC) send(ctx context.Context, txFrame []byte, timeout int, retry int, highPrio bool,
493 receiveCallbackPair callbackPair) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000494
mpagenkoc26d4c02021-05-06 14:27:57 +0000495 if timeout != 0 {
496 logger.Debugw(ctx, "register-response-callback:", log.Fields{"for TansCorrId": receiveCallbackPair.cbKey})
497 oo.mutexRxSchedMap.Lock()
498 // it could be checked, if the callback key is already registered - but simply overwrite may be acceptable ...
499 oo.rxSchedulerMap[receiveCallbackPair.cbKey] = receiveCallbackPair.cbEntry
500 oo.mutexRxSchedMap.Unlock()
501 } //else timeout 0 indicates that no response is expected - fire and forget
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000502
mpagenkoc26d4c02021-05-06 14:27:57 +0000503 printFrame := receiveCallbackPair.cbEntry.framePrint //printFrame true means debug print of frame is requested
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000504 //just use a simple list for starting - might need some more effort, especially for multi source write access
505 omciTxRequest := omciTransferStructure{
506 txFrame,
507 timeout,
508 retry,
509 highPrio,
mpagenko80622a52021-02-09 16:53:23 +0000510 printFrame,
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000511 receiveCallbackPair,
512 nil,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000513 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000514 oo.mutexMonReq.Lock()
515 defer oo.mutexMonReq.Unlock()
516 if _, exist := oo.monitoredRequests[receiveCallbackPair.cbKey]; !exist {
517 go oo.processRequestMonitoring(ctx, omciTxRequest)
518 return nil
519 }
520 logger.Errorw(ctx, "A message with this tid is processed already!",
521 log.Fields{"tid": receiveCallbackPair.cbKey, "device-id": oo.deviceID})
522 return fmt.Errorf("message with tid is processed already %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000523}
524
525//Pull next tx request and send it
Himani Chawla6d2ae152020-09-02 13:11:20 +0530526func (oo *omciCC) sendNextRequest(ctx context.Context) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000527 // return errors.New("sendNextRequest unimplemented")
528
529 // just try to get something transferred !!
530 // avoid accessing the txQueue from parallel send requests
531 // block parallel omci send requests at least until SendIAP is 'committed'
532 // that should be feasible for an onu instance as on OMCI anyway window size 1 is assumed
533 oo.mutexTxQueue.Lock()
mpagenkodff5dda2020-08-28 11:52:01 +0000534 defer oo.mutexTxQueue.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000535 for oo.txQueue.Len() > 0 {
536 queueElement := oo.txQueue.Front() // First element
537 omciTxRequest := queueElement.Value.(omciTransferStructure)
538 /* compare olt device handler code:
539 func (dh *DeviceHandler) omciIndication(omciInd *oop.OmciIndication) {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000540 logger.Debugw(ctx,"omci indication", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000541 var deviceType string
542 var deviceID string
543 var proxyDeviceID string
544
545 onuKey := dh.formOnuKey(omciInd.IntfId, omciInd.OnuId)
546
547 if onuInCache, ok := dh.onus.Load(onuKey); !ok {
548
dbainbri4d3a0dc2020-12-02 00:33:42 +0000549 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 +0000550 ponPort := IntfIDToPortNo(omciInd.GetIntfId(), voltha.Port_PON_OLT)
551 kwargs := make(map[string]interface{})
552 kwargs["onu_id"] = omciInd.OnuId
553 kwargs["parent_port_no"] = ponPort
554
dbainbri4d3a0dc2020-12-02 00:33:42 +0000555 onuDevice, err := dh.coreProxy.GetChildDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, kwargs)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000556 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000557 logger.Errorw(ctx,"onu not found", log.Fields{"intfID": omciInd.IntfId, "onuID": omciInd.OnuId, "error": err})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000558 return
559 }
560 deviceType = onuDevice.Type
561 deviceID = onuDevice.Id
562 proxyDeviceID = onuDevice.ProxyAddress.DeviceId
563 //if not exist in cache, then add to cache.
564 dh.onus.Store(onuKey, NewOnuDevice(deviceID, deviceType, onuDevice.SerialNumber, omciInd.OnuId, omciInd.IntfId, proxyDeviceID))
565 } else {
566 //found in cache
dbainbri4d3a0dc2020-12-02 00:33:42 +0000567 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 +0000568 deviceType = onuInCache.(*OnuDevice).deviceType
569 deviceID = onuInCache.(*OnuDevice).deviceID
570 proxyDeviceID = onuInCache.(*OnuDevice).proxyDeviceID
571 }
572 */
573 /* and compare onu_adapter py code:
574 omci_msg = InterAdapterOmciMessage(
575 message=bytes(frame),
576 proxy_address=self._proxy_address,
577 connect_status=self._device.connect_status)
578
Holger Hildebrandt0f9b88d2020-04-20 13:33:25 +0000579 self.logger.debug('sent-omci-msg', tid=tx_tid, omci_msg=hexlify(bytes(frame)))
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000580
581 yield self._adapter_proxy.send_inter_adapter_message(
582 msg=omci_msg,
583 type=InterAdapterMessageType.OMCI_REQUEST,
584 from_adapter=self._device.type,
585 to_adapter=self._proxy_address.device_type,
586 to_device_id=self._device_id,
587 proxy_device_id=self._proxy_address.device_id
588 )
589 */
mpagenko80622a52021-02-09 16:53:23 +0000590 if omciTxRequest.withFramePrint {
591 logger.Debugw(ctx, "omci-message-to-send:", log.Fields{
592 "TxOmciMessage": hex.EncodeToString(omciTxRequest.txFrame),
593 "device-id": oo.deviceID,
594 "toDeviceType": oo.pBaseDeviceHandler.ProxyAddressType,
595 "proxyDeviceID": oo.pBaseDeviceHandler.ProxyAddressID})
596 }
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000597 omciMsg := &ic.InterAdapterOmciMessage{Message: omciTxRequest.txFrame}
dbainbri4d3a0dc2020-12-02 00:33:42 +0000598 if sendErr := oo.adapterProxy.SendInterAdapterMessage(log.WithSpanFromContext(context.Background(), ctx), omciMsg,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000599 ic.InterAdapterMessageType_OMCI_REQUEST,
Matteo Scandoloefbec272020-11-17 10:33:09 -0800600 //fromTopic,toType,toDevId, ProxyDevId
601 oo.pOnuDeviceEntry.baseDeviceHandler.pOpenOnuAc.config.Topic, oo.pBaseDeviceHandler.ProxyAddressType,
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000602 oo.deviceID, oo.pBaseDeviceHandler.ProxyAddressID, ""); sendErr != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000603 logger.Errorw(ctx, "send omci request error", log.Fields{"ChildId": oo.deviceID, "error": sendErr})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000604 return sendErr
605 }
606 oo.txQueue.Remove(queueElement) // Dequeue
607 }
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000608 return nil
609}
610
Himani Chawla6d2ae152020-09-02 13:11:20 +0530611func (oo *omciCC) getNextTid(highPriority bool) uint16 {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000612 var next uint16
613 if highPriority {
mpagenko900ee4b2020-10-12 11:56:34 +0000614 oo.mutexHpTid.Lock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000615 next = oo.hpTid
Himani Chawla4d908332020-08-31 12:30:20 +0530616 oo.hpTid++
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000617 if oo.hpTid < 0x8000 {
618 oo.hpTid = 0x8000
619 }
mpagenko900ee4b2020-10-12 11:56:34 +0000620 oo.mutexHpTid.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000621 } else {
mpagenko900ee4b2020-10-12 11:56:34 +0000622 oo.mutexTid.Lock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000623 next = oo.tid
Himani Chawla4d908332020-08-31 12:30:20 +0530624 oo.tid++
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000625 if oo.tid >= 0x8000 {
626 oo.tid = 1
627 }
mpagenko900ee4b2020-10-12 11:56:34 +0000628 oo.mutexTid.Unlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000629 }
630 return next
631}
632
633// ###################################################################################
634// # utility methods provided to work on OMCI messages
dbainbri4d3a0dc2020-12-02 00:33:42 +0000635func serialize(ctx context.Context, msgType omci.MessageType, request gopacket.SerializableLayer, tid uint16) ([]byte, error) {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000636 omciLayer := &omci.OMCI{
637 TransactionID: tid,
638 MessageType: msgType,
639 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000640 return serializeOmciLayer(ctx, omciLayer, request)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000641}
642
dbainbri4d3a0dc2020-12-02 00:33:42 +0000643func serializeOmciLayer(ctx context.Context, aOmciLayer *omci.OMCI, aRequest gopacket.SerializableLayer) ([]byte, error) {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000644 var options gopacket.SerializeOptions
645 options.FixLengths = true
646
647 buffer := gopacket.NewSerializeBuffer()
Himani Chawla4d908332020-08-31 12:30:20 +0530648 err := gopacket.SerializeLayers(buffer, options, aOmciLayer, aRequest)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000649 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000650 logger.Errorw(ctx, "Could not create goPacket Omci serial buffer", log.Fields{"Err": err})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000651 return nil, err
652 }
653 return buffer.Bytes(), nil
654}
655
Himani Chawla4d908332020-08-31 12:30:20 +0530656/*
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000657func hexEncode(omciPkt []byte) ([]byte, error) {
658 dst := make([]byte, hex.EncodedLen(len(omciPkt)))
659 hex.Encode(dst, omciPkt)
660 return dst, nil
661}
Himani Chawla4d908332020-08-31 12:30:20 +0530662*/
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000663
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000664//supply a response handler for omci response messages to be transferred to the requested FSM
dbainbri4d3a0dc2020-12-02 00:33:42 +0000665func (oo *omciCC) receiveOmciResponse(ctx context.Context, omciMsg *omci.OMCI, packet *gp.Packet, respChan chan Message) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000666
dbainbri4d3a0dc2020-12-02 00:33:42 +0000667 logger.Debugw(ctx, "omci-message-response - transfer on omciRespChannel", log.Fields{"omciMsgType": omciMsg.MessageType,
divyadesai4d299552020-08-18 07:13:49 +0000668 "transCorrId": strconv.FormatInt(int64(omciMsg.TransactionID), 16), "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000669
670 if oo.pOnuDeviceEntry == nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000671 logger.Errorw(ctx, "Abort receiving OMCI response, DeviceEntryPointer is nil", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000672 "device-id": oo.deviceID})
Andrea Campanella6515c582020-10-05 11:25:00 +0200673 return fmt.Errorf("deviceEntryPointer is nil %s", oo.deviceID)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000674 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000675 oo.mutexMonReq.RLock()
676 if _, exist := oo.monitoredRequests[omciMsg.TransactionID]; exist {
677 oo.monitoredRequests[omciMsg.TransactionID].chSuccess <- true
678 } else {
679 logger.Infow(ctx, "reqMon: map entry does not exist!",
680 log.Fields{"tid": omciMsg.TransactionID, "device-id": oo.deviceID})
681 }
682 oo.mutexMonReq.RUnlock()
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000683
684 // no further test on SeqNo is done here, assignment from rxScheduler is trusted
685 // MibSync responses are simply transferred via deviceEntry to MibSync, no specific analysis here
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000686 omciRespMsg := Message{
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000687 Type: OMCI,
688 Data: OmciMessage{
689 OmciMsg: omciMsg,
690 OmciPacket: packet,
691 },
692 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000693 //logger.Debugw(ctx,"Message to be sent into channel:", log.Fields{"mibSyncMsg": mibSyncMsg})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000694 respChan <- omciRespMsg
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000695
696 return nil
697}
698
Himani Chawla6d2ae152020-09-02 13:11:20 +0530699func (oo *omciCC) sendMibReset(ctx context.Context, timeout int, highPrio bool) error {
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000700
dbainbri4d3a0dc2020-12-02 00:33:42 +0000701 logger.Debugw(ctx, "send MibReset-msg to:", log.Fields{"device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000702 request := &omci.MibResetRequest{
703 MeBasePacket: omci.MeBasePacket{
704 EntityClass: me.OnuDataClassID,
705 },
706 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530707 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000708 pkt, err := serialize(ctx, omci.MibResetRequestType, request, tid)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000709 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000710 logger.Errorw(ctx, "Cannot serialize MibResetRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000711 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000712 return err
713 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530714 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000715 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000716 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000717 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000718 return oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000719}
720
Himani Chawla6d2ae152020-09-02 13:11:20 +0530721func (oo *omciCC) sendReboot(ctx context.Context, timeout int, highPrio bool, responseChannel chan Message) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000722 logger.Debugw(ctx, "send Reboot-msg to:", log.Fields{"device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300723 request := &omci.RebootRequest{
724 MeBasePacket: omci.MeBasePacket{
725 EntityClass: me.OnuGClassID,
726 },
727 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530728 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000729 pkt, err := serialize(ctx, omci.RebootRequestType, request, tid)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300730 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000731 logger.Errorw(ctx, "Cannot serialize RebootRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000732 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300733 return err
734 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530735 omciRxCallbackPair := callbackPair{
ozgecanetsiae11479f2020-07-06 09:44:47 +0300736 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000737 cbEntry: callbackPairEntry{oo.pOnuDeviceEntry.omciRebootMessageReceivedChannel, oo.receiveOmciResponse, true},
ozgecanetsiae11479f2020-07-06 09:44:47 +0300738 }
739
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000740 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300741 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000742 logger.Errorw(ctx, "Cannot send RebootRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000743 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300744 return err
745 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000746 err = oo.pOnuDeviceEntry.waitForRebootResponse(ctx, responseChannel)
ozgecanetsiae11479f2020-07-06 09:44:47 +0300747 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000748 logger.Errorw(ctx, "aborting ONU Reboot!", log.Fields{
Andrea Campanella6515c582020-10-05 11:25:00 +0200749 "Err": err, "device-id": oo.deviceID})
ozgecanetsiae11479f2020-07-06 09:44:47 +0300750 return err
751 }
752 return nil
753}
754
Himani Chawla6d2ae152020-09-02 13:11:20 +0530755func (oo *omciCC) sendMibUpload(ctx context.Context, timeout int, highPrio bool) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000756 logger.Debugw(ctx, "send MibUpload-msg to:", log.Fields{"device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000757 request := &omci.MibUploadRequest{
758 MeBasePacket: omci.MeBasePacket{
759 EntityClass: me.OnuDataClassID,
760 },
761 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530762 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000763 pkt, err := serialize(ctx, omci.MibUploadRequestType, request, tid)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000764 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000765 logger.Errorw(ctx, "Cannot serialize MibUploadRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000766 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000767 return err
768 }
769 oo.uploadSequNo = 0
770 oo.uploadNoOfCmds = 0
771
Himani Chawla6d2ae152020-09-02 13:11:20 +0530772 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000773 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000774 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000775 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000776 return oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000777}
778
Himani Chawla6d2ae152020-09-02 13:11:20 +0530779func (oo *omciCC) sendMibUploadNext(ctx context.Context, timeout int, highPrio bool) error {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000780 logger.Debugw(ctx, "send MibUploadNext-msg to:", log.Fields{"device-id": oo.deviceID, "uploadSequNo": oo.uploadSequNo})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000781 request := &omci.MibUploadNextRequest{
782 MeBasePacket: omci.MeBasePacket{
783 EntityClass: me.OnuDataClassID,
784 },
785 CommandSequenceNumber: oo.uploadSequNo,
786 }
Himani Chawla6d2ae152020-09-02 13:11:20 +0530787 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000788 pkt, err := serialize(ctx, omci.MibUploadNextRequestType, request, tid)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000789 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000790 logger.Errorw(ctx, "Cannot serialize MibUploadNextRequest", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000791 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000792 return err
793 }
794 oo.uploadSequNo++
795
Himani Chawla6d2ae152020-09-02 13:11:20 +0530796 omciRxCallbackPair := callbackPair{
mpagenko80622a52021-02-09 16:53:23 +0000797 cbKey: tid,
798 //frame printing for MibUpload frames disabled now per default to avoid log file abort situations (size/speed?)
799 // if wanted, rx frame printing should be specifically done within the MibUpload FSM or controlled via extra parameter
800 // compare also software upgrade download section handling
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000801 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000802 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000803 return oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000804}
805
Himani Chawlad3dac422021-03-13 02:31:31 +0530806func (oo *omciCC) sendGetAllAlarm(ctx context.Context, alarmRetreivalMode uint8, timeout int, highPrio bool) error {
807 logger.Debugw(ctx, "send GetAllAlarms-msg to:", log.Fields{"device-id": oo.deviceID})
808 request := &omci.GetAllAlarmsRequest{
809 MeBasePacket: omci.MeBasePacket{
810 EntityClass: me.OnuDataClassID,
811 },
812 AlarmRetrievalMode: byte(alarmRetreivalMode),
813 }
814 tid := oo.getNextTid(highPrio)
815 pkt, err := serialize(ctx, omci.GetAllAlarmsRequestType, request, tid)
816 if err != nil {
817 logger.Errorw(ctx, "Cannot serialize GetAllAlarmsRequest", log.Fields{
818 "Err": err, "device-id": oo.deviceID})
819 return err
820 }
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000821 oo.pBaseDeviceHandler.pAlarmMgr.ResetAlarmUploadCounters()
Himani Chawlad3dac422021-03-13 02:31:31 +0530822
823 omciRxCallbackPair := callbackPair{
824 cbKey: tid,
825 cbEntry: callbackPairEntry{(*oo.pBaseDeviceHandler.pAlarmMgr).eventChannel,
826 oo.receiveOmciResponse, true},
827 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000828 return oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Himani Chawlad3dac422021-03-13 02:31:31 +0530829}
830
831func (oo *omciCC) sendGetAllAlarmNext(ctx context.Context, timeout int, highPrio bool) error {
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000832 alarmUploadSeqNo := oo.pBaseDeviceHandler.pAlarmMgr.GetAlarmUploadSeqNo()
Himani Chawlad3dac422021-03-13 02:31:31 +0530833 logger.Debugw(ctx, "send sendGetAllAlarmNext-msg to:", log.Fields{"device-id": oo.deviceID,
834 "alarmUploadSeqNo": alarmUploadSeqNo})
835 request := &omci.GetAllAlarmsNextRequest{
836 MeBasePacket: omci.MeBasePacket{
837 EntityClass: me.OnuDataClassID,
838 },
839 CommandSequenceNumber: alarmUploadSeqNo,
840 }
841 tid := oo.getNextTid(highPrio)
842 pkt, err := serialize(ctx, omci.GetAllAlarmsNextRequestType, request, tid)
843 if err != nil {
844 logger.Errorw(ctx, "Cannot serialize GetAllAlarmsNextRequest", log.Fields{
845 "Err": err, "device-id": oo.deviceID})
846 return err
847 }
Holger Hildebrandt0da7e6f2021-05-12 13:08:43 +0000848 oo.pBaseDeviceHandler.pAlarmMgr.IncrementAlarmUploadSeqNo()
Himani Chawlad3dac422021-03-13 02:31:31 +0530849
850 omciRxCallbackPair := callbackPair{
851 cbKey: tid,
852 cbEntry: callbackPairEntry{(*oo.pBaseDeviceHandler.pAlarmMgr).eventChannel, oo.receiveOmciResponse, true},
853 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000854 return oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Himani Chawlad3dac422021-03-13 02:31:31 +0530855}
856
ozgecanetsiab36ed572021-04-01 10:38:48 +0300857func (oo *omciCC) sendCreateGalEthernetProfile(ctx context.Context, timeout int, highPrio bool) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530858 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000859 logger.Debugw(ctx, "send GalEnetProfile-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000860 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtfa074992020-03-27 15:42:06 +0000861
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000862 meParams := me.ParamData{
863 EntityID: galEthernetEID,
864 Attributes: me.AttributeValueMap{"MaximumGemPayloadSize": maxGemPayloadSize},
865 }
866 meInstance, omciErr := me.NewGalEthernetProfile(meParams)
867 if omciErr.GetError() == nil {
868 //all setByCreate parameters already set, no default option required ...
869 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
870 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000871 logger.Errorw(ctx, "Cannot encode GalEnetProfileInstance for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000872 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300873 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000874 }
875
dbainbri4d3a0dc2020-12-02 00:33:42 +0000876 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000877 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000878 logger.Errorw(ctx, "Cannot serialize GalEnetProfile create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000879 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300880 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000881 }
882
Himani Chawla6d2ae152020-09-02 13:11:20 +0530883 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000884 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000885 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000886 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000887 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000888 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000889 logger.Errorw(ctx, "Cannot send GalEnetProfile create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000890 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300891 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000892 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000893 logger.Debug(ctx, "send GalEnetProfile-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +0300894 return meInstance, nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000895 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000896 logger.Errorw(ctx, "Cannot generate GalEnetProfileInstance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000897 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300898 return nil, omciErr.GetError()
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000899}
900
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000901// might be needed to extend for parameter arguments, here just for setting the ConnectivityMode!!
ozgecanetsiab36ed572021-04-01 10:38:48 +0300902func (oo *omciCC) sendSetOnu2g(ctx context.Context, timeout int, highPrio bool) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530903 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000904 logger.Debugw(ctx, "send ONU2-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000905 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000906
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000907 // ONU-G ME-ID is defined to be 0, but we could verify, if the ONU really supports the desired
908 // connectivity mode 5 (in ConnCap)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000909 // By now we just use fix values to fire - this is anyway what the python adapter does
910 // read ONU-2G from DB ???? //TODO!!!
911 meParams := me.ParamData{
912 EntityID: 0,
913 Attributes: me.AttributeValueMap{"CurrentConnectivityMode": connectivityModeValue},
914 }
915 meInstance, omciErr := me.NewOnu2G(meParams)
916 if omciErr.GetError() == nil {
917 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
918 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000919 logger.Errorw(ctx, "Cannot encode ONU2-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000920 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300921 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000922 }
923
dbainbri4d3a0dc2020-12-02 00:33:42 +0000924 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000925 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000926 logger.Errorw(ctx, "Cannot serialize ONU2-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000927 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300928 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000929 }
930
Himani Chawla6d2ae152020-09-02 13:11:20 +0530931 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000932 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000933 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000934 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000935 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000936 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000937 logger.Errorw(ctx, "Cannot send ONU2-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000938 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300939 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000940 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000941 logger.Debug(ctx, "send ONU2-G-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +0300942 return meInstance, nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000943 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000944 logger.Errorw(ctx, "Cannot generate ONU2-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000945 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300946 return nil, omciErr.GetError()
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000947}
948
Himani Chawla6d2ae152020-09-02 13:11:20 +0530949func (oo *omciCC) sendCreateMBServiceProfile(ctx context.Context,
ozgecanetsiab36ed572021-04-01 10:38:48 +0300950 aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +0530951 tid := oo.getNextTid(highPrio)
Himani Chawla4d908332020-08-31 12:30:20 +0530952 instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
dbainbri4d3a0dc2020-12-02 00:33:42 +0000953 logger.Debugw(ctx, "send MBSP-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +0000954 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000955
956 meParams := me.ParamData{
957 EntityID: instID,
958 Attributes: me.AttributeValueMap{
ozgecanetsiab5000ef2020-11-27 14:38:20 +0300959 "Priority": 0x8000,
960 "MaxAge": 20 * 256, //20s
961 "HelloTime": 2 * 256, //2s
962 "ForwardDelay": 15 * 256, //15s
963 "DynamicFilteringAgeingTime": 0,
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000964 },
965 }
966
967 meInstance, omciErr := me.NewMacBridgeServiceProfile(meParams)
968 if omciErr.GetError() == nil {
969 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
970 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
971 omci.TransactionID(tid), omci.AddDefaults(true))
972 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000973 logger.Errorw(ctx, "Cannot encode MBSP for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000974 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300975 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000976 }
977
dbainbri4d3a0dc2020-12-02 00:33:42 +0000978 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000979 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000980 logger.Errorw(ctx, "Cannot serialize MBSP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000981 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300982 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000983 }
984
Himani Chawla6d2ae152020-09-02 13:11:20 +0530985 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000986 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +0000987 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +0000988 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +0000989 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000990 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +0000991 logger.Errorw(ctx, "Cannot send MBSP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000992 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +0300993 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000994 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000995 logger.Debug(ctx, "send MBSP-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +0300996 return meInstance, nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +0000997 }
dbainbri4d3a0dc2020-12-02 00:33:42 +0000998 logger.Errorw(ctx, "Cannot generate MBSP Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +0000999 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001000 return nil, omciErr.GetError()
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001001}
1002
Himani Chawla6d2ae152020-09-02 13:11:20 +05301003func (oo *omciCC) sendCreateMBPConfigData(ctx context.Context,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001004 aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301005 tid := oo.getNextTid(highPrio)
Himani Chawla26e555c2020-08-31 12:30:20 +05301006 instID := macBridgePortAniEID + aPUniPort.entityID
dbainbri4d3a0dc2020-12-02 00:33:42 +00001007 logger.Debugw(ctx, "send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001008 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001009
1010 meParams := me.ParamData{
1011 EntityID: instID,
1012 Attributes: me.AttributeValueMap{
Himani Chawla4d908332020-08-31 12:30:20 +05301013 "BridgeIdPointer": macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo),
1014 "PortNum": aPUniPort.macBpNo,
1015 "TpType": uint8(aPUniPort.portType),
Himani Chawla26e555c2020-08-31 12:30:20 +05301016 "TpPointer": aPUniPort.entityID,
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001017 },
1018 }
1019 meInstance, omciErr := me.NewMacBridgePortConfigurationData(meParams)
1020 if omciErr.GetError() == nil {
1021 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1022 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1023 omci.TransactionID(tid), omci.AddDefaults(true))
1024 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001025 logger.Errorw(ctx, "Cannot encode MBPCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001026 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001027 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001028 }
1029
dbainbri4d3a0dc2020-12-02 00:33:42 +00001030 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001031 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001032 logger.Errorw(ctx, "Cannot serialize MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001033 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001034 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001035 }
1036
Himani Chawla6d2ae152020-09-02 13:11:20 +05301037 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001038 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001039 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001040 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001041 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001042 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001043 logger.Errorw(ctx, "Cannot send MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001044 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001045 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001046 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001047 logger.Debug(ctx, "send MBPCD-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001048 return meInstance, nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001049 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001050 logger.Errorw(ctx, "Cannot generate MBPCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001051 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001052 return nil, omciErr.GetError()
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001053}
1054
Himani Chawla6d2ae152020-09-02 13:11:20 +05301055func (oo *omciCC) sendCreateEVTOConfigData(ctx context.Context,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001056 aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301057 tid := oo.getNextTid(highPrio)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001058 //same entityId is used as for MBSP (see there), but just arbitrary ...
Himani Chawla4d908332020-08-31 12:30:20 +05301059 instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001060 logger.Debugw(ctx, "send EVTOCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001061 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001062
1063 // compare python adapter code WA VOL-1311: this is not done here!
1064 // (setting TPID values for the create would probably anyway be ignored by the omci lib)
1065 // but perhaps we have to be aware of possible problems at get(Next) Request handling for EVTOOCD tables later ...
1066 assType := uint8(2) // default AssociationType is PPTPEthUni
Himani Chawla6d2ae152020-09-02 13:11:20 +05301067 if aPUniPort.portType == uniVEIP {
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001068 assType = uint8(10) // for VEIP
1069 }
1070 meParams := me.ParamData{
1071 EntityID: instID,
1072 Attributes: me.AttributeValueMap{
1073 "AssociationType": assType,
Himani Chawla26e555c2020-08-31 12:30:20 +05301074 "AssociatedMePointer": aPUniPort.entityID,
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001075 },
1076 }
1077 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(meParams)
1078 if omciErr.GetError() == nil {
1079 //all setByCreate parameters already set, no default option required ...
1080 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
1081 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001082 logger.Errorw(ctx, "Cannot encode EVTOCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001083 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001084 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001085 }
1086
dbainbri4d3a0dc2020-12-02 00:33:42 +00001087 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001088 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001089 logger.Errorw(ctx, "Cannot serialize EVTOCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001090 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001091 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001092 }
1093
Himani Chawla6d2ae152020-09-02 13:11:20 +05301094 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001095 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001096 cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001097 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001098 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001099 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001100 logger.Errorw(ctx, "Cannot send EVTOCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001101 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001102 return nil, err
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001103 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001104 logger.Debug(ctx, "send EVTOCD-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001105 return meInstance, nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001106 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001107 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001108 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001109 return nil, omciErr.GetError()
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001110}
1111
Himani Chawla6d2ae152020-09-02 13:11:20 +05301112func (oo *omciCC) sendSetOnuGLS(ctx context.Context, timeout int,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001113 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301114 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001115 logger.Debugw(ctx, "send ONU-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001116 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001117
1118 // ONU-G ME-ID is defined to be 0, no need to perform a DB lookup
1119 meParams := me.ParamData{
1120 EntityID: 0,
1121 Attributes: requestedAttributes,
1122 }
1123 meInstance, omciErr := me.NewOnuG(meParams)
1124 if omciErr.GetError() == nil {
1125 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1126 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001127 logger.Errorw(ctx, "Cannot encode ONU-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001128 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001129 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001130 }
1131
dbainbri4d3a0dc2020-12-02 00:33:42 +00001132 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001133 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001134 logger.Errorw(ctx, "Cannot serialize ONU-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001135 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001136 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001137 }
1138
Himani Chawla6d2ae152020-09-02 13:11:20 +05301139 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001140 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001141 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001142 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001143 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001144 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001145 logger.Errorw(ctx, "Cannot send ONU-G set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001146 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001147 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001148 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001149 logger.Debug(ctx, "send ONU-G-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001150 return meInstance, nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001151 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001152 logger.Errorw(ctx, "Cannot generate ONU-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001153 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001154 return nil, omciErr.GetError()
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001155}
1156
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001157func (oo *omciCC) sendSetPptpEthUniLS(ctx context.Context, aInstNo uint16, timeout int,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001158 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001159 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001160 logger.Debugw(ctx, "send PPTPEthUni-Set-msg:", log.Fields{"device-id": oo.deviceID,
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001161 "SequNo": strconv.FormatInt(int64(tid), 16)})
1162
1163 // PPTPEthUni ME-ID is taken from Mib Upload stored OnuUniPort instance (argument)
1164 meParams := me.ParamData{
1165 EntityID: aInstNo,
1166 Attributes: requestedAttributes,
1167 }
1168 meInstance, omciErr := me.NewPhysicalPathTerminationPointEthernetUni(meParams)
1169 if omciErr.GetError() == nil {
1170 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1171 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001172 logger.Errorw(ctx, "Cannot encode PPTPEthUni instance for set", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001173 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001174 return nil, err
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001175 }
1176
dbainbri4d3a0dc2020-12-02 00:33:42 +00001177 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001178 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001179 logger.Errorw(ctx, "Cannot serialize PPTPEthUni-Set", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001180 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001181 return nil, err
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001182 }
1183
1184 omciRxCallbackPair := callbackPair{
1185 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001186 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001187 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001188 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001189 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001190 logger.Errorw(ctx, "Cannot send PPTPEthUni-Set", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001191 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001192 return nil, err
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001193 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001194 logger.Debug(ctx, "send PPTPEthUni-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001195 return meInstance, nil
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001196 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001197 logger.Errorw(ctx, "Cannot generate PPTPEthUni", log.Fields{
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001198 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001199 return nil, omciErr.GetError()
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001200}
1201
1202/* UniG obsolete by now, left here in case it should be needed once again
1203 UniG AdminState anyway should be ignored by ONU acc. to G988
Himani Chawla6d2ae152020-09-02 13:11:20 +05301204func (oo *omciCC) sendSetUniGLS(ctx context.Context, aInstNo uint16, timeout int,
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001205 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301206 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001207 logger.Debugw(ctx,"send UNI-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001208 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001209
1210 // UNI-G ME-ID is taken from Mib Upload stored OnuUniPort instance (argument)
1211 meParams := me.ParamData{
1212 EntityID: aInstNo,
1213 Attributes: requestedAttributes,
1214 }
1215 meInstance, omciErr := me.NewUniG(meParams)
1216 if omciErr.GetError() == nil {
1217 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1218 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001219 logger.Errorw(ctx,"Cannot encode UNI-G instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001220 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001221 return nil
1222 }
1223
1224 pkt, err := serializeOmciLayer(omciLayer, msgLayer)
1225 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001226 logger.Errorw(ctx,"Cannot serialize UNI-G-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001227 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001228 return nil
1229 }
1230
Himani Chawla6d2ae152020-09-02 13:11:20 +05301231 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001232 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001233 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001234 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001235 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001236 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001237 logger.Errorw(ctx,"Cannot send UNIG-G-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001238 "Err": err, "device-id": oo.deviceID})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001239 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001240 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001241 logger.Debug(ctx,"send UNI-G-Set-msg done")
mpagenko3dbcdd22020-07-22 07:38:45 +00001242 return meInstance
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001243 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001244 logger.Errorw(ctx,"Cannot generate UNI-G", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001245 "Err": omciErr.GetError(), "device-id": oo.deviceID})
mpagenko3dbcdd22020-07-22 07:38:45 +00001246 return nil
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001247}
Holger Hildebrandt2fb70892020-10-28 11:53:18 +00001248*/
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001249
Himani Chawla6d2ae152020-09-02 13:11:20 +05301250func (oo *omciCC) sendSetVeipLS(ctx context.Context, aInstNo uint16, timeout int,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001251 highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301252 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001253 logger.Debugw(ctx, "send VEIP-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001254 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001255
1256 // ONU-G ME-ID is defined to be 0, no need to perform a DB lookup
1257 meParams := me.ParamData{
1258 EntityID: aInstNo,
1259 Attributes: requestedAttributes,
1260 }
1261 meInstance, omciErr := me.NewVirtualEthernetInterfacePoint(meParams)
1262 if omciErr.GetError() == nil {
1263 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1264 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001265 logger.Errorw(ctx, "Cannot encode VEIP instance for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001266 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001267 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001268 }
1269
dbainbri4d3a0dc2020-12-02 00:33:42 +00001270 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001271 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001272 logger.Errorw(ctx, "Cannot serialize VEIP-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001273 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001274 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001275 }
1276
Himani Chawla6d2ae152020-09-02 13:11:20 +05301277 omciRxCallbackPair := callbackPair{
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001278 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001279 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001280 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001281 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001282 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001283 logger.Errorw(ctx, "Cannot send VEIP-Set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001284 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001285 return nil, err
Holger Hildebrandtccd390c2020-05-29 13:49:04 +00001286 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001287 logger.Debug(ctx, "send VEIP-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001288 return meInstance, nil
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001289 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001290 logger.Errorw(ctx, "Cannot generate VEIP", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001291 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001292 return nil, omciErr.GetError()
Holger Hildebrandtdd23cc22020-05-19 13:32:18 +00001293}
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001294
Himani Chawla6d2ae152020-09-02 13:11:20 +05301295func (oo *omciCC) sendGetMe(ctx context.Context, classID me.ClassID, entityID uint16, requestedAttributes me.AttributeValueMap,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001296 timeout int, highPrio bool, rxChan chan Message) (*me.ManagedEntity, error) {
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001297
Himani Chawla6d2ae152020-09-02 13:11:20 +05301298 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001299 logger.Debugw(ctx, "send get-request-msg", log.Fields{"classID": classID, "device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001300 "SequNo": strconv.FormatInt(int64(tid), 16)})
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001301
1302 meParams := me.ParamData{
1303 EntityID: entityID,
1304 Attributes: requestedAttributes,
1305 }
1306 meInstance, omciErr := me.LoadManagedEntityDefinition(classID, meParams)
1307 if omciErr.GetError() == nil {
Himani Chawla4d908332020-08-31 12:30:20 +05301308 meClassIDName := meInstance.GetName()
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001309 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.GetRequestType, omci.TransactionID(tid))
1310 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001311 logger.Errorf(ctx, "Cannot encode instance for get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001312 return nil, err
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001313 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001314 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001315 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001316 logger.Errorw(ctx, "Cannot serialize get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001317 return nil, err
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001318 }
Himani Chawla6d2ae152020-09-02 13:11:20 +05301319 omciRxCallbackPair := callbackPair{
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001320 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001321 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001322 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001323 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001324 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001325 logger.Errorw(ctx, "Cannot send get-request-msg", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001326 return nil, err
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001327 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001328 logger.Debugw(ctx, "send get-request-msg done", log.Fields{"meClassIDName": meClassIDName, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001329 return meInstance, nil
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001330 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001331 logger.Errorw(ctx, "Cannot generate meDefinition", log.Fields{"classID": classID, "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001332 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001333}
1334
Himani Chawla6d2ae152020-09-02 13:11:20 +05301335func (oo *omciCC) sendCreateDot1PMapper(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001336 aInstID uint16, rxChan chan Message) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301337 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001338 logger.Debugw(ctx, "send .1pMapper-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001339 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(aInstID), 16)})
1340
1341 meParams := me.ParamData{
mpagenko8b5fdd22020-12-17 17:58:32 +00001342 EntityID: aInstID,
1343 Attributes: me.AttributeValueMap{
1344 //workaround for unsuitable omci-lib default values, cmp VOL-3729
1345 "TpPointer": 0xFFFF,
1346 "InterworkTpPointerForPBitPriority0": 0xFFFF,
1347 "InterworkTpPointerForPBitPriority1": 0xFFFF,
1348 "InterworkTpPointerForPBitPriority2": 0xFFFF,
1349 "InterworkTpPointerForPBitPriority3": 0xFFFF,
1350 "InterworkTpPointerForPBitPriority4": 0xFFFF,
1351 "InterworkTpPointerForPBitPriority5": 0xFFFF,
1352 "InterworkTpPointerForPBitPriority6": 0xFFFF,
1353 "InterworkTpPointerForPBitPriority7": 0xFFFF,
1354 },
mpagenko3dbcdd22020-07-22 07:38:45 +00001355 }
1356 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(meParams)
1357 if omciErr.GetError() == nil {
1358 //we have to set all 'untouched' parameters to default by some additional option parameter!!
1359 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1360 omci.TransactionID(tid), omci.AddDefaults(true))
1361 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001362 logger.Errorw(ctx, "Cannot encode .1pMapper for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001363 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001364 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001365 }
1366
dbainbri4d3a0dc2020-12-02 00:33:42 +00001367 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001368 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001369 logger.Errorw(ctx, "Cannot serialize .1pMapper create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001370 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001371 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001372 }
1373
Himani Chawla6d2ae152020-09-02 13:11:20 +05301374 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001375 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001376 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001377 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001378 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001379 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001380 logger.Errorw(ctx, "Cannot send .1pMapper create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001381 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001382 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001383 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001384 logger.Debug(ctx, "send .1pMapper-create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001385 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001386 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001387 logger.Errorw(ctx, "Cannot generate .1pMapper", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001388 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001389 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001390}
1391
Himani Chawla6d2ae152020-09-02 13:11:20 +05301392func (oo *omciCC) sendCreateMBPConfigDataVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001393 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301394 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001395 logger.Debugw(ctx, "send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001396 "SequNo": strconv.FormatInt(int64(tid), 16),
1397 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1398
1399 meInstance, omciErr := me.NewMacBridgePortConfigurationData(params[0])
1400 if omciErr.GetError() == nil {
1401 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1402 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1403 omci.TransactionID(tid), omci.AddDefaults(true))
1404 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001405 logger.Errorw(ctx, "Cannot encode MBPCD for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001406 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001407 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001408 }
1409
dbainbri4d3a0dc2020-12-02 00:33:42 +00001410 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001411 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001412 logger.Errorw(ctx, "Cannot serialize MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001413 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001414 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001415 }
1416
Himani Chawla6d2ae152020-09-02 13:11:20 +05301417 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001418 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001419 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001420 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001421 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001422 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001423 logger.Errorw(ctx, "Cannot send MBPCD create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001424 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001425 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001426 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001427 logger.Debug(ctx, "send MBPCD-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001428 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001429 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001430 logger.Errorw(ctx, "Cannot generate MBPCD Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001431 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001432 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001433}
1434
Himani Chawla6d2ae152020-09-02 13:11:20 +05301435func (oo *omciCC) sendCreateGemNCTPVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001436 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301437 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001438 logger.Debugw(ctx, "send GemNCTP-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001439 "SequNo": strconv.FormatInt(int64(tid), 16),
1440 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1441
1442 meInstance, omciErr := me.NewGemPortNetworkCtp(params[0])
1443 if omciErr.GetError() == nil {
1444 //obviously we have to set all 'untouched' parameters to default by some additional option parameter!!
1445 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1446 omci.TransactionID(tid), omci.AddDefaults(true))
1447 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001448 logger.Errorw(ctx, "Cannot encode GemNCTP for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001449 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001450 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001451 }
1452
dbainbri4d3a0dc2020-12-02 00:33:42 +00001453 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001454 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001455 logger.Errorw(ctx, "Cannot serialize GemNCTP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001456 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001457 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001458 }
1459
Himani Chawla6d2ae152020-09-02 13:11:20 +05301460 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001461 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001462 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001463 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001464 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001465 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001466 logger.Errorw(ctx, "Cannot send GemNCTP create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001467 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001468 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001469 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001470 logger.Debug(ctx, "send GemNCTP-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001471 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001472 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001473 logger.Errorw(ctx, "Cannot generate GemNCTP Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001474 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001475 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001476}
1477
Himani Chawla6d2ae152020-09-02 13:11:20 +05301478func (oo *omciCC) sendCreateGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001479 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301480 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001481 logger.Debugw(ctx, "send GemIwTp-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001482 "SequNo": strconv.FormatInt(int64(tid), 16),
1483 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1484
1485 meInstance, omciErr := me.NewGemInterworkingTerminationPoint(params[0])
1486 if omciErr.GetError() == nil {
1487 //all SetByCreate Parameters (assumed to be) set here, for optimisation no 'AddDefaults'
1488 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1489 omci.TransactionID(tid))
1490 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001491 logger.Errorw(ctx, "Cannot encode GemIwTp for create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001492 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001493 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001494 }
1495
dbainbri4d3a0dc2020-12-02 00:33:42 +00001496 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001497 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001498 logger.Errorw(ctx, "Cannot serialize GemIwTp create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001499 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001500 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001501 }
1502
Himani Chawla6d2ae152020-09-02 13:11:20 +05301503 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001504 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001505 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001506 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001507 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001508 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001509 logger.Errorw(ctx, "Cannot send GemIwTp create", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001510 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001511 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001512 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001513 logger.Debug(ctx, "send GemIwTp-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001514 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001515 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001516 logger.Errorw(ctx, "Cannot generate GemIwTp Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001517 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001518 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001519}
1520
Himani Chawla6d2ae152020-09-02 13:11:20 +05301521func (oo *omciCC) sendSetTcontVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001522 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301523 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001524 logger.Debugw(ctx, "send TCont-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001525 "SequNo": strconv.FormatInt(int64(tid), 16),
1526 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1527
1528 meInstance, omciErr := me.NewTCont(params[0])
1529 if omciErr.GetError() == nil {
1530 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1531 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001532 logger.Errorw(ctx, "Cannot encode TCont for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001533 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001534 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001535 }
1536
dbainbri4d3a0dc2020-12-02 00:33:42 +00001537 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001538 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001539 logger.Errorw(ctx, "Cannot serialize TCont set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001540 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001541 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001542 }
1543
Himani Chawla6d2ae152020-09-02 13:11:20 +05301544 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001545 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001546 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001547 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001548 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001549 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001550 logger.Errorw(ctx, "Cannot send TCont set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001551 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001552 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001553 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001554 logger.Debug(ctx, "send TCont-set msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001555 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001556 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001557 logger.Errorw(ctx, "Cannot generate TCont Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001558 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001559 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001560}
1561
Himani Chawla6d2ae152020-09-02 13:11:20 +05301562func (oo *omciCC) sendSetPrioQueueVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001563 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301564 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001565 logger.Debugw(ctx, "send PrioQueue-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001566 "SequNo": strconv.FormatInt(int64(tid), 16),
1567 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1568
1569 meInstance, omciErr := me.NewPriorityQueue(params[0])
1570 if omciErr.GetError() == nil {
1571 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1572 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001573 logger.Errorw(ctx, "Cannot encode PrioQueue for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001574 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001575 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001576 }
1577
dbainbri4d3a0dc2020-12-02 00:33:42 +00001578 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001579 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001580 logger.Errorw(ctx, "Cannot serialize PrioQueue set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001581 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001582 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001583 }
1584
Himani Chawla6d2ae152020-09-02 13:11:20 +05301585 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001586 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001587 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001588 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001589 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001590 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001591 logger.Errorw(ctx, "Cannot send PrioQueue set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001592 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001593 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001594 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001595 logger.Debug(ctx, "send PrioQueue-set msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001596 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001597 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001598 logger.Errorw(ctx, "Cannot generate PrioQueue Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001599 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001600 return nil, omciErr.GetError()
mpagenko3dbcdd22020-07-22 07:38:45 +00001601}
1602
Himani Chawla6d2ae152020-09-02 13:11:20 +05301603func (oo *omciCC) sendSetDot1PMapperVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001604 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301605 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001606 logger.Debugw(ctx, "send 1PMapper-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko3dbcdd22020-07-22 07:38:45 +00001607 "SequNo": strconv.FormatInt(int64(tid), 16),
1608 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1609
1610 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(params[0])
1611 if omciErr.GetError() == nil {
1612 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1613 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001614 logger.Errorw(ctx, "Cannot encode 1PMapper for set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001615 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001616 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001617 }
1618
dbainbri4d3a0dc2020-12-02 00:33:42 +00001619 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko3dbcdd22020-07-22 07:38:45 +00001620 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001621 logger.Errorw(ctx, "Cannot serialize 1PMapper set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001622 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001623 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001624 }
1625
Himani Chawla6d2ae152020-09-02 13:11:20 +05301626 omciRxCallbackPair := callbackPair{
mpagenko3dbcdd22020-07-22 07:38:45 +00001627 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001628 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko3dbcdd22020-07-22 07:38:45 +00001629 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001630 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko3dbcdd22020-07-22 07:38:45 +00001631 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001632 logger.Errorw(ctx, "Cannot send 1PMapper set", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001633 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001634 return nil, err
mpagenko3dbcdd22020-07-22 07:38:45 +00001635 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001636 logger.Debug(ctx, "send 1PMapper-set msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001637 return meInstance, nil
mpagenko3dbcdd22020-07-22 07:38:45 +00001638 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001639 logger.Errorw(ctx, "Cannot generate 1PMapper Instance", log.Fields{
divyadesai4d299552020-08-18 07:13:49 +00001640 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001641 return nil, omciErr.GetError()
Holger Hildebrandtc54939a2020-06-17 08:14:27 +00001642}
mpagenkodff5dda2020-08-28 11:52:01 +00001643
Himani Chawla6d2ae152020-09-02 13:11:20 +05301644func (oo *omciCC) sendCreateVtfdVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001645 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301646 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001647 logger.Debugw(ctx, "send VTFD-Create-msg:", log.Fields{"device-id": oo.deviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00001648 "SequNo": strconv.FormatInt(int64(tid), 16),
1649 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1650
1651 meInstance, omciErr := me.NewVlanTaggingFilterData(params[0])
1652 if omciErr.GetError() == nil {
1653 //all SetByCreate Parameters (assumed to be) set here, for optimisation no 'AddDefaults'
1654 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType,
1655 omci.TransactionID(tid))
1656 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001657 logger.Errorw(ctx, "Cannot encode VTFD for create", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001658 "Err": err, "device-id": oo.deviceID})
1659 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1660 // return (dual format) error code that can be used at caller for immediate error treatment
1661 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03001662 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001663 }
1664
dbainbri4d3a0dc2020-12-02 00:33:42 +00001665 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenkodff5dda2020-08-28 11:52:01 +00001666 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001667 logger.Errorw(ctx, "Cannot serialize VTFD create", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001668 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001669 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001670 }
1671
Himani Chawla6d2ae152020-09-02 13:11:20 +05301672 omciRxCallbackPair := callbackPair{
mpagenkodff5dda2020-08-28 11:52:01 +00001673 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001674 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenkodff5dda2020-08-28 11:52:01 +00001675 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001676 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenkodff5dda2020-08-28 11:52:01 +00001677 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001678 logger.Errorw(ctx, "Cannot send VTFD create", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001679 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001680 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001681 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001682 logger.Debug(ctx, "send VTFD-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001683 return meInstance, nil
mpagenkodff5dda2020-08-28 11:52:01 +00001684 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001685 logger.Errorw(ctx, "Cannot generate VTFD Instance", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001686 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001687 return nil, omciErr.GetError()
mpagenkodff5dda2020-08-28 11:52:01 +00001688}
1689
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001690// nolint: unused
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001691func (oo *omciCC) sendSetVtfdVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001692 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001693 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001694 logger.Debugw(ctx, "send VTFD-Set-msg:", log.Fields{"device-id": oo.deviceID,
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001695 "SequNo": strconv.FormatInt(int64(tid), 16),
1696 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1697
1698 meInstance, omciErr := me.NewVlanTaggingFilterData(params[0])
1699 if omciErr.GetError() == nil {
1700 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType,
1701 omci.TransactionID(tid))
1702 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001703 logger.Errorw(ctx, "Cannot encode VTFD for set", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001704 "Err": err, "device-id": oo.deviceID})
1705 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1706 // return (dual format) error code that can be used at caller for immediate error treatment
1707 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03001708 return nil, err
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001709 }
1710
dbainbri4d3a0dc2020-12-02 00:33:42 +00001711 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001712 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001713 logger.Errorw(ctx, "Cannot serialize VTFD set", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001714 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001715 return nil, err
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001716 }
1717
1718 omciRxCallbackPair := callbackPair{
1719 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001720 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001721 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001722 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001723 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001724 logger.Errorw(ctx, "Cannot send VTFD set", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001725 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001726 return nil, err
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001727 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001728 logger.Debug(ctx, "send VTFD-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001729 return meInstance, nil
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001730 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001731 logger.Errorw(ctx, "Cannot generate VTFD Instance", log.Fields{
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001732 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001733 return nil, omciErr.GetError()
Holger Hildebrandt394c5522020-09-11 11:23:01 +00001734}
1735
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001736func (oo *omciCC) sendCreateEvtocdVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001737 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001738 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001739 logger.Debugw(ctx, "send EVTOCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001740 "SequNo": strconv.FormatInt(int64(tid), 16),
1741 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1742
1743 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(params[0])
1744 if omciErr.GetError() == nil {
1745 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
1746 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001747 logger.Errorw(ctx, "Cannot encode EVTOCD for create", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001748 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001749 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001750 }
1751
dbainbri4d3a0dc2020-12-02 00:33:42 +00001752 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001753 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001754 logger.Errorw(ctx, "Cannot serialize EVTOCD create", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001755 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001756 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001757 }
1758
1759 omciRxCallbackPair := callbackPair{
1760 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001761 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001762 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001763 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001764 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001765 logger.Errorw(ctx, "Cannot send EVTOCD create", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001766 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001767 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001768 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001769 logger.Debug(ctx, "send EVTOCD-set msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001770 return meInstance, nil
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001771 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001772 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001773 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001774 return nil, omciErr.GetError()
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001775}
1776
Himani Chawla6d2ae152020-09-02 13:11:20 +05301777func (oo *omciCC) sendSetEvtocdVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001778 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
Himani Chawla6d2ae152020-09-02 13:11:20 +05301779 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001780 logger.Debugw(ctx, "send EVTOCD-Set-msg:", log.Fields{"device-id": oo.deviceID,
mpagenkodff5dda2020-08-28 11:52:01 +00001781 "SequNo": strconv.FormatInt(int64(tid), 16),
1782 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1783
1784 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(params[0])
1785 if omciErr.GetError() == nil {
1786 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1787 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001788 logger.Errorw(ctx, "Cannot encode EVTOCD for set", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001789 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001790 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001791 }
1792
dbainbri4d3a0dc2020-12-02 00:33:42 +00001793 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenkodff5dda2020-08-28 11:52:01 +00001794 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001795 logger.Errorw(ctx, "Cannot serialize EVTOCD set", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001796 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001797 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001798 }
1799
Himani Chawla6d2ae152020-09-02 13:11:20 +05301800 omciRxCallbackPair := callbackPair{
mpagenkodff5dda2020-08-28 11:52:01 +00001801 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001802 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenkodff5dda2020-08-28 11:52:01 +00001803 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001804 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenkodff5dda2020-08-28 11:52:01 +00001805 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001806 logger.Errorw(ctx, "Cannot send EVTOCD set", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001807 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001808 return nil, err
mpagenkodff5dda2020-08-28 11:52:01 +00001809 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001810 logger.Debug(ctx, "send EVTOCD-set msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001811 return meInstance, nil
mpagenkodff5dda2020-08-28 11:52:01 +00001812 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001813 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
mpagenkodff5dda2020-08-28 11:52:01 +00001814 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001815 return nil, omciErr.GetError()
mpagenkodff5dda2020-08-28 11:52:01 +00001816}
mpagenko01e726e2020-10-23 09:45:29 +00001817
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001818func (oo *omciCC) sendDeleteEvtocd(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001819 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001820 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001821 logger.Debugw(ctx, "send EVTOCD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001822 "SequNo": strconv.FormatInt(int64(tid), 16),
1823 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1824
1825 meInstance, omciErr := me.NewExtendedVlanTaggingOperationConfigurationData(params[0])
1826 if omciErr.GetError() == nil {
1827 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid))
1828 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001829 logger.Errorw(ctx, "Cannot encode EVTOCD for delete", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001830 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001831 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001832 }
1833
dbainbri4d3a0dc2020-12-02 00:33:42 +00001834 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001835 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001836 logger.Errorw(ctx, "Cannot serialize EVTOCD delete", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001837 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001838 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001839 }
1840
1841 omciRxCallbackPair := callbackPair{
1842 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001843 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001844 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001845 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001846 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001847 logger.Errorw(ctx, "Cannot send EVTOCD delete", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001848 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001849 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001850 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001851 logger.Debug(ctx, "send EVTOCD-delete msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001852 return meInstance, nil
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001853 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001854 logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001855 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001856 return nil, omciErr.GetError()
ozgecanetsiab5000ef2020-11-27 14:38:20 +03001857}
1858
mpagenko01e726e2020-10-23 09:45:29 +00001859func (oo *omciCC) sendDeleteVtfd(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001860 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
mpagenko01e726e2020-10-23 09:45:29 +00001861 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00001862 logger.Debugw(ctx, "send VTFD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko01e726e2020-10-23 09:45:29 +00001863 "SequNo": strconv.FormatInt(int64(tid), 16),
1864 "InstId": strconv.FormatInt(int64(aInstID), 16)})
1865
1866 meParams := me.ParamData{EntityID: aInstID}
1867 meInstance, omciErr := me.NewVlanTaggingFilterData(meParams)
1868 if omciErr.GetError() == nil {
1869 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
1870 omci.TransactionID(tid))
1871 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001872 logger.Errorw(ctx, "Cannot encode VTFD for delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001873 "Err": err, "device-id": oo.deviceID})
1874 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
1875 // return (dual format) error code that can be used at caller for immediate error treatment
1876 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03001877 return nil, err
mpagenko01e726e2020-10-23 09:45:29 +00001878 }
1879
dbainbri4d3a0dc2020-12-02 00:33:42 +00001880 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko01e726e2020-10-23 09:45:29 +00001881 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001882 logger.Errorw(ctx, "Cannot serialize VTFD delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001883 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001884 return nil, err
mpagenko01e726e2020-10-23 09:45:29 +00001885 }
1886
1887 omciRxCallbackPair := callbackPair{
1888 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00001889 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko01e726e2020-10-23 09:45:29 +00001890 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001891 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko01e726e2020-10-23 09:45:29 +00001892 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00001893 logger.Errorw(ctx, "Cannot send VTFD delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001894 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001895 return nil, err
mpagenko01e726e2020-10-23 09:45:29 +00001896 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001897 logger.Debug(ctx, "send VTFD-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001898 return meInstance, nil
mpagenko01e726e2020-10-23 09:45:29 +00001899 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00001900 logger.Errorw(ctx, "Cannot generate VTFD Instance for delete", log.Fields{
mpagenko01e726e2020-10-23 09:45:29 +00001901 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001902 return nil, omciErr.GetError()
mpagenko01e726e2020-10-23 09:45:29 +00001903}
ozgecanetsia422dbf32020-10-28 14:07:19 +03001904
ozgecanetsiab6441962021-03-10 10:58:48 +03001905// nolint: unused
1906func (oo *omciCC) sendCreateTDVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001907 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsiab6441962021-03-10 10:58:48 +03001908 tid := oo.getNextTid(highPrio)
1909 logger.Debugw(ctx, "send TD-Create-msg:", log.Fields{"device-id": oo.deviceID,
1910 "SequNo": strconv.FormatInt(int64(tid), 16),
1911 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1912 meInstance, omciErr := me.NewTrafficDescriptor(params[0])
1913 if omciErr.GetError() == nil {
1914 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
1915 if err != nil {
1916 logger.Errorw(ctx, "Cannot encode TD for create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001917 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001918 }
1919 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
1920 if err != nil {
1921 logger.Errorw(ctx, "Cannot serialize TD create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001922 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001923 }
1924 omciRxCallbackPair := callbackPair{
1925 cbKey: tid,
1926 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
1927 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001928 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab6441962021-03-10 10:58:48 +03001929 if err != nil {
1930 logger.Errorw(ctx, "Cannot send TD create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001931 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001932 }
1933 logger.Debug(ctx, "send TD-Create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001934 return meInstance, nil
ozgecanetsiab6441962021-03-10 10:58:48 +03001935 }
1936 logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001937 return nil, omciErr.GetError()
ozgecanetsiab6441962021-03-10 10:58:48 +03001938}
1939
1940// nolint: unused
1941func (oo *omciCC) sendSetTDVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001942 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsiab6441962021-03-10 10:58:48 +03001943 tid := oo.getNextTid(highPrio)
1944 logger.Debugw(ctx, "send TD-Set-msg:", log.Fields{"device-id": oo.deviceID,
1945 "SequNo": strconv.FormatInt(int64(tid), 16),
1946 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
1947
1948 meInstance, omciErr := me.NewTrafficDescriptor(params[0])
1949 if omciErr.GetError() == nil {
1950 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
1951 if err != nil {
1952 logger.Errorw(ctx, "Cannot encode TD for set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001953 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001954 }
1955 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
1956 if err != nil {
1957 logger.Errorw(ctx, "Cannot serialize TD set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001958 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001959 }
1960 omciRxCallbackPair := callbackPair{
1961 cbKey: tid,
1962 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
1963 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00001964 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab6441962021-03-10 10:58:48 +03001965 if err != nil {
1966 logger.Errorw(ctx, "Cannot send TD set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001967 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001968 }
1969 logger.Debug(ctx, "send TD-Set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03001970 return meInstance, nil
ozgecanetsiab6441962021-03-10 10:58:48 +03001971 }
1972 logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001973 return nil, omciErr.GetError()
ozgecanetsiab6441962021-03-10 10:58:48 +03001974
1975}
1976
1977// nolint: unused
1978func (oo *omciCC) sendDeleteTD(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03001979 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
ozgecanetsiab6441962021-03-10 10:58:48 +03001980 tid := oo.getNextTid(highPrio)
1981 logger.Debugw(ctx, "send TD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
1982 "SequNo": strconv.FormatInt(int64(tid), 16),
1983 "InstId": strconv.FormatInt(int64(aInstID), 16)})
1984
1985 meParams := me.ParamData{EntityID: aInstID}
1986 meInstance, omciErr := me.NewTrafficDescriptor(meParams)
1987 if omciErr.GetError() == nil {
1988 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid))
1989 if err != nil {
1990 logger.Errorw(ctx, "Cannot encode TD for delete", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001991 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001992 }
1993 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
1994 if err != nil {
1995 logger.Errorw(ctx, "Cannot serialize TD delete", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03001996 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03001997 }
1998 omciRxCallbackPair := callbackPair{
1999 cbKey: tid,
2000 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2001 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002002 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab6441962021-03-10 10:58:48 +03002003 if err != nil {
2004 logger.Errorw(ctx, "Cannot send TD delete", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002005 return nil, err
ozgecanetsiab6441962021-03-10 10:58:48 +03002006 }
2007 logger.Debug(ctx, "send TD-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002008 return meInstance, nil
ozgecanetsiab6441962021-03-10 10:58:48 +03002009 }
2010 logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002011 return nil, omciErr.GetError()
ozgecanetsiab6441962021-03-10 10:58:48 +03002012
2013}
2014
mpagenko8b07c1b2020-11-26 10:36:31 +00002015func (oo *omciCC) sendDeleteGemIWTP(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002016 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
mpagenko8b07c1b2020-11-26 10:36:31 +00002017 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002018 logger.Debugw(ctx, "send GemIwTp-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00002019 "SequNo": strconv.FormatInt(int64(tid), 16),
2020 "InstId": strconv.FormatInt(int64(aInstID), 16)})
2021
2022 meParams := me.ParamData{EntityID: aInstID}
2023 meInstance, omciErr := me.NewGemInterworkingTerminationPoint(meParams)
2024 if omciErr.GetError() == nil {
2025 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
2026 omci.TransactionID(tid))
2027 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002028 logger.Errorw(ctx, "Cannot encode GemIwTp for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002029 "Err": err, "device-id": oo.deviceID})
2030 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
2031 // return (dual format) error code that can be used at caller for immediate error treatment
2032 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03002033 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002034 }
2035
dbainbri4d3a0dc2020-12-02 00:33:42 +00002036 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00002037 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002038 logger.Errorw(ctx, "Cannot serialize GemIwTp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002039 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002040 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002041 }
2042
2043 omciRxCallbackPair := callbackPair{
2044 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002045 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko8b07c1b2020-11-26 10:36:31 +00002046 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002047 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko8b07c1b2020-11-26 10:36:31 +00002048 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002049 logger.Errorw(ctx, "Cannot send GemIwTp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002050 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002051 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002052 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002053 logger.Debug(ctx, "send GemIwTp-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002054 return meInstance, nil
mpagenko8b07c1b2020-11-26 10:36:31 +00002055 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002056 logger.Errorw(ctx, "Cannot generate GemIwTp Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002057 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002058 return nil, omciErr.GetError()
mpagenko8b07c1b2020-11-26 10:36:31 +00002059}
2060
2061func (oo *omciCC) sendDeleteGemNCTP(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002062 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
mpagenko8b07c1b2020-11-26 10:36:31 +00002063 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002064 logger.Debugw(ctx, "send GemNCtp-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00002065 "SequNo": strconv.FormatInt(int64(tid), 16),
2066 "InstId": strconv.FormatInt(int64(aInstID), 16)})
2067
2068 meParams := me.ParamData{EntityID: aInstID}
2069 meInstance, omciErr := me.NewGemPortNetworkCtp(meParams)
2070 if omciErr.GetError() == nil {
2071 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
2072 omci.TransactionID(tid))
2073 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002074 logger.Errorw(ctx, "Cannot encode GemNCtp for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002075 "Err": err, "device-id": oo.deviceID})
2076 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
2077 // return (dual format) error code that can be used at caller for immediate error treatment
2078 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03002079 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002080 }
2081
dbainbri4d3a0dc2020-12-02 00:33:42 +00002082 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00002083 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002084 logger.Errorw(ctx, "Cannot serialize GemNCtp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002085 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002086 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002087 }
2088
2089 omciRxCallbackPair := callbackPair{
2090 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002091 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko8b07c1b2020-11-26 10:36:31 +00002092 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002093 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko8b07c1b2020-11-26 10:36:31 +00002094 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002095 logger.Errorw(ctx, "Cannot send GemNCtp delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002096 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002097 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002098 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002099 logger.Debug(ctx, "send GemNCtp-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002100 return meInstance, nil
mpagenko8b07c1b2020-11-26 10:36:31 +00002101 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002102 logger.Errorw(ctx, "Cannot generate GemNCtp Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002103 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002104 return nil, omciErr.GetError()
mpagenko8b07c1b2020-11-26 10:36:31 +00002105}
2106
2107func (oo *omciCC) sendDeleteDot1PMapper(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002108 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
mpagenko8b07c1b2020-11-26 10:36:31 +00002109 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002110 logger.Debugw(ctx, "send .1pMapper-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00002111 "SequNo": strconv.FormatInt(int64(tid), 16),
2112 "InstId": strconv.FormatInt(int64(aInstID), 16)})
2113
2114 meParams := me.ParamData{EntityID: aInstID}
2115 meInstance, omciErr := me.NewIeee8021PMapperServiceProfile(meParams)
2116 if omciErr.GetError() == nil {
2117 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
2118 omci.TransactionID(tid))
2119 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002120 logger.Errorw(ctx, "Cannot encode .1pMapper for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002121 "Err": err, "device-id": oo.deviceID})
2122 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
2123 // return (dual format) error code that can be used at caller for immediate error treatment
2124 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03002125 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002126 }
2127
dbainbri4d3a0dc2020-12-02 00:33:42 +00002128 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00002129 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002130 logger.Errorw(ctx, "Cannot serialize .1pMapper delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002131 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002132 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002133 }
2134
2135 omciRxCallbackPair := callbackPair{
2136 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002137 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko8b07c1b2020-11-26 10:36:31 +00002138 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002139 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko8b07c1b2020-11-26 10:36:31 +00002140 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002141 logger.Errorw(ctx, "Cannot send .1pMapper delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002142 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002143 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002144 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002145 logger.Debug(ctx, "send .1pMapper-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002146 return meInstance, nil
mpagenko8b07c1b2020-11-26 10:36:31 +00002147 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002148 logger.Errorw(ctx, "Cannot generate .1pMapper Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002149 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002150 return nil, omciErr.GetError()
mpagenko8b07c1b2020-11-26 10:36:31 +00002151}
2152
2153func (oo *omciCC) sendDeleteMBPConfigData(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002154 rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
mpagenko8b07c1b2020-11-26 10:36:31 +00002155 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002156 logger.Debugw(ctx, "send MBPCD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
mpagenko8b07c1b2020-11-26 10:36:31 +00002157 "SequNo": strconv.FormatInt(int64(tid), 16),
2158 "InstId": strconv.FormatInt(int64(aInstID), 16)})
2159
2160 meParams := me.ParamData{EntityID: aInstID}
2161 meInstance, omciErr := me.NewMacBridgePortConfigurationData(meParams)
2162 if omciErr.GetError() == nil {
2163 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType,
2164 omci.TransactionID(tid))
2165 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002166 logger.Errorw(ctx, "Cannot encode MBPCD for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002167 "Err": err, "device-id": oo.deviceID})
2168 //TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
2169 // return (dual format) error code that can be used at caller for immediate error treatment
2170 // (relevant to all used sendXX() methods and their error conditions)
ozgecanetsiab36ed572021-04-01 10:38:48 +03002171 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002172 }
2173
dbainbri4d3a0dc2020-12-02 00:33:42 +00002174 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
mpagenko8b07c1b2020-11-26 10:36:31 +00002175 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002176 logger.Errorw(ctx, "Cannot serialize MBPCD delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002177 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002178 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002179 }
2180
2181 omciRxCallbackPair := callbackPair{
2182 cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002183 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
mpagenko8b07c1b2020-11-26 10:36:31 +00002184 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002185 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko8b07c1b2020-11-26 10:36:31 +00002186 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002187 logger.Errorw(ctx, "Cannot send MBPCD delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002188 "Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002189 return nil, err
mpagenko8b07c1b2020-11-26 10:36:31 +00002190 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002191 logger.Debug(ctx, "send MBPCD-Delete-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002192 return meInstance, nil
mpagenko8b07c1b2020-11-26 10:36:31 +00002193 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002194 logger.Errorw(ctx, "Cannot generate MBPCD Instance for delete", log.Fields{
mpagenko8b07c1b2020-11-26 10:36:31 +00002195 "Err": omciErr.GetError(), "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002196 return nil, omciErr.GetError()
mpagenko8b07c1b2020-11-26 10:36:31 +00002197}
2198
ozgecanetsia422dbf32020-10-28 14:07:19 +03002199func (oo *omciCC) sendCreateMulticastGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002200 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsia422dbf32020-10-28 14:07:19 +03002201 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002202 logger.Debugw(ctx, "send MulticastGemIWTP-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002203 "SequNo": strconv.FormatInt(int64(tid), 16),
2204 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2205
2206 meInstance, omciErr := me.NewMulticastGemInterworkingTerminationPoint(params[0])
2207 if omciErr.GetError() == nil {
2208 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2209 omci.AddDefaults(true))
2210 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002211 logger.Errorw(ctx, "Cannot encode MulticastGEMIWTP for create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002212 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002213 }
2214
dbainbri4d3a0dc2020-12-02 00:33:42 +00002215 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002216 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002217 logger.Errorw(ctx, "Cannot serialize MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002218 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002219 }
2220
2221 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002222 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsia422dbf32020-10-28 14:07:19 +03002223 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002224 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002225 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002226 logger.Errorw(ctx, "Cannot send MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002227 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002228 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002229 logger.Debug(ctx, "send MulticastGEMIWTP-create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002230 return meInstance, nil
ozgecanetsia422dbf32020-10-28 14:07:19 +03002231 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002232 logger.Errorw(ctx, "Cannot generate MulticastGEMIWTP Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03002233 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002234 return nil, omciErr.GetError()
ozgecanetsia422dbf32020-10-28 14:07:19 +03002235}
2236
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002237func (oo *omciCC) sendSetMulticastGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002238 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002239 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002240 logger.Debugw(ctx, "send MulticastGemIWTP-set-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002241 "SequNo": strconv.FormatInt(int64(tid), 16),
2242 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2243
2244 meInstance, omciErr := me.NewMulticastGemInterworkingTerminationPoint(params[0])
2245 if omciErr.GetError() == nil {
2246 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid),
2247 omci.AddDefaults(true))
2248 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002249 logger.Errorw(ctx, "Cannot encode MulticastGEMIWTP for set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002250 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002251 }
2252
dbainbri4d3a0dc2020-12-02 00:33:42 +00002253 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002254 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002255 logger.Errorw(ctx, "Cannot serialize MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002256 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002257 }
2258
2259 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002260 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002261 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002262 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002263 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002264 logger.Errorw(ctx, "Cannot send MulticastGEMIWTP set", log.Fields{"Err": err, "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002265 return nil, err
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002266 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002267 logger.Debug(ctx, "send MulticastGEMIWTP-set-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002268 return meInstance, nil
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002269 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002270 logger.Errorw(ctx, "Cannot generate MulticastGEMIWTP Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002271 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002272 return nil, omciErr.GetError()
ozgecanetsiab5000ef2020-11-27 14:38:20 +03002273}
2274
ozgecanetsia422dbf32020-10-28 14:07:19 +03002275func (oo *omciCC) sendCreateMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002276 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsia422dbf32020-10-28 14:07:19 +03002277 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002278 logger.Debugw(ctx, "send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002279 "SequNo": strconv.FormatInt(int64(tid), 16),
2280 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2281
2282 meInstance, omciErr := me.NewMulticastOperationsProfile(params[0])
2283 if omciErr.GetError() == nil {
2284 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2285 omci.AddDefaults(true))
2286 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002287 logger.Errorw(ctx, "Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002288 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002289 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002290 }
2291
dbainbri4d3a0dc2020-12-02 00:33:42 +00002292 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002293 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002294 logger.Errorw(ctx, "Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002295 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002296 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002297 }
2298
2299 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002300 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsia422dbf32020-10-28 14:07:19 +03002301 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002302 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002303 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002304 logger.Errorw(ctx, "Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002305 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002306 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002307 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002308 logger.Debug(ctx, "send MulticastOperationProfile-create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002309 return meInstance, nil
ozgecanetsia422dbf32020-10-28 14:07:19 +03002310 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002311 logger.Errorw(ctx, "Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03002312 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002313 return nil, omciErr.GetError()
ozgecanetsia422dbf32020-10-28 14:07:19 +03002314}
2315
2316func (oo *omciCC) sendSetMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002317 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsia422dbf32020-10-28 14:07:19 +03002318 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002319 logger.Debugw(ctx, "send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002320 "SequNo": strconv.FormatInt(int64(tid), 16),
2321 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2322
2323 meInstance, omciErr := me.NewMulticastOperationsProfile(params[0])
2324 if omciErr.GetError() == nil {
2325 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid),
2326 omci.AddDefaults(true))
2327 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002328 logger.Errorw(ctx, "Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002329 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002330 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002331 }
2332
dbainbri4d3a0dc2020-12-02 00:33:42 +00002333 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002334 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002335 logger.Errorw(ctx, "Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002336 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002337 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002338 }
2339
2340 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002341 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsia422dbf32020-10-28 14:07:19 +03002342 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002343 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002344 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002345 logger.Errorw(ctx, "Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002346 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002347 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002348 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002349 logger.Debug(ctx, "send MulticastOperationProfile-create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002350 return meInstance, nil
ozgecanetsia422dbf32020-10-28 14:07:19 +03002351 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002352 logger.Errorw(ctx, "Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03002353 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002354 return nil, omciErr.GetError()
ozgecanetsia422dbf32020-10-28 14:07:19 +03002355}
2356
2357func (oo *omciCC) sendCreateMulticastSubConfigInfoVar(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002358 rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
ozgecanetsia422dbf32020-10-28 14:07:19 +03002359 tid := oo.getNextTid(highPrio)
dbainbri4d3a0dc2020-12-02 00:33:42 +00002360 logger.Debugw(ctx, "send MulticastSubConfigInfo-create-msg:", log.Fields{"device-id": oo.deviceID,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002361 "SequNo": strconv.FormatInt(int64(tid), 16),
2362 "InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
2363
2364 meInstance, omciErr := me.NewMulticastSubscriberConfigInfo(params[0])
2365 if omciErr.GetError() == nil {
2366 omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2367 omci.AddDefaults(true))
2368 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002369 logger.Errorw(ctx, "Cannot encode MulticastSubConfigInfo for create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002370 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002371 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002372 }
2373
dbainbri4d3a0dc2020-12-02 00:33:42 +00002374 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002375 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002376 logger.Errorw(ctx, "Cannot serialize MulticastSubConfigInfo create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002377 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002378 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002379 }
2380
2381 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002382 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
ozgecanetsia422dbf32020-10-28 14:07:19 +03002383 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002384 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
ozgecanetsia422dbf32020-10-28 14:07:19 +03002385 if err != nil {
dbainbri4d3a0dc2020-12-02 00:33:42 +00002386 logger.Errorw(ctx, "Cannot send MulticastSubConfigInfo create", log.Fields{"Err": err,
ozgecanetsia422dbf32020-10-28 14:07:19 +03002387 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002388 return nil, err
ozgecanetsia422dbf32020-10-28 14:07:19 +03002389 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002390 logger.Debug(ctx, "send MulticastSubConfigInfo-create-msg done")
ozgecanetsiab36ed572021-04-01 10:38:48 +03002391 return meInstance, nil
ozgecanetsia422dbf32020-10-28 14:07:19 +03002392 }
dbainbri4d3a0dc2020-12-02 00:33:42 +00002393 logger.Errorw(ctx, "Cannot generate MulticastSubConfigInfo Instance", log.Fields{"Err": omciErr.GetError(),
ozgecanetsia422dbf32020-10-28 14:07:19 +03002394 "device-id": oo.deviceID})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002395 return nil, omciErr.GetError()
ozgecanetsia422dbf32020-10-28 14:07:19 +03002396}
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +00002397
Girish Gowdrae0140f02021-02-02 16:55:09 -08002398func (oo *omciCC) sendSyncTime(ctx context.Context, timeout int, highPrio bool, rxChan chan Message) error {
2399 tid := oo.getNextTid(highPrio)
2400 logger.Debugw(ctx, "send synchronize time request:", log.Fields{"device-id": oo.deviceID,
2401 "SequNo": strconv.FormatInt(int64(tid), 16)})
2402
2403 omciLayer := &omci.OMCI{
2404 TransactionID: tid,
2405 MessageType: omci.SynchronizeTimeRequestType,
2406 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2407 // Length: 0x28, // Optional, defaults to 40 octets
2408 }
2409 utcTime := time.Now().UTC()
2410 request := &omci.SynchronizeTimeRequest{
2411 MeBasePacket: omci.MeBasePacket{
2412 EntityClass: me.OnuGClassID,
2413 // Default Instance ID is 0
2414 },
2415 Year: uint16(utcTime.Year()),
2416 Month: uint8(utcTime.Month()),
2417 Day: uint8(utcTime.Day()),
2418 Hour: uint8(utcTime.Hour()),
2419 Minute: uint8(utcTime.Minute()),
2420 Second: uint8(utcTime.Second()),
2421 }
2422
2423 pkt, err := serializeOmciLayer(ctx, omciLayer, request)
2424 if err != nil {
2425 logger.Errorw(ctx, "Cannot serialize synchronize time request", log.Fields{"Err": err,
2426 "device-id": oo.deviceID})
2427 return err
2428 }
2429
2430 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002431 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Girish Gowdrae0140f02021-02-02 16:55:09 -08002432 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002433 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Girish Gowdrae0140f02021-02-02 16:55:09 -08002434 if err != nil {
2435 logger.Errorw(ctx, "Cannot send synchronize time request", log.Fields{"Err": err,
2436 "device-id": oo.deviceID})
2437 return err
2438 }
2439 logger.Debug(ctx, "send synchronize time request done")
2440 return nil
2441}
2442
2443func (oo *omciCC) sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002444 upstream bool, create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
Girish Gowdrae0140f02021-02-02 16:55:09 -08002445 tid := oo.getNextTid(highPrio)
2446 logger.Debugw(ctx, "send ethernet-performance-monitoring-history-me-msg:", log.Fields{"device-id": oo.deviceID,
2447 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create, "upstream": upstream})
2448 meParam := me.ParamData{EntityID: entityID}
2449 var meInstance *me.ManagedEntity
2450 var omciErr me.OmciErrors
2451 if upstream {
2452 meInstance, omciErr = me.NewEthernetFramePerformanceMonitoringHistoryDataUpstream(meParam)
2453 } else {
2454 meInstance, omciErr = me.NewEthernetFramePerformanceMonitoringHistoryDataDownstream(meParam)
2455 }
2456 if omciErr.GetError() == nil {
2457 var omciLayer *omci.OMCI
2458 var msgLayer gopacket.SerializableLayer
2459 var err error
2460 if create {
2461 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2462 omci.AddDefaults(true))
2463 } else {
2464 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid),
2465 omci.AddDefaults(true))
2466 }
2467 if err != nil {
2468 logger.Errorw(ctx, "Cannot encode ethernet frame performance monitoring history data ME",
2469 log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002470 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002471 }
2472
2473 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
2474 if err != nil {
2475 logger.Errorw(ctx, "Cannot serialize ethernet frame performance monitoring history data ME",
2476 log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002477 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002478 }
2479
2480 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002481 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Girish Gowdrae0140f02021-02-02 16:55:09 -08002482 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002483 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Girish Gowdrae0140f02021-02-02 16:55:09 -08002484 if err != nil {
2485 logger.Errorw(ctx, "Cannot send ethernet frame performance monitoring history data ME",
2486 log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002487 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002488 }
2489 logger.Debugw(ctx, "send ethernet frame performance monitoring history data ME done",
2490 log.Fields{"device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002491 return meInstance, nil
Girish Gowdrae0140f02021-02-02 16:55:09 -08002492 }
2493 logger.Errorw(ctx, "Cannot generate ethernet frame performance monitoring history data ME Instance",
2494 log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002495 return nil, omciErr.GetError()
Girish Gowdrae0140f02021-02-02 16:55:09 -08002496}
2497
2498func (oo *omciCC) sendCreateOrDeleteEthernetUniHistoryME(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002499 create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
Girish Gowdrae0140f02021-02-02 16:55:09 -08002500 tid := oo.getNextTid(highPrio)
2501 logger.Debugw(ctx, "send ethernet-uni-history-me-msg:", log.Fields{"device-id": oo.deviceID,
2502 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
2503 meParam := me.ParamData{EntityID: entityID}
2504 var meInstance *me.ManagedEntity
2505 var omciErr me.OmciErrors
2506 meInstance, omciErr = me.NewEthernetPerformanceMonitoringHistoryData(meParam)
2507
2508 if omciErr.GetError() == nil {
2509 var omciLayer *omci.OMCI
2510 var msgLayer gopacket.SerializableLayer
2511 var err error
2512 if create {
2513 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2514 omci.AddDefaults(true))
2515 } else {
2516 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid),
2517 omci.AddDefaults(true))
2518 }
2519 if err != nil {
2520 logger.Errorw(ctx, "Cannot encode ethernet uni history data ME",
2521 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002522 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002523 }
2524
2525 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
2526 if err != nil {
2527 logger.Errorw(ctx, "Cannot serialize ethernet uni history data ME",
2528 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002529 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002530 }
2531
2532 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002533 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Girish Gowdrae0140f02021-02-02 16:55:09 -08002534 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002535 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Girish Gowdrae0140f02021-02-02 16:55:09 -08002536 if err != nil {
2537 logger.Errorw(ctx, "Cannot send ethernet uni history data ME",
2538 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002539 return nil, err
Girish Gowdrae0140f02021-02-02 16:55:09 -08002540 }
2541 logger.Debugw(ctx, "send ethernet uni history data ME done",
2542 log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002543 return meInstance, nil
Girish Gowdrae0140f02021-02-02 16:55:09 -08002544 }
2545 logger.Errorw(ctx, "Cannot generate ethernet uni history data ME Instance",
2546 log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002547 return nil, omciErr.GetError()
Girish Gowdrae0140f02021-02-02 16:55:09 -08002548}
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002549
2550func (oo *omciCC) sendCreateOrDeleteFecHistoryME(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002551 create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002552 tid := oo.getNextTid(highPrio)
2553 logger.Debugw(ctx, "send fec-history-me-msg:", log.Fields{"device-id": oo.deviceID,
2554 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
2555 meParam := me.ParamData{EntityID: entityID}
2556 var meInstance *me.ManagedEntity
2557 var omciErr me.OmciErrors
2558 meInstance, omciErr = me.NewFecPerformanceMonitoringHistoryData(meParam)
2559
2560 if omciErr.GetError() == nil {
2561 var omciLayer *omci.OMCI
2562 var msgLayer gopacket.SerializableLayer
2563 var err error
2564 if create {
2565 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2566 omci.AddDefaults(true))
2567 } else {
2568 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid),
2569 omci.AddDefaults(true))
2570 }
2571 if err != nil {
2572 logger.Errorw(ctx, "Cannot encode fec history data ME",
2573 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002574 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002575 }
2576
2577 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
2578 if err != nil {
2579 logger.Errorw(ctx, "Cannot serialize fec history data ME",
2580 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002581 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002582 }
2583
2584 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002585 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002586 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002587 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002588 if err != nil {
2589 logger.Errorw(ctx, "Cannot send fec history data ME",
2590 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002591 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002592 }
2593 logger.Debugw(ctx, "send fec history data ME done",
2594 log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002595 return meInstance, nil
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002596 }
2597 logger.Errorw(ctx, "Cannot generate fec history data ME Instance",
2598 log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002599 return nil, omciErr.GetError()
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002600}
2601
2602func (oo *omciCC) sendCreateOrDeleteGemPortHistoryME(ctx context.Context, timeout int, highPrio bool,
ozgecanetsiab36ed572021-04-01 10:38:48 +03002603 create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002604 tid := oo.getNextTid(highPrio)
2605 logger.Debugw(ctx, "send gemport-history-me-msg:", log.Fields{"device-id": oo.deviceID,
2606 "SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
2607 meParam := me.ParamData{EntityID: entityID}
2608 var meInstance *me.ManagedEntity
2609 var omciErr me.OmciErrors
2610 meInstance, omciErr = me.NewGemPortNetworkCtpPerformanceMonitoringHistoryData(meParam)
2611
2612 if omciErr.GetError() == nil {
2613 var omciLayer *omci.OMCI
2614 var msgLayer gopacket.SerializableLayer
2615 var err error
2616 if create {
2617 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid),
2618 omci.AddDefaults(true))
2619 } else {
2620 omciLayer, msgLayer, err = omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid),
2621 omci.AddDefaults(true))
2622 }
2623 if err != nil {
2624 logger.Errorw(ctx, "Cannot encode gemport history data ME",
2625 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002626 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002627 }
2628
2629 pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
2630 if err != nil {
2631 logger.Errorw(ctx, "Cannot serialize gemport history data ME",
2632 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002633 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002634 }
2635
2636 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenko80622a52021-02-09 16:53:23 +00002637 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002638 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002639 err = oo.send(ctx, pkt, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002640 if err != nil {
2641 logger.Errorw(ctx, "Cannot send gemport history data ME",
2642 log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002643 return nil, err
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002644 }
2645 logger.Debugw(ctx, "send gemport history data ME done",
2646 log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002647 return meInstance, nil
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002648 }
2649 logger.Errorw(ctx, "Cannot generate gemport history data ME Instance",
2650 log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
ozgecanetsiab36ed572021-04-01 10:38:48 +03002651 return nil, omciErr.GetError()
Girish Gowdra5c5aaf42021-02-17 19:40:50 -08002652}
2653
mpagenko80622a52021-02-09 16:53:23 +00002654func (oo *omciCC) sendStartSoftwareDownload(ctx context.Context, timeout int, highPrio bool,
2655 rxChan chan Message, aImageMeID uint16, aDownloadWindowSize uint8, aFileLen uint32) error {
2656 tid := oo.getNextTid(highPrio)
2657 logger.Debugw(ctx, "send StartSwDlRequest:", log.Fields{"device-id": oo.deviceID,
2658 "SequNo": strconv.FormatInt(int64(tid), 16),
2659 "InstId": strconv.FormatInt(int64(aImageMeID), 16)})
2660
2661 omciLayer := &omci.OMCI{
2662 TransactionID: tid,
2663 MessageType: omci.StartSoftwareDownloadRequestType,
2664 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2665 // Length: 0x28, // Optional, defaults to 40 octets
2666 }
2667 request := &omci.StartSoftwareDownloadRequest{
2668 MeBasePacket: omci.MeBasePacket{
2669 EntityClass: me.SoftwareImageClassID,
2670 EntityInstance: aImageMeID, //inactive image
2671 },
2672 WindowSize: aDownloadWindowSize,
2673 ImageSize: aFileLen,
2674 NumberOfCircuitPacks: 1, //parallel download to multiple circuit packs not supported
2675 CircuitPacks: []uint16{0}, //circuit pack indication don't care for NumberOfCircuitPacks=1, but needed by omci-lib
2676 }
2677
2678 var options gopacket.SerializeOptions
2679 options.FixLengths = true
2680 buffer := gopacket.NewSerializeBuffer()
2681 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2682 if err != nil {
2683 logger.Errorw(ctx, "Cannot serialize StartSwDlRequest", log.Fields{"Err": err,
2684 "device-id": oo.deviceID})
2685 return err
2686 }
2687 outgoingPacket := buffer.Bytes()
2688
2689 omciRxCallbackPair := callbackPair{cbKey: tid,
2690 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2691 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002692 err = oo.send(ctx, outgoingPacket, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko80622a52021-02-09 16:53:23 +00002693 if err != nil {
2694 logger.Errorw(ctx, "Cannot send StartSwDlRequest", log.Fields{"Err": err,
2695 "device-id": oo.deviceID})
2696 return err
2697 }
2698 logger.Debug(ctx, "send StartSwDlRequest done")
mpagenko80622a52021-02-09 16:53:23 +00002699 return nil
2700}
2701
mpagenkoc26d4c02021-05-06 14:27:57 +00002702func (oo *omciCC) sendDownloadSection(ctx context.Context, aTimeout int, highPrio bool,
mpagenko80622a52021-02-09 16:53:23 +00002703 rxChan chan Message, aImageMeID uint16, aAckRequest uint8, aDownloadSectionNo uint8, aSection []byte, aPrint bool) error {
2704 tid := oo.getNextTid(highPrio)
2705 logger.Debugw(ctx, "send DlSectionRequest:", log.Fields{"device-id": oo.deviceID,
2706 "SequNo": strconv.FormatInt(int64(tid), 16),
mpagenko15ff4a52021-03-02 10:09:20 +00002707 "InstId": strconv.FormatInt(int64(aImageMeID), 16), "omci-ack": aAckRequest})
mpagenko80622a52021-02-09 16:53:23 +00002708
2709 //TODO!!!: don't know by now on how to generate the possibly needed AR (or enforce it to 0) with current omci-lib
2710 // by now just try to send it as defined by omci-lib
mpagenko15ff4a52021-03-02 10:09:20 +00002711 msgType := omci.DownloadSectionRequestType
mpagenkoc26d4c02021-05-06 14:27:57 +00002712 var timeout int = 0 //default value for no response expected
mpagenko15ff4a52021-03-02 10:09:20 +00002713 if aAckRequest > 0 {
2714 msgType = omci.DownloadSectionRequestWithResponseType
mpagenkoc26d4c02021-05-06 14:27:57 +00002715 timeout = aTimeout
mpagenko15ff4a52021-03-02 10:09:20 +00002716 }
mpagenko80622a52021-02-09 16:53:23 +00002717 omciLayer := &omci.OMCI{
2718 TransactionID: tid,
mpagenko15ff4a52021-03-02 10:09:20 +00002719 MessageType: msgType,
mpagenko80622a52021-02-09 16:53:23 +00002720 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2721 // Length: 0x28, // Optional, defaults to 40 octets
2722 }
Girish Gowdra8a7b4562021-02-23 16:27:42 -08002723 var localSectionData [31]byte
mpagenko15ff4a52021-03-02 10:09:20 +00002724 copy(localSectionData[:], aSection) // as long as DownloadSectionRequest defines array for SectionData we need to copy into the array
mpagenko80622a52021-02-09 16:53:23 +00002725 request := &omci.DownloadSectionRequest{
2726 MeBasePacket: omci.MeBasePacket{
2727 EntityClass: me.SoftwareImageClassID,
2728 EntityInstance: aImageMeID, //inactive image
2729 },
2730 SectionNumber: aDownloadSectionNo,
2731 SectionData: localSectionData,
2732 }
2733
2734 var options gopacket.SerializeOptions
2735 options.FixLengths = true
2736 buffer := gopacket.NewSerializeBuffer()
2737 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2738 if err != nil {
2739 logger.Errorw(ctx, "Cannot serialize DlSectionRequest", log.Fields{"Err": err,
2740 "device-id": oo.deviceID})
2741 return err
2742 }
2743 outgoingPacket := buffer.Bytes()
2744
mpagenko15ff4a52021-03-02 10:09:20 +00002745 //for initial debug purpose overrule the requested print state for some frames
2746 printFrame := aPrint
2747 if aAckRequest > 0 || aDownloadSectionNo == 0 {
2748 printFrame = true
2749 }
2750
mpagenko80622a52021-02-09 16:53:23 +00002751 omciRxCallbackPair := callbackPair{cbKey: tid,
mpagenkoc26d4c02021-05-06 14:27:57 +00002752 // the callback is set even though no response might be required here, the tid (key) setting is needed here anyway
2753 // (used to avoid retransmission of frames with the same TID)
mpagenko15ff4a52021-03-02 10:09:20 +00002754 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, printFrame /*aPrint*/},
mpagenko80622a52021-02-09 16:53:23 +00002755 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002756 err = oo.send(ctx, outgoingPacket, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko80622a52021-02-09 16:53:23 +00002757 if err != nil {
2758 logger.Errorw(ctx, "Cannot send DlSectionRequest", log.Fields{"Err": err,
2759 "device-id": oo.deviceID})
2760 return err
2761 }
2762 logger.Debug(ctx, "send DlSectionRequest done")
mpagenko80622a52021-02-09 16:53:23 +00002763 return nil
2764}
2765
2766func (oo *omciCC) sendEndSoftwareDownload(ctx context.Context, timeout int, highPrio bool,
2767 rxChan chan Message, aImageMeID uint16, aFileLen uint32, aImageCrc uint32) error {
2768 tid := oo.getNextTid(highPrio)
2769 logger.Debugw(ctx, "send EndSwDlRequest:", log.Fields{"device-id": oo.deviceID,
2770 "SequNo": strconv.FormatInt(int64(tid), 16),
2771 "InstId": strconv.FormatInt(int64(aImageMeID), 16)})
2772
mpagenko15ff4a52021-03-02 10:09:20 +00002773 omciLayer := &omci.OMCI{
mpagenko80622a52021-02-09 16:53:23 +00002774 TransactionID: tid,
mpagenko15ff4a52021-03-02 10:09:20 +00002775 MessageType: omci.EndSoftwareDownloadRequestType,
mpagenko80622a52021-02-09 16:53:23 +00002776 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2777 // Length: 0x28, // Optional, defaults to 40 octets
2778 }
mpagenko15ff4a52021-03-02 10:09:20 +00002779 request := &omci.EndSoftwareDownloadRequest{
mpagenko80622a52021-02-09 16:53:23 +00002780 MeBasePacket: omci.MeBasePacket{
2781 EntityClass: me.SoftwareImageClassID,
2782 EntityInstance: aImageMeID, //inactive image
2783 },
mpagenko15ff4a52021-03-02 10:09:20 +00002784 CRC32: aImageCrc,
2785 ImageSize: aFileLen,
2786 NumberOfInstances: 1, //parallel download to multiple circuit packs not supported
2787 ImageInstances: []uint16{0}, //don't care for NumberOfInstances=1, but probably needed by omci-lib as in startSwDlRequest
mpagenko80622a52021-02-09 16:53:23 +00002788 }
mpagenko15ff4a52021-03-02 10:09:20 +00002789
2790 var options gopacket.SerializeOptions
2791 options.FixLengths = true
2792 buffer := gopacket.NewSerializeBuffer()
2793 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2794 if err != nil {
2795 logger.Errorw(ctx, "Cannot serialize EndSwDlRequest", log.Fields{"Err": err,
mpagenko80622a52021-02-09 16:53:23 +00002796 "device-id": oo.deviceID})
mpagenko15ff4a52021-03-02 10:09:20 +00002797 return err
mpagenko80622a52021-02-09 16:53:23 +00002798 }
mpagenko15ff4a52021-03-02 10:09:20 +00002799 outgoingPacket := buffer.Bytes()
2800
2801 omciRxCallbackPair := callbackPair{cbKey: tid,
2802 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2803 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002804 err = oo.send(ctx, outgoingPacket, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko15ff4a52021-03-02 10:09:20 +00002805 if err != nil {
2806 logger.Errorw(ctx, "Cannot send EndSwDlRequest", log.Fields{"Err": err,
2807 "device-id": oo.deviceID})
2808 return err
2809 }
2810 logger.Debug(ctx, "send EndSwDlRequest done")
mpagenko80622a52021-02-09 16:53:23 +00002811 return nil
2812}
2813
2814func (oo *omciCC) sendActivateSoftware(ctx context.Context, timeout int, highPrio bool,
2815 rxChan chan Message, aImageMeID uint16) error {
2816 tid := oo.getNextTid(highPrio)
2817 logger.Debugw(ctx, "send ActivateSwRequest:", log.Fields{"device-id": oo.deviceID,
2818 "SequNo": strconv.FormatInt(int64(tid), 16),
2819 "InstId": strconv.FormatInt(int64(aImageMeID), 16)})
2820
2821 omciLayer := &omci.OMCI{
2822 TransactionID: tid,
2823 MessageType: omci.ActivateSoftwareRequestType,
2824 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2825 // Length: 0x28, // Optional, defaults to 40 octets
2826 }
2827 request := &omci.ActivateSoftwareRequest{
2828 MeBasePacket: omci.MeBasePacket{
2829 EntityClass: me.SoftwareImageClassID,
2830 EntityInstance: aImageMeID, //inactive image
2831 },
2832 ActivateFlags: 0, //unconditionally reset as the only relevant option here (regardless of VOIP)
2833 }
2834
2835 var options gopacket.SerializeOptions
2836 options.FixLengths = true
2837 buffer := gopacket.NewSerializeBuffer()
2838 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2839 if err != nil {
2840 logger.Errorw(ctx, "Cannot serialize ActivateSwRequest", log.Fields{"Err": err,
2841 "device-id": oo.deviceID})
2842 return err
2843 }
2844 outgoingPacket := buffer.Bytes()
2845
2846 omciRxCallbackPair := callbackPair{cbKey: tid,
2847 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2848 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002849 err = oo.send(ctx, outgoingPacket, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko80622a52021-02-09 16:53:23 +00002850 if err != nil {
2851 logger.Errorw(ctx, "Cannot send ActivateSwRequest", log.Fields{"Err": err,
2852 "device-id": oo.deviceID})
2853 return err
2854 }
2855 logger.Debug(ctx, "send ActivateSwRequest done")
mpagenko15ff4a52021-03-02 10:09:20 +00002856 return nil
2857}
mpagenko80622a52021-02-09 16:53:23 +00002858
mpagenko15ff4a52021-03-02 10:09:20 +00002859func (oo *omciCC) sendCommitSoftware(ctx context.Context, timeout int, highPrio bool,
2860 rxChan chan Message, aImageMeID uint16) error {
2861 tid := oo.getNextTid(highPrio)
2862 logger.Debugw(ctx, "send CommitSwRequest:", log.Fields{"device-id": oo.deviceID,
2863 "SequNo": strconv.FormatInt(int64(tid), 16),
2864 "InstId": strconv.FormatInt(int64(aImageMeID), 16)})
2865
2866 omciLayer := &omci.OMCI{
mpagenko80622a52021-02-09 16:53:23 +00002867 TransactionID: tid,
mpagenko15ff4a52021-03-02 10:09:20 +00002868 MessageType: omci.CommitSoftwareRequestType,
mpagenko80622a52021-02-09 16:53:23 +00002869 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2870 // Length: 0x28, // Optional, defaults to 40 octets
2871 }
mpagenko15ff4a52021-03-02 10:09:20 +00002872 request := &omci.CommitSoftwareRequest{
mpagenko80622a52021-02-09 16:53:23 +00002873 MeBasePacket: omci.MeBasePacket{
2874 EntityClass: me.SoftwareImageClassID,
2875 EntityInstance: aImageMeID, //inactive image
2876 },
mpagenko80622a52021-02-09 16:53:23 +00002877 }
mpagenko15ff4a52021-03-02 10:09:20 +00002878
2879 var options gopacket.SerializeOptions
2880 options.FixLengths = true
2881 buffer := gopacket.NewSerializeBuffer()
2882 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2883 if err != nil {
2884 logger.Errorw(ctx, "Cannot serialize CommitSwRequest", log.Fields{"Err": err,
mpagenko80622a52021-02-09 16:53:23 +00002885 "device-id": oo.deviceID})
mpagenko15ff4a52021-03-02 10:09:20 +00002886 return err
mpagenko80622a52021-02-09 16:53:23 +00002887 }
mpagenko15ff4a52021-03-02 10:09:20 +00002888 outgoingPacket := buffer.Bytes()
2889
2890 omciRxCallbackPair := callbackPair{cbKey: tid,
2891 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2892 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00002893 err = oo.send(ctx, outgoingPacket, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
mpagenko15ff4a52021-03-02 10:09:20 +00002894 if err != nil {
2895 logger.Errorw(ctx, "Cannot send CommitSwRequest", log.Fields{"Err": err,
2896 "device-id": oo.deviceID})
2897 return err
2898 }
2899 logger.Debug(ctx, "send CommitSwRequest done")
mpagenko80622a52021-02-09 16:53:23 +00002900 return nil
2901}
2902
Girish Gowdra6afb56a2021-04-27 17:47:57 -07002903func (oo *omciCC) sendSelfTestReq(ctx context.Context, classID me.ClassID, instdID uint16, timeout int, highPrio bool, rxChan chan Message) error {
2904 tid := oo.getNextTid(highPrio)
2905 logger.Debugw(ctx, "send self test request:", log.Fields{"device-id": oo.deviceID,
2906 "SequNo": strconv.FormatInt(int64(tid), 16),
2907 "InstId": strconv.FormatInt(int64(instdID), 16)})
2908 omciLayer := &omci.OMCI{
2909 TransactionID: tid,
2910 MessageType: omci.TestRequestType,
2911 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
2912 // Length: 0x28, // Optional, defaults to 40 octets
2913 }
2914
2915 var request *omci.OpticalLineSupervisionTestRequest
2916 switch classID {
2917 case aniGClassID:
2918 request = &omci.OpticalLineSupervisionTestRequest{
2919 MeBasePacket: omci.MeBasePacket{
2920 EntityClass: classID,
2921 EntityInstance: instdID,
2922 },
2923 SelectTest: uint8(7), // self test
2924 GeneralPurposeBuffer: uint16(0),
2925 VendorSpecificParameters: uint16(0),
2926 }
2927 default:
2928 logger.Errorw(ctx, "unsupported class id for self test request", log.Fields{"device-id": oo.deviceID, "classID": classID})
2929 return fmt.Errorf("unsupported-class-id-for-self-test-request-%v", classID)
2930 }
2931 // Test serialization back to former string
2932 var options gopacket.SerializeOptions
2933 options.FixLengths = true
2934
2935 buffer := gopacket.NewSerializeBuffer()
2936 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
2937 if err != nil {
2938 logger.Errorw(ctx, "Cannot serialize self test request", log.Fields{"Err": err,
2939 "device-id": oo.deviceID})
2940 return err
2941 }
2942 outgoingPacket := buffer.Bytes()
2943
2944 omciRxCallbackPair := callbackPair{cbKey: tid,
2945 cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, true},
2946 }
2947 err = oo.send(ctx, outgoingPacket, timeout, 0, highPrio, omciRxCallbackPair)
2948 if err != nil {
2949 logger.Errorw(ctx, "Cannot send self test request", log.Fields{"Err": err,
2950 "device-id": oo.deviceID})
2951 return err
2952 }
2953 logger.Debug(ctx, "send self test request done")
2954 return nil
2955}
2956
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002957//nolint: gocyclo
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002958func isSuccessfulResponseWithMibDataSync(omciMsg *omci.OMCI, packet *gp.Packet) bool {
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +00002959 for _, v := range responsesWithMibDataSync {
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002960 if v == omciMsg.MessageType {
Girish Gowdra6afb56a2021-04-27 17:47:57 -07002961 nextLayer, _ := omci.MsgTypeToNextLayer(v, false)
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002962 msgLayer := (*packet).Layer(nextLayer)
2963 switch nextLayer {
2964 case omci.LayerTypeCreateResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002965 if resp := msgLayer.(*omci.CreateResponse); resp != nil {
2966 if resp.Result == me.Success {
2967 return true
2968 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002969 }
2970 case omci.LayerTypeDeleteResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002971 if resp := msgLayer.(*omci.DeleteResponse); resp != nil {
2972 if resp.Result == me.Success {
2973 return true
2974 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002975 }
2976 case omci.LayerTypeSetResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002977 if resp := msgLayer.(*omci.SetResponse); resp != nil {
2978 if resp.Result == me.Success {
2979 return true
2980 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002981 }
2982 case omci.LayerTypeStartSoftwareDownloadResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002983 if resp := msgLayer.(*omci.StartSoftwareDownloadResponse); resp != nil {
2984 if resp.Result == me.Success {
2985 return true
2986 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002987 }
2988 case omci.LayerTypeEndSoftwareDownloadResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002989 if resp := msgLayer.(*omci.EndSoftwareDownloadResponse); resp != nil {
2990 if resp.Result == me.Success {
2991 return true
2992 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002993 }
2994 case omci.LayerTypeActivateSoftwareResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00002995 if resp := msgLayer.(*omci.ActivateSoftwareResponse); resp != nil {
2996 if resp.Result == me.Success {
2997 return true
2998 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00002999 }
3000 case omci.LayerTypeCommitSoftwareResponse:
Holger Hildebrandt8680ca32021-05-19 10:30:53 +00003001 if resp := msgLayer.(*omci.CommitSoftwareResponse); resp != nil {
3002 if resp.Result == me.Success {
3003 return true
3004 }
Holger Hildebrandt3124e302021-03-23 12:47:03 +00003005 }
3006 }
Holger Hildebrandt0bd45f82021-01-11 13:29:37 +00003007 }
3008 }
3009 return false
3010}
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003011
3012func (oo *omciCC) processRequestMonitoring(ctx context.Context, aOmciTxRequest omciTransferStructure) {
3013
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003014 timeout := aOmciTxRequest.timeout
mpagenkoc26d4c02021-05-06 14:27:57 +00003015 if timeout == 0 {
3016 //timeout 0 indicates that no response is expected - fire and forget
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003017 oo.mutexTxQueue.Lock()
3018 oo.txQueue.PushBack(aOmciTxRequest) // enqueue
3019 oo.mutexTxQueue.Unlock()
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003020 go oo.sendNextRequest(ctx)
mpagenkoc26d4c02021-05-06 14:27:57 +00003021 } else {
3022 chSuccess := make(chan bool)
3023 aOmciTxRequest.chSuccess = chSuccess
3024 tid := aOmciTxRequest.cbPair.cbKey
3025 retries := aOmciTxRequest.retries
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003026
mpagenkoc26d4c02021-05-06 14:27:57 +00003027 oo.mutexMonReq.Lock()
3028 oo.monitoredRequests[tid] = aOmciTxRequest
3029 oo.mutexMonReq.Unlock()
3030
3031 retryCounter := 0
3032 loop:
3033 for retryCounter <= retries {
3034
3035 oo.mutexTxQueue.Lock()
3036 oo.txQueue.PushBack(aOmciTxRequest) // enqueue
3037 oo.mutexTxQueue.Unlock()
3038 go oo.sendNextRequest(ctx)
3039
3040 select {
3041 case success := <-chSuccess:
3042 if success {
3043 logger.Debugw(ctx, "reqMon: response received in time",
3044 log.Fields{"tid": tid, "device-id": oo.deviceID})
3045 } else {
3046 logger.Debugw(ctx, "reqMon: wait for response aborted",
3047 log.Fields{"tid": tid, "device-id": oo.deviceID})
3048 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003049 break loop
mpagenkoc26d4c02021-05-06 14:27:57 +00003050 case <-time.After(time.Duration(timeout) * time.Second):
3051 if retryCounter == retries {
3052 logger.Errorw(ctx, "reqMon: timeout waiting for response - no of max retries reached!",
3053 log.Fields{"tid": tid, "retries": retryCounter, "device-id": oo.deviceID})
3054 break loop
3055 } else {
3056 logger.Infow(ctx, "reqMon: timeout waiting for response - retry",
3057 log.Fields{"tid": tid, "retries": retryCounter, "device-id": oo.deviceID})
3058 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003059 }
mpagenkoc26d4c02021-05-06 14:27:57 +00003060 retryCounter++
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003061 }
mpagenkoc26d4c02021-05-06 14:27:57 +00003062 oo.mutexMonReq.Lock()
3063 delete(oo.monitoredRequests, tid)
3064 oo.mutexMonReq.Unlock()
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003065 }
Holger Hildebrandt366ef192021-05-05 11:07:44 +00003066}
3067
3068//CancelRequestMonitoring terminates monitoring of outstanding omci requests
3069func (oo *omciCC) CancelRequestMonitoring() {
3070 oo.mutexMonReq.RLock()
3071 for k := range oo.monitoredRequests {
3072 oo.monitoredRequests[k].chSuccess <- false
3073 }
3074 oo.mutexMonReq.RUnlock()
3075}
3076
3077//GetMaxOmciTimeoutWithRetries provides a timeout value greater than the maximum
3078//time consumed for retry processing of a particular OMCI-request
3079func (oo *omciCC) GetMaxOmciTimeoutWithRetries() time.Duration {
3080 return time.Duration((cDefaultRetries+1)*oo.pOnuDeviceEntry.pOpenOnuAc.omciTimeout + 1)
3081}