Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [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 ( |
| 20 | "encoding/hex" |
| 21 | "errors" |
| 22 | "fmt" |
Elia Battiston | ac63b11 | 2022-01-12 18:40:49 +0100 | [diff] [blame] | 23 | "math/rand" |
| 24 | "strconv" |
| 25 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 26 | "github.com/google/gopacket" |
Andrea Campanella | 10426e2 | 2021-10-15 17:58:04 +0200 | [diff] [blame] | 27 | "github.com/opencord/omci-lib-go/v2" |
| 28 | me "github.com/opencord/omci-lib-go/v2/generated" |
David K. Bainbridge | c415efe | 2021-08-19 13:05:21 +0000 | [diff] [blame] | 29 | "github.com/opencord/voltha-protos/v5/go/openolt" |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 30 | log "github.com/sirupsen/logrus" |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 31 | ) |
| 32 | |
| 33 | func ParseGetRequest(omciPkt gopacket.Packet) (*omci.GetRequest, error) { |
| 34 | msgLayer := omciPkt.Layer(omci.LayerTypeGetRequest) |
| 35 | if msgLayer == nil { |
| 36 | err := "omci Msg layer could not be detected for LayerTypeGetRequest" |
| 37 | omciLogger.Error(err) |
| 38 | return nil, errors.New(err) |
| 39 | } |
| 40 | msgObj, msgOk := msgLayer.(*omci.GetRequest) |
| 41 | if !msgOk { |
| 42 | err := "omci Msg layer could not be assigned for LayerTypeGetRequest" |
| 43 | omciLogger.Error(err) |
| 44 | return nil, errors.New(err) |
| 45 | } |
| 46 | return msgObj, nil |
| 47 | } |
| 48 | |
Matteo Scandolo | c00e97a | 2021-05-27 11:45:27 -0700 | [diff] [blame] | 49 | func CreateGetResponse(omciPkt gopacket.Packet, omciMsg *omci.OMCI, onuSn *openolt.SerialNumber, mds uint8, |
| 50 | activeImageEntityId uint16, committedImageEntityId uint16, standbyImageVersion string, activeImageVersion string, |
| 51 | committedImageVersion string, onuDown bool) ([]byte, error) { |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 52 | msgObj, err := ParseGetRequest(omciPkt) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 53 | if err != nil { |
| 54 | return nil, err |
| 55 | } |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 56 | omciLogger.WithFields(log.Fields{ |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 57 | "DeviceIdent": omciMsg.DeviceIdentifier, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 58 | "EntityClass": msgObj.EntityClass, |
| 59 | "EntityInstance": msgObj.EntityInstance, |
| 60 | "AttributeMask": fmt.Sprintf("%x", msgObj.AttributeMask), |
Matteo Scandolo | 992a23e | 2021-02-04 15:35:04 -0800 | [diff] [blame] | 61 | }).Trace("received-omci-get-request") |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 62 | |
| 63 | var response *omci.GetResponse |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 64 | |
| 65 | isExtended := false |
| 66 | if omciMsg.DeviceIdentifier == omci.ExtendedIdent { |
| 67 | isExtended = true |
| 68 | } |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 69 | switch msgObj.EntityClass { |
| 70 | case me.Onu2GClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 71 | response = createOnu2gResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 72 | case me.OnuGClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 73 | response = createOnugResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance, onuSn) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 74 | case me.SoftwareImageClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 75 | response = createSoftwareImageResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance, |
Matteo Scandolo | c00e97a | 2021-05-27 11:45:27 -0700 | [diff] [blame] | 76 | activeImageEntityId, committedImageEntityId, standbyImageVersion, activeImageVersion, committedImageVersion) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 77 | case me.IpHostConfigDataClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 78 | response = createIpHostResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance) |
Elia Battiston | ac63b11 | 2022-01-12 18:40:49 +0100 | [diff] [blame] | 79 | case me.VoipConfigDataClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 80 | response = createVoipConfigDataResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 81 | case me.UniGClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 82 | response = createUnigResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance, onuDown) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 83 | case me.PhysicalPathTerminationPointEthernetUniClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 84 | response = createPptpEthernetResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance, onuDown) |
Elia Battiston | ac63b11 | 2022-01-12 18:40:49 +0100 | [diff] [blame] | 85 | case me.PhysicalPathTerminationPointPotsUniClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 86 | response = createPptpPotsResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance, onuDown) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 87 | case me.AniGClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 88 | response = createAnigResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 89 | case me.OnuDataClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 90 | response = createOnuDataResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance, mds) |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 91 | case me.EthernetFramePerformanceMonitoringHistoryDataUpstreamClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 92 | response = createEthernetFramePerformanceMonitoringHistoryDataUpstreamResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance) |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 93 | case me.EthernetFramePerformanceMonitoringHistoryDataDownstreamClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 94 | response = createEthernetFramePerformanceMonitoringHistoryDataDownstreamResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance) |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 95 | case me.EthernetPerformanceMonitoringHistoryDataClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 96 | response = createEthernetPerformanceMonitoringHistoryDataResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance) |
Girish Gowdra | 6d9a1a4 | 2021-03-05 16:07:15 -0800 | [diff] [blame] | 97 | case me.FecPerformanceMonitoringHistoryDataClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 98 | response = createFecPerformanceMonitoringHistoryDataResponse(isExtended, msgObj.AttributeMask, msgObj.EntityInstance) |
Girish Gowdra | 6d9a1a4 | 2021-03-05 16:07:15 -0800 | [diff] [blame] | 99 | case me.GemPortNetworkCtpPerformanceMonitoringHistoryDataClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 100 | response = createGemPortNetworkCtpPerformanceMonitoringHistoryData(isExtended, msgObj.AttributeMask, msgObj.EntityInstance) |
Himani Chawla | 6bd190a | 2021-07-09 15:31:01 +0530 | [diff] [blame] | 101 | case me.EthernetFrameExtendedPmClassID, |
| 102 | me.EthernetFrameExtendedPm64BitClassID: |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 103 | response = createEthernetFrameExtendedPmGetResponse(isExtended, msgObj.EntityClass, msgObj.AttributeMask, msgObj.EntityInstance) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 104 | default: |
| 105 | omciLogger.WithFields(log.Fields{ |
| 106 | "EntityClass": msgObj.EntityClass, |
| 107 | "EntityInstance": msgObj.EntityInstance, |
| 108 | "AttributeMask": fmt.Sprintf("%x", msgObj.AttributeMask), |
| 109 | }).Warnf("do-not-know-how-to-handle-get-request-for-me-class") |
| 110 | return nil, nil |
| 111 | } |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 112 | omciLayer := &omci.OMCI{ |
| 113 | TransactionID: omciMsg.TransactionID, |
| 114 | MessageType: omci.GetResponseType, |
| 115 | DeviceIdentifier: omciMsg.DeviceIdentifier, |
| 116 | } |
| 117 | var options gopacket.SerializeOptions |
| 118 | options.FixLengths = true |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 119 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 120 | buffer := gopacket.NewSerializeBuffer() |
| 121 | err = gopacket.SerializeLayers(buffer, options, omciLayer, response) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 122 | if err != nil { |
| 123 | omciLogger.WithFields(log.Fields{ |
| 124 | "Err": err, |
| 125 | "TxID": strconv.FormatInt(int64(omciMsg.TransactionID), 16), |
Matteo Scandolo | 78d5ee1 | 2021-04-14 11:11:32 -0700 | [diff] [blame] | 126 | }).Error("cannot-Serialize-GetResponse") |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 127 | return nil, err |
| 128 | } |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 129 | pkt := buffer.Bytes() |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 130 | |
| 131 | log.WithFields(log.Fields{ |
| 132 | "TxID": strconv.FormatInt(int64(omciMsg.TransactionID), 16), |
| 133 | "pkt": hex.EncodeToString(pkt), |
| 134 | }).Trace("omci-get-response") |
| 135 | |
| 136 | return pkt, nil |
| 137 | } |
| 138 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 139 | func createOnu2gResponse(isExtended bool, attributeMask uint16, entityID uint16) *omci.GetResponse { |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 140 | |
| 141 | managedEntity, meErr := me.NewOnu2G(me.ParamData{ |
| 142 | EntityID: entityID, |
| 143 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 144 | me.ManagedEntityID: entityID, |
| 145 | me.Onu2G_EquipmentId: ToOctets("12345123451234512345", 20), |
| 146 | me.Onu2G_OpticalNetworkUnitManagementAndControlChannelOmccVersion: 180, |
| 147 | me.Onu2G_VendorProductCode: 0, |
| 148 | me.Onu2G_SecurityCapability: 1, |
| 149 | me.Onu2G_SecurityMode: 1, |
| 150 | me.Onu2G_TotalPriorityQueueNumber: 1, |
| 151 | me.Onu2G_TotalTrafficSchedulerNumber: 1, |
| 152 | me.Onu2G_Deprecated: 1, |
| 153 | me.Onu2G_TotalGemPortIdNumber: 32, |
| 154 | me.Onu2G_Sysuptime: 319389947, // NOTE need to be smarter? |
| 155 | me.Onu2G_ConnectivityCapability: 127, |
| 156 | me.Onu2G_CurrentConnectivityMode: 5, |
| 157 | me.Onu2G_QualityOfServiceQosConfigurationFlexibility: 48, |
| 158 | me.Onu2G_PriorityQueueScaleFactor: 1, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 159 | }, |
| 160 | }) |
| 161 | |
| 162 | if meErr.GetError() != nil { |
| 163 | omciLogger.Errorf("NewOnu2G %v", meErr.Error()) |
| 164 | return nil |
| 165 | } |
| 166 | |
| 167 | return &omci.GetResponse{ |
| 168 | MeBasePacket: omci.MeBasePacket{ |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 169 | EntityClass: me.Onu2GClassID, |
| 170 | EntityInstance: entityID, |
| 171 | Extended: isExtended, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 172 | }, |
| 173 | Attributes: managedEntity.GetAttributeValueMap(), |
| 174 | AttributeMask: attributeMask, |
| 175 | Result: me.Success, |
| 176 | } |
| 177 | } |
| 178 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 179 | func createOnugResponse(isExtended bool, attributeMask uint16, entityID uint16, onuSn *openolt.SerialNumber) *omci.GetResponse { |
Matteo Scandolo | 5863f00 | 2021-02-08 08:08:14 -0800 | [diff] [blame] | 180 | |
| 181 | managedEntity, meErr := me.NewOnuG(me.ParamData{ |
| 182 | EntityID: entityID, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 183 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 184 | me.ManagedEntityID: entityID, |
| 185 | me.OnuG_VendorId: ToOctets("BBSM", 4), |
| 186 | me.OnuG_Version: ToOctets("v0.0.1", 14), |
| 187 | me.OnuG_SerialNumber: append(onuSn.VendorId, onuSn.VendorSpecific...), |
| 188 | me.OnuG_TrafficManagementOption: 0, |
| 189 | me.OnuG_Deprecated: 0, |
| 190 | me.OnuG_BatteryBackup: 0, |
| 191 | me.OnuG_AdministrativeState: 0, |
| 192 | me.OnuG_OperationalState: 0, |
| 193 | me.OnuG_OnuSurvivalTime: 10, |
| 194 | me.OnuG_LogicalOnuId: ToOctets("BBSM", 24), |
| 195 | me.OnuG_LogicalPassword: ToOctets("BBSM", 12), |
| 196 | me.OnuG_CredentialsStatus: 0, |
| 197 | me.OnuG_ExtendedTcLayerOptions: 0, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 198 | }, |
Matteo Scandolo | 5863f00 | 2021-02-08 08:08:14 -0800 | [diff] [blame] | 199 | }) |
| 200 | |
| 201 | if meErr.GetError() != nil { |
| 202 | omciLogger.Errorf("NewOnu2G %v", meErr.Error()) |
| 203 | return nil |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 204 | } |
Matteo Scandolo | 5863f00 | 2021-02-08 08:08:14 -0800 | [diff] [blame] | 205 | |
| 206 | return &omci.GetResponse{ |
| 207 | MeBasePacket: omci.MeBasePacket{ |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 208 | EntityClass: me.OnuGClassID, |
| 209 | EntityInstance: entityID, |
| 210 | Extended: isExtended, |
Matteo Scandolo | 5863f00 | 2021-02-08 08:08:14 -0800 | [diff] [blame] | 211 | }, |
| 212 | Attributes: managedEntity.GetAttributeValueMap(), |
| 213 | AttributeMask: attributeMask, |
| 214 | Result: me.Success, |
| 215 | } |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 216 | } |
| 217 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 218 | func createSoftwareImageResponse(isExtended bool, attributeMask uint16, entityInstance uint16, activeImageEntityId uint16, |
Matteo Scandolo | c00e97a | 2021-05-27 11:45:27 -0700 | [diff] [blame] | 219 | committedImageEntityId uint16, standbyImageVersion string, activeImageVersion string, committedImageVersion string) *omci.GetResponse { |
Matteo Scandolo | cedde46 | 2021-03-09 17:37:16 -0800 | [diff] [blame] | 220 | |
| 221 | omciLogger.WithFields(log.Fields{ |
| 222 | "EntityInstance": entityInstance, |
Matteo Scandolo | c00e97a | 2021-05-27 11:45:27 -0700 | [diff] [blame] | 223 | "AttributeMask": attributeMask, |
Matteo Scandolo | 21195d6 | 2021-04-07 14:31:23 -0700 | [diff] [blame] | 224 | }).Trace("received-get-software-image-request") |
Matteo Scandolo | cedde46 | 2021-03-09 17:37:16 -0800 | [diff] [blame] | 225 | |
| 226 | // Only one image can be active and committed |
| 227 | committed := 0 |
| 228 | active := 0 |
Matteo Scandolo | c00e97a | 2021-05-27 11:45:27 -0700 | [diff] [blame] | 229 | version := standbyImageVersion |
Matteo Scandolo | cedde46 | 2021-03-09 17:37:16 -0800 | [diff] [blame] | 230 | if entityInstance == activeImageEntityId { |
| 231 | active = 1 |
Matteo Scandolo | c00e97a | 2021-05-27 11:45:27 -0700 | [diff] [blame] | 232 | version = activeImageVersion |
Matteo Scandolo | cedde46 | 2021-03-09 17:37:16 -0800 | [diff] [blame] | 233 | } |
| 234 | if entityInstance == committedImageEntityId { |
| 235 | committed = 1 |
Matteo Scandolo | c00e97a | 2021-05-27 11:45:27 -0700 | [diff] [blame] | 236 | version = committedImageVersion |
| 237 | } |
| 238 | |
| 239 | imageHash, err := hex.DecodeString(hex.EncodeToString([]byte(version))) |
| 240 | if err != nil { |
| 241 | omciLogger.WithFields(log.Fields{ |
| 242 | "entityId": entityInstance, |
| 243 | "active": active, |
| 244 | "committed": committed, |
| 245 | "err": err, |
| 246 | }).Error("cannot-generate-image-hash") |
Matteo Scandolo | cedde46 | 2021-03-09 17:37:16 -0800 | [diff] [blame] | 247 | } |
| 248 | |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 249 | // NOTE that we need send the response for the correct ME Instance or the adapter won't process it |
Matteo Scandolo | cedde46 | 2021-03-09 17:37:16 -0800 | [diff] [blame] | 250 | res := &omci.GetResponse{ |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 251 | MeBasePacket: omci.MeBasePacket{ |
| 252 | EntityClass: me.SoftwareImageClassID, |
| 253 | EntityInstance: entityInstance, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 254 | Extended: isExtended, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 255 | }, |
| 256 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 257 | me.ManagedEntityID: 0, |
| 258 | me.SoftwareImage_Version: ToOctets(version, 14), |
| 259 | me.SoftwareImage_IsCommitted: committed, |
| 260 | me.SoftwareImage_IsActive: active, |
| 261 | me.SoftwareImage_IsValid: 1, |
| 262 | me.SoftwareImage_ProductCode: ToOctets("BBSIM-ONU", 25), |
| 263 | me.SoftwareImage_ImageHash: imageHash, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 264 | }, |
| 265 | Result: me.Success, |
| 266 | AttributeMask: attributeMask, |
| 267 | } |
Matteo Scandolo | cedde46 | 2021-03-09 17:37:16 -0800 | [diff] [blame] | 268 | |
| 269 | omciLogger.WithFields(log.Fields{ |
| 270 | "omciMessage": res, |
| 271 | "entityId": entityInstance, |
| 272 | "active": active, |
| 273 | "committed": committed, |
Matteo Scandolo | 21195d6 | 2021-04-07 14:31:23 -0700 | [diff] [blame] | 274 | }).Trace("Reporting SoftwareImage") |
Matteo Scandolo | cedde46 | 2021-03-09 17:37:16 -0800 | [diff] [blame] | 275 | |
| 276 | return res |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 277 | } |
| 278 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 279 | func createIpHostResponse(isExtended bool, attributeMask uint16, entityInstance uint16) *omci.GetResponse { |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 280 | return &omci.GetResponse{ |
| 281 | MeBasePacket: omci.MeBasePacket{ |
| 282 | EntityClass: me.IpHostConfigDataClassID, |
| 283 | EntityInstance: entityInstance, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 284 | Extended: isExtended, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 285 | }, |
| 286 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 287 | me.ManagedEntityID: 0, |
| 288 | me.IpHostConfigData_MacAddress: ToOctets("aabbcc", 6), |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 289 | }, |
| 290 | Result: me.Success, |
| 291 | AttributeMask: attributeMask, |
| 292 | } |
| 293 | } |
| 294 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 295 | func createVoipConfigDataResponse(isExtended bool, attributeMask uint16, entityInstance uint16) *omci.GetResponse { |
Elia Battiston | ac63b11 | 2022-01-12 18:40:49 +0100 | [diff] [blame] | 296 | return &omci.GetResponse{ |
| 297 | MeBasePacket: omci.MeBasePacket{ |
| 298 | EntityClass: me.VoipConfigDataClassID, |
| 299 | EntityInstance: entityInstance, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 300 | Extended: isExtended, |
Elia Battiston | ac63b11 | 2022-01-12 18:40:49 +0100 | [diff] [blame] | 301 | }, |
| 302 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 303 | me.ManagedEntityID: 0, |
| 304 | me.VoipConfigData_AvailableSignallingProtocols: 1, |
| 305 | me.VoipConfigData_SignallingProtocolUsed: 1, |
| 306 | me.VoipConfigData_AvailableVoipConfigurationMethods: 1, |
| 307 | me.VoipConfigData_VoipConfigurationMethodUsed: 1, |
| 308 | me.VoipConfigData_VoipConfigurationAddressPointer: 0xFFFF, |
| 309 | me.VoipConfigData_VoipConfigurationState: 0, |
| 310 | me.VoipConfigData_RetrieveProfile: 0, |
| 311 | me.VoipConfigData_ProfileVersion: 0, |
Elia Battiston | ac63b11 | 2022-01-12 18:40:49 +0100 | [diff] [blame] | 312 | }, |
| 313 | Result: me.Success, |
| 314 | AttributeMask: attributeMask, |
| 315 | } |
| 316 | } |
| 317 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 318 | func createUnigResponse(isExtended bool, attributeMask uint16, entityID uint16, onuDown bool) *omci.GetResponse { |
Girish Gowdra | 996d81e | 2021-04-21 16:16:27 -0700 | [diff] [blame] | 319 | // Valid values for uni_admin_state are 0 (unlocks) and 1 (locks) |
| 320 | omciAdminState := 1 |
| 321 | if !onuDown { |
| 322 | omciAdminState = 0 |
| 323 | } |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 324 | managedEntity, meErr := me.NewUniG(me.ParamData{ |
| 325 | EntityID: entityID, |
| 326 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 327 | me.ManagedEntityID: entityID, |
| 328 | me.UniG_Deprecated: 0, |
| 329 | me.UniG_AdministrativeState: omciAdminState, |
| 330 | me.UniG_ManagementCapability: 0, |
| 331 | me.UniG_NonOmciManagementIdentifier: 1, |
| 332 | me.UniG_RelayAgentOptions: 1, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 333 | }, |
| 334 | }) |
| 335 | |
| 336 | if meErr.GetError() != nil { |
| 337 | omciLogger.Errorf("NewUniG %v", meErr.Error()) |
| 338 | return nil |
| 339 | } |
| 340 | |
| 341 | return &omci.GetResponse{ |
| 342 | MeBasePacket: omci.MeBasePacket{ |
Girish Gowdra | c3fd50c | 2021-03-12 16:14:44 -0800 | [diff] [blame] | 343 | EntityClass: me.UniGClassID, |
| 344 | EntityInstance: entityID, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 345 | Extended: isExtended, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 346 | }, |
| 347 | Attributes: managedEntity.GetAttributeValueMap(), |
| 348 | AttributeMask: attributeMask, |
| 349 | Result: me.Success, |
| 350 | } |
| 351 | } |
| 352 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 353 | func createPptpEthernetResponse(isExtended bool, attributeMask uint16, entityID uint16, onuDown bool) *omci.GetResponse { |
Girish Gowdra | 996d81e | 2021-04-21 16:16:27 -0700 | [diff] [blame] | 354 | // Valid values for oper_state are 0 (enabled) and 1 (disabled) |
| 355 | // Valid values for uni_admin_state are 0 (unlocks) and 1 (locks) |
| 356 | onuAdminState := 1 |
| 357 | if !onuDown { |
| 358 | onuAdminState = 0 |
| 359 | } |
| 360 | onuOperState := onuAdminState // For now make the assumption that oper state reflects the admin state |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 361 | managedEntity, meErr := me.NewPhysicalPathTerminationPointEthernetUni(me.ParamData{ |
| 362 | EntityID: entityID, |
| 363 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 364 | me.ManagedEntityID: entityID, |
| 365 | me.PhysicalPathTerminationPointEthernetUni_ExpectedType: 0, |
| 366 | me.PhysicalPathTerminationPointEthernetUni_SensedType: 0, |
| 367 | me.PhysicalPathTerminationPointEthernetUni_AutoDetectionConfiguration: 0, |
| 368 | me.PhysicalPathTerminationPointEthernetUni_EthernetLoopbackConfiguration: 0, |
| 369 | me.PhysicalPathTerminationPointEthernetUni_AdministrativeState: onuAdminState, |
| 370 | me.PhysicalPathTerminationPointEthernetUni_OperationalState: onuOperState, |
| 371 | me.PhysicalPathTerminationPointEthernetUni_ConfigurationInd: 0, |
| 372 | me.PhysicalPathTerminationPointEthernetUni_MaxFrameSize: 0, |
| 373 | me.PhysicalPathTerminationPointEthernetUni_DteOrDceInd: 0, |
| 374 | me.PhysicalPathTerminationPointEthernetUni_PauseTime: 0, |
| 375 | me.PhysicalPathTerminationPointEthernetUni_BridgedOrIpInd: 0, |
| 376 | me.PhysicalPathTerminationPointEthernetUni_Arc: 0, |
| 377 | me.PhysicalPathTerminationPointEthernetUni_ArcInterval: 0, |
| 378 | me.PhysicalPathTerminationPointEthernetUni_PppoeFilter: 0, |
| 379 | me.PhysicalPathTerminationPointEthernetUni_PowerControl: 0, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 380 | }, |
| 381 | }) |
| 382 | |
| 383 | if meErr.GetError() != nil { |
| 384 | omciLogger.Errorf("NewPhysicalPathTerminationPointEthernetUni %v", meErr.Error()) |
| 385 | return nil |
| 386 | } |
| 387 | |
| 388 | return &omci.GetResponse{ |
| 389 | MeBasePacket: omci.MeBasePacket{ |
Girish Gowdra | c3fd50c | 2021-03-12 16:14:44 -0800 | [diff] [blame] | 390 | EntityClass: me.PhysicalPathTerminationPointEthernetUniClassID, |
| 391 | EntityInstance: entityID, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 392 | Extended: isExtended, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 393 | }, |
| 394 | Attributes: managedEntity.GetAttributeValueMap(), |
| 395 | AttributeMask: attributeMask, |
| 396 | Result: me.Success, |
| 397 | } |
| 398 | } |
| 399 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 400 | func createPptpPotsResponse(isExtended bool, attributeMask uint16, entityID uint16, onuDown bool) *omci.GetResponse { |
Elia Battiston | ac63b11 | 2022-01-12 18:40:49 +0100 | [diff] [blame] | 401 | // Valid values for oper_state are 0 (enabled) and 1 (disabled) |
| 402 | // Valid values for uni_admin_state are 0 (unlocks) and 1 (locks) |
| 403 | onuAdminState := 1 |
| 404 | if !onuDown { |
| 405 | onuAdminState = 0 |
| 406 | } |
| 407 | onuOperState := onuAdminState // For now make the assumption that oper state reflects the admin state |
| 408 | managedEntity, meErr := me.NewPhysicalPathTerminationPointPotsUni(me.ParamData{ |
| 409 | EntityID: entityID, |
| 410 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 411 | me.ManagedEntityID: entityID, |
| 412 | me.PhysicalPathTerminationPointPotsUni_AdministrativeState: onuAdminState, |
| 413 | me.PhysicalPathTerminationPointPotsUni_Deprecated: 0, |
| 414 | me.PhysicalPathTerminationPointPotsUni_Arc: 0, |
| 415 | me.PhysicalPathTerminationPointPotsUni_ArcInterval: 0, |
| 416 | me.PhysicalPathTerminationPointPotsUni_Impedance: 0, |
| 417 | me.PhysicalPathTerminationPointPotsUni_TransmissionPath: 0, |
| 418 | me.PhysicalPathTerminationPointPotsUni_RxGain: 0, |
| 419 | me.PhysicalPathTerminationPointPotsUni_TxGain: 0, |
| 420 | me.PhysicalPathTerminationPointPotsUni_OperationalState: onuOperState, |
| 421 | me.PhysicalPathTerminationPointPotsUni_HookState: 0, |
| 422 | me.PhysicalPathTerminationPointPotsUni_PotsHoldoverTime: 0, |
| 423 | me.PhysicalPathTerminationPointPotsUni_NominalFeedVoltage: 0, |
| 424 | me.PhysicalPathTerminationPointPotsUni_LossOfSoftswitch: 0, |
Elia Battiston | ac63b11 | 2022-01-12 18:40:49 +0100 | [diff] [blame] | 425 | }, |
| 426 | }) |
| 427 | |
| 428 | if meErr.GetError() != nil { |
| 429 | omciLogger.Errorf("NewPhysicalPathTerminationPointPotsUni %v", meErr.Error()) |
| 430 | return nil |
| 431 | } |
| 432 | |
| 433 | return &omci.GetResponse{ |
| 434 | MeBasePacket: omci.MeBasePacket{ |
| 435 | EntityClass: me.PhysicalPathTerminationPointPotsUniClassID, |
| 436 | EntityInstance: entityID, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 437 | Extended: isExtended, |
Elia Battiston | ac63b11 | 2022-01-12 18:40:49 +0100 | [diff] [blame] | 438 | }, |
| 439 | Attributes: managedEntity.GetAttributeValueMap(), |
| 440 | AttributeMask: attributeMask, |
| 441 | Result: me.Success, |
| 442 | } |
| 443 | } |
| 444 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 445 | func createEthernetFramePerformanceMonitoringHistoryDataUpstreamResponse(isExtended bool, attributeMask uint16, entityID uint16) *omci.GetResponse { |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 446 | managedEntity, meErr := me.NewEthernetFramePerformanceMonitoringHistoryDataUpstream(me.ParamData{ |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 447 | EntityID: entityID, |
| 448 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 449 | me.ManagedEntityID: entityID, |
| 450 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_IntervalEndTime: 0, // This ideally should increment by 1 every collection interval, but staying 0 for simulation is Ok for now. |
| 451 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_ThresholdData12Id: 0, |
| 452 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_DropEvents: rand.Intn(100), |
| 453 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Octets: rand.Intn(100), |
| 454 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets: rand.Intn(100), |
| 455 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_BroadcastPackets: rand.Intn(100), |
| 456 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_MulticastPackets: rand.Intn(100), |
| 457 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_CrcErroredPackets: rand.Intn(100), |
| 458 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_UndersizePackets: rand.Intn(100), |
| 459 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_OversizePackets: rand.Intn(100), |
| 460 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets64Octets: rand.Intn(100), |
| 461 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets65To127Octets: rand.Intn(100), |
| 462 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets128To255Octets: rand.Intn(100), |
| 463 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets256To511Octets: rand.Intn(100), |
| 464 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets512To1023Octets: rand.Intn(100), |
| 465 | me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets1024To1518Octets: rand.Intn(100), |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 466 | }, |
| 467 | }) |
| 468 | |
| 469 | if meErr.GetError() != nil { |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 470 | omciLogger.Errorf("NewEthernetFramePerformanceMonitoringHistoryDataUpstream %v", meErr.Error()) |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 471 | return nil |
| 472 | } |
| 473 | |
| 474 | return &omci.GetResponse{ |
| 475 | MeBasePacket: omci.MeBasePacket{ |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 476 | EntityClass: me.EthernetFramePerformanceMonitoringHistoryDataUpstreamClassID, |
| 477 | EntityInstance: entityID, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 478 | Extended: isExtended, |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 479 | }, |
| 480 | Attributes: managedEntity.GetAttributeValueMap(), |
| 481 | AttributeMask: attributeMask, |
| 482 | Result: me.Success, |
| 483 | } |
| 484 | } |
| 485 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 486 | func createEthernetFramePerformanceMonitoringHistoryDataDownstreamResponse(isExtended bool, attributeMask uint16, entityID uint16) *omci.GetResponse { |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 487 | managedEntity, meErr := me.NewEthernetFramePerformanceMonitoringHistoryDataDownstream(me.ParamData{ |
| 488 | EntityID: entityID, |
| 489 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 490 | me.ManagedEntityID: entityID, |
| 491 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_IntervalEndTime: 0, // This ideally should increment by 1 every collection interval, but staying 0 for simulation is Ok for now. |
| 492 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_ThresholdData12Id: 0, |
| 493 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_DropEvents: rand.Intn(100), |
| 494 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Octets: rand.Intn(100), |
| 495 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets: rand.Intn(100), |
| 496 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_BroadcastPackets: rand.Intn(100), |
| 497 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_MulticastPackets: rand.Intn(100), |
| 498 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_CrcErroredPackets: rand.Intn(100), |
| 499 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_UndersizePackets: rand.Intn(100), |
| 500 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_OversizePackets: rand.Intn(100), |
| 501 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets64Octets: rand.Intn(100), |
| 502 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets65To127Octets: rand.Intn(100), |
| 503 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets128To255Octets: rand.Intn(100), |
| 504 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets256To511Octets: rand.Intn(100), |
| 505 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets512To1023Octets: rand.Intn(100), |
| 506 | me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets1024To1518Octets: rand.Intn(100), |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 507 | }, |
| 508 | }) |
| 509 | |
| 510 | if meErr.GetError() != nil { |
| 511 | omciLogger.Errorf("NewEthernetFramePerformanceMonitoringHistoryDataDownstream %v", meErr.Error()) |
| 512 | return nil |
| 513 | } |
| 514 | |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 515 | return &omci.GetResponse{ |
| 516 | MeBasePacket: omci.MeBasePacket{ |
| 517 | EntityClass: me.EthernetFramePerformanceMonitoringHistoryDataDownstreamClassID, |
| 518 | EntityInstance: entityID, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 519 | Extended: isExtended, |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 520 | }, |
| 521 | Attributes: managedEntity.GetAttributeValueMap(), |
| 522 | AttributeMask: attributeMask, |
| 523 | Result: me.Success, |
| 524 | } |
| 525 | } |
| 526 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 527 | func createEthernetPerformanceMonitoringHistoryDataResponse(isExtended bool, attributeMask uint16, entityID uint16) *omci.GetResponse { |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 528 | managedEntity, meErr := me.NewEthernetPerformanceMonitoringHistoryData(me.ParamData{ |
| 529 | EntityID: entityID, |
| 530 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 531 | me.ManagedEntityID: entityID, |
| 532 | me.EthernetPerformanceMonitoringHistoryData_IntervalEndTime: 0, // This ideally should increment by 1 every collection interval, but staying 0 for simulation is Ok for now. |
| 533 | me.EthernetPerformanceMonitoringHistoryData_ThresholdData12Id: 0, |
| 534 | me.EthernetPerformanceMonitoringHistoryData_FcsErrors: rand.Intn(100), |
| 535 | me.EthernetPerformanceMonitoringHistoryData_ExcessiveCollisionCounter: rand.Intn(100), |
| 536 | me.EthernetPerformanceMonitoringHistoryData_LateCollisionCounter: rand.Intn(100), |
| 537 | me.EthernetPerformanceMonitoringHistoryData_FramesTooLong: rand.Intn(100), |
| 538 | me.EthernetPerformanceMonitoringHistoryData_BufferOverflowsOnReceive: rand.Intn(100), |
| 539 | me.EthernetPerformanceMonitoringHistoryData_BufferOverflowsOnTransmit: rand.Intn(100), |
| 540 | me.EthernetPerformanceMonitoringHistoryData_SingleCollisionFrameCounter: rand.Intn(100), |
| 541 | me.EthernetPerformanceMonitoringHistoryData_MultipleCollisionsFrameCounter: rand.Intn(100), |
| 542 | me.EthernetPerformanceMonitoringHistoryData_SqeCounter: rand.Intn(100), |
| 543 | me.EthernetPerformanceMonitoringHistoryData_DeferredTransmissionCounter: rand.Intn(100), |
| 544 | me.EthernetPerformanceMonitoringHistoryData_InternalMacTransmitErrorCounter: rand.Intn(100), |
| 545 | me.EthernetPerformanceMonitoringHistoryData_CarrierSenseErrorCounter: rand.Intn(100), |
| 546 | me.EthernetPerformanceMonitoringHistoryData_AlignmentErrorCounter: rand.Intn(100), |
| 547 | me.EthernetPerformanceMonitoringHistoryData_InternalMacReceiveErrorCounter: rand.Intn(100), |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 548 | }, |
| 549 | }) |
| 550 | |
| 551 | if meErr.GetError() != nil { |
| 552 | omciLogger.Errorf("NewEthernetPerformanceMonitoringHistoryData %v", meErr.Error()) |
| 553 | return nil |
| 554 | } |
| 555 | |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 556 | return &omci.GetResponse{ |
| 557 | MeBasePacket: omci.MeBasePacket{ |
| 558 | EntityClass: me.EthernetPerformanceMonitoringHistoryDataClassID, |
| 559 | EntityInstance: entityID, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 560 | Extended: isExtended, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 561 | }, |
| 562 | Attributes: managedEntity.GetAttributeValueMap(), |
| 563 | AttributeMask: attributeMask, |
| 564 | Result: me.Success, |
| 565 | } |
| 566 | } |
| 567 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 568 | func createFecPerformanceMonitoringHistoryDataResponse(isExtended bool, attributeMask uint16, entityID uint16) *omci.GetResponse { |
Girish Gowdra | 6d9a1a4 | 2021-03-05 16:07:15 -0800 | [diff] [blame] | 569 | managedEntity, meErr := me.NewFecPerformanceMonitoringHistoryData(me.ParamData{ |
| 570 | EntityID: entityID, |
| 571 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 572 | me.ManagedEntityID: entityID, |
| 573 | me.FecPerformanceMonitoringHistoryData_IntervalEndTime: 0, // This ideally should increment by 1 every collection interval, but staying 0 for simulation is Ok for now. |
| 574 | me.FecPerformanceMonitoringHistoryData_ThresholdData12Id: 0, |
| 575 | me.FecPerformanceMonitoringHistoryData_CorrectedBytes: rand.Intn(100), |
| 576 | me.FecPerformanceMonitoringHistoryData_CorrectedCodeWords: rand.Intn(100), |
| 577 | me.FecPerformanceMonitoringHistoryData_UncorrectableCodeWords: rand.Intn(100), |
| 578 | me.FecPerformanceMonitoringHistoryData_TotalCodeWords: rand.Intn(100), |
| 579 | me.FecPerformanceMonitoringHistoryData_FecSeconds: rand.Intn(100), |
Girish Gowdra | 6d9a1a4 | 2021-03-05 16:07:15 -0800 | [diff] [blame] | 580 | }, |
| 581 | }) |
| 582 | |
| 583 | if meErr.GetError() != nil { |
| 584 | omciLogger.Errorf("NewFecPerformanceMonitoringHistoryData %v", meErr.Error()) |
| 585 | return nil |
| 586 | } |
| 587 | |
| 588 | // FEC History counter fits within single gem payload. |
| 589 | // No need of the logical we use in other Ethernet History counters or Gem Port History counters |
| 590 | |
| 591 | return &omci.GetResponse{ |
| 592 | MeBasePacket: omci.MeBasePacket{ |
| 593 | EntityClass: me.FecPerformanceMonitoringHistoryDataClassID, |
| 594 | EntityInstance: entityID, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 595 | Extended: isExtended, |
Girish Gowdra | 6d9a1a4 | 2021-03-05 16:07:15 -0800 | [diff] [blame] | 596 | }, |
| 597 | Attributes: managedEntity.GetAttributeValueMap(), |
| 598 | AttributeMask: attributeMask, |
| 599 | Result: me.Success, |
| 600 | } |
| 601 | } |
| 602 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 603 | func createGemPortNetworkCtpPerformanceMonitoringHistoryData(isExtended bool, attributeMask uint16, entityID uint16) *omci.GetResponse { |
Girish Gowdra | 6d9a1a4 | 2021-03-05 16:07:15 -0800 | [diff] [blame] | 604 | managedEntity, meErr := me.NewGemPortNetworkCtpPerformanceMonitoringHistoryData(me.ParamData{ |
| 605 | EntityID: entityID, |
| 606 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 607 | me.ManagedEntityID: entityID, |
| 608 | me.GemPortNetworkCtpPerformanceMonitoringHistoryData_IntervalEndTime: 0, // This ideally should increment by 1 every collection interval, but staying 0 for simulation is Ok for now. |
| 609 | me.GemPortNetworkCtpPerformanceMonitoringHistoryData_ThresholdData12Id: 0, |
| 610 | me.GemPortNetworkCtpPerformanceMonitoringHistoryData_TransmittedGemFrames: rand.Intn(100), |
| 611 | me.GemPortNetworkCtpPerformanceMonitoringHistoryData_ReceivedGemFrames: rand.Intn(100), |
| 612 | me.GemPortNetworkCtpPerformanceMonitoringHistoryData_ReceivedPayloadBytes: rand.Intn(100), |
| 613 | me.GemPortNetworkCtpPerformanceMonitoringHistoryData_TransmittedPayloadBytes: rand.Intn(100), |
| 614 | me.GemPortNetworkCtpPerformanceMonitoringHistoryData_EncryptionKeyErrors: rand.Intn(100), |
Girish Gowdra | 6d9a1a4 | 2021-03-05 16:07:15 -0800 | [diff] [blame] | 615 | }, |
| 616 | }) |
| 617 | |
| 618 | if meErr.GetError() != nil { |
| 619 | omciLogger.Errorf("NewGemPortNetworkCtpPerformanceMonitoringHistoryData %v", meErr.Error()) |
| 620 | return nil |
| 621 | } |
| 622 | |
Girish Gowdra | 6d9a1a4 | 2021-03-05 16:07:15 -0800 | [diff] [blame] | 623 | return &omci.GetResponse{ |
| 624 | MeBasePacket: omci.MeBasePacket{ |
| 625 | EntityClass: me.GemPortNetworkCtpPerformanceMonitoringHistoryDataClassID, |
| 626 | EntityInstance: entityID, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 627 | Extended: isExtended, |
Girish Gowdra | 6d9a1a4 | 2021-03-05 16:07:15 -0800 | [diff] [blame] | 628 | }, |
| 629 | Attributes: managedEntity.GetAttributeValueMap(), |
| 630 | AttributeMask: attributeMask, |
| 631 | Result: me.Success, |
| 632 | } |
| 633 | } |
| 634 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 635 | func createOnuDataResponse(isExtended bool, attributeMask uint16, entityID uint16, mds uint8) *omci.GetResponse { |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 636 | managedEntity, meErr := me.NewOnuData(me.ParamData{ |
| 637 | EntityID: entityID, |
| 638 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 639 | me.ManagedEntityID: entityID, |
| 640 | me.OnuData_MibDataSync: mds, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 641 | }, |
| 642 | }) |
| 643 | |
| 644 | if meErr.GetError() != nil { |
| 645 | omciLogger.Errorf("NewOnuData %v", meErr.Error()) |
| 646 | return nil |
| 647 | } |
| 648 | |
| 649 | return &omci.GetResponse{ |
| 650 | MeBasePacket: omci.MeBasePacket{ |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 651 | EntityClass: me.OnuDataClassID, |
| 652 | EntityInstance: entityID, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 653 | Extended: isExtended, |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 654 | }, |
| 655 | Attributes: managedEntity.GetAttributeValueMap(), |
| 656 | AttributeMask: attributeMask, |
| 657 | Result: me.Success, |
| 658 | } |
| 659 | } |
| 660 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 661 | func createAnigResponse(isExtended bool, attributeMask uint16, entityID uint16) *omci.GetResponse { |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 662 | managedEntity, meErr := me.NewAniG(me.ParamData{ |
| 663 | EntityID: entityID, |
| 664 | Attributes: me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 665 | me.ManagedEntityID: entityID, |
| 666 | me.AniG_SrIndication: 0, |
| 667 | me.AniG_TotalTcontNumber: 0, |
| 668 | me.AniG_GemBlockLength: 0, |
| 669 | me.AniG_PiggybackDbaReporting: 0, |
| 670 | me.AniG_Deprecated: 0, |
| 671 | me.AniG_SignalFailThreshold: 0, |
| 672 | me.AniG_SignalDegradeThreshold: 0, |
| 673 | me.AniG_Arc: 0, |
| 674 | me.AniG_ArcInterval: 0, |
| 675 | me.AniG_OpticalSignalLevel: rand.Intn(16000), // generate some random power level than defaulting to 0 |
| 676 | me.AniG_LowerOpticalThreshold: 0, |
| 677 | me.AniG_UpperOpticalThreshold: 0, |
| 678 | me.AniG_OnuResponseTime: 0, |
| 679 | me.AniG_TransmitOpticalLevel: rand.Intn(16000), // generate some random power level than defaulting to 0 |
| 680 | me.AniG_LowerTransmitPowerThreshold: 0, |
| 681 | me.AniG_UpperTransmitPowerThreshold: 0, |
Girish Gowdra | a539f52 | 2021-02-15 23:00:45 -0800 | [diff] [blame] | 682 | }, |
| 683 | }) |
| 684 | |
| 685 | if meErr.GetError() != nil { |
| 686 | omciLogger.Errorf("NewAniG %v", meErr.Error()) |
| 687 | return nil |
| 688 | } |
| 689 | |
| 690 | return &omci.GetResponse{ |
| 691 | MeBasePacket: omci.MeBasePacket{ |
| 692 | EntityClass: me.AniGClassID, |
| 693 | EntityInstance: entityID, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 694 | Extended: isExtended, |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 695 | }, |
| 696 | Attributes: managedEntity.GetAttributeValueMap(), |
| 697 | AttributeMask: attributeMask, |
| 698 | Result: me.Success, |
| 699 | } |
| 700 | } |
| 701 | |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 702 | func createEthernetFrameExtendedPmGetResponse(isExtended bool, meClass me.ClassID, attributeMask uint16, entityID uint16) *omci.GetResponse { |
Himani Chawla | 6bd190a | 2021-07-09 15:31:01 +0530 | [diff] [blame] | 703 | |
| 704 | callback := me.NewEthernetFrameExtendedPm |
| 705 | if meClass != me.EthernetFrameExtendedPmClassID { |
| 706 | callback = me.NewEthernetFrameExtendedPm64Bit |
| 707 | } |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 708 | |
| 709 | //The names of these attributes are left as strings |
| 710 | //rather than constants of a particular ME because |
| 711 | //they can be used with both the MEs in the lines above |
Himani Chawla | 908a1f5 | 2022-01-27 14:39:44 +0530 | [diff] [blame] | 712 | attr := me.AttributeValueMap{ |
Elia Battiston | 9bfe110 | 2022-02-03 10:38:03 +0100 | [diff] [blame] | 713 | me.ManagedEntityID: entityID, |
Himani Chawla | 908a1f5 | 2022-01-27 14:39:44 +0530 | [diff] [blame] | 714 | "DropEvents": 100, |
| 715 | "Octets": 101, |
| 716 | "Frames": 102, |
| 717 | "BroadcastFrames": 103, |
| 718 | "MulticastFrames": 104, |
| 719 | "CrcErroredFrames": 105, |
| 720 | "UndersizeFrames": 106, |
| 721 | "OversizeFrames": 107, |
| 722 | "Frames64Octets": 108, |
| 723 | "Frames65To127Octets": 109, |
| 724 | "Frames128To255Octets": 110, |
| 725 | "Frames256To511Octets": 111, |
| 726 | "Frames512To1023Octets": 112, |
| 727 | "Frames1024To1518Octets": 113, |
| 728 | } |
Himani Chawla | 6bd190a | 2021-07-09 15:31:01 +0530 | [diff] [blame] | 729 | managedEntity, meErr := callback(me.ParamData{ |
Himani Chawla | 908a1f5 | 2022-01-27 14:39:44 +0530 | [diff] [blame] | 730 | EntityID: entityID, |
| 731 | Attributes: attr, |
Himani Chawla | 6bd190a | 2021-07-09 15:31:01 +0530 | [diff] [blame] | 732 | }) |
| 733 | |
| 734 | if meErr.GetError() != nil { |
| 735 | omciLogger.Errorf("NewEthernetFrameExtendedPm %v", meErr.Error()) |
| 736 | return nil |
| 737 | } |
| 738 | |
| 739 | return &omci.GetResponse{ |
| 740 | MeBasePacket: omci.MeBasePacket{ |
| 741 | EntityClass: meClass, |
| 742 | EntityInstance: entityID, |
Holger Hildebrandt | 02101a6 | 2022-04-06 13:00:51 +0000 | [diff] [blame^] | 743 | Extended: isExtended, |
Himani Chawla | 6bd190a | 2021-07-09 15:31:01 +0530 | [diff] [blame] | 744 | }, |
| 745 | Attributes: managedEntity.GetAttributeValueMap(), |
| 746 | AttributeMask: attributeMask, |
| 747 | Result: me.Success, |
| 748 | } |
| 749 | } |
| 750 | |
Matteo Scandolo | ef4e8f8 | 2021-05-17 11:20:49 -0700 | [diff] [blame] | 751 | func ToOctets(str string, size int) []byte { |
Matteo Scandolo | f9d4341 | 2021-01-12 11:11:34 -0800 | [diff] [blame] | 752 | asciiBytes := []byte(str) |
| 753 | |
| 754 | if len(asciiBytes) < size { |
| 755 | missing := size - len(asciiBytes) |
| 756 | for i := 0; i < missing; i++ { |
| 757 | asciiBytes = append(asciiBytes, []byte{0x00}[0]) |
| 758 | } |
| 759 | } |
| 760 | return asciiBytes |
| 761 | } |