Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2018-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 | |
| 17 | package omci |
| 18 | |
| 19 | import ( |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 20 | "errors" |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 21 | "github.com/google/gopacket" |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 22 | "github.com/opencord/omci-lib-go" |
| 23 | me "github.com/opencord/omci-lib-go/generated" |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 24 | log "github.com/sirupsen/logrus" |
| 25 | ) |
| 26 | |
| 27 | var omciLogger = log.WithFields(log.Fields{ |
| 28 | "module": "OMCI", |
| 29 | }) |
| 30 | |
| 31 | const galEthernetEID = uint16(1) |
| 32 | const maxGemPayloadSize = uint16(48) |
| 33 | const gemEID = uint16(1) |
| 34 | |
| 35 | type txFrameCreator func() ([]byte, error) |
| 36 | type rxFrameParser func(gopacket.Packet) error |
| 37 | |
| 38 | type ServiceStep struct { |
| 39 | MakeTxFrame txFrameCreator |
| 40 | RxHandler rxFrameParser |
| 41 | } |
| 42 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 43 | // NOTE this is basically the same as https://github.com/opencord/voltha-openonu-adapter-go/blob/master/internal/pkg/onuadaptercore/omci_cc.go#L545-L564 |
| 44 | // we should probably move it in "omci-lib-go" |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 45 | func Serialize(msgType omci.MessageType, request gopacket.SerializableLayer, tid uint16) ([]byte, error) { |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 46 | omciLayer := &omci.OMCI{ |
| 47 | TransactionID: tid, |
| 48 | MessageType: msgType, |
| 49 | } |
| 50 | var options gopacket.SerializeOptions |
| 51 | options.FixLengths = true |
| 52 | |
| 53 | buffer := gopacket.NewSerializeBuffer() |
| 54 | err := gopacket.SerializeLayers(buffer, options, omciLayer, request) |
| 55 | if err != nil { |
| 56 | return nil, err |
| 57 | } |
| 58 | return buffer.Bytes(), nil |
| 59 | } |
| 60 | |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 61 | func CreateMibResetRequest(tid uint16) ([]byte, error) { |
| 62 | |
| 63 | request := &omci.MibResetRequest{ |
| 64 | MeBasePacket: omci.MeBasePacket{ |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 65 | EntityClass: me.OnuDataClassID, |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 66 | }, |
| 67 | } |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 68 | pkt, err := Serialize(omci.MibResetRequestType, request, tid) |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 69 | if err != nil { |
| 70 | omciLogger.WithFields(log.Fields{ |
| 71 | "Err": err, |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 72 | }).Fatalf("Cannot Serialize MibResetRequest") |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 73 | return nil, err |
| 74 | } |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 75 | return HexEncode(pkt) |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 76 | } |
| 77 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 78 | func CreateMibResetResponse(tid uint16) ([]byte, error) { |
| 79 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 80 | request := &omci.MibResetResponse{ |
| 81 | MeBasePacket: omci.MeBasePacket{ |
| 82 | EntityClass: me.OnuDataClassID, |
| 83 | }, |
| 84 | Result: me.Success, |
| 85 | } |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 86 | pkt, err := Serialize(omci.MibResetResponseType, request, tid) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 87 | if err != nil { |
| 88 | omciLogger.WithFields(log.Fields{ |
| 89 | "Err": err, |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 90 | }).Error("Cannot Serialize MibResetResponse") |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 91 | return nil, err |
| 92 | } |
| 93 | return pkt, nil |
| 94 | } |
| 95 | |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 96 | func CreateMibUploadRequest(tid uint16) ([]byte, error) { |
| 97 | request := &omci.MibUploadRequest{ |
| 98 | MeBasePacket: omci.MeBasePacket{ |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 99 | EntityClass: me.OnuDataClassID, |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 100 | // Default Instance ID is 0 |
| 101 | }, |
| 102 | } |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 103 | pkt, err := Serialize(omci.MibUploadRequestType, request, tid) |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 104 | if err != nil { |
| 105 | omciLogger.WithFields(log.Fields{ |
| 106 | "Err": err, |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 107 | }).Fatalf("Cannot Serialize MibUploadRequest") |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 108 | return nil, err |
| 109 | } |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 110 | return HexEncode(pkt) |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 111 | } |
| 112 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 113 | func CreateMibUploadResponse(tid uint16) ([]byte, error) { |
| 114 | |
| 115 | numberOfCommands := uint16(291) //NOTE should this be configurable? (not until we have moved all the messages away from omci-sim) |
| 116 | |
| 117 | request := &omci.MibUploadResponse{ |
| 118 | MeBasePacket: omci.MeBasePacket{ |
| 119 | EntityClass: me.OnuDataClassID, |
| 120 | }, |
| 121 | NumberOfCommands: numberOfCommands, |
| 122 | } |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 123 | pkt, err := Serialize(omci.MibUploadResponseType, request, tid) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 124 | if err != nil { |
| 125 | omciLogger.WithFields(log.Fields{ |
| 126 | "Err": err, |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 127 | }).Error("Cannot Serialize MibUploadResponse") |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 128 | return nil, err |
| 129 | } |
| 130 | return pkt, nil |
| 131 | } |
| 132 | |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 133 | func CreateMibUploadNextRequest(tid uint16, seqNumber uint16) ([]byte, error) { |
| 134 | |
| 135 | request := &omci.MibUploadNextRequest{ |
| 136 | MeBasePacket: omci.MeBasePacket{ |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 137 | EntityClass: me.OnuDataClassID, |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 138 | // Default Instance ID is 0 |
| 139 | }, |
| 140 | CommandSequenceNumber: seqNumber, |
| 141 | } |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 142 | pkt, err := Serialize(omci.MibUploadNextRequestType, request, tid) |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 143 | |
| 144 | if err != nil { |
| 145 | omciLogger.WithFields(log.Fields{ |
| 146 | "Err": err, |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 147 | }).Fatalf("Cannot Serialize MibUploadNextRequest") |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 148 | return nil, err |
| 149 | } |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 150 | return HexEncode(pkt) |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 151 | } |
| 152 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 153 | func ParseMibUploadNextRequest(omciPkt gopacket.Packet) (*omci.MibUploadNextRequest, error) { |
| 154 | msgLayer := omciPkt.Layer(omci.LayerTypeMibUploadNextRequest) |
| 155 | if msgLayer == nil { |
| 156 | err := "omci Msg layer could not be detected for LayerTypeMibUploadNextRequest" |
| 157 | omciLogger.Error(err) |
| 158 | return nil, errors.New(err) |
Scott Baker | b90c431 | 2020-03-12 21:33:25 -0700 | [diff] [blame] | 159 | } |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 160 | msgObj, msgOk := msgLayer.(*omci.MibUploadNextRequest) |
| 161 | if !msgOk { |
| 162 | err := "omci Msg layer could not be assigned for MibUploadNextRequest" |
| 163 | omciLogger.Error(err) |
| 164 | return nil, errors.New(err) |
| 165 | } |
| 166 | return msgObj, nil |
Scott Baker | b90c431 | 2020-03-12 21:33:25 -0700 | [diff] [blame] | 167 | } |
| 168 | |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 169 | func CreateMibUploadNextResponse(omciPkt gopacket.Packet, omciMsg *omci.OMCI, mds uint8) ([]byte, error) { |
Scott Baker | b90c431 | 2020-03-12 21:33:25 -0700 | [diff] [blame] | 170 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 171 | msgObj, err := ParseMibUploadNextRequest(omciPkt) |
Scott Baker | b90c431 | 2020-03-12 21:33:25 -0700 | [diff] [blame] | 172 | if err != nil { |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 173 | err := "omci Msg layer could not be assigned for LayerTypeGetRequest" |
| 174 | omciLogger.Error(err) |
| 175 | return nil, errors.New(err) |
Scott Baker | b90c431 | 2020-03-12 21:33:25 -0700 | [diff] [blame] | 176 | } |
| 177 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 178 | omciLogger.WithFields(log.Fields{ |
| 179 | "EntityClass": msgObj.EntityClass, |
| 180 | "EntityInstance": msgObj.EntityInstance, |
| 181 | "CommandSequenceNumber": msgObj.CommandSequenceNumber, |
| 182 | }).Trace("received-omci-mibUploadNext-request") |
Scott Baker | b90c431 | 2020-03-12 21:33:25 -0700 | [diff] [blame] | 183 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 184 | // depending on the sequenceNumber we'll report a different |
| 185 | reportedMe := &me.ManagedEntity{} |
| 186 | var meErr me.OmciErrors |
| 187 | //var entityInstance uint16 |
| 188 | switch msgObj.CommandSequenceNumber { |
| 189 | case 0: |
| 190 | reportedMe, meErr = me.NewOnuData(me.ParamData{Attributes: me.AttributeValueMap{ |
| 191 | "ManagedEntityId": me.OnuDataClassID, |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 192 | "MibDataSync": mds, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 193 | }}) |
| 194 | if meErr.GetError() != nil { |
| 195 | omciLogger.Errorf("NewOnuData %v", meErr.Error()) |
| 196 | } |
Scott Baker | b90c431 | 2020-03-12 21:33:25 -0700 | [diff] [blame] | 197 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 198 | case 1: |
| 199 | reportedMe, meErr = me.NewCircuitPack(me.ParamData{Attributes: me.AttributeValueMap{ |
| 200 | "ManagedEntityId": me.CircuitPackClassID, |
| 201 | "Type": 47, |
| 202 | "NumberOfPorts": 4, |
| 203 | "SerialNumber": toOctets("BBSM-Circuit-Pack", 20), |
| 204 | "Version": toOctets("v0.0.1", 20), |
| 205 | }}) |
| 206 | if meErr.GetError() != nil { |
| 207 | omciLogger.Errorf("NewCircuitPack %v", meErr.Error()) |
| 208 | } |
| 209 | case 2: |
| 210 | reportedMe, meErr = me.NewCircuitPack(me.ParamData{Attributes: me.AttributeValueMap{ |
| 211 | "ManagedEntityId": me.CircuitPackClassID, |
| 212 | "VendorId": "ONF", |
| 213 | "AdministrativeState": 0, |
| 214 | "OperationalState": 0, |
| 215 | "BridgedOrIpInd": 0, |
| 216 | }}) |
| 217 | if meErr.GetError() != nil { |
| 218 | omciLogger.Errorf("NewCircuitPack %v", meErr.Error()) |
| 219 | } |
| 220 | case 3: |
| 221 | reportedMe, meErr = me.NewCircuitPack(me.ParamData{Attributes: me.AttributeValueMap{ |
| 222 | "ManagedEntityId": me.CircuitPackClassID, |
| 223 | "EquipmentId": toOctets("BBSM-Circuit-Pack", 20), |
| 224 | "CardConfiguration": 0, |
| 225 | "TotalTContBufferNumber": 0, |
| 226 | "TotalPriorityQueueNumber": 8, |
| 227 | "TotalTrafficSchedulerNumber": 0, |
| 228 | }}) |
| 229 | if meErr.GetError() != nil { |
| 230 | omciLogger.Errorf("NewCircuitPack %v", meErr.Error()) |
| 231 | } |
| 232 | case 4: |
| 233 | reportedMe, meErr = me.NewCircuitPack(me.ParamData{Attributes: me.AttributeValueMap{ |
| 234 | "ManagedEntityId": me.CircuitPackClassID, |
| 235 | "PowerShedOverride": uint32(0), |
| 236 | }}) |
| 237 | if meErr.GetError() != nil { |
| 238 | omciLogger.Errorf("NewCircuitPack %v", meErr.Error()) |
| 239 | } |
| 240 | case 5: |
| 241 | reportedMe, meErr = me.NewCircuitPack(me.ParamData{Attributes: me.AttributeValueMap{ |
| 242 | "ManagedEntityId": me.CircuitPackClassID, |
| 243 | "Type": 238, |
| 244 | "NumberOfPorts": 1, |
| 245 | "SerialNumber": toOctets("BBSM-Circuit-Pack-2", 20), |
| 246 | "Version": toOctets("v0.0.1", 20), |
| 247 | }}) |
| 248 | if meErr.GetError() != nil { |
| 249 | omciLogger.Errorf("NewCircuitPack %v", meErr.Error()) |
| 250 | } |
| 251 | case 6: |
| 252 | reportedMe, meErr = me.NewCircuitPack(me.ParamData{Attributes: me.AttributeValueMap{ |
| 253 | "ManagedEntityId": me.CircuitPackClassID, |
| 254 | "VendorId": "ONF", |
| 255 | "AdministrativeState": 0, |
| 256 | "OperationalState": 0, |
| 257 | "BridgedOrIpInd": 0, |
| 258 | }}) |
| 259 | if meErr.GetError() != nil { |
| 260 | omciLogger.Errorf("NewCircuitPack %v", meErr.Error()) |
| 261 | } |
| 262 | case 7: |
| 263 | reportedMe, meErr = me.NewCircuitPack(me.ParamData{Attributes: me.AttributeValueMap{ |
| 264 | "ManagedEntityId": me.CircuitPackClassID, |
| 265 | "EquipmentId": toOctets("BBSM-Circuit-Pack", 20), |
| 266 | "CardConfiguration": 0, |
| 267 | "TotalTContBufferNumber": 8, |
| 268 | "TotalPriorityQueueNumber": 40, |
| 269 | "TotalTrafficSchedulerNumber": 10, |
| 270 | }}) |
| 271 | if meErr.GetError() != nil { |
| 272 | omciLogger.Errorf("NewCircuitPack %v", meErr.Error()) |
| 273 | } |
| 274 | case 8: |
| 275 | reportedMe, meErr = me.NewCircuitPack(me.ParamData{Attributes: me.AttributeValueMap{ |
| 276 | "ManagedEntityId": me.CircuitPackClassID, |
| 277 | "PowerShedOverride": uint32(0), |
| 278 | }}) |
| 279 | if meErr.GetError() != nil { |
| 280 | omciLogger.Errorf("NewCircuitPack %v", meErr.Error()) |
| 281 | } |
| 282 | case 9, 10, 11, 12: |
| 283 | // NOTE we're reporting for different UNIs, the IDs are 257, 258, 259, 260 |
| 284 | meInstance := 248 + msgObj.CommandSequenceNumber |
| 285 | reportedMe, meErr = me.NewPhysicalPathTerminationPointEthernetUni(me.ParamData{ |
| 286 | EntityID: meInstance, |
| 287 | Attributes: me.AttributeValueMap{ |
| 288 | "ExpectedType": 0, |
| 289 | "SensedType": 47, |
| 290 | "AutoDetectionConfiguration": 0, |
| 291 | "EthernetLoopbackConfiguration": 0, |
| 292 | "AdministrativeState": 0, |
| 293 | "OperationalState": 0, |
| 294 | "ConfigurationInd": 3, |
| 295 | "MaxFrameSize": 1518, |
| 296 | "DteOrDceInd": 0, |
| 297 | "PauseTime": 0, |
| 298 | "BridgedOrIpInd": 2, |
| 299 | "Arc": 0, |
| 300 | "ArcInterval": 0, |
| 301 | "PppoeFilter": 0, |
| 302 | "PowerControl": 0, |
| 303 | }}) |
| 304 | if meErr.GetError() != nil { |
| 305 | omciLogger.Errorf("NewPhysicalPathTerminationPointEthernetUni %v", meErr.Error()) |
| 306 | } |
| 307 | case 13, 14, 15, 16, 17, 18, 19, 20: |
| 308 | // TODO report different MeID (see omci-sim pcap filter "frame[22:2] == 01:06") |
| 309 | reportedMe, meErr = me.NewTCont(me.ParamData{Attributes: me.AttributeValueMap{ |
| 310 | "ManagedEntityId": me.TContClassID, |
| 311 | "AllocId": 0, |
| 312 | }}) |
| 313 | if meErr.GetError() != nil { |
| 314 | omciLogger.Errorf("NewTCont %v", meErr.Error()) |
| 315 | } |
| 316 | case 21: |
| 317 | reportedMe, meErr = me.NewAniG(me.ParamData{Attributes: me.AttributeValueMap{ |
| 318 | "ManagedEntityId": me.AniGClassID, |
| 319 | "SrIndication": 1, |
| 320 | "TotalTcontNumber": 8, |
| 321 | "GemBlockLength": 30, |
| 322 | "PiggybackDbaReporting": 0, |
| 323 | "Deprecated": 0, |
| 324 | "SignalFailThreshold": 5, |
| 325 | "SignalDegradeThreshold": 9, |
| 326 | "Arc": 0, |
| 327 | "ArcInterval": 0, |
| 328 | "OpticalSignalLevel": 57428, |
| 329 | "LowerOpticalThreshold": 255, |
| 330 | "UpperOpticalThreshold": 255, |
| 331 | "OnuResponseTime": 0, |
| 332 | "TransmitOpticalLevel": 3171, |
| 333 | "LowerTransmitPowerThreshold": 129, |
| 334 | "UpperTransmitPowerThreshold": 129, |
| 335 | }}) |
| 336 | if meErr.GetError() != nil { |
| 337 | omciLogger.Errorf("NewAniG %v", meErr.Error()) |
| 338 | } |
| 339 | case 22, 23, 24, 25: |
| 340 | // TODO report different MeID (see omci-sim pcap filter "frame[22:2] == 01:08") |
| 341 | reportedMe, meErr = me.NewUniG(me.ParamData{Attributes: me.AttributeValueMap{ |
| 342 | "ManagedEntityId": me.UniGClassID, |
| 343 | "Deprecated": 0, |
| 344 | "AdministrativeState": 0, |
| 345 | }}) |
| 346 | if meErr.GetError() != nil { |
| 347 | omciLogger.Errorf("NewUniG %v", meErr.Error()) |
| 348 | } |
| 349 | case 26, 30, 34, 38, 42, 46, 50, 54, |
| 350 | 58, 62, 66, 70, 74, 78, 82, 86, |
| 351 | 90, 94, 98, 102, 106, 110, 114, 118, |
| 352 | 122, 126, 130, 134, 138, 142, 146, 150, |
| 353 | 154, 158, 162, 166, 170, 174, 178, 182, |
| 354 | 186, 190, 194, 198, 202, 206, 210, 214, |
| 355 | 218, 222, 226, 230, 234, 238, 242, 246, |
| 356 | 250, 254, 258, 262, 266, 270, 274, 278: |
| 357 | case 27, 31, 35, 39, 43, 47, 51, 55, |
| 358 | 59, 63, 67, 71, 75, 79, 83, 87, |
| 359 | 91, 95, 99, 103, 107, 111, 115, 119, |
| 360 | 123, 127, 131, 135, 139, 143, 147, 151, |
| 361 | 155, 159, 163, 167, 171, 175, 179, 183, |
| 362 | 187, 191, 195, 199, 203, 207, 211, 215, |
| 363 | 219, 223, 227, 231, 235, 239, 243, 247, |
| 364 | 251, 255, 259, 263, 267, 271, 275, 279: |
| 365 | case 28, 32, 36, 40, 44, 48, 52, 56, |
| 366 | 60, 64, 68, 72, 76, 80, 84, 88, |
| 367 | 92, 96, 100, 104, 108, 112, 116, 120, |
| 368 | 124, 128, 132, 136, 140, 144, 148, 152, |
| 369 | 156, 160, 164, 168, 172, 176, 180, 184, |
| 370 | 188, 192, 196, 200, 204, 208, 212, 216, |
| 371 | 220, 224, 228, 232, 236, 240, 244, 248, |
| 372 | 252, 256, 260, 264, 268, 272, 276, 280: |
| 373 | case 29, 33, 37, 41, 45, 49, 53, 57, |
| 374 | 61, 65, 69, 73, 77, 81, 85, 89, |
| 375 | 93, 97, 101, 105, 109, 113, 117, 121, |
| 376 | 125, 129, 133, 137, 141, 145, 149, 153, |
| 377 | 157, 161, 165, 169, 173, 177, 181, 185, |
| 378 | 189, 193, 197, 201, 205, 209, 213, 217, |
| 379 | 221, 225, 229, 233, 237, 241, 245, 249, |
| 380 | 253, 257, 261, 265, 269, 273, 277, 281: |
| 381 | reportedMe, meErr = me.NewPriorityQueue(me.ParamData{Attributes: me.AttributeValueMap{ |
| 382 | "ManagedEntityId": me.PriorityQueueClassID, |
| 383 | "QueueConfigurationOption": 0, |
| 384 | "MaximumQueueSize": 100, |
| 385 | "AllocatedQueueSize": 100, |
| 386 | "DiscardBlockCounterResetInterval": 0, |
| 387 | "ThresholdValueForDiscardedBlocksDueToBufferOverflow": 0, |
| 388 | "RelatedPort": 80010000, // does this need to change? |
| 389 | "TrafficSchedulerPointer": 8008, // does this need to change? |
| 390 | "Weight": 1, |
| 391 | "BackPressureOperation": 1, |
| 392 | "BackPressureTime": 0, |
| 393 | "BackPressureOccurQueueThreshold": 0, |
| 394 | "BackPressureClearQueueThreshold": 0, |
| 395 | }}) |
| 396 | if meErr.GetError() != nil { |
| 397 | omciLogger.Errorf("NewPriorityQueue %v", meErr.Error()) |
| 398 | } |
| 399 | case 282, 283, 284, 285, 286, 287, 288, 289: |
| 400 | reportedMe, meErr = me.NewTrafficScheduler(me.ParamData{Attributes: me.AttributeValueMap{ |
| 401 | "ManagedEntityId": me.TrafficSchedulerClassID, |
| 402 | "TContPointer": 8008, // NOTE does this need to change? |
| 403 | "TrafficSchedulerPointer": 0, |
| 404 | "Policy": 02, |
| 405 | "PriorityWeight": 0, |
| 406 | }}) |
| 407 | if meErr.GetError() != nil { |
| 408 | omciLogger.Errorf("NewTrafficScheduler %v", meErr.Error()) |
| 409 | } |
| 410 | case 290: |
| 411 | reportedMe, meErr = me.NewOnu2G(me.ParamData{Attributes: me.AttributeValueMap{ |
| 412 | "ManagedEntityId": me.Onu2GClassID, |
| 413 | "TotalPriorityQueueNumber": 40, |
| 414 | "SecurityMode": 1, |
| 415 | "TotalTrafficSchedulerNumber": 8, |
| 416 | "TotalGemPortIdNumber": 0, |
| 417 | "Sysuptime": 0, |
| 418 | }}) |
| 419 | if meErr.GetError() != nil { |
| 420 | omciLogger.Errorf("NewOnu2G %v", meErr.Error()) |
| 421 | } |
| 422 | default: |
| 423 | omciLogger.Warn("unsupported-CommandSequenceNumber-in-mib-upload-next", msgObj.CommandSequenceNumber) |
| 424 | return nil, nil |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 425 | } |
| 426 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 427 | response := &omci.MibUploadNextResponse{ |
| 428 | MeBasePacket: omci.MeBasePacket{ |
| 429 | EntityClass: me.OnuDataClassID, |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 430 | }, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 431 | ReportedME: *reportedMe, |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 432 | } |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 433 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 434 | omciLogger.WithFields(log.Fields{ |
| 435 | "reportedMe": reportedMe, |
| 436 | }).Trace("created-omci-mibUploadNext-response") |
| 437 | |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 438 | pkt, err := Serialize(omci.MibUploadNextResponseType, response, omciMsg.TransactionID) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 439 | |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 440 | if err != nil { |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 441 | omciLogger.WithFields(log.Fields{ |
| 442 | "Err": err, |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame^] | 443 | }).Fatalf("Cannot Serialize MibUploadNextRequest") |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 444 | return nil, err |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 445 | } |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 446 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 447 | return pkt, nil |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 448 | } |