interim commit go fmt stuff
Change-Id: I617a7d771b50c2b7999eabbbebbabef4e68d8713
diff --git a/openflow/barrier.go b/openflow/barrier.go
index 7b631fe..60f5a2f 100644
--- a/openflow/barrier.go
+++ b/openflow/barrier.go
@@ -18,7 +18,7 @@
import (
"encoding/json"
- ofp "github.com/skydive-project/goloxi/of13"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
"log"
)
@@ -26,6 +26,7 @@
jsonRequest, _ := json.Marshal(request)
log.Printf("handleBarrierRequest called with %s", jsonRequest)
reply := ofp.NewBarrierReply()
+ reply.SetVersion(4)
reply.SetXid(request.GetXid())
client.SendMessage(reply)
}
diff --git a/openflow/echo.go b/openflow/echo.go
index 51d09df..8e6c0c5 100644
--- a/openflow/echo.go
+++ b/openflow/echo.go
@@ -18,7 +18,7 @@
import (
"encoding/json"
- ofp "github.com/skydive-project/goloxi/of13"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
"log"
)
diff --git a/openflow/feature.go b/openflow/feature.go
index 2c01f73..6a22836 100644
--- a/openflow/feature.go
+++ b/openflow/feature.go
@@ -19,9 +19,9 @@
import (
"context"
"encoding/json"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
"github.com/opencord/voltha-protos/go/common"
pb "github.com/opencord/voltha-protos/go/voltha"
- ofp "github.com/skydive-project/goloxi/of13"
"log"
)
@@ -38,6 +38,7 @@
func createFeaturesRequestReply(xid uint32, device *pb.LogicalDevice) *ofp.FeaturesReply {
featureReply := ofp.NewFeaturesReply()
+ featureReply.SetVersion(4)
featureReply.SetXid(xid)
features := device.GetSwitchFeatures()
featureReply.SetDatapathId(device.GetDatapathId())
diff --git a/openflow/flowMod.go b/openflow/flowMod.go
index 37e6864..2508bde 100644
--- a/openflow/flowMod.go
+++ b/openflow/flowMod.go
@@ -19,10 +19,11 @@
import (
"context"
"encoding/json"
+ "log"
+
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
"github.com/opencord/voltha-protos/go/openflow_13"
pb "github.com/opencord/voltha-protos/go/voltha"
- ofp "github.com/skydive-project/goloxi/of13"
- "log"
)
var oxmMap = map[string]int32{
@@ -147,6 +148,11 @@
var value pb.OfpOxmOfbField_UdpDst
value.UdpDst = uint32(udpDst)
field.Value = &value
+ case pb.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
+ vid := val.(uint16) & 0xfff
+ var value pb.OfpOxmOfbField_VlanVid
+ value.VlanVid = uint32(vid)
+ field.Value = &value
}
oxmList = append(oxmList, &ofpOxmField)
}
@@ -160,18 +166,22 @@
instructionType := ofpInstruction.GetType()
instruction.Type = uint32(instructionType)
switch instructionType {
- case 1:
+ case ofp.OFPITGotoTable:
goToTable := ofpInstruction.(ofp.IInstructionGotoTable)
var ofpGoToTable openflow_13.OfpInstruction_GotoTable
+ var oGoToTable openflow_13.OfpInstructionGotoTable
+ ofpGoToTable.GotoTable = &oGoToTable
ofpGoToTable.GotoTable.TableId = uint32(goToTable.GetTableId())
instruction.Data = &ofpGoToTable
- case 2:
+ case ofp.OFPITWriteMetadata:
writeMetaData := ofpInstruction.(ofp.IInstructionWriteMetadata)
var ofpWriteMetadata openflow_13.OfpInstruction_WriteMetadata
+ var writeMetadata openflow_13.OfpInstructionWriteMetadata
+ ofpWriteMetadata.WriteMetadata = &writeMetadata
ofpWriteMetadata.WriteMetadata.Metadata = writeMetaData.GetMetadata()
ofpWriteMetadata.WriteMetadata.MetadataMask = writeMetaData.GetMetadataMask()
instruction.Data = &ofpWriteMetadata
- case 3:
+ case ofp.OFPITWriteActions:
writeAction := ofpInstruction.(ofp.IInstructionWriteActions)
var ofpInstructionActions openflow_13.OfpInstruction_Actions
var ofpActions []*openflow_13.OfpAction
@@ -182,7 +192,7 @@
ofpActions = append(ofpActions, ofpAction)
}
instruction.Data = &ofpInstructionActions
- case 4:
+ case ofp.OFPITApplyActions:
applyAction := ofpInstruction.(ofp.IInstructionApplyActions)
var ofpInstructionActions openflow_13.OfpInstruction_Actions
var ofpActions []*openflow_13.OfpAction
@@ -196,7 +206,14 @@
actionsHolder.Actions = ofpActions
ofpInstructionActions.Actions = &actionsHolder
instruction.Data = &ofpInstructionActions
+ case ofp.OFPITMeter:
+ var instructionMeter = ofpInstruction.(ofp.IInstructionMeter)
+ var meterInstruction openflow_13.OfpInstruction_Meter
+ var meter openflow_13.OfpInstructionMeter
+ meter.MeterId = instructionMeter.GetMeterId()
+ meterInstruction.Meter = &meter
+ instruction.Data = &meterInstruction
}
instructions = append(instructions, &instruction)
}
@@ -234,50 +251,3 @@
log.Printf("handleFlowDeleteStrict called with %s", js)
}
-func extractAction(action ofp.IAction) *openflow_13.OfpAction {
- var ofpAction openflow_13.OfpAction
- switch action.GetType() {
- case 0: // Output
- var outputAction openflow_13.OfpAction_Output
- loxiOutputAction := action.(*ofp.ActionOutput)
- var output openflow_13.OfpActionOutput
- output.Port = uint32(loxiOutputAction.Port)
- output.MaxLen = uint32(loxiOutputAction.MaxLen)
- outputAction.Output = &output
- ofpAction.Action = &outputAction
- case 11: //CopyTtlOut
- case 12: //CopyTtlIn
- case 15: //SetMplsTtl
- case 16: //DecMplsTtl
- case 17: //PushVlan
- var pushVlan openflow_13.OfpAction_Push
- loxiPushAction := action.(*ofp.ActionPopVlan)
- fields := loxiPushAction.GetActionFields()
- fieldsJS, _ := json.Marshal(fields)
- log.Printf("\n\nPushVlan fields %s\n\n", fieldsJS)
- pushVlan.Push.Ethertype = 0x8100 //TODO This should be available in the fields
- ofpAction.Type = openflow_13.OfpActionType_OFPAT_PUSH_VLAN
- case 18: //PopVlan
- ofpAction.Type = openflow_13.OfpActionType_OFPAT_POP_VLAN
- case 19: //PushMpls
- case 20: //PopMpls
- case 21: //SetQueue
- case 22: //ActionGroup
- case 23: //SetNwTtl
- case 24: //DecNwTtl
- case 25: //SetField
- var setField openflow_13.OfpAction_SetField
- loxiSetField := action.(*ofp.ActionSetField)
- fields := loxiSetField.GetActionFields()
- fieldsJS, _ := json.Marshal(fields)
- log.Printf("\n\nSet Fields fields %s\n\n", fieldsJS)
-
- ofpAction.Action = &setField
- case 26: //PushPbb
- case 27: //PopPbb
- case 65535: //Experimenter
-
- }
- return &ofpAction
-
-}
diff --git a/openflow/getConfig.go b/openflow/getConfig.go
index 6d4444f..2ba4ded 100644
--- a/openflow/getConfig.go
+++ b/openflow/getConfig.go
@@ -18,7 +18,7 @@
import (
"encoding/json"
- ofp "github.com/skydive-project/goloxi/of13"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
"log"
)
@@ -26,6 +26,7 @@
jsonReq, _ := json.Marshal(request)
log.Printf("handleGetConfigRequest called with %s", jsonReq)
reply := ofp.NewGetConfigReply()
+ reply.SetVersion(4)
reply.SetXid(request.GetXid())
reply.SetMissSendLen(ofp.OFPCMLNoBuffer)
client.SendMessage(reply)
diff --git a/openflow/meter.go b/openflow/meter.go
new file mode 100644
index 0000000..43d690e
--- /dev/null
+++ b/openflow/meter.go
@@ -0,0 +1,88 @@
+/*
+ Copyright 2017 the original author or authors.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+package openflow
+
+import (
+ "encoding/json"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
+ "github.com/opencord/voltha-protos/go/openflow_13"
+ "golang.org/x/net/context"
+ "log"
+)
+
+func handleMeterModRequest(request *ofp.MeterMod, client *Client) {
+ jsonRequest, _ := json.Marshal(request)
+ log.Printf("handleMeterModRequest called with %s", jsonRequest)
+
+ var meterModUpdate openflow_13.MeterModUpdate
+ meterModUpdate.Id = client.DeviceId
+ var meterMod openflow_13.OfpMeterMod
+ meterMod.MeterId = request.MeterId
+ meterMod.Flags = uint32(request.Flags)
+ command := openflow_13.OfpMeterModCommand(request.Command)
+ meterMod.Command = command
+ var bands []*openflow_13.OfpMeterBandHeader
+ ofpBands := request.GetMeters()
+ for i := 0; i < len(ofpBands); i++ {
+ ofpBand := ofpBands[i]
+
+ bandType := ofpBand.GetType()
+ var band openflow_13.OfpMeterBandHeader
+ switch bandType {
+ case ofp.OFPMBTDrop:
+ ofpDrop := ofpBand.(ofp.IMeterBandDrop)
+ band.BurstSize = ofpDrop.GetBurstSize()
+ band.Type = openflow_13.OfpMeterBandType_OFPMBT_DROP
+ band.Rate = ofpDrop.GetRate()
+ var meterBandHeaderDrop openflow_13.OfpMeterBandHeader_Drop
+ var drop openflow_13.OfpMeterBandDrop
+ meterBandHeaderDrop.Drop = &drop
+ band.Data = &meterBandHeaderDrop
+ case ofp.OFPMBTDSCPRemark:
+ ofpDscpRemark := ofpBand.(ofp.IMeterBandDscpRemark)
+ var dscpRemark openflow_13.OfpMeterBandDscpRemark
+ band.Type = openflow_13.OfpMeterBandType_OFPMBT_DSCP_REMARK
+ band.BurstSize = ofpDscpRemark.GetBurstSize()
+ band.Rate = ofpDscpRemark.GetRate()
+ dscpRemark.PrecLevel = uint32(ofpDscpRemark.GetPrecLevel())
+ var meterBandHeaderDscp openflow_13.OfpMeterBandHeader_DscpRemark
+ meterBandHeaderDscp.DscpRemark = &dscpRemark
+ band.Data = &meterBandHeaderDscp
+ case ofp.OFPMBTExperimenter:
+ ofpExperimenter := ofpBand.(ofp.IMeterBandExperimenter)
+ var experimenter openflow_13.OfpMeterBandExperimenter
+ experimenter.Experimenter = ofpExperimenter.GetExperimenter()
+ band.Type = openflow_13.OfpMeterBandType_OFPMBT_EXPERIMENTER
+ band.BurstSize = ofpExperimenter.GetBurstSize()
+ band.Rate = ofpExperimenter.GetRate()
+ var meterBandHeaderExperimenter openflow_13.OfpMeterBandHeader_Experimenter
+ meterBandHeaderExperimenter.Experimenter = &experimenter
+ band.Data = &meterBandHeaderExperimenter
+ }
+ bands = append(bands, &band)
+ }
+ meterMod.Bands = bands
+ meterModUpdate.MeterMod = &meterMod
+ grpcClient := *getGrpcClient()
+ meterModJS, _ := json.Marshal(meterModUpdate)
+ log.Printf("METER MOD UPDATE %s", meterModJS)
+ empty, err := grpcClient.UpdateLogicalDeviceMeterTable(context.Background(), &meterModUpdate)
+ if err != nil {
+ log.Printf("ERROR DOING METER MOD ADD %v", err)
+ }
+ emptyJs, _ := json.Marshal(empty)
+ log.Printf("METER MOD RESPONSE %s", emptyJs)
+}
diff --git a/openflow/ofError.go b/openflow/ofError.go
index c4329e1..2ca5b81 100644
--- a/openflow/ofError.go
+++ b/openflow/ofError.go
@@ -18,7 +18,7 @@
import (
"encoding/json"
- ofp "github.com/skydive-project/goloxi/of13"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
"log"
)
diff --git a/openflow/openflowClient.go b/openflow/openflowClient.go
index b07e36d..f7e3b72 100644
--- a/openflow/openflowClient.go
+++ b/openflow/openflowClient.go
@@ -21,9 +21,9 @@
"fmt"
"time"
+ "github.com/donNewtonAlpha/goloxi"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
pb "github.com/opencord/voltha-protos/go/voltha"
- "github.com/skydive-project/goloxi"
- ofp "github.com/skydive-project/goloxi/of13"
"log"
"net"
@@ -138,80 +138,66 @@
log.Printf("parseHeader called with type %d", header.GetType())
switch header.GetType() {
- case 0:
+ case ofp.OFPTHello:
x := header.(*ofp.Hello)
log.Printf("helloMessage : %+v", x)
- //nothing real to do
- case 1:
+ case ofp.OFPTError:
errMsg := header.(*ofp.ErrorMsg)
go handleErrMsg(errMsg)
- case 2:
+ case ofp.OFPTEchoRequest:
echoReq := header.(*ofp.EchoRequest)
go handleEchoRequest(echoReq, client)
- case 3:
- //EchoReply
- case 4:
- //Expirementer
- case 5:
+ case ofp.OFPTEchoReply:
+ case ofp.OFPTExperimenter:
+ case ofp.OFPTFeaturesRequest:
featReq := header.(*ofp.FeaturesRequest)
go handleFeatureRequest(featReq, client.DeviceId, client)
- case 6:
- //feature reply
- case 7:
+ case ofp.OFPTFeaturesReply:
+ case ofp.OFPTGetConfigRequest:
configReq := header.(*ofp.GetConfigRequest)
go handleGetConfigRequest(configReq, client)
- case 8:
- //GetConfigReply
- case 9:
+ case ofp.OFPTGetConfigReply:
+ case ofp.OFPTSetConfig:
setConf := header.(*ofp.SetConfig)
go handleSetConfig(setConf)
- case 10:
- //packetIn := header.(*ofp.PacketIn)
- //go handlePacketIn(packetIn)
- case 11:
- //FlowRemoved
- case 12:
- //portStatus
- case 13:
+ case ofp.OFPTPacketIn:
+ case ofp.OFPTFlowRemoved:
+ case ofp.OFPTPortStatus:
+ case ofp.OFPTPacketOut:
packetOut := header.(*ofp.PacketOut)
go handlePacketOut(packetOut, client.DeviceId)
- case 14:
+ case ofp.OFPTFlowMod:
flowModType := uint8(buf[25])
switch flowModType {
- case 0:
+ case ofp.OFPFCAdd:
flowAdd := header.(*ofp.FlowAdd)
go handleFlowAdd(flowAdd, client.DeviceId)
- //return DecodeFlowAdd(_flowmod, decoder)
- case 1:
+ case ofp.OFPFCModify:
flowMod := header.(*ofp.FlowMod)
go handleFlowMod(flowMod, client.DeviceId)
- //return DecodeFlowModify(_flowmod, decoder)
- case 2:
+ case ofp.OFPFCModifyStrict:
flowModStrict := header.(*ofp.FlowModifyStrict)
go handleFlowModStrict(flowModStrict, client.DeviceId)
- //return DecodeFlowModifyStrict(_flowmod, decoder)
- case 3:
+ case ofp.OFPFCDelete:
flowDelete := header.(*ofp.FlowDelete)
go handleFlowDelete(flowDelete, client.DeviceId)
- //return DecodeFlowDelete(_flowmod, decoder)
- case 4:
+ case ofp.OFPFCDeleteStrict:
flowDeleteStrict := header.(*ofp.FlowDeleteStrict)
go handleFlowDeleteStrict(flowDeleteStrict, client.DeviceId)
- //return DecodeFlowDeleteStrict(_flowmod, decoder)
- default:
- //return nil, fmt.Errorf("Invalid type '%d' for 'FlowMod'", _flowmod.Command)
-
}
- case 18:
+ case ofp.OFPTStatsRequest:
var statType = uint16(buf[8])<<8 + uint16(buf[9])
log.Println("statsType", statType)
go handleStatsRequest(header, statType, client.DeviceId, client)
- case 20:
+ case ofp.OFPTBarrierRequest:
barRequest := header.(*ofp.BarrierRequest)
go handleBarrierRequest(barRequest, client)
- case 24:
+ case ofp.OFPTRoleRequest:
roleReq := header.(*ofp.RoleRequest)
go handleRoleRequest(roleReq, client)
+ case ofp.OFPTMeterMod:
+ meterMod := header.(*ofp.MeterMod)
+ go handleMeterModRequest(meterMod, client)
}
}
@@ -227,7 +213,8 @@
enc := goloxi.NewEncoder()
message.Serialize(enc)
jMessage, _ := json.Marshal(message)
- log.Printf("message after serialize %s", jMessage)
+ bytes := enc.Bytes()
+ log.Printf("message after serialize %d for message %s", bytes, jMessage)
for {
if conn == nil {
@@ -237,10 +224,12 @@
break
}
}
- _, err := conn.Write(enc.Bytes())
+ _, err := conn.Write(bytes)
if err != nil {
- log.Printf("SendMessage had error %s", err)
+ log.Printf("SendMessage had error %v \n %s\n********", err, jMessage)
return err
+ } else {
+ log.Printf("message after send %s", jMessage)
}
return nil
}
diff --git a/openflow/packet.go b/openflow/packet.go
index 2bd46cd..66949cd 100644
--- a/openflow/packet.go
+++ b/openflow/packet.go
@@ -18,8 +18,8 @@
import (
"encoding/json"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
pb "github.com/opencord/voltha-protos/go/voltha"
- ofp "github.com/skydive-project/goloxi/of13"
"log"
)
@@ -33,12 +33,18 @@
inActions := packetOut.GetActions()
for i := 0; i < len(inActions); i++ {
action := inActions[i]
- var newAction = pb.OfpAction{}
+ newAction := extractAction(action)
+ /*var newAction = pb.OfpAction{}
newAction.Type = pb.OfpActionType(action.GetType())
- actions = append(actions, &newAction)
+ action.
+
+ */
+ actions = append(actions, newAction)
}
pktOut.Actions = actions
pktOut.Data = packetOut.GetData()
+ js, _ := json.Marshal(pktOut)
+ log.Printf("PacketOut %s", js)
pbPacketOut := pb.PacketOut{}
pbPacketOut.PacketOut = &pktOut
pbPacketOut.Id = deviceId
diff --git a/openflow/parseGrpcReturn.go b/openflow/parseGrpcReturn.go
new file mode 100644
index 0000000..706e9a7
--- /dev/null
+++ b/openflow/parseGrpcReturn.go
@@ -0,0 +1,184 @@
+/*
+ Copyright 2017 the original author or authors.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+package openflow
+
+import (
+ "encoding/json"
+ "github.com/donNewtonAlpha/goloxi"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
+ "github.com/opencord/voltha-protos/go/openflow_13"
+ pb "github.com/opencord/voltha-protos/go/voltha"
+ "log"
+ "unsafe"
+)
+
+func parseOxm(ofbField *openflow_13.OfpOxmOfbField) (goloxi.IOxm, uint16) {
+ switch ofbField.Type {
+ case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT:
+ ofpInPort := ofp.NewOxmInPort()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_Port)
+ ofpInPort.Value = ofp.Port(val.Port)
+ return ofpInPort, 4
+ case pb.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE:
+ ofpEthType := ofp.NewOxmEthType()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_EthType)
+ ofpEthType.Value = ofp.EthernetType(val.EthType)
+ return ofpEthType, 2
+ case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT:
+ ofpInPhyPort := ofp.NewOxmInPhyPort()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_PhysicalPort)
+ ofpInPhyPort.Value = ofp.Port(val.PhysicalPort)
+ return ofpInPhyPort, 4
+ case pb.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO:
+ ofpIpProto := ofp.NewOxmIpProto()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_IpProto)
+ ofpIpProto.Value = ofp.IpPrototype(val.IpProto)
+ return ofpIpProto, 1
+ case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC:
+ ofpUdpSrc := ofp.NewOxmUdpSrc()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_UdpSrc)
+ ofpUdpSrc.Value = uint16(val.UdpSrc)
+ return ofpUdpSrc, 2
+ case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
+ ofpUdpDst := ofp.NewOxmUdpDst()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_UdpDst)
+ ofpUdpDst.Value = uint16(val.UdpDst)
+ return ofpUdpDst, 2
+ case pb.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
+ ofpVlanVid := ofp.NewOxmVlanVid()
+ val := ofbField.GetValue()
+ if val != nil {
+ vlanId := val.(*openflow_13.OfpOxmOfbField_VlanVid)
+ ofpVlanVid.Value = uint16(vlanId.VlanVid) + 0x1000
+ } else {
+ ofpVlanVid.Value = uint16(0)
+ }
+ return ofpVlanVid, 2
+ case pb.OxmOfbFieldTypes_OFPXMT_OFB_METADATA:
+ ofpMetadata := ofp.NewOxmMetadata()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_TableMetadata)
+ ofpMetadata.Value = val.TableMetadata
+ return ofpMetadata, 8
+ default:
+ log.Printf("handleFlowStatsRequest Unhandled OxmField %v", ofbField.Type)
+ }
+ return nil, 0
+}
+func parseInstructions(ofpInstruction *openflow_13.OfpInstruction) (ofp.IInstruction, uint16) {
+ instType := ofpInstruction.Type
+ data := ofpInstruction.GetData()
+ switch instType {
+ case ofp.OFPITWriteMetadata:
+ instruction := ofp.NewInstructionWriteMetadata()
+ instruction.Len = 24
+ metadata := data.(*openflow_13.OfpInstruction_WriteMetadata).WriteMetadata
+ instruction.Metadata = uint64(metadata.Metadata)
+ return instruction, 24
+ case ofp.OFPITMeter:
+ instruction := ofp.NewInstructionMeter()
+ instruction.Len = 8
+ meter := data.(*openflow_13.OfpInstruction_Meter).Meter
+ instruction.MeterId = meter.MeterId
+ return instruction, 8
+ case ofp.OFPITGotoTable:
+ instruction := ofp.NewInstructionGotoTable()
+ instruction.Len = 8
+ gotoTable := data.(*openflow_13.OfpInstruction_GotoTable).GotoTable
+ instruction.TableId = uint8(gotoTable.TableId)
+ return instruction, 8
+ case ofp.OFPITApplyActions:
+ instruction := ofp.NewInstructionApplyActions()
+ var instructionSize uint16
+ instructionSize = 8
+ ofpActions := ofpInstruction.GetActions().Actions
+ var actions []goloxi.IAction
+ for i := 0; i < len(ofpActions); i++ {
+ ofpAction := ofpActions[i]
+ action, actionSize := parseAction(ofpAction)
+ js, _ := json.Marshal(action)
+ log.Printf("ACTION size(%d) value %s", actionSize, js)
+ actions = append(actions, action)
+ instructionSize += actionSize
+ mySize := unsafe.Sizeof(*instruction)
+ log.Printf("Calculated Size %d Measured size %d", instructionSize, mySize)
+
+ }
+ instruction.Actions = actions
+ instruction.SetLen(instructionSize)
+ js, _ := json.Marshal(instruction)
+ log.Printf("INSTRUCTION %s", js)
+ return instruction, instructionSize
+ }
+ //shouldn't have reached here :<
+ js, _ := json.Marshal(ofpInstruction)
+ log.Printf("Parse Instruction Failed ofpInstruction : %s", js)
+ return nil, 0
+}
+func parseAction(ofpAction *openflow_13.OfpAction) (goloxi.IAction, uint16) {
+ js, _ := json.Marshal(ofpAction)
+ log.Printf("ACTION BEFORE %s", js)
+ switch ofpAction.Type {
+ case openflow_13.OfpActionType_OFPAT_OUTPUT:
+ ofpOutputAction := ofpAction.GetOutput()
+ outputAction := ofp.NewActionOutput()
+ outputAction.Port = ofp.Port(ofpOutputAction.Port)
+ outputAction.MaxLen = uint16(ofpOutputAction.MaxLen)
+ outputAction.Len = 16
+ return outputAction, 16
+ case openflow_13.OfpActionType_OFPAT_PUSH_VLAN:
+ ofpPushVlanAction := ofp.NewActionPushVlan()
+ ofpPushVlanAction.Ethertype = uint16(ofpAction.GetPush().Ethertype)
+ ofpPushVlanAction.Len = 8
+ return ofpPushVlanAction, 8
+ case openflow_13.OfpActionType_OFPAT_POP_VLAN:
+ ofpPopVlanAction := ofp.NewActionPopVlan()
+ ofpPopVlanAction.Len = 8
+ return ofpPopVlanAction, 8
+ case openflow_13.OfpActionType_OFPAT_SET_FIELD:
+ ofpActionSetField := ofpAction.GetSetField()
+ setFieldAction := ofp.NewActionSetField()
+
+ iOxm, _ := parseOxm(ofpActionSetField.GetField().GetOfbField())
+ setFieldAction.Field = iOxm
+ setFieldAction.Len = 10
+ return setFieldAction, 10
+ default:
+ js, _ := json.Marshal(ofpAction)
+ log.Printf("UNKNOWN ACTION %s", js)
+ }
+ return nil, 0
+}
+func parsePortStats(port *pb.LogicalPort) ofp.PortStatsEntry {
+ stats := port.OfpPortStats
+ port.OfpPort.GetPortNo()
+ var entry ofp.PortStatsEntry
+ entry.SetPortNo(ofp.Port(port.OfpPort.GetPortNo()))
+ entry.SetRxPackets(stats.GetRxPackets())
+ entry.SetTxPackets(stats.GetTxPackets())
+ entry.SetRxBytes(stats.GetRxBytes())
+ entry.SetTxBytes(stats.GetTxBytes())
+ entry.SetRxDropped(stats.GetRxDropped())
+ entry.SetTxDropped(stats.GetTxDropped())
+ entry.SetRxErrors(stats.GetRxErrors())
+ entry.SetTxErrors(stats.GetTxErrors())
+ entry.SetRxFrameErr(stats.GetRxFrameErr())
+ entry.SetRxOverErr(stats.GetRxOverErr())
+ entry.SetRxCrcErr(stats.GetRxCrcErr())
+ entry.SetCollisions(stats.GetCollisions())
+ entry.SetDurationSec(stats.GetDurationSec())
+ entry.SetDurationNsec(stats.GetDurationNsec())
+ return entry
+}
diff --git a/openflow/role.go b/openflow/role.go
index 08cf457..0620321 100644
--- a/openflow/role.go
+++ b/openflow/role.go
@@ -18,7 +18,7 @@
import (
"encoding/json"
- ofp "github.com/skydive-project/goloxi/of13"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
"log"
)
diff --git a/openflow/setConfig.go b/openflow/setConfig.go
index c429f46..69a6ab2 100644
--- a/openflow/setConfig.go
+++ b/openflow/setConfig.go
@@ -18,7 +18,7 @@
import (
"encoding/json"
- ofp "github.com/skydive-project/goloxi/of13"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
"log"
)
diff --git a/openflow/stats.go b/openflow/stats.go
index 46fe2f2..0218463 100644
--- a/openflow/stats.go
+++ b/openflow/stats.go
@@ -19,15 +19,16 @@
import (
"context"
"encoding/json"
- "github.com/opencord/voltha-protos/go/openflow_13"
- "github.com/skydive-project/goloxi"
+
"log"
"net"
"unsafe"
+ "github.com/opencord/voltha-protos/go/openflow_13"
+
+ "github.com/donNewtonAlpha/goloxi"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
"github.com/opencord/voltha-protos/go/common"
- pb "github.com/opencord/voltha-protos/go/voltha"
- ofp "github.com/skydive-project/goloxi/of13"
)
func handleStatsRequest(request ofp.IHeader, statType uint16, deviceId string, client *Client) error {
@@ -36,7 +37,7 @@
var id = common.ID{Id: deviceId}
switch statType {
- case 0:
+ case ofp.OFPSTDesc:
statsReq := request.(*ofp.DescStatsRequest)
response, err := handleDescStatsRequest(statsReq, id)
if err != nil {
@@ -44,29 +45,32 @@
}
client.SendMessage(response)
- case 1:
+ case ofp.OFPSTFlow:
statsReq := request.(*ofp.FlowStatsRequest)
response, _ := handleFlowStatsRequest(statsReq, id)
+ response.Length = uint16(unsafe.Sizeof(*response))
+ jResponse, _ := json.Marshal(response)
+ log.Printf("HANDLE FLOW STATS REQUEST response\n\n\n %s \n\n\n", jResponse)
err := client.SendMessage(response)
if err != nil {
return err
}
- case 2:
+ case ofp.OFPSTAggregate:
statsReq := request.(*ofp.AggregateStatsRequest)
aggregateStatsReply, err := handleAggregateStatsRequest(statsReq, id)
if err != nil {
return err
}
client.SendMessage(aggregateStatsReply)
- case 3:
+ case ofp.OFPSTTable:
statsReq := request.(*ofp.TableStatsRequest)
tableStatsReply, e := handleTableStatsRequest(statsReq, id)
if e != nil {
return e
}
client.SendMessage(tableStatsReply)
- case 4:
+ case ofp.OFPSTPort:
statsReq := request.(*ofp.PortStatsRequest)
response, err := handlePortStatsRequest(statsReq, id)
if err != nil {
@@ -74,63 +78,66 @@
}
client.SendMessage(response)
- case 5:
+ case ofp.OFPSTQueue:
statsReq := request.(*ofp.QueueStatsRequest)
response, err := handleQueueStatsRequest(statsReq, id)
if err != nil {
return err
}
client.SendMessage(response)
- case 6:
+ case ofp.OFPSTGroup:
statsReq := request.(*ofp.GroupStatsRequest)
response, err := handleGroupStatsRequest(statsReq, id)
if err != nil {
return err
}
+
client.SendMessage(response)
- case 7:
+ case ofp.OFPSTGroupDesc:
statsReq := request.(*ofp.GroupDescStatsRequest)
response, err := handleGroupStatsDescRequest(statsReq, id)
if err != nil {
return err
}
client.SendMessage(response)
- case 8:
+
+ case ofp.OFPSTGroupFeatures:
statsReq := request.(*ofp.GroupFeaturesStatsRequest)
response, err := handleGroupFeatureStatsRequest(statsReq, id)
if err != nil {
return err
}
client.SendMessage(response)
- case 9:
+ case ofp.OFPSTMeter:
statsReq := request.(*ofp.MeterStatsRequest)
response, err := handleMeterStatsRequest(statsReq, id)
if err != nil {
+ log.Printf("ERROR HANDLE METER STATS REQUEST %v", err)
return err
}
client.SendMessage(response)
- case 10:
+ case ofp.OFPSTMeterConfig:
statsReq := request.(*ofp.MeterConfigStatsRequest)
response, err := handleMeterConfigStatsRequest(statsReq, id)
if err != nil {
return err
}
client.SendMessage(response)
- case 11:
+ case ofp.OFPSTMeterFeatures:
statsReq := request.(*ofp.MeterFeaturesStatsRequest)
response, err := handleMeterFeatureStatsRequest(statsReq)
if err != nil {
return err
}
client.SendMessage(response)
- case 12:
+ case ofp.OFPSTTableFeatures:
statsReq := request.(*ofp.TableFeaturesStatsRequest)
response, err := handleTableFeaturesStatsRequest(statsReq, id)
if err != nil {
return err
}
client.SendMessage(response)
- case 13:
+ case ofp.OFPSTPortDesc:
statsReq := request.(*ofp.PortDescStatsRequest)
response, err := handlePortDescStatsRequest(statsReq, deviceId)
if err != nil {
@@ -138,7 +145,7 @@
}
client.SendMessage(response)
- case 65535:
+ case ofp.OFPSTExperimenter:
statsReq := request.(*ofp.ExperimenterStatsRequest)
response, err := handleExperimenterStatsRequest(statsReq, id)
if err != nil {
@@ -153,6 +160,8 @@
response := ofp.NewDescStatsReply()
response.SetXid(request.GetXid())
response.SetVersion(request.GetVersion())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+
client := *getGrpcClient()
resp, err := client.GetLogicalDevice(context.Background(), &id)
if err != nil {
@@ -165,33 +174,30 @@
response.SetSwDesc(PadString(desc.GetSwDesc(), 256))
response.SetSerialNum(PadString(desc.GetSerialNum(), 32))
response.SetDpDesc(PadString(desc.GetDpDesc(), 256))
- //jsonRes,_ := json.Marshal(response)
- //log.Printf("handleDescStatsRequest response : %s",jsonRes)
return response, nil
}
func handleFlowStatsRequest(request *ofp.FlowStatsRequest, id common.ID) (*ofp.FlowStatsReply, error) {
log.Println("****************************************\n***********************************")
response := ofp.NewFlowStatsReply()
response.SetXid(request.GetXid())
- response.SetVersion(request.GetVersion())
+ response.SetVersion(4)
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
client := *getGrpcClient()
resp, err := client.ListLogicalDeviceFlows(context.Background(), &id)
if err != nil {
- log.Println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
log.Printf("err in handleFlowStatsRequest calling ListLogicalDeviceFlows %v", err)
return nil, err
}
- log.Println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
- js, _ := json.Marshal(resp.GetItems())
- log.Printf("||||||||||||||||||||||||||||||||||||HandFlowStat %s|||||||||||||||||||||||||||||||||||||||||", js)
+ js, _ := json.Marshal(resp)
+ log.Printf("HandleFlowStats response: %s", js)
var flow []*ofp.FlowStatsEntry
items := resp.GetItems()
for i := 0; i < len(items); i++ {
- item := items[1]
- var entry ofp.FlowStatsEntry
+ item := items[i]
+ entry := ofp.NewFlowStatsEntry()
- entry.SetTableId(uint8(item.GetId()))
+ entry.SetTableId(uint8(item.GetTableId()))
entry.SetDurationSec(item.GetDurationSec())
entry.SetDurationNsec(item.GetDurationNsec())
entry.SetPriority(uint16(item.GetPriority()))
@@ -201,86 +207,55 @@
entry.SetCookie(item.GetCookie())
entry.SetPacketCount(item.GetPacketCount())
entry.SetByteCount(item.GetByteCount())
- var match ofp.Match
+ var entrySize uint16
+ entrySize = 48
+ match := ofp.NewMatchV3()
pbMatch := item.GetMatch()
-
var fields []goloxi.IOxm
match.SetType(uint16(pbMatch.GetType()))
oxFields := pbMatch.GetOxmFields()
+ var size uint16
+ size = 4
for i := 0; i < len(oxFields); i++ {
- js, _ := json.Marshal(oxFields[i])
- log.Printf("oxfields %s", js)
oxmField := oxFields[i]
field := oxmField.GetField()
ofbField := field.(*openflow_13.OfpOxmField_OfbField).OfbField
- switch ofbField.Type {
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT:
- ofpInPort := ofp.NewOxmInPort()
- val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_Port)
- ofpInPort.Value = ofp.Port(val.Port)
- fields = append(fields, ofpInPort)
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT:
- ofpInPhyPort := ofp.NewOxmInPhyPort()
- val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_PhysicalPort)
- ofpInPhyPort.Value = ofp.Port(val.PhysicalPort)
- fields = append(fields, ofpInPhyPort)
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO:
- ofpIpProto := ofp.NewOxmIpProto()
- val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_IpProto)
- ofpIpProto.Value = ofp.IpPrototype(val.IpProto)
- fields = append(fields, ofpIpProto)
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC:
- ofpUdpSrc := ofp.NewOxmUdpSrc()
- val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_UdpSrc)
- ofpUdpSrc.Value = uint16(val.UdpSrc)
- fields = append(fields, ofpUdpSrc)
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
- ofpUdpDst := ofp.NewOxmUdpSrc()
- val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_UdpDst)
- ofpUdpDst.Value = uint16(val.UdpDst)
- fields = append(fields, ofpUdpDst)
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
- ofpVlanVid := ofp.NewOxmVlanVid()
- val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_VlanVid)
- ofpVlanVid.Value = uint16(val.VlanVid)
- fields = append(fields, ofpVlanVid)
- default:
- log.Printf("handleFlowStatsRequest Unhandled OxmField %v", ofbField.Type)
+ iOxm, oxmSize := parseOxm(ofbField)
+ log.Printf("OXMSIZE %d", oxmSize)
+ fields = append(fields, iOxm)
+ if oxmSize > 0 {
+ size += 4 //header for oxm
}
-
+ size += oxmSize
+ log.Printf("SIZE %d", size)
}
+
+ log.Printf("entrySize %d += size %d", entrySize, size)
+ log.Printf("new entrySize %d", entrySize)
match.OxmList = fields
- match.Length = uint16(unsafe.Sizeof(match))
- entry.SetMatch(match)
+ match.Length = uint16(size)
+ //account for 8 byte alignment
+ log.Printf("Size was %d", size)
+ if size%8 != 0 {
+ size = ((size / 8) + 1) * 8
+ }
+ log.Printf("Size is %d", size)
+ entrySize += size
+ entry.SetMatch(*match)
var instructions []ofp.IInstruction
ofpInstructions := item.Instructions
for i := 0; i < len(ofpInstructions); i++ {
- ofpInstruction := ofpInstructions[i]
- instType := ofpInstruction.Type
- switch instType {
- case uint32(openflow_13.OfpInstructionType_OFPIT_APPLY_ACTIONS):
- ofpActions := ofpInstruction.GetActions().Actions
- for i := 0; i < len(ofpActions); i++ {
- ofpAction := ofpActions[i]
- var actions []*ofp.Action
- switch ofpAction.Type {
- case openflow_13.OfpActionType_OFPAT_OUTPUT:
- ofpOutputAction := ofpAction.GetOutput()
- outputAction := ofp.NewActionOutput()
- outputAction.Port = ofp.Port(ofpOutputAction.Port)
- outputAction.MaxLen = uint16(ofpOutputAction.MaxLen)
- actions = append(actions, outputAction.Action)
- }
- }
- instruction := ofp.NewInstruction(uint16(instType))
- instructions = append(instructions, instruction)
- }
-
+ instruction, size := parseInstructions(ofpInstructions[i])
+ instructions = append(instructions, instruction)
+ entrySize += size
}
entry.Instructions = instructions
- entry.Length = uint16(unsafe.Sizeof(entry))
- flow = append(flow, &entry)
-
+ log.Printf("entrysize was %d", entrySize)
+ entrySizeMeasured := uint16(unsafe.Sizeof(*entry))
+ log.Printf("entrysize measure %d", entrySizeMeasured)
+ entry.Length = entrySize
+ entrySize = 0
+ flow = append(flow, entry)
}
response.SetEntries(flow)
return response, nil
@@ -289,6 +264,7 @@
response := ofp.NewAggregateStatsReply()
response.SetVersion(request.GetVersion())
response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
response.SetFlowCount(0)
//TODO wire this to voltha core when it implements
return response, nil
@@ -297,6 +273,7 @@
response := ofp.NewGroupStatsReply()
response.SetVersion(request.GetVersion())
response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
client := *getGrpcClient()
reply, err := client.ListLogicalDeviceFlowGroups(context.Background(), &id)
if err != nil {
@@ -333,6 +310,7 @@
response := ofp.NewGroupDescStatsReply()
response.SetVersion(request.GetVersion())
response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
client := *getGrpcClient()
reply, err := client.ListLogicalDeviceFlowGroups(context.Background(), &id)
if err != nil {
@@ -362,6 +340,7 @@
response := ofp.NewGroupFeaturesStatsReply()
response.SetVersion(request.GetVersion())
response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
//TODO wire this to voltha core when it implements
return response, nil
}
@@ -369,38 +348,70 @@
response := ofp.NewMeterStatsReply()
response.SetVersion(request.GetVersion())
response.SetXid(request.GetXid())
- //TODO wire this to voltha core when it implements
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+ client := *getGrpcClient()
+ resp, err := client.ListLogicalDeviceMeters(context.Background(), &id)
+ if err != nil {
+ return nil, err
+ }
+ size := uint16(40)
+ items := resp.Items
+ var meterStats []*ofp.MeterStats
+ for i := 0; i < len(items); i++ {
+ meterStat := ofp.NewMeterStats()
+ item := items[i]
+ stats := item.Stats
+ meterStat.DurationNsec = stats.DurationNsec
+ meterStat.DurationSec = stats.DurationSec
+ meterStat.ByteInCount = stats.ByteInCount
+ meterStat.FlowCount = stats.FlowCount
+ meterStat.MeterId = stats.MeterId
+ var bandStats []*ofp.MeterBandStats
+ bStats := stats.BandStats
+ for j := 0; j < len(bStats); j++ {
+ bStat := bStats[j]
+ bandStat := ofp.NewMeterBandStats()
+ bandStat.ByteBandCount = bStat.ByteBandCount
+ bandStat.PacketBandCount = bStat.PacketBandCount
+ bandStats = append(bandStats, bandStat)
+ size += 16
+ }
+ meterStat.SetBandStats(bandStats)
+ meterStat.Len = size
+ meterStats = append(meterStats, meterStat)
+ }
+ response.SetEntries(meterStats)
return response, nil
}
-
-//statsReq := request.(*ofp.MeterConfigStatsRequest)
func handleMeterConfigStatsRequest(request *ofp.MeterConfigStatsRequest, id common.ID) (*ofp.MeterConfigStatsReply, error) {
response := ofp.NewMeterConfigStatsReply()
response.SetVersion(request.GetVersion())
response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
//TODO wire this to voltha core when it implements
return response, nil
}
-
-//statsReq := request.(*ofp.TableFeaturesStatsRequest)
func handleTableFeaturesStatsRequest(request *ofp.TableFeaturesStatsRequest, id common.ID) (*ofp.TableFeaturesStatsReply, error) {
response := ofp.NewTableFeaturesStatsReply()
response.SetVersion(request.GetVersion())
response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
//TODO wire this to voltha core when it implements
return response, nil
}
func handleTableStatsRequest(request *ofp.TableStatsRequest, id common.ID) (*ofp.TableStatsReply, error) {
- var tableStatsReply = ofp.NewTableStatsReply()
- tableStatsReply.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
- tableStatsReply.SetVersion(request.GetVersion())
- tableStatsReply.SetXid(request.GetXid())
- return tableStatsReply, nil
+ var response = ofp.NewTableStatsReply()
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+ response.SetVersion(request.GetVersion())
+ response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+ return response, nil
}
func handleQueueStatsRequest(request *ofp.QueueStatsRequest, id common.ID) (*ofp.QueueStatsReply, error) {
response := ofp.NewQueueStatsReply()
response.SetVersion(request.GetVersion())
response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
//TODO wire this to voltha core when it implements
return response, nil
}
@@ -409,7 +420,7 @@
response := ofp.NewPortStatsReply()
response.SetXid(request.GetXid())
response.SetVersion(request.GetVersion())
- //response.SetFlags(ofp.flagsrequest.GetFlags())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
client := *getGrpcClient()
reply, err := client.ListLogicalDevicePorts(context.Background(), &id)
//reply,err := client.GetLogicalDevicePort(context.Background(),&id)
@@ -441,30 +452,12 @@
return response, nil
}
-func parsePortStats(port *pb.LogicalPort) ofp.PortStatsEntry {
- stats := port.OfpPortStats
- var entry ofp.PortStatsEntry
- entry.SetPortNo(ofp.Port(stats.GetPortNo()))
- entry.SetRxPackets(stats.GetRxPackets())
- entry.SetTxPackets(stats.GetTxPackets())
- entry.SetRxBytes(stats.GetRxBytes())
- entry.SetTxBytes(stats.GetTxBytes())
- entry.SetRxDropped(stats.GetRxDropped())
- entry.SetTxDropped(stats.GetTxDropped())
- entry.SetRxErrors(stats.GetRxErrors())
- entry.SetTxErrors(stats.GetTxErrors())
- entry.SetRxFrameErr(stats.GetRxFrameErr())
- entry.SetRxOverErr(stats.GetRxOverErr())
- entry.SetRxCrcErr(stats.GetRxCrcErr())
- entry.SetCollisions(stats.GetCollisions())
- entry.SetDurationSec(stats.GetDurationSec())
- entry.SetDurationNsec(stats.GetDurationNsec())
- return entry
-}
+
func handlePortDescStatsRequest(request *ofp.PortDescStatsRequest, deviceId string) (*ofp.PortDescStatsReply, error) {
response := ofp.NewPortDescStatsReply()
response.SetVersion(request.GetVersion())
response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
var grpcClient = *getGrpcClient()
var id = common.ID{Id: deviceId}
logicalDevice, err := grpcClient.GetLogicalDevice(context.Background(), &id)
@@ -507,12 +500,21 @@
response := ofp.NewMeterFeaturesStatsReply()
response.SetXid(request.GetXid())
response.SetVersion(request.GetVersion())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+ meterFeatures := ofp.NewMeterFeatures()
+ meterFeatures.Capabilities = ofp.OFPMFKbps
+ meterFeatures.BandTypes = ofp.OFPMBTDrop
+ meterFeatures.MaxMeter = 0xffffffff
+ meterFeatures.MaxBands = 0xff
+ meterFeatures.MaxColor = 0xff
+ response.Features = *meterFeatures
return response, nil
}
func handleExperimenterStatsRequest(request *ofp.ExperimenterStatsRequest, id common.ID) (*ofp.ExperimenterStatsReply, error) {
response := ofp.NewExperimenterStatsReply(request.GetExperimenter())
response.SetVersion(request.GetVersion())
response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
//TODO wire this to voltha core when it implements
return response, nil
}
diff --git a/openflow/utils.go b/openflow/utils.go
index 160b2ab..aba7400 100644
--- a/openflow/utils.go
+++ b/openflow/utils.go
@@ -17,9 +17,14 @@
package openflow
import (
+ "encoding/json"
"fmt"
+ "log"
"strings"
"sync"
+
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
+ "github.com/opencord/voltha-protos/go/openflow_13"
)
var mu sync.Mutex
@@ -38,3 +43,73 @@
padded := strings.Repeat(null, nullsNeeded)
return fmt.Sprintf("%s%s", value, padded)
}
+
+func extractAction(action ofp.IAction) *openflow_13.OfpAction {
+ var ofpAction openflow_13.OfpAction
+ switch action.GetType() {
+ case ofp.OFPATOutput:
+ var outputAction openflow_13.OfpAction_Output
+ loxiOutputAction := action.(*ofp.ActionOutput)
+ var output openflow_13.OfpActionOutput
+ output.Port = uint32(loxiOutputAction.Port)
+ output.MaxLen = uint32(loxiOutputAction.MaxLen)
+ outputAction.Output = &output
+ ofpAction.Action = &outputAction
+ ofpAction.Type = openflow_13.OfpActionType_OFPAT_OUTPUT
+ case ofp.OFPATCopyTtlOut: //CopyTtltOut
+ case ofp.OFPATCopyTtlIn: //CopyTtlIn
+ case ofp.OFPATSetMplsTtl: //SetMplsTtl
+ case ofp.OFPATDecMplsTtl: //DecMplsTtl
+ case ofp.OFPATPushVLAN: //PushVlan
+ var pushVlan openflow_13.OfpAction_Push
+ loxiPushAction := action.(*ofp.ActionPushVlan)
+ fields := loxiPushAction.GetActionFields()
+ fieldsJS, _ := json.Marshal(fields)
+ log.Printf("\n\nPushVlan fields %s\n\n", fieldsJS)
+ var push openflow_13.OfpActionPush
+ push.Ethertype = uint32(loxiPushAction.Ethertype) //TODO This should be available in the fields
+ pushVlan.Push = &push
+ ofpAction.Type = openflow_13.OfpActionType_OFPAT_PUSH_VLAN
+ ofpAction.Action = &pushVlan
+ case ofp.OFPATPopVLAN: //PopVlan
+ ofpAction.Type = openflow_13.OfpActionType_OFPAT_POP_VLAN
+ case ofp.OFPATPushMpls: //PushMpls
+ case ofp.OFPATPopMpls: //PopMpls
+ case ofp.OFPATSetQueue: //SetQueue
+ case ofp.OFPATGroup: //ActionGroup
+ case ofp.OFPATSetNwTtl: //SetNwTtl
+ case ofp.OFPATDecNwTtl: //DecNwTtl
+ case ofp.OFPATSetField: //SetField
+ ofpAction.Type = openflow_13.OfpActionType_OFPAT_SET_FIELD
+ var ofpAction_SetField openflow_13.OfpAction_SetField
+ var ofpActionSetField openflow_13.OfpActionSetField
+ var ofpOxmField openflow_13.OfpOxmField
+ ofpOxmField.OxmClass = openflow_13.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+ var ofpOxmField_OfbField openflow_13.OfpOxmField_OfbField
+ var ofpOxmOfbField openflow_13.OfpOxmOfbField
+ loxiSetField := action.(*ofp.ActionSetField)
+ oxmName := loxiSetField.Field.GetOXMName()
+ switch oxmName {
+ case "vlan_vid":
+ ofpOxmOfbField.Type = openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID
+ var vlanVid openflow_13.OfpOxmOfbField_VlanVid
+ var VlanVid = loxiSetField.Field.GetOXMValue().(uint16)
+ vlanVid.VlanVid = uint32(VlanVid)
+
+ ofpOxmOfbField.Value = &vlanVid
+ default:
+ log.Printf("UNHANDLED SET FIELD %s", oxmName)
+ }
+ ofpOxmField_OfbField.OfbField = &ofpOxmOfbField
+ ofpOxmField.Field = &ofpOxmField_OfbField
+ ofpActionSetField.Field = &ofpOxmField
+ ofpAction_SetField.SetField = &ofpActionSetField
+ ofpAction.Action = &ofpAction_SetField
+ case ofp.OFPATPushPbb: //PushPbb
+ case ofp.OFPATPopPbb: //PopPbb
+ case ofp.OFPATExperimenter: //Experimenter
+
+ }
+ return &ofpAction
+
+}