Netopeer NETCONF server integration
Amendments:
- Removed local copy of golang package. Added instructions to download it.
- Removed cached files which are created when transapi is built.
- Added netopeer as a build-able Makefile component.
Updated documentation.
Change-Id: I532e813b81a0531648c5a6bcb048208700cf57a4
diff --git a/netopeer/voltha-grpc-client/README.md b/netopeer/voltha-grpc-client/README.md
new file mode 100644
index 0000000..a7e00db
--- /dev/null
+++ b/netopeer/voltha-grpc-client/README.md
@@ -0,0 +1,39 @@
+Voltha Golang GRPC Client
+-------------------------
+
+### Introduction
+
+This GoLang library is meant to be used as a layer between C libraries that need to interact with
+Voltha.
+
+The Voltha GRPC Go api was generated by first copying all the voltha .proto files located under:
+
+```
+../../voltha/protos
+```
+
+Followed by the execution of the command:
+
+```
+protoc --go_out=plugins=grpc:. *.proto
+```
+
+### TODO(s)
+
+* At the moment, the resulting API files had to be manually fixed to obtain a working solution.
+There were conflicting imports throughout the file. It still needs to be investigated
+
+* The user-facing API, i.e. the exported methods with the main voltha.go file, need to be
+manually added. Only a few commands have been completed as it requires a lot of effort to
+translate between the GRPC data model to C model that can be used by C libraries.
+
+* As a first attempt to auto-generate some of the code, a utility executable (generate-c-header
+.go) was implemented to create the C header that defines all the necessary C data structures
+based on the available Voltha GRPC data structures. This utility still needs some polishing.
+
+
+
+
+
+
+
diff --git a/netopeer/voltha-grpc-client/generate-c-header.go b/netopeer/voltha-grpc-client/generate-c-header.go
new file mode 100644
index 0000000..c84fdda
--- /dev/null
+++ b/netopeer/voltha-grpc-client/generate-c-header.go
@@ -0,0 +1,133 @@
+package main
+
+import (
+ "github.com/opencord/voltha/netconf/translator/voltha"
+ "reflect"
+ "fmt"
+)
+
+var StructMap map[string]map[string]string
+
+func init() {
+ StructMap = make(map[string]map[string]string)
+}
+
+func addArrayType(newType string) {
+ if _, ok := StructMap[newType+"Array"]; !ok {
+ StructMap[newType+"Array"] = make(map[string]string)
+ StructMap[newType+"Array"]["items"] = newType + "*"
+ StructMap[newType+"Array"]["size"] = "int"
+ }
+
+}
+
+func addEnumType(newType string) {
+ if _, ok := StructMap[newType]; !ok {
+ StructMap[newType] = make(map[string]string)
+ StructMap[newType]["Type"] = "enum " + newType + "Enum"
+ StructMap[newType]["Value"] = "char*"
+ }
+}
+
+func traverseVolthaStructures(original reflect.Value) string {
+ field_type := ""
+
+ switch original.Kind() {
+
+ case reflect.Ptr:
+ field_type = traverseVolthaStructures(original.Elem())
+
+ case reflect.Interface:
+ addEnumType(original.Type().Name())
+ field_type = original.Type().Name()
+
+ case reflect.Struct:
+ for i := 0; i < original.NumField(); i += 1 {
+ field_type = ""
+ if original.Field(i).Kind() == reflect.Ptr {
+ newType := reflect.New(original.Type().Field(i).Type.Elem())
+ traverseVolthaStructures(reflect.Indirect(newType))
+ field_type = original.Type().Field(i).Type.Elem().Name() + "*"
+ } else {
+ field_type = traverseVolthaStructures(original.Field(i))
+ }
+ if _, ok := StructMap[original.Type().Name()]; !ok {
+ StructMap[original.Type().Name()] = make(map[string]string)
+ }
+ if _, ok := StructMap[original.Type().Name()][original.Type().Field(i).Name]; !ok {
+ if field_type == "" {
+ StructMap[original.Type().Name()][original.Type().Field(i).Name] =
+ string(original.Type().Field(i).Type.String())
+ } else {
+ StructMap[original.Type().Name()][original.Type().Field(i).Name] =
+ field_type
+ }
+ }
+ }
+
+ case reflect.Slice:
+ if original.Type().Elem().Kind() == reflect.Ptr {
+ newType := reflect.New(original.Type().Elem().Elem())
+ field_type = newType.Type().Elem().Name() + "Array"
+ traverseVolthaStructures(reflect.Indirect(newType))
+ addArrayType(newType.Type().Elem().Name())
+ } else {
+ field_type = original.Type().Elem().Kind().String() + "Array"
+ addArrayType(original.Type().Elem().Kind().String())
+ }
+
+ //case reflect.Map:
+ // for _, key := range original.MapKeys() {
+ // originalValue := original.MapIndex(key)
+ // }
+
+ case reflect.String:
+ field_type = "string"
+ break
+
+ default:
+ field_type = original.Kind().String()
+ }
+
+ return field_type
+}
+
+func main() {
+ traverseVolthaStructures(reflect.ValueOf(voltha.Voltha{}))
+
+ fmt.Printf("#ifndef VOLTHA_DEFS\n")
+ fmt.Printf("#define VOLTHA_DEFS\n")
+ fmt.Printf("\n#include <stdint.h>\n")
+ var attribute_type string
+ for k, v := range StructMap {
+ fmt.Printf("\ntypedef struct {\n")
+ for kk, vv := range v {
+ attribute_type = vv
+ switch vv {
+ case "string*":
+ attribute_type = "char**"
+ case "string":
+ attribute_type = "char*"
+ case "int32":
+ attribute_type = "int32_t"
+ case "uint8*":
+ fallthrough
+ case "uint8":
+ attribute_type = "uint8_t"
+ case "uint32*":
+ fallthrough
+ case "uint32":
+ attribute_type = "uint32_t"
+ case "uint64*":
+ fallthrough
+ case "uint64":
+ attribute_type = "uint64_t"
+ case "bool":
+ attribute_type = "int"
+ }
+ fmt.Printf("\t%s %s;\n", attribute_type, kk)
+ }
+ fmt.Printf("} %s;\n", k)
+ }
+ fmt.Printf("\n#endif\n")
+}
diff --git a/netopeer/voltha-grpc-client/voltha-defs.h b/netopeer/voltha-grpc-client/voltha-defs.h
new file mode 100644
index 0000000..eac9360
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha-defs.h
@@ -0,0 +1,456 @@
+#ifndef VOLTHA_DEFS
+#define VOLTHA_DEFS
+
+#include <stdint.h>
+
+typedef enum {
+ OUTPUT = 0,
+ MPLS_TTL = 1,
+ PUSH = 2,
+ POP_MPLS = 3,
+ GROUP = 4,
+ NW_TTL = 5,
+ SET_FIELD = 6,
+ EXPERIMENTER = 7
+} isOfpAction_ActionEnum;
+
+typedef enum {
+ DEBUG = 0,
+ INFO = 1,
+ WARNING = 2,
+ ERROR = 3,
+ CRITICAL = 4
+} LogLevelEnum;
+
+typedef enum {
+ OFPIT_INVALID = 0,
+ OFPIT_GOTO_TABLE = 1,
+ OFPIT_WRITE_METADATA = 2,
+ OFPIT_WRITE_ACTIONS = 3,
+ OFPIT_APPLY_ACTIONS = 4,
+ OFPIT_CLEAR_ACTIONS = 5,
+ OFPIT_METER = 6,
+ OFPIT_EXPERIMENTER = 7
+} isOfpInstruction_DataEnum;
+
+typedef enum {
+ OFB_FIELD = 0,
+ EXPERIMENTER_FIELD = 1
+} isOfpOxmField_FieldEnum;
+
+typedef enum {
+ MAC = 0,
+ IPV4 = 1,
+ IPV6 = 2,
+ HOST_AND_PORT = 3
+} isDevice_AddressEnum;
+
+typedef enum {
+ HEALTHY = 0,
+ OVERLOADED = 1,
+ DYING = 1
+} HealthStatusEnum;
+
+typedef struct {
+ char* State;
+} HealthStatus;
+
+typedef struct {
+ char* MfrDesc;
+ char* HwDesc;
+ char* SwDesc;
+ char* SerialNum;
+ char* DpDesc;
+} OfpDesc;
+
+typedef struct {
+ uint32_t NBuffers;
+ uint32_t NTables;
+ uint32_t AuxiliaryId;
+ uint32_t Capabilities;
+ uint64_t DatapathId;
+} OfpSwitchFeatures;
+
+typedef struct {
+ char* Value;
+ int Type;
+} isOfpOxmField_Field;
+
+typedef struct {
+ int32_t OxmClass;
+ isOfpOxmField_Field Field;
+} OfpOxmField;
+
+typedef struct {
+ OfpOxmField* items;
+ int size;
+} OfpOxmFieldArray;
+
+typedef struct {
+ int32_t Type;
+ OfpOxmFieldArray OxmFields;
+} OfpMatch;
+
+typedef struct {
+ int Type;
+ char* Value;
+} isOfpAction_Action;
+
+typedef struct {
+ int32_t Type;
+ isOfpAction_Action Action;
+} OfpAction;
+
+typedef struct {
+ int Type;
+ char* Value;
+} isOfpInstruction_Data;
+
+typedef struct {
+ isOfpInstruction_Data Data;
+ uint32_t Type;
+} OfpInstruction;
+
+typedef struct {
+ OfpInstruction* items;
+ int size;
+} OfpInstructionArray;
+
+typedef struct {
+ uint64_t PacketCount;
+ uint64_t ByteCount;
+ OfpMatch* Match;
+ uint64_t Id;
+ uint32_t DurationSec;
+ uint32_t Priority;
+ uint32_t HardTimeout;
+ uint32_t Flags;
+ uint32_t TableId;
+ uint32_t DurationNsec;
+ uint32_t IdleTimeout;
+ uint64_t Cookie;
+ OfpInstructionArray Instructions;
+} OfpFlowStats;
+
+typedef struct {
+ OfpFlowStats* items;
+ int size;
+} OfpFlowStatsArray;
+
+typedef struct {
+ OfpFlowStatsArray Items;
+} Flows;
+
+typedef struct {
+ OfpAction* items;
+ int size;
+} OfpActionArray;
+
+typedef struct {
+ OfpActionArray Actions;
+ uint32_t Weight;
+ uint32_t WatchPort;
+ uint32_t WatchGroup;
+} OfpBucket;
+
+typedef struct {
+ OfpBucket* items;
+ int size;
+} OfpBucketArray;
+
+typedef struct {
+ int32_t Type;
+ uint32_t GroupId;
+ OfpBucketArray Buckets;
+} OfpGroupDesc;
+
+typedef struct {
+ uint64_t PacketCount;
+ uint64_t ByteCount;
+} OfpBucketCounter;
+
+typedef struct {
+ OfpBucketCounter* items;
+ int size;
+} OfpBucketCounterArray;
+
+typedef struct {
+ uint32_t RefCount;
+ uint64_t PacketCount;
+ uint64_t ByteCount;
+ uint32_t DurationSec;
+ uint32_t DurationNsec;
+ OfpBucketCounterArray BucketStats;
+ uint32_t GroupId;
+} OfpGroupStats;
+
+typedef struct {
+ OfpGroupDesc* Desc;
+ OfpGroupStats* Stats;
+} OfpGroupEntry;
+
+typedef struct {
+ OfpGroupEntry* items;
+ int size;
+} OfpGroupEntryArray;
+
+typedef struct {
+ OfpGroupEntryArray Items;
+} FlowGroups;
+
+typedef struct {
+ uint32_t SampleFreq;
+ char* Name;
+ int32_t Type;
+ int Enabled;
+} PmConfig;
+
+typedef struct {
+ PmConfig* items;
+ int size;
+} PmConfigArray;
+
+typedef struct {
+ char* GroupName;
+ uint32_t GroupFreq;
+ int Enabled;
+ PmConfigArray Metrics;
+} PmGroupConfig;
+
+typedef struct {
+ PmGroupConfig* items;
+ int size;
+} PmGroupConfigArray;
+
+typedef struct {
+ uint32_t items;
+ int size;
+} uint32Array;
+
+typedef struct {
+ uint32Array HwAddr;
+ uint32_t State;
+ uint32_t Curr;
+ uint32_t MaxSpeed;
+ uint32_t PortNo;
+ char* Name;
+ uint32_t Config;
+ uint32_t Advertised;
+ uint32_t Supported;
+ uint32_t Peer;
+ uint32_t CurrSpeed;
+} OfpPort;
+
+typedef struct {
+ char* Value;
+ int Type;
+} isDevice_Address;
+
+typedef struct {
+ char* DeviceId;
+ uint32_t ChannelId;
+ uint32_t OnuId;
+ uint32_t OnuSessionId;
+} Device_ProxyAddress;
+
+typedef struct {
+ char** items;
+ int size;
+} stringArray;
+
+typedef struct {
+ uint8_t* items;
+ int size;
+} uint8Array;
+
+typedef struct {
+ uint8Array Value;
+ char* TypeUrl;
+} Any;
+
+typedef struct {
+ int32_t LogLevel;
+ Any* AdditionalConfig;
+} AdapterConfig;
+
+typedef struct {
+ AdapterConfig* Config;
+ Any* AdditionalDescription;
+ stringArray LogicalDeviceIds;
+ char* Id;
+ char* Vendor;
+ char* Version;
+} Adapter;
+
+typedef struct {
+ int32_t Key;
+ char* Value;
+} AlarmFilterRule;
+
+typedef struct {
+ AlarmFilterRule* items;
+ int size;
+} AlarmFilterRuleArray;
+
+typedef struct {
+ char* Id;
+ AlarmFilterRuleArray Rules;
+} AlarmFilter;
+
+typedef struct {
+ AlarmFilter* items;
+ int size;
+} AlarmFilterArray;
+
+typedef struct {
+ char* Id;
+ OfpPort* OfpPort;
+ char* DeviceId;
+ uint32_t DevicePortNo;
+ int RootPort;
+} LogicalPort;
+
+typedef struct {
+ LogicalPort* items;
+ int size;
+} LogicalPortArray;
+
+typedef struct {
+ FlowGroups* FlowGroups;
+ char* Id;
+ uint64_t DatapathId;
+ OfpDesc* Desc;
+ OfpSwitchFeatures* SwitchFeatures;
+ char* RootDeviceId;
+ LogicalPortArray Ports;
+ Flows* Flows;
+} LogicalDevice;
+
+typedef struct {
+ LogicalDevice* items;
+ int size;
+} LogicalDeviceArray;
+
+typedef struct {
+ uint32_t PortNo;
+ char* DeviceId;
+} Port_PeerPort;
+
+typedef struct {
+ Port_PeerPort* items;
+ int size;
+} Port_PeerPortArray;
+
+typedef struct {
+ uint32_t PortNo;
+ char* Label;
+ int32_t Type;
+ int32_t AdminState;
+ int32_t OperStatus;
+ char* DeviceId;
+ Port_PeerPortArray Peers;
+} Port;
+
+typedef struct {
+ Port* items;
+ int size;
+} PortArray;
+
+typedef struct {
+ uint32_t DefaultFreq;
+ int Grouped;
+ int FreqOverride;
+ PmGroupConfigArray Groups;
+ PmConfigArray Metrics;
+ char* Id;
+} PmConfigs;
+
+typedef struct {
+ char* Id;
+ char* Adapter;
+ int AcceptsBulkFlowUpdate;
+ int AcceptsAddRemoveFlowUpdates;
+} DeviceType;
+
+typedef struct {
+ DeviceType* items;
+ int size;
+} DeviceTypeArray;
+
+typedef struct {
+ char* Reason;
+ char* ConnectStatus;
+ FlowGroups* FlowGroups;
+ char* Id;
+ char* Model;
+ Device_ProxyAddress* ProxyAddress;
+ char* OperStatus;
+ uint32_t ParentPortNo;
+ char* HardwareVersion;
+ Flows* Flows;
+ PmConfigs* PmConfigs;
+ char* AdminState;
+ char* Type;
+ char* ParentId;
+ char* Vendor;
+ char* SerialNumber;
+ uint32_t Vlan;
+ isDevice_Address Address;
+ Any* Custom;
+ PortArray Ports;
+ int Root;
+ char* FirmwareVersion;
+ char* SoftwareVersion;
+ char* Adapter;
+} Device;
+
+typedef struct {
+ Device* items;
+ int size;
+} DeviceArray;
+
+typedef struct {
+ char* Id;
+ LogicalDeviceArray LogicalDevices;
+ DeviceArray Devices;
+} DeviceGroup;
+
+typedef struct {
+ DeviceGroup* items;
+ int size;
+} DeviceGroupArray;
+
+typedef struct {
+ Adapter* items;
+ int size;
+} AdapterArray;
+
+typedef struct {
+ AlarmFilterArray AlarmFilters;
+ char* InstanceId;
+ HealthStatus Health;
+ AdapterArray Adapters;
+ LogicalDeviceArray LogicalDevices;
+ DeviceGroupArray DeviceGroups;
+ char* Version;
+ char* LogLevel;
+ DeviceArray Devices;
+ DeviceTypeArray DeviceTypes;
+} VolthaInstance;
+
+typedef struct {
+ VolthaInstance* items;
+ int size;
+} VolthaInstanceArray;
+
+typedef struct {
+ char* Version;
+ char* LogLevel;
+ VolthaInstanceArray Instances;
+ AdapterArray Adapters;
+ LogicalDeviceArray LogicalDevices;
+ DeviceArray Devices;
+ DeviceGroupArray DeviceGroups;
+} Voltha;
+
+#endif
diff --git a/netopeer/voltha-grpc-client/voltha.go b/netopeer/voltha-grpc-client/voltha.go
new file mode 100644
index 0000000..2c7853a
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha.go
@@ -0,0 +1,497 @@
+//package voltha
+package main
+
+/*
+#include <stdlib.h>
+#include "voltha-defs.h"
+ */
+import "C"
+
+import (
+ "log"
+ "golang.org/x/net/context"
+ "google.golang.org/grpc"
+ "github.com/golang/protobuf/ptypes/empty"
+ "github.com/hashicorp/consul/api"
+ pb "github.com/opencord/voltha/netconf/translator/voltha"
+ pb_health "github.com/opencord/voltha/netconf/translator/voltha/health"
+ pb_device "github.com/opencord/voltha/netconf/translator/voltha/device"
+ pb_adapter "github.com/opencord/voltha/netconf/translator/voltha/adapter"
+ pb_logical_device "github.com/opencord/voltha/netconf/translator/voltha/logical_device"
+ pb_openflow "github.com/opencord/voltha/netconf/translator/voltha/openflow_13"
+ pb_any "github.com/golang/protobuf/ptypes/any"
+ "unsafe"
+ "fmt"
+)
+
+const (
+ default_consul_address = "10.100.198.220:8500"
+ default_grpc_address = "localhost:50555"
+ grpc_service_name = "voltha-grpc"
+)
+
+var (
+ GrpcConn *grpc.ClientConn = nil
+ VolthaGlobalClient pb.VolthaGlobalServiceClient = nil
+ HealthClient pb_health.HealthServiceClient = nil
+ ConsulClient *api.Client = nil
+ GrpcServiceAddress string = "localhost:50555"
+)
+
+func init() {
+ ConsulClient = connect_to_consul(default_consul_address)
+ GrpcServiceAddress = get_consul_service_address(grpc_service_name)
+ GrpcConn = connect_to_grpc(GrpcServiceAddress)
+
+ VolthaGlobalClient = pb.NewVolthaGlobalServiceClient(GrpcConn)
+ HealthClient = pb_health.NewHealthServiceClient(GrpcConn)
+}
+
+func connect_to_consul(consul_address string) *api.Client {
+ cfg := api.Config{Address: consul_address }
+
+ log.Printf("Connecting to consul - address: %s", consul_address)
+
+ client, err := api.NewClient(&cfg)
+ if err != nil {
+ panic(err)
+ }
+
+ log.Printf("Connected to consul - address: %s", consul_address)
+
+ return client
+}
+
+func get_consul_service_address(service_name string) string {
+ var service []*api.CatalogService
+ var err error
+
+ log.Printf("Getting consul service - name:%s", service_name)
+
+ if service, _, _ = ConsulClient.Catalog().Service(service_name, "", nil); err != nil {
+ panic(err)
+ }
+
+ address := fmt.Sprintf("%s:%d", service[0].ServiceAddress, service[0].ServicePort)
+
+ log.Printf("Got consul service - name:%s, address:%s", service_name, address)
+
+ return address
+}
+
+func connect_to_grpc(grpc_address string) *grpc.ClientConn {
+ var err error
+ var client *grpc.ClientConn
+
+ log.Printf("Connecting to grpc - address: %s", grpc_address)
+
+ // Set up a connection to the server.
+ client, err = grpc.Dial(grpc_address, grpc.WithInsecure())
+ if err != nil {
+ log.Fatalf("did not connect: %s", err.Error())
+ }
+
+ log.Printf("Connected to grpc - address: %s", grpc_address)
+
+ return client
+}
+// Utility methods
+
+// -------------------------------------------------
+// C to Protobuf conversion methods
+// -------------------------------------------------
+
+func _c_to_proto_Address(address C.isDevice_Address) *pb_device.Device {
+ var device *pb_device.Device
+
+ // Identify the address type to assign
+ switch address.Type {
+ case C.MAC:
+ device.Address = &pb_device.Device_MacAddress{
+ MacAddress: C.GoString(address.Value),
+ }
+ break
+ case C.IPV4:
+ device.Address = &pb_device.Device_Ipv4Address{
+ Ipv4Address: C.GoString(address.Value),
+ }
+ break
+ case C.IPV6:
+ device.Address = &pb_device.Device_Ipv6Address{
+ Ipv6Address: C.GoString(address.Value),
+ }
+ break
+ case C.HOST_AND_PORT:
+ device.Address = &pb_device.Device_HostAndPort{
+ HostAndPort: C.GoString(address.Value),
+ }
+ break
+ }
+
+ return device
+}
+
+// -------------------------------------------------
+// Protobuf to C conversion methods
+// -------------------------------------------------
+
+func _proto_to_c_Adapters(instances []*pb_adapter.Adapter) C.AdapterArray {
+ // TODO: not implemented
+ var result C.AdapterArray
+ return result
+}
+func _proto_to_c_LogicalDevices(instances []*pb_logical_device.LogicalDevice) C.LogicalDeviceArray {
+ // TODO: not implemented
+ var result C.LogicalDeviceArray
+ return result
+}
+func _proto_to_c_DeviceTypes(instances []*pb_device.DeviceType) C.DeviceTypeArray {
+ // TODO: not implemented
+ var result C.DeviceTypeArray
+ return result
+}
+func _proto_to_c_AlarmFilters(instances []*pb.AlarmFilter) C.AlarmFilterArray {
+ // TODO: not implemented
+ var result C.AlarmFilterArray
+ return result
+}
+func _proto_to_c_DeviceGroups(instances []*pb.DeviceGroup) C.DeviceGroupArray {
+ // TODO: not implemented
+ var result C.DeviceGroupArray
+ return result
+}
+func _proto_to_c_ProxyAddress(proxyAddress *pb_device.Device_ProxyAddress) *C.Device_ProxyAddress {
+ // TODO: not implemented
+ var result *C.Device_ProxyAddress
+ defer C.free(unsafe.Pointer(result))
+ return result
+}
+func _proto_to_c_Ports(ports []*pb_device.Port) C.PortArray {
+ // TODO: not implemented
+ var result C.PortArray
+ return result
+}
+func _proto_to_c_Flows(flows *pb_openflow.Flows) *C.Flows {
+ // TODO: not implemented
+ var result *C.Flows
+ defer C.free(unsafe.Pointer(result))
+ return result
+}
+func _proto_to_c_FlowGroups(groups *pb_openflow.FlowGroups) *C.FlowGroups {
+ // TODO: not implemented
+ var result *C.FlowGroups
+ defer C.free(unsafe.Pointer(result))
+ return result
+}
+func _proto_to_c_PmConfigs(configs *pb_device.PmConfigs) *C.PmConfigs {
+ // TODO: not implemented
+ var result *C.PmConfigs
+ defer C.free(unsafe.Pointer(result))
+ return result
+}
+func _proto_to_c_Custom(configs *pb_any.Any) *C.Any {
+ // TODO: not implemented
+ var result *C.Any
+ defer C.free(unsafe.Pointer(result))
+ return result
+}
+func _proto_to_c_HealthStatus(health *pb_health.HealthStatus) C.HealthStatus {
+ var result C.HealthStatus
+
+ var c_string *C.char
+ defer C.free(unsafe.Pointer(c_string))
+
+ if c_string = C.CString(health.GetState().String()); c_string != nil {
+ result.State = c_string
+ }
+
+ return result
+}
+
+func _proto_to_c_VolthaInstances(instances []*pb.VolthaInstance) C.VolthaInstanceArray {
+ var result C.VolthaInstanceArray
+ var c_string *C.char
+ var c_voltha_instance C.VolthaInstance
+ defer C.free(unsafe.Pointer(c_string))
+
+ sizeof := unsafe.Sizeof(c_voltha_instance)
+ count := len(instances)
+ result.size = C.int(count)
+
+ c_items := C.malloc(C.size_t(result.size) * C.size_t(sizeof))
+ defer C.free(unsafe.Pointer(c_items))
+
+ // Array to the allocated space
+ c_array := (*[1<<30 - 1]C.VolthaInstance)(c_items)
+
+ for index, value := range instances {
+ if c_string = C.CString(value.GetInstanceId()); c_string != nil {
+ c_voltha_instance.InstanceId = c_string
+ }
+ if c_string = C.CString(value.GetVersion()); c_string != nil {
+ c_voltha_instance.Version = c_string
+ }
+ if c_string = C.CString(value.GetLogLevel().String()); c_string != nil {
+ c_voltha_instance.LogLevel = c_string
+ }
+ c_voltha_instance.Health = _proto_to_c_HealthStatus(value.GetHealth())
+ c_voltha_instance.Adapters = _proto_to_c_Adapters(value.GetAdapters())
+ c_voltha_instance.LogicalDevices = _proto_to_c_LogicalDevices(value.GetLogicalDevices())
+ c_voltha_instance.Devices = _proto_to_c_Devices(value.GetDevices())
+ c_voltha_instance.DeviceTypes = _proto_to_c_DeviceTypes(value.GetDeviceTypes())
+ c_voltha_instance.DeviceGroups = _proto_to_c_DeviceGroups(value.GetDeviceGroups())
+ c_voltha_instance.AlarmFilters = _proto_to_c_AlarmFilters(value.GetAlarmFilters())
+
+ c_array[index] = c_voltha_instance
+ }
+
+ result.items = (*C.VolthaInstance)(unsafe.Pointer(c_array))
+
+ return result
+}
+func _proto_to_c_Devices(instances []*pb_device.Device) C.DeviceArray {
+ var result C.DeviceArray
+ var c_string *C.char
+ var c_device_instance C.Device
+ defer C.free(unsafe.Pointer(c_string))
+
+ sizeof := unsafe.Sizeof(c_device_instance)
+ count := len(instances)
+ result.size = C.int(count)
+
+ c_items := C.malloc(C.size_t(result.size) * C.size_t(sizeof))
+ defer C.free(unsafe.Pointer(c_items))
+
+ c_array := (*[1<<30 - 1]C.Device)(c_items)
+
+ for index, value := range instances {
+ c_array[index] = _proto_to_c_Device(value)
+ }
+
+ result.items = (*C.Device)(unsafe.Pointer(c_array))
+
+ return result
+}
+func _proto_to_c_Voltha(voltha *pb.Voltha) C.Voltha {
+ var result C.Voltha
+ var c_string *C.char
+ defer C.free(unsafe.Pointer(c_string))
+
+ if c_string = C.CString(voltha.GetVersion()); c_string != nil {
+ result.Version = c_string
+ }
+ if c_string = C.CString(voltha.GetLogLevel().String()); c_string != nil {
+ result.LogLevel = c_string
+ }
+
+ result.Instances = _proto_to_c_VolthaInstances(voltha.GetInstances())
+ result.Adapters = _proto_to_c_Adapters(voltha.GetAdapters())
+ result.LogicalDevices = _proto_to_c_LogicalDevices(voltha.GetLogicalDevices())
+ result.Devices = _proto_to_c_Devices(voltha.GetDevices())
+ result.DeviceGroups = _proto_to_c_DeviceGroups(voltha.GetDeviceGroups())
+
+ return result
+}
+
+func _proto_to_c_Address(device *pb_device.Device) C.isDevice_Address {
+ var address C.isDevice_Address
+ var c_string *C.char
+ defer C.free(unsafe.Pointer(c_string))
+
+ switch device.GetAddress().(type) {
+ case *pb_device.Device_MacAddress:
+ address.Type = C.MAC
+ c_string = C.CString(device.GetMacAddress())
+ address.Value = c_string
+ case *pb_device.Device_Ipv4Address:
+ address.Type = C.IPV4
+ c_string = C.CString(device.GetIpv4Address())
+ address.Value = c_string
+ case *pb_device.Device_Ipv6Address:
+ address.Type = C.IPV6
+ c_string = C.CString(device.GetIpv6Address())
+ address.Value = c_string
+ case *pb_device.Device_HostAndPort:
+ address.Type = C.HOST_AND_PORT
+ c_string = C.CString(device.GetHostAndPort())
+ address.Value = c_string
+ }
+ return address
+}
+
+func _proto_to_c_Device(device *pb_device.Device) C.Device {
+ var result C.Device
+ var c_string *C.char
+ defer C.free(unsafe.Pointer(c_string))
+
+ if c_string = C.CString(device.GetId()); c_string != nil {
+ result.Id = c_string
+ }
+ if c_string = C.CString(device.GetType()); c_string != nil {
+ result.Type = c_string
+ }
+ if device.GetRoot() {
+ result.Root = C.int(1)
+ } else {
+ result.Root = C.int(0)
+ }
+ if c_string = C.CString(device.GetParentId()); c_string != nil {
+ result.ParentId = c_string
+ }
+
+ result.ParentPortNo = C.uint32_t(device.GetParentPortNo())
+
+ if c_string = C.CString(device.GetVendor()); c_string != nil {
+ result.Vendor = c_string
+ }
+ if c_string = C.CString(device.GetModel()); c_string != nil {
+ result.Model = c_string
+ }
+ if c_string = C.CString(device.GetHardwareVersion()); c_string != nil {
+ result.HardwareVersion = c_string
+ }
+ if c_string = C.CString(device.GetFirmwareVersion()); c_string != nil {
+ result.FirmwareVersion = c_string
+ }
+ if c_string = C.CString(device.GetSoftwareVersion()); c_string != nil {
+ result.SoftwareVersion = c_string
+ }
+ if c_string = C.CString(device.GetSerialNumber()); c_string != nil {
+ result.SerialNumber = c_string
+ }
+ if c_string = C.CString(device.GetAdapter()); c_string != nil {
+ result.Adapter = c_string
+ }
+
+ result.Vlan = C.uint32_t(device.GetVlan())
+ result.ProxyAddress = _proto_to_c_ProxyAddress(device.GetProxyAddress())
+
+ if c_string = C.CString(device.GetAdminState().String()); c_string != nil {
+ result.AdminState = c_string
+ }
+ if c_string = C.CString(device.GetOperStatus().String()); c_string != nil {
+ result.OperStatus = c_string
+ }
+ if c_string = C.CString(device.GetReason()); c_string != nil {
+ result.Reason = c_string
+ }
+ if c_string = C.CString(device.GetConnectStatus().String()); c_string != nil {
+ result.ConnectStatus = c_string
+ }
+
+ result.Custom = _proto_to_c_Custom(device.GetCustom())
+ result.Ports = _proto_to_c_Ports(device.GetPorts())
+ result.Flows = _proto_to_c_Flows(device.GetFlows())
+ result.FlowGroups = _proto_to_c_FlowGroups(device.GetFlowGroups())
+ result.PmConfigs = _proto_to_c_PmConfigs(device.GetPmConfigs())
+ result.Address = _proto_to_c_Address(device)
+
+ return result
+}
+
+// ---------------------------------------------------------
+// Exported methods accessible through the shared library
+// ---------------------------------------------------------
+
+//export GetHealthStatus
+func GetHealthStatus() C.HealthStatus {
+ var output *pb_health.HealthStatus
+ var err error
+
+ if output, err = HealthClient.GetHealthStatus(context.Background(), &empty.Empty{}); output == nil || err != nil {
+ log.Fatalf("Failed to retrieve health status: %s", err.Error())
+ }
+
+ return _proto_to_c_HealthStatus(output)
+}
+
+//export GetVoltha
+func GetVoltha() C.Voltha {
+ var output *pb.Voltha
+ var err error
+ if output, err = VolthaGlobalClient.GetVoltha(context.Background(), &empty.Empty{}); output == nil || err != nil {
+ log.Fatalf("Failed to retrieve voltha information: %s", err.Error())
+ }
+
+ return _proto_to_c_Voltha(output)
+}
+
+//export ListDevices
+func ListDevices() C.DeviceArray {
+ var output *pb_device.Devices
+ var err error
+ if output, err = VolthaGlobalClient.ListDevices(context.Background(), &empty.Empty{});
+ output == nil || err != nil {
+ log.Fatalf("Failed to retrieve voltha information: %s", err.Error())
+ }
+
+ return _proto_to_c_Devices(output.Items)
+}
+
+//export ListVolthaInstances
+func ListVolthaInstances() *C.char {
+ return nil
+}
+
+//export ListLogicalDevices
+func ListLogicalDevices() *C.char {
+ return nil
+}
+
+//export GetLogicalDevice
+func GetLogicalDevice(input *C.char) *C.char {
+ return nil
+}
+
+//export ListLogicalDevicePorts
+func ListLogicalDevicePorts(input *C.char) *C.char {
+ return nil
+}
+
+//export ListLogicalDeviceFlows
+func ListLogicalDeviceFlows(input *C.char) *C.char {
+ return nil
+}
+
+//export CreateDevice
+func CreateDevice(input C.Device) C.Device {
+ log.Printf("Incoming C Device - type:%v, address_type: %v, address_value:%s",
+ C.GoString(input.Type),
+ C.int(input.Address.Type),
+ C.GoString(input.Address.Value),
+ )
+
+ device := _c_to_proto_Address(input.Address)
+ device.Type = C.GoString(input.Type)
+
+ var output *pb_device.Device
+ var err error
+
+ if output, err = VolthaGlobalClient.CreateDevice(context.Background(), device);
+ output == nil || err != nil {
+ log.Fatalf("Failed to create device: %s", err.Error())
+ }
+
+ return _proto_to_c_Device(output)
+}
+
+// Debugging code
+func TestSerialize() {
+ var object C.Device
+
+ object.Type = C.CString("simulated_olt")
+ object.Address.Type = 3
+ object.Address.Value = C.CString("172.16.1.233:123")
+
+ //xmlObject, _ := xml.Marshal(object)
+ //
+ //log.Printf("object: %+v", string(xmlObject))
+
+ CreateDevice(object)
+}
+
+func main() {
+ // We need the main function to make possible
+ // CGO compiler to compile the package as C shared library
+ //TestSerialize()
+}
diff --git a/netopeer/voltha-grpc-client/voltha/adapter/adapter.pb.go b/netopeer/voltha-grpc-client/voltha/adapter/adapter.pb.go
new file mode 100644
index 0000000..9c1f8e4
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/adapter/adapter.pb.go
@@ -0,0 +1,170 @@
+// Code generated by protoc-gen-go.
+// source: adapter.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+ adapter.proto
+
+It has these top-level messages:
+ AdapterConfig
+ Adapter
+ Adapters
+*/
+package adapter
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/ptypes/any"
+import voltha2 "github.com/opencord/voltha/netconf/translator/voltha/common"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type AdapterConfig struct {
+ // Common adapter config attributes here
+ LogLevel voltha2.LogLevel_LogLevel `protobuf:"varint,1,opt,name=log_level,json=logLevel,enum=voltha.LogLevel_LogLevel" json:"log_level,omitempty"`
+ // Custom (vendor-specific) configuration attributes
+ AdditionalConfig *google_protobuf.Any `protobuf:"bytes,64,opt,name=additional_config,json=additionalConfig" json:"additional_config,omitempty"`
+}
+
+func (m *AdapterConfig) Reset() { *m = AdapterConfig{} }
+func (m *AdapterConfig) String() string { return proto.CompactTextString(m) }
+func (*AdapterConfig) ProtoMessage() {}
+func (*AdapterConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *AdapterConfig) GetLogLevel() voltha2.LogLevel_LogLevel {
+ if m != nil {
+ return m.LogLevel
+ }
+ return voltha2.LogLevel_DEBUG
+}
+
+func (m *AdapterConfig) GetAdditionalConfig() *google_protobuf.Any {
+ if m != nil {
+ return m.AdditionalConfig
+ }
+ return nil
+}
+
+// Adapter (software plugin)
+type Adapter struct {
+ // Unique name of adapter, matching the python packate name under
+ // voltha/adapters.
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ Vendor string `protobuf:"bytes,2,opt,name=vendor" json:"vendor,omitempty"`
+ Version string `protobuf:"bytes,3,opt,name=version" json:"version,omitempty"`
+ // Adapter configuration
+ Config *AdapterConfig `protobuf:"bytes,16,opt,name=config" json:"config,omitempty"`
+ // Custom descriptors and custom configuration
+ AdditionalDescription *google_protobuf.Any `protobuf:"bytes,64,opt,name=additional_description,json=additionalDescription" json:"additional_description,omitempty"`
+ LogicalDeviceIds []string `protobuf:"bytes,4,rep,name=logical_device_ids,json=logicalDeviceIds" json:"logical_device_ids,omitempty"`
+}
+
+func (m *Adapter) Reset() { *m = Adapter{} }
+func (m *Adapter) String() string { return proto.CompactTextString(m) }
+func (*Adapter) ProtoMessage() {}
+func (*Adapter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *Adapter) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *Adapter) GetVendor() string {
+ if m != nil {
+ return m.Vendor
+ }
+ return ""
+}
+
+func (m *Adapter) GetVersion() string {
+ if m != nil {
+ return m.Version
+ }
+ return ""
+}
+
+func (m *Adapter) GetConfig() *AdapterConfig {
+ if m != nil {
+ return m.Config
+ }
+ return nil
+}
+
+func (m *Adapter) GetAdditionalDescription() *google_protobuf.Any {
+ if m != nil {
+ return m.AdditionalDescription
+ }
+ return nil
+}
+
+func (m *Adapter) GetLogicalDeviceIds() []string {
+ if m != nil {
+ return m.LogicalDeviceIds
+ }
+ return nil
+}
+
+type Adapters struct {
+ Items []*Adapter `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *Adapters) Reset() { *m = Adapters{} }
+func (m *Adapters) String() string { return proto.CompactTextString(m) }
+func (*Adapters) ProtoMessage() {}
+func (*Adapters) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *Adapters) GetItems() []*Adapter {
+ if m != nil {
+ return m.Items
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*AdapterConfig)(nil), "voltha.AdapterConfig")
+ proto.RegisterType((*Adapter)(nil), "voltha.Adapter")
+ proto.RegisterType((*Adapters)(nil), "voltha.Adapters")
+}
+
+func init() { proto.RegisterFile("adapter.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 340 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x90, 0xc1, 0x4e, 0xea, 0x40,
+ 0x14, 0x86, 0xd3, 0x72, 0x29, 0x70, 0xb8, 0xdc, 0x8b, 0x13, 0x31, 0x85, 0x84, 0xd8, 0x90, 0x98,
+ 0x74, 0xa1, 0x25, 0x62, 0xe2, 0x5a, 0x94, 0x8d, 0x09, 0xab, 0xbe, 0x00, 0x19, 0x3a, 0x43, 0x9d,
+ 0x64, 0x3a, 0x87, 0xb4, 0xb5, 0x09, 0xaf, 0xe0, 0xce, 0x07, 0xf3, 0x3d, 0x7c, 0x02, 0xd7, 0x86,
+ 0x99, 0xa9, 0xa0, 0x0b, 0x77, 0x67, 0xfe, 0xff, 0x9c, 0xf3, 0x7f, 0x67, 0xa0, 0x47, 0x19, 0xdd,
+ 0x96, 0x3c, 0x8f, 0xb6, 0x39, 0x96, 0x48, 0xbc, 0x0a, 0x65, 0xf9, 0x44, 0x47, 0xc3, 0x14, 0x31,
+ 0x95, 0x7c, 0xaa, 0xd5, 0xf5, 0xf3, 0x66, 0x4a, 0xd5, 0xce, 0xb4, 0x8c, 0xfe, 0x26, 0x98, 0x65,
+ 0xa8, 0xec, 0x0b, 0x32, 0x5e, 0x52, 0x53, 0x4f, 0x5e, 0x1c, 0xe8, 0xcd, 0xcd, 0xba, 0x07, 0x54,
+ 0x1b, 0x91, 0x92, 0x5b, 0xe8, 0x48, 0x4c, 0x57, 0x92, 0x57, 0x5c, 0xfa, 0x4e, 0xe0, 0x84, 0xff,
+ 0x66, 0xc3, 0xc8, 0x44, 0x44, 0x4b, 0x4c, 0x97, 0x7b, 0xfd, 0xab, 0x88, 0xdb, 0xd2, 0x56, 0x64,
+ 0x0e, 0x27, 0x94, 0x31, 0x51, 0x0a, 0x54, 0x54, 0xae, 0x12, 0xbd, 0xcc, 0xbf, 0x0b, 0x9c, 0xb0,
+ 0x3b, 0x3b, 0x8d, 0x0c, 0x5a, 0x54, 0xa3, 0x45, 0x73, 0xb5, 0x8b, 0xfb, 0x87, 0x76, 0x13, 0x3d,
+ 0x79, 0x75, 0xa1, 0x65, 0x61, 0xc8, 0x00, 0x5c, 0xc1, 0x74, 0x7e, 0xe7, 0xbe, 0xf9, 0xfe, 0xf1,
+ 0x36, 0x76, 0x62, 0x57, 0x30, 0x32, 0x06, 0xaf, 0xe2, 0x8a, 0x61, 0xee, 0xbb, 0xc7, 0x96, 0x15,
+ 0xc9, 0x39, 0xb4, 0x2a, 0x9e, 0x17, 0x02, 0x95, 0xdf, 0x38, 0xf6, 0x6b, 0x95, 0x5c, 0x81, 0x67,
+ 0xd1, 0xfa, 0x1a, 0x6d, 0x50, 0x9f, 0xf6, 0xed, 0x13, 0x62, 0xdb, 0x44, 0x62, 0x38, 0x3b, 0x3a,
+ 0x8a, 0xf1, 0x22, 0xc9, 0xc5, 0x76, 0xff, 0xfa, 0xed, 0xb2, 0x3a, 0x74, 0x70, 0x18, 0x5d, 0x1c,
+ 0x26, 0xc9, 0x25, 0x10, 0x89, 0xa9, 0x48, 0xf4, 0xc2, 0x4a, 0x24, 0x7c, 0x25, 0x58, 0xe1, 0xff,
+ 0x09, 0x1a, 0x61, 0x27, 0xee, 0x5b, 0x67, 0xa1, 0x8d, 0x47, 0x56, 0x4c, 0xae, 0xa1, 0x6d, 0xd1,
+ 0x0a, 0x72, 0x01, 0x4d, 0x51, 0xf2, 0xac, 0xf0, 0x9d, 0xa0, 0x11, 0x76, 0x67, 0xff, 0x7f, 0xb0,
+ 0xc7, 0xc6, 0x5d, 0x7b, 0x1a, 0xe6, 0xe6, 0x33, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x5e, 0xc4, 0x9a,
+ 0x28, 0x02, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/common/common.pb.go b/netopeer/voltha-grpc-client/voltha/common/common.pb.go
new file mode 100644
index 0000000..7a621d6
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/common/common.pb.go
@@ -0,0 +1,255 @@
+// Code generated by protoc-gen-go.
+// source: common.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+ common.proto
+
+It has these top-level messages:
+ ID
+ LogLevel
+ AdminState
+ OperStatus
+ ConnectStatus
+*/
+package common
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Logging verbosity level
+type LogLevel_LogLevel int32
+
+const (
+ LogLevel_DEBUG LogLevel_LogLevel = 0
+ LogLevel_INFO LogLevel_LogLevel = 1
+ LogLevel_WARNING LogLevel_LogLevel = 2
+ LogLevel_ERROR LogLevel_LogLevel = 3
+ LogLevel_CRITICAL LogLevel_LogLevel = 4
+)
+
+var LogLevel_LogLevel_name = map[int32]string{
+ 0: "DEBUG",
+ 1: "INFO",
+ 2: "WARNING",
+ 3: "ERROR",
+ 4: "CRITICAL",
+}
+var LogLevel_LogLevel_value = map[string]int32{
+ "DEBUG": 0,
+ "INFO": 1,
+ "WARNING": 2,
+ "ERROR": 3,
+ "CRITICAL": 4,
+}
+
+func (x LogLevel_LogLevel) String() string {
+ return proto.EnumName(LogLevel_LogLevel_name, int32(x))
+}
+func (LogLevel_LogLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+// Administrative State
+type AdminState_AdminState int32
+
+const (
+ // The administrative state of the device is unknown
+ AdminState_UNKNOWN AdminState_AdminState = 0
+ // The device is pre-provisioned into Voltha, but not contacted by it
+ AdminState_PREPROVISIONED AdminState_AdminState = 1
+ // The device is enabled for activation and operation
+ AdminState_ENABLED AdminState_AdminState = 3
+ // The device is disabled and shall not perform its intended forwarding
+ // functions other than being available for re-activation.
+ AdminState_DISABLED AdminState_AdminState = 2
+)
+
+var AdminState_AdminState_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "PREPROVISIONED",
+ 3: "ENABLED",
+ 2: "DISABLED",
+}
+var AdminState_AdminState_value = map[string]int32{
+ "UNKNOWN": 0,
+ "PREPROVISIONED": 1,
+ "ENABLED": 3,
+ "DISABLED": 2,
+}
+
+func (x AdminState_AdminState) String() string {
+ return proto.EnumName(AdminState_AdminState_name, int32(x))
+}
+func (AdminState_AdminState) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
+
+// Operational Status
+type OperStatus_OperStatus int32
+
+const (
+ // The status of the device is unknown at this point
+ OperStatus_UNKNOWN OperStatus_OperStatus = 0
+ // The device has been discovered, but not yet activated
+ OperStatus_DISCOVERED OperStatus_OperStatus = 1
+ // The device is being activated (booted, rebooted, upgraded, etc.)
+ OperStatus_ACTIVATING OperStatus_OperStatus = 2
+ // Service impacting tests are being conducted
+ OperStatus_TESTING OperStatus_OperStatus = 3
+ // The device is up and active
+ OperStatus_ACTIVE OperStatus_OperStatus = 4
+ // The device has failed and cannot fulfill its intended role
+ OperStatus_FAILED OperStatus_OperStatus = 5
+)
+
+var OperStatus_OperStatus_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "DISCOVERED",
+ 2: "ACTIVATING",
+ 3: "TESTING",
+ 4: "ACTIVE",
+ 5: "FAILED",
+}
+var OperStatus_OperStatus_value = map[string]int32{
+ "UNKNOWN": 0,
+ "DISCOVERED": 1,
+ "ACTIVATING": 2,
+ "TESTING": 3,
+ "ACTIVE": 4,
+ "FAILED": 5,
+}
+
+func (x OperStatus_OperStatus) String() string {
+ return proto.EnumName(OperStatus_OperStatus_name, int32(x))
+}
+func (OperStatus_OperStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3, 0} }
+
+// Connectivity Status
+type ConnectStatus_ConnectStatus int32
+
+const (
+ // The device connectivity status is unknown
+ ConnectStatus_UNKNOWN ConnectStatus_ConnectStatus = 0
+ // The device cannot be reached by Voltha
+ ConnectStatus_UNREACHABLE ConnectStatus_ConnectStatus = 1
+ // There is live communication between device and Voltha
+ ConnectStatus_REACHABLE ConnectStatus_ConnectStatus = 2
+)
+
+var ConnectStatus_ConnectStatus_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "UNREACHABLE",
+ 2: "REACHABLE",
+}
+var ConnectStatus_ConnectStatus_value = map[string]int32{
+ "UNKNOWN": 0,
+ "UNREACHABLE": 1,
+ "REACHABLE": 2,
+}
+
+func (x ConnectStatus_ConnectStatus) String() string {
+ return proto.EnumName(ConnectStatus_ConnectStatus_name, int32(x))
+}
+func (ConnectStatus_ConnectStatus) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor0, []int{4, 0}
+}
+
+// Convey a resource identifier
+type ID struct {
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+}
+
+func (m *ID) Reset() { *m = ID{} }
+func (m *ID) String() string { return proto.CompactTextString(m) }
+func (*ID) ProtoMessage() {}
+func (*ID) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *ID) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+type LogLevel struct {
+}
+
+func (m *LogLevel) Reset() { *m = LogLevel{} }
+func (m *LogLevel) String() string { return proto.CompactTextString(m) }
+func (*LogLevel) ProtoMessage() {}
+func (*LogLevel) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+type AdminState struct {
+}
+
+func (m *AdminState) Reset() { *m = AdminState{} }
+func (m *AdminState) String() string { return proto.CompactTextString(m) }
+func (*AdminState) ProtoMessage() {}
+func (*AdminState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+type OperStatus struct {
+}
+
+func (m *OperStatus) Reset() { *m = OperStatus{} }
+func (m *OperStatus) String() string { return proto.CompactTextString(m) }
+func (*OperStatus) ProtoMessage() {}
+func (*OperStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+type ConnectStatus struct {
+}
+
+func (m *ConnectStatus) Reset() { *m = ConnectStatus{} }
+func (m *ConnectStatus) String() string { return proto.CompactTextString(m) }
+func (*ConnectStatus) ProtoMessage() {}
+func (*ConnectStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func init() {
+ proto.RegisterType((*ID)(nil), "voltha.ID")
+ proto.RegisterType((*LogLevel)(nil), "voltha.LogLevel")
+ proto.RegisterType((*AdminState)(nil), "voltha.AdminState")
+ proto.RegisterType((*OperStatus)(nil), "voltha.OperStatus")
+ proto.RegisterType((*ConnectStatus)(nil), "voltha.ConnectStatus")
+ proto.RegisterEnum("voltha.LogLevel_LogLevel", LogLevel_LogLevel_name, LogLevel_LogLevel_value)
+ proto.RegisterEnum("voltha.AdminState_AdminState", AdminState_AdminState_name, AdminState_AdminState_value)
+ proto.RegisterEnum("voltha.OperStatus_OperStatus", OperStatus_OperStatus_name, OperStatus_OperStatus_value)
+ proto.RegisterEnum("voltha.ConnectStatus_ConnectStatus", ConnectStatus_ConnectStatus_name, ConnectStatus_ConnectStatus_value)
+}
+
+func init() { proto.RegisterFile("common.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 326 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x91, 0x4f, 0x4f, 0xc2, 0x30,
+ 0x18, 0xc6, 0xd9, 0xf8, 0xff, 0x02, 0xb3, 0x69, 0x3c, 0x18, 0x13, 0x13, 0xb3, 0x93, 0x27, 0x2f,
+ 0xde, 0x8c, 0x97, 0xb2, 0x15, 0x68, 0x5c, 0x5a, 0xd2, 0x0d, 0xf0, 0xa2, 0x06, 0x61, 0xc1, 0x25,
+ 0xd0, 0x12, 0xa8, 0x24, 0x7e, 0x48, 0xbf, 0x8b, 0x27, 0xcf, 0xa6, 0x9b, 0x04, 0xf0, 0xf6, 0x3e,
+ 0x7d, 0x9b, 0xdf, 0xaf, 0x4f, 0x0a, 0xed, 0x99, 0x5e, 0xad, 0xb4, 0xba, 0x5d, 0x6f, 0xb4, 0xd1,
+ 0xb8, 0xb6, 0xd3, 0x4b, 0xf3, 0x3e, 0xbd, 0xc4, 0x9f, 0x53, 0xb5, 0x78, 0xd5, 0x6b, 0x93, 0x69,
+ 0xb5, 0x2d, 0x76, 0xfe, 0x39, 0xb8, 0x2c, 0xc4, 0x1e, 0xb8, 0xd9, 0xfc, 0xc2, 0xb9, 0x76, 0x6e,
+ 0x9a, 0xd2, 0xcd, 0xe6, 0xfe, 0x13, 0x34, 0x22, 0xbd, 0x88, 0xd2, 0x5d, 0xba, 0xf4, 0xe9, 0x61,
+ 0xc6, 0x4d, 0xa8, 0x86, 0xb4, 0x3b, 0xea, 0xa3, 0x12, 0x6e, 0x40, 0x85, 0xf1, 0x9e, 0x40, 0x0e,
+ 0x6e, 0x41, 0x7d, 0x42, 0x24, 0x67, 0xbc, 0x8f, 0x5c, 0x7b, 0x83, 0x4a, 0x29, 0x24, 0x2a, 0xe3,
+ 0x36, 0x34, 0x02, 0xc9, 0x12, 0x16, 0x90, 0x08, 0x55, 0xee, 0xab, 0xdf, 0x3f, 0x5f, 0x57, 0x25,
+ 0xff, 0x19, 0x80, 0xcc, 0x57, 0x99, 0x8a, 0xcd, 0xd4, 0xa4, 0xfe, 0xe0, 0x38, 0x59, 0xd0, 0x88,
+ 0x3f, 0x72, 0x31, 0xe1, 0xa8, 0x84, 0x31, 0x78, 0x43, 0x49, 0x87, 0x52, 0x8c, 0x59, 0xcc, 0x04,
+ 0xa7, 0x61, 0x61, 0xa2, 0x9c, 0x74, 0x23, 0x1a, 0x16, 0xf8, 0x90, 0xc5, 0x45, 0x72, 0xf7, 0xf8,
+ 0x2d, 0x80, 0x58, 0xa7, 0x1b, 0xcb, 0xfb, 0xd8, 0xfa, 0x2f, 0xc7, 0xe9, 0x14, 0xef, 0x01, 0x84,
+ 0x2c, 0x0e, 0xc4, 0x98, 0xca, 0x1c, 0xed, 0x01, 0x90, 0x20, 0x61, 0x63, 0x92, 0x14, 0x3d, 0x5a,
+ 0x50, 0x4f, 0x68, 0x9c, 0x87, 0x32, 0x06, 0xa8, 0xe5, 0x4b, 0x8a, 0x2a, 0x76, 0xee, 0x11, 0x66,
+ 0xa5, 0xd5, 0xbd, 0x34, 0x81, 0x4e, 0xa0, 0x95, 0x4a, 0x67, 0xe6, 0xcf, 0xfb, 0xf0, 0xef, 0xe0,
+ 0x54, 0x7d, 0x06, 0xad, 0x11, 0x97, 0x94, 0x04, 0x03, 0xfb, 0x78, 0xe4, 0xe0, 0x0e, 0x34, 0x0f,
+ 0x71, 0x5f, 0xe5, 0xad, 0x96, 0x7f, 0xd0, 0xdd, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x49, 0x80,
+ 0x95, 0xd3, 0xcc, 0x01, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/device/device.pb.go b/netopeer/voltha-grpc-client/voltha/device/device.pb.go
new file mode 100644
index 0000000..9e87b04
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/device/device.pb.go
@@ -0,0 +1,918 @@
+// Code generated by protoc-gen-go.
+// source: device.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+ device.proto
+
+It has these top-level messages:
+ DeviceType
+ DeviceTypes
+ PmConfig
+ PmGroupConfig
+ PmConfigs
+ Port
+ Ports
+ Device
+ Devices
+*/
+package device
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf1 "github.com/golang/protobuf/ptypes/any"
+import voltha3 "github.com/opencord/voltha/netconf/translator/voltha/common"
+import openflow_13 "github.com/opencord/voltha/netconf/translator/voltha/openflow_13"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type PmConfig_PmType int32
+
+const (
+ PmConfig_COUNTER PmConfig_PmType = 0
+ PmConfig_GUAGE PmConfig_PmType = 1
+ PmConfig_STATE PmConfig_PmType = 2
+)
+
+var PmConfig_PmType_name = map[int32]string{
+ 0: "COUNTER",
+ 1: "GUAGE",
+ 2: "STATE",
+}
+var PmConfig_PmType_value = map[string]int32{
+ "COUNTER": 0,
+ "GUAGE": 1,
+ "STATE": 2,
+}
+
+func (x PmConfig_PmType) String() string {
+ return proto.EnumName(PmConfig_PmType_name, int32(x))
+}
+func (PmConfig_PmType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
+
+type Port_PortType int32
+
+const (
+ Port_UNKNOWN Port_PortType = 0
+ Port_ETHERNET_NNI Port_PortType = 1
+ Port_ETHERNET_UNI Port_PortType = 2
+ Port_PON_OLT Port_PortType = 3
+ Port_PON_ONU Port_PortType = 4
+)
+
+var Port_PortType_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "ETHERNET_NNI",
+ 2: "ETHERNET_UNI",
+ 3: "PON_OLT",
+ 4: "PON_ONU",
+}
+var Port_PortType_value = map[string]int32{
+ "UNKNOWN": 0,
+ "ETHERNET_NNI": 1,
+ "ETHERNET_UNI": 2,
+ "PON_OLT": 3,
+ "PON_ONU": 4,
+}
+
+func (x Port_PortType) String() string {
+ return proto.EnumName(Port_PortType_name, int32(x))
+}
+func (Port_PortType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{5, 0} }
+
+// A Device Type
+type DeviceType struct {
+ // Unique name for the device type
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ // Name of the adapter that handles device type
+ Adapter string `protobuf:"bytes,2,opt,name=adapter" json:"adapter,omitempty"`
+ AcceptsBulkFlowUpdate bool `protobuf:"varint,3,opt,name=accepts_bulk_flow_update,json=acceptsBulkFlowUpdate" json:"accepts_bulk_flow_update,omitempty"`
+ AcceptsAddRemoveFlowUpdates bool `protobuf:"varint,4,opt,name=accepts_add_remove_flow_updates,json=acceptsAddRemoveFlowUpdates" json:"accepts_add_remove_flow_updates,omitempty"`
+}
+
+func (m *DeviceType) Reset() { *m = DeviceType{} }
+func (m *DeviceType) String() string { return proto.CompactTextString(m) }
+func (*DeviceType) ProtoMessage() {}
+func (*DeviceType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *DeviceType) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *DeviceType) GetAdapter() string {
+ if m != nil {
+ return m.Adapter
+ }
+ return ""
+}
+
+func (m *DeviceType) GetAcceptsBulkFlowUpdate() bool {
+ if m != nil {
+ return m.AcceptsBulkFlowUpdate
+ }
+ return false
+}
+
+func (m *DeviceType) GetAcceptsAddRemoveFlowUpdates() bool {
+ if m != nil {
+ return m.AcceptsAddRemoveFlowUpdates
+ }
+ return false
+}
+
+// A plurality of device types
+type DeviceTypes struct {
+ Items []*DeviceType `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *DeviceTypes) Reset() { *m = DeviceTypes{} }
+func (m *DeviceTypes) String() string { return proto.CompactTextString(m) }
+func (*DeviceTypes) ProtoMessage() {}
+func (*DeviceTypes) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *DeviceTypes) GetItems() []*DeviceType {
+ if m != nil {
+ return m.Items
+ }
+ return nil
+}
+
+type PmConfig struct {
+ Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Type PmConfig_PmType `protobuf:"varint,2,opt,name=type,enum=voltha.PmConfig_PmType" json:"type,omitempty"`
+ Enabled bool `protobuf:"varint,3,opt,name=enabled" json:"enabled,omitempty"`
+ SampleFreq uint32 `protobuf:"varint,4,opt,name=sample_freq,json=sampleFreq" json:"sample_freq,omitempty"`
+}
+
+func (m *PmConfig) Reset() { *m = PmConfig{} }
+func (m *PmConfig) String() string { return proto.CompactTextString(m) }
+func (*PmConfig) ProtoMessage() {}
+func (*PmConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *PmConfig) GetName() string {
+ if m != nil {
+ return m.Name
+ }
+ return ""
+}
+
+func (m *PmConfig) GetType() PmConfig_PmType {
+ if m != nil {
+ return m.Type
+ }
+ return PmConfig_COUNTER
+}
+
+func (m *PmConfig) GetEnabled() bool {
+ if m != nil {
+ return m.Enabled
+ }
+ return false
+}
+
+func (m *PmConfig) GetSampleFreq() uint32 {
+ if m != nil {
+ return m.SampleFreq
+ }
+ return 0
+}
+
+type PmGroupConfig struct {
+ GroupName string `protobuf:"bytes,1,opt,name=group_name,json=groupName" json:"group_name,omitempty"`
+ GroupFreq uint32 `protobuf:"varint,2,opt,name=group_freq,json=groupFreq" json:"group_freq,omitempty"`
+ Enabled bool `protobuf:"varint,3,opt,name=enabled" json:"enabled,omitempty"`
+ Metrics []*PmConfig `protobuf:"bytes,4,rep,name=metrics" json:"metrics,omitempty"`
+}
+
+func (m *PmGroupConfig) Reset() { *m = PmGroupConfig{} }
+func (m *PmGroupConfig) String() string { return proto.CompactTextString(m) }
+func (*PmGroupConfig) ProtoMessage() {}
+func (*PmGroupConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *PmGroupConfig) GetGroupName() string {
+ if m != nil {
+ return m.GroupName
+ }
+ return ""
+}
+
+func (m *PmGroupConfig) GetGroupFreq() uint32 {
+ if m != nil {
+ return m.GroupFreq
+ }
+ return 0
+}
+
+func (m *PmGroupConfig) GetEnabled() bool {
+ if m != nil {
+ return m.Enabled
+ }
+ return false
+}
+
+func (m *PmGroupConfig) GetMetrics() []*PmConfig {
+ if m != nil {
+ return m.Metrics
+ }
+ return nil
+}
+
+type PmConfigs struct {
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ DefaultFreq uint32 `protobuf:"varint,2,opt,name=default_freq,json=defaultFreq" json:"default_freq,omitempty"`
+ // Forces group names and group semantics
+ Grouped bool `protobuf:"varint,3,opt,name=grouped" json:"grouped,omitempty"`
+ // Allows Pm to set an individual sample frequency
+ FreqOverride bool `protobuf:"varint,4,opt,name=freq_override,json=freqOverride" json:"freq_override,omitempty"`
+ Groups []*PmGroupConfig `protobuf:"bytes,5,rep,name=groups" json:"groups,omitempty"`
+ Metrics []*PmConfig `protobuf:"bytes,6,rep,name=metrics" json:"metrics,omitempty"`
+}
+
+func (m *PmConfigs) Reset() { *m = PmConfigs{} }
+func (m *PmConfigs) String() string { return proto.CompactTextString(m) }
+func (*PmConfigs) ProtoMessage() {}
+func (*PmConfigs) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *PmConfigs) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *PmConfigs) GetDefaultFreq() uint32 {
+ if m != nil {
+ return m.DefaultFreq
+ }
+ return 0
+}
+
+func (m *PmConfigs) GetGrouped() bool {
+ if m != nil {
+ return m.Grouped
+ }
+ return false
+}
+
+func (m *PmConfigs) GetFreqOverride() bool {
+ if m != nil {
+ return m.FreqOverride
+ }
+ return false
+}
+
+func (m *PmConfigs) GetGroups() []*PmGroupConfig {
+ if m != nil {
+ return m.Groups
+ }
+ return nil
+}
+
+func (m *PmConfigs) GetMetrics() []*PmConfig {
+ if m != nil {
+ return m.Metrics
+ }
+ return nil
+}
+
+type Port struct {
+ PortNo uint32 `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+ Label string `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"`
+ Type Port_PortType `protobuf:"varint,3,opt,name=type,enum=voltha.Port_PortType" json:"type,omitempty"`
+ AdminState voltha3.AdminState_AdminState `protobuf:"varint,5,opt,name=admin_state,json=adminState,enum=voltha.AdminState_AdminState" json:"admin_state,omitempty"`
+ OperStatus voltha3.OperStatus_OperStatus `protobuf:"varint,6,opt,name=oper_status,json=operStatus,enum=voltha.OperStatus_OperStatus" json:"oper_status,omitempty"`
+ DeviceId string `protobuf:"bytes,7,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
+ Peers []*Port_PeerPort `protobuf:"bytes,8,rep,name=peers" json:"peers,omitempty"`
+}
+
+func (m *Port) Reset() { *m = Port{} }
+func (m *Port) String() string { return proto.CompactTextString(m) }
+func (*Port) ProtoMessage() {}
+func (*Port) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+func (m *Port) GetPortNo() uint32 {
+ if m != nil {
+ return m.PortNo
+ }
+ return 0
+}
+
+func (m *Port) GetLabel() string {
+ if m != nil {
+ return m.Label
+ }
+ return ""
+}
+
+func (m *Port) GetType() Port_PortType {
+ if m != nil {
+ return m.Type
+ }
+ return Port_UNKNOWN
+}
+
+func (m *Port) GetAdminState() voltha3.AdminState_AdminState {
+ if m != nil {
+ return m.AdminState
+ }
+ return voltha3.AdminState_UNKNOWN
+}
+
+func (m *Port) GetOperStatus() voltha3.OperStatus_OperStatus {
+ if m != nil {
+ return m.OperStatus
+ }
+ return voltha3.OperStatus_UNKNOWN
+}
+
+func (m *Port) GetDeviceId() string {
+ if m != nil {
+ return m.DeviceId
+ }
+ return ""
+}
+
+func (m *Port) GetPeers() []*Port_PeerPort {
+ if m != nil {
+ return m.Peers
+ }
+ return nil
+}
+
+type Port_PeerPort struct {
+ DeviceId string `protobuf:"bytes,1,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
+ PortNo uint32 `protobuf:"varint,2,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+}
+
+func (m *Port_PeerPort) Reset() { *m = Port_PeerPort{} }
+func (m *Port_PeerPort) String() string { return proto.CompactTextString(m) }
+func (*Port_PeerPort) ProtoMessage() {}
+func (*Port_PeerPort) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5, 0} }
+
+func (m *Port_PeerPort) GetDeviceId() string {
+ if m != nil {
+ return m.DeviceId
+ }
+ return ""
+}
+
+func (m *Port_PeerPort) GetPortNo() uint32 {
+ if m != nil {
+ return m.PortNo
+ }
+ return 0
+}
+
+type Ports struct {
+ Items []*Port `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *Ports) Reset() { *m = Ports{} }
+func (m *Ports) String() string { return proto.CompactTextString(m) }
+func (*Ports) ProtoMessage() {}
+func (*Ports) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+func (m *Ports) GetItems() []*Port {
+ if m != nil {
+ return m.Items
+ }
+ return nil
+}
+
+// A Physical Device instance
+type Device struct {
+ // Voltha's device identifier
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ // Device type, refers to one of the registered device types
+ Type string `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
+ // Is this device a root device. Each logical switch has one root
+ // device that is associated with the logical flow switch.
+ Root bool `protobuf:"varint,3,opt,name=root" json:"root,omitempty"`
+ // Parent device id, in the device tree (for a root device, the parent_id
+ // is the logical_device.id)
+ ParentId string `protobuf:"bytes,4,opt,name=parent_id,json=parentId" json:"parent_id,omitempty"`
+ ParentPortNo uint32 `protobuf:"varint,20,opt,name=parent_port_no,json=parentPortNo" json:"parent_port_no,omitempty"`
+ // Vendor, version, serial number, etc.
+ Vendor string `protobuf:"bytes,5,opt,name=vendor" json:"vendor,omitempty"`
+ Model string `protobuf:"bytes,6,opt,name=model" json:"model,omitempty"`
+ HardwareVersion string `protobuf:"bytes,7,opt,name=hardware_version,json=hardwareVersion" json:"hardware_version,omitempty"`
+ FirmwareVersion string `protobuf:"bytes,8,opt,name=firmware_version,json=firmwareVersion" json:"firmware_version,omitempty"`
+ SoftwareVersion string `protobuf:"bytes,9,opt,name=software_version,json=softwareVersion" json:"software_version,omitempty"`
+ SerialNumber string `protobuf:"bytes,10,opt,name=serial_number,json=serialNumber" json:"serial_number,omitempty"`
+ // Addapter that takes care of device
+ Adapter string `protobuf:"bytes,11,opt,name=adapter" json:"adapter,omitempty"`
+ // Device contact on vlan (if 0, no vlan)
+ Vlan uint32 `protobuf:"varint,12,opt,name=vlan" json:"vlan,omitempty"`
+ // Types that are valid to be assigned to Address:
+ // *Device_MacAddress
+ // *Device_Ipv4Address
+ // *Device_Ipv6Address
+ // *Device_HostAndPort
+ Address isDevice_Address `protobuf_oneof:"address"`
+ ProxyAddress *Device_ProxyAddress `protobuf:"bytes,19,opt,name=proxy_address,json=proxyAddress" json:"proxy_address,omitempty"`
+ AdminState voltha3.AdminState_AdminState `protobuf:"varint,16,opt,name=admin_state,json=adminState,enum=voltha.AdminState_AdminState" json:"admin_state,omitempty"`
+ OperStatus voltha3.OperStatus_OperStatus `protobuf:"varint,17,opt,name=oper_status,json=operStatus,enum=voltha.OperStatus_OperStatus" json:"oper_status,omitempty"`
+ Reason string `protobuf:"bytes,22,opt,name=reason" json:"reason,omitempty"`
+ ConnectStatus voltha3.ConnectStatus_ConnectStatus `protobuf:"varint,18,opt,name=connect_status,json=connectStatus,enum=voltha.ConnectStatus_ConnectStatus" json:"connect_status,omitempty"`
+ // Device type specific attributes
+ Custom *google_protobuf1.Any `protobuf:"bytes,64,opt,name=custom" json:"custom,omitempty"`
+ Ports []*Port `protobuf:"bytes,128,rep,name=ports" json:"ports,omitempty"`
+ Flows *openflow_13.Flows `protobuf:"bytes,129,opt,name=flows" json:"flows,omitempty"`
+ FlowGroups *openflow_13.FlowGroups `protobuf:"bytes,130,opt,name=flow_groups,json=flowGroups" json:"flow_groups,omitempty"`
+ // PmConfigs will eventually converted to a child node of the
+ // device to falicitata callbacks and to simplify manipulation.
+ PmConfigs *PmConfigs `protobuf:"bytes,131,opt,name=pm_configs,json=pmConfigs" json:"pm_configs,omitempty"`
+}
+
+func (m *Device) Reset() { *m = Device{} }
+func (m *Device) String() string { return proto.CompactTextString(m) }
+func (*Device) ProtoMessage() {}
+func (*Device) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+type isDevice_Address interface {
+ isDevice_Address()
+}
+
+type Device_MacAddress struct {
+ MacAddress string `protobuf:"bytes,13,opt,name=mac_address,json=macAddress,oneof"`
+}
+type Device_Ipv4Address struct {
+ Ipv4Address string `protobuf:"bytes,14,opt,name=ipv4_address,json=ipv4Address,oneof"`
+}
+type Device_Ipv6Address struct {
+ Ipv6Address string `protobuf:"bytes,15,opt,name=ipv6_address,json=ipv6Address,oneof"`
+}
+type Device_HostAndPort struct {
+ HostAndPort string `protobuf:"bytes,21,opt,name=host_and_port,json=hostAndPort,oneof"`
+}
+
+func (*Device_MacAddress) isDevice_Address() {}
+func (*Device_Ipv4Address) isDevice_Address() {}
+func (*Device_Ipv6Address) isDevice_Address() {}
+func (*Device_HostAndPort) isDevice_Address() {}
+
+func (m *Device) GetAddress() isDevice_Address {
+ if m != nil {
+ return m.Address
+ }
+ return nil
+}
+
+func (m *Device) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *Device) GetType() string {
+ if m != nil {
+ return m.Type
+ }
+ return ""
+}
+
+func (m *Device) GetRoot() bool {
+ if m != nil {
+ return m.Root
+ }
+ return false
+}
+
+func (m *Device) GetParentId() string {
+ if m != nil {
+ return m.ParentId
+ }
+ return ""
+}
+
+func (m *Device) GetParentPortNo() uint32 {
+ if m != nil {
+ return m.ParentPortNo
+ }
+ return 0
+}
+
+func (m *Device) GetVendor() string {
+ if m != nil {
+ return m.Vendor
+ }
+ return ""
+}
+
+func (m *Device) GetModel() string {
+ if m != nil {
+ return m.Model
+ }
+ return ""
+}
+
+func (m *Device) GetHardwareVersion() string {
+ if m != nil {
+ return m.HardwareVersion
+ }
+ return ""
+}
+
+func (m *Device) GetFirmwareVersion() string {
+ if m != nil {
+ return m.FirmwareVersion
+ }
+ return ""
+}
+
+func (m *Device) GetSoftwareVersion() string {
+ if m != nil {
+ return m.SoftwareVersion
+ }
+ return ""
+}
+
+func (m *Device) GetSerialNumber() string {
+ if m != nil {
+ return m.SerialNumber
+ }
+ return ""
+}
+
+func (m *Device) GetAdapter() string {
+ if m != nil {
+ return m.Adapter
+ }
+ return ""
+}
+
+func (m *Device) GetVlan() uint32 {
+ if m != nil {
+ return m.Vlan
+ }
+ return 0
+}
+
+func (m *Device) GetMacAddress() string {
+ if x, ok := m.GetAddress().(*Device_MacAddress); ok {
+ return x.MacAddress
+ }
+ return ""
+}
+
+func (m *Device) GetIpv4Address() string {
+ if x, ok := m.GetAddress().(*Device_Ipv4Address); ok {
+ return x.Ipv4Address
+ }
+ return ""
+}
+
+func (m *Device) GetIpv6Address() string {
+ if x, ok := m.GetAddress().(*Device_Ipv6Address); ok {
+ return x.Ipv6Address
+ }
+ return ""
+}
+
+func (m *Device) GetHostAndPort() string {
+ if x, ok := m.GetAddress().(*Device_HostAndPort); ok {
+ return x.HostAndPort
+ }
+ return ""
+}
+
+func (m *Device) GetProxyAddress() *Device_ProxyAddress {
+ if m != nil {
+ return m.ProxyAddress
+ }
+ return nil
+}
+
+func (m *Device) GetAdminState() voltha3.AdminState_AdminState {
+ if m != nil {
+ return m.AdminState
+ }
+ return voltha3.AdminState_UNKNOWN
+}
+
+func (m *Device) GetOperStatus() voltha3.OperStatus_OperStatus {
+ if m != nil {
+ return m.OperStatus
+ }
+ return voltha3.OperStatus_UNKNOWN
+}
+
+func (m *Device) GetReason() string {
+ if m != nil {
+ return m.Reason
+ }
+ return ""
+}
+
+func (m *Device) GetConnectStatus() voltha3.ConnectStatus_ConnectStatus {
+ if m != nil {
+ return m.ConnectStatus
+ }
+ return voltha3.ConnectStatus_UNKNOWN
+}
+
+func (m *Device) GetCustom() *google_protobuf1.Any {
+ if m != nil {
+ return m.Custom
+ }
+ return nil
+}
+
+func (m *Device) GetPorts() []*Port {
+ if m != nil {
+ return m.Ports
+ }
+ return nil
+}
+
+func (m *Device) GetFlows() *openflow_13.Flows {
+ if m != nil {
+ return m.Flows
+ }
+ return nil
+}
+
+func (m *Device) GetFlowGroups() *openflow_13.FlowGroups {
+ if m != nil {
+ return m.FlowGroups
+ }
+ return nil
+}
+
+func (m *Device) GetPmConfigs() *PmConfigs {
+ if m != nil {
+ return m.PmConfigs
+ }
+ return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Device) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _Device_OneofMarshaler, _Device_OneofUnmarshaler, _Device_OneofSizer, []interface{}{
+ (*Device_MacAddress)(nil),
+ (*Device_Ipv4Address)(nil),
+ (*Device_Ipv6Address)(nil),
+ (*Device_HostAndPort)(nil),
+ }
+}
+
+func _Device_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*Device)
+ // address
+ switch x := m.Address.(type) {
+ case *Device_MacAddress:
+ b.EncodeVarint(13<<3 | proto.WireBytes)
+ b.EncodeStringBytes(x.MacAddress)
+ case *Device_Ipv4Address:
+ b.EncodeVarint(14<<3 | proto.WireBytes)
+ b.EncodeStringBytes(x.Ipv4Address)
+ case *Device_Ipv6Address:
+ b.EncodeVarint(15<<3 | proto.WireBytes)
+ b.EncodeStringBytes(x.Ipv6Address)
+ case *Device_HostAndPort:
+ b.EncodeVarint(21<<3 | proto.WireBytes)
+ b.EncodeStringBytes(x.HostAndPort)
+ case nil:
+ default:
+ return fmt.Errorf("Device.Address has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _Device_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*Device)
+ switch tag {
+ case 13: // address.mac_address
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeStringBytes()
+ m.Address = &Device_MacAddress{x}
+ return true, err
+ case 14: // address.ipv4_address
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeStringBytes()
+ m.Address = &Device_Ipv4Address{x}
+ return true, err
+ case 15: // address.ipv6_address
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeStringBytes()
+ m.Address = &Device_Ipv6Address{x}
+ return true, err
+ case 21: // address.host_and_port
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeStringBytes()
+ m.Address = &Device_HostAndPort{x}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _Device_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*Device)
+ // address
+ switch x := m.Address.(type) {
+ case *Device_MacAddress:
+ n += proto.SizeVarint(13<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.MacAddress)))
+ n += len(x.MacAddress)
+ case *Device_Ipv4Address:
+ n += proto.SizeVarint(14<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.Ipv4Address)))
+ n += len(x.Ipv4Address)
+ case *Device_Ipv6Address:
+ n += proto.SizeVarint(15<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.Ipv6Address)))
+ n += len(x.Ipv6Address)
+ case *Device_HostAndPort:
+ n += proto.SizeVarint(21<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.HostAndPort)))
+ n += len(x.HostAndPort)
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+type Device_ProxyAddress struct {
+ DeviceId string `protobuf:"bytes,1,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
+ ChannelId uint32 `protobuf:"varint,2,opt,name=channel_id,json=channelId" json:"channel_id,omitempty"`
+ OnuId uint32 `protobuf:"varint,3,opt,name=onu_id,json=onuId" json:"onu_id,omitempty"`
+ OnuSessionId uint32 `protobuf:"varint,4,opt,name=onu_session_id,json=onuSessionId" json:"onu_session_id,omitempty"`
+}
+
+func (m *Device_ProxyAddress) Reset() { *m = Device_ProxyAddress{} }
+func (m *Device_ProxyAddress) String() string { return proto.CompactTextString(m) }
+func (*Device_ProxyAddress) ProtoMessage() {}
+func (*Device_ProxyAddress) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7, 0} }
+
+func (m *Device_ProxyAddress) GetDeviceId() string {
+ if m != nil {
+ return m.DeviceId
+ }
+ return ""
+}
+
+func (m *Device_ProxyAddress) GetChannelId() uint32 {
+ if m != nil {
+ return m.ChannelId
+ }
+ return 0
+}
+
+func (m *Device_ProxyAddress) GetOnuId() uint32 {
+ if m != nil {
+ return m.OnuId
+ }
+ return 0
+}
+
+func (m *Device_ProxyAddress) GetOnuSessionId() uint32 {
+ if m != nil {
+ return m.OnuSessionId
+ }
+ return 0
+}
+
+type Devices struct {
+ Items []*Device `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *Devices) Reset() { *m = Devices{} }
+func (m *Devices) String() string { return proto.CompactTextString(m) }
+func (*Devices) ProtoMessage() {}
+func (*Devices) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+func (m *Devices) GetItems() []*Device {
+ if m != nil {
+ return m.Items
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*DeviceType)(nil), "voltha.DeviceType")
+ proto.RegisterType((*DeviceTypes)(nil), "voltha.DeviceTypes")
+ proto.RegisterType((*PmConfig)(nil), "voltha.PmConfig")
+ proto.RegisterType((*PmGroupConfig)(nil), "voltha.PmGroupConfig")
+ proto.RegisterType((*PmConfigs)(nil), "voltha.PmConfigs")
+ proto.RegisterType((*Port)(nil), "voltha.Port")
+ proto.RegisterType((*Port_PeerPort)(nil), "voltha.Port.PeerPort")
+ proto.RegisterType((*Ports)(nil), "voltha.Ports")
+ proto.RegisterType((*Device)(nil), "voltha.Device")
+ proto.RegisterType((*Device_ProxyAddress)(nil), "voltha.Device.ProxyAddress")
+ proto.RegisterType((*Devices)(nil), "voltha.Devices")
+ proto.RegisterEnum("voltha.PmConfig_PmType", PmConfig_PmType_name, PmConfig_PmType_value)
+ proto.RegisterEnum("voltha.Port_PortType", Port_PortType_name, Port_PortType_value)
+}
+
+func init() { proto.RegisterFile("device.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 1280 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x4d, 0x6f, 0xdb, 0xb6,
+ 0x1b, 0x8f, 0x1c, 0xcb, 0x2f, 0x8f, 0x5f, 0xea, 0xf2, 0xdf, 0xfc, 0xab, 0x26, 0x30, 0x9a, 0xba,
+ 0x3d, 0x64, 0xcd, 0xe6, 0x76, 0xed, 0xd0, 0x0e, 0x3b, 0x0c, 0x71, 0x5a, 0xb7, 0x0d, 0x36, 0x38,
+ 0x9e, 0x62, 0x6f, 0x47, 0x81, 0x91, 0xe8, 0x44, 0xa8, 0x44, 0xaa, 0xa4, 0xec, 0x2e, 0xb7, 0xbd,
+ 0x1c, 0xf6, 0x01, 0xf6, 0x51, 0x86, 0x7d, 0x89, 0x01, 0xbd, 0xed, 0x13, 0xec, 0x30, 0xec, 0xb8,
+ 0x53, 0xce, 0x03, 0x49, 0x51, 0x91, 0xd2, 0xa1, 0xdb, 0x2e, 0x06, 0xf9, 0x7b, 0x21, 0xf9, 0x3c,
+ 0x7e, 0xf8, 0x50, 0xd0, 0x0e, 0xc8, 0x2a, 0xf4, 0xc9, 0x30, 0xe1, 0x2c, 0x65, 0xa8, 0xb6, 0x62,
+ 0x51, 0x7a, 0x8a, 0x37, 0x21, 0x26, 0x29, 0xd6, 0xd8, 0xe6, 0x8d, 0x13, 0xc6, 0x4e, 0x22, 0x72,
+ 0x4f, 0xcd, 0x8e, 0x97, 0x8b, 0x7b, 0x98, 0x9e, 0x65, 0x54, 0xdb, 0x67, 0x71, 0xcc, 0x68, 0x36,
+ 0xbb, 0xca, 0x12, 0x42, 0x17, 0x11, 0x7b, 0xed, 0x7d, 0xf8, 0x30, 0x83, 0xd0, 0x19, 0xa6, 0x27,
+ 0x1e, 0x4b, 0xd2, 0x90, 0x51, 0xa1, 0xb1, 0xc1, 0xcf, 0x16, 0xc0, 0x53, 0xb5, 0xe9, 0xec, 0x2c,
+ 0x21, 0xa8, 0x0b, 0x95, 0x30, 0x70, 0xac, 0x6d, 0x6b, 0xa7, 0xe9, 0x56, 0xc2, 0x00, 0x39, 0x50,
+ 0xc7, 0x01, 0x4e, 0x52, 0xc2, 0x9d, 0x8a, 0x02, 0xcd, 0x14, 0x3d, 0x06, 0x07, 0xfb, 0x3e, 0x49,
+ 0x52, 0xe1, 0x1d, 0x2f, 0xa3, 0x97, 0x9e, 0xda, 0x6a, 0x99, 0x04, 0x38, 0x25, 0xce, 0xfa, 0xb6,
+ 0xb5, 0xd3, 0x70, 0x37, 0x32, 0x7e, 0x7f, 0x19, 0xbd, 0x7c, 0x16, 0xb1, 0xd7, 0x73, 0x45, 0xa2,
+ 0xa7, 0x70, 0xd3, 0x18, 0x71, 0x10, 0x78, 0x9c, 0xc4, 0x6c, 0x45, 0x8a, 0x76, 0xe1, 0x54, 0x95,
+ 0x7f, 0x2b, 0x93, 0x8d, 0x82, 0xc0, 0x55, 0xa2, 0x8b, 0x45, 0xc4, 0xe0, 0x31, 0xb4, 0x2e, 0x8e,
+ 0x2d, 0xd0, 0x0e, 0xd8, 0x61, 0x4a, 0x62, 0xe1, 0x58, 0xdb, 0xeb, 0x3b, 0xad, 0x07, 0x68, 0xa8,
+ 0x53, 0x37, 0xbc, 0xd0, 0xb8, 0x5a, 0x30, 0xf8, 0xc9, 0x82, 0xc6, 0x34, 0x7e, 0xc2, 0xe8, 0x22,
+ 0x3c, 0x41, 0x08, 0xaa, 0x14, 0xc7, 0x24, 0x0b, 0x58, 0x8d, 0xd1, 0x2e, 0x54, 0xd3, 0xb3, 0x84,
+ 0xa8, 0x78, 0xbb, 0x0f, 0xae, 0x9b, 0x95, 0x8c, 0x67, 0x38, 0x8d, 0xd5, 0x72, 0x4a, 0x24, 0xf3,
+ 0x43, 0x28, 0x3e, 0x8e, 0x48, 0x90, 0x05, 0x6d, 0xa6, 0xe8, 0x26, 0xb4, 0x04, 0x8e, 0x93, 0x88,
+ 0x78, 0x0b, 0x4e, 0x5e, 0xa9, 0x90, 0x3a, 0x2e, 0x68, 0xe8, 0x19, 0x27, 0xaf, 0x06, 0xbb, 0x50,
+ 0xd3, 0x4b, 0xa1, 0x16, 0xd4, 0x9f, 0x1c, 0xce, 0x27, 0xb3, 0xb1, 0xdb, 0x5b, 0x43, 0x4d, 0xb0,
+ 0x9f, 0xcf, 0x47, 0xcf, 0xc7, 0x3d, 0x4b, 0x0e, 0x8f, 0x66, 0xa3, 0xd9, 0xb8, 0x57, 0x19, 0xfc,
+ 0x68, 0x41, 0x67, 0x1a, 0x3f, 0xe7, 0x6c, 0x99, 0x64, 0x47, 0xef, 0x03, 0x9c, 0xc8, 0xa9, 0x57,
+ 0x08, 0xa0, 0xa9, 0x90, 0x89, 0x8c, 0x22, 0xa7, 0xd5, 0xee, 0x15, 0xb5, 0xbb, 0xa6, 0xe5, 0xe6,
+ 0xef, 0x38, 0xf7, 0x5d, 0xa8, 0xc7, 0x24, 0xe5, 0xa1, 0x2f, 0xff, 0x06, 0x99, 0xcb, 0xde, 0xe5,
+ 0x0c, 0xb8, 0x46, 0x30, 0xf8, 0xdd, 0x82, 0xa6, 0x41, 0xc5, 0x5b, 0xb5, 0x73, 0x4b, 0x96, 0xf3,
+ 0x02, 0x2f, 0xa3, 0xb4, 0x78, 0x88, 0x56, 0x86, 0xa9, 0x63, 0xdc, 0x84, 0xba, 0x3a, 0x93, 0x39,
+ 0xc6, 0xbe, 0xfd, 0xc7, 0xf9, 0x9b, 0xbe, 0xe5, 0x1a, 0x14, 0xdd, 0x85, 0x8e, 0xf4, 0x7a, 0x6c,
+ 0x45, 0x38, 0x0f, 0x03, 0xa2, 0x4b, 0xc3, 0xc8, 0xda, 0x92, 0x3b, 0xcc, 0x28, 0xf4, 0x01, 0xd4,
+ 0x94, 0x4d, 0x38, 0xb6, 0x3a, 0xf8, 0xc6, 0xc5, 0xc1, 0x0b, 0x89, 0x73, 0x33, 0x51, 0x31, 0xd0,
+ 0xda, 0x3f, 0x05, 0xfa, 0xcb, 0x3a, 0x54, 0xa7, 0x8c, 0xa7, 0xe8, 0x3a, 0xd4, 0x13, 0xc6, 0x53,
+ 0x8f, 0x32, 0x15, 0x68, 0xc7, 0xad, 0xc9, 0xe9, 0x84, 0xa1, 0x6b, 0x60, 0x47, 0xf8, 0x98, 0x44,
+ 0xd9, 0x35, 0xd1, 0x13, 0xf4, 0x5e, 0x56, 0x4b, 0xeb, 0xaa, 0x96, 0x2e, 0x0e, 0xc4, 0x78, 0xaa,
+ 0x7e, 0x0a, 0x95, 0xf4, 0x29, 0xb4, 0x70, 0x10, 0x87, 0xd4, 0x13, 0xa9, 0xbc, 0x42, 0xb6, 0x72,
+ 0xf4, 0x8d, 0x63, 0x24, 0xa9, 0x23, 0xc9, 0x14, 0x86, 0x2e, 0xe0, 0x7c, 0x2c, 0xfd, 0x2c, 0x21,
+ 0x5c, 0xd9, 0x97, 0x32, 0xa4, 0x92, 0xff, 0x30, 0x21, 0xfc, 0x48, 0x31, 0x85, 0xa1, 0x0b, 0x2c,
+ 0x1f, 0xa3, 0x2d, 0x68, 0xea, 0xe6, 0xe3, 0x85, 0x81, 0x53, 0x57, 0x41, 0x34, 0x34, 0x70, 0x10,
+ 0xa0, 0x5d, 0xb0, 0x13, 0x42, 0xb8, 0x70, 0x1a, 0x97, 0x32, 0xab, 0x02, 0x21, 0x84, 0xcb, 0x81,
+ 0xab, 0x35, 0x9b, 0x7b, 0xd0, 0x30, 0x50, 0x79, 0x55, 0xeb, 0xd2, 0xaa, 0x85, 0x64, 0x56, 0x8a,
+ 0xc9, 0x1c, 0xcc, 0xa1, 0x61, 0xb2, 0x23, 0x2f, 0xc7, 0x7c, 0xf2, 0xd9, 0xe4, 0xf0, 0xab, 0x49,
+ 0x6f, 0x0d, 0xf5, 0xa0, 0x3d, 0x9e, 0xbd, 0x18, 0xbb, 0x93, 0xf1, 0xcc, 0x9b, 0x4c, 0x0e, 0x7a,
+ 0x56, 0x09, 0x99, 0x4f, 0x0e, 0x7a, 0x15, 0x69, 0x98, 0x1e, 0x4e, 0xbc, 0xc3, 0xcf, 0x67, 0xbd,
+ 0xf5, 0x7c, 0x32, 0x99, 0xf7, 0xaa, 0x9f, 0xd8, 0x7f, 0x9e, 0xbf, 0xe9, 0xaf, 0x0d, 0x76, 0xc1,
+ 0x96, 0xab, 0x0b, 0x34, 0x28, 0x37, 0x8d, 0x76, 0x31, 0x2a, 0xd3, 0x2e, 0x7e, 0x05, 0xa8, 0xe9,
+ 0x26, 0x82, 0x36, 0x2e, 0xea, 0xdb, 0x14, 0xa0, 0x2c, 0xf3, 0x1b, 0x85, 0x7e, 0x91, 0x13, 0xfa,
+ 0x3f, 0xbd, 0x01, 0x55, 0xce, 0x58, 0x5a, 0xae, 0x6d, 0x05, 0xa1, 0x01, 0x34, 0x13, 0xcc, 0x09,
+ 0x4d, 0x65, 0x62, 0xaa, 0x45, 0x6b, 0x43, 0xe3, 0x2a, 0xeb, 0xdd, 0x4c, 0x63, 0xd2, 0x74, 0x4d,
+ 0xa6, 0x29, 0xaf, 0x7e, 0x4d, 0x4e, 0x75, 0x01, 0xf6, 0xa1, 0xb6, 0x22, 0x34, 0x60, 0x5c, 0x95,
+ 0x4e, 0xbe, 0x5a, 0x06, 0xa2, 0x2d, 0xb0, 0x63, 0x16, 0x90, 0x48, 0x15, 0x46, 0xce, 0x6a, 0x0c,
+ 0xdd, 0x87, 0xde, 0x29, 0xe6, 0xc1, 0x6b, 0xcc, 0x89, 0xb7, 0x22, 0x5c, 0x84, 0x8c, 0xea, 0x12,
+ 0x30, 0xba, 0x2b, 0x86, 0xfe, 0x52, 0xb3, 0xd2, 0xb1, 0x08, 0x79, 0x5c, 0x72, 0x34, 0x4a, 0x0e,
+ 0x43, 0x17, 0x1c, 0x82, 0x2d, 0xd2, 0x92, 0xa3, 0x59, 0x72, 0x18, 0xda, 0x38, 0xee, 0x42, 0x47,
+ 0x10, 0x1e, 0xe2, 0xc8, 0xa3, 0xcb, 0xf8, 0x98, 0x70, 0x07, 0x8a, 0xf2, 0xb6, 0xe6, 0x26, 0x8a,
+ 0x92, 0x8d, 0xc4, 0xbc, 0x53, 0xad, 0xa2, 0x2a, 0x7f, 0xae, 0x10, 0x54, 0x57, 0x11, 0xa6, 0x4e,
+ 0x5b, 0x15, 0x9a, 0x1a, 0xa3, 0x5b, 0xd0, 0x8a, 0xb1, 0x2f, 0x5f, 0x21, 0x4e, 0x84, 0x70, 0x3a,
+ 0xd2, 0xf8, 0x62, 0xcd, 0x85, 0x18, 0xfb, 0x23, 0x8d, 0xa1, 0xdb, 0xd0, 0x0e, 0x93, 0xd5, 0x47,
+ 0xb9, 0xa6, 0x9b, 0x69, 0x5a, 0x12, 0x2d, 0x8b, 0x1e, 0xe5, 0xa2, 0x2b, 0x05, 0xd1, 0x23, 0x23,
+ 0xba, 0x03, 0x9d, 0x53, 0x26, 0x52, 0x0f, 0xd3, 0x40, 0xfd, 0x9d, 0xce, 0x86, 0x51, 0x49, 0x78,
+ 0x44, 0x03, 0x75, 0x5f, 0xf6, 0xa0, 0x93, 0x70, 0xf6, 0xf5, 0x59, 0xbe, 0xd6, 0xff, 0xb6, 0xad,
+ 0x9d, 0xd6, 0x83, 0xad, 0xf2, 0x7b, 0x36, 0x9c, 0x4a, 0x4d, 0xb6, 0xb2, 0xdb, 0x4e, 0x0a, 0xb3,
+ 0xcb, 0x7d, 0xa4, 0xf7, 0x5f, 0xfb, 0xc8, 0xb8, 0xdc, 0x47, 0xae, 0xfe, 0x8b, 0x3e, 0x62, 0x92,
+ 0x5d, 0x6c, 0x27, 0x7d, 0xa8, 0x71, 0x82, 0x05, 0xa3, 0xce, 0xff, 0x4b, 0xe5, 0xa8, 0x41, 0xf4,
+ 0x05, 0x74, 0x7d, 0x46, 0x29, 0xf1, 0x53, 0xb3, 0x11, 0x52, 0x1b, 0xdd, 0x36, 0x1b, 0x3d, 0xd1,
+ 0x6c, 0xb6, 0x57, 0x69, 0x66, 0xd6, 0xea, 0xf8, 0x45, 0x14, 0xbd, 0x0f, 0x35, 0x7f, 0x29, 0x52,
+ 0x16, 0x3b, 0x7b, 0x2a, 0x67, 0xd7, 0x86, 0xfa, 0x53, 0x69, 0x68, 0x3e, 0x95, 0x86, 0x23, 0x7a,
+ 0xe6, 0x66, 0x1a, 0xf4, 0x10, 0x6c, 0xf9, 0x2f, 0x08, 0xe7, 0x9b, 0xbf, 0xb9, 0xfc, 0xfb, 0xdd,
+ 0xdf, 0xce, 0xdf, 0xf4, 0x9b, 0x79, 0x7b, 0x72, 0xb5, 0x16, 0xdd, 0x07, 0x5b, 0x7e, 0xa7, 0x08,
+ 0xe7, 0x5b, 0x4b, 0x6d, 0x81, 0x86, 0xc5, 0x8f, 0x2c, 0xf9, 0x79, 0x22, 0xf6, 0x6d, 0x69, 0x5d,
+ 0x73, 0xb5, 0x10, 0xed, 0x41, 0x4b, 0xd1, 0xd9, 0xc3, 0xf4, 0x9d, 0xf6, 0x5d, 0x7f, 0xcb, 0xa7,
+ 0x1e, 0xa8, 0xdc, 0x0c, 0x8b, 0x1c, 0x42, 0x1f, 0x03, 0x24, 0xb1, 0xe7, 0xeb, 0x37, 0xd6, 0xf9,
+ 0x5e, 0x2f, 0x70, 0xf5, 0xf2, 0x53, 0x95, 0x5b, 0x9b, 0x89, 0x41, 0x36, 0x7f, 0xb0, 0xa0, 0x5d,
+ 0x2c, 0x94, 0x77, 0x37, 0xe3, 0x3e, 0x80, 0x7f, 0x8a, 0x29, 0x25, 0x91, 0x64, 0xb3, 0x0f, 0x86,
+ 0x0c, 0x39, 0x08, 0xd0, 0x06, 0xd4, 0x18, 0x5d, 0x4a, 0x6a, 0x5d, 0x51, 0x36, 0xa3, 0xcb, 0x83,
+ 0x00, 0xdd, 0x81, 0xae, 0x84, 0x05, 0x11, 0xf2, 0xca, 0x9a, 0x5e, 0xd6, 0x71, 0xdb, 0x8c, 0x2e,
+ 0x8f, 0x34, 0x78, 0x10, 0x64, 0x8d, 0x77, 0xbf, 0x29, 0x2f, 0xa9, 0x3a, 0xca, 0xe0, 0x1e, 0xd4,
+ 0x75, 0x29, 0xcb, 0x8b, 0x51, 0xea, 0xc2, 0xdd, 0x72, 0xa9, 0x67, 0x7d, 0xf8, 0xb8, 0xa6, 0xfe,
+ 0xc5, 0x87, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0xa7, 0x33, 0xa2, 0x3e, 0x22, 0x0b, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/events/events.pb.go b/netopeer/voltha-grpc-client/voltha/events/events.pb.go
new file mode 100644
index 0000000..dea9896
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/events/events.pb.go
@@ -0,0 +1,518 @@
+// Code generated by protoc-gen-go.
+// source: events.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+ events.proto
+
+It has these top-level messages:
+ ConfigEventType
+ ConfigEvent
+ KpiEventType
+ MetricValuePairs
+ KpiEvent
+ AlarmEventType
+ AlarmEventCategory
+ AlarmEventState
+ AlarmEventSeverity
+ AlarmEvent
+*/
+package events
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type ConfigEventType_ConfigEventType int32
+
+const (
+ ConfigEventType_add ConfigEventType_ConfigEventType = 0
+ ConfigEventType_remove ConfigEventType_ConfigEventType = 1
+ ConfigEventType_update ConfigEventType_ConfigEventType = 2
+)
+
+var ConfigEventType_ConfigEventType_name = map[int32]string{
+ 0: "add",
+ 1: "remove",
+ 2: "update",
+}
+var ConfigEventType_ConfigEventType_value = map[string]int32{
+ "add": 0,
+ "remove": 1,
+ "update": 2,
+}
+
+func (x ConfigEventType_ConfigEventType) String() string {
+ return proto.EnumName(ConfigEventType_ConfigEventType_name, int32(x))
+}
+func (ConfigEventType_ConfigEventType) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor0, []int{0, 0}
+}
+
+type KpiEventType_KpiEventType int32
+
+const (
+ KpiEventType_slice KpiEventType_KpiEventType = 0
+ KpiEventType_ts KpiEventType_KpiEventType = 1
+)
+
+var KpiEventType_KpiEventType_name = map[int32]string{
+ 0: "slice",
+ 1: "ts",
+}
+var KpiEventType_KpiEventType_value = map[string]int32{
+ "slice": 0,
+ "ts": 1,
+}
+
+func (x KpiEventType_KpiEventType) String() string {
+ return proto.EnumName(KpiEventType_KpiEventType_name, int32(x))
+}
+func (KpiEventType_KpiEventType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
+
+type AlarmEventType_AlarmEventType int32
+
+const (
+ AlarmEventType_COMMUNICATION AlarmEventType_AlarmEventType = 0
+ AlarmEventType_ENVIRONMENT AlarmEventType_AlarmEventType = 1
+ AlarmEventType_EQUIPMENT AlarmEventType_AlarmEventType = 2
+ AlarmEventType_SERVICE AlarmEventType_AlarmEventType = 3
+ AlarmEventType_PROCESSING AlarmEventType_AlarmEventType = 4
+ AlarmEventType_SECURITY AlarmEventType_AlarmEventType = 5
+)
+
+var AlarmEventType_AlarmEventType_name = map[int32]string{
+ 0: "COMMUNICATION",
+ 1: "ENVIRONMENT",
+ 2: "EQUIPMENT",
+ 3: "SERVICE",
+ 4: "PROCESSING",
+ 5: "SECURITY",
+}
+var AlarmEventType_AlarmEventType_value = map[string]int32{
+ "COMMUNICATION": 0,
+ "ENVIRONMENT": 1,
+ "EQUIPMENT": 2,
+ "SERVICE": 3,
+ "PROCESSING": 4,
+ "SECURITY": 5,
+}
+
+func (x AlarmEventType_AlarmEventType) String() string {
+ return proto.EnumName(AlarmEventType_AlarmEventType_name, int32(x))
+}
+func (AlarmEventType_AlarmEventType) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor0, []int{5, 0}
+}
+
+type AlarmEventCategory_AlarmEventCategory int32
+
+const (
+ AlarmEventCategory_PON AlarmEventCategory_AlarmEventCategory = 0
+)
+
+var AlarmEventCategory_AlarmEventCategory_name = map[int32]string{
+ 0: "PON",
+}
+var AlarmEventCategory_AlarmEventCategory_value = map[string]int32{
+ "PON": 0,
+}
+
+func (x AlarmEventCategory_AlarmEventCategory) String() string {
+ return proto.EnumName(AlarmEventCategory_AlarmEventCategory_name, int32(x))
+}
+func (AlarmEventCategory_AlarmEventCategory) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor0, []int{6, 0}
+}
+
+type AlarmEventState_AlarmEventState int32
+
+const (
+ AlarmEventState_RAISED AlarmEventState_AlarmEventState = 0
+ AlarmEventState_CLEARED AlarmEventState_AlarmEventState = 1
+)
+
+var AlarmEventState_AlarmEventState_name = map[int32]string{
+ 0: "RAISED",
+ 1: "CLEARED",
+}
+var AlarmEventState_AlarmEventState_value = map[string]int32{
+ "RAISED": 0,
+ "CLEARED": 1,
+}
+
+func (x AlarmEventState_AlarmEventState) String() string {
+ return proto.EnumName(AlarmEventState_AlarmEventState_name, int32(x))
+}
+func (AlarmEventState_AlarmEventState) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor0, []int{7, 0}
+}
+
+type AlarmEventSeverity_AlarmEventSeverity int32
+
+const (
+ AlarmEventSeverity_INDETERMINATE AlarmEventSeverity_AlarmEventSeverity = 0
+ AlarmEventSeverity_WARNING AlarmEventSeverity_AlarmEventSeverity = 1
+ AlarmEventSeverity_MINOR AlarmEventSeverity_AlarmEventSeverity = 2
+ AlarmEventSeverity_MAJOR AlarmEventSeverity_AlarmEventSeverity = 3
+ AlarmEventSeverity_CRITICAL AlarmEventSeverity_AlarmEventSeverity = 4
+)
+
+var AlarmEventSeverity_AlarmEventSeverity_name = map[int32]string{
+ 0: "INDETERMINATE",
+ 1: "WARNING",
+ 2: "MINOR",
+ 3: "MAJOR",
+ 4: "CRITICAL",
+}
+var AlarmEventSeverity_AlarmEventSeverity_value = map[string]int32{
+ "INDETERMINATE": 0,
+ "WARNING": 1,
+ "MINOR": 2,
+ "MAJOR": 3,
+ "CRITICAL": 4,
+}
+
+func (x AlarmEventSeverity_AlarmEventSeverity) String() string {
+ return proto.EnumName(AlarmEventSeverity_AlarmEventSeverity_name, int32(x))
+}
+func (AlarmEventSeverity_AlarmEventSeverity) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor0, []int{8, 0}
+}
+
+type ConfigEventType struct {
+}
+
+func (m *ConfigEventType) Reset() { *m = ConfigEventType{} }
+func (m *ConfigEventType) String() string { return proto.CompactTextString(m) }
+func (*ConfigEventType) ProtoMessage() {}
+func (*ConfigEventType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type ConfigEvent struct {
+ Type ConfigEventType_ConfigEventType `protobuf:"varint,1,opt,name=type,enum=voltha.ConfigEventType_ConfigEventType" json:"type,omitempty"`
+ Hash string `protobuf:"bytes,2,opt,name=hash" json:"hash,omitempty"`
+ Data string `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"`
+}
+
+func (m *ConfigEvent) Reset() { *m = ConfigEvent{} }
+func (m *ConfigEvent) String() string { return proto.CompactTextString(m) }
+func (*ConfigEvent) ProtoMessage() {}
+func (*ConfigEvent) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *ConfigEvent) GetType() ConfigEventType_ConfigEventType {
+ if m != nil {
+ return m.Type
+ }
+ return ConfigEventType_add
+}
+
+func (m *ConfigEvent) GetHash() string {
+ if m != nil {
+ return m.Hash
+ }
+ return ""
+}
+
+func (m *ConfigEvent) GetData() string {
+ if m != nil {
+ return m.Data
+ }
+ return ""
+}
+
+type KpiEventType struct {
+}
+
+func (m *KpiEventType) Reset() { *m = KpiEventType{} }
+func (m *KpiEventType) String() string { return proto.CompactTextString(m) }
+func (*KpiEventType) ProtoMessage() {}
+func (*KpiEventType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+//
+// Struct to convey a dictionary of metric->value pairs. Typically used in
+// pure shared-timestamp or shared-timestamp + shared object prefix situations.
+type MetricValuePairs struct {
+ // Metric / value pairs.
+ Metrics map[string]float32 `protobuf:"bytes,1,rep,name=metrics" json:"metrics,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+}
+
+func (m *MetricValuePairs) Reset() { *m = MetricValuePairs{} }
+func (m *MetricValuePairs) String() string { return proto.CompactTextString(m) }
+func (*MetricValuePairs) ProtoMessage() {}
+func (*MetricValuePairs) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *MetricValuePairs) GetMetrics() map[string]float32 {
+ if m != nil {
+ return m.Metrics
+ }
+ return nil
+}
+
+type KpiEvent struct {
+ Type KpiEventType_KpiEventType `protobuf:"varint,1,opt,name=type,enum=voltha.KpiEventType_KpiEventType" json:"type,omitempty"`
+ Ts float32 `protobuf:"fixed32,2,opt,name=ts" json:"ts,omitempty"`
+ Prefixes map[string]*MetricValuePairs `protobuf:"bytes,3,rep,name=prefixes" json:"prefixes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (m *KpiEvent) Reset() { *m = KpiEvent{} }
+func (m *KpiEvent) String() string { return proto.CompactTextString(m) }
+func (*KpiEvent) ProtoMessage() {}
+func (*KpiEvent) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *KpiEvent) GetType() KpiEventType_KpiEventType {
+ if m != nil {
+ return m.Type
+ }
+ return KpiEventType_slice
+}
+
+func (m *KpiEvent) GetTs() float32 {
+ if m != nil {
+ return m.Ts
+ }
+ return 0
+}
+
+func (m *KpiEvent) GetPrefixes() map[string]*MetricValuePairs {
+ if m != nil {
+ return m.Prefixes
+ }
+ return nil
+}
+
+//
+// Identify to the area of the system impacted by the alarm
+type AlarmEventType struct {
+}
+
+func (m *AlarmEventType) Reset() { *m = AlarmEventType{} }
+func (m *AlarmEventType) String() string { return proto.CompactTextString(m) }
+func (*AlarmEventType) ProtoMessage() {}
+func (*AlarmEventType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+//
+// Identify to the functional category originating the alarm
+type AlarmEventCategory struct {
+}
+
+func (m *AlarmEventCategory) Reset() { *m = AlarmEventCategory{} }
+func (m *AlarmEventCategory) String() string { return proto.CompactTextString(m) }
+func (*AlarmEventCategory) ProtoMessage() {}
+func (*AlarmEventCategory) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+//
+// Active state of the alarm
+type AlarmEventState struct {
+}
+
+func (m *AlarmEventState) Reset() { *m = AlarmEventState{} }
+func (m *AlarmEventState) String() string { return proto.CompactTextString(m) }
+func (*AlarmEventState) ProtoMessage() {}
+func (*AlarmEventState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+//
+// Identify the overall impact of the alarm on the system
+type AlarmEventSeverity struct {
+}
+
+func (m *AlarmEventSeverity) Reset() { *m = AlarmEventSeverity{} }
+func (m *AlarmEventSeverity) String() string { return proto.CompactTextString(m) }
+func (*AlarmEventSeverity) ProtoMessage() {}
+func (*AlarmEventSeverity) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+//
+//
+type AlarmEvent struct {
+ // Unique ID for this alarm. e.g. voltha.some_olt.1234
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ // Refers to the area of the system impacted by the alarm
+ Type AlarmEventType_AlarmEventType `protobuf:"varint,2,opt,name=type,enum=voltha.AlarmEventType_AlarmEventType" json:"type,omitempty"`
+ // Refers to functional category of the alarm
+ Category AlarmEventCategory_AlarmEventCategory `protobuf:"varint,3,opt,name=category,enum=voltha.AlarmEventCategory_AlarmEventCategory" json:"category,omitempty"`
+ // Current active state of the alarm
+ State AlarmEventState_AlarmEventState `protobuf:"varint,4,opt,name=state,enum=voltha.AlarmEventState_AlarmEventState" json:"state,omitempty"`
+ // Overall impact of the alarm on the system
+ Severity AlarmEventSeverity_AlarmEventSeverity `protobuf:"varint,5,opt,name=severity,enum=voltha.AlarmEventSeverity_AlarmEventSeverity" json:"severity,omitempty"`
+ // Timestamp at which the alarm was first raised
+ RaisedTs float32 `protobuf:"fixed32,6,opt,name=raised_ts,json=raisedTs" json:"raised_ts,omitempty"`
+ // Timestamp at which the alarm was reported
+ ReportedTs float32 `protobuf:"fixed32,7,opt,name=reported_ts,json=reportedTs" json:"reported_ts,omitempty"`
+ // Timestamp at which the alarm has changed since it was raised
+ ChangedTs float32 `protobuf:"fixed32,8,opt,name=changed_ts,json=changedTs" json:"changed_ts,omitempty"`
+ // Identifier of the originating resource of the alarm
+ ResourceId string `protobuf:"bytes,9,opt,name=resource_id,json=resourceId" json:"resource_id,omitempty"`
+ // Textual explanation of the alarm
+ Description string `protobuf:"bytes,10,opt,name=description" json:"description,omitempty"`
+ // Key/Value storage for extra information that may give context to the alarm
+ Context map[string]string `protobuf:"bytes,11,rep,name=context" json:"context,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (m *AlarmEvent) Reset() { *m = AlarmEvent{} }
+func (m *AlarmEvent) String() string { return proto.CompactTextString(m) }
+func (*AlarmEvent) ProtoMessage() {}
+func (*AlarmEvent) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
+
+func (m *AlarmEvent) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *AlarmEvent) GetType() AlarmEventType_AlarmEventType {
+ if m != nil {
+ return m.Type
+ }
+ return AlarmEventType_COMMUNICATION
+}
+
+func (m *AlarmEvent) GetCategory() AlarmEventCategory_AlarmEventCategory {
+ if m != nil {
+ return m.Category
+ }
+ return AlarmEventCategory_PON
+}
+
+func (m *AlarmEvent) GetState() AlarmEventState_AlarmEventState {
+ if m != nil {
+ return m.State
+ }
+ return AlarmEventState_RAISED
+}
+
+func (m *AlarmEvent) GetSeverity() AlarmEventSeverity_AlarmEventSeverity {
+ if m != nil {
+ return m.Severity
+ }
+ return AlarmEventSeverity_INDETERMINATE
+}
+
+func (m *AlarmEvent) GetRaisedTs() float32 {
+ if m != nil {
+ return m.RaisedTs
+ }
+ return 0
+}
+
+func (m *AlarmEvent) GetReportedTs() float32 {
+ if m != nil {
+ return m.ReportedTs
+ }
+ return 0
+}
+
+func (m *AlarmEvent) GetChangedTs() float32 {
+ if m != nil {
+ return m.ChangedTs
+ }
+ return 0
+}
+
+func (m *AlarmEvent) GetResourceId() string {
+ if m != nil {
+ return m.ResourceId
+ }
+ return ""
+}
+
+func (m *AlarmEvent) GetDescription() string {
+ if m != nil {
+ return m.Description
+ }
+ return ""
+}
+
+func (m *AlarmEvent) GetContext() map[string]string {
+ if m != nil {
+ return m.Context
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*ConfigEventType)(nil), "voltha.ConfigEventType")
+ proto.RegisterType((*ConfigEvent)(nil), "voltha.ConfigEvent")
+ proto.RegisterType((*KpiEventType)(nil), "voltha.KpiEventType")
+ proto.RegisterType((*MetricValuePairs)(nil), "voltha.MetricValuePairs")
+ proto.RegisterType((*KpiEvent)(nil), "voltha.KpiEvent")
+ proto.RegisterType((*AlarmEventType)(nil), "voltha.AlarmEventType")
+ proto.RegisterType((*AlarmEventCategory)(nil), "voltha.AlarmEventCategory")
+ proto.RegisterType((*AlarmEventState)(nil), "voltha.AlarmEventState")
+ proto.RegisterType((*AlarmEventSeverity)(nil), "voltha.AlarmEventSeverity")
+ proto.RegisterType((*AlarmEvent)(nil), "voltha.AlarmEvent")
+ proto.RegisterEnum("voltha.ConfigEventType_ConfigEventType", ConfigEventType_ConfigEventType_name, ConfigEventType_ConfigEventType_value)
+ proto.RegisterEnum("voltha.KpiEventType_KpiEventType", KpiEventType_KpiEventType_name, KpiEventType_KpiEventType_value)
+ proto.RegisterEnum("voltha.AlarmEventType_AlarmEventType", AlarmEventType_AlarmEventType_name, AlarmEventType_AlarmEventType_value)
+ proto.RegisterEnum("voltha.AlarmEventCategory_AlarmEventCategory", AlarmEventCategory_AlarmEventCategory_name, AlarmEventCategory_AlarmEventCategory_value)
+ proto.RegisterEnum("voltha.AlarmEventState_AlarmEventState", AlarmEventState_AlarmEventState_name, AlarmEventState_AlarmEventState_value)
+ proto.RegisterEnum("voltha.AlarmEventSeverity_AlarmEventSeverity", AlarmEventSeverity_AlarmEventSeverity_name, AlarmEventSeverity_AlarmEventSeverity_value)
+}
+
+func init() { proto.RegisterFile("events.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 775 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x55, 0xef, 0x6e, 0xe3, 0x44,
+ 0x10, 0xaf, 0x9d, 0xbf, 0x1e, 0xb7, 0xe9, 0xb2, 0xe2, 0x83, 0x55, 0x38, 0xae, 0x67, 0x09, 0x51,
+ 0x21, 0x91, 0x13, 0x39, 0x21, 0x71, 0x45, 0x27, 0x64, 0xb9, 0x2b, 0x64, 0xb8, 0x38, 0x61, 0xe3,
+ 0x16, 0xf8, 0x74, 0x5a, 0xe2, 0xbd, 0xd4, 0x22, 0xb5, 0x2d, 0xef, 0x36, 0xba, 0x7c, 0xe3, 0x0d,
+ 0x78, 0x28, 0x5e, 0x85, 0x07, 0x41, 0xbb, 0xb6, 0x1b, 0xc7, 0x4d, 0x75, 0xdf, 0x66, 0x7e, 0xf3,
+ 0xc7, 0xf3, 0x9b, 0x9d, 0x19, 0xc3, 0x31, 0xdf, 0xf0, 0x54, 0x8a, 0x71, 0x5e, 0x64, 0x32, 0xc3,
+ 0xfd, 0x4d, 0xb6, 0x96, 0xb7, 0xec, 0x0c, 0xee, 0xb8, 0x64, 0x25, 0x76, 0xf6, 0xf9, 0x2a, 0xcb,
+ 0x56, 0x6b, 0xfe, 0x92, 0xe5, 0xc9, 0x4b, 0x96, 0xa6, 0x99, 0x64, 0x32, 0xc9, 0xd2, 0x2a, 0xc2,
+ 0x25, 0x70, 0xea, 0x67, 0xe9, 0xfb, 0x64, 0x45, 0x54, 0x9e, 0x68, 0x9b, 0x73, 0x77, 0xf2, 0x08,
+ 0xc2, 0x03, 0xe8, 0xb0, 0x38, 0x46, 0x47, 0x18, 0xa0, 0x5f, 0xf0, 0xbb, 0x6c, 0xc3, 0x91, 0xa1,
+ 0xe4, 0xfb, 0x3c, 0x66, 0x92, 0x23, 0xd3, 0x2d, 0xc0, 0x6e, 0xc4, 0xe0, 0x1f, 0xa0, 0x2b, 0xb7,
+ 0x39, 0x77, 0x8c, 0x73, 0xe3, 0x62, 0x34, 0xf9, 0x6a, 0x5c, 0x96, 0x35, 0x6e, 0xa5, 0x6d, 0xeb,
+ 0x54, 0x07, 0x61, 0x0c, 0xdd, 0x5b, 0x26, 0x6e, 0x1d, 0xf3, 0xdc, 0xb8, 0xb0, 0xa8, 0x96, 0x15,
+ 0x16, 0x33, 0xc9, 0x9c, 0x4e, 0x89, 0x29, 0xd9, 0xfd, 0x16, 0x8e, 0x7f, 0xc9, 0x93, 0x5d, 0xdd,
+ 0x2f, 0xf6, 0x75, 0x6c, 0x41, 0x4f, 0xac, 0x93, 0x25, 0x47, 0x47, 0xb8, 0x0f, 0xa6, 0x14, 0xc8,
+ 0x70, 0xff, 0x31, 0x00, 0x4d, 0xb9, 0x2c, 0x92, 0xe5, 0x0d, 0x5b, 0xdf, 0xf3, 0x39, 0x4b, 0x0a,
+ 0x81, 0x7f, 0x84, 0xc1, 0x9d, 0xc6, 0x84, 0x63, 0x9c, 0x77, 0x2e, 0xec, 0xc9, 0x97, 0x75, 0xbd,
+ 0x6d, 0xd7, 0x0a, 0x10, 0x24, 0x95, 0xc5, 0x96, 0xd6, 0x51, 0x67, 0x97, 0x70, 0xdc, 0x34, 0x60,
+ 0x04, 0x9d, 0xbf, 0xf8, 0x56, 0x93, 0xb7, 0xa8, 0x12, 0xf1, 0xa7, 0xd0, 0xdb, 0xa8, 0x2c, 0x9a,
+ 0x93, 0x49, 0x4b, 0xe5, 0xd2, 0xfc, 0xde, 0x70, 0xff, 0x33, 0x60, 0x58, 0x57, 0x8d, 0xbf, 0xdb,
+ 0x6b, 0xdb, 0x8b, 0xba, 0x8c, 0x26, 0xab, 0x3d, 0xa5, 0x6a, 0xd8, 0x48, 0xb1, 0xab, 0x52, 0x9b,
+ 0x52, 0xe0, 0x4b, 0x18, 0xe6, 0x05, 0x7f, 0x9f, 0x7c, 0xe0, 0xc2, 0xe9, 0x68, 0x46, 0x5f, 0xb4,
+ 0x53, 0x8d, 0xe7, 0x95, 0x43, 0x49, 0xe5, 0xc1, 0xff, 0xec, 0x1a, 0x4e, 0xf6, 0x4c, 0x07, 0xc8,
+ 0x8c, 0x9b, 0x64, 0xec, 0x89, 0xf3, 0x54, 0xb7, 0x9a, 0x34, 0xff, 0x36, 0x60, 0xe4, 0xad, 0x59,
+ 0x71, 0xb7, 0x7b, 0xae, 0xb4, 0x8d, 0xe0, 0x4f, 0xe0, 0xc4, 0x9f, 0x4d, 0xa7, 0xd7, 0x61, 0xe0,
+ 0x7b, 0x51, 0x30, 0x0b, 0xd1, 0x11, 0x3e, 0x05, 0x9b, 0x84, 0x37, 0x01, 0x9d, 0x85, 0x53, 0x12,
+ 0x46, 0xc8, 0xc0, 0x27, 0x60, 0x91, 0x5f, 0xaf, 0x83, 0xb9, 0x56, 0x4d, 0x6c, 0xc3, 0x60, 0x41,
+ 0xe8, 0x4d, 0xe0, 0x13, 0xd4, 0xc1, 0x23, 0x80, 0x39, 0x9d, 0xf9, 0x64, 0xb1, 0x08, 0xc2, 0x9f,
+ 0x50, 0x17, 0x1f, 0xc3, 0x70, 0x41, 0xfc, 0x6b, 0x1a, 0x44, 0x7f, 0xa0, 0x9e, 0xfb, 0x0a, 0xf0,
+ 0xee, 0x7b, 0x3e, 0x93, 0x7c, 0x95, 0x15, 0x5b, 0xf7, 0xd9, 0x21, 0x54, 0xcd, 0xfb, 0x5c, 0x7d,
+ 0xdf, 0x7d, 0x03, 0xa7, 0x3b, 0xf3, 0x42, 0x32, 0xc9, 0xdd, 0xaf, 0x1f, 0x41, 0x6a, 0x13, 0xa8,
+ 0x17, 0x2c, 0xc8, 0x15, 0x3a, 0x52, 0x15, 0xf9, 0x6f, 0x89, 0x47, 0xc9, 0x15, 0x32, 0xdc, 0xb4,
+ 0x99, 0x7d, 0xc1, 0x37, 0xbc, 0x48, 0xe4, 0xd6, 0xfd, 0xfd, 0x10, 0xaa, 0xd8, 0x07, 0xe1, 0x15,
+ 0x89, 0x08, 0x9d, 0x06, 0xa1, 0x17, 0x91, 0x32, 0xd7, 0x6f, 0x1e, 0x0d, 0x15, 0x1b, 0x43, 0x8d,
+ 0xf3, 0x34, 0x08, 0x67, 0x14, 0x99, 0x5a, 0xf4, 0x7e, 0x9e, 0x51, 0xd4, 0x51, 0x1c, 0x7d, 0x1a,
+ 0x44, 0x81, 0xef, 0xbd, 0x45, 0x5d, 0xf7, 0xdf, 0x2e, 0xc0, 0x2e, 0xb5, 0x1a, 0x8c, 0x24, 0xae,
+ 0x9e, 0xce, 0x4c, 0x62, 0xfc, 0xba, 0x9a, 0x2f, 0x53, 0xcf, 0xd7, 0xc3, 0x98, 0xef, 0x3f, 0x43,
+ 0x4b, 0xad, 0x66, 0x2c, 0x80, 0xe1, 0xb2, 0xea, 0x8e, 0x5e, 0xc2, 0xd1, 0xe4, 0x9b, 0xc7, 0xe1,
+ 0x75, 0xff, 0x0e, 0x40, 0xf4, 0x21, 0x1c, 0xbf, 0x81, 0x9e, 0x50, 0x6d, 0x73, 0xba, 0xfb, 0xd7,
+ 0xa1, 0xd5, 0xd5, 0xb6, 0x4e, 0xcb, 0x28, 0x55, 0x89, 0xa8, 0x7a, 0xe6, 0xf4, 0x9e, 0xaa, 0xa4,
+ 0xee, 0xea, 0x01, 0x88, 0x3e, 0x84, 0xe3, 0xcf, 0xc0, 0x2a, 0x58, 0x22, 0x78, 0xfc, 0x4e, 0x0a,
+ 0xa7, 0xaf, 0xf7, 0x67, 0x58, 0x02, 0x91, 0xc0, 0xcf, 0xc1, 0x2e, 0x78, 0x9e, 0x15, 0xb2, 0x34,
+ 0x0f, 0xb4, 0x19, 0x6a, 0x28, 0x12, 0xf8, 0x19, 0xc0, 0xf2, 0x96, 0xa5, 0xab, 0xd2, 0x3e, 0xd4,
+ 0x76, 0xab, 0x42, 0xea, 0x78, 0x91, 0xdd, 0x17, 0x4b, 0xfe, 0x2e, 0x89, 0x1d, 0x4b, 0xbf, 0x02,
+ 0xd4, 0x50, 0x10, 0xe3, 0x73, 0xb0, 0x63, 0x2e, 0x96, 0x45, 0x92, 0xab, 0x83, 0xec, 0x80, 0x76,
+ 0x68, 0x42, 0xf8, 0x35, 0x0c, 0x96, 0x59, 0x2a, 0xf9, 0x07, 0xe9, 0xd8, 0x7a, 0x8f, 0x9f, 0x3f,
+ 0x66, 0xaa, 0x8e, 0xa8, 0xf2, 0xa8, 0x6e, 0x52, 0xe5, 0xaf, 0x6e, 0x52, 0xd3, 0xf0, 0xb1, 0x9b,
+ 0x64, 0x35, 0x96, 0xf5, 0xcf, 0xbe, 0xfe, 0x35, 0xbc, 0xfa, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x27,
+ 0x78, 0x37, 0x67, 0x5c, 0x06, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/health/health.pb.go b/netopeer/voltha-grpc-client/voltha/health/health.pb.go
new file mode 100644
index 0000000..cf98267
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/health/health.pb.go
@@ -0,0 +1,179 @@
+// Code generated by protoc-gen-go.
+// source: health.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+ health.proto
+
+It has these top-level messages:
+ HealthStatus
+*/
+package health
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf1 "github.com/golang/protobuf/ptypes/empty"
+
+import (
+ context "golang.org/x/net/context"
+ grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Health states
+type HealthStatus_HealthState int32
+
+const (
+ HealthStatus_HEALTHY HealthStatus_HealthState = 0
+ HealthStatus_OVERLOADED HealthStatus_HealthState = 1
+ HealthStatus_DYING HealthStatus_HealthState = 2
+)
+
+var HealthStatus_HealthState_name = map[int32]string{
+ 0: "HEALTHY",
+ 1: "OVERLOADED",
+ 2: "DYING",
+}
+var HealthStatus_HealthState_value = map[string]int32{
+ "HEALTHY": 0,
+ "OVERLOADED": 1,
+ "DYING": 2,
+}
+
+func (x HealthStatus_HealthState) String() string {
+ return proto.EnumName(HealthStatus_HealthState_name, int32(x))
+}
+func (HealthStatus_HealthState) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }
+
+// Encode health status of a Voltha instance
+type HealthStatus struct {
+ // Current state of health of this Voltha instance
+ State HealthStatus_HealthState `protobuf:"varint,1,opt,name=state,enum=voltha.HealthStatus_HealthState" json:"state,omitempty"`
+}
+
+func (m *HealthStatus) Reset() { *m = HealthStatus{} }
+func (m *HealthStatus) String() string { return proto.CompactTextString(m) }
+func (*HealthStatus) ProtoMessage() {}
+func (*HealthStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *HealthStatus) GetState() HealthStatus_HealthState {
+ if m != nil {
+ return m.State
+ }
+ return HealthStatus_HEALTHY
+}
+
+func init() {
+ proto.RegisterType((*HealthStatus)(nil), "voltha.HealthStatus")
+ proto.RegisterEnum("voltha.HealthStatus_HealthState", HealthStatus_HealthState_name, HealthStatus_HealthState_value)
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for HealthService service
+
+type HealthServiceClient interface {
+ // Return current health status of a Voltha instance
+ GetHealthStatus(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*HealthStatus, error)
+}
+
+type healthServiceClient struct {
+ cc *grpc.ClientConn
+}
+
+func NewHealthServiceClient(cc *grpc.ClientConn) HealthServiceClient {
+ return &healthServiceClient{cc}
+}
+
+func (c *healthServiceClient) GetHealthStatus(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*HealthStatus, error) {
+ out := new(HealthStatus)
+ err := grpc.Invoke(ctx, "/voltha.HealthService/GetHealthStatus", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// Server API for HealthService service
+
+type HealthServiceServer interface {
+ // Return current health status of a Voltha instance
+ GetHealthStatus(context.Context, *google_protobuf1.Empty) (*HealthStatus, error)
+}
+
+func RegisterHealthServiceServer(s *grpc.Server, srv HealthServiceServer) {
+ s.RegisterService(&_HealthService_serviceDesc, srv)
+}
+
+func _HealthService_GetHealthStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf1.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(HealthServiceServer).GetHealthStatus(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.HealthService/GetHealthStatus",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(HealthServiceServer).GetHealthStatus(ctx, req.(*google_protobuf1.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _HealthService_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "voltha.HealthService",
+ HandlerType: (*HealthServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "GetHealthStatus",
+ Handler: _HealthService_GetHealthStatus_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "health.proto",
+}
+
+func init() { proto.RegisterFile("health.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 248 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xc9, 0x48, 0x4d, 0xcc,
+ 0x29, 0xc9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2b, 0xcb, 0xcf, 0x29, 0xc9, 0x48,
+ 0x94, 0x92, 0x49, 0xcf, 0xcf, 0x4f, 0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x4f, 0xcc, 0xcb,
+ 0xcb, 0x2f, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0x2b, 0x86, 0xa8, 0x92, 0x92, 0x86, 0xca, 0x82, 0x79,
+ 0x49, 0xa5, 0x69, 0xfa, 0xa9, 0xb9, 0x05, 0x25, 0x95, 0x50, 0x49, 0xae, 0xdc, 0xd4, 0x92, 0x44,
+ 0x08, 0x5b, 0xa9, 0x85, 0x91, 0x8b, 0xc7, 0x03, 0x6c, 0x7e, 0x70, 0x49, 0x62, 0x49, 0x69, 0xb1,
+ 0x90, 0x2d, 0x17, 0x6b, 0x71, 0x49, 0x62, 0x49, 0xaa, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x9f, 0x91,
+ 0x82, 0x1e, 0xc4, 0x3e, 0x3d, 0x64, 0x45, 0x48, 0x9c, 0x54, 0x27, 0xd6, 0x17, 0xdf, 0xce, 0xca,
+ 0x32, 0x06, 0x41, 0x74, 0x29, 0x99, 0x72, 0x71, 0x23, 0x49, 0x0a, 0x71, 0x73, 0xb1, 0x7b, 0xb8,
+ 0x3a, 0xfa, 0x84, 0x78, 0x44, 0x0a, 0x30, 0x08, 0xf1, 0x71, 0x71, 0xf9, 0x87, 0xb9, 0x06, 0xf9,
+ 0xf8, 0x3b, 0xba, 0xb8, 0xba, 0x08, 0x30, 0x0a, 0x71, 0x72, 0xb1, 0xba, 0x44, 0x7a, 0xfa, 0xb9,
+ 0x0b, 0x30, 0x19, 0x25, 0x72, 0xf1, 0x42, 0xb5, 0xa5, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x0a, 0x05,
+ 0x70, 0xf1, 0xbb, 0xa7, 0x96, 0xa0, 0xb8, 0x4c, 0x4c, 0x0f, 0xe2, 0x29, 0x3d, 0x98, 0xa7, 0xf4,
+ 0x5c, 0x41, 0x9e, 0x92, 0x12, 0xc1, 0xe6, 0x44, 0x25, 0xfe, 0xa6, 0xcb, 0x4f, 0x26, 0x33, 0x71,
+ 0x0a, 0xb1, 0xeb, 0x43, 0x82, 0x2f, 0x89, 0x0d, 0xac, 0xcd, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff,
+ 0x59, 0x30, 0x7e, 0x18, 0x4f, 0x01, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/logical_device/logical_device.pb.go b/netopeer/voltha-grpc-client/voltha/logical_device/logical_device.pb.go
new file mode 100644
index 0000000..04bde69
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/logical_device/logical_device.pb.go
@@ -0,0 +1,234 @@
+// Code generated by protoc-gen-go.
+// source: logical_device.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+ logical_device.proto
+
+It has these top-level messages:
+ LogicalPort
+ LogicalPorts
+ LogicalDevice
+ LogicalDevices
+*/
+package logical_device
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import openflow_13 "github.com/opencord/voltha/netconf/translator/voltha/openflow_13"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type LogicalPort struct {
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ OfpPort *openflow_13.OfpPort `protobuf:"bytes,2,opt,name=ofp_port,json=ofpPort" json:"ofp_port,omitempty"`
+ DeviceId string `protobuf:"bytes,3,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
+ DevicePortNo uint32 `protobuf:"varint,4,opt,name=device_port_no,json=devicePortNo" json:"device_port_no,omitempty"`
+ RootPort bool `protobuf:"varint,5,opt,name=root_port,json=rootPort" json:"root_port,omitempty"`
+}
+
+func (m *LogicalPort) Reset() { *m = LogicalPort{} }
+func (m *LogicalPort) String() string { return proto.CompactTextString(m) }
+func (*LogicalPort) ProtoMessage() {}
+func (*LogicalPort) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *LogicalPort) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *LogicalPort) GetOfpPort() *openflow_13.OfpPort {
+ if m != nil {
+ return m.OfpPort
+ }
+ return nil
+}
+
+func (m *LogicalPort) GetDeviceId() string {
+ if m != nil {
+ return m.DeviceId
+ }
+ return ""
+}
+
+func (m *LogicalPort) GetDevicePortNo() uint32 {
+ if m != nil {
+ return m.DevicePortNo
+ }
+ return 0
+}
+
+func (m *LogicalPort) GetRootPort() bool {
+ if m != nil {
+ return m.RootPort
+ }
+ return false
+}
+
+type LogicalPorts struct {
+ Items []*LogicalPort `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *LogicalPorts) Reset() { *m = LogicalPorts{} }
+func (m *LogicalPorts) String() string { return proto.CompactTextString(m) }
+func (*LogicalPorts) ProtoMessage() {}
+func (*LogicalPorts) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *LogicalPorts) GetItems() []*LogicalPort {
+ if m != nil {
+ return m.Items
+ }
+ return nil
+}
+
+type LogicalDevice struct {
+ // unique id of logical device
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ // unique datapath id for the logical device (used by the SDN controller)
+ DatapathId uint64 `protobuf:"varint,2,opt,name=datapath_id,json=datapathId" json:"datapath_id,omitempty"`
+ // device description
+ Desc *openflow_13.OfpDesc `protobuf:"bytes,3,opt,name=desc" json:"desc,omitempty"`
+ // device features
+ SwitchFeatures *openflow_13.OfpSwitchFeatures `protobuf:"bytes,4,opt,name=switch_features,json=switchFeatures" json:"switch_features,omitempty"`
+ // name of the root device anchoring logical device
+ RootDeviceId string `protobuf:"bytes,5,opt,name=root_device_id,json=rootDeviceId" json:"root_device_id,omitempty"`
+ // logical device ports
+ Ports []*LogicalPort `protobuf:"bytes,128,rep,name=ports" json:"ports,omitempty"`
+ // flows configured on the logical device
+ Flows *openflow_13.Flows `protobuf:"bytes,129,opt,name=flows" json:"flows,omitempty"`
+ // flow groups configured on the logical device
+ FlowGroups *openflow_13.FlowGroups `protobuf:"bytes,130,opt,name=flow_groups,json=flowGroups" json:"flow_groups,omitempty"`
+}
+
+func (m *LogicalDevice) Reset() { *m = LogicalDevice{} }
+func (m *LogicalDevice) String() string { return proto.CompactTextString(m) }
+func (*LogicalDevice) ProtoMessage() {}
+func (*LogicalDevice) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *LogicalDevice) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *LogicalDevice) GetDatapathId() uint64 {
+ if m != nil {
+ return m.DatapathId
+ }
+ return 0
+}
+
+func (m *LogicalDevice) GetDesc() *openflow_13.OfpDesc {
+ if m != nil {
+ return m.Desc
+ }
+ return nil
+}
+
+func (m *LogicalDevice) GetSwitchFeatures() *openflow_13.OfpSwitchFeatures {
+ if m != nil {
+ return m.SwitchFeatures
+ }
+ return nil
+}
+
+func (m *LogicalDevice) GetRootDeviceId() string {
+ if m != nil {
+ return m.RootDeviceId
+ }
+ return ""
+}
+
+func (m *LogicalDevice) GetPorts() []*LogicalPort {
+ if m != nil {
+ return m.Ports
+ }
+ return nil
+}
+
+func (m *LogicalDevice) GetFlows() *openflow_13.Flows {
+ if m != nil {
+ return m.Flows
+ }
+ return nil
+}
+
+func (m *LogicalDevice) GetFlowGroups() *openflow_13.FlowGroups {
+ if m != nil {
+ return m.FlowGroups
+ }
+ return nil
+}
+
+type LogicalDevices struct {
+ Items []*LogicalDevice `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *LogicalDevices) Reset() { *m = LogicalDevices{} }
+func (m *LogicalDevices) String() string { return proto.CompactTextString(m) }
+func (*LogicalDevices) ProtoMessage() {}
+func (*LogicalDevices) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *LogicalDevices) GetItems() []*LogicalDevice {
+ if m != nil {
+ return m.Items
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*LogicalPort)(nil), "voltha.LogicalPort")
+ proto.RegisterType((*LogicalPorts)(nil), "voltha.LogicalPorts")
+ proto.RegisterType((*LogicalDevice)(nil), "voltha.LogicalDevice")
+ proto.RegisterType((*LogicalDevices)(nil), "voltha.LogicalDevices")
+}
+
+func init() { proto.RegisterFile("logical_device.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 438 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x52, 0xd1, 0x6e, 0xd3, 0x30,
+ 0x14, 0xc5, 0x6d, 0x33, 0xda, 0x9b, 0xae, 0x08, 0xc3, 0x84, 0x35, 0x40, 0x44, 0x15, 0x0f, 0x99,
+ 0x90, 0xba, 0xd1, 0x89, 0x07, 0x1e, 0x90, 0xd0, 0x34, 0x0d, 0x55, 0x42, 0x08, 0xf9, 0x07, 0x22,
+ 0x53, 0x3b, 0xad, 0xa5, 0x2c, 0xd7, 0x8a, 0xbd, 0xed, 0x15, 0x78, 0xe1, 0x73, 0xf8, 0x12, 0x7e,
+ 0x82, 0x8f, 0xe0, 0x19, 0xd9, 0x4e, 0xa0, 0x5d, 0xe1, 0x31, 0xe7, 0x9c, 0x7b, 0x7c, 0xee, 0xb9,
+ 0x81, 0x87, 0x15, 0xae, 0xf4, 0x52, 0x54, 0x85, 0x54, 0xd7, 0x7a, 0xa9, 0x66, 0xa6, 0x41, 0x87,
+ 0x74, 0xef, 0x1a, 0x2b, 0xb7, 0x16, 0x87, 0x70, 0xa9, 0x9c, 0x88, 0xd8, 0xe1, 0x93, 0x15, 0xe2,
+ 0xaa, 0x52, 0xc7, 0xc2, 0xe8, 0x63, 0x51, 0xd7, 0xe8, 0x84, 0xd3, 0x58, 0xdb, 0x96, 0xbd, 0x8f,
+ 0x46, 0xd5, 0x65, 0x85, 0x37, 0xc5, 0xcb, 0xd3, 0x08, 0x4d, 0xbf, 0x13, 0x48, 0xdf, 0x47, 0xf7,
+ 0x8f, 0xd8, 0x38, 0x3a, 0x81, 0x9e, 0x96, 0x8c, 0x64, 0x24, 0x1f, 0xf1, 0x9e, 0x96, 0xf4, 0x04,
+ 0x86, 0x58, 0x9a, 0xc2, 0x60, 0xe3, 0x58, 0x2f, 0x23, 0x79, 0x3a, 0x3f, 0x98, 0x6d, 0xba, 0x74,
+ 0x24, 0xbf, 0x8b, 0xa5, 0x09, 0x0e, 0x8f, 0x61, 0x14, 0x63, 0x16, 0x5a, 0xb2, 0x7e, 0x30, 0x1a,
+ 0x46, 0x60, 0x21, 0xe9, 0x73, 0x98, 0xb4, 0xa4, 0x1f, 0x2a, 0x6a, 0x64, 0x83, 0x8c, 0xe4, 0xfb,
+ 0x7c, 0x1c, 0x51, 0x6f, 0xf0, 0x01, 0xbd, 0x45, 0x83, 0xe8, 0xe2, 0xab, 0x49, 0x46, 0xf2, 0x21,
+ 0x1f, 0x7a, 0xc0, 0xd3, 0xd3, 0xd7, 0x30, 0xde, 0x08, 0x6c, 0xe9, 0x11, 0x24, 0xda, 0xa9, 0x4b,
+ 0xcb, 0x48, 0xd6, 0xcf, 0xd3, 0xf9, 0x83, 0x59, 0xac, 0x65, 0xb6, 0x21, 0xe2, 0x51, 0x31, 0xfd,
+ 0xd6, 0x87, 0xfd, 0x16, 0x3e, 0x0f, 0xef, 0xed, 0xac, 0xfb, 0x0c, 0x52, 0x29, 0x9c, 0x30, 0xc2,
+ 0xad, 0x7d, 0x7c, 0xbf, 0xf1, 0x80, 0x43, 0x07, 0x2d, 0x24, 0x3d, 0x82, 0x81, 0x54, 0x76, 0x19,
+ 0x16, 0xfb, 0x57, 0x17, 0x9e, 0xe4, 0x41, 0x42, 0x17, 0x70, 0xcf, 0xde, 0x68, 0xb7, 0x5c, 0x17,
+ 0xa5, 0x12, 0xee, 0xaa, 0x51, 0x36, 0x2c, 0x9b, 0xce, 0xb3, 0x9d, 0xa9, 0x5b, 0x3a, 0x3e, 0x89,
+ 0xc0, 0x45, 0xfb, 0xed, 0x6b, 0x0b, 0x85, 0xfc, 0x2d, 0x36, 0x09, 0x91, 0xc7, 0x1e, 0x3d, 0xef,
+ 0xca, 0x7d, 0x05, 0x89, 0x6f, 0xcc, 0xb2, 0xcf, 0xff, 0xaf, 0xe2, 0x6c, 0xf4, 0xf3, 0xd7, 0x8f,
+ 0xa7, 0x03, 0xbf, 0x36, 0x8f, 0x6a, 0x7a, 0x02, 0x89, 0xcf, 0x62, 0xd9, 0x17, 0x12, 0xe2, 0xd1,
+ 0xad, 0x78, 0x17, 0x9e, 0x3a, 0x4b, 0xfc, 0xd4, 0x1d, 0x1e, 0x85, 0xf4, 0x2d, 0xa4, 0x81, 0x5e,
+ 0x35, 0x78, 0x65, 0x2c, 0xfb, 0x1a, 0xe7, 0x1e, 0xed, 0xcc, 0xbd, 0x0b, 0x7c, 0x37, 0x0c, 0xe5,
+ 0x1f, 0x68, 0xfa, 0x06, 0x26, 0x5b, 0x87, 0xb0, 0xf4, 0xc5, 0xf6, 0x19, 0x0f, 0x6e, 0x65, 0x8f,
+ 0xb2, 0xf6, 0x90, 0x9f, 0xf6, 0xc2, 0xcf, 0x7b, 0xfa, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x24, 0xce,
+ 0xf3, 0x88, 0x19, 0x03, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/meta/meta.pb.go b/netopeer/voltha-grpc-client/voltha/meta/meta.pb.go
new file mode 100644
index 0000000..f4ab63c
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/meta/meta.pb.go
@@ -0,0 +1,120 @@
+// Code generated by protoc-gen-go.
+// source: meta.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+ meta.proto
+
+It has these top-level messages:
+ ChildNode
+*/
+package meta
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Access int32
+
+const (
+ // read-write, stored attribute
+ Access_CONFIG Access = 0
+ // read-only field, stored with the model, covered by its hash
+ Access_READ_ONLY Access = 1
+ // A read-only attribute that is not stored in the model, not covered
+ // by its hash, its value is filled real-time upon each request.
+ Access_REAL_TIME Access = 2
+)
+
+var Access_name = map[int32]string{
+ 0: "CONFIG",
+ 1: "READ_ONLY",
+ 2: "REAL_TIME",
+}
+var Access_value = map[string]int32{
+ "CONFIG": 0,
+ "READ_ONLY": 1,
+ "REAL_TIME": 2,
+}
+
+func (x Access) String() string {
+ return proto.EnumName(Access_name, int32(x))
+}
+func (Access) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type ChildNode struct {
+ Key string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+}
+
+func (m *ChildNode) Reset() { *m = ChildNode{} }
+func (m *ChildNode) String() string { return proto.CompactTextString(m) }
+func (*ChildNode) ProtoMessage() {}
+func (*ChildNode) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *ChildNode) GetKey() string {
+ if m != nil {
+ return m.Key
+ }
+ return ""
+}
+
+var E_ChildNode = &proto.ExtensionDesc{
+ ExtendedType: (*google_protobuf.FieldOptions)(nil),
+ ExtensionType: (*ChildNode)(nil),
+ Field: 7761772,
+ Name: "voltha.child_node",
+ Tag: "bytes,7761772,opt,name=child_node,json=childNode",
+ Filename: "meta.proto",
+}
+
+var E_Access = &proto.ExtensionDesc{
+ ExtendedType: (*google_protobuf.FieldOptions)(nil),
+ ExtensionType: (*Access)(nil),
+ Field: 7761773,
+ Name: "voltha.access",
+ Tag: "varint,7761773,opt,name=access,enum=voltha.Access",
+ Filename: "meta.proto",
+}
+
+func init() {
+ proto.RegisterType((*ChildNode)(nil), "voltha.ChildNode")
+ proto.RegisterEnum("voltha.Access", Access_name, Access_value)
+ proto.RegisterExtension(E_ChildNode)
+ proto.RegisterExtension(E_Access)
+}
+
+func init() { proto.RegisterFile("meta.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 229 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xca, 0x4d, 0x2d, 0x49,
+ 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2b, 0xcb, 0xcf, 0x29, 0xc9, 0x48, 0x94, 0x52,
+ 0x48, 0xcf, 0xcf, 0x4f, 0xcf, 0x49, 0xd5, 0x07, 0x8b, 0x26, 0x95, 0xa6, 0xe9, 0xa7, 0xa4, 0x16,
+ 0x27, 0x17, 0x65, 0x16, 0x94, 0xe4, 0x17, 0x41, 0x54, 0x2a, 0xc9, 0x72, 0x71, 0x3a, 0x67, 0x64,
+ 0xe6, 0xa4, 0xf8, 0xe5, 0xa7, 0xa4, 0x0a, 0x09, 0x70, 0x31, 0x67, 0xa7, 0x56, 0x4a, 0x30, 0x2a,
+ 0x30, 0x6a, 0x70, 0x06, 0x81, 0x98, 0x5a, 0x46, 0x5c, 0x6c, 0x8e, 0xc9, 0xc9, 0xa9, 0xc5, 0xc5,
+ 0x42, 0x5c, 0x5c, 0x6c, 0xce, 0xfe, 0x7e, 0x6e, 0x9e, 0xee, 0x02, 0x0c, 0x42, 0xbc, 0x5c, 0x9c,
+ 0x41, 0xae, 0x8e, 0x2e, 0xf1, 0xfe, 0x7e, 0x3e, 0x91, 0x02, 0x8c, 0x50, 0xae, 0x4f, 0x7c, 0x88,
+ 0xa7, 0xaf, 0xab, 0x00, 0x93, 0x55, 0x10, 0x17, 0x57, 0x32, 0xc8, 0xc8, 0xf8, 0x3c, 0x90, 0x99,
+ 0xb2, 0x7a, 0x10, 0x37, 0xe8, 0xc1, 0xdc, 0xa0, 0xe7, 0x96, 0x99, 0x9a, 0x93, 0xe2, 0x5f, 0x50,
+ 0x92, 0x99, 0x9f, 0x57, 0x2c, 0xf1, 0xe6, 0xde, 0x4d, 0x66, 0x05, 0x46, 0x0d, 0x6e, 0x23, 0x41,
+ 0x3d, 0x88, 0x9b, 0xf5, 0xe0, 0xce, 0x09, 0xe2, 0x4c, 0x86, 0x31, 0xad, 0x3c, 0xb8, 0xd8, 0x12,
+ 0x21, 0xee, 0x20, 0x60, 0xde, 0x5b, 0x88, 0x79, 0x7c, 0x46, 0x7c, 0x30, 0xf3, 0x20, 0xee, 0x0f,
+ 0x82, 0xea, 0x4f, 0x62, 0x03, 0xeb, 0x33, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x55, 0xcc, 0xf1,
+ 0x90, 0x2f, 0x01, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/openflow_13/openflow_13.pb.go b/netopeer/voltha-grpc-client/voltha/openflow_13/openflow_13.pb.go
new file mode 100644
index 0000000..4be77bd
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/openflow_13/openflow_13.pb.go
@@ -0,0 +1,8597 @@
+// Code generated by protoc-gen-go.
+// source: openflow_13.proto
+// DO NOT EDIT!
+
+/*
+Package openflow_13 is a generated protocol buffer package.
+
+It is generated from these files:
+ openflow_13.proto
+
+It has these top-level messages:
+ OfpHeader
+ OfpHelloElemHeader
+ OfpHelloElemVersionbitmap
+ OfpHello
+ OfpSwitchConfig
+ OfpTableMod
+ OfpPort
+ OfpSwitchFeatures
+ OfpPortStatus
+ OfpPortMod
+ OfpMatch
+ OfpOxmField
+ OfpOxmOfbField
+ OfpOxmExperimenterField
+ OfpAction
+ OfpActionOutput
+ OfpActionMplsTtl
+ OfpActionPush
+ OfpActionPopMpls
+ OfpActionGroup
+ OfpActionNwTtl
+ OfpActionSetField
+ OfpActionExperimenter
+ OfpInstruction
+ OfpInstructionGotoTable
+ OfpInstructionWriteMetadata
+ OfpInstructionActions
+ OfpInstructionMeter
+ OfpInstructionExperimenter
+ OfpFlowMod
+ OfpBucket
+ OfpGroupMod
+ OfpPacketOut
+ OfpPacketIn
+ OfpFlowRemoved
+ OfpMeterBandHeader
+ OfpMeterBandDrop
+ OfpMeterBandDscpRemark
+ OfpMeterBandExperimenter
+ OfpMeterMod
+ OfpErrorMsg
+ OfpErrorExperimenterMsg
+ OfpMultipartRequest
+ OfpMultipartReply
+ OfpDesc
+ OfpFlowStatsRequest
+ OfpFlowStats
+ OfpAggregateStatsRequest
+ OfpAggregateStatsReply
+ OfpTableFeatureProperty
+ OfpTableFeaturePropInstructions
+ OfpTableFeaturePropNextTables
+ OfpTableFeaturePropActions
+ OfpTableFeaturePropOxm
+ OfpTableFeaturePropExperimenter
+ OfpTableFeatures
+ OfpTableStats
+ OfpPortStatsRequest
+ OfpPortStats
+ OfpGroupStatsRequest
+ OfpBucketCounter
+ OfpGroupStats
+ OfpGroupDesc
+ OfpGroupEntry
+ OfpGroupFeatures
+ OfpMeterMultipartRequest
+ OfpMeterBandStats
+ OfpMeterStats
+ OfpMeterConfig
+ OfpMeterFeatures
+ OfpExperimenterMultipartHeader
+ OfpExperimenterHeader
+ OfpQueuePropHeader
+ OfpQueuePropMinRate
+ OfpQueuePropMaxRate
+ OfpQueuePropExperimenter
+ OfpPacketQueue
+ OfpQueueGetConfigRequest
+ OfpQueueGetConfigReply
+ OfpActionSetQueue
+ OfpQueueStatsRequest
+ OfpQueueStats
+ OfpRoleRequest
+ OfpAsyncConfig
+ FlowTableUpdate
+ FlowGroupTableUpdate
+ Flows
+ FlowGroups
+ PacketIn
+ PacketOut
+ ChangeEvent
+*/
+package openflow_13
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import voltha "github.com/opencord/voltha/netconf/translator/voltha/yang_options"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// InlineNode from public import yang_options.proto
+type InlineNode voltha.InlineNode
+
+func (m *InlineNode) Reset() { (*voltha.InlineNode)(m).Reset() }
+func (m *InlineNode) String() string { return (*voltha.InlineNode)(m).String() }
+func (*InlineNode) ProtoMessage() {}
+func (m *InlineNode) GetId() string { return (*voltha.InlineNode)(m).GetId() }
+func (m *InlineNode) GetType() string { return (*voltha.InlineNode)(m).GetType() }
+
+// RpcReturnDef from public import yang_options.proto
+type RpcReturnDef voltha.RpcReturnDef
+
+func (m *RpcReturnDef) Reset() { (*voltha.RpcReturnDef)(m).Reset() }
+func (m *RpcReturnDef) String() string { return (*voltha.RpcReturnDef)(m).String() }
+func (*RpcReturnDef) ProtoMessage() {}
+func (m *RpcReturnDef) GetXmlTag() string { return (*voltha.RpcReturnDef)(m).GetXmlTag() }
+func (m *RpcReturnDef) GetListItemsName() string { return (*voltha.RpcReturnDef)(m).GetListItemsName() }
+
+// MessageParserOption from public import yang_options.proto
+type MessageParserOption voltha.MessageParserOption
+
+var MessageParserOption_name = voltha.MessageParserOption_name
+var MessageParserOption_value = voltha.MessageParserOption_value
+
+func (x MessageParserOption) String() string { return (voltha.MessageParserOption)(x).String() }
+
+const MessageParserOption_MOVE_TO_PARENT_LEVEL = MessageParserOption(voltha.MessageParserOption_MOVE_TO_PARENT_LEVEL)
+const MessageParserOption_CREATE_BOTH_GROUPING_AND_CONTAINER = MessageParserOption(voltha.MessageParserOption_CREATE_BOTH_GROUPING_AND_CONTAINER)
+
+// yang_child_rule from public import yang_options.proto
+var E_YangChildRule = voltha.E_YangChildRule
+
+// yang_message_rule from public import yang_options.proto
+var E_YangMessageRule = voltha.E_YangMessageRule
+
+// yang_inline_node from public import yang_options.proto
+var E_YangInlineNode = voltha.E_YangInlineNode
+
+// yang_xml_tag from public import yang_options.proto
+var E_YangXmlTag = voltha.E_YangXmlTag
+
+// Port numbering. Ports are numbered starting from 1.
+type OfpPortNo int32
+
+const (
+ OfpPortNo_OFPP_INVALID OfpPortNo = 0
+ // Maximum number of physical and logical switch ports.
+ OfpPortNo_OFPP_MAX OfpPortNo = 2147483392
+ // Reserved OpenFlow Port (fake output "ports").
+ OfpPortNo_OFPP_IN_PORT OfpPortNo = 2147483640
+ OfpPortNo_OFPP_TABLE OfpPortNo = 2147483641
+ OfpPortNo_OFPP_NORMAL OfpPortNo = 2147483642
+ OfpPortNo_OFPP_FLOOD OfpPortNo = 2147483643
+ OfpPortNo_OFPP_ALL OfpPortNo = 2147483644
+ OfpPortNo_OFPP_CONTROLLER OfpPortNo = 2147483645
+ OfpPortNo_OFPP_LOCAL OfpPortNo = 2147483646
+ OfpPortNo_OFPP_ANY OfpPortNo = 2147483647
+)
+
+var OfpPortNo_name = map[int32]string{
+ 0: "OFPP_INVALID",
+ 2147483392: "OFPP_MAX",
+ 2147483640: "OFPP_IN_PORT",
+ 2147483641: "OFPP_TABLE",
+ 2147483642: "OFPP_NORMAL",
+ 2147483643: "OFPP_FLOOD",
+ 2147483644: "OFPP_ALL",
+ 2147483645: "OFPP_CONTROLLER",
+ 2147483646: "OFPP_LOCAL",
+ 2147483647: "OFPP_ANY",
+}
+var OfpPortNo_value = map[string]int32{
+ "OFPP_INVALID": 0,
+ "OFPP_MAX": 2147483392,
+ "OFPP_IN_PORT": 2147483640,
+ "OFPP_TABLE": 2147483641,
+ "OFPP_NORMAL": 2147483642,
+ "OFPP_FLOOD": 2147483643,
+ "OFPP_ALL": 2147483644,
+ "OFPP_CONTROLLER": 2147483645,
+ "OFPP_LOCAL": 2147483646,
+ "OFPP_ANY": 2147483647,
+}
+
+func (x OfpPortNo) String() string {
+ return proto.EnumName(OfpPortNo_name, int32(x))
+}
+func (OfpPortNo) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type OfpType int32
+
+const (
+ // Immutable messages.
+ OfpType_OFPT_HELLO OfpType = 0
+ OfpType_OFPT_ERROR OfpType = 1
+ OfpType_OFPT_ECHO_REQUEST OfpType = 2
+ OfpType_OFPT_ECHO_REPLY OfpType = 3
+ OfpType_OFPT_EXPERIMENTER OfpType = 4
+ // Switch configuration messages.
+ OfpType_OFPT_FEATURES_REQUEST OfpType = 5
+ OfpType_OFPT_FEATURES_REPLY OfpType = 6
+ OfpType_OFPT_GET_CONFIG_REQUEST OfpType = 7
+ OfpType_OFPT_GET_CONFIG_REPLY OfpType = 8
+ OfpType_OFPT_SET_CONFIG OfpType = 9
+ // Asynchronous messages.
+ OfpType_OFPT_PACKET_IN OfpType = 10
+ OfpType_OFPT_FLOW_REMOVED OfpType = 11
+ OfpType_OFPT_PORT_STATUS OfpType = 12
+ // Controller command messages.
+ OfpType_OFPT_PACKET_OUT OfpType = 13
+ OfpType_OFPT_FLOW_MOD OfpType = 14
+ OfpType_OFPT_GROUP_MOD OfpType = 15
+ OfpType_OFPT_PORT_MOD OfpType = 16
+ OfpType_OFPT_TABLE_MOD OfpType = 17
+ // Multipart messages.
+ OfpType_OFPT_MULTIPART_REQUEST OfpType = 18
+ OfpType_OFPT_MULTIPART_REPLY OfpType = 19
+ // Barrier messages.
+ OfpType_OFPT_BARRIER_REQUEST OfpType = 20
+ OfpType_OFPT_BARRIER_REPLY OfpType = 21
+ // Queue Configuration messages.
+ OfpType_OFPT_QUEUE_GET_CONFIG_REQUEST OfpType = 22
+ OfpType_OFPT_QUEUE_GET_CONFIG_REPLY OfpType = 23
+ // Controller role change request messages.
+ OfpType_OFPT_ROLE_REQUEST OfpType = 24
+ OfpType_OFPT_ROLE_REPLY OfpType = 25
+ // Asynchronous message configuration.
+ OfpType_OFPT_GET_ASYNC_REQUEST OfpType = 26
+ OfpType_OFPT_GET_ASYNC_REPLY OfpType = 27
+ OfpType_OFPT_SET_ASYNC OfpType = 28
+ // Meters and rate limiters configuration messages.
+ OfpType_OFPT_METER_MOD OfpType = 29
+)
+
+var OfpType_name = map[int32]string{
+ 0: "OFPT_HELLO",
+ 1: "OFPT_ERROR",
+ 2: "OFPT_ECHO_REQUEST",
+ 3: "OFPT_ECHO_REPLY",
+ 4: "OFPT_EXPERIMENTER",
+ 5: "OFPT_FEATURES_REQUEST",
+ 6: "OFPT_FEATURES_REPLY",
+ 7: "OFPT_GET_CONFIG_REQUEST",
+ 8: "OFPT_GET_CONFIG_REPLY",
+ 9: "OFPT_SET_CONFIG",
+ 10: "OFPT_PACKET_IN",
+ 11: "OFPT_FLOW_REMOVED",
+ 12: "OFPT_PORT_STATUS",
+ 13: "OFPT_PACKET_OUT",
+ 14: "OFPT_FLOW_MOD",
+ 15: "OFPT_GROUP_MOD",
+ 16: "OFPT_PORT_MOD",
+ 17: "OFPT_TABLE_MOD",
+ 18: "OFPT_MULTIPART_REQUEST",
+ 19: "OFPT_MULTIPART_REPLY",
+ 20: "OFPT_BARRIER_REQUEST",
+ 21: "OFPT_BARRIER_REPLY",
+ 22: "OFPT_QUEUE_GET_CONFIG_REQUEST",
+ 23: "OFPT_QUEUE_GET_CONFIG_REPLY",
+ 24: "OFPT_ROLE_REQUEST",
+ 25: "OFPT_ROLE_REPLY",
+ 26: "OFPT_GET_ASYNC_REQUEST",
+ 27: "OFPT_GET_ASYNC_REPLY",
+ 28: "OFPT_SET_ASYNC",
+ 29: "OFPT_METER_MOD",
+}
+var OfpType_value = map[string]int32{
+ "OFPT_HELLO": 0,
+ "OFPT_ERROR": 1,
+ "OFPT_ECHO_REQUEST": 2,
+ "OFPT_ECHO_REPLY": 3,
+ "OFPT_EXPERIMENTER": 4,
+ "OFPT_FEATURES_REQUEST": 5,
+ "OFPT_FEATURES_REPLY": 6,
+ "OFPT_GET_CONFIG_REQUEST": 7,
+ "OFPT_GET_CONFIG_REPLY": 8,
+ "OFPT_SET_CONFIG": 9,
+ "OFPT_PACKET_IN": 10,
+ "OFPT_FLOW_REMOVED": 11,
+ "OFPT_PORT_STATUS": 12,
+ "OFPT_PACKET_OUT": 13,
+ "OFPT_FLOW_MOD": 14,
+ "OFPT_GROUP_MOD": 15,
+ "OFPT_PORT_MOD": 16,
+ "OFPT_TABLE_MOD": 17,
+ "OFPT_MULTIPART_REQUEST": 18,
+ "OFPT_MULTIPART_REPLY": 19,
+ "OFPT_BARRIER_REQUEST": 20,
+ "OFPT_BARRIER_REPLY": 21,
+ "OFPT_QUEUE_GET_CONFIG_REQUEST": 22,
+ "OFPT_QUEUE_GET_CONFIG_REPLY": 23,
+ "OFPT_ROLE_REQUEST": 24,
+ "OFPT_ROLE_REPLY": 25,
+ "OFPT_GET_ASYNC_REQUEST": 26,
+ "OFPT_GET_ASYNC_REPLY": 27,
+ "OFPT_SET_ASYNC": 28,
+ "OFPT_METER_MOD": 29,
+}
+
+func (x OfpType) String() string {
+ return proto.EnumName(OfpType_name, int32(x))
+}
+func (OfpType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+// Hello elements types.
+type OfpHelloElemType int32
+
+const (
+ OfpHelloElemType_OFPHET_INVALID OfpHelloElemType = 0
+ OfpHelloElemType_OFPHET_VERSIONBITMAP OfpHelloElemType = 1
+)
+
+var OfpHelloElemType_name = map[int32]string{
+ 0: "OFPHET_INVALID",
+ 1: "OFPHET_VERSIONBITMAP",
+}
+var OfpHelloElemType_value = map[string]int32{
+ "OFPHET_INVALID": 0,
+ "OFPHET_VERSIONBITMAP": 1,
+}
+
+func (x OfpHelloElemType) String() string {
+ return proto.EnumName(OfpHelloElemType_name, int32(x))
+}
+func (OfpHelloElemType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+type OfpConfigFlags int32
+
+const (
+ // Handling of IP fragments.
+ OfpConfigFlags_OFPC_FRAG_NORMAL OfpConfigFlags = 0
+ OfpConfigFlags_OFPC_FRAG_DROP OfpConfigFlags = 1
+ OfpConfigFlags_OFPC_FRAG_REASM OfpConfigFlags = 2
+ OfpConfigFlags_OFPC_FRAG_MASK OfpConfigFlags = 3
+)
+
+var OfpConfigFlags_name = map[int32]string{
+ 0: "OFPC_FRAG_NORMAL",
+ 1: "OFPC_FRAG_DROP",
+ 2: "OFPC_FRAG_REASM",
+ 3: "OFPC_FRAG_MASK",
+}
+var OfpConfigFlags_value = map[string]int32{
+ "OFPC_FRAG_NORMAL": 0,
+ "OFPC_FRAG_DROP": 1,
+ "OFPC_FRAG_REASM": 2,
+ "OFPC_FRAG_MASK": 3,
+}
+
+func (x OfpConfigFlags) String() string {
+ return proto.EnumName(OfpConfigFlags_name, int32(x))
+}
+func (OfpConfigFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+// Flags to configure the table. Reserved for future use.
+type OfpTableConfig int32
+
+const (
+ OfpTableConfig_OFPTC_INVALID OfpTableConfig = 0
+ OfpTableConfig_OFPTC_DEPRECATED_MASK OfpTableConfig = 3
+)
+
+var OfpTableConfig_name = map[int32]string{
+ 0: "OFPTC_INVALID",
+ 3: "OFPTC_DEPRECATED_MASK",
+}
+var OfpTableConfig_value = map[string]int32{
+ "OFPTC_INVALID": 0,
+ "OFPTC_DEPRECATED_MASK": 3,
+}
+
+func (x OfpTableConfig) String() string {
+ return proto.EnumName(OfpTableConfig_name, int32(x))
+}
+func (OfpTableConfig) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+// Table numbering. Tables can use any number up to OFPT_MAX.
+type OfpTable int32
+
+const (
+ OfpTable_OFPTT_INVALID OfpTable = 0
+ // Last usable table number.
+ OfpTable_OFPTT_MAX OfpTable = 254
+ // Fake tables.
+ OfpTable_OFPTT_ALL OfpTable = 255
+)
+
+var OfpTable_name = map[int32]string{
+ 0: "OFPTT_INVALID",
+ 254: "OFPTT_MAX",
+ 255: "OFPTT_ALL",
+}
+var OfpTable_value = map[string]int32{
+ "OFPTT_INVALID": 0,
+ "OFPTT_MAX": 254,
+ "OFPTT_ALL": 255,
+}
+
+func (x OfpTable) String() string {
+ return proto.EnumName(OfpTable_name, int32(x))
+}
+func (OfpTable) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+// Capabilities supported by the datapath.
+type OfpCapabilities int32
+
+const (
+ OfpCapabilities_OFPC_INVALID OfpCapabilities = 0
+ OfpCapabilities_OFPC_FLOW_STATS OfpCapabilities = 1
+ OfpCapabilities_OFPC_TABLE_STATS OfpCapabilities = 2
+ OfpCapabilities_OFPC_PORT_STATS OfpCapabilities = 4
+ OfpCapabilities_OFPC_GROUP_STATS OfpCapabilities = 8
+ OfpCapabilities_OFPC_IP_REASM OfpCapabilities = 32
+ OfpCapabilities_OFPC_QUEUE_STATS OfpCapabilities = 64
+ OfpCapabilities_OFPC_PORT_BLOCKED OfpCapabilities = 256
+)
+
+var OfpCapabilities_name = map[int32]string{
+ 0: "OFPC_INVALID",
+ 1: "OFPC_FLOW_STATS",
+ 2: "OFPC_TABLE_STATS",
+ 4: "OFPC_PORT_STATS",
+ 8: "OFPC_GROUP_STATS",
+ 32: "OFPC_IP_REASM",
+ 64: "OFPC_QUEUE_STATS",
+ 256: "OFPC_PORT_BLOCKED",
+}
+var OfpCapabilities_value = map[string]int32{
+ "OFPC_INVALID": 0,
+ "OFPC_FLOW_STATS": 1,
+ "OFPC_TABLE_STATS": 2,
+ "OFPC_PORT_STATS": 4,
+ "OFPC_GROUP_STATS": 8,
+ "OFPC_IP_REASM": 32,
+ "OFPC_QUEUE_STATS": 64,
+ "OFPC_PORT_BLOCKED": 256,
+}
+
+func (x OfpCapabilities) String() string {
+ return proto.EnumName(OfpCapabilities_name, int32(x))
+}
+func (OfpCapabilities) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+// Flags to indicate behavior of the physical port. These flags are
+// used in ofp_port to describe the current configuration. They are
+// used in the ofp_port_mod message to configure the port's behavior.
+type OfpPortConfig int32
+
+const (
+ OfpPortConfig_OFPPC_INVALID OfpPortConfig = 0
+ OfpPortConfig_OFPPC_PORT_DOWN OfpPortConfig = 1
+ OfpPortConfig_OFPPC_NO_RECV OfpPortConfig = 4
+ OfpPortConfig_OFPPC_NO_FWD OfpPortConfig = 32
+ OfpPortConfig_OFPPC_NO_PACKET_IN OfpPortConfig = 64
+)
+
+var OfpPortConfig_name = map[int32]string{
+ 0: "OFPPC_INVALID",
+ 1: "OFPPC_PORT_DOWN",
+ 4: "OFPPC_NO_RECV",
+ 32: "OFPPC_NO_FWD",
+ 64: "OFPPC_NO_PACKET_IN",
+}
+var OfpPortConfig_value = map[string]int32{
+ "OFPPC_INVALID": 0,
+ "OFPPC_PORT_DOWN": 1,
+ "OFPPC_NO_RECV": 4,
+ "OFPPC_NO_FWD": 32,
+ "OFPPC_NO_PACKET_IN": 64,
+}
+
+func (x OfpPortConfig) String() string {
+ return proto.EnumName(OfpPortConfig_name, int32(x))
+}
+func (OfpPortConfig) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+// Current state of the physical port. These are not configurable from
+// the controller.
+type OfpPortState int32
+
+const (
+ OfpPortState_OFPPS_INVALID OfpPortState = 0
+ OfpPortState_OFPPS_LINK_DOWN OfpPortState = 1
+ OfpPortState_OFPPS_BLOCKED OfpPortState = 2
+ OfpPortState_OFPPS_LIVE OfpPortState = 4
+)
+
+var OfpPortState_name = map[int32]string{
+ 0: "OFPPS_INVALID",
+ 1: "OFPPS_LINK_DOWN",
+ 2: "OFPPS_BLOCKED",
+ 4: "OFPPS_LIVE",
+}
+var OfpPortState_value = map[string]int32{
+ "OFPPS_INVALID": 0,
+ "OFPPS_LINK_DOWN": 1,
+ "OFPPS_BLOCKED": 2,
+ "OFPPS_LIVE": 4,
+}
+
+func (x OfpPortState) String() string {
+ return proto.EnumName(OfpPortState_name, int32(x))
+}
+func (OfpPortState) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+// Features of ports available in a datapath.
+type OfpPortFeatures int32
+
+const (
+ OfpPortFeatures_OFPPF_INVALID OfpPortFeatures = 0
+ OfpPortFeatures_OFPPF_10MB_HD OfpPortFeatures = 1
+ OfpPortFeatures_OFPPF_10MB_FD OfpPortFeatures = 2
+ OfpPortFeatures_OFPPF_100MB_HD OfpPortFeatures = 4
+ OfpPortFeatures_OFPPF_100MB_FD OfpPortFeatures = 8
+ OfpPortFeatures_OFPPF_1GB_HD OfpPortFeatures = 16
+ OfpPortFeatures_OFPPF_1GB_FD OfpPortFeatures = 32
+ OfpPortFeatures_OFPPF_10GB_FD OfpPortFeatures = 64
+ OfpPortFeatures_OFPPF_40GB_FD OfpPortFeatures = 128
+ OfpPortFeatures_OFPPF_100GB_FD OfpPortFeatures = 256
+ OfpPortFeatures_OFPPF_1TB_FD OfpPortFeatures = 512
+ OfpPortFeatures_OFPPF_OTHER OfpPortFeatures = 1024
+ OfpPortFeatures_OFPPF_COPPER OfpPortFeatures = 2048
+ OfpPortFeatures_OFPPF_FIBER OfpPortFeatures = 4096
+ OfpPortFeatures_OFPPF_AUTONEG OfpPortFeatures = 8192
+ OfpPortFeatures_OFPPF_PAUSE OfpPortFeatures = 16384
+ OfpPortFeatures_OFPPF_PAUSE_ASYM OfpPortFeatures = 32768
+)
+
+var OfpPortFeatures_name = map[int32]string{
+ 0: "OFPPF_INVALID",
+ 1: "OFPPF_10MB_HD",
+ 2: "OFPPF_10MB_FD",
+ 4: "OFPPF_100MB_HD",
+ 8: "OFPPF_100MB_FD",
+ 16: "OFPPF_1GB_HD",
+ 32: "OFPPF_1GB_FD",
+ 64: "OFPPF_10GB_FD",
+ 128: "OFPPF_40GB_FD",
+ 256: "OFPPF_100GB_FD",
+ 512: "OFPPF_1TB_FD",
+ 1024: "OFPPF_OTHER",
+ 2048: "OFPPF_COPPER",
+ 4096: "OFPPF_FIBER",
+ 8192: "OFPPF_AUTONEG",
+ 16384: "OFPPF_PAUSE",
+ 32768: "OFPPF_PAUSE_ASYM",
+}
+var OfpPortFeatures_value = map[string]int32{
+ "OFPPF_INVALID": 0,
+ "OFPPF_10MB_HD": 1,
+ "OFPPF_10MB_FD": 2,
+ "OFPPF_100MB_HD": 4,
+ "OFPPF_100MB_FD": 8,
+ "OFPPF_1GB_HD": 16,
+ "OFPPF_1GB_FD": 32,
+ "OFPPF_10GB_FD": 64,
+ "OFPPF_40GB_FD": 128,
+ "OFPPF_100GB_FD": 256,
+ "OFPPF_1TB_FD": 512,
+ "OFPPF_OTHER": 1024,
+ "OFPPF_COPPER": 2048,
+ "OFPPF_FIBER": 4096,
+ "OFPPF_AUTONEG": 8192,
+ "OFPPF_PAUSE": 16384,
+ "OFPPF_PAUSE_ASYM": 32768,
+}
+
+func (x OfpPortFeatures) String() string {
+ return proto.EnumName(OfpPortFeatures_name, int32(x))
+}
+func (OfpPortFeatures) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
+
+// What changed about the physical port
+type OfpPortReason int32
+
+const (
+ OfpPortReason_OFPPR_ADD OfpPortReason = 0
+ OfpPortReason_OFPPR_DELETE OfpPortReason = 1
+ OfpPortReason_OFPPR_MODIFY OfpPortReason = 2
+)
+
+var OfpPortReason_name = map[int32]string{
+ 0: "OFPPR_ADD",
+ 1: "OFPPR_DELETE",
+ 2: "OFPPR_MODIFY",
+}
+var OfpPortReason_value = map[string]int32{
+ "OFPPR_ADD": 0,
+ "OFPPR_DELETE": 1,
+ "OFPPR_MODIFY": 2,
+}
+
+func (x OfpPortReason) String() string {
+ return proto.EnumName(OfpPortReason_name, int32(x))
+}
+func (OfpPortReason) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
+
+// The match type indicates the match structure (set of fields that compose the
+// match) in use. The match type is placed in the type field at the beginning
+// of all match structures. The "OpenFlow Extensible Match" type corresponds
+// to OXM TLV format described below and must be supported by all OpenFlow
+// switches. Extensions that define other match types may be published on the
+// ONF wiki. Support for extensions is optional.
+type OfpMatchType int32
+
+const (
+ OfpMatchType_OFPMT_STANDARD OfpMatchType = 0
+ OfpMatchType_OFPMT_OXM OfpMatchType = 1
+)
+
+var OfpMatchType_name = map[int32]string{
+ 0: "OFPMT_STANDARD",
+ 1: "OFPMT_OXM",
+}
+var OfpMatchType_value = map[string]int32{
+ "OFPMT_STANDARD": 0,
+ "OFPMT_OXM": 1,
+}
+
+func (x OfpMatchType) String() string {
+ return proto.EnumName(OfpMatchType_name, int32(x))
+}
+func (OfpMatchType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
+
+// OXM Class IDs.
+// The high order bit differentiate reserved classes from member classes.
+// Classes 0x0000 to 0x7FFF are member classes, allocated by ONF.
+// Classes 0x8000 to 0xFFFE are reserved classes, reserved for standardisation.
+type OfpOxmClass int32
+
+const (
+ OfpOxmClass_OFPXMC_NXM_0 OfpOxmClass = 0
+ OfpOxmClass_OFPXMC_NXM_1 OfpOxmClass = 1
+ OfpOxmClass_OFPXMC_OPENFLOW_BASIC OfpOxmClass = 32768
+ OfpOxmClass_OFPXMC_EXPERIMENTER OfpOxmClass = 65535
+)
+
+var OfpOxmClass_name = map[int32]string{
+ 0: "OFPXMC_NXM_0",
+ 1: "OFPXMC_NXM_1",
+ 32768: "OFPXMC_OPENFLOW_BASIC",
+ 65535: "OFPXMC_EXPERIMENTER",
+}
+var OfpOxmClass_value = map[string]int32{
+ "OFPXMC_NXM_0": 0,
+ "OFPXMC_NXM_1": 1,
+ "OFPXMC_OPENFLOW_BASIC": 32768,
+ "OFPXMC_EXPERIMENTER": 65535,
+}
+
+func (x OfpOxmClass) String() string {
+ return proto.EnumName(OfpOxmClass_name, int32(x))
+}
+func (OfpOxmClass) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
+
+// OXM Flow field types for OpenFlow basic class.
+type OxmOfbFieldTypes int32
+
+const (
+ OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT OxmOfbFieldTypes = 0
+ OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT OxmOfbFieldTypes = 1
+ OxmOfbFieldTypes_OFPXMT_OFB_METADATA OxmOfbFieldTypes = 2
+ OxmOfbFieldTypes_OFPXMT_OFB_ETH_DST OxmOfbFieldTypes = 3
+ OxmOfbFieldTypes_OFPXMT_OFB_ETH_SRC OxmOfbFieldTypes = 4
+ OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE OxmOfbFieldTypes = 5
+ OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID OxmOfbFieldTypes = 6
+ OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP OxmOfbFieldTypes = 7
+ OxmOfbFieldTypes_OFPXMT_OFB_IP_DSCP OxmOfbFieldTypes = 8
+ OxmOfbFieldTypes_OFPXMT_OFB_IP_ECN OxmOfbFieldTypes = 9
+ OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO OxmOfbFieldTypes = 10
+ OxmOfbFieldTypes_OFPXMT_OFB_IPV4_SRC OxmOfbFieldTypes = 11
+ OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST OxmOfbFieldTypes = 12
+ OxmOfbFieldTypes_OFPXMT_OFB_TCP_SRC OxmOfbFieldTypes = 13
+ OxmOfbFieldTypes_OFPXMT_OFB_TCP_DST OxmOfbFieldTypes = 14
+ OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC OxmOfbFieldTypes = 15
+ OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST OxmOfbFieldTypes = 16
+ OxmOfbFieldTypes_OFPXMT_OFB_SCTP_SRC OxmOfbFieldTypes = 17
+ OxmOfbFieldTypes_OFPXMT_OFB_SCTP_DST OxmOfbFieldTypes = 18
+ OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_TYPE OxmOfbFieldTypes = 19
+ OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_CODE OxmOfbFieldTypes = 20
+ OxmOfbFieldTypes_OFPXMT_OFB_ARP_OP OxmOfbFieldTypes = 21
+ OxmOfbFieldTypes_OFPXMT_OFB_ARP_SPA OxmOfbFieldTypes = 22
+ OxmOfbFieldTypes_OFPXMT_OFB_ARP_TPA OxmOfbFieldTypes = 23
+ OxmOfbFieldTypes_OFPXMT_OFB_ARP_SHA OxmOfbFieldTypes = 24
+ OxmOfbFieldTypes_OFPXMT_OFB_ARP_THA OxmOfbFieldTypes = 25
+ OxmOfbFieldTypes_OFPXMT_OFB_IPV6_SRC OxmOfbFieldTypes = 26
+ OxmOfbFieldTypes_OFPXMT_OFB_IPV6_DST OxmOfbFieldTypes = 27
+ OxmOfbFieldTypes_OFPXMT_OFB_IPV6_FLABEL OxmOfbFieldTypes = 28
+ OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_TYPE OxmOfbFieldTypes = 29
+ OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_CODE OxmOfbFieldTypes = 30
+ OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TARGET OxmOfbFieldTypes = 31
+ OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_SLL OxmOfbFieldTypes = 32
+ OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TLL OxmOfbFieldTypes = 33
+ OxmOfbFieldTypes_OFPXMT_OFB_MPLS_LABEL OxmOfbFieldTypes = 34
+ OxmOfbFieldTypes_OFPXMT_OFB_MPLS_TC OxmOfbFieldTypes = 35
+ OxmOfbFieldTypes_OFPXMT_OFB_MPLS_BOS OxmOfbFieldTypes = 36
+ OxmOfbFieldTypes_OFPXMT_OFB_PBB_ISID OxmOfbFieldTypes = 37
+ OxmOfbFieldTypes_OFPXMT_OFB_TUNNEL_ID OxmOfbFieldTypes = 38
+ OxmOfbFieldTypes_OFPXMT_OFB_IPV6_EXTHDR OxmOfbFieldTypes = 39
+)
+
+var OxmOfbFieldTypes_name = map[int32]string{
+ 0: "OFPXMT_OFB_IN_PORT",
+ 1: "OFPXMT_OFB_IN_PHY_PORT",
+ 2: "OFPXMT_OFB_METADATA",
+ 3: "OFPXMT_OFB_ETH_DST",
+ 4: "OFPXMT_OFB_ETH_SRC",
+ 5: "OFPXMT_OFB_ETH_TYPE",
+ 6: "OFPXMT_OFB_VLAN_VID",
+ 7: "OFPXMT_OFB_VLAN_PCP",
+ 8: "OFPXMT_OFB_IP_DSCP",
+ 9: "OFPXMT_OFB_IP_ECN",
+ 10: "OFPXMT_OFB_IP_PROTO",
+ 11: "OFPXMT_OFB_IPV4_SRC",
+ 12: "OFPXMT_OFB_IPV4_DST",
+ 13: "OFPXMT_OFB_TCP_SRC",
+ 14: "OFPXMT_OFB_TCP_DST",
+ 15: "OFPXMT_OFB_UDP_SRC",
+ 16: "OFPXMT_OFB_UDP_DST",
+ 17: "OFPXMT_OFB_SCTP_SRC",
+ 18: "OFPXMT_OFB_SCTP_DST",
+ 19: "OFPXMT_OFB_ICMPV4_TYPE",
+ 20: "OFPXMT_OFB_ICMPV4_CODE",
+ 21: "OFPXMT_OFB_ARP_OP",
+ 22: "OFPXMT_OFB_ARP_SPA",
+ 23: "OFPXMT_OFB_ARP_TPA",
+ 24: "OFPXMT_OFB_ARP_SHA",
+ 25: "OFPXMT_OFB_ARP_THA",
+ 26: "OFPXMT_OFB_IPV6_SRC",
+ 27: "OFPXMT_OFB_IPV6_DST",
+ 28: "OFPXMT_OFB_IPV6_FLABEL",
+ 29: "OFPXMT_OFB_ICMPV6_TYPE",
+ 30: "OFPXMT_OFB_ICMPV6_CODE",
+ 31: "OFPXMT_OFB_IPV6_ND_TARGET",
+ 32: "OFPXMT_OFB_IPV6_ND_SLL",
+ 33: "OFPXMT_OFB_IPV6_ND_TLL",
+ 34: "OFPXMT_OFB_MPLS_LABEL",
+ 35: "OFPXMT_OFB_MPLS_TC",
+ 36: "OFPXMT_OFB_MPLS_BOS",
+ 37: "OFPXMT_OFB_PBB_ISID",
+ 38: "OFPXMT_OFB_TUNNEL_ID",
+ 39: "OFPXMT_OFB_IPV6_EXTHDR",
+}
+var OxmOfbFieldTypes_value = map[string]int32{
+ "OFPXMT_OFB_IN_PORT": 0,
+ "OFPXMT_OFB_IN_PHY_PORT": 1,
+ "OFPXMT_OFB_METADATA": 2,
+ "OFPXMT_OFB_ETH_DST": 3,
+ "OFPXMT_OFB_ETH_SRC": 4,
+ "OFPXMT_OFB_ETH_TYPE": 5,
+ "OFPXMT_OFB_VLAN_VID": 6,
+ "OFPXMT_OFB_VLAN_PCP": 7,
+ "OFPXMT_OFB_IP_DSCP": 8,
+ "OFPXMT_OFB_IP_ECN": 9,
+ "OFPXMT_OFB_IP_PROTO": 10,
+ "OFPXMT_OFB_IPV4_SRC": 11,
+ "OFPXMT_OFB_IPV4_DST": 12,
+ "OFPXMT_OFB_TCP_SRC": 13,
+ "OFPXMT_OFB_TCP_DST": 14,
+ "OFPXMT_OFB_UDP_SRC": 15,
+ "OFPXMT_OFB_UDP_DST": 16,
+ "OFPXMT_OFB_SCTP_SRC": 17,
+ "OFPXMT_OFB_SCTP_DST": 18,
+ "OFPXMT_OFB_ICMPV4_TYPE": 19,
+ "OFPXMT_OFB_ICMPV4_CODE": 20,
+ "OFPXMT_OFB_ARP_OP": 21,
+ "OFPXMT_OFB_ARP_SPA": 22,
+ "OFPXMT_OFB_ARP_TPA": 23,
+ "OFPXMT_OFB_ARP_SHA": 24,
+ "OFPXMT_OFB_ARP_THA": 25,
+ "OFPXMT_OFB_IPV6_SRC": 26,
+ "OFPXMT_OFB_IPV6_DST": 27,
+ "OFPXMT_OFB_IPV6_FLABEL": 28,
+ "OFPXMT_OFB_ICMPV6_TYPE": 29,
+ "OFPXMT_OFB_ICMPV6_CODE": 30,
+ "OFPXMT_OFB_IPV6_ND_TARGET": 31,
+ "OFPXMT_OFB_IPV6_ND_SLL": 32,
+ "OFPXMT_OFB_IPV6_ND_TLL": 33,
+ "OFPXMT_OFB_MPLS_LABEL": 34,
+ "OFPXMT_OFB_MPLS_TC": 35,
+ "OFPXMT_OFB_MPLS_BOS": 36,
+ "OFPXMT_OFB_PBB_ISID": 37,
+ "OFPXMT_OFB_TUNNEL_ID": 38,
+ "OFPXMT_OFB_IPV6_EXTHDR": 39,
+}
+
+func (x OxmOfbFieldTypes) String() string {
+ return proto.EnumName(OxmOfbFieldTypes_name, int32(x))
+}
+func (OxmOfbFieldTypes) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
+
+// The VLAN id is 12-bits, so we can use the entire 16 bits to indicate
+// special conditions.
+type OfpVlanId int32
+
+const (
+ OfpVlanId_OFPVID_NONE OfpVlanId = 0
+ OfpVlanId_OFPVID_PRESENT OfpVlanId = 4096
+)
+
+var OfpVlanId_name = map[int32]string{
+ 0: "OFPVID_NONE",
+ 4096: "OFPVID_PRESENT",
+}
+var OfpVlanId_value = map[string]int32{
+ "OFPVID_NONE": 0,
+ "OFPVID_PRESENT": 4096,
+}
+
+func (x OfpVlanId) String() string {
+ return proto.EnumName(OfpVlanId_name, int32(x))
+}
+func (OfpVlanId) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
+
+// Bit definitions for IPv6 Extension Header pseudo-field.
+type OfpIpv6ExthdrFlags int32
+
+const (
+ OfpIpv6ExthdrFlags_OFPIEH_INVALID OfpIpv6ExthdrFlags = 0
+ OfpIpv6ExthdrFlags_OFPIEH_NONEXT OfpIpv6ExthdrFlags = 1
+ OfpIpv6ExthdrFlags_OFPIEH_ESP OfpIpv6ExthdrFlags = 2
+ OfpIpv6ExthdrFlags_OFPIEH_AUTH OfpIpv6ExthdrFlags = 4
+ OfpIpv6ExthdrFlags_OFPIEH_DEST OfpIpv6ExthdrFlags = 8
+ OfpIpv6ExthdrFlags_OFPIEH_FRAG OfpIpv6ExthdrFlags = 16
+ OfpIpv6ExthdrFlags_OFPIEH_ROUTER OfpIpv6ExthdrFlags = 32
+ OfpIpv6ExthdrFlags_OFPIEH_HOP OfpIpv6ExthdrFlags = 64
+ OfpIpv6ExthdrFlags_OFPIEH_UNREP OfpIpv6ExthdrFlags = 128
+ OfpIpv6ExthdrFlags_OFPIEH_UNSEQ OfpIpv6ExthdrFlags = 256
+)
+
+var OfpIpv6ExthdrFlags_name = map[int32]string{
+ 0: "OFPIEH_INVALID",
+ 1: "OFPIEH_NONEXT",
+ 2: "OFPIEH_ESP",
+ 4: "OFPIEH_AUTH",
+ 8: "OFPIEH_DEST",
+ 16: "OFPIEH_FRAG",
+ 32: "OFPIEH_ROUTER",
+ 64: "OFPIEH_HOP",
+ 128: "OFPIEH_UNREP",
+ 256: "OFPIEH_UNSEQ",
+}
+var OfpIpv6ExthdrFlags_value = map[string]int32{
+ "OFPIEH_INVALID": 0,
+ "OFPIEH_NONEXT": 1,
+ "OFPIEH_ESP": 2,
+ "OFPIEH_AUTH": 4,
+ "OFPIEH_DEST": 8,
+ "OFPIEH_FRAG": 16,
+ "OFPIEH_ROUTER": 32,
+ "OFPIEH_HOP": 64,
+ "OFPIEH_UNREP": 128,
+ "OFPIEH_UNSEQ": 256,
+}
+
+func (x OfpIpv6ExthdrFlags) String() string {
+ return proto.EnumName(OfpIpv6ExthdrFlags_name, int32(x))
+}
+func (OfpIpv6ExthdrFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
+
+type OfpActionType int32
+
+const (
+ OfpActionType_OFPAT_OUTPUT OfpActionType = 0
+ OfpActionType_OFPAT_COPY_TTL_OUT OfpActionType = 11
+ OfpActionType_OFPAT_COPY_TTL_IN OfpActionType = 12
+ OfpActionType_OFPAT_SET_MPLS_TTL OfpActionType = 15
+ OfpActionType_OFPAT_DEC_MPLS_TTL OfpActionType = 16
+ OfpActionType_OFPAT_PUSH_VLAN OfpActionType = 17
+ OfpActionType_OFPAT_POP_VLAN OfpActionType = 18
+ OfpActionType_OFPAT_PUSH_MPLS OfpActionType = 19
+ OfpActionType_OFPAT_POP_MPLS OfpActionType = 20
+ OfpActionType_OFPAT_SET_QUEUE OfpActionType = 21
+ OfpActionType_OFPAT_GROUP OfpActionType = 22
+ OfpActionType_OFPAT_SET_NW_TTL OfpActionType = 23
+ OfpActionType_OFPAT_DEC_NW_TTL OfpActionType = 24
+ OfpActionType_OFPAT_SET_FIELD OfpActionType = 25
+ OfpActionType_OFPAT_PUSH_PBB OfpActionType = 26
+ OfpActionType_OFPAT_POP_PBB OfpActionType = 27
+ OfpActionType_OFPAT_EXPERIMENTER OfpActionType = 65535
+)
+
+var OfpActionType_name = map[int32]string{
+ 0: "OFPAT_OUTPUT",
+ 11: "OFPAT_COPY_TTL_OUT",
+ 12: "OFPAT_COPY_TTL_IN",
+ 15: "OFPAT_SET_MPLS_TTL",
+ 16: "OFPAT_DEC_MPLS_TTL",
+ 17: "OFPAT_PUSH_VLAN",
+ 18: "OFPAT_POP_VLAN",
+ 19: "OFPAT_PUSH_MPLS",
+ 20: "OFPAT_POP_MPLS",
+ 21: "OFPAT_SET_QUEUE",
+ 22: "OFPAT_GROUP",
+ 23: "OFPAT_SET_NW_TTL",
+ 24: "OFPAT_DEC_NW_TTL",
+ 25: "OFPAT_SET_FIELD",
+ 26: "OFPAT_PUSH_PBB",
+ 27: "OFPAT_POP_PBB",
+ 65535: "OFPAT_EXPERIMENTER",
+}
+var OfpActionType_value = map[string]int32{
+ "OFPAT_OUTPUT": 0,
+ "OFPAT_COPY_TTL_OUT": 11,
+ "OFPAT_COPY_TTL_IN": 12,
+ "OFPAT_SET_MPLS_TTL": 15,
+ "OFPAT_DEC_MPLS_TTL": 16,
+ "OFPAT_PUSH_VLAN": 17,
+ "OFPAT_POP_VLAN": 18,
+ "OFPAT_PUSH_MPLS": 19,
+ "OFPAT_POP_MPLS": 20,
+ "OFPAT_SET_QUEUE": 21,
+ "OFPAT_GROUP": 22,
+ "OFPAT_SET_NW_TTL": 23,
+ "OFPAT_DEC_NW_TTL": 24,
+ "OFPAT_SET_FIELD": 25,
+ "OFPAT_PUSH_PBB": 26,
+ "OFPAT_POP_PBB": 27,
+ "OFPAT_EXPERIMENTER": 65535,
+}
+
+func (x OfpActionType) String() string {
+ return proto.EnumName(OfpActionType_name, int32(x))
+}
+func (OfpActionType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
+
+type OfpControllerMaxLen int32
+
+const (
+ OfpControllerMaxLen_OFPCML_INVALID OfpControllerMaxLen = 0
+ OfpControllerMaxLen_OFPCML_MAX OfpControllerMaxLen = 65509
+ OfpControllerMaxLen_OFPCML_NO_BUFFER OfpControllerMaxLen = 65535
+)
+
+var OfpControllerMaxLen_name = map[int32]string{
+ 0: "OFPCML_INVALID",
+ 65509: "OFPCML_MAX",
+ 65535: "OFPCML_NO_BUFFER",
+}
+var OfpControllerMaxLen_value = map[string]int32{
+ "OFPCML_INVALID": 0,
+ "OFPCML_MAX": 65509,
+ "OFPCML_NO_BUFFER": 65535,
+}
+
+func (x OfpControllerMaxLen) String() string {
+ return proto.EnumName(OfpControllerMaxLen_name, int32(x))
+}
+func (OfpControllerMaxLen) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
+
+type OfpInstructionType int32
+
+const (
+ OfpInstructionType_OFPIT_INVALID OfpInstructionType = 0
+ OfpInstructionType_OFPIT_GOTO_TABLE OfpInstructionType = 1
+ OfpInstructionType_OFPIT_WRITE_METADATA OfpInstructionType = 2
+ OfpInstructionType_OFPIT_WRITE_ACTIONS OfpInstructionType = 3
+ OfpInstructionType_OFPIT_APPLY_ACTIONS OfpInstructionType = 4
+ OfpInstructionType_OFPIT_CLEAR_ACTIONS OfpInstructionType = 5
+ OfpInstructionType_OFPIT_METER OfpInstructionType = 6
+ OfpInstructionType_OFPIT_EXPERIMENTER OfpInstructionType = 65535
+)
+
+var OfpInstructionType_name = map[int32]string{
+ 0: "OFPIT_INVALID",
+ 1: "OFPIT_GOTO_TABLE",
+ 2: "OFPIT_WRITE_METADATA",
+ 3: "OFPIT_WRITE_ACTIONS",
+ 4: "OFPIT_APPLY_ACTIONS",
+ 5: "OFPIT_CLEAR_ACTIONS",
+ 6: "OFPIT_METER",
+ 65535: "OFPIT_EXPERIMENTER",
+}
+var OfpInstructionType_value = map[string]int32{
+ "OFPIT_INVALID": 0,
+ "OFPIT_GOTO_TABLE": 1,
+ "OFPIT_WRITE_METADATA": 2,
+ "OFPIT_WRITE_ACTIONS": 3,
+ "OFPIT_APPLY_ACTIONS": 4,
+ "OFPIT_CLEAR_ACTIONS": 5,
+ "OFPIT_METER": 6,
+ "OFPIT_EXPERIMENTER": 65535,
+}
+
+func (x OfpInstructionType) String() string {
+ return proto.EnumName(OfpInstructionType_name, int32(x))
+}
+func (OfpInstructionType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
+
+type OfpFlowModCommand int32
+
+const (
+ OfpFlowModCommand_OFPFC_ADD OfpFlowModCommand = 0
+ OfpFlowModCommand_OFPFC_MODIFY OfpFlowModCommand = 1
+ OfpFlowModCommand_OFPFC_MODIFY_STRICT OfpFlowModCommand = 2
+ OfpFlowModCommand_OFPFC_DELETE OfpFlowModCommand = 3
+ OfpFlowModCommand_OFPFC_DELETE_STRICT OfpFlowModCommand = 4
+)
+
+var OfpFlowModCommand_name = map[int32]string{
+ 0: "OFPFC_ADD",
+ 1: "OFPFC_MODIFY",
+ 2: "OFPFC_MODIFY_STRICT",
+ 3: "OFPFC_DELETE",
+ 4: "OFPFC_DELETE_STRICT",
+}
+var OfpFlowModCommand_value = map[string]int32{
+ "OFPFC_ADD": 0,
+ "OFPFC_MODIFY": 1,
+ "OFPFC_MODIFY_STRICT": 2,
+ "OFPFC_DELETE": 3,
+ "OFPFC_DELETE_STRICT": 4,
+}
+
+func (x OfpFlowModCommand) String() string {
+ return proto.EnumName(OfpFlowModCommand_name, int32(x))
+}
+func (OfpFlowModCommand) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
+
+type OfpFlowModFlags int32
+
+const (
+ OfpFlowModFlags_OFPFF_INVALID OfpFlowModFlags = 0
+ OfpFlowModFlags_OFPFF_SEND_FLOW_REM OfpFlowModFlags = 1
+ OfpFlowModFlags_OFPFF_CHECK_OVERLAP OfpFlowModFlags = 2
+ OfpFlowModFlags_OFPFF_RESET_COUNTS OfpFlowModFlags = 4
+ OfpFlowModFlags_OFPFF_NO_PKT_COUNTS OfpFlowModFlags = 8
+ OfpFlowModFlags_OFPFF_NO_BYT_COUNTS OfpFlowModFlags = 16
+)
+
+var OfpFlowModFlags_name = map[int32]string{
+ 0: "OFPFF_INVALID",
+ 1: "OFPFF_SEND_FLOW_REM",
+ 2: "OFPFF_CHECK_OVERLAP",
+ 4: "OFPFF_RESET_COUNTS",
+ 8: "OFPFF_NO_PKT_COUNTS",
+ 16: "OFPFF_NO_BYT_COUNTS",
+}
+var OfpFlowModFlags_value = map[string]int32{
+ "OFPFF_INVALID": 0,
+ "OFPFF_SEND_FLOW_REM": 1,
+ "OFPFF_CHECK_OVERLAP": 2,
+ "OFPFF_RESET_COUNTS": 4,
+ "OFPFF_NO_PKT_COUNTS": 8,
+ "OFPFF_NO_BYT_COUNTS": 16,
+}
+
+func (x OfpFlowModFlags) String() string {
+ return proto.EnumName(OfpFlowModFlags_name, int32(x))
+}
+func (OfpFlowModFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
+
+// Group numbering. Groups can use any number up to OFPG_MAX.
+type OfpGroup int32
+
+const (
+ OfpGroup_OFPG_INVALID OfpGroup = 0
+ // Last usable group number.
+ OfpGroup_OFPG_MAX OfpGroup = 2147483392
+ // Fake groups.
+ OfpGroup_OFPG_ALL OfpGroup = 2147483644
+ OfpGroup_OFPG_ANY OfpGroup = 2147483647
+)
+
+var OfpGroup_name = map[int32]string{
+ 0: "OFPG_INVALID",
+ 2147483392: "OFPG_MAX",
+ 2147483644: "OFPG_ALL",
+ 2147483647: "OFPG_ANY",
+}
+var OfpGroup_value = map[string]int32{
+ "OFPG_INVALID": 0,
+ "OFPG_MAX": 2147483392,
+ "OFPG_ALL": 2147483644,
+ "OFPG_ANY": 2147483647,
+}
+
+func (x OfpGroup) String() string {
+ return proto.EnumName(OfpGroup_name, int32(x))
+}
+func (OfpGroup) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
+
+// Group commands
+type OfpGroupModCommand int32
+
+const (
+ OfpGroupModCommand_OFPGC_ADD OfpGroupModCommand = 0
+ OfpGroupModCommand_OFPGC_MODIFY OfpGroupModCommand = 1
+ OfpGroupModCommand_OFPGC_DELETE OfpGroupModCommand = 2
+)
+
+var OfpGroupModCommand_name = map[int32]string{
+ 0: "OFPGC_ADD",
+ 1: "OFPGC_MODIFY",
+ 2: "OFPGC_DELETE",
+}
+var OfpGroupModCommand_value = map[string]int32{
+ "OFPGC_ADD": 0,
+ "OFPGC_MODIFY": 1,
+ "OFPGC_DELETE": 2,
+}
+
+func (x OfpGroupModCommand) String() string {
+ return proto.EnumName(OfpGroupModCommand_name, int32(x))
+}
+func (OfpGroupModCommand) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
+
+// Group types. Values in the range [128; 255] are reserved for experimental
+// use.
+type OfpGroupType int32
+
+const (
+ OfpGroupType_OFPGT_ALL OfpGroupType = 0
+ OfpGroupType_OFPGT_SELECT OfpGroupType = 1
+ OfpGroupType_OFPGT_INDIRECT OfpGroupType = 2
+ OfpGroupType_OFPGT_FF OfpGroupType = 3
+)
+
+var OfpGroupType_name = map[int32]string{
+ 0: "OFPGT_ALL",
+ 1: "OFPGT_SELECT",
+ 2: "OFPGT_INDIRECT",
+ 3: "OFPGT_FF",
+}
+var OfpGroupType_value = map[string]int32{
+ "OFPGT_ALL": 0,
+ "OFPGT_SELECT": 1,
+ "OFPGT_INDIRECT": 2,
+ "OFPGT_FF": 3,
+}
+
+func (x OfpGroupType) String() string {
+ return proto.EnumName(OfpGroupType_name, int32(x))
+}
+func (OfpGroupType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
+
+// Why is this packet being sent to the controller?
+type OfpPacketInReason int32
+
+const (
+ OfpPacketInReason_OFPR_NO_MATCH OfpPacketInReason = 0
+ OfpPacketInReason_OFPR_ACTION OfpPacketInReason = 1
+ OfpPacketInReason_OFPR_INVALID_TTL OfpPacketInReason = 2
+)
+
+var OfpPacketInReason_name = map[int32]string{
+ 0: "OFPR_NO_MATCH",
+ 1: "OFPR_ACTION",
+ 2: "OFPR_INVALID_TTL",
+}
+var OfpPacketInReason_value = map[string]int32{
+ "OFPR_NO_MATCH": 0,
+ "OFPR_ACTION": 1,
+ "OFPR_INVALID_TTL": 2,
+}
+
+func (x OfpPacketInReason) String() string {
+ return proto.EnumName(OfpPacketInReason_name, int32(x))
+}
+func (OfpPacketInReason) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
+
+// Why was this flow removed?
+type OfpFlowRemovedReason int32
+
+const (
+ OfpFlowRemovedReason_OFPRR_IDLE_TIMEOUT OfpFlowRemovedReason = 0
+ OfpFlowRemovedReason_OFPRR_HARD_TIMEOUT OfpFlowRemovedReason = 1
+ OfpFlowRemovedReason_OFPRR_DELETE OfpFlowRemovedReason = 2
+ OfpFlowRemovedReason_OFPRR_GROUP_DELETE OfpFlowRemovedReason = 3
+ OfpFlowRemovedReason_OFPRR_METER_DELETE OfpFlowRemovedReason = 4
+)
+
+var OfpFlowRemovedReason_name = map[int32]string{
+ 0: "OFPRR_IDLE_TIMEOUT",
+ 1: "OFPRR_HARD_TIMEOUT",
+ 2: "OFPRR_DELETE",
+ 3: "OFPRR_GROUP_DELETE",
+ 4: "OFPRR_METER_DELETE",
+}
+var OfpFlowRemovedReason_value = map[string]int32{
+ "OFPRR_IDLE_TIMEOUT": 0,
+ "OFPRR_HARD_TIMEOUT": 1,
+ "OFPRR_DELETE": 2,
+ "OFPRR_GROUP_DELETE": 3,
+ "OFPRR_METER_DELETE": 4,
+}
+
+func (x OfpFlowRemovedReason) String() string {
+ return proto.EnumName(OfpFlowRemovedReason_name, int32(x))
+}
+func (OfpFlowRemovedReason) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
+
+// Meter numbering. Flow meters can use any number up to OFPM_MAX.
+type OfpMeter int32
+
+const (
+ OfpMeter_OFPM_ZERO OfpMeter = 0
+ // Last usable meter.
+ OfpMeter_OFPM_MAX OfpMeter = 2147418112
+ // Virtual meters.
+ OfpMeter_OFPM_SLOWPATH OfpMeter = 2147483645
+ OfpMeter_OFPM_CONTROLLER OfpMeter = 2147483646
+ OfpMeter_OFPM_ALL OfpMeter = 2147483647
+)
+
+var OfpMeter_name = map[int32]string{
+ 0: "OFPM_ZERO",
+ 2147418112: "OFPM_MAX",
+ 2147483645: "OFPM_SLOWPATH",
+ 2147483646: "OFPM_CONTROLLER",
+ 2147483647: "OFPM_ALL",
+}
+var OfpMeter_value = map[string]int32{
+ "OFPM_ZERO": 0,
+ "OFPM_MAX": 2147418112,
+ "OFPM_SLOWPATH": 2147483645,
+ "OFPM_CONTROLLER": 2147483646,
+ "OFPM_ALL": 2147483647,
+}
+
+func (x OfpMeter) String() string {
+ return proto.EnumName(OfpMeter_name, int32(x))
+}
+func (OfpMeter) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
+
+// Meter band types
+type OfpMeterBandType int32
+
+const (
+ OfpMeterBandType_OFPMBT_INVALID OfpMeterBandType = 0
+ OfpMeterBandType_OFPMBT_DROP OfpMeterBandType = 1
+ OfpMeterBandType_OFPMBT_DSCP_REMARK OfpMeterBandType = 2
+ OfpMeterBandType_OFPMBT_EXPERIMENTER OfpMeterBandType = 65535
+)
+
+var OfpMeterBandType_name = map[int32]string{
+ 0: "OFPMBT_INVALID",
+ 1: "OFPMBT_DROP",
+ 2: "OFPMBT_DSCP_REMARK",
+ 65535: "OFPMBT_EXPERIMENTER",
+}
+var OfpMeterBandType_value = map[string]int32{
+ "OFPMBT_INVALID": 0,
+ "OFPMBT_DROP": 1,
+ "OFPMBT_DSCP_REMARK": 2,
+ "OFPMBT_EXPERIMENTER": 65535,
+}
+
+func (x OfpMeterBandType) String() string {
+ return proto.EnumName(OfpMeterBandType_name, int32(x))
+}
+func (OfpMeterBandType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
+
+// Meter commands
+type OfpMeterModCommand int32
+
+const (
+ OfpMeterModCommand_OFPMC_ADD OfpMeterModCommand = 0
+ OfpMeterModCommand_OFPMC_MODIFY OfpMeterModCommand = 1
+ OfpMeterModCommand_OFPMC_DELETE OfpMeterModCommand = 2
+)
+
+var OfpMeterModCommand_name = map[int32]string{
+ 0: "OFPMC_ADD",
+ 1: "OFPMC_MODIFY",
+ 2: "OFPMC_DELETE",
+}
+var OfpMeterModCommand_value = map[string]int32{
+ "OFPMC_ADD": 0,
+ "OFPMC_MODIFY": 1,
+ "OFPMC_DELETE": 2,
+}
+
+func (x OfpMeterModCommand) String() string {
+ return proto.EnumName(OfpMeterModCommand_name, int32(x))
+}
+func (OfpMeterModCommand) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
+
+// Meter configuration flags
+type OfpMeterFlags int32
+
+const (
+ OfpMeterFlags_OFPMF_INVALID OfpMeterFlags = 0
+ OfpMeterFlags_OFPMF_KBPS OfpMeterFlags = 1
+ OfpMeterFlags_OFPMF_PKTPS OfpMeterFlags = 2
+ OfpMeterFlags_OFPMF_BURST OfpMeterFlags = 4
+ OfpMeterFlags_OFPMF_STATS OfpMeterFlags = 8
+)
+
+var OfpMeterFlags_name = map[int32]string{
+ 0: "OFPMF_INVALID",
+ 1: "OFPMF_KBPS",
+ 2: "OFPMF_PKTPS",
+ 4: "OFPMF_BURST",
+ 8: "OFPMF_STATS",
+}
+var OfpMeterFlags_value = map[string]int32{
+ "OFPMF_INVALID": 0,
+ "OFPMF_KBPS": 1,
+ "OFPMF_PKTPS": 2,
+ "OFPMF_BURST": 4,
+ "OFPMF_STATS": 8,
+}
+
+func (x OfpMeterFlags) String() string {
+ return proto.EnumName(OfpMeterFlags_name, int32(x))
+}
+func (OfpMeterFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
+
+// Values for 'type' in ofp_error_message. These values are immutable: they
+// will not change in future versions of the protocol (although new values may
+// be added).
+type OfpErrorType int32
+
+const (
+ OfpErrorType_OFPET_HELLO_FAILED OfpErrorType = 0
+ OfpErrorType_OFPET_BAD_REQUEST OfpErrorType = 1
+ OfpErrorType_OFPET_BAD_ACTION OfpErrorType = 2
+ OfpErrorType_OFPET_BAD_INSTRUCTION OfpErrorType = 3
+ OfpErrorType_OFPET_BAD_MATCH OfpErrorType = 4
+ OfpErrorType_OFPET_FLOW_MOD_FAILED OfpErrorType = 5
+ OfpErrorType_OFPET_GROUP_MOD_FAILED OfpErrorType = 6
+ OfpErrorType_OFPET_PORT_MOD_FAILED OfpErrorType = 7
+ OfpErrorType_OFPET_TABLE_MOD_FAILED OfpErrorType = 8
+ OfpErrorType_OFPET_QUEUE_OP_FAILED OfpErrorType = 9
+ OfpErrorType_OFPET_SWITCH_CONFIG_FAILED OfpErrorType = 10
+ OfpErrorType_OFPET_ROLE_REQUEST_FAILED OfpErrorType = 11
+ OfpErrorType_OFPET_METER_MOD_FAILED OfpErrorType = 12
+ OfpErrorType_OFPET_TABLE_FEATURES_FAILED OfpErrorType = 13
+ OfpErrorType_OFPET_EXPERIMENTER OfpErrorType = 65535
+)
+
+var OfpErrorType_name = map[int32]string{
+ 0: "OFPET_HELLO_FAILED",
+ 1: "OFPET_BAD_REQUEST",
+ 2: "OFPET_BAD_ACTION",
+ 3: "OFPET_BAD_INSTRUCTION",
+ 4: "OFPET_BAD_MATCH",
+ 5: "OFPET_FLOW_MOD_FAILED",
+ 6: "OFPET_GROUP_MOD_FAILED",
+ 7: "OFPET_PORT_MOD_FAILED",
+ 8: "OFPET_TABLE_MOD_FAILED",
+ 9: "OFPET_QUEUE_OP_FAILED",
+ 10: "OFPET_SWITCH_CONFIG_FAILED",
+ 11: "OFPET_ROLE_REQUEST_FAILED",
+ 12: "OFPET_METER_MOD_FAILED",
+ 13: "OFPET_TABLE_FEATURES_FAILED",
+ 65535: "OFPET_EXPERIMENTER",
+}
+var OfpErrorType_value = map[string]int32{
+ "OFPET_HELLO_FAILED": 0,
+ "OFPET_BAD_REQUEST": 1,
+ "OFPET_BAD_ACTION": 2,
+ "OFPET_BAD_INSTRUCTION": 3,
+ "OFPET_BAD_MATCH": 4,
+ "OFPET_FLOW_MOD_FAILED": 5,
+ "OFPET_GROUP_MOD_FAILED": 6,
+ "OFPET_PORT_MOD_FAILED": 7,
+ "OFPET_TABLE_MOD_FAILED": 8,
+ "OFPET_QUEUE_OP_FAILED": 9,
+ "OFPET_SWITCH_CONFIG_FAILED": 10,
+ "OFPET_ROLE_REQUEST_FAILED": 11,
+ "OFPET_METER_MOD_FAILED": 12,
+ "OFPET_TABLE_FEATURES_FAILED": 13,
+ "OFPET_EXPERIMENTER": 65535,
+}
+
+func (x OfpErrorType) String() string {
+ return proto.EnumName(OfpErrorType_name, int32(x))
+}
+func (OfpErrorType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
+
+// ofp_error_msg 'code' values for OFPET_HELLO_FAILED. 'data' contains an
+// ASCII text string that may give failure details.
+type OfpHelloFailedCode int32
+
+const (
+ OfpHelloFailedCode_OFPHFC_INCOMPATIBLE OfpHelloFailedCode = 0
+ OfpHelloFailedCode_OFPHFC_EPERM OfpHelloFailedCode = 1
+)
+
+var OfpHelloFailedCode_name = map[int32]string{
+ 0: "OFPHFC_INCOMPATIBLE",
+ 1: "OFPHFC_EPERM",
+}
+var OfpHelloFailedCode_value = map[string]int32{
+ "OFPHFC_INCOMPATIBLE": 0,
+ "OFPHFC_EPERM": 1,
+}
+
+func (x OfpHelloFailedCode) String() string {
+ return proto.EnumName(OfpHelloFailedCode_name, int32(x))
+}
+func (OfpHelloFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
+
+// ofp_error_msg 'code' values for OFPET_BAD_REQUEST. 'data' contains at least
+// the first 64 bytes of the failed request.
+type OfpBadRequestCode int32
+
+const (
+ OfpBadRequestCode_OFPBRC_BAD_VERSION OfpBadRequestCode = 0
+ OfpBadRequestCode_OFPBRC_BAD_TYPE OfpBadRequestCode = 1
+ OfpBadRequestCode_OFPBRC_BAD_MULTIPART OfpBadRequestCode = 2
+ OfpBadRequestCode_OFPBRC_BAD_EXPERIMENTER OfpBadRequestCode = 3
+ OfpBadRequestCode_OFPBRC_BAD_EXP_TYPE OfpBadRequestCode = 4
+ OfpBadRequestCode_OFPBRC_EPERM OfpBadRequestCode = 5
+ OfpBadRequestCode_OFPBRC_BAD_LEN OfpBadRequestCode = 6
+ OfpBadRequestCode_OFPBRC_BUFFER_EMPTY OfpBadRequestCode = 7
+ OfpBadRequestCode_OFPBRC_BUFFER_UNKNOWN OfpBadRequestCode = 8
+ OfpBadRequestCode_OFPBRC_BAD_TABLE_ID OfpBadRequestCode = 9
+ OfpBadRequestCode_OFPBRC_IS_SLAVE OfpBadRequestCode = 10
+ OfpBadRequestCode_OFPBRC_BAD_PORT OfpBadRequestCode = 11
+ OfpBadRequestCode_OFPBRC_BAD_PACKET OfpBadRequestCode = 12
+ OfpBadRequestCode_OFPBRC_MULTIPART_BUFFER_OVERFLOW OfpBadRequestCode = 13
+)
+
+var OfpBadRequestCode_name = map[int32]string{
+ 0: "OFPBRC_BAD_VERSION",
+ 1: "OFPBRC_BAD_TYPE",
+ 2: "OFPBRC_BAD_MULTIPART",
+ 3: "OFPBRC_BAD_EXPERIMENTER",
+ 4: "OFPBRC_BAD_EXP_TYPE",
+ 5: "OFPBRC_EPERM",
+ 6: "OFPBRC_BAD_LEN",
+ 7: "OFPBRC_BUFFER_EMPTY",
+ 8: "OFPBRC_BUFFER_UNKNOWN",
+ 9: "OFPBRC_BAD_TABLE_ID",
+ 10: "OFPBRC_IS_SLAVE",
+ 11: "OFPBRC_BAD_PORT",
+ 12: "OFPBRC_BAD_PACKET",
+ 13: "OFPBRC_MULTIPART_BUFFER_OVERFLOW",
+}
+var OfpBadRequestCode_value = map[string]int32{
+ "OFPBRC_BAD_VERSION": 0,
+ "OFPBRC_BAD_TYPE": 1,
+ "OFPBRC_BAD_MULTIPART": 2,
+ "OFPBRC_BAD_EXPERIMENTER": 3,
+ "OFPBRC_BAD_EXP_TYPE": 4,
+ "OFPBRC_EPERM": 5,
+ "OFPBRC_BAD_LEN": 6,
+ "OFPBRC_BUFFER_EMPTY": 7,
+ "OFPBRC_BUFFER_UNKNOWN": 8,
+ "OFPBRC_BAD_TABLE_ID": 9,
+ "OFPBRC_IS_SLAVE": 10,
+ "OFPBRC_BAD_PORT": 11,
+ "OFPBRC_BAD_PACKET": 12,
+ "OFPBRC_MULTIPART_BUFFER_OVERFLOW": 13,
+}
+
+func (x OfpBadRequestCode) String() string {
+ return proto.EnumName(OfpBadRequestCode_name, int32(x))
+}
+func (OfpBadRequestCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{32} }
+
+// ofp_error_msg 'code' values for OFPET_BAD_ACTION. 'data' contains at least
+// the first 64 bytes of the failed request.
+type OfpBadActionCode int32
+
+const (
+ OfpBadActionCode_OFPBAC_BAD_TYPE OfpBadActionCode = 0
+ OfpBadActionCode_OFPBAC_BAD_LEN OfpBadActionCode = 1
+ OfpBadActionCode_OFPBAC_BAD_EXPERIMENTER OfpBadActionCode = 2
+ OfpBadActionCode_OFPBAC_BAD_EXP_TYPE OfpBadActionCode = 3
+ OfpBadActionCode_OFPBAC_BAD_OUT_PORT OfpBadActionCode = 4
+ OfpBadActionCode_OFPBAC_BAD_ARGUMENT OfpBadActionCode = 5
+ OfpBadActionCode_OFPBAC_EPERM OfpBadActionCode = 6
+ OfpBadActionCode_OFPBAC_TOO_MANY OfpBadActionCode = 7
+ OfpBadActionCode_OFPBAC_BAD_QUEUE OfpBadActionCode = 8
+ OfpBadActionCode_OFPBAC_BAD_OUT_GROUP OfpBadActionCode = 9
+ OfpBadActionCode_OFPBAC_MATCH_INCONSISTENT OfpBadActionCode = 10
+ OfpBadActionCode_OFPBAC_UNSUPPORTED_ORDER OfpBadActionCode = 11
+ OfpBadActionCode_OFPBAC_BAD_TAG OfpBadActionCode = 12
+ OfpBadActionCode_OFPBAC_BAD_SET_TYPE OfpBadActionCode = 13
+ OfpBadActionCode_OFPBAC_BAD_SET_LEN OfpBadActionCode = 14
+ OfpBadActionCode_OFPBAC_BAD_SET_ARGUMENT OfpBadActionCode = 15
+)
+
+var OfpBadActionCode_name = map[int32]string{
+ 0: "OFPBAC_BAD_TYPE",
+ 1: "OFPBAC_BAD_LEN",
+ 2: "OFPBAC_BAD_EXPERIMENTER",
+ 3: "OFPBAC_BAD_EXP_TYPE",
+ 4: "OFPBAC_BAD_OUT_PORT",
+ 5: "OFPBAC_BAD_ARGUMENT",
+ 6: "OFPBAC_EPERM",
+ 7: "OFPBAC_TOO_MANY",
+ 8: "OFPBAC_BAD_QUEUE",
+ 9: "OFPBAC_BAD_OUT_GROUP",
+ 10: "OFPBAC_MATCH_INCONSISTENT",
+ 11: "OFPBAC_UNSUPPORTED_ORDER",
+ 12: "OFPBAC_BAD_TAG",
+ 13: "OFPBAC_BAD_SET_TYPE",
+ 14: "OFPBAC_BAD_SET_LEN",
+ 15: "OFPBAC_BAD_SET_ARGUMENT",
+}
+var OfpBadActionCode_value = map[string]int32{
+ "OFPBAC_BAD_TYPE": 0,
+ "OFPBAC_BAD_LEN": 1,
+ "OFPBAC_BAD_EXPERIMENTER": 2,
+ "OFPBAC_BAD_EXP_TYPE": 3,
+ "OFPBAC_BAD_OUT_PORT": 4,
+ "OFPBAC_BAD_ARGUMENT": 5,
+ "OFPBAC_EPERM": 6,
+ "OFPBAC_TOO_MANY": 7,
+ "OFPBAC_BAD_QUEUE": 8,
+ "OFPBAC_BAD_OUT_GROUP": 9,
+ "OFPBAC_MATCH_INCONSISTENT": 10,
+ "OFPBAC_UNSUPPORTED_ORDER": 11,
+ "OFPBAC_BAD_TAG": 12,
+ "OFPBAC_BAD_SET_TYPE": 13,
+ "OFPBAC_BAD_SET_LEN": 14,
+ "OFPBAC_BAD_SET_ARGUMENT": 15,
+}
+
+func (x OfpBadActionCode) String() string {
+ return proto.EnumName(OfpBadActionCode_name, int32(x))
+}
+func (OfpBadActionCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{33} }
+
+// ofp_error_msg 'code' values for OFPET_BAD_INSTRUCTION. 'data' contains at
+// least the first 64 bytes of the failed request.
+type OfpBadInstructionCode int32
+
+const (
+ OfpBadInstructionCode_OFPBIC_UNKNOWN_INST OfpBadInstructionCode = 0
+ OfpBadInstructionCode_OFPBIC_UNSUP_INST OfpBadInstructionCode = 1
+ OfpBadInstructionCode_OFPBIC_BAD_TABLE_ID OfpBadInstructionCode = 2
+ OfpBadInstructionCode_OFPBIC_UNSUP_METADATA OfpBadInstructionCode = 3
+ OfpBadInstructionCode_OFPBIC_UNSUP_METADATA_MASK OfpBadInstructionCode = 4
+ OfpBadInstructionCode_OFPBIC_BAD_EXPERIMENTER OfpBadInstructionCode = 5
+ OfpBadInstructionCode_OFPBIC_BAD_EXP_TYPE OfpBadInstructionCode = 6
+ OfpBadInstructionCode_OFPBIC_BAD_LEN OfpBadInstructionCode = 7
+ OfpBadInstructionCode_OFPBIC_EPERM OfpBadInstructionCode = 8
+)
+
+var OfpBadInstructionCode_name = map[int32]string{
+ 0: "OFPBIC_UNKNOWN_INST",
+ 1: "OFPBIC_UNSUP_INST",
+ 2: "OFPBIC_BAD_TABLE_ID",
+ 3: "OFPBIC_UNSUP_METADATA",
+ 4: "OFPBIC_UNSUP_METADATA_MASK",
+ 5: "OFPBIC_BAD_EXPERIMENTER",
+ 6: "OFPBIC_BAD_EXP_TYPE",
+ 7: "OFPBIC_BAD_LEN",
+ 8: "OFPBIC_EPERM",
+}
+var OfpBadInstructionCode_value = map[string]int32{
+ "OFPBIC_UNKNOWN_INST": 0,
+ "OFPBIC_UNSUP_INST": 1,
+ "OFPBIC_BAD_TABLE_ID": 2,
+ "OFPBIC_UNSUP_METADATA": 3,
+ "OFPBIC_UNSUP_METADATA_MASK": 4,
+ "OFPBIC_BAD_EXPERIMENTER": 5,
+ "OFPBIC_BAD_EXP_TYPE": 6,
+ "OFPBIC_BAD_LEN": 7,
+ "OFPBIC_EPERM": 8,
+}
+
+func (x OfpBadInstructionCode) String() string {
+ return proto.EnumName(OfpBadInstructionCode_name, int32(x))
+}
+func (OfpBadInstructionCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{34} }
+
+// ofp_error_msg 'code' values for OFPET_BAD_MATCH. 'data' contains at least
+// the first 64 bytes of the failed request.
+type OfpBadMatchCode int32
+
+const (
+ OfpBadMatchCode_OFPBMC_BAD_TYPE OfpBadMatchCode = 0
+ OfpBadMatchCode_OFPBMC_BAD_LEN OfpBadMatchCode = 1
+ OfpBadMatchCode_OFPBMC_BAD_TAG OfpBadMatchCode = 2
+ OfpBadMatchCode_OFPBMC_BAD_DL_ADDR_MASK OfpBadMatchCode = 3
+ OfpBadMatchCode_OFPBMC_BAD_NW_ADDR_MASK OfpBadMatchCode = 4
+ OfpBadMatchCode_OFPBMC_BAD_WILDCARDS OfpBadMatchCode = 5
+ OfpBadMatchCode_OFPBMC_BAD_FIELD OfpBadMatchCode = 6
+ OfpBadMatchCode_OFPBMC_BAD_VALUE OfpBadMatchCode = 7
+ OfpBadMatchCode_OFPBMC_BAD_MASK OfpBadMatchCode = 8
+ OfpBadMatchCode_OFPBMC_BAD_PREREQ OfpBadMatchCode = 9
+ OfpBadMatchCode_OFPBMC_DUP_FIELD OfpBadMatchCode = 10
+ OfpBadMatchCode_OFPBMC_EPERM OfpBadMatchCode = 11
+)
+
+var OfpBadMatchCode_name = map[int32]string{
+ 0: "OFPBMC_BAD_TYPE",
+ 1: "OFPBMC_BAD_LEN",
+ 2: "OFPBMC_BAD_TAG",
+ 3: "OFPBMC_BAD_DL_ADDR_MASK",
+ 4: "OFPBMC_BAD_NW_ADDR_MASK",
+ 5: "OFPBMC_BAD_WILDCARDS",
+ 6: "OFPBMC_BAD_FIELD",
+ 7: "OFPBMC_BAD_VALUE",
+ 8: "OFPBMC_BAD_MASK",
+ 9: "OFPBMC_BAD_PREREQ",
+ 10: "OFPBMC_DUP_FIELD",
+ 11: "OFPBMC_EPERM",
+}
+var OfpBadMatchCode_value = map[string]int32{
+ "OFPBMC_BAD_TYPE": 0,
+ "OFPBMC_BAD_LEN": 1,
+ "OFPBMC_BAD_TAG": 2,
+ "OFPBMC_BAD_DL_ADDR_MASK": 3,
+ "OFPBMC_BAD_NW_ADDR_MASK": 4,
+ "OFPBMC_BAD_WILDCARDS": 5,
+ "OFPBMC_BAD_FIELD": 6,
+ "OFPBMC_BAD_VALUE": 7,
+ "OFPBMC_BAD_MASK": 8,
+ "OFPBMC_BAD_PREREQ": 9,
+ "OFPBMC_DUP_FIELD": 10,
+ "OFPBMC_EPERM": 11,
+}
+
+func (x OfpBadMatchCode) String() string {
+ return proto.EnumName(OfpBadMatchCode_name, int32(x))
+}
+func (OfpBadMatchCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{35} }
+
+// ofp_error_msg 'code' values for OFPET_FLOW_MOD_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpFlowModFailedCode int32
+
+const (
+ OfpFlowModFailedCode_OFPFMFC_UNKNOWN OfpFlowModFailedCode = 0
+ OfpFlowModFailedCode_OFPFMFC_TABLE_FULL OfpFlowModFailedCode = 1
+ OfpFlowModFailedCode_OFPFMFC_BAD_TABLE_ID OfpFlowModFailedCode = 2
+ OfpFlowModFailedCode_OFPFMFC_OVERLAP OfpFlowModFailedCode = 3
+ OfpFlowModFailedCode_OFPFMFC_EPERM OfpFlowModFailedCode = 4
+ OfpFlowModFailedCode_OFPFMFC_BAD_TIMEOUT OfpFlowModFailedCode = 5
+ OfpFlowModFailedCode_OFPFMFC_BAD_COMMAND OfpFlowModFailedCode = 6
+ OfpFlowModFailedCode_OFPFMFC_BAD_FLAGS OfpFlowModFailedCode = 7
+)
+
+var OfpFlowModFailedCode_name = map[int32]string{
+ 0: "OFPFMFC_UNKNOWN",
+ 1: "OFPFMFC_TABLE_FULL",
+ 2: "OFPFMFC_BAD_TABLE_ID",
+ 3: "OFPFMFC_OVERLAP",
+ 4: "OFPFMFC_EPERM",
+ 5: "OFPFMFC_BAD_TIMEOUT",
+ 6: "OFPFMFC_BAD_COMMAND",
+ 7: "OFPFMFC_BAD_FLAGS",
+}
+var OfpFlowModFailedCode_value = map[string]int32{
+ "OFPFMFC_UNKNOWN": 0,
+ "OFPFMFC_TABLE_FULL": 1,
+ "OFPFMFC_BAD_TABLE_ID": 2,
+ "OFPFMFC_OVERLAP": 3,
+ "OFPFMFC_EPERM": 4,
+ "OFPFMFC_BAD_TIMEOUT": 5,
+ "OFPFMFC_BAD_COMMAND": 6,
+ "OFPFMFC_BAD_FLAGS": 7,
+}
+
+func (x OfpFlowModFailedCode) String() string {
+ return proto.EnumName(OfpFlowModFailedCode_name, int32(x))
+}
+func (OfpFlowModFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{36} }
+
+// ofp_error_msg 'code' values for OFPET_GROUP_MOD_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpGroupModFailedCode int32
+
+const (
+ OfpGroupModFailedCode_OFPGMFC_GROUP_EXISTS OfpGroupModFailedCode = 0
+ OfpGroupModFailedCode_OFPGMFC_INVALID_GROUP OfpGroupModFailedCode = 1
+ OfpGroupModFailedCode_OFPGMFC_WEIGHT_UNSUPPORTED OfpGroupModFailedCode = 2
+ OfpGroupModFailedCode_OFPGMFC_OUT_OF_GROUPS OfpGroupModFailedCode = 3
+ OfpGroupModFailedCode_OFPGMFC_OUT_OF_BUCKETS OfpGroupModFailedCode = 4
+ OfpGroupModFailedCode_OFPGMFC_CHAINING_UNSUPPORTED OfpGroupModFailedCode = 5
+ OfpGroupModFailedCode_OFPGMFC_WATCH_UNSUPPORTED OfpGroupModFailedCode = 6
+ OfpGroupModFailedCode_OFPGMFC_LOOP OfpGroupModFailedCode = 7
+ OfpGroupModFailedCode_OFPGMFC_UNKNOWN_GROUP OfpGroupModFailedCode = 8
+ OfpGroupModFailedCode_OFPGMFC_CHAINED_GROUP OfpGroupModFailedCode = 9
+ OfpGroupModFailedCode_OFPGMFC_BAD_TYPE OfpGroupModFailedCode = 10
+ OfpGroupModFailedCode_OFPGMFC_BAD_COMMAND OfpGroupModFailedCode = 11
+ OfpGroupModFailedCode_OFPGMFC_BAD_BUCKET OfpGroupModFailedCode = 12
+ OfpGroupModFailedCode_OFPGMFC_BAD_WATCH OfpGroupModFailedCode = 13
+ OfpGroupModFailedCode_OFPGMFC_EPERM OfpGroupModFailedCode = 14
+)
+
+var OfpGroupModFailedCode_name = map[int32]string{
+ 0: "OFPGMFC_GROUP_EXISTS",
+ 1: "OFPGMFC_INVALID_GROUP",
+ 2: "OFPGMFC_WEIGHT_UNSUPPORTED",
+ 3: "OFPGMFC_OUT_OF_GROUPS",
+ 4: "OFPGMFC_OUT_OF_BUCKETS",
+ 5: "OFPGMFC_CHAINING_UNSUPPORTED",
+ 6: "OFPGMFC_WATCH_UNSUPPORTED",
+ 7: "OFPGMFC_LOOP",
+ 8: "OFPGMFC_UNKNOWN_GROUP",
+ 9: "OFPGMFC_CHAINED_GROUP",
+ 10: "OFPGMFC_BAD_TYPE",
+ 11: "OFPGMFC_BAD_COMMAND",
+ 12: "OFPGMFC_BAD_BUCKET",
+ 13: "OFPGMFC_BAD_WATCH",
+ 14: "OFPGMFC_EPERM",
+}
+var OfpGroupModFailedCode_value = map[string]int32{
+ "OFPGMFC_GROUP_EXISTS": 0,
+ "OFPGMFC_INVALID_GROUP": 1,
+ "OFPGMFC_WEIGHT_UNSUPPORTED": 2,
+ "OFPGMFC_OUT_OF_GROUPS": 3,
+ "OFPGMFC_OUT_OF_BUCKETS": 4,
+ "OFPGMFC_CHAINING_UNSUPPORTED": 5,
+ "OFPGMFC_WATCH_UNSUPPORTED": 6,
+ "OFPGMFC_LOOP": 7,
+ "OFPGMFC_UNKNOWN_GROUP": 8,
+ "OFPGMFC_CHAINED_GROUP": 9,
+ "OFPGMFC_BAD_TYPE": 10,
+ "OFPGMFC_BAD_COMMAND": 11,
+ "OFPGMFC_BAD_BUCKET": 12,
+ "OFPGMFC_BAD_WATCH": 13,
+ "OFPGMFC_EPERM": 14,
+}
+
+func (x OfpGroupModFailedCode) String() string {
+ return proto.EnumName(OfpGroupModFailedCode_name, int32(x))
+}
+func (OfpGroupModFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{37} }
+
+// ofp_error_msg 'code' values for OFPET_PORT_MOD_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpPortModFailedCode int32
+
+const (
+ OfpPortModFailedCode_OFPPMFC_BAD_PORT OfpPortModFailedCode = 0
+ OfpPortModFailedCode_OFPPMFC_BAD_HW_ADDR OfpPortModFailedCode = 1
+ OfpPortModFailedCode_OFPPMFC_BAD_CONFIG OfpPortModFailedCode = 2
+ OfpPortModFailedCode_OFPPMFC_BAD_ADVERTISE OfpPortModFailedCode = 3
+ OfpPortModFailedCode_OFPPMFC_EPERM OfpPortModFailedCode = 4
+)
+
+var OfpPortModFailedCode_name = map[int32]string{
+ 0: "OFPPMFC_BAD_PORT",
+ 1: "OFPPMFC_BAD_HW_ADDR",
+ 2: "OFPPMFC_BAD_CONFIG",
+ 3: "OFPPMFC_BAD_ADVERTISE",
+ 4: "OFPPMFC_EPERM",
+}
+var OfpPortModFailedCode_value = map[string]int32{
+ "OFPPMFC_BAD_PORT": 0,
+ "OFPPMFC_BAD_HW_ADDR": 1,
+ "OFPPMFC_BAD_CONFIG": 2,
+ "OFPPMFC_BAD_ADVERTISE": 3,
+ "OFPPMFC_EPERM": 4,
+}
+
+func (x OfpPortModFailedCode) String() string {
+ return proto.EnumName(OfpPortModFailedCode_name, int32(x))
+}
+func (OfpPortModFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{38} }
+
+// ofp_error_msg 'code' values for OFPET_TABLE_MOD_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpTableModFailedCode int32
+
+const (
+ OfpTableModFailedCode_OFPTMFC_BAD_TABLE OfpTableModFailedCode = 0
+ OfpTableModFailedCode_OFPTMFC_BAD_CONFIG OfpTableModFailedCode = 1
+ OfpTableModFailedCode_OFPTMFC_EPERM OfpTableModFailedCode = 2
+)
+
+var OfpTableModFailedCode_name = map[int32]string{
+ 0: "OFPTMFC_BAD_TABLE",
+ 1: "OFPTMFC_BAD_CONFIG",
+ 2: "OFPTMFC_EPERM",
+}
+var OfpTableModFailedCode_value = map[string]int32{
+ "OFPTMFC_BAD_TABLE": 0,
+ "OFPTMFC_BAD_CONFIG": 1,
+ "OFPTMFC_EPERM": 2,
+}
+
+func (x OfpTableModFailedCode) String() string {
+ return proto.EnumName(OfpTableModFailedCode_name, int32(x))
+}
+func (OfpTableModFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{39} }
+
+// ofp_error msg 'code' values for OFPET_QUEUE_OP_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request
+type OfpQueueOpFailedCode int32
+
+const (
+ OfpQueueOpFailedCode_OFPQOFC_BAD_PORT OfpQueueOpFailedCode = 0
+ OfpQueueOpFailedCode_OFPQOFC_BAD_QUEUE OfpQueueOpFailedCode = 1
+ OfpQueueOpFailedCode_OFPQOFC_EPERM OfpQueueOpFailedCode = 2
+)
+
+var OfpQueueOpFailedCode_name = map[int32]string{
+ 0: "OFPQOFC_BAD_PORT",
+ 1: "OFPQOFC_BAD_QUEUE",
+ 2: "OFPQOFC_EPERM",
+}
+var OfpQueueOpFailedCode_value = map[string]int32{
+ "OFPQOFC_BAD_PORT": 0,
+ "OFPQOFC_BAD_QUEUE": 1,
+ "OFPQOFC_EPERM": 2,
+}
+
+func (x OfpQueueOpFailedCode) String() string {
+ return proto.EnumName(OfpQueueOpFailedCode_name, int32(x))
+}
+func (OfpQueueOpFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{40} }
+
+// ofp_error_msg 'code' values for OFPET_SWITCH_CONFIG_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpSwitchConfigFailedCode int32
+
+const (
+ OfpSwitchConfigFailedCode_OFPSCFC_BAD_FLAGS OfpSwitchConfigFailedCode = 0
+ OfpSwitchConfigFailedCode_OFPSCFC_BAD_LEN OfpSwitchConfigFailedCode = 1
+ OfpSwitchConfigFailedCode_OFPSCFC_EPERM OfpSwitchConfigFailedCode = 2
+)
+
+var OfpSwitchConfigFailedCode_name = map[int32]string{
+ 0: "OFPSCFC_BAD_FLAGS",
+ 1: "OFPSCFC_BAD_LEN",
+ 2: "OFPSCFC_EPERM",
+}
+var OfpSwitchConfigFailedCode_value = map[string]int32{
+ "OFPSCFC_BAD_FLAGS": 0,
+ "OFPSCFC_BAD_LEN": 1,
+ "OFPSCFC_EPERM": 2,
+}
+
+func (x OfpSwitchConfigFailedCode) String() string {
+ return proto.EnumName(OfpSwitchConfigFailedCode_name, int32(x))
+}
+func (OfpSwitchConfigFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{41} }
+
+// ofp_error_msg 'code' values for OFPET_ROLE_REQUEST_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpRoleRequestFailedCode int32
+
+const (
+ OfpRoleRequestFailedCode_OFPRRFC_STALE OfpRoleRequestFailedCode = 0
+ OfpRoleRequestFailedCode_OFPRRFC_UNSUP OfpRoleRequestFailedCode = 1
+ OfpRoleRequestFailedCode_OFPRRFC_BAD_ROLE OfpRoleRequestFailedCode = 2
+)
+
+var OfpRoleRequestFailedCode_name = map[int32]string{
+ 0: "OFPRRFC_STALE",
+ 1: "OFPRRFC_UNSUP",
+ 2: "OFPRRFC_BAD_ROLE",
+}
+var OfpRoleRequestFailedCode_value = map[string]int32{
+ "OFPRRFC_STALE": 0,
+ "OFPRRFC_UNSUP": 1,
+ "OFPRRFC_BAD_ROLE": 2,
+}
+
+func (x OfpRoleRequestFailedCode) String() string {
+ return proto.EnumName(OfpRoleRequestFailedCode_name, int32(x))
+}
+func (OfpRoleRequestFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{42} }
+
+// ofp_error_msg 'code' values for OFPET_METER_MOD_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpMeterModFailedCode int32
+
+const (
+ OfpMeterModFailedCode_OFPMMFC_UNKNOWN OfpMeterModFailedCode = 0
+ OfpMeterModFailedCode_OFPMMFC_METER_EXISTS OfpMeterModFailedCode = 1
+ OfpMeterModFailedCode_OFPMMFC_INVALID_METER OfpMeterModFailedCode = 2
+ OfpMeterModFailedCode_OFPMMFC_UNKNOWN_METER OfpMeterModFailedCode = 3
+ OfpMeterModFailedCode_OFPMMFC_BAD_COMMAND OfpMeterModFailedCode = 4
+ OfpMeterModFailedCode_OFPMMFC_BAD_FLAGS OfpMeterModFailedCode = 5
+ OfpMeterModFailedCode_OFPMMFC_BAD_RATE OfpMeterModFailedCode = 6
+ OfpMeterModFailedCode_OFPMMFC_BAD_BURST OfpMeterModFailedCode = 7
+ OfpMeterModFailedCode_OFPMMFC_BAD_BAND OfpMeterModFailedCode = 8
+ OfpMeterModFailedCode_OFPMMFC_BAD_BAND_VALUE OfpMeterModFailedCode = 9
+ OfpMeterModFailedCode_OFPMMFC_OUT_OF_METERS OfpMeterModFailedCode = 10
+ OfpMeterModFailedCode_OFPMMFC_OUT_OF_BANDS OfpMeterModFailedCode = 11
+)
+
+var OfpMeterModFailedCode_name = map[int32]string{
+ 0: "OFPMMFC_UNKNOWN",
+ 1: "OFPMMFC_METER_EXISTS",
+ 2: "OFPMMFC_INVALID_METER",
+ 3: "OFPMMFC_UNKNOWN_METER",
+ 4: "OFPMMFC_BAD_COMMAND",
+ 5: "OFPMMFC_BAD_FLAGS",
+ 6: "OFPMMFC_BAD_RATE",
+ 7: "OFPMMFC_BAD_BURST",
+ 8: "OFPMMFC_BAD_BAND",
+ 9: "OFPMMFC_BAD_BAND_VALUE",
+ 10: "OFPMMFC_OUT_OF_METERS",
+ 11: "OFPMMFC_OUT_OF_BANDS",
+}
+var OfpMeterModFailedCode_value = map[string]int32{
+ "OFPMMFC_UNKNOWN": 0,
+ "OFPMMFC_METER_EXISTS": 1,
+ "OFPMMFC_INVALID_METER": 2,
+ "OFPMMFC_UNKNOWN_METER": 3,
+ "OFPMMFC_BAD_COMMAND": 4,
+ "OFPMMFC_BAD_FLAGS": 5,
+ "OFPMMFC_BAD_RATE": 6,
+ "OFPMMFC_BAD_BURST": 7,
+ "OFPMMFC_BAD_BAND": 8,
+ "OFPMMFC_BAD_BAND_VALUE": 9,
+ "OFPMMFC_OUT_OF_METERS": 10,
+ "OFPMMFC_OUT_OF_BANDS": 11,
+}
+
+func (x OfpMeterModFailedCode) String() string {
+ return proto.EnumName(OfpMeterModFailedCode_name, int32(x))
+}
+func (OfpMeterModFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{43} }
+
+// ofp_error_msg 'code' values for OFPET_TABLE_FEATURES_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpTableFeaturesFailedCode int32
+
+const (
+ OfpTableFeaturesFailedCode_OFPTFFC_BAD_TABLE OfpTableFeaturesFailedCode = 0
+ OfpTableFeaturesFailedCode_OFPTFFC_BAD_METADATA OfpTableFeaturesFailedCode = 1
+ OfpTableFeaturesFailedCode_OFPTFFC_BAD_TYPE OfpTableFeaturesFailedCode = 2
+ OfpTableFeaturesFailedCode_OFPTFFC_BAD_LEN OfpTableFeaturesFailedCode = 3
+ OfpTableFeaturesFailedCode_OFPTFFC_BAD_ARGUMENT OfpTableFeaturesFailedCode = 4
+ OfpTableFeaturesFailedCode_OFPTFFC_EPERM OfpTableFeaturesFailedCode = 5
+)
+
+var OfpTableFeaturesFailedCode_name = map[int32]string{
+ 0: "OFPTFFC_BAD_TABLE",
+ 1: "OFPTFFC_BAD_METADATA",
+ 2: "OFPTFFC_BAD_TYPE",
+ 3: "OFPTFFC_BAD_LEN",
+ 4: "OFPTFFC_BAD_ARGUMENT",
+ 5: "OFPTFFC_EPERM",
+}
+var OfpTableFeaturesFailedCode_value = map[string]int32{
+ "OFPTFFC_BAD_TABLE": 0,
+ "OFPTFFC_BAD_METADATA": 1,
+ "OFPTFFC_BAD_TYPE": 2,
+ "OFPTFFC_BAD_LEN": 3,
+ "OFPTFFC_BAD_ARGUMENT": 4,
+ "OFPTFFC_EPERM": 5,
+}
+
+func (x OfpTableFeaturesFailedCode) String() string {
+ return proto.EnumName(OfpTableFeaturesFailedCode_name, int32(x))
+}
+func (OfpTableFeaturesFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{44} }
+
+type OfpMultipartType int32
+
+const (
+ // Description of this OpenFlow switch.
+ // The request body is empty.
+ // The reply body is struct ofp_desc.
+ OfpMultipartType_OFPMP_DESC OfpMultipartType = 0
+ // Individual flow statistics.
+ // The request body is struct ofp_flow_stats_request.
+ // The reply body is an array of struct ofp_flow_stats.
+ OfpMultipartType_OFPMP_FLOW OfpMultipartType = 1
+ // Aggregate flow statistics.
+ // The request body is struct ofp_aggregate_stats_request.
+ // The reply body is struct ofp_aggregate_stats_reply.
+ OfpMultipartType_OFPMP_AGGREGATE OfpMultipartType = 2
+ // Flow table statistics.
+ // The request body is empty.
+ // The reply body is an array of struct ofp_table_stats.
+ OfpMultipartType_OFPMP_TABLE OfpMultipartType = 3
+ // Port statistics.
+ // The request body is struct ofp_port_stats_request.
+ // The reply body is an array of struct ofp_port_stats.
+ OfpMultipartType_OFPMP_PORT_STATS OfpMultipartType = 4
+ // Queue statistics for a port
+ // The request body is struct ofp_queue_stats_request.
+ // The reply body is an array of struct ofp_queue_stats
+ OfpMultipartType_OFPMP_QUEUE OfpMultipartType = 5
+ // Group counter statistics.
+ // The request body is struct ofp_group_stats_request.
+ // The reply is an array of struct ofp_group_stats.
+ OfpMultipartType_OFPMP_GROUP OfpMultipartType = 6
+ // Group description.
+ // The request body is empty.
+ // The reply body is an array of struct ofp_group_desc.
+ OfpMultipartType_OFPMP_GROUP_DESC OfpMultipartType = 7
+ // Group features.
+ // The request body is empty.
+ // The reply body is struct ofp_group_features.
+ OfpMultipartType_OFPMP_GROUP_FEATURES OfpMultipartType = 8
+ // Meter statistics.
+ // The request body is struct ofp_meter_multipart_requests.
+ // The reply body is an array of struct ofp_meter_stats.
+ OfpMultipartType_OFPMP_METER OfpMultipartType = 9
+ // Meter configuration.
+ // The request body is struct ofp_meter_multipart_requests.
+ // The reply body is an array of struct ofp_meter_config.
+ OfpMultipartType_OFPMP_METER_CONFIG OfpMultipartType = 10
+ // Meter features.
+ // The request body is empty.
+ // The reply body is struct ofp_meter_features.
+ OfpMultipartType_OFPMP_METER_FEATURES OfpMultipartType = 11
+ // Table features.
+ // The request body is either empty or contains an array of
+ // struct ofp_table_features containing the controller's
+ // desired view of the switch. If the switch is unable to
+ // set the specified view an error is returned.
+ // The reply body is an array of struct ofp_table_features.
+ OfpMultipartType_OFPMP_TABLE_FEATURES OfpMultipartType = 12
+ // Port description.
+ // The request body is empty.
+ // The reply body is an array of struct ofp_port.
+ OfpMultipartType_OFPMP_PORT_DESC OfpMultipartType = 13
+ // Experimenter extension.
+ // The request and reply bodies begin with
+ // struct ofp_experimenter_multipart_header.
+ // The request and reply bodies are otherwise experimenter-defined.
+ OfpMultipartType_OFPMP_EXPERIMENTER OfpMultipartType = 65535
+)
+
+var OfpMultipartType_name = map[int32]string{
+ 0: "OFPMP_DESC",
+ 1: "OFPMP_FLOW",
+ 2: "OFPMP_AGGREGATE",
+ 3: "OFPMP_TABLE",
+ 4: "OFPMP_PORT_STATS",
+ 5: "OFPMP_QUEUE",
+ 6: "OFPMP_GROUP",
+ 7: "OFPMP_GROUP_DESC",
+ 8: "OFPMP_GROUP_FEATURES",
+ 9: "OFPMP_METER",
+ 10: "OFPMP_METER_CONFIG",
+ 11: "OFPMP_METER_FEATURES",
+ 12: "OFPMP_TABLE_FEATURES",
+ 13: "OFPMP_PORT_DESC",
+ 65535: "OFPMP_EXPERIMENTER",
+}
+var OfpMultipartType_value = map[string]int32{
+ "OFPMP_DESC": 0,
+ "OFPMP_FLOW": 1,
+ "OFPMP_AGGREGATE": 2,
+ "OFPMP_TABLE": 3,
+ "OFPMP_PORT_STATS": 4,
+ "OFPMP_QUEUE": 5,
+ "OFPMP_GROUP": 6,
+ "OFPMP_GROUP_DESC": 7,
+ "OFPMP_GROUP_FEATURES": 8,
+ "OFPMP_METER": 9,
+ "OFPMP_METER_CONFIG": 10,
+ "OFPMP_METER_FEATURES": 11,
+ "OFPMP_TABLE_FEATURES": 12,
+ "OFPMP_PORT_DESC": 13,
+ "OFPMP_EXPERIMENTER": 65535,
+}
+
+func (x OfpMultipartType) String() string {
+ return proto.EnumName(OfpMultipartType_name, int32(x))
+}
+func (OfpMultipartType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{45} }
+
+type OfpMultipartRequestFlags int32
+
+const (
+ OfpMultipartRequestFlags_OFPMPF_REQ_INVALID OfpMultipartRequestFlags = 0
+ OfpMultipartRequestFlags_OFPMPF_REQ_MORE OfpMultipartRequestFlags = 1
+)
+
+var OfpMultipartRequestFlags_name = map[int32]string{
+ 0: "OFPMPF_REQ_INVALID",
+ 1: "OFPMPF_REQ_MORE",
+}
+var OfpMultipartRequestFlags_value = map[string]int32{
+ "OFPMPF_REQ_INVALID": 0,
+ "OFPMPF_REQ_MORE": 1,
+}
+
+func (x OfpMultipartRequestFlags) String() string {
+ return proto.EnumName(OfpMultipartRequestFlags_name, int32(x))
+}
+func (OfpMultipartRequestFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{46} }
+
+type OfpMultipartReplyFlags int32
+
+const (
+ OfpMultipartReplyFlags_OFPMPF_REPLY_INVALID OfpMultipartReplyFlags = 0
+ OfpMultipartReplyFlags_OFPMPF_REPLY_MORE OfpMultipartReplyFlags = 1
+)
+
+var OfpMultipartReplyFlags_name = map[int32]string{
+ 0: "OFPMPF_REPLY_INVALID",
+ 1: "OFPMPF_REPLY_MORE",
+}
+var OfpMultipartReplyFlags_value = map[string]int32{
+ "OFPMPF_REPLY_INVALID": 0,
+ "OFPMPF_REPLY_MORE": 1,
+}
+
+func (x OfpMultipartReplyFlags) String() string {
+ return proto.EnumName(OfpMultipartReplyFlags_name, int32(x))
+}
+func (OfpMultipartReplyFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{47} }
+
+// Table Feature property types.
+// Low order bit cleared indicates a property for a regular Flow Entry.
+// Low order bit set indicates a property for the Table-Miss Flow Entry.
+type OfpTableFeaturePropType int32
+
+const (
+ OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS OfpTableFeaturePropType = 0
+ OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS_MISS OfpTableFeaturePropType = 1
+ OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES OfpTableFeaturePropType = 2
+ OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES_MISS OfpTableFeaturePropType = 3
+ OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS OfpTableFeaturePropType = 4
+ OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS_MISS OfpTableFeaturePropType = 5
+ OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS OfpTableFeaturePropType = 6
+ OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS_MISS OfpTableFeaturePropType = 7
+ OfpTableFeaturePropType_OFPTFPT_MATCH OfpTableFeaturePropType = 8
+ OfpTableFeaturePropType_OFPTFPT_WILDCARDS OfpTableFeaturePropType = 10
+ OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD OfpTableFeaturePropType = 12
+ OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD_MISS OfpTableFeaturePropType = 13
+ OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD OfpTableFeaturePropType = 14
+ OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD_MISS OfpTableFeaturePropType = 15
+ OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER OfpTableFeaturePropType = 65534
+ OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER_MISS OfpTableFeaturePropType = 65535
+)
+
+var OfpTableFeaturePropType_name = map[int32]string{
+ 0: "OFPTFPT_INSTRUCTIONS",
+ 1: "OFPTFPT_INSTRUCTIONS_MISS",
+ 2: "OFPTFPT_NEXT_TABLES",
+ 3: "OFPTFPT_NEXT_TABLES_MISS",
+ 4: "OFPTFPT_WRITE_ACTIONS",
+ 5: "OFPTFPT_WRITE_ACTIONS_MISS",
+ 6: "OFPTFPT_APPLY_ACTIONS",
+ 7: "OFPTFPT_APPLY_ACTIONS_MISS",
+ 8: "OFPTFPT_MATCH",
+ 10: "OFPTFPT_WILDCARDS",
+ 12: "OFPTFPT_WRITE_SETFIELD",
+ 13: "OFPTFPT_WRITE_SETFIELD_MISS",
+ 14: "OFPTFPT_APPLY_SETFIELD",
+ 15: "OFPTFPT_APPLY_SETFIELD_MISS",
+ 65534: "OFPTFPT_EXPERIMENTER",
+ 65535: "OFPTFPT_EXPERIMENTER_MISS",
+}
+var OfpTableFeaturePropType_value = map[string]int32{
+ "OFPTFPT_INSTRUCTIONS": 0,
+ "OFPTFPT_INSTRUCTIONS_MISS": 1,
+ "OFPTFPT_NEXT_TABLES": 2,
+ "OFPTFPT_NEXT_TABLES_MISS": 3,
+ "OFPTFPT_WRITE_ACTIONS": 4,
+ "OFPTFPT_WRITE_ACTIONS_MISS": 5,
+ "OFPTFPT_APPLY_ACTIONS": 6,
+ "OFPTFPT_APPLY_ACTIONS_MISS": 7,
+ "OFPTFPT_MATCH": 8,
+ "OFPTFPT_WILDCARDS": 10,
+ "OFPTFPT_WRITE_SETFIELD": 12,
+ "OFPTFPT_WRITE_SETFIELD_MISS": 13,
+ "OFPTFPT_APPLY_SETFIELD": 14,
+ "OFPTFPT_APPLY_SETFIELD_MISS": 15,
+ "OFPTFPT_EXPERIMENTER": 65534,
+ "OFPTFPT_EXPERIMENTER_MISS": 65535,
+}
+
+func (x OfpTableFeaturePropType) String() string {
+ return proto.EnumName(OfpTableFeaturePropType_name, int32(x))
+}
+func (OfpTableFeaturePropType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{48} }
+
+// Group configuration flags
+type OfpGroupCapabilities int32
+
+const (
+ OfpGroupCapabilities_OFPGFC_INVALID OfpGroupCapabilities = 0
+ OfpGroupCapabilities_OFPGFC_SELECT_WEIGHT OfpGroupCapabilities = 1
+ OfpGroupCapabilities_OFPGFC_SELECT_LIVENESS OfpGroupCapabilities = 2
+ OfpGroupCapabilities_OFPGFC_CHAINING OfpGroupCapabilities = 4
+ OfpGroupCapabilities_OFPGFC_CHAINING_CHECKS OfpGroupCapabilities = 8
+)
+
+var OfpGroupCapabilities_name = map[int32]string{
+ 0: "OFPGFC_INVALID",
+ 1: "OFPGFC_SELECT_WEIGHT",
+ 2: "OFPGFC_SELECT_LIVENESS",
+ 4: "OFPGFC_CHAINING",
+ 8: "OFPGFC_CHAINING_CHECKS",
+}
+var OfpGroupCapabilities_value = map[string]int32{
+ "OFPGFC_INVALID": 0,
+ "OFPGFC_SELECT_WEIGHT": 1,
+ "OFPGFC_SELECT_LIVENESS": 2,
+ "OFPGFC_CHAINING": 4,
+ "OFPGFC_CHAINING_CHECKS": 8,
+}
+
+func (x OfpGroupCapabilities) String() string {
+ return proto.EnumName(OfpGroupCapabilities_name, int32(x))
+}
+func (OfpGroupCapabilities) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{49} }
+
+type OfpQueueProperties int32
+
+const (
+ OfpQueueProperties_OFPQT_INVALID OfpQueueProperties = 0
+ OfpQueueProperties_OFPQT_MIN_RATE OfpQueueProperties = 1
+ OfpQueueProperties_OFPQT_MAX_RATE OfpQueueProperties = 2
+ OfpQueueProperties_OFPQT_EXPERIMENTER OfpQueueProperties = 65535
+)
+
+var OfpQueueProperties_name = map[int32]string{
+ 0: "OFPQT_INVALID",
+ 1: "OFPQT_MIN_RATE",
+ 2: "OFPQT_MAX_RATE",
+ 65535: "OFPQT_EXPERIMENTER",
+}
+var OfpQueueProperties_value = map[string]int32{
+ "OFPQT_INVALID": 0,
+ "OFPQT_MIN_RATE": 1,
+ "OFPQT_MAX_RATE": 2,
+ "OFPQT_EXPERIMENTER": 65535,
+}
+
+func (x OfpQueueProperties) String() string {
+ return proto.EnumName(OfpQueueProperties_name, int32(x))
+}
+func (OfpQueueProperties) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{50} }
+
+// Controller roles.
+type OfpControllerRole int32
+
+const (
+ OfpControllerRole_OFPCR_ROLE_NOCHANGE OfpControllerRole = 0
+ OfpControllerRole_OFPCR_ROLE_EQUAL OfpControllerRole = 1
+ OfpControllerRole_OFPCR_ROLE_MASTER OfpControllerRole = 2
+ OfpControllerRole_OFPCR_ROLE_SLAVE OfpControllerRole = 3
+)
+
+var OfpControllerRole_name = map[int32]string{
+ 0: "OFPCR_ROLE_NOCHANGE",
+ 1: "OFPCR_ROLE_EQUAL",
+ 2: "OFPCR_ROLE_MASTER",
+ 3: "OFPCR_ROLE_SLAVE",
+}
+var OfpControllerRole_value = map[string]int32{
+ "OFPCR_ROLE_NOCHANGE": 0,
+ "OFPCR_ROLE_EQUAL": 1,
+ "OFPCR_ROLE_MASTER": 2,
+ "OFPCR_ROLE_SLAVE": 3,
+}
+
+func (x OfpControllerRole) String() string {
+ return proto.EnumName(OfpControllerRole_name, int32(x))
+}
+func (OfpControllerRole) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{51} }
+
+// Header on all OpenFlow packets.
+type OfpHeader struct {
+ Version uint32 `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
+ Type OfpType `protobuf:"varint,2,opt,name=type,enum=openflow_13.OfpType" json:"type,omitempty"`
+ Xid uint32 `protobuf:"varint,3,opt,name=xid" json:"xid,omitempty"`
+}
+
+func (m *OfpHeader) Reset() { *m = OfpHeader{} }
+func (m *OfpHeader) String() string { return proto.CompactTextString(m) }
+func (*OfpHeader) ProtoMessage() {}
+func (*OfpHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *OfpHeader) GetVersion() uint32 {
+ if m != nil {
+ return m.Version
+ }
+ return 0
+}
+
+func (m *OfpHeader) GetType() OfpType {
+ if m != nil {
+ return m.Type
+ }
+ return OfpType_OFPT_HELLO
+}
+
+func (m *OfpHeader) GetXid() uint32 {
+ if m != nil {
+ return m.Xid
+ }
+ return 0
+}
+
+// Common header for all Hello Elements
+type OfpHelloElemHeader struct {
+ Type OfpHelloElemType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpHelloElemType" json:"type,omitempty"`
+ // Types that are valid to be assigned to Element:
+ // *OfpHelloElemHeader_Versionbitmap
+ Element isOfpHelloElemHeader_Element `protobuf_oneof:"element"`
+}
+
+func (m *OfpHelloElemHeader) Reset() { *m = OfpHelloElemHeader{} }
+func (m *OfpHelloElemHeader) String() string { return proto.CompactTextString(m) }
+func (*OfpHelloElemHeader) ProtoMessage() {}
+func (*OfpHelloElemHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+type isOfpHelloElemHeader_Element interface {
+ isOfpHelloElemHeader_Element()
+}
+
+type OfpHelloElemHeader_Versionbitmap struct {
+ Versionbitmap *OfpHelloElemVersionbitmap `protobuf:"bytes,2,opt,name=versionbitmap,oneof"`
+}
+
+func (*OfpHelloElemHeader_Versionbitmap) isOfpHelloElemHeader_Element() {}
+
+func (m *OfpHelloElemHeader) GetElement() isOfpHelloElemHeader_Element {
+ if m != nil {
+ return m.Element
+ }
+ return nil
+}
+
+func (m *OfpHelloElemHeader) GetType() OfpHelloElemType {
+ if m != nil {
+ return m.Type
+ }
+ return OfpHelloElemType_OFPHET_INVALID
+}
+
+func (m *OfpHelloElemHeader) GetVersionbitmap() *OfpHelloElemVersionbitmap {
+ if x, ok := m.GetElement().(*OfpHelloElemHeader_Versionbitmap); ok {
+ return x.Versionbitmap
+ }
+ return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpHelloElemHeader) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _OfpHelloElemHeader_OneofMarshaler, _OfpHelloElemHeader_OneofUnmarshaler, _OfpHelloElemHeader_OneofSizer, []interface{}{
+ (*OfpHelloElemHeader_Versionbitmap)(nil),
+ }
+}
+
+func _OfpHelloElemHeader_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpHelloElemHeader)
+ // element
+ switch x := m.Element.(type) {
+ case *OfpHelloElemHeader_Versionbitmap:
+ b.EncodeVarint(2<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Versionbitmap); err != nil {
+ return err
+ }
+ case nil:
+ default:
+ return fmt.Errorf("OfpHelloElemHeader.Element has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _OfpHelloElemHeader_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpHelloElemHeader)
+ switch tag {
+ case 2: // element.versionbitmap
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpHelloElemVersionbitmap)
+ err := b.DecodeMessage(msg)
+ m.Element = &OfpHelloElemHeader_Versionbitmap{msg}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _OfpHelloElemHeader_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*OfpHelloElemHeader)
+ // element
+ switch x := m.Element.(type) {
+ case *OfpHelloElemHeader_Versionbitmap:
+ s := proto.Size(x.Versionbitmap)
+ n += proto.SizeVarint(2<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+// Version bitmap Hello Element
+type OfpHelloElemVersionbitmap struct {
+ Bitmaps []uint32 `protobuf:"varint,2,rep,packed,name=bitmaps" json:"bitmaps,omitempty"`
+}
+
+func (m *OfpHelloElemVersionbitmap) Reset() { *m = OfpHelloElemVersionbitmap{} }
+func (m *OfpHelloElemVersionbitmap) String() string { return proto.CompactTextString(m) }
+func (*OfpHelloElemVersionbitmap) ProtoMessage() {}
+func (*OfpHelloElemVersionbitmap) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *OfpHelloElemVersionbitmap) GetBitmaps() []uint32 {
+ if m != nil {
+ return m.Bitmaps
+ }
+ return nil
+}
+
+// OFPT_HELLO. This message includes zero or more hello elements having
+// variable size. Unknown elements types must be ignored/skipped, to allow
+// for future extensions.
+type OfpHello struct {
+ // Hello element list
+ Elements []*OfpHelloElemHeader `protobuf:"bytes,1,rep,name=elements" json:"elements,omitempty"`
+}
+
+func (m *OfpHello) Reset() { *m = OfpHello{} }
+func (m *OfpHello) String() string { return proto.CompactTextString(m) }
+func (*OfpHello) ProtoMessage() {}
+func (*OfpHello) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *OfpHello) GetElements() []*OfpHelloElemHeader {
+ if m != nil {
+ return m.Elements
+ }
+ return nil
+}
+
+// Switch configuration.
+type OfpSwitchConfig struct {
+ // ofp_header header;
+ Flags uint32 `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"`
+ MissSendLen uint32 `protobuf:"varint,2,opt,name=miss_send_len,json=missSendLen" json:"miss_send_len,omitempty"`
+}
+
+func (m *OfpSwitchConfig) Reset() { *m = OfpSwitchConfig{} }
+func (m *OfpSwitchConfig) String() string { return proto.CompactTextString(m) }
+func (*OfpSwitchConfig) ProtoMessage() {}
+func (*OfpSwitchConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *OfpSwitchConfig) GetFlags() uint32 {
+ if m != nil {
+ return m.Flags
+ }
+ return 0
+}
+
+func (m *OfpSwitchConfig) GetMissSendLen() uint32 {
+ if m != nil {
+ return m.MissSendLen
+ }
+ return 0
+}
+
+// Configure/Modify behavior of a flow table
+type OfpTableMod struct {
+ // ofp_header header;
+ TableId uint32 `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+ Config uint32 `protobuf:"varint,2,opt,name=config" json:"config,omitempty"`
+}
+
+func (m *OfpTableMod) Reset() { *m = OfpTableMod{} }
+func (m *OfpTableMod) String() string { return proto.CompactTextString(m) }
+func (*OfpTableMod) ProtoMessage() {}
+func (*OfpTableMod) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+func (m *OfpTableMod) GetTableId() uint32 {
+ if m != nil {
+ return m.TableId
+ }
+ return 0
+}
+
+func (m *OfpTableMod) GetConfig() uint32 {
+ if m != nil {
+ return m.Config
+ }
+ return 0
+}
+
+// Description of a port
+type OfpPort struct {
+ PortNo uint32 `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+ HwAddr []uint32 `protobuf:"varint,2,rep,packed,name=hw_addr,json=hwAddr" json:"hw_addr,omitempty"`
+ Name string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"`
+ Config uint32 `protobuf:"varint,4,opt,name=config" json:"config,omitempty"`
+ State uint32 `protobuf:"varint,5,opt,name=state" json:"state,omitempty"`
+ // Bitmaps of OFPPF_* that describe features. All bits zeroed if
+ // unsupported or unavailable.
+ Curr uint32 `protobuf:"varint,6,opt,name=curr" json:"curr,omitempty"`
+ Advertised uint32 `protobuf:"varint,7,opt,name=advertised" json:"advertised,omitempty"`
+ Supported uint32 `protobuf:"varint,8,opt,name=supported" json:"supported,omitempty"`
+ Peer uint32 `protobuf:"varint,9,opt,name=peer" json:"peer,omitempty"`
+ CurrSpeed uint32 `protobuf:"varint,10,opt,name=curr_speed,json=currSpeed" json:"curr_speed,omitempty"`
+ MaxSpeed uint32 `protobuf:"varint,11,opt,name=max_speed,json=maxSpeed" json:"max_speed,omitempty"`
+}
+
+func (m *OfpPort) Reset() { *m = OfpPort{} }
+func (m *OfpPort) String() string { return proto.CompactTextString(m) }
+func (*OfpPort) ProtoMessage() {}
+func (*OfpPort) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+func (m *OfpPort) GetPortNo() uint32 {
+ if m != nil {
+ return m.PortNo
+ }
+ return 0
+}
+
+func (m *OfpPort) GetHwAddr() []uint32 {
+ if m != nil {
+ return m.HwAddr
+ }
+ return nil
+}
+
+func (m *OfpPort) GetName() string {
+ if m != nil {
+ return m.Name
+ }
+ return ""
+}
+
+func (m *OfpPort) GetConfig() uint32 {
+ if m != nil {
+ return m.Config
+ }
+ return 0
+}
+
+func (m *OfpPort) GetState() uint32 {
+ if m != nil {
+ return m.State
+ }
+ return 0
+}
+
+func (m *OfpPort) GetCurr() uint32 {
+ if m != nil {
+ return m.Curr
+ }
+ return 0
+}
+
+func (m *OfpPort) GetAdvertised() uint32 {
+ if m != nil {
+ return m.Advertised
+ }
+ return 0
+}
+
+func (m *OfpPort) GetSupported() uint32 {
+ if m != nil {
+ return m.Supported
+ }
+ return 0
+}
+
+func (m *OfpPort) GetPeer() uint32 {
+ if m != nil {
+ return m.Peer
+ }
+ return 0
+}
+
+func (m *OfpPort) GetCurrSpeed() uint32 {
+ if m != nil {
+ return m.CurrSpeed
+ }
+ return 0
+}
+
+func (m *OfpPort) GetMaxSpeed() uint32 {
+ if m != nil {
+ return m.MaxSpeed
+ }
+ return 0
+}
+
+// Switch features.
+type OfpSwitchFeatures struct {
+ // ofp_header header;
+ DatapathId uint64 `protobuf:"varint,1,opt,name=datapath_id,json=datapathId" json:"datapath_id,omitempty"`
+ NBuffers uint32 `protobuf:"varint,2,opt,name=n_buffers,json=nBuffers" json:"n_buffers,omitempty"`
+ NTables uint32 `protobuf:"varint,3,opt,name=n_tables,json=nTables" json:"n_tables,omitempty"`
+ AuxiliaryId uint32 `protobuf:"varint,4,opt,name=auxiliary_id,json=auxiliaryId" json:"auxiliary_id,omitempty"`
+ // Features.
+ Capabilities uint32 `protobuf:"varint,5,opt,name=capabilities" json:"capabilities,omitempty"`
+}
+
+func (m *OfpSwitchFeatures) Reset() { *m = OfpSwitchFeatures{} }
+func (m *OfpSwitchFeatures) String() string { return proto.CompactTextString(m) }
+func (*OfpSwitchFeatures) ProtoMessage() {}
+func (*OfpSwitchFeatures) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+func (m *OfpSwitchFeatures) GetDatapathId() uint64 {
+ if m != nil {
+ return m.DatapathId
+ }
+ return 0
+}
+
+func (m *OfpSwitchFeatures) GetNBuffers() uint32 {
+ if m != nil {
+ return m.NBuffers
+ }
+ return 0
+}
+
+func (m *OfpSwitchFeatures) GetNTables() uint32 {
+ if m != nil {
+ return m.NTables
+ }
+ return 0
+}
+
+func (m *OfpSwitchFeatures) GetAuxiliaryId() uint32 {
+ if m != nil {
+ return m.AuxiliaryId
+ }
+ return 0
+}
+
+func (m *OfpSwitchFeatures) GetCapabilities() uint32 {
+ if m != nil {
+ return m.Capabilities
+ }
+ return 0
+}
+
+// A physical port has changed in the datapath
+type OfpPortStatus struct {
+ // ofp_header header;
+ Reason OfpPortReason `protobuf:"varint,1,opt,name=reason,enum=openflow_13.OfpPortReason" json:"reason,omitempty"`
+ Desc *OfpPort `protobuf:"bytes,2,opt,name=desc" json:"desc,omitempty"`
+}
+
+func (m *OfpPortStatus) Reset() { *m = OfpPortStatus{} }
+func (m *OfpPortStatus) String() string { return proto.CompactTextString(m) }
+func (*OfpPortStatus) ProtoMessage() {}
+func (*OfpPortStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+func (m *OfpPortStatus) GetReason() OfpPortReason {
+ if m != nil {
+ return m.Reason
+ }
+ return OfpPortReason_OFPPR_ADD
+}
+
+func (m *OfpPortStatus) GetDesc() *OfpPort {
+ if m != nil {
+ return m.Desc
+ }
+ return nil
+}
+
+// Modify behavior of the physical port
+type OfpPortMod struct {
+ // ofp_header header;
+ PortNo uint32 `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+ HwAddr []uint32 `protobuf:"varint,2,rep,packed,name=hw_addr,json=hwAddr" json:"hw_addr,omitempty"`
+ // The hardware address is not
+ // configurable. This is used to
+ // sanity-check the request, so it must
+ // be the same as returned in an
+ // ofp_port struct.
+ Config uint32 `protobuf:"varint,3,opt,name=config" json:"config,omitempty"`
+ Mask uint32 `protobuf:"varint,4,opt,name=mask" json:"mask,omitempty"`
+ Advertise uint32 `protobuf:"varint,5,opt,name=advertise" json:"advertise,omitempty"`
+}
+
+func (m *OfpPortMod) Reset() { *m = OfpPortMod{} }
+func (m *OfpPortMod) String() string { return proto.CompactTextString(m) }
+func (*OfpPortMod) ProtoMessage() {}
+func (*OfpPortMod) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
+
+func (m *OfpPortMod) GetPortNo() uint32 {
+ if m != nil {
+ return m.PortNo
+ }
+ return 0
+}
+
+func (m *OfpPortMod) GetHwAddr() []uint32 {
+ if m != nil {
+ return m.HwAddr
+ }
+ return nil
+}
+
+func (m *OfpPortMod) GetConfig() uint32 {
+ if m != nil {
+ return m.Config
+ }
+ return 0
+}
+
+func (m *OfpPortMod) GetMask() uint32 {
+ if m != nil {
+ return m.Mask
+ }
+ return 0
+}
+
+func (m *OfpPortMod) GetAdvertise() uint32 {
+ if m != nil {
+ return m.Advertise
+ }
+ return 0
+}
+
+// Fields to match against flows
+type OfpMatch struct {
+ Type OfpMatchType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpMatchType" json:"type,omitempty"`
+ OxmFields []*OfpOxmField `protobuf:"bytes,2,rep,name=oxm_fields,json=oxmFields" json:"oxm_fields,omitempty"`
+}
+
+func (m *OfpMatch) Reset() { *m = OfpMatch{} }
+func (m *OfpMatch) String() string { return proto.CompactTextString(m) }
+func (*OfpMatch) ProtoMessage() {}
+func (*OfpMatch) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
+
+func (m *OfpMatch) GetType() OfpMatchType {
+ if m != nil {
+ return m.Type
+ }
+ return OfpMatchType_OFPMT_STANDARD
+}
+
+func (m *OfpMatch) GetOxmFields() []*OfpOxmField {
+ if m != nil {
+ return m.OxmFields
+ }
+ return nil
+}
+
+// OXM Flow match fields
+type OfpOxmField struct {
+ OxmClass OfpOxmClass `protobuf:"varint,1,opt,name=oxm_class,json=oxmClass,enum=openflow_13.OfpOxmClass" json:"oxm_class,omitempty"`
+ // Types that are valid to be assigned to Field:
+ // *OfpOxmField_OfbField
+ // *OfpOxmField_ExperimenterField
+ Field isOfpOxmField_Field `protobuf_oneof:"field"`
+}
+
+func (m *OfpOxmField) Reset() { *m = OfpOxmField{} }
+func (m *OfpOxmField) String() string { return proto.CompactTextString(m) }
+func (*OfpOxmField) ProtoMessage() {}
+func (*OfpOxmField) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
+
+type isOfpOxmField_Field interface {
+ isOfpOxmField_Field()
+}
+
+type OfpOxmField_OfbField struct {
+ OfbField *OfpOxmOfbField `protobuf:"bytes,4,opt,name=ofb_field,json=ofbField,oneof"`
+}
+type OfpOxmField_ExperimenterField struct {
+ ExperimenterField *OfpOxmExperimenterField `protobuf:"bytes,5,opt,name=experimenter_field,json=experimenterField,oneof"`
+}
+
+func (*OfpOxmField_OfbField) isOfpOxmField_Field() {}
+func (*OfpOxmField_ExperimenterField) isOfpOxmField_Field() {}
+
+func (m *OfpOxmField) GetField() isOfpOxmField_Field {
+ if m != nil {
+ return m.Field
+ }
+ return nil
+}
+
+func (m *OfpOxmField) GetOxmClass() OfpOxmClass {
+ if m != nil {
+ return m.OxmClass
+ }
+ return OfpOxmClass_OFPXMC_NXM_0
+}
+
+func (m *OfpOxmField) GetOfbField() *OfpOxmOfbField {
+ if x, ok := m.GetField().(*OfpOxmField_OfbField); ok {
+ return x.OfbField
+ }
+ return nil
+}
+
+func (m *OfpOxmField) GetExperimenterField() *OfpOxmExperimenterField {
+ if x, ok := m.GetField().(*OfpOxmField_ExperimenterField); ok {
+ return x.ExperimenterField
+ }
+ return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpOxmField) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _OfpOxmField_OneofMarshaler, _OfpOxmField_OneofUnmarshaler, _OfpOxmField_OneofSizer, []interface{}{
+ (*OfpOxmField_OfbField)(nil),
+ (*OfpOxmField_ExperimenterField)(nil),
+ }
+}
+
+func _OfpOxmField_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpOxmField)
+ // field
+ switch x := m.Field.(type) {
+ case *OfpOxmField_OfbField:
+ b.EncodeVarint(4<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.OfbField); err != nil {
+ return err
+ }
+ case *OfpOxmField_ExperimenterField:
+ b.EncodeVarint(5<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.ExperimenterField); err != nil {
+ return err
+ }
+ case nil:
+ default:
+ return fmt.Errorf("OfpOxmField.Field has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _OfpOxmField_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpOxmField)
+ switch tag {
+ case 4: // field.ofb_field
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpOxmOfbField)
+ err := b.DecodeMessage(msg)
+ m.Field = &OfpOxmField_OfbField{msg}
+ return true, err
+ case 5: // field.experimenter_field
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpOxmExperimenterField)
+ err := b.DecodeMessage(msg)
+ m.Field = &OfpOxmField_ExperimenterField{msg}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _OfpOxmField_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*OfpOxmField)
+ // field
+ switch x := m.Field.(type) {
+ case *OfpOxmField_OfbField:
+ s := proto.Size(x.OfbField)
+ n += proto.SizeVarint(4<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpOxmField_ExperimenterField:
+ s := proto.Size(x.ExperimenterField)
+ n += proto.SizeVarint(5<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+// OXM OpenFlow Basic Match Field
+type OfpOxmOfbField struct {
+ Type OxmOfbFieldTypes `protobuf:"varint,1,opt,name=type,enum=openflow_13.OxmOfbFieldTypes" json:"type,omitempty"`
+ HasMask bool `protobuf:"varint,2,opt,name=has_mask,json=hasMask" json:"has_mask,omitempty"`
+ // Types that are valid to be assigned to Value:
+ // *OfpOxmOfbField_Port
+ // *OfpOxmOfbField_PhysicalPort
+ // *OfpOxmOfbField_TableMetadata
+ // *OfpOxmOfbField_EthDst
+ // *OfpOxmOfbField_EthSrc
+ // *OfpOxmOfbField_EthType
+ // *OfpOxmOfbField_VlanVid
+ // *OfpOxmOfbField_VlanPcp
+ // *OfpOxmOfbField_IpDscp
+ // *OfpOxmOfbField_IpEcn
+ // *OfpOxmOfbField_IpProto
+ // *OfpOxmOfbField_Ipv4Src
+ // *OfpOxmOfbField_Ipv4Dst
+ // *OfpOxmOfbField_TcpSrc
+ // *OfpOxmOfbField_TcpDst
+ // *OfpOxmOfbField_UdpSrc
+ // *OfpOxmOfbField_UdpDst
+ // *OfpOxmOfbField_SctpSrc
+ // *OfpOxmOfbField_SctpDst
+ // *OfpOxmOfbField_Icmpv4Type
+ // *OfpOxmOfbField_Icmpv4Code
+ // *OfpOxmOfbField_ArpOp
+ // *OfpOxmOfbField_ArpSpa
+ // *OfpOxmOfbField_ArpTpa
+ // *OfpOxmOfbField_ArpSha
+ // *OfpOxmOfbField_ArpTha
+ // *OfpOxmOfbField_Ipv6Src
+ // *OfpOxmOfbField_Ipv6Dst
+ // *OfpOxmOfbField_Ipv6Flabel
+ // *OfpOxmOfbField_Icmpv6Type
+ // *OfpOxmOfbField_Icmpv6Code
+ // *OfpOxmOfbField_Ipv6NdTarget
+ // *OfpOxmOfbField_Ipv6NdSsl
+ // *OfpOxmOfbField_Ipv6NdTll
+ // *OfpOxmOfbField_MplsLabel
+ // *OfpOxmOfbField_MplsTc
+ // *OfpOxmOfbField_MplsBos
+ // *OfpOxmOfbField_PbbIsid
+ // *OfpOxmOfbField_TunnelId
+ // *OfpOxmOfbField_Ipv6Exthdr
+ Value isOfpOxmOfbField_Value `protobuf_oneof:"value"`
+ // Optional mask values (must be present when has_mask is true
+ //
+ // Types that are valid to be assigned to Mask:
+ // *OfpOxmOfbField_TableMetadataMask
+ // *OfpOxmOfbField_EthDstMask
+ // *OfpOxmOfbField_EthSrcMask
+ // *OfpOxmOfbField_VlanVidMask
+ // *OfpOxmOfbField_Ipv4SrcMask
+ // *OfpOxmOfbField_Ipv4DstMask
+ // *OfpOxmOfbField_ArpSpaMask
+ // *OfpOxmOfbField_ArpTpaMask
+ // *OfpOxmOfbField_Ipv6SrcMask
+ // *OfpOxmOfbField_Ipv6DstMask
+ // *OfpOxmOfbField_Ipv6FlabelMask
+ // *OfpOxmOfbField_PbbIsidMask
+ // *OfpOxmOfbField_TunnelIdMask
+ // *OfpOxmOfbField_Ipv6ExthdrMask
+ Mask isOfpOxmOfbField_Mask `protobuf_oneof:"mask"`
+}
+
+func (m *OfpOxmOfbField) Reset() { *m = OfpOxmOfbField{} }
+func (m *OfpOxmOfbField) String() string { return proto.CompactTextString(m) }
+func (*OfpOxmOfbField) ProtoMessage() {}
+func (*OfpOxmOfbField) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
+
+type isOfpOxmOfbField_Value interface {
+ isOfpOxmOfbField_Value()
+}
+type isOfpOxmOfbField_Mask interface {
+ isOfpOxmOfbField_Mask()
+}
+
+type OfpOxmOfbField_Port struct {
+ Port uint32 `protobuf:"varint,3,opt,name=port,oneof"`
+}
+type OfpOxmOfbField_PhysicalPort struct {
+ PhysicalPort uint32 `protobuf:"varint,4,opt,name=physical_port,json=physicalPort,oneof"`
+}
+type OfpOxmOfbField_TableMetadata struct {
+ TableMetadata uint64 `protobuf:"varint,5,opt,name=table_metadata,json=tableMetadata,oneof"`
+}
+type OfpOxmOfbField_EthDst struct {
+ EthDst []byte `protobuf:"bytes,6,opt,name=eth_dst,json=ethDst,proto3,oneof"`
+}
+type OfpOxmOfbField_EthSrc struct {
+ EthSrc []byte `protobuf:"bytes,7,opt,name=eth_src,json=ethSrc,proto3,oneof"`
+}
+type OfpOxmOfbField_EthType struct {
+ EthType uint32 `protobuf:"varint,8,opt,name=eth_type,json=ethType,oneof"`
+}
+type OfpOxmOfbField_VlanVid struct {
+ VlanVid uint32 `protobuf:"varint,9,opt,name=vlan_vid,json=vlanVid,oneof"`
+}
+type OfpOxmOfbField_VlanPcp struct {
+ VlanPcp uint32 `protobuf:"varint,10,opt,name=vlan_pcp,json=vlanPcp,oneof"`
+}
+type OfpOxmOfbField_IpDscp struct {
+ IpDscp uint32 `protobuf:"varint,11,opt,name=ip_dscp,json=ipDscp,oneof"`
+}
+type OfpOxmOfbField_IpEcn struct {
+ IpEcn uint32 `protobuf:"varint,12,opt,name=ip_ecn,json=ipEcn,oneof"`
+}
+type OfpOxmOfbField_IpProto struct {
+ IpProto uint32 `protobuf:"varint,13,opt,name=ip_proto,json=ipProto,oneof"`
+}
+type OfpOxmOfbField_Ipv4Src struct {
+ Ipv4Src uint32 `protobuf:"varint,14,opt,name=ipv4_src,json=ipv4Src,oneof"`
+}
+type OfpOxmOfbField_Ipv4Dst struct {
+ Ipv4Dst uint32 `protobuf:"varint,15,opt,name=ipv4_dst,json=ipv4Dst,oneof"`
+}
+type OfpOxmOfbField_TcpSrc struct {
+ TcpSrc uint32 `protobuf:"varint,16,opt,name=tcp_src,json=tcpSrc,oneof"`
+}
+type OfpOxmOfbField_TcpDst struct {
+ TcpDst uint32 `protobuf:"varint,17,opt,name=tcp_dst,json=tcpDst,oneof"`
+}
+type OfpOxmOfbField_UdpSrc struct {
+ UdpSrc uint32 `protobuf:"varint,18,opt,name=udp_src,json=udpSrc,oneof"`
+}
+type OfpOxmOfbField_UdpDst struct {
+ UdpDst uint32 `protobuf:"varint,19,opt,name=udp_dst,json=udpDst,oneof"`
+}
+type OfpOxmOfbField_SctpSrc struct {
+ SctpSrc uint32 `protobuf:"varint,20,opt,name=sctp_src,json=sctpSrc,oneof"`
+}
+type OfpOxmOfbField_SctpDst struct {
+ SctpDst uint32 `protobuf:"varint,21,opt,name=sctp_dst,json=sctpDst,oneof"`
+}
+type OfpOxmOfbField_Icmpv4Type struct {
+ Icmpv4Type uint32 `protobuf:"varint,22,opt,name=icmpv4_type,json=icmpv4Type,oneof"`
+}
+type OfpOxmOfbField_Icmpv4Code struct {
+ Icmpv4Code uint32 `protobuf:"varint,23,opt,name=icmpv4_code,json=icmpv4Code,oneof"`
+}
+type OfpOxmOfbField_ArpOp struct {
+ ArpOp uint32 `protobuf:"varint,24,opt,name=arp_op,json=arpOp,oneof"`
+}
+type OfpOxmOfbField_ArpSpa struct {
+ ArpSpa uint32 `protobuf:"varint,25,opt,name=arp_spa,json=arpSpa,oneof"`
+}
+type OfpOxmOfbField_ArpTpa struct {
+ ArpTpa uint32 `protobuf:"varint,26,opt,name=arp_tpa,json=arpTpa,oneof"`
+}
+type OfpOxmOfbField_ArpSha struct {
+ ArpSha []byte `protobuf:"bytes,27,opt,name=arp_sha,json=arpSha,proto3,oneof"`
+}
+type OfpOxmOfbField_ArpTha struct {
+ ArpTha []byte `protobuf:"bytes,28,opt,name=arp_tha,json=arpTha,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6Src struct {
+ Ipv6Src []byte `protobuf:"bytes,29,opt,name=ipv6_src,json=ipv6Src,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6Dst struct {
+ Ipv6Dst []byte `protobuf:"bytes,30,opt,name=ipv6_dst,json=ipv6Dst,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6Flabel struct {
+ Ipv6Flabel uint32 `protobuf:"varint,31,opt,name=ipv6_flabel,json=ipv6Flabel,oneof"`
+}
+type OfpOxmOfbField_Icmpv6Type struct {
+ Icmpv6Type uint32 `protobuf:"varint,32,opt,name=icmpv6_type,json=icmpv6Type,oneof"`
+}
+type OfpOxmOfbField_Icmpv6Code struct {
+ Icmpv6Code uint32 `protobuf:"varint,33,opt,name=icmpv6_code,json=icmpv6Code,oneof"`
+}
+type OfpOxmOfbField_Ipv6NdTarget struct {
+ Ipv6NdTarget []byte `protobuf:"bytes,34,opt,name=ipv6_nd_target,json=ipv6NdTarget,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6NdSsl struct {
+ Ipv6NdSsl []byte `protobuf:"bytes,35,opt,name=ipv6_nd_ssl,json=ipv6NdSsl,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6NdTll struct {
+ Ipv6NdTll []byte `protobuf:"bytes,36,opt,name=ipv6_nd_tll,json=ipv6NdTll,proto3,oneof"`
+}
+type OfpOxmOfbField_MplsLabel struct {
+ MplsLabel uint32 `protobuf:"varint,37,opt,name=mpls_label,json=mplsLabel,oneof"`
+}
+type OfpOxmOfbField_MplsTc struct {
+ MplsTc uint32 `protobuf:"varint,38,opt,name=mpls_tc,json=mplsTc,oneof"`
+}
+type OfpOxmOfbField_MplsBos struct {
+ MplsBos uint32 `protobuf:"varint,39,opt,name=mpls_bos,json=mplsBos,oneof"`
+}
+type OfpOxmOfbField_PbbIsid struct {
+ PbbIsid uint32 `protobuf:"varint,40,opt,name=pbb_isid,json=pbbIsid,oneof"`
+}
+type OfpOxmOfbField_TunnelId struct {
+ TunnelId uint64 `protobuf:"varint,41,opt,name=tunnel_id,json=tunnelId,oneof"`
+}
+type OfpOxmOfbField_Ipv6Exthdr struct {
+ Ipv6Exthdr uint32 `protobuf:"varint,42,opt,name=ipv6_exthdr,json=ipv6Exthdr,oneof"`
+}
+type OfpOxmOfbField_TableMetadataMask struct {
+ TableMetadataMask uint64 `protobuf:"varint,105,opt,name=table_metadata_mask,json=tableMetadataMask,oneof"`
+}
+type OfpOxmOfbField_EthDstMask struct {
+ EthDstMask []byte `protobuf:"bytes,106,opt,name=eth_dst_mask,json=ethDstMask,proto3,oneof"`
+}
+type OfpOxmOfbField_EthSrcMask struct {
+ EthSrcMask []byte `protobuf:"bytes,107,opt,name=eth_src_mask,json=ethSrcMask,proto3,oneof"`
+}
+type OfpOxmOfbField_VlanVidMask struct {
+ VlanVidMask uint32 `protobuf:"varint,109,opt,name=vlan_vid_mask,json=vlanVidMask,oneof"`
+}
+type OfpOxmOfbField_Ipv4SrcMask struct {
+ Ipv4SrcMask uint32 `protobuf:"varint,114,opt,name=ipv4_src_mask,json=ipv4SrcMask,oneof"`
+}
+type OfpOxmOfbField_Ipv4DstMask struct {
+ Ipv4DstMask uint32 `protobuf:"varint,115,opt,name=ipv4_dst_mask,json=ipv4DstMask,oneof"`
+}
+type OfpOxmOfbField_ArpSpaMask struct {
+ ArpSpaMask uint32 `protobuf:"varint,125,opt,name=arp_spa_mask,json=arpSpaMask,oneof"`
+}
+type OfpOxmOfbField_ArpTpaMask struct {
+ ArpTpaMask uint32 `protobuf:"varint,126,opt,name=arp_tpa_mask,json=arpTpaMask,oneof"`
+}
+type OfpOxmOfbField_Ipv6SrcMask struct {
+ Ipv6SrcMask []byte `protobuf:"bytes,129,opt,name=ipv6_src_mask,json=ipv6SrcMask,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6DstMask struct {
+ Ipv6DstMask []byte `protobuf:"bytes,130,opt,name=ipv6_dst_mask,json=ipv6DstMask,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6FlabelMask struct {
+ Ipv6FlabelMask uint32 `protobuf:"varint,131,opt,name=ipv6_flabel_mask,json=ipv6FlabelMask,oneof"`
+}
+type OfpOxmOfbField_PbbIsidMask struct {
+ PbbIsidMask uint32 `protobuf:"varint,140,opt,name=pbb_isid_mask,json=pbbIsidMask,oneof"`
+}
+type OfpOxmOfbField_TunnelIdMask struct {
+ TunnelIdMask uint64 `protobuf:"varint,141,opt,name=tunnel_id_mask,json=tunnelIdMask,oneof"`
+}
+type OfpOxmOfbField_Ipv6ExthdrMask struct {
+ Ipv6ExthdrMask uint32 `protobuf:"varint,142,opt,name=ipv6_exthdr_mask,json=ipv6ExthdrMask,oneof"`
+}
+
+func (*OfpOxmOfbField_Port) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_PhysicalPort) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_TableMetadata) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_EthDst) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_EthSrc) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_EthType) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_VlanVid) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_VlanPcp) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_IpDscp) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_IpEcn) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_IpProto) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Ipv4Src) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Ipv4Dst) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_TcpSrc) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_TcpDst) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_UdpSrc) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_UdpDst) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_SctpSrc) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_SctpDst) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Icmpv4Type) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Icmpv4Code) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_ArpOp) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_ArpSpa) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_ArpTpa) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_ArpSha) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_ArpTha) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Ipv6Src) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Ipv6Dst) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Ipv6Flabel) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Icmpv6Type) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Icmpv6Code) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Ipv6NdTarget) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Ipv6NdSsl) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Ipv6NdTll) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_MplsLabel) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_MplsTc) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_MplsBos) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_PbbIsid) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_TunnelId) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_Ipv6Exthdr) isOfpOxmOfbField_Value() {}
+func (*OfpOxmOfbField_TableMetadataMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_EthDstMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_EthSrcMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_VlanVidMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_Ipv4SrcMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_Ipv4DstMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_ArpSpaMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_ArpTpaMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_Ipv6SrcMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_Ipv6DstMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_Ipv6FlabelMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_PbbIsidMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_TunnelIdMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_Ipv6ExthdrMask) isOfpOxmOfbField_Mask() {}
+
+func (m *OfpOxmOfbField) GetValue() isOfpOxmOfbField_Value {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+func (m *OfpOxmOfbField) GetMask() isOfpOxmOfbField_Mask {
+ if m != nil {
+ return m.Mask
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetType() OxmOfbFieldTypes {
+ if m != nil {
+ return m.Type
+ }
+ return OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT
+}
+
+func (m *OfpOxmOfbField) GetHasMask() bool {
+ if m != nil {
+ return m.HasMask
+ }
+ return false
+}
+
+func (m *OfpOxmOfbField) GetPort() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Port); ok {
+ return x.Port
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetPhysicalPort() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_PhysicalPort); ok {
+ return x.PhysicalPort
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetTableMetadata() uint64 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_TableMetadata); ok {
+ return x.TableMetadata
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetEthDst() []byte {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_EthDst); ok {
+ return x.EthDst
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetEthSrc() []byte {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_EthSrc); ok {
+ return x.EthSrc
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetEthType() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_EthType); ok {
+ return x.EthType
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetVlanVid() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_VlanVid); ok {
+ return x.VlanVid
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetVlanPcp() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_VlanPcp); ok {
+ return x.VlanPcp
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIpDscp() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_IpDscp); ok {
+ return x.IpDscp
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIpEcn() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_IpEcn); ok {
+ return x.IpEcn
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIpProto() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_IpProto); ok {
+ return x.IpProto
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv4Src() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv4Src); ok {
+ return x.Ipv4Src
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv4Dst() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv4Dst); ok {
+ return x.Ipv4Dst
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetTcpSrc() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_TcpSrc); ok {
+ return x.TcpSrc
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetTcpDst() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_TcpDst); ok {
+ return x.TcpDst
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetUdpSrc() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_UdpSrc); ok {
+ return x.UdpSrc
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetUdpDst() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_UdpDst); ok {
+ return x.UdpDst
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetSctpSrc() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_SctpSrc); ok {
+ return x.SctpSrc
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetSctpDst() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_SctpDst); ok {
+ return x.SctpDst
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIcmpv4Type() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Icmpv4Type); ok {
+ return x.Icmpv4Type
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIcmpv4Code() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Icmpv4Code); ok {
+ return x.Icmpv4Code
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetArpOp() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_ArpOp); ok {
+ return x.ArpOp
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetArpSpa() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_ArpSpa); ok {
+ return x.ArpSpa
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetArpTpa() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_ArpTpa); ok {
+ return x.ArpTpa
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetArpSha() []byte {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_ArpSha); ok {
+ return x.ArpSha
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetArpTha() []byte {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_ArpTha); ok {
+ return x.ArpTha
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6Src() []byte {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6Src); ok {
+ return x.Ipv6Src
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6Dst() []byte {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6Dst); ok {
+ return x.Ipv6Dst
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6Flabel() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6Flabel); ok {
+ return x.Ipv6Flabel
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIcmpv6Type() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Icmpv6Type); ok {
+ return x.Icmpv6Type
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIcmpv6Code() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Icmpv6Code); ok {
+ return x.Icmpv6Code
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv6NdTarget() []byte {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6NdTarget); ok {
+ return x.Ipv6NdTarget
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6NdSsl() []byte {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6NdSsl); ok {
+ return x.Ipv6NdSsl
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6NdTll() []byte {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6NdTll); ok {
+ return x.Ipv6NdTll
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetMplsLabel() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_MplsLabel); ok {
+ return x.MplsLabel
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetMplsTc() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_MplsTc); ok {
+ return x.MplsTc
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetMplsBos() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_MplsBos); ok {
+ return x.MplsBos
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetPbbIsid() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_PbbIsid); ok {
+ return x.PbbIsid
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetTunnelId() uint64 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_TunnelId); ok {
+ return x.TunnelId
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv6Exthdr() uint32 {
+ if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6Exthdr); ok {
+ return x.Ipv6Exthdr
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetTableMetadataMask() uint64 {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_TableMetadataMask); ok {
+ return x.TableMetadataMask
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetEthDstMask() []byte {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_EthDstMask); ok {
+ return x.EthDstMask
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetEthSrcMask() []byte {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_EthSrcMask); ok {
+ return x.EthSrcMask
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetVlanVidMask() uint32 {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_VlanVidMask); ok {
+ return x.VlanVidMask
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv4SrcMask() uint32 {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv4SrcMask); ok {
+ return x.Ipv4SrcMask
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv4DstMask() uint32 {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv4DstMask); ok {
+ return x.Ipv4DstMask
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetArpSpaMask() uint32 {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_ArpSpaMask); ok {
+ return x.ArpSpaMask
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetArpTpaMask() uint32 {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_ArpTpaMask); ok {
+ return x.ArpTpaMask
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv6SrcMask() []byte {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv6SrcMask); ok {
+ return x.Ipv6SrcMask
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6DstMask() []byte {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv6DstMask); ok {
+ return x.Ipv6DstMask
+ }
+ return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6FlabelMask() uint32 {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv6FlabelMask); ok {
+ return x.Ipv6FlabelMask
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetPbbIsidMask() uint32 {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_PbbIsidMask); ok {
+ return x.PbbIsidMask
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetTunnelIdMask() uint64 {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_TunnelIdMask); ok {
+ return x.TunnelIdMask
+ }
+ return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv6ExthdrMask() uint32 {
+ if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv6ExthdrMask); ok {
+ return x.Ipv6ExthdrMask
+ }
+ return 0
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpOxmOfbField) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _OfpOxmOfbField_OneofMarshaler, _OfpOxmOfbField_OneofUnmarshaler, _OfpOxmOfbField_OneofSizer, []interface{}{
+ (*OfpOxmOfbField_Port)(nil),
+ (*OfpOxmOfbField_PhysicalPort)(nil),
+ (*OfpOxmOfbField_TableMetadata)(nil),
+ (*OfpOxmOfbField_EthDst)(nil),
+ (*OfpOxmOfbField_EthSrc)(nil),
+ (*OfpOxmOfbField_EthType)(nil),
+ (*OfpOxmOfbField_VlanVid)(nil),
+ (*OfpOxmOfbField_VlanPcp)(nil),
+ (*OfpOxmOfbField_IpDscp)(nil),
+ (*OfpOxmOfbField_IpEcn)(nil),
+ (*OfpOxmOfbField_IpProto)(nil),
+ (*OfpOxmOfbField_Ipv4Src)(nil),
+ (*OfpOxmOfbField_Ipv4Dst)(nil),
+ (*OfpOxmOfbField_TcpSrc)(nil),
+ (*OfpOxmOfbField_TcpDst)(nil),
+ (*OfpOxmOfbField_UdpSrc)(nil),
+ (*OfpOxmOfbField_UdpDst)(nil),
+ (*OfpOxmOfbField_SctpSrc)(nil),
+ (*OfpOxmOfbField_SctpDst)(nil),
+ (*OfpOxmOfbField_Icmpv4Type)(nil),
+ (*OfpOxmOfbField_Icmpv4Code)(nil),
+ (*OfpOxmOfbField_ArpOp)(nil),
+ (*OfpOxmOfbField_ArpSpa)(nil),
+ (*OfpOxmOfbField_ArpTpa)(nil),
+ (*OfpOxmOfbField_ArpSha)(nil),
+ (*OfpOxmOfbField_ArpTha)(nil),
+ (*OfpOxmOfbField_Ipv6Src)(nil),
+ (*OfpOxmOfbField_Ipv6Dst)(nil),
+ (*OfpOxmOfbField_Ipv6Flabel)(nil),
+ (*OfpOxmOfbField_Icmpv6Type)(nil),
+ (*OfpOxmOfbField_Icmpv6Code)(nil),
+ (*OfpOxmOfbField_Ipv6NdTarget)(nil),
+ (*OfpOxmOfbField_Ipv6NdSsl)(nil),
+ (*OfpOxmOfbField_Ipv6NdTll)(nil),
+ (*OfpOxmOfbField_MplsLabel)(nil),
+ (*OfpOxmOfbField_MplsTc)(nil),
+ (*OfpOxmOfbField_MplsBos)(nil),
+ (*OfpOxmOfbField_PbbIsid)(nil),
+ (*OfpOxmOfbField_TunnelId)(nil),
+ (*OfpOxmOfbField_Ipv6Exthdr)(nil),
+ (*OfpOxmOfbField_TableMetadataMask)(nil),
+ (*OfpOxmOfbField_EthDstMask)(nil),
+ (*OfpOxmOfbField_EthSrcMask)(nil),
+ (*OfpOxmOfbField_VlanVidMask)(nil),
+ (*OfpOxmOfbField_Ipv4SrcMask)(nil),
+ (*OfpOxmOfbField_Ipv4DstMask)(nil),
+ (*OfpOxmOfbField_ArpSpaMask)(nil),
+ (*OfpOxmOfbField_ArpTpaMask)(nil),
+ (*OfpOxmOfbField_Ipv6SrcMask)(nil),
+ (*OfpOxmOfbField_Ipv6DstMask)(nil),
+ (*OfpOxmOfbField_Ipv6FlabelMask)(nil),
+ (*OfpOxmOfbField_PbbIsidMask)(nil),
+ (*OfpOxmOfbField_TunnelIdMask)(nil),
+ (*OfpOxmOfbField_Ipv6ExthdrMask)(nil),
+ }
+}
+
+func _OfpOxmOfbField_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpOxmOfbField)
+ // value
+ switch x := m.Value.(type) {
+ case *OfpOxmOfbField_Port:
+ b.EncodeVarint(3<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Port))
+ case *OfpOxmOfbField_PhysicalPort:
+ b.EncodeVarint(4<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.PhysicalPort))
+ case *OfpOxmOfbField_TableMetadata:
+ b.EncodeVarint(5<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.TableMetadata))
+ case *OfpOxmOfbField_EthDst:
+ b.EncodeVarint(6<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.EthDst)
+ case *OfpOxmOfbField_EthSrc:
+ b.EncodeVarint(7<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.EthSrc)
+ case *OfpOxmOfbField_EthType:
+ b.EncodeVarint(8<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.EthType))
+ case *OfpOxmOfbField_VlanVid:
+ b.EncodeVarint(9<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.VlanVid))
+ case *OfpOxmOfbField_VlanPcp:
+ b.EncodeVarint(10<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.VlanPcp))
+ case *OfpOxmOfbField_IpDscp:
+ b.EncodeVarint(11<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.IpDscp))
+ case *OfpOxmOfbField_IpEcn:
+ b.EncodeVarint(12<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.IpEcn))
+ case *OfpOxmOfbField_IpProto:
+ b.EncodeVarint(13<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.IpProto))
+ case *OfpOxmOfbField_Ipv4Src:
+ b.EncodeVarint(14<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Ipv4Src))
+ case *OfpOxmOfbField_Ipv4Dst:
+ b.EncodeVarint(15<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Ipv4Dst))
+ case *OfpOxmOfbField_TcpSrc:
+ b.EncodeVarint(16<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.TcpSrc))
+ case *OfpOxmOfbField_TcpDst:
+ b.EncodeVarint(17<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.TcpDst))
+ case *OfpOxmOfbField_UdpSrc:
+ b.EncodeVarint(18<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.UdpSrc))
+ case *OfpOxmOfbField_UdpDst:
+ b.EncodeVarint(19<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.UdpDst))
+ case *OfpOxmOfbField_SctpSrc:
+ b.EncodeVarint(20<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.SctpSrc))
+ case *OfpOxmOfbField_SctpDst:
+ b.EncodeVarint(21<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.SctpDst))
+ case *OfpOxmOfbField_Icmpv4Type:
+ b.EncodeVarint(22<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Icmpv4Type))
+ case *OfpOxmOfbField_Icmpv4Code:
+ b.EncodeVarint(23<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Icmpv4Code))
+ case *OfpOxmOfbField_ArpOp:
+ b.EncodeVarint(24<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.ArpOp))
+ case *OfpOxmOfbField_ArpSpa:
+ b.EncodeVarint(25<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.ArpSpa))
+ case *OfpOxmOfbField_ArpTpa:
+ b.EncodeVarint(26<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.ArpTpa))
+ case *OfpOxmOfbField_ArpSha:
+ b.EncodeVarint(27<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.ArpSha)
+ case *OfpOxmOfbField_ArpTha:
+ b.EncodeVarint(28<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.ArpTha)
+ case *OfpOxmOfbField_Ipv6Src:
+ b.EncodeVarint(29<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.Ipv6Src)
+ case *OfpOxmOfbField_Ipv6Dst:
+ b.EncodeVarint(30<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.Ipv6Dst)
+ case *OfpOxmOfbField_Ipv6Flabel:
+ b.EncodeVarint(31<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Ipv6Flabel))
+ case *OfpOxmOfbField_Icmpv6Type:
+ b.EncodeVarint(32<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Icmpv6Type))
+ case *OfpOxmOfbField_Icmpv6Code:
+ b.EncodeVarint(33<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Icmpv6Code))
+ case *OfpOxmOfbField_Ipv6NdTarget:
+ b.EncodeVarint(34<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.Ipv6NdTarget)
+ case *OfpOxmOfbField_Ipv6NdSsl:
+ b.EncodeVarint(35<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.Ipv6NdSsl)
+ case *OfpOxmOfbField_Ipv6NdTll:
+ b.EncodeVarint(36<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.Ipv6NdTll)
+ case *OfpOxmOfbField_MplsLabel:
+ b.EncodeVarint(37<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.MplsLabel))
+ case *OfpOxmOfbField_MplsTc:
+ b.EncodeVarint(38<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.MplsTc))
+ case *OfpOxmOfbField_MplsBos:
+ b.EncodeVarint(39<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.MplsBos))
+ case *OfpOxmOfbField_PbbIsid:
+ b.EncodeVarint(40<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.PbbIsid))
+ case *OfpOxmOfbField_TunnelId:
+ b.EncodeVarint(41<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.TunnelId))
+ case *OfpOxmOfbField_Ipv6Exthdr:
+ b.EncodeVarint(42<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Ipv6Exthdr))
+ case nil:
+ default:
+ return fmt.Errorf("OfpOxmOfbField.Value has unexpected type %T", x)
+ }
+ // mask
+ switch x := m.Mask.(type) {
+ case *OfpOxmOfbField_TableMetadataMask:
+ b.EncodeVarint(105<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.TableMetadataMask))
+ case *OfpOxmOfbField_EthDstMask:
+ b.EncodeVarint(106<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.EthDstMask)
+ case *OfpOxmOfbField_EthSrcMask:
+ b.EncodeVarint(107<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.EthSrcMask)
+ case *OfpOxmOfbField_VlanVidMask:
+ b.EncodeVarint(109<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.VlanVidMask))
+ case *OfpOxmOfbField_Ipv4SrcMask:
+ b.EncodeVarint(114<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Ipv4SrcMask))
+ case *OfpOxmOfbField_Ipv4DstMask:
+ b.EncodeVarint(115<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Ipv4DstMask))
+ case *OfpOxmOfbField_ArpSpaMask:
+ b.EncodeVarint(125<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.ArpSpaMask))
+ case *OfpOxmOfbField_ArpTpaMask:
+ b.EncodeVarint(126<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.ArpTpaMask))
+ case *OfpOxmOfbField_Ipv6SrcMask:
+ b.EncodeVarint(129<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.Ipv6SrcMask)
+ case *OfpOxmOfbField_Ipv6DstMask:
+ b.EncodeVarint(130<<3 | proto.WireBytes)
+ b.EncodeRawBytes(x.Ipv6DstMask)
+ case *OfpOxmOfbField_Ipv6FlabelMask:
+ b.EncodeVarint(131<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Ipv6FlabelMask))
+ case *OfpOxmOfbField_PbbIsidMask:
+ b.EncodeVarint(140<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.PbbIsidMask))
+ case *OfpOxmOfbField_TunnelIdMask:
+ b.EncodeVarint(141<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.TunnelIdMask))
+ case *OfpOxmOfbField_Ipv6ExthdrMask:
+ b.EncodeVarint(142<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.Ipv6ExthdrMask))
+ case nil:
+ default:
+ return fmt.Errorf("OfpOxmOfbField.Mask has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _OfpOxmOfbField_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpOxmOfbField)
+ switch tag {
+ case 3: // value.port
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_Port{uint32(x)}
+ return true, err
+ case 4: // value.physical_port
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_PhysicalPort{uint32(x)}
+ return true, err
+ case 5: // value.table_metadata
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_TableMetadata{x}
+ return true, err
+ case 6: // value.eth_dst
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Value = &OfpOxmOfbField_EthDst{x}
+ return true, err
+ case 7: // value.eth_src
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Value = &OfpOxmOfbField_EthSrc{x}
+ return true, err
+ case 8: // value.eth_type
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_EthType{uint32(x)}
+ return true, err
+ case 9: // value.vlan_vid
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_VlanVid{uint32(x)}
+ return true, err
+ case 10: // value.vlan_pcp
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_VlanPcp{uint32(x)}
+ return true, err
+ case 11: // value.ip_dscp
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_IpDscp{uint32(x)}
+ return true, err
+ case 12: // value.ip_ecn
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_IpEcn{uint32(x)}
+ return true, err
+ case 13: // value.ip_proto
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_IpProto{uint32(x)}
+ return true, err
+ case 14: // value.ipv4_src
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_Ipv4Src{uint32(x)}
+ return true, err
+ case 15: // value.ipv4_dst
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_Ipv4Dst{uint32(x)}
+ return true, err
+ case 16: // value.tcp_src
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_TcpSrc{uint32(x)}
+ return true, err
+ case 17: // value.tcp_dst
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_TcpDst{uint32(x)}
+ return true, err
+ case 18: // value.udp_src
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_UdpSrc{uint32(x)}
+ return true, err
+ case 19: // value.udp_dst
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_UdpDst{uint32(x)}
+ return true, err
+ case 20: // value.sctp_src
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_SctpSrc{uint32(x)}
+ return true, err
+ case 21: // value.sctp_dst
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_SctpDst{uint32(x)}
+ return true, err
+ case 22: // value.icmpv4_type
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_Icmpv4Type{uint32(x)}
+ return true, err
+ case 23: // value.icmpv4_code
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_Icmpv4Code{uint32(x)}
+ return true, err
+ case 24: // value.arp_op
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_ArpOp{uint32(x)}
+ return true, err
+ case 25: // value.arp_spa
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_ArpSpa{uint32(x)}
+ return true, err
+ case 26: // value.arp_tpa
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_ArpTpa{uint32(x)}
+ return true, err
+ case 27: // value.arp_sha
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Value = &OfpOxmOfbField_ArpSha{x}
+ return true, err
+ case 28: // value.arp_tha
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Value = &OfpOxmOfbField_ArpTha{x}
+ return true, err
+ case 29: // value.ipv6_src
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Value = &OfpOxmOfbField_Ipv6Src{x}
+ return true, err
+ case 30: // value.ipv6_dst
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Value = &OfpOxmOfbField_Ipv6Dst{x}
+ return true, err
+ case 31: // value.ipv6_flabel
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_Ipv6Flabel{uint32(x)}
+ return true, err
+ case 32: // value.icmpv6_type
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_Icmpv6Type{uint32(x)}
+ return true, err
+ case 33: // value.icmpv6_code
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_Icmpv6Code{uint32(x)}
+ return true, err
+ case 34: // value.ipv6_nd_target
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Value = &OfpOxmOfbField_Ipv6NdTarget{x}
+ return true, err
+ case 35: // value.ipv6_nd_ssl
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Value = &OfpOxmOfbField_Ipv6NdSsl{x}
+ return true, err
+ case 36: // value.ipv6_nd_tll
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Value = &OfpOxmOfbField_Ipv6NdTll{x}
+ return true, err
+ case 37: // value.mpls_label
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_MplsLabel{uint32(x)}
+ return true, err
+ case 38: // value.mpls_tc
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_MplsTc{uint32(x)}
+ return true, err
+ case 39: // value.mpls_bos
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_MplsBos{uint32(x)}
+ return true, err
+ case 40: // value.pbb_isid
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_PbbIsid{uint32(x)}
+ return true, err
+ case 41: // value.tunnel_id
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_TunnelId{x}
+ return true, err
+ case 42: // value.ipv6_exthdr
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &OfpOxmOfbField_Ipv6Exthdr{uint32(x)}
+ return true, err
+ case 105: // mask.table_metadata_mask
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Mask = &OfpOxmOfbField_TableMetadataMask{x}
+ return true, err
+ case 106: // mask.eth_dst_mask
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Mask = &OfpOxmOfbField_EthDstMask{x}
+ return true, err
+ case 107: // mask.eth_src_mask
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Mask = &OfpOxmOfbField_EthSrcMask{x}
+ return true, err
+ case 109: // mask.vlan_vid_mask
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Mask = &OfpOxmOfbField_VlanVidMask{uint32(x)}
+ return true, err
+ case 114: // mask.ipv4_src_mask
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Mask = &OfpOxmOfbField_Ipv4SrcMask{uint32(x)}
+ return true, err
+ case 115: // mask.ipv4_dst_mask
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Mask = &OfpOxmOfbField_Ipv4DstMask{uint32(x)}
+ return true, err
+ case 125: // mask.arp_spa_mask
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Mask = &OfpOxmOfbField_ArpSpaMask{uint32(x)}
+ return true, err
+ case 126: // mask.arp_tpa_mask
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Mask = &OfpOxmOfbField_ArpTpaMask{uint32(x)}
+ return true, err
+ case 129: // mask.ipv6_src_mask
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Mask = &OfpOxmOfbField_Ipv6SrcMask{x}
+ return true, err
+ case 130: // mask.ipv6_dst_mask
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeRawBytes(true)
+ m.Mask = &OfpOxmOfbField_Ipv6DstMask{x}
+ return true, err
+ case 131: // mask.ipv6_flabel_mask
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Mask = &OfpOxmOfbField_Ipv6FlabelMask{uint32(x)}
+ return true, err
+ case 140: // mask.pbb_isid_mask
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Mask = &OfpOxmOfbField_PbbIsidMask{uint32(x)}
+ return true, err
+ case 141: // mask.tunnel_id_mask
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Mask = &OfpOxmOfbField_TunnelIdMask{x}
+ return true, err
+ case 142: // mask.ipv6_exthdr_mask
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Mask = &OfpOxmOfbField_Ipv6ExthdrMask{uint32(x)}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _OfpOxmOfbField_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*OfpOxmOfbField)
+ // value
+ switch x := m.Value.(type) {
+ case *OfpOxmOfbField_Port:
+ n += proto.SizeVarint(3<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Port))
+ case *OfpOxmOfbField_PhysicalPort:
+ n += proto.SizeVarint(4<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.PhysicalPort))
+ case *OfpOxmOfbField_TableMetadata:
+ n += proto.SizeVarint(5<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.TableMetadata))
+ case *OfpOxmOfbField_EthDst:
+ n += proto.SizeVarint(6<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.EthDst)))
+ n += len(x.EthDst)
+ case *OfpOxmOfbField_EthSrc:
+ n += proto.SizeVarint(7<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.EthSrc)))
+ n += len(x.EthSrc)
+ case *OfpOxmOfbField_EthType:
+ n += proto.SizeVarint(8<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.EthType))
+ case *OfpOxmOfbField_VlanVid:
+ n += proto.SizeVarint(9<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.VlanVid))
+ case *OfpOxmOfbField_VlanPcp:
+ n += proto.SizeVarint(10<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.VlanPcp))
+ case *OfpOxmOfbField_IpDscp:
+ n += proto.SizeVarint(11<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.IpDscp))
+ case *OfpOxmOfbField_IpEcn:
+ n += proto.SizeVarint(12<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.IpEcn))
+ case *OfpOxmOfbField_IpProto:
+ n += proto.SizeVarint(13<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.IpProto))
+ case *OfpOxmOfbField_Ipv4Src:
+ n += proto.SizeVarint(14<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Ipv4Src))
+ case *OfpOxmOfbField_Ipv4Dst:
+ n += proto.SizeVarint(15<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Ipv4Dst))
+ case *OfpOxmOfbField_TcpSrc:
+ n += proto.SizeVarint(16<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.TcpSrc))
+ case *OfpOxmOfbField_TcpDst:
+ n += proto.SizeVarint(17<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.TcpDst))
+ case *OfpOxmOfbField_UdpSrc:
+ n += proto.SizeVarint(18<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.UdpSrc))
+ case *OfpOxmOfbField_UdpDst:
+ n += proto.SizeVarint(19<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.UdpDst))
+ case *OfpOxmOfbField_SctpSrc:
+ n += proto.SizeVarint(20<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.SctpSrc))
+ case *OfpOxmOfbField_SctpDst:
+ n += proto.SizeVarint(21<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.SctpDst))
+ case *OfpOxmOfbField_Icmpv4Type:
+ n += proto.SizeVarint(22<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Icmpv4Type))
+ case *OfpOxmOfbField_Icmpv4Code:
+ n += proto.SizeVarint(23<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Icmpv4Code))
+ case *OfpOxmOfbField_ArpOp:
+ n += proto.SizeVarint(24<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.ArpOp))
+ case *OfpOxmOfbField_ArpSpa:
+ n += proto.SizeVarint(25<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.ArpSpa))
+ case *OfpOxmOfbField_ArpTpa:
+ n += proto.SizeVarint(26<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.ArpTpa))
+ case *OfpOxmOfbField_ArpSha:
+ n += proto.SizeVarint(27<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.ArpSha)))
+ n += len(x.ArpSha)
+ case *OfpOxmOfbField_ArpTha:
+ n += proto.SizeVarint(28<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.ArpTha)))
+ n += len(x.ArpTha)
+ case *OfpOxmOfbField_Ipv6Src:
+ n += proto.SizeVarint(29<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.Ipv6Src)))
+ n += len(x.Ipv6Src)
+ case *OfpOxmOfbField_Ipv6Dst:
+ n += proto.SizeVarint(30<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.Ipv6Dst)))
+ n += len(x.Ipv6Dst)
+ case *OfpOxmOfbField_Ipv6Flabel:
+ n += proto.SizeVarint(31<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Ipv6Flabel))
+ case *OfpOxmOfbField_Icmpv6Type:
+ n += proto.SizeVarint(32<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Icmpv6Type))
+ case *OfpOxmOfbField_Icmpv6Code:
+ n += proto.SizeVarint(33<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Icmpv6Code))
+ case *OfpOxmOfbField_Ipv6NdTarget:
+ n += proto.SizeVarint(34<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.Ipv6NdTarget)))
+ n += len(x.Ipv6NdTarget)
+ case *OfpOxmOfbField_Ipv6NdSsl:
+ n += proto.SizeVarint(35<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.Ipv6NdSsl)))
+ n += len(x.Ipv6NdSsl)
+ case *OfpOxmOfbField_Ipv6NdTll:
+ n += proto.SizeVarint(36<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.Ipv6NdTll)))
+ n += len(x.Ipv6NdTll)
+ case *OfpOxmOfbField_MplsLabel:
+ n += proto.SizeVarint(37<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.MplsLabel))
+ case *OfpOxmOfbField_MplsTc:
+ n += proto.SizeVarint(38<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.MplsTc))
+ case *OfpOxmOfbField_MplsBos:
+ n += proto.SizeVarint(39<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.MplsBos))
+ case *OfpOxmOfbField_PbbIsid:
+ n += proto.SizeVarint(40<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.PbbIsid))
+ case *OfpOxmOfbField_TunnelId:
+ n += proto.SizeVarint(41<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.TunnelId))
+ case *OfpOxmOfbField_Ipv6Exthdr:
+ n += proto.SizeVarint(42<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Ipv6Exthdr))
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ // mask
+ switch x := m.Mask.(type) {
+ case *OfpOxmOfbField_TableMetadataMask:
+ n += proto.SizeVarint(105<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.TableMetadataMask))
+ case *OfpOxmOfbField_EthDstMask:
+ n += proto.SizeVarint(106<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.EthDstMask)))
+ n += len(x.EthDstMask)
+ case *OfpOxmOfbField_EthSrcMask:
+ n += proto.SizeVarint(107<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.EthSrcMask)))
+ n += len(x.EthSrcMask)
+ case *OfpOxmOfbField_VlanVidMask:
+ n += proto.SizeVarint(109<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.VlanVidMask))
+ case *OfpOxmOfbField_Ipv4SrcMask:
+ n += proto.SizeVarint(114<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Ipv4SrcMask))
+ case *OfpOxmOfbField_Ipv4DstMask:
+ n += proto.SizeVarint(115<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Ipv4DstMask))
+ case *OfpOxmOfbField_ArpSpaMask:
+ n += proto.SizeVarint(125<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.ArpSpaMask))
+ case *OfpOxmOfbField_ArpTpaMask:
+ n += proto.SizeVarint(126<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.ArpTpaMask))
+ case *OfpOxmOfbField_Ipv6SrcMask:
+ n += proto.SizeVarint(129<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.Ipv6SrcMask)))
+ n += len(x.Ipv6SrcMask)
+ case *OfpOxmOfbField_Ipv6DstMask:
+ n += proto.SizeVarint(130<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(len(x.Ipv6DstMask)))
+ n += len(x.Ipv6DstMask)
+ case *OfpOxmOfbField_Ipv6FlabelMask:
+ n += proto.SizeVarint(131<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Ipv6FlabelMask))
+ case *OfpOxmOfbField_PbbIsidMask:
+ n += proto.SizeVarint(140<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.PbbIsidMask))
+ case *OfpOxmOfbField_TunnelIdMask:
+ n += proto.SizeVarint(141<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.TunnelIdMask))
+ case *OfpOxmOfbField_Ipv6ExthdrMask:
+ n += proto.SizeVarint(142<<3 | proto.WireVarint)
+ n += proto.SizeVarint(uint64(x.Ipv6ExthdrMask))
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+// Header for OXM experimenter match fields.
+// The experimenter class should not use OXM_HEADER() macros for defining
+// fields due to this extra header.
+type OfpOxmExperimenterField struct {
+ OxmHeader uint32 `protobuf:"varint,1,opt,name=oxm_header,json=oxmHeader" json:"oxm_header,omitempty"`
+ Experimenter uint32 `protobuf:"varint,2,opt,name=experimenter" json:"experimenter,omitempty"`
+}
+
+func (m *OfpOxmExperimenterField) Reset() { *m = OfpOxmExperimenterField{} }
+func (m *OfpOxmExperimenterField) String() string { return proto.CompactTextString(m) }
+func (*OfpOxmExperimenterField) ProtoMessage() {}
+func (*OfpOxmExperimenterField) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
+
+func (m *OfpOxmExperimenterField) GetOxmHeader() uint32 {
+ if m != nil {
+ return m.OxmHeader
+ }
+ return 0
+}
+
+func (m *OfpOxmExperimenterField) GetExperimenter() uint32 {
+ if m != nil {
+ return m.Experimenter
+ }
+ return 0
+}
+
+// Action header that is common to all actions. The length includes the
+// header and any padding used to make the action 64-bit aligned.
+// NB: The length of an action *must* always be a multiple of eight.
+type OfpAction struct {
+ Type OfpActionType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpActionType" json:"type,omitempty"`
+ // Types that are valid to be assigned to Action:
+ // *OfpAction_Output
+ // *OfpAction_MplsTtl
+ // *OfpAction_Push
+ // *OfpAction_PopMpls
+ // *OfpAction_Group
+ // *OfpAction_NwTtl
+ // *OfpAction_SetField
+ // *OfpAction_Experimenter
+ Action isOfpAction_Action `protobuf_oneof:"action"`
+}
+
+func (m *OfpAction) Reset() { *m = OfpAction{} }
+func (m *OfpAction) String() string { return proto.CompactTextString(m) }
+func (*OfpAction) ProtoMessage() {}
+func (*OfpAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
+
+type isOfpAction_Action interface {
+ isOfpAction_Action()
+}
+
+type OfpAction_Output struct {
+ Output *OfpActionOutput `protobuf:"bytes,2,opt,name=output,oneof"`
+}
+type OfpAction_MplsTtl struct {
+ MplsTtl *OfpActionMplsTtl `protobuf:"bytes,3,opt,name=mpls_ttl,json=mplsTtl,oneof"`
+}
+type OfpAction_Push struct {
+ Push *OfpActionPush `protobuf:"bytes,4,opt,name=push,oneof"`
+}
+type OfpAction_PopMpls struct {
+ PopMpls *OfpActionPopMpls `protobuf:"bytes,5,opt,name=pop_mpls,json=popMpls,oneof"`
+}
+type OfpAction_Group struct {
+ Group *OfpActionGroup `protobuf:"bytes,6,opt,name=group,oneof"`
+}
+type OfpAction_NwTtl struct {
+ NwTtl *OfpActionNwTtl `protobuf:"bytes,7,opt,name=nw_ttl,json=nwTtl,oneof"`
+}
+type OfpAction_SetField struct {
+ SetField *OfpActionSetField `protobuf:"bytes,8,opt,name=set_field,json=setField,oneof"`
+}
+type OfpAction_Experimenter struct {
+ Experimenter *OfpActionExperimenter `protobuf:"bytes,9,opt,name=experimenter,oneof"`
+}
+
+func (*OfpAction_Output) isOfpAction_Action() {}
+func (*OfpAction_MplsTtl) isOfpAction_Action() {}
+func (*OfpAction_Push) isOfpAction_Action() {}
+func (*OfpAction_PopMpls) isOfpAction_Action() {}
+func (*OfpAction_Group) isOfpAction_Action() {}
+func (*OfpAction_NwTtl) isOfpAction_Action() {}
+func (*OfpAction_SetField) isOfpAction_Action() {}
+func (*OfpAction_Experimenter) isOfpAction_Action() {}
+
+func (m *OfpAction) GetAction() isOfpAction_Action {
+ if m != nil {
+ return m.Action
+ }
+ return nil
+}
+
+func (m *OfpAction) GetType() OfpActionType {
+ if m != nil {
+ return m.Type
+ }
+ return OfpActionType_OFPAT_OUTPUT
+}
+
+func (m *OfpAction) GetOutput() *OfpActionOutput {
+ if x, ok := m.GetAction().(*OfpAction_Output); ok {
+ return x.Output
+ }
+ return nil
+}
+
+func (m *OfpAction) GetMplsTtl() *OfpActionMplsTtl {
+ if x, ok := m.GetAction().(*OfpAction_MplsTtl); ok {
+ return x.MplsTtl
+ }
+ return nil
+}
+
+func (m *OfpAction) GetPush() *OfpActionPush {
+ if x, ok := m.GetAction().(*OfpAction_Push); ok {
+ return x.Push
+ }
+ return nil
+}
+
+func (m *OfpAction) GetPopMpls() *OfpActionPopMpls {
+ if x, ok := m.GetAction().(*OfpAction_PopMpls); ok {
+ return x.PopMpls
+ }
+ return nil
+}
+
+func (m *OfpAction) GetGroup() *OfpActionGroup {
+ if x, ok := m.GetAction().(*OfpAction_Group); ok {
+ return x.Group
+ }
+ return nil
+}
+
+func (m *OfpAction) GetNwTtl() *OfpActionNwTtl {
+ if x, ok := m.GetAction().(*OfpAction_NwTtl); ok {
+ return x.NwTtl
+ }
+ return nil
+}
+
+func (m *OfpAction) GetSetField() *OfpActionSetField {
+ if x, ok := m.GetAction().(*OfpAction_SetField); ok {
+ return x.SetField
+ }
+ return nil
+}
+
+func (m *OfpAction) GetExperimenter() *OfpActionExperimenter {
+ if x, ok := m.GetAction().(*OfpAction_Experimenter); ok {
+ return x.Experimenter
+ }
+ return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _OfpAction_OneofMarshaler, _OfpAction_OneofUnmarshaler, _OfpAction_OneofSizer, []interface{}{
+ (*OfpAction_Output)(nil),
+ (*OfpAction_MplsTtl)(nil),
+ (*OfpAction_Push)(nil),
+ (*OfpAction_PopMpls)(nil),
+ (*OfpAction_Group)(nil),
+ (*OfpAction_NwTtl)(nil),
+ (*OfpAction_SetField)(nil),
+ (*OfpAction_Experimenter)(nil),
+ }
+}
+
+func _OfpAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpAction)
+ // action
+ switch x := m.Action.(type) {
+ case *OfpAction_Output:
+ b.EncodeVarint(2<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Output); err != nil {
+ return err
+ }
+ case *OfpAction_MplsTtl:
+ b.EncodeVarint(3<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.MplsTtl); err != nil {
+ return err
+ }
+ case *OfpAction_Push:
+ b.EncodeVarint(4<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Push); err != nil {
+ return err
+ }
+ case *OfpAction_PopMpls:
+ b.EncodeVarint(5<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.PopMpls); err != nil {
+ return err
+ }
+ case *OfpAction_Group:
+ b.EncodeVarint(6<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Group); err != nil {
+ return err
+ }
+ case *OfpAction_NwTtl:
+ b.EncodeVarint(7<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.NwTtl); err != nil {
+ return err
+ }
+ case *OfpAction_SetField:
+ b.EncodeVarint(8<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.SetField); err != nil {
+ return err
+ }
+ case *OfpAction_Experimenter:
+ b.EncodeVarint(9<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Experimenter); err != nil {
+ return err
+ }
+ case nil:
+ default:
+ return fmt.Errorf("OfpAction.Action has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _OfpAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpAction)
+ switch tag {
+ case 2: // action.output
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpActionOutput)
+ err := b.DecodeMessage(msg)
+ m.Action = &OfpAction_Output{msg}
+ return true, err
+ case 3: // action.mpls_ttl
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpActionMplsTtl)
+ err := b.DecodeMessage(msg)
+ m.Action = &OfpAction_MplsTtl{msg}
+ return true, err
+ case 4: // action.push
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpActionPush)
+ err := b.DecodeMessage(msg)
+ m.Action = &OfpAction_Push{msg}
+ return true, err
+ case 5: // action.pop_mpls
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpActionPopMpls)
+ err := b.DecodeMessage(msg)
+ m.Action = &OfpAction_PopMpls{msg}
+ return true, err
+ case 6: // action.group
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpActionGroup)
+ err := b.DecodeMessage(msg)
+ m.Action = &OfpAction_Group{msg}
+ return true, err
+ case 7: // action.nw_ttl
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpActionNwTtl)
+ err := b.DecodeMessage(msg)
+ m.Action = &OfpAction_NwTtl{msg}
+ return true, err
+ case 8: // action.set_field
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpActionSetField)
+ err := b.DecodeMessage(msg)
+ m.Action = &OfpAction_SetField{msg}
+ return true, err
+ case 9: // action.experimenter
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpActionExperimenter)
+ err := b.DecodeMessage(msg)
+ m.Action = &OfpAction_Experimenter{msg}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _OfpAction_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*OfpAction)
+ // action
+ switch x := m.Action.(type) {
+ case *OfpAction_Output:
+ s := proto.Size(x.Output)
+ n += proto.SizeVarint(2<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpAction_MplsTtl:
+ s := proto.Size(x.MplsTtl)
+ n += proto.SizeVarint(3<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpAction_Push:
+ s := proto.Size(x.Push)
+ n += proto.SizeVarint(4<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpAction_PopMpls:
+ s := proto.Size(x.PopMpls)
+ n += proto.SizeVarint(5<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpAction_Group:
+ s := proto.Size(x.Group)
+ n += proto.SizeVarint(6<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpAction_NwTtl:
+ s := proto.Size(x.NwTtl)
+ n += proto.SizeVarint(7<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpAction_SetField:
+ s := proto.Size(x.SetField)
+ n += proto.SizeVarint(8<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpAction_Experimenter:
+ s := proto.Size(x.Experimenter)
+ n += proto.SizeVarint(9<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+// Action structure for OFPAT_OUTPUT, which sends packets out 'port'.
+// When the 'port' is the OFPP_CONTROLLER, 'max_len' indicates the max
+// number of bytes to send. A 'max_len' of zero means no bytes of the
+// packet should be sent. A 'max_len' of OFPCML_NO_BUFFER means that
+// the packet is not buffered and the complete packet is to be sent to
+// the controller.
+type OfpActionOutput struct {
+ Port uint32 `protobuf:"varint,1,opt,name=port" json:"port,omitempty"`
+ MaxLen uint32 `protobuf:"varint,2,opt,name=max_len,json=maxLen" json:"max_len,omitempty"`
+}
+
+func (m *OfpActionOutput) Reset() { *m = OfpActionOutput{} }
+func (m *OfpActionOutput) String() string { return proto.CompactTextString(m) }
+func (*OfpActionOutput) ProtoMessage() {}
+func (*OfpActionOutput) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
+
+func (m *OfpActionOutput) GetPort() uint32 {
+ if m != nil {
+ return m.Port
+ }
+ return 0
+}
+
+func (m *OfpActionOutput) GetMaxLen() uint32 {
+ if m != nil {
+ return m.MaxLen
+ }
+ return 0
+}
+
+// Action structure for OFPAT_SET_MPLS_TTL.
+type OfpActionMplsTtl struct {
+ MplsTtl uint32 `protobuf:"varint,1,opt,name=mpls_ttl,json=mplsTtl" json:"mpls_ttl,omitempty"`
+}
+
+func (m *OfpActionMplsTtl) Reset() { *m = OfpActionMplsTtl{} }
+func (m *OfpActionMplsTtl) String() string { return proto.CompactTextString(m) }
+func (*OfpActionMplsTtl) ProtoMessage() {}
+func (*OfpActionMplsTtl) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
+
+func (m *OfpActionMplsTtl) GetMplsTtl() uint32 {
+ if m != nil {
+ return m.MplsTtl
+ }
+ return 0
+}
+
+// Action structure for OFPAT_PUSH_VLAN/MPLS/PBB.
+type OfpActionPush struct {
+ Ethertype uint32 `protobuf:"varint,1,opt,name=ethertype" json:"ethertype,omitempty"`
+}
+
+func (m *OfpActionPush) Reset() { *m = OfpActionPush{} }
+func (m *OfpActionPush) String() string { return proto.CompactTextString(m) }
+func (*OfpActionPush) ProtoMessage() {}
+func (*OfpActionPush) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
+
+func (m *OfpActionPush) GetEthertype() uint32 {
+ if m != nil {
+ return m.Ethertype
+ }
+ return 0
+}
+
+// Action structure for OFPAT_POP_MPLS.
+type OfpActionPopMpls struct {
+ Ethertype uint32 `protobuf:"varint,1,opt,name=ethertype" json:"ethertype,omitempty"`
+}
+
+func (m *OfpActionPopMpls) Reset() { *m = OfpActionPopMpls{} }
+func (m *OfpActionPopMpls) String() string { return proto.CompactTextString(m) }
+func (*OfpActionPopMpls) ProtoMessage() {}
+func (*OfpActionPopMpls) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
+
+func (m *OfpActionPopMpls) GetEthertype() uint32 {
+ if m != nil {
+ return m.Ethertype
+ }
+ return 0
+}
+
+// Action structure for OFPAT_GROUP.
+type OfpActionGroup struct {
+ GroupId uint32 `protobuf:"varint,1,opt,name=group_id,json=groupId" json:"group_id,omitempty"`
+}
+
+func (m *OfpActionGroup) Reset() { *m = OfpActionGroup{} }
+func (m *OfpActionGroup) String() string { return proto.CompactTextString(m) }
+func (*OfpActionGroup) ProtoMessage() {}
+func (*OfpActionGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
+
+func (m *OfpActionGroup) GetGroupId() uint32 {
+ if m != nil {
+ return m.GroupId
+ }
+ return 0
+}
+
+// Action structure for OFPAT_SET_NW_TTL.
+type OfpActionNwTtl struct {
+ NwTtl uint32 `protobuf:"varint,1,opt,name=nw_ttl,json=nwTtl" json:"nw_ttl,omitempty"`
+}
+
+func (m *OfpActionNwTtl) Reset() { *m = OfpActionNwTtl{} }
+func (m *OfpActionNwTtl) String() string { return proto.CompactTextString(m) }
+func (*OfpActionNwTtl) ProtoMessage() {}
+func (*OfpActionNwTtl) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
+
+func (m *OfpActionNwTtl) GetNwTtl() uint32 {
+ if m != nil {
+ return m.NwTtl
+ }
+ return 0
+}
+
+// Action structure for OFPAT_SET_FIELD.
+type OfpActionSetField struct {
+ Field *OfpOxmField `protobuf:"bytes,1,opt,name=field" json:"field,omitempty"`
+}
+
+func (m *OfpActionSetField) Reset() { *m = OfpActionSetField{} }
+func (m *OfpActionSetField) String() string { return proto.CompactTextString(m) }
+func (*OfpActionSetField) ProtoMessage() {}
+func (*OfpActionSetField) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
+
+func (m *OfpActionSetField) GetField() *OfpOxmField {
+ if m != nil {
+ return m.Field
+ }
+ return nil
+}
+
+// Action header for OFPAT_EXPERIMENTER.
+// The rest of the body is experimenter-defined.
+type OfpActionExperimenter struct {
+ Experimenter uint32 `protobuf:"varint,1,opt,name=experimenter" json:"experimenter,omitempty"`
+ Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpActionExperimenter) Reset() { *m = OfpActionExperimenter{} }
+func (m *OfpActionExperimenter) String() string { return proto.CompactTextString(m) }
+func (*OfpActionExperimenter) ProtoMessage() {}
+func (*OfpActionExperimenter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
+
+func (m *OfpActionExperimenter) GetExperimenter() uint32 {
+ if m != nil {
+ return m.Experimenter
+ }
+ return 0
+}
+
+func (m *OfpActionExperimenter) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+// Instruction header that is common to all instructions. The length includes
+// the header and any padding used to make the instruction 64-bit aligned.
+// NB: The length of an instruction *must* always be a multiple of eight.
+type OfpInstruction struct {
+ Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+ // Types that are valid to be assigned to Data:
+ // *OfpInstruction_GotoTable
+ // *OfpInstruction_WriteMetadata
+ // *OfpInstruction_Actions
+ // *OfpInstruction_Meter
+ // *OfpInstruction_Experimenter
+ Data isOfpInstruction_Data `protobuf_oneof:"data"`
+}
+
+func (m *OfpInstruction) Reset() { *m = OfpInstruction{} }
+func (m *OfpInstruction) String() string { return proto.CompactTextString(m) }
+func (*OfpInstruction) ProtoMessage() {}
+func (*OfpInstruction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
+
+type isOfpInstruction_Data interface {
+ isOfpInstruction_Data()
+}
+
+type OfpInstruction_GotoTable struct {
+ GotoTable *OfpInstructionGotoTable `protobuf:"bytes,2,opt,name=goto_table,json=gotoTable,oneof"`
+}
+type OfpInstruction_WriteMetadata struct {
+ WriteMetadata *OfpInstructionWriteMetadata `protobuf:"bytes,3,opt,name=write_metadata,json=writeMetadata,oneof"`
+}
+type OfpInstruction_Actions struct {
+ Actions *OfpInstructionActions `protobuf:"bytes,4,opt,name=actions,oneof"`
+}
+type OfpInstruction_Meter struct {
+ Meter *OfpInstructionMeter `protobuf:"bytes,5,opt,name=meter,oneof"`
+}
+type OfpInstruction_Experimenter struct {
+ Experimenter *OfpInstructionExperimenter `protobuf:"bytes,6,opt,name=experimenter,oneof"`
+}
+
+func (*OfpInstruction_GotoTable) isOfpInstruction_Data() {}
+func (*OfpInstruction_WriteMetadata) isOfpInstruction_Data() {}
+func (*OfpInstruction_Actions) isOfpInstruction_Data() {}
+func (*OfpInstruction_Meter) isOfpInstruction_Data() {}
+func (*OfpInstruction_Experimenter) isOfpInstruction_Data() {}
+
+func (m *OfpInstruction) GetData() isOfpInstruction_Data {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+func (m *OfpInstruction) GetType() uint32 {
+ if m != nil {
+ return m.Type
+ }
+ return 0
+}
+
+func (m *OfpInstruction) GetGotoTable() *OfpInstructionGotoTable {
+ if x, ok := m.GetData().(*OfpInstruction_GotoTable); ok {
+ return x.GotoTable
+ }
+ return nil
+}
+
+func (m *OfpInstruction) GetWriteMetadata() *OfpInstructionWriteMetadata {
+ if x, ok := m.GetData().(*OfpInstruction_WriteMetadata); ok {
+ return x.WriteMetadata
+ }
+ return nil
+}
+
+func (m *OfpInstruction) GetActions() *OfpInstructionActions {
+ if x, ok := m.GetData().(*OfpInstruction_Actions); ok {
+ return x.Actions
+ }
+ return nil
+}
+
+func (m *OfpInstruction) GetMeter() *OfpInstructionMeter {
+ if x, ok := m.GetData().(*OfpInstruction_Meter); ok {
+ return x.Meter
+ }
+ return nil
+}
+
+func (m *OfpInstruction) GetExperimenter() *OfpInstructionExperimenter {
+ if x, ok := m.GetData().(*OfpInstruction_Experimenter); ok {
+ return x.Experimenter
+ }
+ return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpInstruction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _OfpInstruction_OneofMarshaler, _OfpInstruction_OneofUnmarshaler, _OfpInstruction_OneofSizer, []interface{}{
+ (*OfpInstruction_GotoTable)(nil),
+ (*OfpInstruction_WriteMetadata)(nil),
+ (*OfpInstruction_Actions)(nil),
+ (*OfpInstruction_Meter)(nil),
+ (*OfpInstruction_Experimenter)(nil),
+ }
+}
+
+func _OfpInstruction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpInstruction)
+ // data
+ switch x := m.Data.(type) {
+ case *OfpInstruction_GotoTable:
+ b.EncodeVarint(2<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.GotoTable); err != nil {
+ return err
+ }
+ case *OfpInstruction_WriteMetadata:
+ b.EncodeVarint(3<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.WriteMetadata); err != nil {
+ return err
+ }
+ case *OfpInstruction_Actions:
+ b.EncodeVarint(4<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Actions); err != nil {
+ return err
+ }
+ case *OfpInstruction_Meter:
+ b.EncodeVarint(5<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Meter); err != nil {
+ return err
+ }
+ case *OfpInstruction_Experimenter:
+ b.EncodeVarint(6<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Experimenter); err != nil {
+ return err
+ }
+ case nil:
+ default:
+ return fmt.Errorf("OfpInstruction.Data has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _OfpInstruction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpInstruction)
+ switch tag {
+ case 2: // data.goto_table
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpInstructionGotoTable)
+ err := b.DecodeMessage(msg)
+ m.Data = &OfpInstruction_GotoTable{msg}
+ return true, err
+ case 3: // data.write_metadata
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpInstructionWriteMetadata)
+ err := b.DecodeMessage(msg)
+ m.Data = &OfpInstruction_WriteMetadata{msg}
+ return true, err
+ case 4: // data.actions
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpInstructionActions)
+ err := b.DecodeMessage(msg)
+ m.Data = &OfpInstruction_Actions{msg}
+ return true, err
+ case 5: // data.meter
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpInstructionMeter)
+ err := b.DecodeMessage(msg)
+ m.Data = &OfpInstruction_Meter{msg}
+ return true, err
+ case 6: // data.experimenter
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpInstructionExperimenter)
+ err := b.DecodeMessage(msg)
+ m.Data = &OfpInstruction_Experimenter{msg}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _OfpInstruction_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*OfpInstruction)
+ // data
+ switch x := m.Data.(type) {
+ case *OfpInstruction_GotoTable:
+ s := proto.Size(x.GotoTable)
+ n += proto.SizeVarint(2<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpInstruction_WriteMetadata:
+ s := proto.Size(x.WriteMetadata)
+ n += proto.SizeVarint(3<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpInstruction_Actions:
+ s := proto.Size(x.Actions)
+ n += proto.SizeVarint(4<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpInstruction_Meter:
+ s := proto.Size(x.Meter)
+ n += proto.SizeVarint(5<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpInstruction_Experimenter:
+ s := proto.Size(x.Experimenter)
+ n += proto.SizeVarint(6<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+// Instruction structure for OFPIT_GOTO_TABLE
+type OfpInstructionGotoTable struct {
+ TableId uint32 `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+}
+
+func (m *OfpInstructionGotoTable) Reset() { *m = OfpInstructionGotoTable{} }
+func (m *OfpInstructionGotoTable) String() string { return proto.CompactTextString(m) }
+func (*OfpInstructionGotoTable) ProtoMessage() {}
+func (*OfpInstructionGotoTable) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
+
+func (m *OfpInstructionGotoTable) GetTableId() uint32 {
+ if m != nil {
+ return m.TableId
+ }
+ return 0
+}
+
+// Instruction structure for OFPIT_WRITE_METADATA
+type OfpInstructionWriteMetadata struct {
+ Metadata uint64 `protobuf:"varint,1,opt,name=metadata" json:"metadata,omitempty"`
+ MetadataMask uint64 `protobuf:"varint,2,opt,name=metadata_mask,json=metadataMask" json:"metadata_mask,omitempty"`
+}
+
+func (m *OfpInstructionWriteMetadata) Reset() { *m = OfpInstructionWriteMetadata{} }
+func (m *OfpInstructionWriteMetadata) String() string { return proto.CompactTextString(m) }
+func (*OfpInstructionWriteMetadata) ProtoMessage() {}
+func (*OfpInstructionWriteMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
+
+func (m *OfpInstructionWriteMetadata) GetMetadata() uint64 {
+ if m != nil {
+ return m.Metadata
+ }
+ return 0
+}
+
+func (m *OfpInstructionWriteMetadata) GetMetadataMask() uint64 {
+ if m != nil {
+ return m.MetadataMask
+ }
+ return 0
+}
+
+// Instruction structure for OFPIT_WRITE/APPLY/CLEAR_ACTIONS
+type OfpInstructionActions struct {
+ Actions []*OfpAction `protobuf:"bytes,1,rep,name=actions" json:"actions,omitempty"`
+}
+
+func (m *OfpInstructionActions) Reset() { *m = OfpInstructionActions{} }
+func (m *OfpInstructionActions) String() string { return proto.CompactTextString(m) }
+func (*OfpInstructionActions) ProtoMessage() {}
+func (*OfpInstructionActions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
+
+func (m *OfpInstructionActions) GetActions() []*OfpAction {
+ if m != nil {
+ return m.Actions
+ }
+ return nil
+}
+
+// Instruction structure for OFPIT_METER
+type OfpInstructionMeter struct {
+ MeterId uint32 `protobuf:"varint,1,opt,name=meter_id,json=meterId" json:"meter_id,omitempty"`
+}
+
+func (m *OfpInstructionMeter) Reset() { *m = OfpInstructionMeter{} }
+func (m *OfpInstructionMeter) String() string { return proto.CompactTextString(m) }
+func (*OfpInstructionMeter) ProtoMessage() {}
+func (*OfpInstructionMeter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
+
+func (m *OfpInstructionMeter) GetMeterId() uint32 {
+ if m != nil {
+ return m.MeterId
+ }
+ return 0
+}
+
+// Instruction structure for experimental instructions
+type OfpInstructionExperimenter struct {
+ Experimenter uint32 `protobuf:"varint,1,opt,name=experimenter" json:"experimenter,omitempty"`
+ // Experimenter-defined arbitrary additional data.
+ Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpInstructionExperimenter) Reset() { *m = OfpInstructionExperimenter{} }
+func (m *OfpInstructionExperimenter) String() string { return proto.CompactTextString(m) }
+func (*OfpInstructionExperimenter) ProtoMessage() {}
+func (*OfpInstructionExperimenter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
+
+func (m *OfpInstructionExperimenter) GetExperimenter() uint32 {
+ if m != nil {
+ return m.Experimenter
+ }
+ return 0
+}
+
+func (m *OfpInstructionExperimenter) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+// Flow setup and teardown (controller -> datapath).
+type OfpFlowMod struct {
+ // ofp_header header;
+ Cookie uint64 `protobuf:"varint,1,opt,name=cookie" json:"cookie,omitempty"`
+ CookieMask uint64 `protobuf:"varint,2,opt,name=cookie_mask,json=cookieMask" json:"cookie_mask,omitempty"`
+ TableId uint32 `protobuf:"varint,3,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+ Command OfpFlowModCommand `protobuf:"varint,4,opt,name=command,enum=openflow_13.OfpFlowModCommand" json:"command,omitempty"`
+ IdleTimeout uint32 `protobuf:"varint,5,opt,name=idle_timeout,json=idleTimeout" json:"idle_timeout,omitempty"`
+ HardTimeout uint32 `protobuf:"varint,6,opt,name=hard_timeout,json=hardTimeout" json:"hard_timeout,omitempty"`
+ Priority uint32 `protobuf:"varint,7,opt,name=priority" json:"priority,omitempty"`
+ BufferId uint32 `protobuf:"varint,8,opt,name=buffer_id,json=bufferId" json:"buffer_id,omitempty"`
+ OutPort uint32 `protobuf:"varint,9,opt,name=out_port,json=outPort" json:"out_port,omitempty"`
+ OutGroup uint32 `protobuf:"varint,10,opt,name=out_group,json=outGroup" json:"out_group,omitempty"`
+ Flags uint32 `protobuf:"varint,11,opt,name=flags" json:"flags,omitempty"`
+ Match *OfpMatch `protobuf:"bytes,12,opt,name=match" json:"match,omitempty"`
+ Instructions []*OfpInstruction `protobuf:"bytes,13,rep,name=instructions" json:"instructions,omitempty"`
+}
+
+func (m *OfpFlowMod) Reset() { *m = OfpFlowMod{} }
+func (m *OfpFlowMod) String() string { return proto.CompactTextString(m) }
+func (*OfpFlowMod) ProtoMessage() {}
+func (*OfpFlowMod) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
+
+func (m *OfpFlowMod) GetCookie() uint64 {
+ if m != nil {
+ return m.Cookie
+ }
+ return 0
+}
+
+func (m *OfpFlowMod) GetCookieMask() uint64 {
+ if m != nil {
+ return m.CookieMask
+ }
+ return 0
+}
+
+func (m *OfpFlowMod) GetTableId() uint32 {
+ if m != nil {
+ return m.TableId
+ }
+ return 0
+}
+
+func (m *OfpFlowMod) GetCommand() OfpFlowModCommand {
+ if m != nil {
+ return m.Command
+ }
+ return OfpFlowModCommand_OFPFC_ADD
+}
+
+func (m *OfpFlowMod) GetIdleTimeout() uint32 {
+ if m != nil {
+ return m.IdleTimeout
+ }
+ return 0
+}
+
+func (m *OfpFlowMod) GetHardTimeout() uint32 {
+ if m != nil {
+ return m.HardTimeout
+ }
+ return 0
+}
+
+func (m *OfpFlowMod) GetPriority() uint32 {
+ if m != nil {
+ return m.Priority
+ }
+ return 0
+}
+
+func (m *OfpFlowMod) GetBufferId() uint32 {
+ if m != nil {
+ return m.BufferId
+ }
+ return 0
+}
+
+func (m *OfpFlowMod) GetOutPort() uint32 {
+ if m != nil {
+ return m.OutPort
+ }
+ return 0
+}
+
+func (m *OfpFlowMod) GetOutGroup() uint32 {
+ if m != nil {
+ return m.OutGroup
+ }
+ return 0
+}
+
+func (m *OfpFlowMod) GetFlags() uint32 {
+ if m != nil {
+ return m.Flags
+ }
+ return 0
+}
+
+func (m *OfpFlowMod) GetMatch() *OfpMatch {
+ if m != nil {
+ return m.Match
+ }
+ return nil
+}
+
+func (m *OfpFlowMod) GetInstructions() []*OfpInstruction {
+ if m != nil {
+ return m.Instructions
+ }
+ return nil
+}
+
+// Bucket for use in groups.
+type OfpBucket struct {
+ Weight uint32 `protobuf:"varint,1,opt,name=weight" json:"weight,omitempty"`
+ WatchPort uint32 `protobuf:"varint,2,opt,name=watch_port,json=watchPort" json:"watch_port,omitempty"`
+ WatchGroup uint32 `protobuf:"varint,3,opt,name=watch_group,json=watchGroup" json:"watch_group,omitempty"`
+ Actions []*OfpAction `protobuf:"bytes,4,rep,name=actions" json:"actions,omitempty"`
+}
+
+func (m *OfpBucket) Reset() { *m = OfpBucket{} }
+func (m *OfpBucket) String() string { return proto.CompactTextString(m) }
+func (*OfpBucket) ProtoMessage() {}
+func (*OfpBucket) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
+
+func (m *OfpBucket) GetWeight() uint32 {
+ if m != nil {
+ return m.Weight
+ }
+ return 0
+}
+
+func (m *OfpBucket) GetWatchPort() uint32 {
+ if m != nil {
+ return m.WatchPort
+ }
+ return 0
+}
+
+func (m *OfpBucket) GetWatchGroup() uint32 {
+ if m != nil {
+ return m.WatchGroup
+ }
+ return 0
+}
+
+func (m *OfpBucket) GetActions() []*OfpAction {
+ if m != nil {
+ return m.Actions
+ }
+ return nil
+}
+
+// Group setup and teardown (controller -> datapath).
+type OfpGroupMod struct {
+ // ofp_header header;
+ Command OfpGroupModCommand `protobuf:"varint,1,opt,name=command,enum=openflow_13.OfpGroupModCommand" json:"command,omitempty"`
+ Type OfpGroupType `protobuf:"varint,2,opt,name=type,enum=openflow_13.OfpGroupType" json:"type,omitempty"`
+ GroupId uint32 `protobuf:"varint,3,opt,name=group_id,json=groupId" json:"group_id,omitempty"`
+ Buckets []*OfpBucket `protobuf:"bytes,4,rep,name=buckets" json:"buckets,omitempty"`
+}
+
+func (m *OfpGroupMod) Reset() { *m = OfpGroupMod{} }
+func (m *OfpGroupMod) String() string { return proto.CompactTextString(m) }
+func (*OfpGroupMod) ProtoMessage() {}
+func (*OfpGroupMod) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
+
+func (m *OfpGroupMod) GetCommand() OfpGroupModCommand {
+ if m != nil {
+ return m.Command
+ }
+ return OfpGroupModCommand_OFPGC_ADD
+}
+
+func (m *OfpGroupMod) GetType() OfpGroupType {
+ if m != nil {
+ return m.Type
+ }
+ return OfpGroupType_OFPGT_ALL
+}
+
+func (m *OfpGroupMod) GetGroupId() uint32 {
+ if m != nil {
+ return m.GroupId
+ }
+ return 0
+}
+
+func (m *OfpGroupMod) GetBuckets() []*OfpBucket {
+ if m != nil {
+ return m.Buckets
+ }
+ return nil
+}
+
+// Send packet (controller -> datapath).
+type OfpPacketOut struct {
+ // ofp_header header;
+ BufferId uint32 `protobuf:"varint,1,opt,name=buffer_id,json=bufferId" json:"buffer_id,omitempty"`
+ InPort uint32 `protobuf:"varint,2,opt,name=in_port,json=inPort" json:"in_port,omitempty"`
+ Actions []*OfpAction `protobuf:"bytes,3,rep,name=actions" json:"actions,omitempty"`
+ // The variable size action list is optionally followed by packet data.
+ // This data is only present and meaningful if buffer_id == -1.
+ Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpPacketOut) Reset() { *m = OfpPacketOut{} }
+func (m *OfpPacketOut) String() string { return proto.CompactTextString(m) }
+func (*OfpPacketOut) ProtoMessage() {}
+func (*OfpPacketOut) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} }
+
+func (m *OfpPacketOut) GetBufferId() uint32 {
+ if m != nil {
+ return m.BufferId
+ }
+ return 0
+}
+
+func (m *OfpPacketOut) GetInPort() uint32 {
+ if m != nil {
+ return m.InPort
+ }
+ return 0
+}
+
+func (m *OfpPacketOut) GetActions() []*OfpAction {
+ if m != nil {
+ return m.Actions
+ }
+ return nil
+}
+
+func (m *OfpPacketOut) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+// Packet received on port (datapath -> controller).
+type OfpPacketIn struct {
+ // ofp_header header;
+ BufferId uint32 `protobuf:"varint,1,opt,name=buffer_id,json=bufferId" json:"buffer_id,omitempty"`
+ Reason OfpPacketInReason `protobuf:"varint,2,opt,name=reason,enum=openflow_13.OfpPacketInReason" json:"reason,omitempty"`
+ TableId uint32 `protobuf:"varint,3,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+ Cookie uint64 `protobuf:"varint,4,opt,name=cookie" json:"cookie,omitempty"`
+ Match *OfpMatch `protobuf:"bytes,5,opt,name=match" json:"match,omitempty"`
+ Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpPacketIn) Reset() { *m = OfpPacketIn{} }
+func (m *OfpPacketIn) String() string { return proto.CompactTextString(m) }
+func (*OfpPacketIn) ProtoMessage() {}
+func (*OfpPacketIn) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} }
+
+func (m *OfpPacketIn) GetBufferId() uint32 {
+ if m != nil {
+ return m.BufferId
+ }
+ return 0
+}
+
+func (m *OfpPacketIn) GetReason() OfpPacketInReason {
+ if m != nil {
+ return m.Reason
+ }
+ return OfpPacketInReason_OFPR_NO_MATCH
+}
+
+func (m *OfpPacketIn) GetTableId() uint32 {
+ if m != nil {
+ return m.TableId
+ }
+ return 0
+}
+
+func (m *OfpPacketIn) GetCookie() uint64 {
+ if m != nil {
+ return m.Cookie
+ }
+ return 0
+}
+
+func (m *OfpPacketIn) GetMatch() *OfpMatch {
+ if m != nil {
+ return m.Match
+ }
+ return nil
+}
+
+func (m *OfpPacketIn) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+// Flow removed (datapath -> controller).
+type OfpFlowRemoved struct {
+ // ofp_header header;
+ Cookie uint64 `protobuf:"varint,1,opt,name=cookie" json:"cookie,omitempty"`
+ Priority uint32 `protobuf:"varint,2,opt,name=priority" json:"priority,omitempty"`
+ Reason OfpFlowRemovedReason `protobuf:"varint,3,opt,name=reason,enum=openflow_13.OfpFlowRemovedReason" json:"reason,omitempty"`
+ TableId uint32 `protobuf:"varint,4,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+ DurationSec uint32 `protobuf:"varint,5,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+ DurationNsec uint32 `protobuf:"varint,6,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+ IdleTimeout uint32 `protobuf:"varint,7,opt,name=idle_timeout,json=idleTimeout" json:"idle_timeout,omitempty"`
+ HardTimeout uint32 `protobuf:"varint,8,opt,name=hard_timeout,json=hardTimeout" json:"hard_timeout,omitempty"`
+ PacketCount uint64 `protobuf:"varint,9,opt,name=packet_count,json=packetCount" json:"packet_count,omitempty"`
+ ByteCount uint64 `protobuf:"varint,10,opt,name=byte_count,json=byteCount" json:"byte_count,omitempty"`
+ Match *OfpMatch `protobuf:"bytes,121,opt,name=match" json:"match,omitempty"`
+}
+
+func (m *OfpFlowRemoved) Reset() { *m = OfpFlowRemoved{} }
+func (m *OfpFlowRemoved) String() string { return proto.CompactTextString(m) }
+func (*OfpFlowRemoved) ProtoMessage() {}
+func (*OfpFlowRemoved) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} }
+
+func (m *OfpFlowRemoved) GetCookie() uint64 {
+ if m != nil {
+ return m.Cookie
+ }
+ return 0
+}
+
+func (m *OfpFlowRemoved) GetPriority() uint32 {
+ if m != nil {
+ return m.Priority
+ }
+ return 0
+}
+
+func (m *OfpFlowRemoved) GetReason() OfpFlowRemovedReason {
+ if m != nil {
+ return m.Reason
+ }
+ return OfpFlowRemovedReason_OFPRR_IDLE_TIMEOUT
+}
+
+func (m *OfpFlowRemoved) GetTableId() uint32 {
+ if m != nil {
+ return m.TableId
+ }
+ return 0
+}
+
+func (m *OfpFlowRemoved) GetDurationSec() uint32 {
+ if m != nil {
+ return m.DurationSec
+ }
+ return 0
+}
+
+func (m *OfpFlowRemoved) GetDurationNsec() uint32 {
+ if m != nil {
+ return m.DurationNsec
+ }
+ return 0
+}
+
+func (m *OfpFlowRemoved) GetIdleTimeout() uint32 {
+ if m != nil {
+ return m.IdleTimeout
+ }
+ return 0
+}
+
+func (m *OfpFlowRemoved) GetHardTimeout() uint32 {
+ if m != nil {
+ return m.HardTimeout
+ }
+ return 0
+}
+
+func (m *OfpFlowRemoved) GetPacketCount() uint64 {
+ if m != nil {
+ return m.PacketCount
+ }
+ return 0
+}
+
+func (m *OfpFlowRemoved) GetByteCount() uint64 {
+ if m != nil {
+ return m.ByteCount
+ }
+ return 0
+}
+
+func (m *OfpFlowRemoved) GetMatch() *OfpMatch {
+ if m != nil {
+ return m.Match
+ }
+ return nil
+}
+
+// Common header for all meter bands
+type OfpMeterBandHeader struct {
+ Type OfpMeterBandType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpMeterBandType" json:"type,omitempty"`
+ Len uint32 `protobuf:"varint,2,opt,name=len" json:"len,omitempty"`
+ Rate uint32 `protobuf:"varint,3,opt,name=rate" json:"rate,omitempty"`
+ BurstSize uint32 `protobuf:"varint,4,opt,name=burst_size,json=burstSize" json:"burst_size,omitempty"`
+}
+
+func (m *OfpMeterBandHeader) Reset() { *m = OfpMeterBandHeader{} }
+func (m *OfpMeterBandHeader) String() string { return proto.CompactTextString(m) }
+func (*OfpMeterBandHeader) ProtoMessage() {}
+func (*OfpMeterBandHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{35} }
+
+func (m *OfpMeterBandHeader) GetType() OfpMeterBandType {
+ if m != nil {
+ return m.Type
+ }
+ return OfpMeterBandType_OFPMBT_INVALID
+}
+
+func (m *OfpMeterBandHeader) GetLen() uint32 {
+ if m != nil {
+ return m.Len
+ }
+ return 0
+}
+
+func (m *OfpMeterBandHeader) GetRate() uint32 {
+ if m != nil {
+ return m.Rate
+ }
+ return 0
+}
+
+func (m *OfpMeterBandHeader) GetBurstSize() uint32 {
+ if m != nil {
+ return m.BurstSize
+ }
+ return 0
+}
+
+// OFPMBT_DROP band - drop packets
+type OfpMeterBandDrop struct {
+ Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+ Len uint32 `protobuf:"varint,2,opt,name=len" json:"len,omitempty"`
+ Rate uint32 `protobuf:"varint,3,opt,name=rate" json:"rate,omitempty"`
+ BurstSize uint32 `protobuf:"varint,4,opt,name=burst_size,json=burstSize" json:"burst_size,omitempty"`
+}
+
+func (m *OfpMeterBandDrop) Reset() { *m = OfpMeterBandDrop{} }
+func (m *OfpMeterBandDrop) String() string { return proto.CompactTextString(m) }
+func (*OfpMeterBandDrop) ProtoMessage() {}
+func (*OfpMeterBandDrop) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{36} }
+
+func (m *OfpMeterBandDrop) GetType() uint32 {
+ if m != nil {
+ return m.Type
+ }
+ return 0
+}
+
+func (m *OfpMeterBandDrop) GetLen() uint32 {
+ if m != nil {
+ return m.Len
+ }
+ return 0
+}
+
+func (m *OfpMeterBandDrop) GetRate() uint32 {
+ if m != nil {
+ return m.Rate
+ }
+ return 0
+}
+
+func (m *OfpMeterBandDrop) GetBurstSize() uint32 {
+ if m != nil {
+ return m.BurstSize
+ }
+ return 0
+}
+
+// OFPMBT_DSCP_REMARK band - Remark DSCP in the IP header
+type OfpMeterBandDscpRemark struct {
+ Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+ Len uint32 `protobuf:"varint,2,opt,name=len" json:"len,omitempty"`
+ Rate uint32 `protobuf:"varint,3,opt,name=rate" json:"rate,omitempty"`
+ BurstSize uint32 `protobuf:"varint,4,opt,name=burst_size,json=burstSize" json:"burst_size,omitempty"`
+ PrecLevel uint32 `protobuf:"varint,5,opt,name=prec_level,json=precLevel" json:"prec_level,omitempty"`
+}
+
+func (m *OfpMeterBandDscpRemark) Reset() { *m = OfpMeterBandDscpRemark{} }
+func (m *OfpMeterBandDscpRemark) String() string { return proto.CompactTextString(m) }
+func (*OfpMeterBandDscpRemark) ProtoMessage() {}
+func (*OfpMeterBandDscpRemark) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{37} }
+
+func (m *OfpMeterBandDscpRemark) GetType() uint32 {
+ if m != nil {
+ return m.Type
+ }
+ return 0
+}
+
+func (m *OfpMeterBandDscpRemark) GetLen() uint32 {
+ if m != nil {
+ return m.Len
+ }
+ return 0
+}
+
+func (m *OfpMeterBandDscpRemark) GetRate() uint32 {
+ if m != nil {
+ return m.Rate
+ }
+ return 0
+}
+
+func (m *OfpMeterBandDscpRemark) GetBurstSize() uint32 {
+ if m != nil {
+ return m.BurstSize
+ }
+ return 0
+}
+
+func (m *OfpMeterBandDscpRemark) GetPrecLevel() uint32 {
+ if m != nil {
+ return m.PrecLevel
+ }
+ return 0
+}
+
+// OFPMBT_EXPERIMENTER band - Experimenter type.
+// The rest of the band is experimenter-defined.
+type OfpMeterBandExperimenter struct {
+ Type OfpMeterBandType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpMeterBandType" json:"type,omitempty"`
+ Len uint32 `protobuf:"varint,2,opt,name=len" json:"len,omitempty"`
+ Rate uint32 `protobuf:"varint,3,opt,name=rate" json:"rate,omitempty"`
+ BurstSize uint32 `protobuf:"varint,4,opt,name=burst_size,json=burstSize" json:"burst_size,omitempty"`
+ Experimenter uint32 `protobuf:"varint,5,opt,name=experimenter" json:"experimenter,omitempty"`
+}
+
+func (m *OfpMeterBandExperimenter) Reset() { *m = OfpMeterBandExperimenter{} }
+func (m *OfpMeterBandExperimenter) String() string { return proto.CompactTextString(m) }
+func (*OfpMeterBandExperimenter) ProtoMessage() {}
+func (*OfpMeterBandExperimenter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{38} }
+
+func (m *OfpMeterBandExperimenter) GetType() OfpMeterBandType {
+ if m != nil {
+ return m.Type
+ }
+ return OfpMeterBandType_OFPMBT_INVALID
+}
+
+func (m *OfpMeterBandExperimenter) GetLen() uint32 {
+ if m != nil {
+ return m.Len
+ }
+ return 0
+}
+
+func (m *OfpMeterBandExperimenter) GetRate() uint32 {
+ if m != nil {
+ return m.Rate
+ }
+ return 0
+}
+
+func (m *OfpMeterBandExperimenter) GetBurstSize() uint32 {
+ if m != nil {
+ return m.BurstSize
+ }
+ return 0
+}
+
+func (m *OfpMeterBandExperimenter) GetExperimenter() uint32 {
+ if m != nil {
+ return m.Experimenter
+ }
+ return 0
+}
+
+// Meter configuration. OFPT_METER_MOD.
+type OfpMeterMod struct {
+ // ofp_header header = 1;
+ Command OfpMeterModCommand `protobuf:"varint,1,opt,name=command,enum=openflow_13.OfpMeterModCommand" json:"command,omitempty"`
+ Flags uint32 `protobuf:"varint,2,opt,name=flags" json:"flags,omitempty"`
+ MeterId uint32 `protobuf:"varint,3,opt,name=meter_id,json=meterId" json:"meter_id,omitempty"`
+ Bands []*OfpMeterBandHeader `protobuf:"bytes,4,rep,name=bands" json:"bands,omitempty"`
+}
+
+func (m *OfpMeterMod) Reset() { *m = OfpMeterMod{} }
+func (m *OfpMeterMod) String() string { return proto.CompactTextString(m) }
+func (*OfpMeterMod) ProtoMessage() {}
+func (*OfpMeterMod) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{39} }
+
+func (m *OfpMeterMod) GetCommand() OfpMeterModCommand {
+ if m != nil {
+ return m.Command
+ }
+ return OfpMeterModCommand_OFPMC_ADD
+}
+
+func (m *OfpMeterMod) GetFlags() uint32 {
+ if m != nil {
+ return m.Flags
+ }
+ return 0
+}
+
+func (m *OfpMeterMod) GetMeterId() uint32 {
+ if m != nil {
+ return m.MeterId
+ }
+ return 0
+}
+
+func (m *OfpMeterMod) GetBands() []*OfpMeterBandHeader {
+ if m != nil {
+ return m.Bands
+ }
+ return nil
+}
+
+// OFPT_ERROR: Error message (datapath -> controller).
+type OfpErrorMsg struct {
+ // ofp_header header;
+ Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+ Code uint32 `protobuf:"varint,2,opt,name=code" json:"code,omitempty"`
+ Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpErrorMsg) Reset() { *m = OfpErrorMsg{} }
+func (m *OfpErrorMsg) String() string { return proto.CompactTextString(m) }
+func (*OfpErrorMsg) ProtoMessage() {}
+func (*OfpErrorMsg) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{40} }
+
+func (m *OfpErrorMsg) GetType() uint32 {
+ if m != nil {
+ return m.Type
+ }
+ return 0
+}
+
+func (m *OfpErrorMsg) GetCode() uint32 {
+ if m != nil {
+ return m.Code
+ }
+ return 0
+}
+
+func (m *OfpErrorMsg) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+// OFPET_EXPERIMENTER: Error message (datapath -> controller).
+type OfpErrorExperimenterMsg struct {
+ Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+ ExpType uint32 `protobuf:"varint,2,opt,name=exp_type,json=expType" json:"exp_type,omitempty"`
+ Experimenter uint32 `protobuf:"varint,3,opt,name=experimenter" json:"experimenter,omitempty"`
+ Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpErrorExperimenterMsg) Reset() { *m = OfpErrorExperimenterMsg{} }
+func (m *OfpErrorExperimenterMsg) String() string { return proto.CompactTextString(m) }
+func (*OfpErrorExperimenterMsg) ProtoMessage() {}
+func (*OfpErrorExperimenterMsg) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{41} }
+
+func (m *OfpErrorExperimenterMsg) GetType() uint32 {
+ if m != nil {
+ return m.Type
+ }
+ return 0
+}
+
+func (m *OfpErrorExperimenterMsg) GetExpType() uint32 {
+ if m != nil {
+ return m.ExpType
+ }
+ return 0
+}
+
+func (m *OfpErrorExperimenterMsg) GetExperimenter() uint32 {
+ if m != nil {
+ return m.Experimenter
+ }
+ return 0
+}
+
+func (m *OfpErrorExperimenterMsg) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+type OfpMultipartRequest struct {
+ // ofp_header header;
+ Type OfpMultipartType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpMultipartType" json:"type,omitempty"`
+ Flags uint32 `protobuf:"varint,2,opt,name=flags" json:"flags,omitempty"`
+ Body []byte `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
+}
+
+func (m *OfpMultipartRequest) Reset() { *m = OfpMultipartRequest{} }
+func (m *OfpMultipartRequest) String() string { return proto.CompactTextString(m) }
+func (*OfpMultipartRequest) ProtoMessage() {}
+func (*OfpMultipartRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{42} }
+
+func (m *OfpMultipartRequest) GetType() OfpMultipartType {
+ if m != nil {
+ return m.Type
+ }
+ return OfpMultipartType_OFPMP_DESC
+}
+
+func (m *OfpMultipartRequest) GetFlags() uint32 {
+ if m != nil {
+ return m.Flags
+ }
+ return 0
+}
+
+func (m *OfpMultipartRequest) GetBody() []byte {
+ if m != nil {
+ return m.Body
+ }
+ return nil
+}
+
+type OfpMultipartReply struct {
+ // ofp_header header;
+ Type OfpMultipartType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpMultipartType" json:"type,omitempty"`
+ Flags uint32 `protobuf:"varint,2,opt,name=flags" json:"flags,omitempty"`
+ Body []byte `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
+}
+
+func (m *OfpMultipartReply) Reset() { *m = OfpMultipartReply{} }
+func (m *OfpMultipartReply) String() string { return proto.CompactTextString(m) }
+func (*OfpMultipartReply) ProtoMessage() {}
+func (*OfpMultipartReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{43} }
+
+func (m *OfpMultipartReply) GetType() OfpMultipartType {
+ if m != nil {
+ return m.Type
+ }
+ return OfpMultipartType_OFPMP_DESC
+}
+
+func (m *OfpMultipartReply) GetFlags() uint32 {
+ if m != nil {
+ return m.Flags
+ }
+ return 0
+}
+
+func (m *OfpMultipartReply) GetBody() []byte {
+ if m != nil {
+ return m.Body
+ }
+ return nil
+}
+
+// Body of reply to OFPMP_DESC request. Each entry is a NULL-terminated
+// ASCII string.
+type OfpDesc struct {
+ MfrDesc string `protobuf:"bytes,1,opt,name=mfr_desc,json=mfrDesc" json:"mfr_desc,omitempty"`
+ HwDesc string `protobuf:"bytes,2,opt,name=hw_desc,json=hwDesc" json:"hw_desc,omitempty"`
+ SwDesc string `protobuf:"bytes,3,opt,name=sw_desc,json=swDesc" json:"sw_desc,omitempty"`
+ SerialNum string `protobuf:"bytes,4,opt,name=serial_num,json=serialNum" json:"serial_num,omitempty"`
+ DpDesc string `protobuf:"bytes,5,opt,name=dp_desc,json=dpDesc" json:"dp_desc,omitempty"`
+}
+
+func (m *OfpDesc) Reset() { *m = OfpDesc{} }
+func (m *OfpDesc) String() string { return proto.CompactTextString(m) }
+func (*OfpDesc) ProtoMessage() {}
+func (*OfpDesc) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{44} }
+
+func (m *OfpDesc) GetMfrDesc() string {
+ if m != nil {
+ return m.MfrDesc
+ }
+ return ""
+}
+
+func (m *OfpDesc) GetHwDesc() string {
+ if m != nil {
+ return m.HwDesc
+ }
+ return ""
+}
+
+func (m *OfpDesc) GetSwDesc() string {
+ if m != nil {
+ return m.SwDesc
+ }
+ return ""
+}
+
+func (m *OfpDesc) GetSerialNum() string {
+ if m != nil {
+ return m.SerialNum
+ }
+ return ""
+}
+
+func (m *OfpDesc) GetDpDesc() string {
+ if m != nil {
+ return m.DpDesc
+ }
+ return ""
+}
+
+// Body for ofp_multipart_request of type OFPMP_FLOW.
+type OfpFlowStatsRequest struct {
+ TableId uint32 `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+ OutPort uint32 `protobuf:"varint,2,opt,name=out_port,json=outPort" json:"out_port,omitempty"`
+ OutGroup uint32 `protobuf:"varint,3,opt,name=out_group,json=outGroup" json:"out_group,omitempty"`
+ Cookie uint64 `protobuf:"varint,4,opt,name=cookie" json:"cookie,omitempty"`
+ CookieMask uint64 `protobuf:"varint,5,opt,name=cookie_mask,json=cookieMask" json:"cookie_mask,omitempty"`
+ Match *OfpMatch `protobuf:"bytes,6,opt,name=match" json:"match,omitempty"`
+}
+
+func (m *OfpFlowStatsRequest) Reset() { *m = OfpFlowStatsRequest{} }
+func (m *OfpFlowStatsRequest) String() string { return proto.CompactTextString(m) }
+func (*OfpFlowStatsRequest) ProtoMessage() {}
+func (*OfpFlowStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{45} }
+
+func (m *OfpFlowStatsRequest) GetTableId() uint32 {
+ if m != nil {
+ return m.TableId
+ }
+ return 0
+}
+
+func (m *OfpFlowStatsRequest) GetOutPort() uint32 {
+ if m != nil {
+ return m.OutPort
+ }
+ return 0
+}
+
+func (m *OfpFlowStatsRequest) GetOutGroup() uint32 {
+ if m != nil {
+ return m.OutGroup
+ }
+ return 0
+}
+
+func (m *OfpFlowStatsRequest) GetCookie() uint64 {
+ if m != nil {
+ return m.Cookie
+ }
+ return 0
+}
+
+func (m *OfpFlowStatsRequest) GetCookieMask() uint64 {
+ if m != nil {
+ return m.CookieMask
+ }
+ return 0
+}
+
+func (m *OfpFlowStatsRequest) GetMatch() *OfpMatch {
+ if m != nil {
+ return m.Match
+ }
+ return nil
+}
+
+// Body of reply to OFPMP_FLOW request.
+type OfpFlowStats struct {
+ Id uint64 `protobuf:"varint,14,opt,name=id" json:"id,omitempty"`
+ TableId uint32 `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+ DurationSec uint32 `protobuf:"varint,2,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+ DurationNsec uint32 `protobuf:"varint,3,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+ Priority uint32 `protobuf:"varint,4,opt,name=priority" json:"priority,omitempty"`
+ IdleTimeout uint32 `protobuf:"varint,5,opt,name=idle_timeout,json=idleTimeout" json:"idle_timeout,omitempty"`
+ HardTimeout uint32 `protobuf:"varint,6,opt,name=hard_timeout,json=hardTimeout" json:"hard_timeout,omitempty"`
+ Flags uint32 `protobuf:"varint,7,opt,name=flags" json:"flags,omitempty"`
+ Cookie uint64 `protobuf:"varint,8,opt,name=cookie" json:"cookie,omitempty"`
+ PacketCount uint64 `protobuf:"varint,9,opt,name=packet_count,json=packetCount" json:"packet_count,omitempty"`
+ ByteCount uint64 `protobuf:"varint,10,opt,name=byte_count,json=byteCount" json:"byte_count,omitempty"`
+ Match *OfpMatch `protobuf:"bytes,12,opt,name=match" json:"match,omitempty"`
+ Instructions []*OfpInstruction `protobuf:"bytes,13,rep,name=instructions" json:"instructions,omitempty"`
+}
+
+func (m *OfpFlowStats) Reset() { *m = OfpFlowStats{} }
+func (m *OfpFlowStats) String() string { return proto.CompactTextString(m) }
+func (*OfpFlowStats) ProtoMessage() {}
+func (*OfpFlowStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{46} }
+
+func (m *OfpFlowStats) GetId() uint64 {
+ if m != nil {
+ return m.Id
+ }
+ return 0
+}
+
+func (m *OfpFlowStats) GetTableId() uint32 {
+ if m != nil {
+ return m.TableId
+ }
+ return 0
+}
+
+func (m *OfpFlowStats) GetDurationSec() uint32 {
+ if m != nil {
+ return m.DurationSec
+ }
+ return 0
+}
+
+func (m *OfpFlowStats) GetDurationNsec() uint32 {
+ if m != nil {
+ return m.DurationNsec
+ }
+ return 0
+}
+
+func (m *OfpFlowStats) GetPriority() uint32 {
+ if m != nil {
+ return m.Priority
+ }
+ return 0
+}
+
+func (m *OfpFlowStats) GetIdleTimeout() uint32 {
+ if m != nil {
+ return m.IdleTimeout
+ }
+ return 0
+}
+
+func (m *OfpFlowStats) GetHardTimeout() uint32 {
+ if m != nil {
+ return m.HardTimeout
+ }
+ return 0
+}
+
+func (m *OfpFlowStats) GetFlags() uint32 {
+ if m != nil {
+ return m.Flags
+ }
+ return 0
+}
+
+func (m *OfpFlowStats) GetCookie() uint64 {
+ if m != nil {
+ return m.Cookie
+ }
+ return 0
+}
+
+func (m *OfpFlowStats) GetPacketCount() uint64 {
+ if m != nil {
+ return m.PacketCount
+ }
+ return 0
+}
+
+func (m *OfpFlowStats) GetByteCount() uint64 {
+ if m != nil {
+ return m.ByteCount
+ }
+ return 0
+}
+
+func (m *OfpFlowStats) GetMatch() *OfpMatch {
+ if m != nil {
+ return m.Match
+ }
+ return nil
+}
+
+func (m *OfpFlowStats) GetInstructions() []*OfpInstruction {
+ if m != nil {
+ return m.Instructions
+ }
+ return nil
+}
+
+// Body for ofp_multipart_request of type OFPMP_AGGREGATE.
+type OfpAggregateStatsRequest struct {
+ TableId uint32 `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+ OutPort uint32 `protobuf:"varint,2,opt,name=out_port,json=outPort" json:"out_port,omitempty"`
+ OutGroup uint32 `protobuf:"varint,3,opt,name=out_group,json=outGroup" json:"out_group,omitempty"`
+ Cookie uint64 `protobuf:"varint,4,opt,name=cookie" json:"cookie,omitempty"`
+ CookieMask uint64 `protobuf:"varint,5,opt,name=cookie_mask,json=cookieMask" json:"cookie_mask,omitempty"`
+ Match *OfpMatch `protobuf:"bytes,6,opt,name=match" json:"match,omitempty"`
+}
+
+func (m *OfpAggregateStatsRequest) Reset() { *m = OfpAggregateStatsRequest{} }
+func (m *OfpAggregateStatsRequest) String() string { return proto.CompactTextString(m) }
+func (*OfpAggregateStatsRequest) ProtoMessage() {}
+func (*OfpAggregateStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{47} }
+
+func (m *OfpAggregateStatsRequest) GetTableId() uint32 {
+ if m != nil {
+ return m.TableId
+ }
+ return 0
+}
+
+func (m *OfpAggregateStatsRequest) GetOutPort() uint32 {
+ if m != nil {
+ return m.OutPort
+ }
+ return 0
+}
+
+func (m *OfpAggregateStatsRequest) GetOutGroup() uint32 {
+ if m != nil {
+ return m.OutGroup
+ }
+ return 0
+}
+
+func (m *OfpAggregateStatsRequest) GetCookie() uint64 {
+ if m != nil {
+ return m.Cookie
+ }
+ return 0
+}
+
+func (m *OfpAggregateStatsRequest) GetCookieMask() uint64 {
+ if m != nil {
+ return m.CookieMask
+ }
+ return 0
+}
+
+func (m *OfpAggregateStatsRequest) GetMatch() *OfpMatch {
+ if m != nil {
+ return m.Match
+ }
+ return nil
+}
+
+// Body of reply to OFPMP_AGGREGATE request.
+type OfpAggregateStatsReply struct {
+ PacketCount uint64 `protobuf:"varint,1,opt,name=packet_count,json=packetCount" json:"packet_count,omitempty"`
+ ByteCount uint64 `protobuf:"varint,2,opt,name=byte_count,json=byteCount" json:"byte_count,omitempty"`
+ FlowCount uint32 `protobuf:"varint,3,opt,name=flow_count,json=flowCount" json:"flow_count,omitempty"`
+}
+
+func (m *OfpAggregateStatsReply) Reset() { *m = OfpAggregateStatsReply{} }
+func (m *OfpAggregateStatsReply) String() string { return proto.CompactTextString(m) }
+func (*OfpAggregateStatsReply) ProtoMessage() {}
+func (*OfpAggregateStatsReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{48} }
+
+func (m *OfpAggregateStatsReply) GetPacketCount() uint64 {
+ if m != nil {
+ return m.PacketCount
+ }
+ return 0
+}
+
+func (m *OfpAggregateStatsReply) GetByteCount() uint64 {
+ if m != nil {
+ return m.ByteCount
+ }
+ return 0
+}
+
+func (m *OfpAggregateStatsReply) GetFlowCount() uint32 {
+ if m != nil {
+ return m.FlowCount
+ }
+ return 0
+}
+
+// Common header for all Table Feature Properties
+type OfpTableFeatureProperty struct {
+ Type OfpTableFeaturePropType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpTableFeaturePropType" json:"type,omitempty"`
+ // Types that are valid to be assigned to Value:
+ // *OfpTableFeatureProperty_Instructions
+ // *OfpTableFeatureProperty_NextTables
+ // *OfpTableFeatureProperty_Actions
+ // *OfpTableFeatureProperty_Oxm
+ // *OfpTableFeatureProperty_Experimenter
+ Value isOfpTableFeatureProperty_Value `protobuf_oneof:"value"`
+}
+
+func (m *OfpTableFeatureProperty) Reset() { *m = OfpTableFeatureProperty{} }
+func (m *OfpTableFeatureProperty) String() string { return proto.CompactTextString(m) }
+func (*OfpTableFeatureProperty) ProtoMessage() {}
+func (*OfpTableFeatureProperty) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{49} }
+
+type isOfpTableFeatureProperty_Value interface {
+ isOfpTableFeatureProperty_Value()
+}
+
+type OfpTableFeatureProperty_Instructions struct {
+ Instructions *OfpTableFeaturePropInstructions `protobuf:"bytes,2,opt,name=instructions,oneof"`
+}
+type OfpTableFeatureProperty_NextTables struct {
+ NextTables *OfpTableFeaturePropNextTables `protobuf:"bytes,3,opt,name=next_tables,json=nextTables,oneof"`
+}
+type OfpTableFeatureProperty_Actions struct {
+ Actions *OfpTableFeaturePropActions `protobuf:"bytes,4,opt,name=actions,oneof"`
+}
+type OfpTableFeatureProperty_Oxm struct {
+ Oxm *OfpTableFeaturePropOxm `protobuf:"bytes,5,opt,name=oxm,oneof"`
+}
+type OfpTableFeatureProperty_Experimenter struct {
+ Experimenter *OfpTableFeaturePropExperimenter `protobuf:"bytes,6,opt,name=experimenter,oneof"`
+}
+
+func (*OfpTableFeatureProperty_Instructions) isOfpTableFeatureProperty_Value() {}
+func (*OfpTableFeatureProperty_NextTables) isOfpTableFeatureProperty_Value() {}
+func (*OfpTableFeatureProperty_Actions) isOfpTableFeatureProperty_Value() {}
+func (*OfpTableFeatureProperty_Oxm) isOfpTableFeatureProperty_Value() {}
+func (*OfpTableFeatureProperty_Experimenter) isOfpTableFeatureProperty_Value() {}
+
+func (m *OfpTableFeatureProperty) GetValue() isOfpTableFeatureProperty_Value {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+
+func (m *OfpTableFeatureProperty) GetType() OfpTableFeaturePropType {
+ if m != nil {
+ return m.Type
+ }
+ return OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS
+}
+
+func (m *OfpTableFeatureProperty) GetInstructions() *OfpTableFeaturePropInstructions {
+ if x, ok := m.GetValue().(*OfpTableFeatureProperty_Instructions); ok {
+ return x.Instructions
+ }
+ return nil
+}
+
+func (m *OfpTableFeatureProperty) GetNextTables() *OfpTableFeaturePropNextTables {
+ if x, ok := m.GetValue().(*OfpTableFeatureProperty_NextTables); ok {
+ return x.NextTables
+ }
+ return nil
+}
+
+func (m *OfpTableFeatureProperty) GetActions() *OfpTableFeaturePropActions {
+ if x, ok := m.GetValue().(*OfpTableFeatureProperty_Actions); ok {
+ return x.Actions
+ }
+ return nil
+}
+
+func (m *OfpTableFeatureProperty) GetOxm() *OfpTableFeaturePropOxm {
+ if x, ok := m.GetValue().(*OfpTableFeatureProperty_Oxm); ok {
+ return x.Oxm
+ }
+ return nil
+}
+
+func (m *OfpTableFeatureProperty) GetExperimenter() *OfpTableFeaturePropExperimenter {
+ if x, ok := m.GetValue().(*OfpTableFeatureProperty_Experimenter); ok {
+ return x.Experimenter
+ }
+ return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpTableFeatureProperty) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _OfpTableFeatureProperty_OneofMarshaler, _OfpTableFeatureProperty_OneofUnmarshaler, _OfpTableFeatureProperty_OneofSizer, []interface{}{
+ (*OfpTableFeatureProperty_Instructions)(nil),
+ (*OfpTableFeatureProperty_NextTables)(nil),
+ (*OfpTableFeatureProperty_Actions)(nil),
+ (*OfpTableFeatureProperty_Oxm)(nil),
+ (*OfpTableFeatureProperty_Experimenter)(nil),
+ }
+}
+
+func _OfpTableFeatureProperty_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpTableFeatureProperty)
+ // value
+ switch x := m.Value.(type) {
+ case *OfpTableFeatureProperty_Instructions:
+ b.EncodeVarint(2<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Instructions); err != nil {
+ return err
+ }
+ case *OfpTableFeatureProperty_NextTables:
+ b.EncodeVarint(3<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.NextTables); err != nil {
+ return err
+ }
+ case *OfpTableFeatureProperty_Actions:
+ b.EncodeVarint(4<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Actions); err != nil {
+ return err
+ }
+ case *OfpTableFeatureProperty_Oxm:
+ b.EncodeVarint(5<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Oxm); err != nil {
+ return err
+ }
+ case *OfpTableFeatureProperty_Experimenter:
+ b.EncodeVarint(6<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Experimenter); err != nil {
+ return err
+ }
+ case nil:
+ default:
+ return fmt.Errorf("OfpTableFeatureProperty.Value has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _OfpTableFeatureProperty_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpTableFeatureProperty)
+ switch tag {
+ case 2: // value.instructions
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpTableFeaturePropInstructions)
+ err := b.DecodeMessage(msg)
+ m.Value = &OfpTableFeatureProperty_Instructions{msg}
+ return true, err
+ case 3: // value.next_tables
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpTableFeaturePropNextTables)
+ err := b.DecodeMessage(msg)
+ m.Value = &OfpTableFeatureProperty_NextTables{msg}
+ return true, err
+ case 4: // value.actions
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpTableFeaturePropActions)
+ err := b.DecodeMessage(msg)
+ m.Value = &OfpTableFeatureProperty_Actions{msg}
+ return true, err
+ case 5: // value.oxm
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpTableFeaturePropOxm)
+ err := b.DecodeMessage(msg)
+ m.Value = &OfpTableFeatureProperty_Oxm{msg}
+ return true, err
+ case 6: // value.experimenter
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpTableFeaturePropExperimenter)
+ err := b.DecodeMessage(msg)
+ m.Value = &OfpTableFeatureProperty_Experimenter{msg}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _OfpTableFeatureProperty_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*OfpTableFeatureProperty)
+ // value
+ switch x := m.Value.(type) {
+ case *OfpTableFeatureProperty_Instructions:
+ s := proto.Size(x.Instructions)
+ n += proto.SizeVarint(2<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpTableFeatureProperty_NextTables:
+ s := proto.Size(x.NextTables)
+ n += proto.SizeVarint(3<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpTableFeatureProperty_Actions:
+ s := proto.Size(x.Actions)
+ n += proto.SizeVarint(4<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpTableFeatureProperty_Oxm:
+ s := proto.Size(x.Oxm)
+ n += proto.SizeVarint(5<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *OfpTableFeatureProperty_Experimenter:
+ s := proto.Size(x.Experimenter)
+ n += proto.SizeVarint(6<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+// Instructions property
+type OfpTableFeaturePropInstructions struct {
+ // One of OFPTFPT_INSTRUCTIONS,
+ // OFPTFPT_INSTRUCTIONS_MISS.
+ Instructions []*OfpInstruction `protobuf:"bytes,1,rep,name=instructions" json:"instructions,omitempty"`
+}
+
+func (m *OfpTableFeaturePropInstructions) Reset() { *m = OfpTableFeaturePropInstructions{} }
+func (m *OfpTableFeaturePropInstructions) String() string { return proto.CompactTextString(m) }
+func (*OfpTableFeaturePropInstructions) ProtoMessage() {}
+func (*OfpTableFeaturePropInstructions) Descriptor() ([]byte, []int) {
+ return fileDescriptor0, []int{50}
+}
+
+func (m *OfpTableFeaturePropInstructions) GetInstructions() []*OfpInstruction {
+ if m != nil {
+ return m.Instructions
+ }
+ return nil
+}
+
+// Next Tables property
+type OfpTableFeaturePropNextTables struct {
+ // One of OFPTFPT_NEXT_TABLES,
+ // OFPTFPT_NEXT_TABLES_MISS.
+ NextTableIds []uint32 `protobuf:"varint,1,rep,packed,name=next_table_ids,json=nextTableIds" json:"next_table_ids,omitempty"`
+}
+
+func (m *OfpTableFeaturePropNextTables) Reset() { *m = OfpTableFeaturePropNextTables{} }
+func (m *OfpTableFeaturePropNextTables) String() string { return proto.CompactTextString(m) }
+func (*OfpTableFeaturePropNextTables) ProtoMessage() {}
+func (*OfpTableFeaturePropNextTables) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{51} }
+
+func (m *OfpTableFeaturePropNextTables) GetNextTableIds() []uint32 {
+ if m != nil {
+ return m.NextTableIds
+ }
+ return nil
+}
+
+// Actions property
+type OfpTableFeaturePropActions struct {
+ // One of OFPTFPT_WRITE_ACTIONS,
+ // OFPTFPT_WRITE_ACTIONS_MISS,
+ // OFPTFPT_APPLY_ACTIONS,
+ // OFPTFPT_APPLY_ACTIONS_MISS.
+ Actions []*OfpAction `protobuf:"bytes,1,rep,name=actions" json:"actions,omitempty"`
+}
+
+func (m *OfpTableFeaturePropActions) Reset() { *m = OfpTableFeaturePropActions{} }
+func (m *OfpTableFeaturePropActions) String() string { return proto.CompactTextString(m) }
+func (*OfpTableFeaturePropActions) ProtoMessage() {}
+func (*OfpTableFeaturePropActions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{52} }
+
+func (m *OfpTableFeaturePropActions) GetActions() []*OfpAction {
+ if m != nil {
+ return m.Actions
+ }
+ return nil
+}
+
+// Match, Wildcard or Set-Field property
+type OfpTableFeaturePropOxm struct {
+ // TODO is this a uint32???
+ OxmIds []uint32 `protobuf:"varint,3,rep,packed,name=oxm_ids,json=oxmIds" json:"oxm_ids,omitempty"`
+}
+
+func (m *OfpTableFeaturePropOxm) Reset() { *m = OfpTableFeaturePropOxm{} }
+func (m *OfpTableFeaturePropOxm) String() string { return proto.CompactTextString(m) }
+func (*OfpTableFeaturePropOxm) ProtoMessage() {}
+func (*OfpTableFeaturePropOxm) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{53} }
+
+func (m *OfpTableFeaturePropOxm) GetOxmIds() []uint32 {
+ if m != nil {
+ return m.OxmIds
+ }
+ return nil
+}
+
+// Experimenter table feature property
+type OfpTableFeaturePropExperimenter struct {
+ // One of OFPTFPT_EXPERIMENTER,
+ // OFPTFPT_EXPERIMENTER_MISS.
+ Experimenter uint32 `protobuf:"varint,2,opt,name=experimenter" json:"experimenter,omitempty"`
+ ExpType uint32 `protobuf:"varint,3,opt,name=exp_type,json=expType" json:"exp_type,omitempty"`
+ ExperimenterData []uint32 `protobuf:"varint,4,rep,packed,name=experimenter_data,json=experimenterData" json:"experimenter_data,omitempty"`
+}
+
+func (m *OfpTableFeaturePropExperimenter) Reset() { *m = OfpTableFeaturePropExperimenter{} }
+func (m *OfpTableFeaturePropExperimenter) String() string { return proto.CompactTextString(m) }
+func (*OfpTableFeaturePropExperimenter) ProtoMessage() {}
+func (*OfpTableFeaturePropExperimenter) Descriptor() ([]byte, []int) {
+ return fileDescriptor0, []int{54}
+}
+
+func (m *OfpTableFeaturePropExperimenter) GetExperimenter() uint32 {
+ if m != nil {
+ return m.Experimenter
+ }
+ return 0
+}
+
+func (m *OfpTableFeaturePropExperimenter) GetExpType() uint32 {
+ if m != nil {
+ return m.ExpType
+ }
+ return 0
+}
+
+func (m *OfpTableFeaturePropExperimenter) GetExperimenterData() []uint32 {
+ if m != nil {
+ return m.ExperimenterData
+ }
+ return nil
+}
+
+// Body for ofp_multipart_request of type OFPMP_TABLE_FEATURES./
+// Body of reply to OFPMP_TABLE_FEATURES request.
+type OfpTableFeatures struct {
+ TableId uint32 `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+ Name string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+ MetadataMatch uint64 `protobuf:"varint,3,opt,name=metadata_match,json=metadataMatch" json:"metadata_match,omitempty"`
+ MetadataWrite uint64 `protobuf:"varint,4,opt,name=metadata_write,json=metadataWrite" json:"metadata_write,omitempty"`
+ Config uint32 `protobuf:"varint,5,opt,name=config" json:"config,omitempty"`
+ MaxEntries uint32 `protobuf:"varint,6,opt,name=max_entries,json=maxEntries" json:"max_entries,omitempty"`
+ // Table Feature Property list
+ Properties []*OfpTableFeatureProperty `protobuf:"bytes,7,rep,name=properties" json:"properties,omitempty"`
+}
+
+func (m *OfpTableFeatures) Reset() { *m = OfpTableFeatures{} }
+func (m *OfpTableFeatures) String() string { return proto.CompactTextString(m) }
+func (*OfpTableFeatures) ProtoMessage() {}
+func (*OfpTableFeatures) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{55} }
+
+func (m *OfpTableFeatures) GetTableId() uint32 {
+ if m != nil {
+ return m.TableId
+ }
+ return 0
+}
+
+func (m *OfpTableFeatures) GetName() string {
+ if m != nil {
+ return m.Name
+ }
+ return ""
+}
+
+func (m *OfpTableFeatures) GetMetadataMatch() uint64 {
+ if m != nil {
+ return m.MetadataMatch
+ }
+ return 0
+}
+
+func (m *OfpTableFeatures) GetMetadataWrite() uint64 {
+ if m != nil {
+ return m.MetadataWrite
+ }
+ return 0
+}
+
+func (m *OfpTableFeatures) GetConfig() uint32 {
+ if m != nil {
+ return m.Config
+ }
+ return 0
+}
+
+func (m *OfpTableFeatures) GetMaxEntries() uint32 {
+ if m != nil {
+ return m.MaxEntries
+ }
+ return 0
+}
+
+func (m *OfpTableFeatures) GetProperties() []*OfpTableFeatureProperty {
+ if m != nil {
+ return m.Properties
+ }
+ return nil
+}
+
+// Body of reply to OFPMP_TABLE request.
+type OfpTableStats struct {
+ TableId uint32 `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+ ActiveCount uint32 `protobuf:"varint,2,opt,name=active_count,json=activeCount" json:"active_count,omitempty"`
+ LookupCount uint64 `protobuf:"varint,3,opt,name=lookup_count,json=lookupCount" json:"lookup_count,omitempty"`
+ MatchedCount uint64 `protobuf:"varint,4,opt,name=matched_count,json=matchedCount" json:"matched_count,omitempty"`
+}
+
+func (m *OfpTableStats) Reset() { *m = OfpTableStats{} }
+func (m *OfpTableStats) String() string { return proto.CompactTextString(m) }
+func (*OfpTableStats) ProtoMessage() {}
+func (*OfpTableStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{56} }
+
+func (m *OfpTableStats) GetTableId() uint32 {
+ if m != nil {
+ return m.TableId
+ }
+ return 0
+}
+
+func (m *OfpTableStats) GetActiveCount() uint32 {
+ if m != nil {
+ return m.ActiveCount
+ }
+ return 0
+}
+
+func (m *OfpTableStats) GetLookupCount() uint64 {
+ if m != nil {
+ return m.LookupCount
+ }
+ return 0
+}
+
+func (m *OfpTableStats) GetMatchedCount() uint64 {
+ if m != nil {
+ return m.MatchedCount
+ }
+ return 0
+}
+
+// Body for ofp_multipart_request of type OFPMP_PORT.
+type OfpPortStatsRequest struct {
+ PortNo uint32 `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+}
+
+func (m *OfpPortStatsRequest) Reset() { *m = OfpPortStatsRequest{} }
+func (m *OfpPortStatsRequest) String() string { return proto.CompactTextString(m) }
+func (*OfpPortStatsRequest) ProtoMessage() {}
+func (*OfpPortStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{57} }
+
+func (m *OfpPortStatsRequest) GetPortNo() uint32 {
+ if m != nil {
+ return m.PortNo
+ }
+ return 0
+}
+
+// Body of reply to OFPMP_PORT request. If a counter is unsupported, set
+// the field to all ones.
+type OfpPortStats struct {
+ PortNo uint32 `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+ RxPackets uint64 `protobuf:"varint,2,opt,name=rx_packets,json=rxPackets" json:"rx_packets,omitempty"`
+ TxPackets uint64 `protobuf:"varint,3,opt,name=tx_packets,json=txPackets" json:"tx_packets,omitempty"`
+ RxBytes uint64 `protobuf:"varint,4,opt,name=rx_bytes,json=rxBytes" json:"rx_bytes,omitempty"`
+ TxBytes uint64 `protobuf:"varint,5,opt,name=tx_bytes,json=txBytes" json:"tx_bytes,omitempty"`
+ RxDropped uint64 `protobuf:"varint,6,opt,name=rx_dropped,json=rxDropped" json:"rx_dropped,omitempty"`
+ TxDropped uint64 `protobuf:"varint,7,opt,name=tx_dropped,json=txDropped" json:"tx_dropped,omitempty"`
+ RxErrors uint64 `protobuf:"varint,8,opt,name=rx_errors,json=rxErrors" json:"rx_errors,omitempty"`
+ TxErrors uint64 `protobuf:"varint,9,opt,name=tx_errors,json=txErrors" json:"tx_errors,omitempty"`
+ RxFrameErr uint64 `protobuf:"varint,10,opt,name=rx_frame_err,json=rxFrameErr" json:"rx_frame_err,omitempty"`
+ RxOverErr uint64 `protobuf:"varint,11,opt,name=rx_over_err,json=rxOverErr" json:"rx_over_err,omitempty"`
+ RxCrcErr uint64 `protobuf:"varint,12,opt,name=rx_crc_err,json=rxCrcErr" json:"rx_crc_err,omitempty"`
+ Collisions uint64 `protobuf:"varint,13,opt,name=collisions" json:"collisions,omitempty"`
+ DurationSec uint32 `protobuf:"varint,14,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+ DurationNsec uint32 `protobuf:"varint,15,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+}
+
+func (m *OfpPortStats) Reset() { *m = OfpPortStats{} }
+func (m *OfpPortStats) String() string { return proto.CompactTextString(m) }
+func (*OfpPortStats) ProtoMessage() {}
+func (*OfpPortStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{58} }
+
+func (m *OfpPortStats) GetPortNo() uint32 {
+ if m != nil {
+ return m.PortNo
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetRxPackets() uint64 {
+ if m != nil {
+ return m.RxPackets
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetTxPackets() uint64 {
+ if m != nil {
+ return m.TxPackets
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetRxBytes() uint64 {
+ if m != nil {
+ return m.RxBytes
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetTxBytes() uint64 {
+ if m != nil {
+ return m.TxBytes
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetRxDropped() uint64 {
+ if m != nil {
+ return m.RxDropped
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetTxDropped() uint64 {
+ if m != nil {
+ return m.TxDropped
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetRxErrors() uint64 {
+ if m != nil {
+ return m.RxErrors
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetTxErrors() uint64 {
+ if m != nil {
+ return m.TxErrors
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetRxFrameErr() uint64 {
+ if m != nil {
+ return m.RxFrameErr
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetRxOverErr() uint64 {
+ if m != nil {
+ return m.RxOverErr
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetRxCrcErr() uint64 {
+ if m != nil {
+ return m.RxCrcErr
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetCollisions() uint64 {
+ if m != nil {
+ return m.Collisions
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetDurationSec() uint32 {
+ if m != nil {
+ return m.DurationSec
+ }
+ return 0
+}
+
+func (m *OfpPortStats) GetDurationNsec() uint32 {
+ if m != nil {
+ return m.DurationNsec
+ }
+ return 0
+}
+
+// Body of OFPMP_GROUP request.
+type OfpGroupStatsRequest struct {
+ GroupId uint32 `protobuf:"varint,1,opt,name=group_id,json=groupId" json:"group_id,omitempty"`
+}
+
+func (m *OfpGroupStatsRequest) Reset() { *m = OfpGroupStatsRequest{} }
+func (m *OfpGroupStatsRequest) String() string { return proto.CompactTextString(m) }
+func (*OfpGroupStatsRequest) ProtoMessage() {}
+func (*OfpGroupStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{59} }
+
+func (m *OfpGroupStatsRequest) GetGroupId() uint32 {
+ if m != nil {
+ return m.GroupId
+ }
+ return 0
+}
+
+// Used in group stats replies.
+type OfpBucketCounter struct {
+ PacketCount uint64 `protobuf:"varint,1,opt,name=packet_count,json=packetCount" json:"packet_count,omitempty"`
+ ByteCount uint64 `protobuf:"varint,2,opt,name=byte_count,json=byteCount" json:"byte_count,omitempty"`
+}
+
+func (m *OfpBucketCounter) Reset() { *m = OfpBucketCounter{} }
+func (m *OfpBucketCounter) String() string { return proto.CompactTextString(m) }
+func (*OfpBucketCounter) ProtoMessage() {}
+func (*OfpBucketCounter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{60} }
+
+func (m *OfpBucketCounter) GetPacketCount() uint64 {
+ if m != nil {
+ return m.PacketCount
+ }
+ return 0
+}
+
+func (m *OfpBucketCounter) GetByteCount() uint64 {
+ if m != nil {
+ return m.ByteCount
+ }
+ return 0
+}
+
+// Body of reply to OFPMP_GROUP request.
+type OfpGroupStats struct {
+ GroupId uint32 `protobuf:"varint,1,opt,name=group_id,json=groupId" json:"group_id,omitempty"`
+ RefCount uint32 `protobuf:"varint,2,opt,name=ref_count,json=refCount" json:"ref_count,omitempty"`
+ PacketCount uint64 `protobuf:"varint,3,opt,name=packet_count,json=packetCount" json:"packet_count,omitempty"`
+ ByteCount uint64 `protobuf:"varint,4,opt,name=byte_count,json=byteCount" json:"byte_count,omitempty"`
+ DurationSec uint32 `protobuf:"varint,5,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+ DurationNsec uint32 `protobuf:"varint,6,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+ BucketStats []*OfpBucketCounter `protobuf:"bytes,7,rep,name=bucket_stats,json=bucketStats" json:"bucket_stats,omitempty"`
+}
+
+func (m *OfpGroupStats) Reset() { *m = OfpGroupStats{} }
+func (m *OfpGroupStats) String() string { return proto.CompactTextString(m) }
+func (*OfpGroupStats) ProtoMessage() {}
+func (*OfpGroupStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{61} }
+
+func (m *OfpGroupStats) GetGroupId() uint32 {
+ if m != nil {
+ return m.GroupId
+ }
+ return 0
+}
+
+func (m *OfpGroupStats) GetRefCount() uint32 {
+ if m != nil {
+ return m.RefCount
+ }
+ return 0
+}
+
+func (m *OfpGroupStats) GetPacketCount() uint64 {
+ if m != nil {
+ return m.PacketCount
+ }
+ return 0
+}
+
+func (m *OfpGroupStats) GetByteCount() uint64 {
+ if m != nil {
+ return m.ByteCount
+ }
+ return 0
+}
+
+func (m *OfpGroupStats) GetDurationSec() uint32 {
+ if m != nil {
+ return m.DurationSec
+ }
+ return 0
+}
+
+func (m *OfpGroupStats) GetDurationNsec() uint32 {
+ if m != nil {
+ return m.DurationNsec
+ }
+ return 0
+}
+
+func (m *OfpGroupStats) GetBucketStats() []*OfpBucketCounter {
+ if m != nil {
+ return m.BucketStats
+ }
+ return nil
+}
+
+// Body of reply to OFPMP_GROUP_DESC request.
+type OfpGroupDesc struct {
+ Type OfpGroupType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpGroupType" json:"type,omitempty"`
+ GroupId uint32 `protobuf:"varint,2,opt,name=group_id,json=groupId" json:"group_id,omitempty"`
+ Buckets []*OfpBucket `protobuf:"bytes,3,rep,name=buckets" json:"buckets,omitempty"`
+}
+
+func (m *OfpGroupDesc) Reset() { *m = OfpGroupDesc{} }
+func (m *OfpGroupDesc) String() string { return proto.CompactTextString(m) }
+func (*OfpGroupDesc) ProtoMessage() {}
+func (*OfpGroupDesc) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{62} }
+
+func (m *OfpGroupDesc) GetType() OfpGroupType {
+ if m != nil {
+ return m.Type
+ }
+ return OfpGroupType_OFPGT_ALL
+}
+
+func (m *OfpGroupDesc) GetGroupId() uint32 {
+ if m != nil {
+ return m.GroupId
+ }
+ return 0
+}
+
+func (m *OfpGroupDesc) GetBuckets() []*OfpBucket {
+ if m != nil {
+ return m.Buckets
+ }
+ return nil
+}
+
+type OfpGroupEntry struct {
+ Desc *OfpGroupDesc `protobuf:"bytes,1,opt,name=desc" json:"desc,omitempty"`
+ Stats *OfpGroupStats `protobuf:"bytes,2,opt,name=stats" json:"stats,omitempty"`
+}
+
+func (m *OfpGroupEntry) Reset() { *m = OfpGroupEntry{} }
+func (m *OfpGroupEntry) String() string { return proto.CompactTextString(m) }
+func (*OfpGroupEntry) ProtoMessage() {}
+func (*OfpGroupEntry) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{63} }
+
+func (m *OfpGroupEntry) GetDesc() *OfpGroupDesc {
+ if m != nil {
+ return m.Desc
+ }
+ return nil
+}
+
+func (m *OfpGroupEntry) GetStats() *OfpGroupStats {
+ if m != nil {
+ return m.Stats
+ }
+ return nil
+}
+
+// Body of reply to OFPMP_GROUP_FEATURES request. Group features.
+type OfpGroupFeatures struct {
+ Types uint32 `protobuf:"varint,1,opt,name=types" json:"types,omitempty"`
+ Capabilities uint32 `protobuf:"varint,2,opt,name=capabilities" json:"capabilities,omitempty"`
+ MaxGroups []uint32 `protobuf:"varint,3,rep,packed,name=max_groups,json=maxGroups" json:"max_groups,omitempty"`
+ Actions []uint32 `protobuf:"varint,4,rep,packed,name=actions" json:"actions,omitempty"`
+}
+
+func (m *OfpGroupFeatures) Reset() { *m = OfpGroupFeatures{} }
+func (m *OfpGroupFeatures) String() string { return proto.CompactTextString(m) }
+func (*OfpGroupFeatures) ProtoMessage() {}
+func (*OfpGroupFeatures) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{64} }
+
+func (m *OfpGroupFeatures) GetTypes() uint32 {
+ if m != nil {
+ return m.Types
+ }
+ return 0
+}
+
+func (m *OfpGroupFeatures) GetCapabilities() uint32 {
+ if m != nil {
+ return m.Capabilities
+ }
+ return 0
+}
+
+func (m *OfpGroupFeatures) GetMaxGroups() []uint32 {
+ if m != nil {
+ return m.MaxGroups
+ }
+ return nil
+}
+
+func (m *OfpGroupFeatures) GetActions() []uint32 {
+ if m != nil {
+ return m.Actions
+ }
+ return nil
+}
+
+// Body of OFPMP_METER and OFPMP_METER_CONFIG requests.
+type OfpMeterMultipartRequest struct {
+ MeterId uint32 `protobuf:"varint,1,opt,name=meter_id,json=meterId" json:"meter_id,omitempty"`
+}
+
+func (m *OfpMeterMultipartRequest) Reset() { *m = OfpMeterMultipartRequest{} }
+func (m *OfpMeterMultipartRequest) String() string { return proto.CompactTextString(m) }
+func (*OfpMeterMultipartRequest) ProtoMessage() {}
+func (*OfpMeterMultipartRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{65} }
+
+func (m *OfpMeterMultipartRequest) GetMeterId() uint32 {
+ if m != nil {
+ return m.MeterId
+ }
+ return 0
+}
+
+// Statistics for each meter band
+type OfpMeterBandStats struct {
+ PacketBandCount uint64 `protobuf:"varint,1,opt,name=packet_band_count,json=packetBandCount" json:"packet_band_count,omitempty"`
+ ByteBandCount uint64 `protobuf:"varint,2,opt,name=byte_band_count,json=byteBandCount" json:"byte_band_count,omitempty"`
+}
+
+func (m *OfpMeterBandStats) Reset() { *m = OfpMeterBandStats{} }
+func (m *OfpMeterBandStats) String() string { return proto.CompactTextString(m) }
+func (*OfpMeterBandStats) ProtoMessage() {}
+func (*OfpMeterBandStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{66} }
+
+func (m *OfpMeterBandStats) GetPacketBandCount() uint64 {
+ if m != nil {
+ return m.PacketBandCount
+ }
+ return 0
+}
+
+func (m *OfpMeterBandStats) GetByteBandCount() uint64 {
+ if m != nil {
+ return m.ByteBandCount
+ }
+ return 0
+}
+
+// Body of reply to OFPMP_METER request. Meter statistics.
+type OfpMeterStats struct {
+ MeterId uint32 `protobuf:"varint,1,opt,name=meter_id,json=meterId" json:"meter_id,omitempty"`
+ FlowCount uint32 `protobuf:"varint,2,opt,name=flow_count,json=flowCount" json:"flow_count,omitempty"`
+ PacketInCount uint64 `protobuf:"varint,3,opt,name=packet_in_count,json=packetInCount" json:"packet_in_count,omitempty"`
+ ByteInCount uint64 `protobuf:"varint,4,opt,name=byte_in_count,json=byteInCount" json:"byte_in_count,omitempty"`
+ DurationSec uint32 `protobuf:"varint,5,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+ DurationNsec uint32 `protobuf:"varint,6,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+ BandStats []*OfpMeterBandStats `protobuf:"bytes,7,rep,name=band_stats,json=bandStats" json:"band_stats,omitempty"`
+}
+
+func (m *OfpMeterStats) Reset() { *m = OfpMeterStats{} }
+func (m *OfpMeterStats) String() string { return proto.CompactTextString(m) }
+func (*OfpMeterStats) ProtoMessage() {}
+func (*OfpMeterStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{67} }
+
+func (m *OfpMeterStats) GetMeterId() uint32 {
+ if m != nil {
+ return m.MeterId
+ }
+ return 0
+}
+
+func (m *OfpMeterStats) GetFlowCount() uint32 {
+ if m != nil {
+ return m.FlowCount
+ }
+ return 0
+}
+
+func (m *OfpMeterStats) GetPacketInCount() uint64 {
+ if m != nil {
+ return m.PacketInCount
+ }
+ return 0
+}
+
+func (m *OfpMeterStats) GetByteInCount() uint64 {
+ if m != nil {
+ return m.ByteInCount
+ }
+ return 0
+}
+
+func (m *OfpMeterStats) GetDurationSec() uint32 {
+ if m != nil {
+ return m.DurationSec
+ }
+ return 0
+}
+
+func (m *OfpMeterStats) GetDurationNsec() uint32 {
+ if m != nil {
+ return m.DurationNsec
+ }
+ return 0
+}
+
+func (m *OfpMeterStats) GetBandStats() []*OfpMeterBandStats {
+ if m != nil {
+ return m.BandStats
+ }
+ return nil
+}
+
+// Body of reply to OFPMP_METER_CONFIG request. Meter configuration.
+type OfpMeterConfig struct {
+ Flags uint32 `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"`
+ MeterId uint32 `protobuf:"varint,2,opt,name=meter_id,json=meterId" json:"meter_id,omitempty"`
+ Bands []*OfpMeterBandHeader `protobuf:"bytes,3,rep,name=bands" json:"bands,omitempty"`
+}
+
+func (m *OfpMeterConfig) Reset() { *m = OfpMeterConfig{} }
+func (m *OfpMeterConfig) String() string { return proto.CompactTextString(m) }
+func (*OfpMeterConfig) ProtoMessage() {}
+func (*OfpMeterConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{68} }
+
+func (m *OfpMeterConfig) GetFlags() uint32 {
+ if m != nil {
+ return m.Flags
+ }
+ return 0
+}
+
+func (m *OfpMeterConfig) GetMeterId() uint32 {
+ if m != nil {
+ return m.MeterId
+ }
+ return 0
+}
+
+func (m *OfpMeterConfig) GetBands() []*OfpMeterBandHeader {
+ if m != nil {
+ return m.Bands
+ }
+ return nil
+}
+
+// Body of reply to OFPMP_METER_FEATURES request. Meter features.
+type OfpMeterFeatures struct {
+ MaxMeter uint32 `protobuf:"varint,1,opt,name=max_meter,json=maxMeter" json:"max_meter,omitempty"`
+ BandTypes uint32 `protobuf:"varint,2,opt,name=band_types,json=bandTypes" json:"band_types,omitempty"`
+ Capabilities uint32 `protobuf:"varint,3,opt,name=capabilities" json:"capabilities,omitempty"`
+ MaxBands uint32 `protobuf:"varint,4,opt,name=max_bands,json=maxBands" json:"max_bands,omitempty"`
+ MaxColor uint32 `protobuf:"varint,5,opt,name=max_color,json=maxColor" json:"max_color,omitempty"`
+}
+
+func (m *OfpMeterFeatures) Reset() { *m = OfpMeterFeatures{} }
+func (m *OfpMeterFeatures) String() string { return proto.CompactTextString(m) }
+func (*OfpMeterFeatures) ProtoMessage() {}
+func (*OfpMeterFeatures) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{69} }
+
+func (m *OfpMeterFeatures) GetMaxMeter() uint32 {
+ if m != nil {
+ return m.MaxMeter
+ }
+ return 0
+}
+
+func (m *OfpMeterFeatures) GetBandTypes() uint32 {
+ if m != nil {
+ return m.BandTypes
+ }
+ return 0
+}
+
+func (m *OfpMeterFeatures) GetCapabilities() uint32 {
+ if m != nil {
+ return m.Capabilities
+ }
+ return 0
+}
+
+func (m *OfpMeterFeatures) GetMaxBands() uint32 {
+ if m != nil {
+ return m.MaxBands
+ }
+ return 0
+}
+
+func (m *OfpMeterFeatures) GetMaxColor() uint32 {
+ if m != nil {
+ return m.MaxColor
+ }
+ return 0
+}
+
+// Body for ofp_multipart_request/reply of type OFPMP_EXPERIMENTER.
+type OfpExperimenterMultipartHeader struct {
+ Experimenter uint32 `protobuf:"varint,1,opt,name=experimenter" json:"experimenter,omitempty"`
+ ExpType uint32 `protobuf:"varint,2,opt,name=exp_type,json=expType" json:"exp_type,omitempty"`
+ Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpExperimenterMultipartHeader) Reset() { *m = OfpExperimenterMultipartHeader{} }
+func (m *OfpExperimenterMultipartHeader) String() string { return proto.CompactTextString(m) }
+func (*OfpExperimenterMultipartHeader) ProtoMessage() {}
+func (*OfpExperimenterMultipartHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{70} }
+
+func (m *OfpExperimenterMultipartHeader) GetExperimenter() uint32 {
+ if m != nil {
+ return m.Experimenter
+ }
+ return 0
+}
+
+func (m *OfpExperimenterMultipartHeader) GetExpType() uint32 {
+ if m != nil {
+ return m.ExpType
+ }
+ return 0
+}
+
+func (m *OfpExperimenterMultipartHeader) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+// Experimenter extension.
+type OfpExperimenterHeader struct {
+ // ofp_header header; /* Type OFPT_EXPERIMENTER. */
+ Experimenter uint32 `protobuf:"varint,1,opt,name=experimenter" json:"experimenter,omitempty"`
+ ExpType uint32 `protobuf:"varint,2,opt,name=exp_type,json=expType" json:"exp_type,omitempty"`
+ Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpExperimenterHeader) Reset() { *m = OfpExperimenterHeader{} }
+func (m *OfpExperimenterHeader) String() string { return proto.CompactTextString(m) }
+func (*OfpExperimenterHeader) ProtoMessage() {}
+func (*OfpExperimenterHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{71} }
+
+func (m *OfpExperimenterHeader) GetExperimenter() uint32 {
+ if m != nil {
+ return m.Experimenter
+ }
+ return 0
+}
+
+func (m *OfpExperimenterHeader) GetExpType() uint32 {
+ if m != nil {
+ return m.ExpType
+ }
+ return 0
+}
+
+func (m *OfpExperimenterHeader) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+// Common description for a queue.
+type OfpQueuePropHeader struct {
+ Property uint32 `protobuf:"varint,1,opt,name=property" json:"property,omitempty"`
+ Len uint32 `protobuf:"varint,2,opt,name=len" json:"len,omitempty"`
+}
+
+func (m *OfpQueuePropHeader) Reset() { *m = OfpQueuePropHeader{} }
+func (m *OfpQueuePropHeader) String() string { return proto.CompactTextString(m) }
+func (*OfpQueuePropHeader) ProtoMessage() {}
+func (*OfpQueuePropHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{72} }
+
+func (m *OfpQueuePropHeader) GetProperty() uint32 {
+ if m != nil {
+ return m.Property
+ }
+ return 0
+}
+
+func (m *OfpQueuePropHeader) GetLen() uint32 {
+ if m != nil {
+ return m.Len
+ }
+ return 0
+}
+
+// Min-Rate queue property description.
+type OfpQueuePropMinRate struct {
+ PropHeader *OfpQueuePropHeader `protobuf:"bytes,1,opt,name=prop_header,json=propHeader" json:"prop_header,omitempty"`
+ Rate uint32 `protobuf:"varint,2,opt,name=rate" json:"rate,omitempty"`
+}
+
+func (m *OfpQueuePropMinRate) Reset() { *m = OfpQueuePropMinRate{} }
+func (m *OfpQueuePropMinRate) String() string { return proto.CompactTextString(m) }
+func (*OfpQueuePropMinRate) ProtoMessage() {}
+func (*OfpQueuePropMinRate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{73} }
+
+func (m *OfpQueuePropMinRate) GetPropHeader() *OfpQueuePropHeader {
+ if m != nil {
+ return m.PropHeader
+ }
+ return nil
+}
+
+func (m *OfpQueuePropMinRate) GetRate() uint32 {
+ if m != nil {
+ return m.Rate
+ }
+ return 0
+}
+
+// Max-Rate queue property description.
+type OfpQueuePropMaxRate struct {
+ PropHeader *OfpQueuePropHeader `protobuf:"bytes,1,opt,name=prop_header,json=propHeader" json:"prop_header,omitempty"`
+ Rate uint32 `protobuf:"varint,2,opt,name=rate" json:"rate,omitempty"`
+}
+
+func (m *OfpQueuePropMaxRate) Reset() { *m = OfpQueuePropMaxRate{} }
+func (m *OfpQueuePropMaxRate) String() string { return proto.CompactTextString(m) }
+func (*OfpQueuePropMaxRate) ProtoMessage() {}
+func (*OfpQueuePropMaxRate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{74} }
+
+func (m *OfpQueuePropMaxRate) GetPropHeader() *OfpQueuePropHeader {
+ if m != nil {
+ return m.PropHeader
+ }
+ return nil
+}
+
+func (m *OfpQueuePropMaxRate) GetRate() uint32 {
+ if m != nil {
+ return m.Rate
+ }
+ return 0
+}
+
+// Experimenter queue property description.
+type OfpQueuePropExperimenter struct {
+ PropHeader *OfpQueuePropHeader `protobuf:"bytes,1,opt,name=prop_header,json=propHeader" json:"prop_header,omitempty"`
+ Experimenter uint32 `protobuf:"varint,2,opt,name=experimenter" json:"experimenter,omitempty"`
+ Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpQueuePropExperimenter) Reset() { *m = OfpQueuePropExperimenter{} }
+func (m *OfpQueuePropExperimenter) String() string { return proto.CompactTextString(m) }
+func (*OfpQueuePropExperimenter) ProtoMessage() {}
+func (*OfpQueuePropExperimenter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{75} }
+
+func (m *OfpQueuePropExperimenter) GetPropHeader() *OfpQueuePropHeader {
+ if m != nil {
+ return m.PropHeader
+ }
+ return nil
+}
+
+func (m *OfpQueuePropExperimenter) GetExperimenter() uint32 {
+ if m != nil {
+ return m.Experimenter
+ }
+ return 0
+}
+
+func (m *OfpQueuePropExperimenter) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+// Full description for a queue.
+type OfpPacketQueue struct {
+ QueueId uint32 `protobuf:"varint,1,opt,name=queue_id,json=queueId" json:"queue_id,omitempty"`
+ Port uint32 `protobuf:"varint,2,opt,name=port" json:"port,omitempty"`
+ Properties []*OfpQueuePropHeader `protobuf:"bytes,4,rep,name=properties" json:"properties,omitempty"`
+}
+
+func (m *OfpPacketQueue) Reset() { *m = OfpPacketQueue{} }
+func (m *OfpPacketQueue) String() string { return proto.CompactTextString(m) }
+func (*OfpPacketQueue) ProtoMessage() {}
+func (*OfpPacketQueue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{76} }
+
+func (m *OfpPacketQueue) GetQueueId() uint32 {
+ if m != nil {
+ return m.QueueId
+ }
+ return 0
+}
+
+func (m *OfpPacketQueue) GetPort() uint32 {
+ if m != nil {
+ return m.Port
+ }
+ return 0
+}
+
+func (m *OfpPacketQueue) GetProperties() []*OfpQueuePropHeader {
+ if m != nil {
+ return m.Properties
+ }
+ return nil
+}
+
+// Query for port queue configuration.
+type OfpQueueGetConfigRequest struct {
+ // ofp_header header;
+ Port uint32 `protobuf:"varint,1,opt,name=port" json:"port,omitempty"`
+}
+
+func (m *OfpQueueGetConfigRequest) Reset() { *m = OfpQueueGetConfigRequest{} }
+func (m *OfpQueueGetConfigRequest) String() string { return proto.CompactTextString(m) }
+func (*OfpQueueGetConfigRequest) ProtoMessage() {}
+func (*OfpQueueGetConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{77} }
+
+func (m *OfpQueueGetConfigRequest) GetPort() uint32 {
+ if m != nil {
+ return m.Port
+ }
+ return 0
+}
+
+// Queue configuration for a given port.
+type OfpQueueGetConfigReply struct {
+ // ofp_header header;
+ Port uint32 `protobuf:"varint,1,opt,name=port" json:"port,omitempty"`
+ Queues []*OfpPacketQueue `protobuf:"bytes,2,rep,name=queues" json:"queues,omitempty"`
+}
+
+func (m *OfpQueueGetConfigReply) Reset() { *m = OfpQueueGetConfigReply{} }
+func (m *OfpQueueGetConfigReply) String() string { return proto.CompactTextString(m) }
+func (*OfpQueueGetConfigReply) ProtoMessage() {}
+func (*OfpQueueGetConfigReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{78} }
+
+func (m *OfpQueueGetConfigReply) GetPort() uint32 {
+ if m != nil {
+ return m.Port
+ }
+ return 0
+}
+
+func (m *OfpQueueGetConfigReply) GetQueues() []*OfpPacketQueue {
+ if m != nil {
+ return m.Queues
+ }
+ return nil
+}
+
+// OFPAT_SET_QUEUE action struct: send packets to given queue on port.
+type OfpActionSetQueue struct {
+ Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+ QueueId uint32 `protobuf:"varint,3,opt,name=queue_id,json=queueId" json:"queue_id,omitempty"`
+}
+
+func (m *OfpActionSetQueue) Reset() { *m = OfpActionSetQueue{} }
+func (m *OfpActionSetQueue) String() string { return proto.CompactTextString(m) }
+func (*OfpActionSetQueue) ProtoMessage() {}
+func (*OfpActionSetQueue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{79} }
+
+func (m *OfpActionSetQueue) GetType() uint32 {
+ if m != nil {
+ return m.Type
+ }
+ return 0
+}
+
+func (m *OfpActionSetQueue) GetQueueId() uint32 {
+ if m != nil {
+ return m.QueueId
+ }
+ return 0
+}
+
+type OfpQueueStatsRequest struct {
+ PortNo uint32 `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+ QueueId uint32 `protobuf:"varint,2,opt,name=queue_id,json=queueId" json:"queue_id,omitempty"`
+}
+
+func (m *OfpQueueStatsRequest) Reset() { *m = OfpQueueStatsRequest{} }
+func (m *OfpQueueStatsRequest) String() string { return proto.CompactTextString(m) }
+func (*OfpQueueStatsRequest) ProtoMessage() {}
+func (*OfpQueueStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{80} }
+
+func (m *OfpQueueStatsRequest) GetPortNo() uint32 {
+ if m != nil {
+ return m.PortNo
+ }
+ return 0
+}
+
+func (m *OfpQueueStatsRequest) GetQueueId() uint32 {
+ if m != nil {
+ return m.QueueId
+ }
+ return 0
+}
+
+type OfpQueueStats struct {
+ PortNo uint32 `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+ QueueId uint32 `protobuf:"varint,2,opt,name=queue_id,json=queueId" json:"queue_id,omitempty"`
+ TxBytes uint64 `protobuf:"varint,3,opt,name=tx_bytes,json=txBytes" json:"tx_bytes,omitempty"`
+ TxPackets uint64 `protobuf:"varint,4,opt,name=tx_packets,json=txPackets" json:"tx_packets,omitempty"`
+ TxErrors uint64 `protobuf:"varint,5,opt,name=tx_errors,json=txErrors" json:"tx_errors,omitempty"`
+ DurationSec uint32 `protobuf:"varint,6,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+ DurationNsec uint32 `protobuf:"varint,7,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+}
+
+func (m *OfpQueueStats) Reset() { *m = OfpQueueStats{} }
+func (m *OfpQueueStats) String() string { return proto.CompactTextString(m) }
+func (*OfpQueueStats) ProtoMessage() {}
+func (*OfpQueueStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{81} }
+
+func (m *OfpQueueStats) GetPortNo() uint32 {
+ if m != nil {
+ return m.PortNo
+ }
+ return 0
+}
+
+func (m *OfpQueueStats) GetQueueId() uint32 {
+ if m != nil {
+ return m.QueueId
+ }
+ return 0
+}
+
+func (m *OfpQueueStats) GetTxBytes() uint64 {
+ if m != nil {
+ return m.TxBytes
+ }
+ return 0
+}
+
+func (m *OfpQueueStats) GetTxPackets() uint64 {
+ if m != nil {
+ return m.TxPackets
+ }
+ return 0
+}
+
+func (m *OfpQueueStats) GetTxErrors() uint64 {
+ if m != nil {
+ return m.TxErrors
+ }
+ return 0
+}
+
+func (m *OfpQueueStats) GetDurationSec() uint32 {
+ if m != nil {
+ return m.DurationSec
+ }
+ return 0
+}
+
+func (m *OfpQueueStats) GetDurationNsec() uint32 {
+ if m != nil {
+ return m.DurationNsec
+ }
+ return 0
+}
+
+// Role request and reply message.
+type OfpRoleRequest struct {
+ // ofp_header header; /* Type OFPT_ROLE_REQUEST/OFPT_ROLE_REPLY. */
+ Role OfpControllerRole `protobuf:"varint,1,opt,name=role,enum=openflow_13.OfpControllerRole" json:"role,omitempty"`
+ GenerationId uint64 `protobuf:"varint,2,opt,name=generation_id,json=generationId" json:"generation_id,omitempty"`
+}
+
+func (m *OfpRoleRequest) Reset() { *m = OfpRoleRequest{} }
+func (m *OfpRoleRequest) String() string { return proto.CompactTextString(m) }
+func (*OfpRoleRequest) ProtoMessage() {}
+func (*OfpRoleRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{82} }
+
+func (m *OfpRoleRequest) GetRole() OfpControllerRole {
+ if m != nil {
+ return m.Role
+ }
+ return OfpControllerRole_OFPCR_ROLE_NOCHANGE
+}
+
+func (m *OfpRoleRequest) GetGenerationId() uint64 {
+ if m != nil {
+ return m.GenerationId
+ }
+ return 0
+}
+
+// Asynchronous message configuration.
+type OfpAsyncConfig struct {
+ // ofp_header header; /* OFPT_GET_ASYNC_REPLY or OFPT_SET_ASYNC. */
+ PacketInMask []uint32 `protobuf:"varint,1,rep,packed,name=packet_in_mask,json=packetInMask" json:"packet_in_mask,omitempty"`
+ PortStatusMask []uint32 `protobuf:"varint,2,rep,packed,name=port_status_mask,json=portStatusMask" json:"port_status_mask,omitempty"`
+ FlowRemovedMask []uint32 `protobuf:"varint,3,rep,packed,name=flow_removed_mask,json=flowRemovedMask" json:"flow_removed_mask,omitempty"`
+}
+
+func (m *OfpAsyncConfig) Reset() { *m = OfpAsyncConfig{} }
+func (m *OfpAsyncConfig) String() string { return proto.CompactTextString(m) }
+func (*OfpAsyncConfig) ProtoMessage() {}
+func (*OfpAsyncConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{83} }
+
+func (m *OfpAsyncConfig) GetPacketInMask() []uint32 {
+ if m != nil {
+ return m.PacketInMask
+ }
+ return nil
+}
+
+func (m *OfpAsyncConfig) GetPortStatusMask() []uint32 {
+ if m != nil {
+ return m.PortStatusMask
+ }
+ return nil
+}
+
+func (m *OfpAsyncConfig) GetFlowRemovedMask() []uint32 {
+ if m != nil {
+ return m.FlowRemovedMask
+ }
+ return nil
+}
+
+type FlowTableUpdate struct {
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ FlowMod *OfpFlowMod `protobuf:"bytes,2,opt,name=flow_mod,json=flowMod" json:"flow_mod,omitempty"`
+}
+
+func (m *FlowTableUpdate) Reset() { *m = FlowTableUpdate{} }
+func (m *FlowTableUpdate) String() string { return proto.CompactTextString(m) }
+func (*FlowTableUpdate) ProtoMessage() {}
+func (*FlowTableUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{84} }
+
+func (m *FlowTableUpdate) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *FlowTableUpdate) GetFlowMod() *OfpFlowMod {
+ if m != nil {
+ return m.FlowMod
+ }
+ return nil
+}
+
+type FlowGroupTableUpdate struct {
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ GroupMod *OfpGroupMod `protobuf:"bytes,2,opt,name=group_mod,json=groupMod" json:"group_mod,omitempty"`
+}
+
+func (m *FlowGroupTableUpdate) Reset() { *m = FlowGroupTableUpdate{} }
+func (m *FlowGroupTableUpdate) String() string { return proto.CompactTextString(m) }
+func (*FlowGroupTableUpdate) ProtoMessage() {}
+func (*FlowGroupTableUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{85} }
+
+func (m *FlowGroupTableUpdate) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *FlowGroupTableUpdate) GetGroupMod() *OfpGroupMod {
+ if m != nil {
+ return m.GroupMod
+ }
+ return nil
+}
+
+type Flows struct {
+ Items []*OfpFlowStats `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *Flows) Reset() { *m = Flows{} }
+func (m *Flows) String() string { return proto.CompactTextString(m) }
+func (*Flows) ProtoMessage() {}
+func (*Flows) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{86} }
+
+func (m *Flows) GetItems() []*OfpFlowStats {
+ if m != nil {
+ return m.Items
+ }
+ return nil
+}
+
+type FlowGroups struct {
+ Items []*OfpGroupEntry `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *FlowGroups) Reset() { *m = FlowGroups{} }
+func (m *FlowGroups) String() string { return proto.CompactTextString(m) }
+func (*FlowGroups) ProtoMessage() {}
+func (*FlowGroups) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{87} }
+
+func (m *FlowGroups) GetItems() []*OfpGroupEntry {
+ if m != nil {
+ return m.Items
+ }
+ return nil
+}
+
+type PacketIn struct {
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ PacketIn *OfpPacketIn `protobuf:"bytes,2,opt,name=packet_in,json=packetIn" json:"packet_in,omitempty"`
+}
+
+func (m *PacketIn) Reset() { *m = PacketIn{} }
+func (m *PacketIn) String() string { return proto.CompactTextString(m) }
+func (*PacketIn) ProtoMessage() {}
+func (*PacketIn) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{88} }
+
+func (m *PacketIn) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *PacketIn) GetPacketIn() *OfpPacketIn {
+ if m != nil {
+ return m.PacketIn
+ }
+ return nil
+}
+
+type PacketOut struct {
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ PacketOut *OfpPacketOut `protobuf:"bytes,2,opt,name=packet_out,json=packetOut" json:"packet_out,omitempty"`
+}
+
+func (m *PacketOut) Reset() { *m = PacketOut{} }
+func (m *PacketOut) String() string { return proto.CompactTextString(m) }
+func (*PacketOut) ProtoMessage() {}
+func (*PacketOut) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{89} }
+
+func (m *PacketOut) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *PacketOut) GetPacketOut() *OfpPacketOut {
+ if m != nil {
+ return m.PacketOut
+ }
+ return nil
+}
+
+type ChangeEvent struct {
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ // Types that are valid to be assigned to Event:
+ // *ChangeEvent_PortStatus
+ Event isChangeEvent_Event `protobuf_oneof:"event"`
+}
+
+func (m *ChangeEvent) Reset() { *m = ChangeEvent{} }
+func (m *ChangeEvent) String() string { return proto.CompactTextString(m) }
+func (*ChangeEvent) ProtoMessage() {}
+func (*ChangeEvent) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{90} }
+
+type isChangeEvent_Event interface {
+ isChangeEvent_Event()
+}
+
+type ChangeEvent_PortStatus struct {
+ PortStatus *OfpPortStatus `protobuf:"bytes,2,opt,name=port_status,json=portStatus,oneof"`
+}
+
+func (*ChangeEvent_PortStatus) isChangeEvent_Event() {}
+
+func (m *ChangeEvent) GetEvent() isChangeEvent_Event {
+ if m != nil {
+ return m.Event
+ }
+ return nil
+}
+
+func (m *ChangeEvent) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *ChangeEvent) GetPortStatus() *OfpPortStatus {
+ if x, ok := m.GetEvent().(*ChangeEvent_PortStatus); ok {
+ return x.PortStatus
+ }
+ return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*ChangeEvent) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _ChangeEvent_OneofMarshaler, _ChangeEvent_OneofUnmarshaler, _ChangeEvent_OneofSizer, []interface{}{
+ (*ChangeEvent_PortStatus)(nil),
+ }
+}
+
+func _ChangeEvent_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*ChangeEvent)
+ // event
+ switch x := m.Event.(type) {
+ case *ChangeEvent_PortStatus:
+ b.EncodeVarint(2<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.PortStatus); err != nil {
+ return err
+ }
+ case nil:
+ default:
+ return fmt.Errorf("ChangeEvent.Event has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _ChangeEvent_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*ChangeEvent)
+ switch tag {
+ case 2: // event.port_status
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(OfpPortStatus)
+ err := b.DecodeMessage(msg)
+ m.Event = &ChangeEvent_PortStatus{msg}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _ChangeEvent_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*ChangeEvent)
+ // event
+ switch x := m.Event.(type) {
+ case *ChangeEvent_PortStatus:
+ s := proto.Size(x.PortStatus)
+ n += proto.SizeVarint(2<<3 | proto.WireBytes)
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+func init() {
+ proto.RegisterType((*OfpHeader)(nil), "openflow_13.ofp_header")
+ proto.RegisterType((*OfpHelloElemHeader)(nil), "openflow_13.ofp_hello_elem_header")
+ proto.RegisterType((*OfpHelloElemVersionbitmap)(nil), "openflow_13.ofp_hello_elem_versionbitmap")
+ proto.RegisterType((*OfpHello)(nil), "openflow_13.ofp_hello")
+ proto.RegisterType((*OfpSwitchConfig)(nil), "openflow_13.ofp_switch_config")
+ proto.RegisterType((*OfpTableMod)(nil), "openflow_13.ofp_table_mod")
+ proto.RegisterType((*OfpPort)(nil), "openflow_13.ofp_port")
+ proto.RegisterType((*OfpSwitchFeatures)(nil), "openflow_13.ofp_switch_features")
+ proto.RegisterType((*OfpPortStatus)(nil), "openflow_13.ofp_port_status")
+ proto.RegisterType((*OfpPortMod)(nil), "openflow_13.ofp_port_mod")
+ proto.RegisterType((*OfpMatch)(nil), "openflow_13.ofp_match")
+ proto.RegisterType((*OfpOxmField)(nil), "openflow_13.ofp_oxm_field")
+ proto.RegisterType((*OfpOxmOfbField)(nil), "openflow_13.ofp_oxm_ofb_field")
+ proto.RegisterType((*OfpOxmExperimenterField)(nil), "openflow_13.ofp_oxm_experimenter_field")
+ proto.RegisterType((*OfpAction)(nil), "openflow_13.ofp_action")
+ proto.RegisterType((*OfpActionOutput)(nil), "openflow_13.ofp_action_output")
+ proto.RegisterType((*OfpActionMplsTtl)(nil), "openflow_13.ofp_action_mpls_ttl")
+ proto.RegisterType((*OfpActionPush)(nil), "openflow_13.ofp_action_push")
+ proto.RegisterType((*OfpActionPopMpls)(nil), "openflow_13.ofp_action_pop_mpls")
+ proto.RegisterType((*OfpActionGroup)(nil), "openflow_13.ofp_action_group")
+ proto.RegisterType((*OfpActionNwTtl)(nil), "openflow_13.ofp_action_nw_ttl")
+ proto.RegisterType((*OfpActionSetField)(nil), "openflow_13.ofp_action_set_field")
+ proto.RegisterType((*OfpActionExperimenter)(nil), "openflow_13.ofp_action_experimenter")
+ proto.RegisterType((*OfpInstruction)(nil), "openflow_13.ofp_instruction")
+ proto.RegisterType((*OfpInstructionGotoTable)(nil), "openflow_13.ofp_instruction_goto_table")
+ proto.RegisterType((*OfpInstructionWriteMetadata)(nil), "openflow_13.ofp_instruction_write_metadata")
+ proto.RegisterType((*OfpInstructionActions)(nil), "openflow_13.ofp_instruction_actions")
+ proto.RegisterType((*OfpInstructionMeter)(nil), "openflow_13.ofp_instruction_meter")
+ proto.RegisterType((*OfpInstructionExperimenter)(nil), "openflow_13.ofp_instruction_experimenter")
+ proto.RegisterType((*OfpFlowMod)(nil), "openflow_13.ofp_flow_mod")
+ proto.RegisterType((*OfpBucket)(nil), "openflow_13.ofp_bucket")
+ proto.RegisterType((*OfpGroupMod)(nil), "openflow_13.ofp_group_mod")
+ proto.RegisterType((*OfpPacketOut)(nil), "openflow_13.ofp_packet_out")
+ proto.RegisterType((*OfpPacketIn)(nil), "openflow_13.ofp_packet_in")
+ proto.RegisterType((*OfpFlowRemoved)(nil), "openflow_13.ofp_flow_removed")
+ proto.RegisterType((*OfpMeterBandHeader)(nil), "openflow_13.ofp_meter_band_header")
+ proto.RegisterType((*OfpMeterBandDrop)(nil), "openflow_13.ofp_meter_band_drop")
+ proto.RegisterType((*OfpMeterBandDscpRemark)(nil), "openflow_13.ofp_meter_band_dscp_remark")
+ proto.RegisterType((*OfpMeterBandExperimenter)(nil), "openflow_13.ofp_meter_band_experimenter")
+ proto.RegisterType((*OfpMeterMod)(nil), "openflow_13.ofp_meter_mod")
+ proto.RegisterType((*OfpErrorMsg)(nil), "openflow_13.ofp_error_msg")
+ proto.RegisterType((*OfpErrorExperimenterMsg)(nil), "openflow_13.ofp_error_experimenter_msg")
+ proto.RegisterType((*OfpMultipartRequest)(nil), "openflow_13.ofp_multipart_request")
+ proto.RegisterType((*OfpMultipartReply)(nil), "openflow_13.ofp_multipart_reply")
+ proto.RegisterType((*OfpDesc)(nil), "openflow_13.ofp_desc")
+ proto.RegisterType((*OfpFlowStatsRequest)(nil), "openflow_13.ofp_flow_stats_request")
+ proto.RegisterType((*OfpFlowStats)(nil), "openflow_13.ofp_flow_stats")
+ proto.RegisterType((*OfpAggregateStatsRequest)(nil), "openflow_13.ofp_aggregate_stats_request")
+ proto.RegisterType((*OfpAggregateStatsReply)(nil), "openflow_13.ofp_aggregate_stats_reply")
+ proto.RegisterType((*OfpTableFeatureProperty)(nil), "openflow_13.ofp_table_feature_property")
+ proto.RegisterType((*OfpTableFeaturePropInstructions)(nil), "openflow_13.ofp_table_feature_prop_instructions")
+ proto.RegisterType((*OfpTableFeaturePropNextTables)(nil), "openflow_13.ofp_table_feature_prop_next_tables")
+ proto.RegisterType((*OfpTableFeaturePropActions)(nil), "openflow_13.ofp_table_feature_prop_actions")
+ proto.RegisterType((*OfpTableFeaturePropOxm)(nil), "openflow_13.ofp_table_feature_prop_oxm")
+ proto.RegisterType((*OfpTableFeaturePropExperimenter)(nil), "openflow_13.ofp_table_feature_prop_experimenter")
+ proto.RegisterType((*OfpTableFeatures)(nil), "openflow_13.ofp_table_features")
+ proto.RegisterType((*OfpTableStats)(nil), "openflow_13.ofp_table_stats")
+ proto.RegisterType((*OfpPortStatsRequest)(nil), "openflow_13.ofp_port_stats_request")
+ proto.RegisterType((*OfpPortStats)(nil), "openflow_13.ofp_port_stats")
+ proto.RegisterType((*OfpGroupStatsRequest)(nil), "openflow_13.ofp_group_stats_request")
+ proto.RegisterType((*OfpBucketCounter)(nil), "openflow_13.ofp_bucket_counter")
+ proto.RegisterType((*OfpGroupStats)(nil), "openflow_13.ofp_group_stats")
+ proto.RegisterType((*OfpGroupDesc)(nil), "openflow_13.ofp_group_desc")
+ proto.RegisterType((*OfpGroupEntry)(nil), "openflow_13.ofp_group_entry")
+ proto.RegisterType((*OfpGroupFeatures)(nil), "openflow_13.ofp_group_features")
+ proto.RegisterType((*OfpMeterMultipartRequest)(nil), "openflow_13.ofp_meter_multipart_request")
+ proto.RegisterType((*OfpMeterBandStats)(nil), "openflow_13.ofp_meter_band_stats")
+ proto.RegisterType((*OfpMeterStats)(nil), "openflow_13.ofp_meter_stats")
+ proto.RegisterType((*OfpMeterConfig)(nil), "openflow_13.ofp_meter_config")
+ proto.RegisterType((*OfpMeterFeatures)(nil), "openflow_13.ofp_meter_features")
+ proto.RegisterType((*OfpExperimenterMultipartHeader)(nil), "openflow_13.ofp_experimenter_multipart_header")
+ proto.RegisterType((*OfpExperimenterHeader)(nil), "openflow_13.ofp_experimenter_header")
+ proto.RegisterType((*OfpQueuePropHeader)(nil), "openflow_13.ofp_queue_prop_header")
+ proto.RegisterType((*OfpQueuePropMinRate)(nil), "openflow_13.ofp_queue_prop_min_rate")
+ proto.RegisterType((*OfpQueuePropMaxRate)(nil), "openflow_13.ofp_queue_prop_max_rate")
+ proto.RegisterType((*OfpQueuePropExperimenter)(nil), "openflow_13.ofp_queue_prop_experimenter")
+ proto.RegisterType((*OfpPacketQueue)(nil), "openflow_13.ofp_packet_queue")
+ proto.RegisterType((*OfpQueueGetConfigRequest)(nil), "openflow_13.ofp_queue_get_config_request")
+ proto.RegisterType((*OfpQueueGetConfigReply)(nil), "openflow_13.ofp_queue_get_config_reply")
+ proto.RegisterType((*OfpActionSetQueue)(nil), "openflow_13.ofp_action_set_queue")
+ proto.RegisterType((*OfpQueueStatsRequest)(nil), "openflow_13.ofp_queue_stats_request")
+ proto.RegisterType((*OfpQueueStats)(nil), "openflow_13.ofp_queue_stats")
+ proto.RegisterType((*OfpRoleRequest)(nil), "openflow_13.ofp_role_request")
+ proto.RegisterType((*OfpAsyncConfig)(nil), "openflow_13.ofp_async_config")
+ proto.RegisterType((*FlowTableUpdate)(nil), "openflow_13.FlowTableUpdate")
+ proto.RegisterType((*FlowGroupTableUpdate)(nil), "openflow_13.FlowGroupTableUpdate")
+ proto.RegisterType((*Flows)(nil), "openflow_13.Flows")
+ proto.RegisterType((*FlowGroups)(nil), "openflow_13.FlowGroups")
+ proto.RegisterType((*PacketIn)(nil), "openflow_13.PacketIn")
+ proto.RegisterType((*PacketOut)(nil), "openflow_13.PacketOut")
+ proto.RegisterType((*ChangeEvent)(nil), "openflow_13.ChangeEvent")
+ proto.RegisterEnum("openflow_13.OfpPortNo", OfpPortNo_name, OfpPortNo_value)
+ proto.RegisterEnum("openflow_13.OfpType", OfpType_name, OfpType_value)
+ proto.RegisterEnum("openflow_13.OfpHelloElemType", OfpHelloElemType_name, OfpHelloElemType_value)
+ proto.RegisterEnum("openflow_13.OfpConfigFlags", OfpConfigFlags_name, OfpConfigFlags_value)
+ proto.RegisterEnum("openflow_13.OfpTableConfig", OfpTableConfig_name, OfpTableConfig_value)
+ proto.RegisterEnum("openflow_13.OfpTable", OfpTable_name, OfpTable_value)
+ proto.RegisterEnum("openflow_13.OfpCapabilities", OfpCapabilities_name, OfpCapabilities_value)
+ proto.RegisterEnum("openflow_13.OfpPortConfig", OfpPortConfig_name, OfpPortConfig_value)
+ proto.RegisterEnum("openflow_13.OfpPortState", OfpPortState_name, OfpPortState_value)
+ proto.RegisterEnum("openflow_13.OfpPortFeatures", OfpPortFeatures_name, OfpPortFeatures_value)
+ proto.RegisterEnum("openflow_13.OfpPortReason", OfpPortReason_name, OfpPortReason_value)
+ proto.RegisterEnum("openflow_13.OfpMatchType", OfpMatchType_name, OfpMatchType_value)
+ proto.RegisterEnum("openflow_13.OfpOxmClass", OfpOxmClass_name, OfpOxmClass_value)
+ proto.RegisterEnum("openflow_13.OxmOfbFieldTypes", OxmOfbFieldTypes_name, OxmOfbFieldTypes_value)
+ proto.RegisterEnum("openflow_13.OfpVlanId", OfpVlanId_name, OfpVlanId_value)
+ proto.RegisterEnum("openflow_13.OfpIpv6ExthdrFlags", OfpIpv6ExthdrFlags_name, OfpIpv6ExthdrFlags_value)
+ proto.RegisterEnum("openflow_13.OfpActionType", OfpActionType_name, OfpActionType_value)
+ proto.RegisterEnum("openflow_13.OfpControllerMaxLen", OfpControllerMaxLen_name, OfpControllerMaxLen_value)
+ proto.RegisterEnum("openflow_13.OfpInstructionType", OfpInstructionType_name, OfpInstructionType_value)
+ proto.RegisterEnum("openflow_13.OfpFlowModCommand", OfpFlowModCommand_name, OfpFlowModCommand_value)
+ proto.RegisterEnum("openflow_13.OfpFlowModFlags", OfpFlowModFlags_name, OfpFlowModFlags_value)
+ proto.RegisterEnum("openflow_13.OfpGroup", OfpGroup_name, OfpGroup_value)
+ proto.RegisterEnum("openflow_13.OfpGroupModCommand", OfpGroupModCommand_name, OfpGroupModCommand_value)
+ proto.RegisterEnum("openflow_13.OfpGroupType", OfpGroupType_name, OfpGroupType_value)
+ proto.RegisterEnum("openflow_13.OfpPacketInReason", OfpPacketInReason_name, OfpPacketInReason_value)
+ proto.RegisterEnum("openflow_13.OfpFlowRemovedReason", OfpFlowRemovedReason_name, OfpFlowRemovedReason_value)
+ proto.RegisterEnum("openflow_13.OfpMeter", OfpMeter_name, OfpMeter_value)
+ proto.RegisterEnum("openflow_13.OfpMeterBandType", OfpMeterBandType_name, OfpMeterBandType_value)
+ proto.RegisterEnum("openflow_13.OfpMeterModCommand", OfpMeterModCommand_name, OfpMeterModCommand_value)
+ proto.RegisterEnum("openflow_13.OfpMeterFlags", OfpMeterFlags_name, OfpMeterFlags_value)
+ proto.RegisterEnum("openflow_13.OfpErrorType", OfpErrorType_name, OfpErrorType_value)
+ proto.RegisterEnum("openflow_13.OfpHelloFailedCode", OfpHelloFailedCode_name, OfpHelloFailedCode_value)
+ proto.RegisterEnum("openflow_13.OfpBadRequestCode", OfpBadRequestCode_name, OfpBadRequestCode_value)
+ proto.RegisterEnum("openflow_13.OfpBadActionCode", OfpBadActionCode_name, OfpBadActionCode_value)
+ proto.RegisterEnum("openflow_13.OfpBadInstructionCode", OfpBadInstructionCode_name, OfpBadInstructionCode_value)
+ proto.RegisterEnum("openflow_13.OfpBadMatchCode", OfpBadMatchCode_name, OfpBadMatchCode_value)
+ proto.RegisterEnum("openflow_13.OfpFlowModFailedCode", OfpFlowModFailedCode_name, OfpFlowModFailedCode_value)
+ proto.RegisterEnum("openflow_13.OfpGroupModFailedCode", OfpGroupModFailedCode_name, OfpGroupModFailedCode_value)
+ proto.RegisterEnum("openflow_13.OfpPortModFailedCode", OfpPortModFailedCode_name, OfpPortModFailedCode_value)
+ proto.RegisterEnum("openflow_13.OfpTableModFailedCode", OfpTableModFailedCode_name, OfpTableModFailedCode_value)
+ proto.RegisterEnum("openflow_13.OfpQueueOpFailedCode", OfpQueueOpFailedCode_name, OfpQueueOpFailedCode_value)
+ proto.RegisterEnum("openflow_13.OfpSwitchConfigFailedCode", OfpSwitchConfigFailedCode_name, OfpSwitchConfigFailedCode_value)
+ proto.RegisterEnum("openflow_13.OfpRoleRequestFailedCode", OfpRoleRequestFailedCode_name, OfpRoleRequestFailedCode_value)
+ proto.RegisterEnum("openflow_13.OfpMeterModFailedCode", OfpMeterModFailedCode_name, OfpMeterModFailedCode_value)
+ proto.RegisterEnum("openflow_13.OfpTableFeaturesFailedCode", OfpTableFeaturesFailedCode_name, OfpTableFeaturesFailedCode_value)
+ proto.RegisterEnum("openflow_13.OfpMultipartType", OfpMultipartType_name, OfpMultipartType_value)
+ proto.RegisterEnum("openflow_13.OfpMultipartRequestFlags", OfpMultipartRequestFlags_name, OfpMultipartRequestFlags_value)
+ proto.RegisterEnum("openflow_13.OfpMultipartReplyFlags", OfpMultipartReplyFlags_name, OfpMultipartReplyFlags_value)
+ proto.RegisterEnum("openflow_13.OfpTableFeaturePropType", OfpTableFeaturePropType_name, OfpTableFeaturePropType_value)
+ proto.RegisterEnum("openflow_13.OfpGroupCapabilities", OfpGroupCapabilities_name, OfpGroupCapabilities_value)
+ proto.RegisterEnum("openflow_13.OfpQueueProperties", OfpQueueProperties_name, OfpQueueProperties_value)
+ proto.RegisterEnum("openflow_13.OfpControllerRole", OfpControllerRole_name, OfpControllerRole_value)
+}
+
+func init() { proto.RegisterFile("openflow_13.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 8209 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x7c, 0x5b, 0x8c, 0x1b, 0x4b,
+ 0x76, 0x98, 0xf8, 0x98, 0x21, 0x59, 0x9c, 0x19, 0xb5, 0x5a, 0x2f, 0x4a, 0x23, 0x5d, 0x49, 0x5c,
+ 0xdd, 0xdd, 0xbb, 0x5c, 0xdb, 0xf7, 0x5e, 0x5d, 0xad, 0x76, 0xbd, 0x7e, 0x44, 0x4d, 0xb2, 0x39,
+ 0xe4, 0x8a, 0x8f, 0x56, 0x77, 0xcf, 0x48, 0x72, 0xe0, 0x34, 0x38, 0x64, 0x6b, 0x86, 0xbe, 0x7c,
+ 0x6d, 0x77, 0xcf, 0x68, 0xe4, 0xc4, 0x81, 0x62, 0x23, 0x08, 0x90, 0xc4, 0x76, 0x12, 0x07, 0x58,
+ 0x20, 0x70, 0x80, 0x18, 0x71, 0x3e, 0x82, 0x00, 0xf9, 0x08, 0x10, 0x20, 0x40, 0xf2, 0x99, 0x00,
+ 0x09, 0x90, 0x07, 0x60, 0x20, 0xf0, 0x4f, 0xfc, 0xe7, 0xfc, 0x04, 0xf0, 0x77, 0x12, 0x67, 0xb3,
+ 0x0a, 0x4e, 0x9d, 0x53, 0xd5, 0xd5, 0x7c, 0xcc, 0x9d, 0xdd, 0xdc, 0x4d, 0x00, 0x7f, 0x0d, 0xfb,
+ 0x9c, 0x53, 0xa7, 0xaa, 0x4e, 0x9d, 0x77, 0x57, 0x0f, 0xbb, 0x32, 0x9b, 0xfb, 0xd3, 0xd7, 0xe3,
+ 0xd9, 0x1b, 0xef, 0xd3, 0xcf, 0x7e, 0x66, 0x1e, 0xcc, 0xa2, 0x99, 0x5e, 0x54, 0x40, 0xb7, 0xef,
+ 0x1c, 0xcd, 0x66, 0x47, 0x63, 0xff, 0xe3, 0xfe, 0x7c, 0xf4, 0x71, 0x7f, 0x3a, 0x9d, 0x45, 0xfd,
+ 0x68, 0x34, 0x9b, 0x86, 0x48, 0x7a, 0x5b, 0x7f, 0xdb, 0x9f, 0x1e, 0x79, 0xb3, 0xb9, 0x02, 0x2b,
+ 0x0f, 0x18, 0x9b, 0xbd, 0x9e, 0x7b, 0xc7, 0x7e, 0x7f, 0xe8, 0x07, 0x7a, 0x89, 0xe5, 0x4e, 0xfd,
+ 0x20, 0x1c, 0xcd, 0xa6, 0xa5, 0xd4, 0xfd, 0xd4, 0x47, 0xdb, 0xb6, 0x78, 0xd4, 0xbf, 0xce, 0xb2,
+ 0xd1, 0xdb, 0xb9, 0x5f, 0x4a, 0xdf, 0x4f, 0x7d, 0xb4, 0xf3, 0xe8, 0xfa, 0xcf, 0xa8, 0x0b, 0x01,
+ 0x06, 0x80, 0xb4, 0x39, 0x89, 0xae, 0xb1, 0xcc, 0xd9, 0x68, 0x58, 0xca, 0x70, 0x06, 0xf0, 0xb3,
+ 0xfc, 0x4f, 0x52, 0xec, 0x3a, 0xce, 0x32, 0x1e, 0xcf, 0x3c, 0x7f, 0xec, 0x4f, 0xc4, 0x84, 0x8f,
+ 0x89, 0x6d, 0x8a, 0xb3, 0xbd, 0xbf, 0xc4, 0x56, 0x19, 0xa1, 0xcc, 0xf0, 0x9c, 0x6d, 0xd3, 0xba,
+ 0x0e, 0x47, 0xd1, 0xa4, 0x3f, 0xe7, 0xab, 0x2a, 0x3e, 0xfa, 0xfa, 0x79, 0xc3, 0x13, 0x03, 0x9a,
+ 0x97, 0xec, 0x24, 0x87, 0x6a, 0x81, 0xe5, 0x80, 0xcc, 0x9f, 0x46, 0xe5, 0x6f, 0xb3, 0x3b, 0xe7,
+ 0x8d, 0x05, 0x21, 0xe1, 0xaf, 0xb0, 0x94, 0xbe, 0x9f, 0x01, 0x21, 0xd1, 0x63, 0xf9, 0x19, 0x2b,
+ 0xc8, 0x91, 0xfa, 0x2f, 0xb2, 0x3c, 0x71, 0x0c, 0x4b, 0xa9, 0xfb, 0x99, 0x8f, 0x8a, 0x8f, 0xca,
+ 0xe7, 0xad, 0x0f, 0x05, 0x62, 0xcb, 0x31, 0xe5, 0x0e, 0xbb, 0x02, 0x24, 0xe1, 0x9b, 0x51, 0x34,
+ 0x38, 0xf6, 0x06, 0xb3, 0xe9, 0xeb, 0xd1, 0x91, 0x7e, 0x8d, 0x6d, 0xbc, 0x1e, 0xf7, 0x8f, 0x42,
+ 0x3a, 0x1e, 0x7c, 0xd0, 0xcb, 0x6c, 0x7b, 0x32, 0x0a, 0x43, 0x2f, 0xf4, 0xa7, 0x43, 0x6f, 0xec,
+ 0x4f, 0xb9, 0x3c, 0xb6, 0xed, 0x22, 0x00, 0x1d, 0x7f, 0x3a, 0x6c, 0xfb, 0xd3, 0x72, 0x95, 0x6d,
+ 0xf3, 0x73, 0xea, 0x1f, 0x8e, 0x7d, 0x6f, 0x32, 0x1b, 0xea, 0xb7, 0x58, 0x1e, 0x1f, 0x46, 0x43,
+ 0x71, 0xd8, 0xfc, 0xb9, 0x35, 0xd4, 0x6f, 0xb0, 0x4d, 0x9c, 0x8f, 0x18, 0xd1, 0x53, 0xf9, 0x1f,
+ 0xa4, 0x59, 0x1e, 0x98, 0xcc, 0x67, 0x41, 0xa4, 0xdf, 0x64, 0x39, 0xf8, 0xeb, 0x4d, 0x67, 0x34,
+ 0x7c, 0x13, 0x1e, 0xbb, 0x33, 0x40, 0x1c, 0xbf, 0xf1, 0xfa, 0xc3, 0x61, 0x40, 0xf2, 0xd9, 0x3c,
+ 0x7e, 0x63, 0x0c, 0x87, 0x81, 0xae, 0xb3, 0xec, 0xb4, 0x3f, 0xf1, 0xb9, 0x66, 0x14, 0x6c, 0xfe,
+ 0x5b, 0x99, 0x2a, 0xab, 0x4e, 0x05, 0x1b, 0x0d, 0xa3, 0x7e, 0xe4, 0x97, 0x36, 0x70, 0xa3, 0xfc,
+ 0x01, 0x38, 0x0c, 0x4e, 0x82, 0xa0, 0xb4, 0xc9, 0x81, 0xfc, 0xb7, 0xfe, 0x01, 0x63, 0xfd, 0xe1,
+ 0xa9, 0x1f, 0x44, 0xa3, 0xd0, 0x1f, 0x96, 0x72, 0x1c, 0xa3, 0x40, 0xf4, 0x3b, 0xac, 0x10, 0x9e,
+ 0xcc, 0x61, 0x6d, 0xfe, 0xb0, 0x94, 0xe7, 0xe8, 0x18, 0x00, 0x1c, 0xe7, 0xbe, 0x1f, 0x94, 0x0a,
+ 0xc8, 0x11, 0x7e, 0xeb, 0x77, 0x19, 0x03, 0xce, 0x5e, 0x38, 0xf7, 0xfd, 0x61, 0x89, 0xe1, 0x10,
+ 0x80, 0x38, 0x00, 0xd0, 0x77, 0x59, 0x61, 0xd2, 0x3f, 0x23, 0x6c, 0x91, 0x63, 0xf3, 0x93, 0xfe,
+ 0x19, 0x47, 0x96, 0xff, 0x79, 0x8a, 0x5d, 0x55, 0x8e, 0xed, 0xb5, 0xdf, 0x8f, 0x4e, 0x02, 0x3f,
+ 0xd4, 0xef, 0xb1, 0xe2, 0xb0, 0x1f, 0xf5, 0xe7, 0xfd, 0xe8, 0x58, 0x08, 0x3c, 0x6b, 0x33, 0x01,
+ 0x6a, 0x71, 0xae, 0x53, 0xef, 0xf0, 0xe4, 0xf5, 0x6b, 0x3f, 0x08, 0x49, 0xec, 0xf9, 0x69, 0x15,
+ 0x9f, 0xe1, 0xac, 0xa6, 0x78, 0x74, 0x21, 0xd9, 0x55, 0x6e, 0xea, 0xf2, 0x47, 0xfd, 0x01, 0xdb,
+ 0xea, 0x9f, 0x9c, 0x8d, 0xc6, 0xa3, 0x7e, 0xf0, 0x16, 0x38, 0xa3, 0x18, 0x8b, 0x12, 0xd6, 0x1a,
+ 0xea, 0x65, 0xb6, 0x35, 0xe8, 0xcf, 0xfb, 0x87, 0xa3, 0xf1, 0x28, 0x1a, 0xf9, 0x21, 0x89, 0x34,
+ 0x01, 0x2b, 0x07, 0xec, 0xb2, 0x38, 0x59, 0x0f, 0x64, 0x7d, 0x12, 0xea, 0x8f, 0xd9, 0x66, 0xe0,
+ 0xf7, 0x43, 0xf2, 0x05, 0x3b, 0x8f, 0xee, 0x2c, 0xa9, 0x2f, 0xa7, 0x46, 0x1a, 0x9b, 0x68, 0xc1,
+ 0x51, 0x0c, 0xfd, 0x70, 0x40, 0x26, 0x79, 0x7d, 0xe5, 0x18, 0x9b, 0x93, 0x94, 0xff, 0x7a, 0x8a,
+ 0x6d, 0x49, 0x36, 0xa0, 0x92, 0x3f, 0xba, 0x4a, 0xc5, 0xea, 0x93, 0x49, 0xa8, 0x8f, 0xce, 0xb2,
+ 0x93, 0x7e, 0xf8, 0x39, 0x49, 0x83, 0xff, 0x06, 0x45, 0x90, 0x6a, 0x41, 0x32, 0x88, 0x01, 0xe5,
+ 0x37, 0x68, 0xbb, 0x93, 0x7e, 0x34, 0x38, 0xd6, 0x3f, 0x4e, 0xb8, 0xa5, 0xdd, 0xa5, 0x4d, 0x70,
+ 0x2a, 0xd5, 0x23, 0xfd, 0x2c, 0x63, 0xb3, 0xb3, 0x89, 0xf7, 0x7a, 0xe4, 0x8f, 0x87, 0xe8, 0x16,
+ 0x8a, 0x8f, 0x6e, 0x2f, 0x0d, 0x93, 0x24, 0x76, 0x61, 0x76, 0x36, 0x69, 0x70, 0xe2, 0xf2, 0x7f,
+ 0x4b, 0xa1, 0x65, 0x4a, 0xa4, 0xfe, 0x2d, 0x06, 0x68, 0x6f, 0x30, 0xee, 0x87, 0x21, 0x2d, 0x61,
+ 0x35, 0x2f, 0x4e, 0x61, 0xe7, 0x67, 0x67, 0x93, 0x1a, 0xfc, 0xd2, 0x7f, 0x01, 0xf6, 0x70, 0x88,
+ 0x5c, 0xf8, 0xd6, 0x8b, 0x8f, 0x3e, 0x58, 0x39, 0x50, 0x52, 0x35, 0x2f, 0xd9, 0xf9, 0xd9, 0xeb,
+ 0x43, 0xbe, 0x14, 0xfd, 0x25, 0xd3, 0xfd, 0xb3, 0xb9, 0x1f, 0x8c, 0xc0, 0x01, 0xf9, 0x01, 0xf1,
+ 0xd9, 0xe0, 0x7c, 0xbe, 0xb6, 0x92, 0xcf, 0x32, 0x79, 0xf3, 0x92, 0x7d, 0x45, 0x85, 0x72, 0xce,
+ 0xd5, 0x1c, 0xdb, 0xe0, 0xd8, 0xf2, 0x1f, 0xee, 0xa0, 0x57, 0x4b, 0x2c, 0xe2, 0xfc, 0x28, 0xa0,
+ 0x52, 0x72, 0x91, 0x87, 0x24, 0xf3, 0x5b, 0x2c, 0x7f, 0xdc, 0x0f, 0x3d, 0x7e, 0xce, 0xa0, 0x6d,
+ 0x79, 0x3b, 0x77, 0xdc, 0x0f, 0x3b, 0x70, 0xd4, 0xd7, 0x58, 0x16, 0x34, 0x07, 0x95, 0xa2, 0x79,
+ 0xc9, 0xe6, 0x4f, 0xfa, 0x87, 0x6c, 0x7b, 0x7e, 0xfc, 0x36, 0x1c, 0x0d, 0xfa, 0x63, 0xae, 0x73,
+ 0xa8, 0x1d, 0xcd, 0x4b, 0xf6, 0x96, 0x00, 0x5b, 0x40, 0xf6, 0x35, 0xb6, 0x43, 0x5e, 0xd2, 0x8f,
+ 0xfa, 0x60, 0xa1, 0x5c, 0x04, 0x59, 0x88, 0x19, 0x1c, 0xde, 0x21, 0xb0, 0x7e, 0x8b, 0xe5, 0xfc,
+ 0xe8, 0xd8, 0x1b, 0x86, 0x11, 0x77, 0x48, 0x5b, 0xcd, 0x4b, 0xf6, 0xa6, 0x1f, 0x1d, 0xd7, 0xc3,
+ 0x48, 0xa0, 0xc2, 0x60, 0xc0, 0x3d, 0x92, 0x40, 0x39, 0xc1, 0x40, 0xdf, 0x65, 0x79, 0x40, 0xf1,
+ 0x0d, 0xe7, 0x69, 0x01, 0x40, 0xec, 0xc2, 0x9e, 0x76, 0x59, 0xfe, 0x74, 0xdc, 0x9f, 0x7a, 0xa7,
+ 0xa3, 0x21, 0xba, 0x24, 0x40, 0x02, 0xe4, 0x60, 0x34, 0x94, 0xc8, 0xf9, 0x60, 0x8e, 0x5e, 0x49,
+ 0x20, 0xad, 0xc1, 0x1c, 0x66, 0x1c, 0xcd, 0xbd, 0x61, 0x38, 0x98, 0xa3, 0x4f, 0x82, 0x19, 0x47,
+ 0xf3, 0x7a, 0x38, 0x98, 0xeb, 0x37, 0xd9, 0xe6, 0x68, 0xee, 0xf9, 0x83, 0x69, 0x69, 0x8b, 0x30,
+ 0x1b, 0xa3, 0xb9, 0x39, 0x98, 0x02, 0xc3, 0xd1, 0xdc, 0xe3, 0x89, 0x40, 0x69, 0x5b, 0x30, 0x1c,
+ 0xcd, 0x2d, 0x9e, 0x58, 0x70, 0xe4, 0xe9, 0x63, 0xbe, 0x87, 0x9d, 0x18, 0x79, 0xfa, 0x98, 0x36,
+ 0xc1, 0x91, 0xb0, 0xf7, 0xcb, 0x2a, 0x92, 0x36, 0x1f, 0x0d, 0xe6, 0x7c, 0xa0, 0x26, 0x96, 0x12,
+ 0x0d, 0xe6, 0x30, 0x8e, 0x50, 0x30, 0xec, 0x8a, 0x82, 0xa2, 0x51, 0x27, 0x43, 0x1c, 0xa5, 0x0b,
+ 0xd4, 0xc9, 0x50, 0x8c, 0x02, 0x14, 0x8c, 0xba, 0xaa, 0xa0, 0x60, 0xd4, 0x2e, 0xcb, 0x87, 0x83,
+ 0x08, 0x87, 0x5d, 0x13, 0x0b, 0x01, 0x08, 0xad, 0x92, 0x23, 0x61, 0xe0, 0x75, 0x15, 0x09, 0x23,
+ 0x1f, 0xb0, 0xe2, 0x68, 0x30, 0x81, 0x4d, 0xf0, 0xa3, 0xb8, 0x41, 0x78, 0x86, 0x40, 0x7e, 0x1a,
+ 0x31, 0xc9, 0x60, 0x36, 0xf4, 0x4b, 0x37, 0x93, 0x24, 0xb5, 0xd9, 0xd0, 0x07, 0xd9, 0xf6, 0x83,
+ 0xb9, 0x37, 0x9b, 0x97, 0x4a, 0x42, 0xb6, 0xfd, 0x60, 0xde, 0xe3, 0xe7, 0x01, 0x88, 0x70, 0xde,
+ 0x2f, 0xdd, 0x12, 0x6b, 0xee, 0x07, 0x73, 0x67, 0xde, 0x17, 0xa8, 0x68, 0xde, 0x2f, 0xdd, 0x56,
+ 0x50, 0x6e, 0x8c, 0x0a, 0x8f, 0xfb, 0xa5, 0x5d, 0xa1, 0x37, 0x30, 0xea, 0x38, 0x1e, 0x75, 0xdc,
+ 0x2f, 0xdd, 0x51, 0x50, 0xee, 0x71, 0x9f, 0x4e, 0xe3, 0x09, 0x17, 0xc2, 0x5d, 0xc2, 0xc1, 0x69,
+ 0x3c, 0x89, 0x8f, 0xea, 0x09, 0x17, 0xc2, 0x07, 0x2a, 0x52, 0x08, 0x01, 0x90, 0xaf, 0xc7, 0xfd,
+ 0x43, 0x7f, 0x5c, 0xba, 0x27, 0x77, 0x38, 0x3f, 0x7d, 0xd2, 0xe0, 0x30, 0x29, 0x84, 0x27, 0x28,
+ 0xa7, 0xfb, 0x09, 0x21, 0x3c, 0x49, 0xc8, 0xe9, 0x09, 0xca, 0xe9, 0x41, 0x92, 0x84, 0xcb, 0xe9,
+ 0xab, 0x6c, 0x87, 0x4f, 0x34, 0x1d, 0x7a, 0x51, 0x3f, 0x38, 0xf2, 0xa3, 0x52, 0x99, 0xd6, 0xb2,
+ 0x05, 0xf0, 0xee, 0xd0, 0xe5, 0x50, 0xfd, 0x3e, 0x2d, 0x68, 0x3a, 0xf4, 0xc2, 0x70, 0x5c, 0xfa,
+ 0x0a, 0x11, 0x15, 0x90, 0xc8, 0x09, 0xc7, 0x2a, 0x45, 0x34, 0x1e, 0x97, 0x1e, 0x26, 0x29, 0xdc,
+ 0xf1, 0x58, 0xbf, 0xc7, 0xd8, 0x64, 0x3e, 0x0e, 0x3d, 0xdc, 0xd3, 0x87, 0xb4, 0x9a, 0x02, 0xc0,
+ 0xda, 0x7c, 0x4b, 0xb7, 0x58, 0x8e, 0x13, 0x44, 0x83, 0xd2, 0x57, 0xc5, 0x01, 0x00, 0xc0, 0xe5,
+ 0xd2, 0xe2, 0xa8, 0xc3, 0x59, 0x58, 0xfa, 0x9a, 0x50, 0x19, 0x80, 0x54, 0x67, 0x21, 0x20, 0xe7,
+ 0x87, 0x87, 0xde, 0x28, 0x1c, 0x0d, 0x4b, 0x1f, 0x09, 0xe4, 0xfc, 0xf0, 0xb0, 0x15, 0x8e, 0x86,
+ 0xfa, 0x5d, 0x56, 0x88, 0x4e, 0xa6, 0x53, 0x7f, 0x0c, 0x51, 0xf8, 0xeb, 0xe4, 0x31, 0xf2, 0x08,
+ 0x6a, 0x0d, 0xa5, 0xa4, 0xfd, 0xb3, 0xe8, 0x78, 0x18, 0x94, 0x2a, 0xaa, 0xa4, 0x4d, 0x0e, 0xd3,
+ 0x3f, 0x61, 0x57, 0x93, 0x8e, 0x07, 0x7d, 0xdb, 0x88, 0xf3, 0x4a, 0xd9, 0x57, 0x12, 0xde, 0x87,
+ 0xfb, 0xb9, 0x32, 0xdb, 0x22, 0x0f, 0x84, 0xa4, 0xbf, 0xc2, 0x85, 0x91, 0xb2, 0x19, 0xba, 0x21,
+ 0x95, 0x26, 0x0c, 0x06, 0x48, 0xf3, 0xb9, 0x42, 0xe3, 0x04, 0x03, 0x4e, 0xf3, 0x90, 0x6d, 0x0b,
+ 0xb7, 0x83, 0x44, 0x13, 0xbe, 0xbc, 0x94, 0x5d, 0x24, 0xdf, 0x23, 0xa8, 0x84, 0x47, 0x40, 0xaa,
+ 0x40, 0x50, 0x91, 0x5b, 0x48, 0x50, 0xc9, 0x45, 0x85, 0x2a, 0x95, 0xb2, 0x2a, 0x32, 0x0f, 0x24,
+ 0xfa, 0x35, 0x22, 0x62, 0x68, 0x23, 0x2a, 0x4d, 0x24, 0x68, 0xfe, 0xb2, 0x42, 0xe3, 0x12, 0xcd,
+ 0x87, 0x7c, 0xb6, 0x27, 0xf1, 0x9a, 0xfe, 0x4a, 0x8a, 0xf6, 0x57, 0x24, 0x03, 0x48, 0x90, 0xc9,
+ 0x45, 0xfd, 0x7a, 0x82, 0x4c, 0xac, 0xea, 0x1b, 0x4c, 0x53, 0xcc, 0x01, 0x29, 0x7f, 0x23, 0x45,
+ 0xd3, 0xee, 0xc4, 0x46, 0x21, 0x78, 0x0a, 0x6d, 0x40, 0xca, 0xbf, 0x29, 0x28, 0x8b, 0xa4, 0x13,
+ 0x9c, 0x0c, 0xc2, 0x89, 0xd0, 0x0b, 0xa4, 0xfb, 0xcd, 0x14, 0x9d, 0xe8, 0x96, 0xd0, 0x8e, 0xc4,
+ 0xe4, 0xa8, 0x21, 0x48, 0xfa, 0x5b, 0x89, 0xc9, 0x51, 0x4f, 0x80, 0x18, 0x22, 0xea, 0x69, 0x7f,
+ 0x7c, 0xe2, 0x57, 0x37, 0x31, 0xd3, 0x29, 0x7b, 0xec, 0xf6, 0xfa, 0xa8, 0x0c, 0x29, 0x2d, 0x60,
+ 0xb0, 0xc8, 0xa0, 0xe4, 0x0a, 0x92, 0x8c, 0x26, 0x96, 0x61, 0xa0, 0x23, 0xca, 0x20, 0xca, 0x3f,
+ 0x13, 0xb0, 0xf2, 0x3f, 0xcb, 0x62, 0xa9, 0xd8, 0x1f, 0x40, 0xfd, 0xa8, 0x7f, 0x92, 0x88, 0xd9,
+ 0xcb, 0xb9, 0x21, 0x92, 0xa9, 0x39, 0xd2, 0xb7, 0xd9, 0xe6, 0xec, 0x24, 0x9a, 0x9f, 0x44, 0x94,
+ 0x1b, 0x7e, 0xb0, 0x6e, 0x0c, 0x52, 0x81, 0x51, 0xe2, 0x2f, 0xfd, 0x17, 0xc8, 0x28, 0xa3, 0x68,
+ 0xcc, 0x43, 0x7a, 0x71, 0x45, 0xa5, 0x48, 0x63, 0x05, 0x9d, 0x30, 0x5b, 0x37, 0x1a, 0xeb, 0x8f,
+ 0x58, 0x76, 0x7e, 0x12, 0x1e, 0x53, 0x46, 0xb4, 0x76, 0xa9, 0x40, 0xc3, 0x73, 0x85, 0x93, 0xf0,
+ 0x18, 0xa6, 0x9c, 0xcf, 0xe6, 0x9c, 0x1d, 0x65, 0x40, 0x6b, 0xa7, 0x14, 0x74, 0xdc, 0x19, 0xcc,
+ 0xe6, 0x9d, 0xf9, 0x38, 0xd4, 0xbf, 0xc9, 0x36, 0x8e, 0x82, 0xd9, 0xc9, 0x9c, 0x27, 0x06, 0xc5,
+ 0x47, 0x77, 0xd7, 0x8d, 0xe5, 0x44, 0x10, 0x34, 0xf8, 0x0f, 0xfd, 0x5b, 0x6c, 0x73, 0xfa, 0x86,
+ 0x6f, 0x33, 0x77, 0xbe, 0x88, 0x90, 0x0a, 0x06, 0x4e, 0xdf, 0xc0, 0x16, 0x9f, 0xb2, 0x42, 0xe8,
+ 0x47, 0x94, 0xb1, 0xe5, 0xf9, 0xd8, 0x07, 0xeb, 0xc6, 0x4a, 0x42, 0xf0, 0x4f, 0xa1, 0x1f, 0x61,
+ 0xf2, 0xf7, 0xdd, 0x05, 0x15, 0x28, 0x70, 0x26, 0x0f, 0xd7, 0x31, 0x51, 0x69, 0xc1, 0x89, 0xab,
+ 0xcf, 0xd5, 0x3c, 0xdb, 0x44, 0xb2, 0xf2, 0x53, 0x4c, 0xf7, 0x12, 0x07, 0xcb, 0x6b, 0x2e, 0x48,
+ 0xbf, 0x52, 0x54, 0x73, 0x51, 0x35, 0x09, 0x45, 0x55, 0x5c, 0xbc, 0x6e, 0x4e, 0xfa, 0x67, 0x50,
+ 0xb7, 0x7e, 0x82, 0xf5, 0xd4, 0xc2, 0xf1, 0x42, 0xf2, 0x27, 0x55, 0x82, 0xaa, 0x57, 0x3a, 0xee,
+ 0xf2, 0xc7, 0x58, 0xca, 0x28, 0xa7, 0x0a, 0xa9, 0xbf, 0x1f, 0x1d, 0xfb, 0x81, 0xd4, 0xd8, 0x6d,
+ 0x3b, 0x06, 0x94, 0x3f, 0x4b, 0x4c, 0x21, 0x8e, 0xf3, 0x0b, 0x06, 0xfd, 0x34, 0xd3, 0x16, 0xcf,
+ 0x11, 0x16, 0xc5, 0x7f, 0x28, 0x25, 0x35, 0x7f, 0x6e, 0x0d, 0xcb, 0x95, 0x84, 0x20, 0xf0, 0xf8,
+ 0xf4, 0xeb, 0xf2, 0xb8, 0xa9, 0x9c, 0xe7, 0x87, 0x59, 0x6e, 0xb2, 0x6b, 0xab, 0x8e, 0x4b, 0xff,
+ 0x84, 0xb2, 0x68, 0x4e, 0x7d, 0x7e, 0x7d, 0x41, 0xe9, 0xf6, 0x73, 0x76, 0x73, 0xcd, 0x99, 0x2d,
+ 0x99, 0x7c, 0x6a, 0xd9, 0xe4, 0xe1, 0xa0, 0x78, 0xfe, 0x0b, 0x27, 0xb2, 0x65, 0xf3, 0xdf, 0xe5,
+ 0xdf, 0xcd, 0xa0, 0x78, 0x47, 0xd3, 0x30, 0x0a, 0x4e, 0xd0, 0x17, 0xe8, 0x8a, 0x2f, 0xd8, 0x26,
+ 0x6b, 0x6f, 0x32, 0x76, 0x34, 0x8b, 0x66, 0x58, 0xb5, 0x92, 0xc5, 0x2f, 0x17, 0x11, 0x0a, 0x17,
+ 0x2f, 0x26, 0x87, 0x68, 0x0d, 0x4f, 0xbc, 0xc4, 0xd5, 0x5d, 0xb6, 0xf3, 0x26, 0x18, 0x45, 0x4a,
+ 0x3e, 0x8e, 0x3e, 0xe0, 0x1b, 0xe7, 0x72, 0x4b, 0x0e, 0x81, 0xe4, 0x9d, 0x43, 0x64, 0xf2, 0xfe,
+ 0x94, 0xe5, 0x50, 0x2c, 0x21, 0xf9, 0x85, 0x87, 0xe7, 0xb2, 0x23, 0x5a, 0xb0, 0x71, 0xfa, 0xa9,
+ 0x7f, 0x87, 0x6d, 0x4c, 0x7c, 0x10, 0x1d, 0xfa, 0x87, 0xf2, 0xb9, 0xe3, 0x39, 0x25, 0xd8, 0x2b,
+ 0xff, 0xa1, 0xf7, 0x16, 0xa4, 0xbf, 0xb9, 0xa6, 0x81, 0xa5, 0xb2, 0x38, 0xd7, 0xe4, 0x36, 0xf1,
+ 0xa8, 0xca, 0xdf, 0xc2, 0x30, 0xb0, 0x5a, 0xae, 0xe7, 0xf4, 0x7c, 0xca, 0x7d, 0xf6, 0xc1, 0xf9,
+ 0x22, 0xd4, 0x6f, 0xb3, 0xbc, 0x3c, 0x01, 0xec, 0x5f, 0xc8, 0x67, 0xfd, 0x2b, 0x6c, 0x3b, 0x99,
+ 0xb4, 0xa4, 0x39, 0xc1, 0xd6, 0x44, 0xc9, 0x56, 0xca, 0x6d, 0xd4, 0xc6, 0x15, 0x62, 0xd5, 0x3f,
+ 0x8d, 0x4f, 0x03, 0x7b, 0x65, 0x37, 0xd7, 0x38, 0x1e, 0x29, 0xfe, 0xf2, 0x23, 0xec, 0x29, 0x2e,
+ 0x09, 0x99, 0xbb, 0x06, 0xf8, 0xa1, 0x6c, 0x92, 0x3f, 0xb7, 0x86, 0xe5, 0x03, 0x6c, 0xed, 0xad,
+ 0x93, 0xea, 0x8f, 0x6d, 0x14, 0xff, 0x25, 0x83, 0x9d, 0x0c, 0xbe, 0xde, 0xc9, 0x8c, 0x3a, 0x68,
+ 0xb3, 0xcf, 0x47, 0x3e, 0x49, 0x8a, 0x9e, 0xf4, 0x7b, 0xac, 0x88, 0xbf, 0x54, 0x29, 0x31, 0x04,
+ 0xf1, 0x24, 0x40, 0x3d, 0xa1, 0x4c, 0xb2, 0x2b, 0xf7, 0x73, 0x2c, 0x37, 0x98, 0x4d, 0x26, 0xfd,
+ 0x29, 0xd6, 0xf6, 0x3b, 0x2b, 0x3c, 0xbc, 0x98, 0xdf, 0x23, 0x42, 0x5b, 0x8c, 0xd0, 0x1f, 0xb0,
+ 0xad, 0xd1, 0x70, 0xec, 0x7b, 0xd1, 0x68, 0xe2, 0xcf, 0x4e, 0x22, 0xea, 0x7f, 0x14, 0x01, 0xe6,
+ 0x22, 0x08, 0x48, 0x8e, 0xfb, 0xc1, 0x50, 0x92, 0x60, 0x93, 0xad, 0x08, 0x30, 0x41, 0x72, 0x9b,
+ 0xe5, 0xe7, 0xc1, 0x68, 0x16, 0x8c, 0xa2, 0xb7, 0xd4, 0x69, 0x93, 0xcf, 0xfa, 0x2e, 0x2b, 0x60,
+ 0xfb, 0x0a, 0x96, 0x8e, 0x7d, 0xb6, 0x3c, 0x02, 0x5a, 0xbc, 0xd9, 0x38, 0x3b, 0x89, 0xb0, 0xea,
+ 0xc6, 0x56, 0x5b, 0x6e, 0x76, 0x12, 0xf1, 0x72, 0x7b, 0x97, 0x15, 0x00, 0x85, 0xe1, 0x12, 0x9b,
+ 0x6d, 0x40, 0xbb, 0xc7, 0x3d, 0xaa, 0xec, 0x77, 0x16, 0xd5, 0x7e, 0xe7, 0x4f, 0xb1, 0x0d, 0xde,
+ 0x81, 0xe1, 0xf5, 0x6c, 0xf1, 0xd1, 0x8d, 0xd5, 0xfd, 0x19, 0x1b, 0x89, 0xf4, 0xa7, 0x6c, 0x4b,
+ 0x39, 0xf0, 0xb0, 0xb4, 0xcd, 0x15, 0xec, 0xce, 0x79, 0xb6, 0x66, 0x27, 0x46, 0x94, 0xbf, 0x9f,
+ 0xc2, 0xd4, 0xe7, 0xf0, 0x64, 0xf0, 0xb9, 0x1f, 0xc1, 0xe1, 0xbe, 0xf1, 0x47, 0x47, 0xc7, 0x22,
+ 0x82, 0xd1, 0x13, 0x24, 0x59, 0x6f, 0x78, 0x63, 0x88, 0x6f, 0x13, 0xc3, 0x58, 0x81, 0x43, 0xf8,
+ 0x46, 0xef, 0xb1, 0x22, 0xa2, 0x71, 0xab, 0x78, 0xba, 0x38, 0x02, 0x37, 0xfb, 0xa9, 0xea, 0x92,
+ 0x2e, 0x66, 0x04, 0xff, 0x9e, 0x9a, 0x47, 0x18, 0x76, 0x40, 0xf3, 0x7e, 0x3e, 0xd6, 0x12, 0x4c,
+ 0xcd, 0x96, 0xfd, 0x92, 0x24, 0x5e, 0x56, 0x93, 0x8f, 0x13, 0x6d, 0xfe, 0xdd, 0x35, 0x43, 0x95,
+ 0xa4, 0x4e, 0x0d, 0x79, 0x99, 0x44, 0xc8, 0x83, 0xed, 0xa0, 0xc0, 0xd6, 0x6f, 0x07, 0xf1, 0xb6,
+ 0xa0, 0x2b, 0xff, 0x66, 0x8a, 0xed, 0xf0, 0x8e, 0x60, 0x1f, 0x9e, 0x21, 0x5f, 0x48, 0xaa, 0x55,
+ 0x6a, 0x41, 0xad, 0x6e, 0xb2, 0xdc, 0x68, 0xaa, 0x8a, 0x7b, 0x73, 0x34, 0xe5, 0xb2, 0x56, 0x44,
+ 0x99, 0xb9, 0x98, 0x28, 0xa5, 0x5d, 0x67, 0x55, 0xbb, 0x26, 0xf1, 0xd2, 0x7a, 0x46, 0xd3, 0xf3,
+ 0x97, 0xf3, 0xb3, 0xb2, 0x63, 0x9a, 0x5e, 0x63, 0xa0, 0x92, 0xd1, 0x62, 0xdb, 0xf4, 0x1c, 0xbb,
+ 0x8f, 0x7d, 0x49, 0x36, 0xe1, 0x4b, 0xa4, 0x15, 0x6c, 0x5c, 0xc4, 0x0a, 0xc4, 0xf6, 0x36, 0x95,
+ 0xed, 0xfd, 0xfd, 0x0c, 0x26, 0x31, 0x7c, 0x50, 0xe0, 0x4f, 0x66, 0xa7, 0xfe, 0x7a, 0xd7, 0xa5,
+ 0xda, 0x7e, 0x7a, 0xc1, 0xf6, 0x7f, 0x5e, 0x6e, 0x3c, 0xc3, 0x37, 0xfe, 0x70, 0xb5, 0x67, 0xa2,
+ 0x29, 0xce, 0xdb, 0x7b, 0x36, 0xb9, 0xf7, 0x07, 0x6c, 0x6b, 0x78, 0x12, 0xf4, 0x29, 0x11, 0x1a,
+ 0x08, 0xb7, 0x25, 0x60, 0x8e, 0x3f, 0x80, 0xd0, 0x23, 0x49, 0xa6, 0x40, 0x83, 0x7e, 0x4b, 0x8e,
+ 0xeb, 0x86, 0xfe, 0x60, 0xc9, 0xfd, 0xe5, 0xbe, 0xd8, 0xfd, 0xe5, 0x97, 0xdd, 0xdf, 0x03, 0xb6,
+ 0x45, 0x07, 0x38, 0x98, 0x9d, 0x4c, 0xd1, 0x93, 0x65, 0xed, 0x22, 0xc2, 0x6a, 0x00, 0x02, 0x1f,
+ 0x70, 0xf8, 0x36, 0xf2, 0x89, 0x80, 0x71, 0x82, 0x02, 0x40, 0x10, 0x2d, 0xcf, 0xec, 0xed, 0x05,
+ 0xce, 0xac, 0xfc, 0x77, 0xe8, 0xbd, 0x19, 0x86, 0xb3, 0xc3, 0xfe, 0x74, 0x78, 0xd1, 0xf7, 0x66,
+ 0xca, 0x88, 0xe4, 0x9b, 0xb9, 0x38, 0xc1, 0x86, 0x9f, 0xa0, 0x15, 0x41, 0x3f, 0xf2, 0x49, 0xe5,
+ 0xf8, 0x6f, 0xbe, 0x85, 0x93, 0x20, 0x8c, 0xbc, 0x70, 0xf4, 0xab, 0x3e, 0x1d, 0x48, 0x81, 0x43,
+ 0x9c, 0xd1, 0xaf, 0xfa, 0xe5, 0x29, 0x66, 0xcb, 0xca, 0x0c, 0xc3, 0x60, 0x36, 0x5f, 0x99, 0x03,
+ 0x7e, 0x29, 0xf3, 0xfd, 0xdd, 0x14, 0xa6, 0x34, 0xea, 0x84, 0xe1, 0x60, 0x0e, 0xca, 0xd4, 0x0f,
+ 0x3e, 0xff, 0x89, 0xcd, 0x0b, 0xe8, 0x79, 0xe0, 0x0f, 0xbc, 0xb1, 0x7f, 0xea, 0x8f, 0xc5, 0xfb,
+ 0x02, 0x80, 0xb4, 0x01, 0x50, 0xfe, 0x57, 0x29, 0xb6, 0xbb, 0xb0, 0xac, 0x44, 0x9a, 0xf0, 0xff,
+ 0xef, 0x84, 0x96, 0xb2, 0x98, 0x8d, 0x15, 0xd5, 0xfc, 0xbf, 0x20, 0xcf, 0x86, 0xcb, 0xb8, 0x60,
+ 0xe0, 0x90, 0xc4, 0xcb, 0x81, 0x43, 0x06, 0xea, 0xb4, 0x1a, 0xa8, 0xd5, 0x54, 0x2c, 0x93, 0x48,
+ 0xc5, 0xf4, 0x6f, 0xb3, 0x0d, 0xd8, 0xbc, 0x88, 0x0d, 0xe5, 0xf3, 0x04, 0x44, 0xef, 0x46, 0x71,
+ 0x40, 0xf9, 0x19, 0xae, 0xdc, 0x0f, 0x82, 0x59, 0xe0, 0x4d, 0xc2, 0xa3, 0x95, 0x2a, 0xa0, 0xb3,
+ 0x2c, 0xef, 0x45, 0xa6, 0xe9, 0x4d, 0xe1, 0x6c, 0xe8, 0x4b, 0x17, 0x98, 0x51, 0x5c, 0xe0, 0x6f,
+ 0x90, 0x76, 0x21, 0xb7, 0x44, 0xe7, 0x64, 0x1d, 0xeb, 0x5b, 0x2c, 0xef, 0x9f, 0x61, 0x10, 0x24,
+ 0xf6, 0x39, 0xff, 0x6c, 0xce, 0x1b, 0xa1, 0x8b, 0x92, 0xcf, 0x9c, 0x93, 0x3f, 0xaa, 0x71, 0xe6,
+ 0x94, 0xec, 0xfc, 0x64, 0x1c, 0x8d, 0xe6, 0x7d, 0xfe, 0x52, 0xed, 0x7b, 0x27, 0x7e, 0x18, 0xe9,
+ 0x9f, 0x25, 0xb4, 0xe8, 0xde, 0xb2, 0x90, 0xe4, 0x08, 0x45, 0x89, 0x56, 0x9f, 0x85, 0xce, 0xb2,
+ 0x87, 0xb3, 0xe1, 0x5b, 0xb1, 0x7b, 0xf8, 0x5d, 0x8e, 0xc8, 0x96, 0x95, 0x79, 0xe7, 0xe3, 0xb7,
+ 0x3f, 0xe9, 0x59, 0x7f, 0x3b, 0x85, 0xaf, 0x91, 0x87, 0x7e, 0x38, 0xe0, 0x2a, 0xf2, 0x3a, 0xe0,
+ 0xbf, 0xf9, 0x7c, 0x05, 0x3b, 0x37, 0x79, 0x1d, 0xd4, 0x01, 0x85, 0x6f, 0xfd, 0xe4, 0xdb, 0xc4,
+ 0x82, 0xbd, 0x79, 0xfc, 0x46, 0x20, 0x42, 0x42, 0xe0, 0xbb, 0xe4, 0xcd, 0x10, 0x11, 0x77, 0x19,
+ 0x0b, 0xfd, 0x60, 0xd4, 0x1f, 0x7b, 0xd3, 0x93, 0x09, 0x97, 0x70, 0xc1, 0x2e, 0x20, 0xa4, 0x7b,
+ 0x32, 0x81, 0x71, 0x43, 0x9c, 0x96, 0xdb, 0x44, 0xc1, 0xde, 0x1c, 0xce, 0x61, 0x5c, 0xf9, 0x0f,
+ 0x52, 0xec, 0x86, 0x8c, 0x52, 0x61, 0xd4, 0x8f, 0x42, 0x79, 0x02, 0xe7, 0xbc, 0x26, 0x57, 0x93,
+ 0xda, 0xf4, 0x39, 0x49, 0x6d, 0x66, 0x21, 0xa9, 0x5d, 0x17, 0xd0, 0x17, 0x8a, 0x83, 0x8d, 0xa5,
+ 0xe2, 0x40, 0x46, 0x8f, 0xcd, 0x8b, 0x44, 0x8f, 0x7f, 0x93, 0xc1, 0x64, 0x2a, 0xde, 0x94, 0xbe,
+ 0xc3, 0xd2, 0xa3, 0x21, 0x7f, 0x9b, 0x93, 0xb5, 0xd3, 0xa3, 0x73, 0xef, 0x00, 0x2c, 0x46, 0xde,
+ 0xf4, 0x05, 0x22, 0x6f, 0x66, 0x45, 0xe4, 0x55, 0xd3, 0x86, 0xec, 0x42, 0xda, 0xf0, 0xe5, 0x14,
+ 0x25, 0x52, 0xf1, 0x72, 0xaa, 0xe2, 0xc5, 0x42, 0xce, 0x27, 0x84, 0xfc, 0x25, 0xc6, 0xf0, 0xff,
+ 0x47, 0xd5, 0xc7, 0x1f, 0x52, 0xa4, 0xe9, 0x1f, 0x1d, 0x05, 0xfe, 0x51, 0x3f, 0xf2, 0xff, 0xcc,
+ 0x68, 0xe8, 0x5f, 0x62, 0xb7, 0x56, 0x6f, 0x0c, 0x9c, 0xd0, 0xe2, 0x41, 0xa5, 0xbe, 0xe8, 0xa0,
+ 0xd2, 0x8b, 0x07, 0x75, 0x97, 0x31, 0x3e, 0x35, 0xa2, 0x71, 0x8f, 0x05, 0x80, 0x70, 0x74, 0xf9,
+ 0x4f, 0x32, 0xe8, 0xfa, 0x51, 0x78, 0x74, 0x53, 0xc3, 0x9b, 0x07, 0xb3, 0xb9, 0x1f, 0xf0, 0x9c,
+ 0x56, 0x75, 0x82, 0x1f, 0x2d, 0xdf, 0x78, 0x5a, 0x1a, 0xa6, 0x7a, 0xc3, 0x83, 0x85, 0x63, 0xc7,
+ 0x06, 0xd8, 0x27, 0x17, 0xe1, 0xa2, 0x8e, 0xe3, 0xef, 0xc7, 0x94, 0x67, 0xdd, 0x66, 0xc5, 0xa9,
+ 0x7f, 0x16, 0xa9, 0x97, 0x41, 0x8a, 0x8f, 0x3e, 0xbe, 0x08, 0x5b, 0x65, 0x58, 0xf3, 0x92, 0xcd,
+ 0xe0, 0x91, 0xae, 0x90, 0xec, 0x2d, 0xb6, 0xc2, 0xbe, 0x71, 0x11, 0x7e, 0x2b, 0x3a, 0x62, 0x3f,
+ 0xc7, 0x32, 0xb3, 0xb3, 0xc9, 0xda, 0x1b, 0x03, 0x2b, 0x98, 0xcc, 0xce, 0x26, 0xcd, 0x4b, 0x36,
+ 0x8c, 0x02, 0x89, 0xad, 0x68, 0x89, 0x5d, 0x48, 0x62, 0xe7, 0x76, 0xc6, 0xc4, 0x9b, 0x92, 0xf2,
+ 0x11, 0xfb, 0xca, 0x05, 0x24, 0xbe, 0x64, 0xb0, 0xa9, 0x1f, 0xd9, 0x60, 0xbf, 0xcb, 0xca, 0x5f,
+ 0x7c, 0x06, 0xfa, 0x43, 0xb6, 0x13, 0x3f, 0x7a, 0xa3, 0x21, 0xce, 0xb4, 0x6d, 0x6f, 0xc9, 0x93,
+ 0x69, 0x0d, 0xc3, 0xb2, 0x83, 0x6d, 0xb9, 0xf5, 0xf2, 0xff, 0x71, 0x5a, 0x67, 0xdf, 0x5c, 0xa7,
+ 0xf8, 0x70, 0x1e, 0x10, 0x25, 0x67, 0x67, 0x13, 0xbe, 0xa2, 0x0c, 0x5e, 0xb6, 0x99, 0x9d, 0x4d,
+ 0x60, 0x2d, 0x7f, 0x3b, 0xb5, 0x56, 0x82, 0xe7, 0x76, 0xd1, 0x56, 0xbc, 0x4d, 0x4a, 0x24, 0x51,
+ 0x99, 0x64, 0x12, 0xf5, 0x0d, 0x96, 0xb8, 0x41, 0xe2, 0x51, 0xb6, 0x04, 0x2b, 0xd1, 0x54, 0x44,
+ 0x1d, 0x32, 0xa7, 0xdf, 0x49, 0x33, 0x7d, 0x69, 0x4d, 0xe1, 0x79, 0x3e, 0x51, 0xdc, 0x42, 0x4b,
+ 0x2b, 0xb7, 0xd0, 0x3e, 0x64, 0x3b, 0x4a, 0xfb, 0x12, 0xfc, 0x57, 0x86, 0x3b, 0x93, 0xed, 0xb8,
+ 0x7f, 0x09, 0xbe, 0x5c, 0x25, 0xe3, 0xcd, 0x51, 0x72, 0x8f, 0x92, 0xec, 0x05, 0x00, 0x95, 0x4b,
+ 0x49, 0x1b, 0x89, 0x4b, 0x49, 0xf7, 0x58, 0x71, 0xd2, 0x3f, 0xf3, 0xfc, 0x69, 0x14, 0x8c, 0xfc,
+ 0x90, 0x42, 0x19, 0x9b, 0xf4, 0xcf, 0x4c, 0x84, 0xe8, 0x7b, 0x50, 0x72, 0x70, 0xf7, 0x03, 0xf8,
+ 0x1c, 0x3f, 0xcd, 0x8b, 0x98, 0x11, 0xf8, 0x2b, 0x5b, 0x19, 0x5a, 0xfe, 0x7e, 0x0a, 0x9b, 0xf4,
+ 0x48, 0x8a, 0xb1, 0xff, 0xfc, 0x58, 0x0f, 0xaa, 0x71, 0xaa, 0x7a, 0xd2, 0x6d, 0xbb, 0x88, 0x30,
+ 0xf4, 0xa5, 0x0f, 0xd8, 0xd6, 0x78, 0x36, 0xfb, 0xfc, 0x64, 0xae, 0x78, 0xd3, 0xac, 0x5d, 0x44,
+ 0x18, 0x92, 0x7c, 0x85, 0x6d, 0x73, 0xd9, 0xf9, 0x43, 0xa2, 0xc9, 0x52, 0x0f, 0x18, 0x81, 0xe8,
+ 0x74, 0x3f, 0xc5, 0x44, 0x4b, 0xde, 0x33, 0x8b, 0xc3, 0xd8, 0xba, 0xcb, 0x5f, 0xe5, 0x3f, 0xa2,
+ 0x3c, 0x26, 0x1e, 0xb3, 0xfe, 0xa2, 0xd8, 0x5d, 0xc6, 0x82, 0x33, 0xea, 0xb2, 0x84, 0x22, 0x22,
+ 0x04, 0x67, 0x16, 0x02, 0x00, 0x1d, 0xc5, 0x68, 0xdc, 0x43, 0x21, 0x92, 0xe8, 0x5b, 0x2c, 0x1f,
+ 0x9c, 0x79, 0x10, 0x40, 0x42, 0x5a, 0x7c, 0x2e, 0x38, 0xab, 0xc2, 0x23, 0x97, 0x9e, 0x40, 0x61,
+ 0xd8, 0xcb, 0x45, 0x84, 0xc2, 0x39, 0xa1, 0x08, 0x9e, 0xfb, 0x43, 0x7e, 0xaa, 0x7c, 0xce, 0x3a,
+ 0x02, 0x68, 0x4e, 0x81, 0xce, 0x89, 0x39, 0x05, 0x7a, 0x97, 0x15, 0x82, 0x33, 0x2c, 0x3f, 0x42,
+ 0x4a, 0x55, 0xf2, 0xc1, 0x99, 0xc9, 0x9f, 0x01, 0x19, 0x49, 0x24, 0x66, 0x2a, 0xf9, 0x48, 0x20,
+ 0xef, 0xb3, 0xad, 0xe0, 0xcc, 0x7b, 0x1d, 0xf4, 0x27, 0x3e, 0x90, 0x50, 0xa2, 0xc2, 0x82, 0xb3,
+ 0x06, 0x80, 0x4c, 0x7e, 0x35, 0xb2, 0x18, 0x9c, 0x79, 0xb3, 0x53, 0x3f, 0xe0, 0x04, 0x45, 0xb1,
+ 0xb4, 0xde, 0xa9, 0x1f, 0x00, 0xfe, 0x0e, 0x5f, 0xf9, 0x20, 0x18, 0x70, 0xf4, 0x96, 0x98, 0xbc,
+ 0x16, 0x0c, 0x70, 0x34, 0x1b, 0xcc, 0xc6, 0xe3, 0x51, 0x48, 0x79, 0x0b, 0xc5, 0x7a, 0x01, 0x59,
+ 0xca, 0x10, 0x77, 0x2e, 0x90, 0x21, 0x5e, 0x5e, 0xce, 0x10, 0xcb, 0x8f, 0xf1, 0xb5, 0x00, 0xb6,
+ 0x11, 0x97, 0x52, 0x9b, 0x75, 0x2f, 0xd4, 0x0e, 0xd0, 0xee, 0xb1, 0x73, 0x88, 0x0a, 0xe7, 0x07,
+ 0xff, 0xf7, 0x49, 0x43, 0xf9, 0xfb, 0x69, 0x34, 0x1d, 0x65, 0x39, 0xe7, 0x2c, 0x83, 0x1f, 0x9f,
+ 0xff, 0x3a, 0x61, 0x37, 0xf9, 0xc0, 0x7f, 0x2d, 0x8d, 0x26, 0xb1, 0x9a, 0xcc, 0x17, 0xad, 0x26,
+ 0xbb, 0x98, 0xc2, 0x7c, 0x59, 0xfd, 0xaf, 0x2a, 0xdb, 0x22, 0x49, 0xf1, 0x1d, 0x91, 0x6f, 0xb9,
+ 0xb7, 0xa6, 0x21, 0x2b, 0xc4, 0x69, 0x17, 0xf1, 0xd9, 0x81, 0x31, 0x50, 0xb6, 0xed, 0xc4, 0x92,
+ 0xe1, 0xc5, 0xdb, 0x17, 0xdd, 0x93, 0x3c, 0xb7, 0x5d, 0x9c, 0x5e, 0xdb, 0x2e, 0xce, 0x5c, 0xb0,
+ 0x5d, 0xfc, 0xfb, 0x29, 0xf5, 0xac, 0xc0, 0xaf, 0xbe, 0xd5, 0x7f, 0x99, 0xee, 0x9f, 0xe2, 0x3b,
+ 0xd2, 0x75, 0x4b, 0x02, 0x92, 0xea, 0x4f, 0xfd, 0xfa, 0x7f, 0xff, 0x0f, 0x77, 0x37, 0x91, 0x1e,
+ 0x7e, 0xde, 0xd1, 0x6f, 0x2b, 0xd4, 0x3f, 0x9d, 0xa4, 0xc6, 0x3b, 0xab, 0xfa, 0x23, 0xbc, 0x97,
+ 0x2c, 0x12, 0xba, 0x3b, 0x6b, 0xf8, 0x73, 0x1a, 0xbc, 0xb5, 0x1c, 0x96, 0xff, 0x5a, 0x0a, 0x75,
+ 0x15, 0x51, 0x32, 0x46, 0x5d, 0x63, 0x1b, 0xfc, 0x3a, 0xa3, 0x78, 0xf9, 0xcb, 0x1f, 0x96, 0x2e,
+ 0xeb, 0xa6, 0x97, 0x2f, 0xeb, 0x82, 0xd2, 0x40, 0x20, 0xe1, 0xfc, 0x44, 0x90, 0x2e, 0x4c, 0xfa,
+ 0x67, 0x3c, 0x79, 0x0f, 0xf5, 0x52, 0xf2, 0x3d, 0xc2, 0x76, 0x1c, 0xf8, 0xbf, 0xad, 0xf6, 0xac,
+ 0x96, 0xbb, 0x0d, 0xe7, 0xbc, 0x39, 0xfb, 0x15, 0x7c, 0x27, 0xad, 0x34, 0x65, 0xd0, 0x34, 0x2a,
+ 0xec, 0x0a, 0xa9, 0x38, 0x07, 0xaa, 0x56, 0x77, 0x19, 0x11, 0xd5, 0xfe, 0x14, 0x7d, 0xbf, 0xfe,
+ 0x55, 0x76, 0x99, 0xeb, 0xba, 0x42, 0x89, 0xe6, 0xb7, 0x0d, 0x60, 0x49, 0x57, 0xfe, 0x3d, 0x32,
+ 0x41, 0x9c, 0x4c, 0x9a, 0xe0, 0x9a, 0xa5, 0x2d, 0xa4, 0xf9, 0xe9, 0x85, 0x34, 0x1f, 0x66, 0x8d,
+ 0xbb, 0xee, 0xaa, 0x1d, 0x6e, 0x23, 0xb8, 0x35, 0x45, 0xba, 0x32, 0xe3, 0xcb, 0x88, 0xa9, 0xd0,
+ 0x18, 0x8b, 0x00, 0x14, 0x34, 0x5f, 0x96, 0x39, 0x3e, 0x65, 0x2c, 0x96, 0x21, 0x19, 0xe3, 0x83,
+ 0xf3, 0x3a, 0x60, 0xa8, 0x4f, 0x05, 0xf8, 0x8d, 0xc6, 0xf8, 0x6b, 0xd8, 0xb9, 0x47, 0x92, 0x73,
+ 0x3f, 0x0e, 0x50, 0x25, 0x97, 0x5e, 0xd3, 0x83, 0xcb, 0xfc, 0xa8, 0x3d, 0xb8, 0x7f, 0x4a, 0x2a,
+ 0x8d, 0x04, 0x52, 0xa5, 0xe9, 0x6a, 0x3c, 0xbe, 0x16, 0x4f, 0xc9, 0xab, 0xf1, 0x1d, 0xfe, 0x5e,
+ 0xf6, 0x2e, 0x6d, 0x1a, 0x95, 0x9e, 0xce, 0x09, 0x20, 0xee, 0x4a, 0xc5, 0xcf, 0xac, 0x50, 0x7c,
+ 0xe2, 0x2f, 0x1a, 0x87, 0x82, 0x3f, 0xa8, 0x8e, 0x44, 0x0e, 0x66, 0xe3, 0x99, 0xe8, 0x79, 0x02,
+ 0xb2, 0x06, 0xcf, 0xe5, 0x53, 0xf6, 0x80, 0xb7, 0xf9, 0x12, 0x0d, 0x3e, 0x69, 0x00, 0xc7, 0xab,
+ 0xaf, 0x41, 0xa5, 0xbe, 0x20, 0x71, 0x5d, 0xe8, 0xfe, 0xad, 0xea, 0x2f, 0x8e, 0x31, 0xb8, 0x25,
+ 0xe6, 0xfd, 0xc9, 0xcd, 0x66, 0x62, 0x1f, 0xf1, 0x7b, 0x27, 0xfe, 0x09, 0x25, 0xe6, 0x34, 0x17,
+ 0xef, 0xc2, 0x60, 0xa2, 0x28, 0xce, 0x45, 0x16, 0xba, 0x4b, 0x3d, 0xe7, 0x72, 0x80, 0x8b, 0x56,
+ 0xd8, 0x4c, 0x46, 0x53, 0x8f, 0xb7, 0x9e, 0x6b, 0xac, 0xa8, 0xf0, 0x25, 0x2f, 0xbb, 0xac, 0x38,
+ 0x4b, 0x2b, 0xc0, 0xf4, 0x94, 0xae, 0x9b, 0x89, 0x9e, 0x76, 0x3a, 0xee, 0x69, 0xaf, 0x9a, 0xb3,
+ 0x7f, 0xf6, 0x13, 0x9e, 0xf3, 0xef, 0x51, 0x67, 0x45, 0x19, 0x99, 0x90, 0xfe, 0x97, 0x32, 0xf1,
+ 0x45, 0xaa, 0xa1, 0x55, 0x67, 0xf9, 0x57, 0x53, 0x68, 0xe2, 0xe4, 0xbc, 0xf8, 0x24, 0xa0, 0x0f,
+ 0x38, 0x5b, 0xec, 0x06, 0xf9, 0x33, 0xd6, 0x35, 0x4a, 0x9f, 0x07, 0x6f, 0x55, 0x55, 0x13, 0x05,
+ 0xc5, 0xba, 0x4e, 0xfb, 0x9a, 0xf5, 0x53, 0x2d, 0xf1, 0x08, 0xef, 0x4c, 0x20, 0xd1, 0x11, 0x4f,
+ 0x0e, 0xc0, 0xdb, 0xc8, 0xa0, 0xb1, 0xe2, 0x36, 0x57, 0xf9, 0x08, 0x0b, 0xcc, 0x15, 0x63, 0xe6,
+ 0xe3, 0xb7, 0x2b, 0xef, 0x7f, 0x7d, 0x93, 0x6d, 0x72, 0x6a, 0xf1, 0xf1, 0xc4, 0xdd, 0x75, 0xaf,
+ 0x4e, 0x39, 0x95, 0x4d, 0xc4, 0x65, 0x73, 0xe9, 0xaa, 0x14, 0xca, 0x69, 0x4d, 0xdf, 0x5e, 0xca,
+ 0x2e, 0x93, 0x90, 0x5d, 0xb9, 0xa3, 0x2a, 0xdf, 0xc5, 0xca, 0x92, 0x04, 0xbb, 0x74, 0x92, 0xdd,
+ 0x1f, 0x53, 0x5e, 0xa2, 0xf0, 0xfb, 0x71, 0xf8, 0x24, 0x8a, 0x8e, 0xcc, 0x52, 0xd1, 0xa1, 0x54,
+ 0x32, 0xd9, 0xc5, 0x4a, 0x26, 0x51, 0x38, 0x6c, 0x2c, 0x14, 0x0e, 0x8b, 0x51, 0x6c, 0xf3, 0x02,
+ 0x51, 0x2c, 0xb7, 0x22, 0x71, 0x9f, 0xa0, 0x82, 0x06, 0xb3, 0xb1, 0x2f, 0xc5, 0xf5, 0x98, 0x65,
+ 0xe1, 0x79, 0xed, 0x6b, 0xaf, 0xc1, 0x6c, 0x1a, 0x05, 0xb3, 0xf1, 0xd8, 0x0f, 0xf8, 0x38, 0x9b,
+ 0x53, 0xc3, 0x74, 0x47, 0xfe, 0xd4, 0xa7, 0x09, 0x49, 0x10, 0x59, 0x7b, 0x2b, 0x06, 0xb6, 0x86,
+ 0xe5, 0xdf, 0x22, 0x83, 0xe8, 0x87, 0x6f, 0xa7, 0x03, 0x11, 0xf3, 0x1e, 0xb2, 0x9d, 0x38, 0xba,
+ 0xf3, 0xa6, 0x24, 0x75, 0x51, 0x44, 0x70, 0xe7, 0x6d, 0xc9, 0x8f, 0x98, 0xa6, 0x7c, 0xd9, 0x24,
+ 0xee, 0xde, 0x00, 0xdd, 0x0e, 0xc0, 0x1d, 0x0e, 0xe6, 0x94, 0x15, 0x76, 0x25, 0xf1, 0xaa, 0x9a,
+ 0x93, 0x62, 0x86, 0x75, 0x19, 0x10, 0x36, 0xc2, 0xf9, 0x7d, 0xa6, 0x17, 0xec, 0x72, 0x63, 0x3c,
+ 0x7b, 0xc3, 0x7b, 0x35, 0xfb, 0xf3, 0x21, 0xb8, 0x2a, 0x6c, 0xb0, 0xe3, 0x7b, 0x8c, 0xf4, 0x68,
+ 0xa8, 0x3f, 0x66, 0x79, 0x71, 0x27, 0x87, 0x32, 0xc6, 0x5b, 0x6b, 0x2f, 0xed, 0xd8, 0x39, 0xf8,
+ 0xd5, 0x99, 0x0d, 0xcb, 0x1e, 0xbb, 0x06, 0x8c, 0x79, 0x3a, 0x77, 0x1e, 0xf7, 0x6f, 0xb1, 0x82,
+ 0xbc, 0xcb, 0x41, 0xec, 0x6f, 0xaf, 0xbf, 0xed, 0x61, 0x63, 0xea, 0x0d, 0x13, 0x7c, 0x87, 0x6d,
+ 0xc0, 0x04, 0xa1, 0xfe, 0x29, 0xdb, 0x18, 0x45, 0xfe, 0x44, 0xb4, 0x8e, 0x76, 0x57, 0x2f, 0x8e,
+ 0xb2, 0x59, 0x4e, 0x59, 0x7e, 0xca, 0x98, 0x5c, 0x5c, 0x08, 0xf9, 0xb0, 0xca, 0x60, 0x5d, 0x3e,
+ 0xcc, 0x73, 0x73, 0xc1, 0xc1, 0x61, 0x79, 0x8b, 0x4e, 0x67, 0xd5, 0x96, 0xe4, 0x79, 0xae, 0xdd,
+ 0x92, 0xa4, 0xb0, 0xf3, 0xe2, 0x98, 0xcb, 0x2f, 0x58, 0x01, 0x99, 0xf6, 0x4e, 0xa2, 0x25, 0xae,
+ 0xdf, 0x61, 0x2c, 0xbe, 0x52, 0x42, 0x6c, 0x77, 0xd7, 0xb1, 0x9d, 0x9d, 0x44, 0x36, 0x2d, 0xa2,
+ 0x77, 0x02, 0xbe, 0xac, 0x58, 0x3b, 0xee, 0x4f, 0x8f, 0x7c, 0xf3, 0xd4, 0x9f, 0x2e, 0xb3, 0xfe,
+ 0x73, 0xac, 0xa8, 0xa8, 0xd6, 0xda, 0xb2, 0x40, 0xa1, 0x69, 0x5e, 0xb2, 0x59, 0xac, 0x75, 0xd5,
+ 0x1c, 0xdb, 0xf0, 0x81, 0x73, 0xe5, 0x3f, 0xa7, 0x58, 0x51, 0x92, 0x4e, 0x67, 0xba, 0xc6, 0xb6,
+ 0x7a, 0x0d, 0xcb, 0xf2, 0x5a, 0xdd, 0x03, 0xa3, 0xdd, 0xaa, 0x6b, 0x97, 0x74, 0x8d, 0xe5, 0x39,
+ 0xa4, 0x63, 0xbc, 0xd4, 0xde, 0xfd, 0xf0, 0xfd, 0xfb, 0x9c, 0x7e, 0x4d, 0xd2, 0x78, 0x56, 0xcf,
+ 0x76, 0xb5, 0xff, 0xf1, 0x1e, 0xa0, 0x3a, 0x63, 0x1c, 0xea, 0x1a, 0xd5, 0xb6, 0xa9, 0xfd, 0x4f,
+ 0x0e, 0xbb, 0xca, 0x8a, 0x1c, 0xd6, 0xed, 0xd9, 0x1d, 0xa3, 0xad, 0xfd, 0x69, 0x82, 0xb0, 0xd1,
+ 0xee, 0xf5, 0xea, 0xda, 0xff, 0xe2, 0x30, 0x31, 0x89, 0xd1, 0x6e, 0x6b, 0x3f, 0xe0, 0x90, 0x9b,
+ 0xec, 0x32, 0x87, 0xd4, 0x7a, 0x5d, 0xd7, 0xee, 0xb5, 0xdb, 0xa6, 0xad, 0xfd, 0xef, 0xc4, 0xf0,
+ 0x76, 0xaf, 0x66, 0xb4, 0xb5, 0x1f, 0x26, 0x87, 0x77, 0x5f, 0x69, 0xef, 0x01, 0x52, 0xf9, 0xb7,
+ 0x1b, 0xf8, 0xba, 0x8f, 0x3b, 0xe1, 0x1d, 0x3e, 0xc4, 0xf5, 0x9a, 0x66, 0xbb, 0xdd, 0xd3, 0x2e,
+ 0xc9, 0x67, 0xd3, 0xb6, 0x7b, 0xb6, 0x96, 0xd2, 0xaf, 0xb3, 0x2b, 0xf8, 0x5c, 0x6b, 0xf6, 0x3c,
+ 0xdb, 0x7c, 0xbe, 0x6f, 0x3a, 0xae, 0x96, 0xd6, 0xaf, 0xf2, 0x25, 0x48, 0xb0, 0xd5, 0x7e, 0xa5,
+ 0x65, 0x62, 0xda, 0x97, 0x96, 0x69, 0xb7, 0x3a, 0x66, 0xd7, 0x35, 0x6d, 0x2d, 0xab, 0xdf, 0x62,
+ 0xd7, 0x39, 0xb8, 0x61, 0x1a, 0xee, 0xbe, 0x6d, 0x3a, 0x92, 0xcd, 0x86, 0x7e, 0x93, 0x5d, 0x5d,
+ 0x44, 0x01, 0xab, 0x4d, 0x7d, 0x97, 0xdd, 0xe4, 0x88, 0x3d, 0xd3, 0x85, 0x6d, 0x36, 0x5a, 0x7b,
+ 0x72, 0x54, 0x4e, 0x32, 0x4c, 0x20, 0x61, 0x5c, 0x5e, 0xae, 0xcb, 0x91, 0x28, 0xad, 0xa0, 0xeb,
+ 0x6c, 0x87, 0x03, 0x2d, 0xa3, 0xf6, 0xcc, 0x74, 0xbd, 0x56, 0x57, 0x63, 0x72, 0xad, 0x8d, 0x76,
+ 0xef, 0x85, 0x67, 0x9b, 0x9d, 0xde, 0x81, 0x59, 0xd7, 0x8a, 0xfa, 0x35, 0xa6, 0x21, 0x69, 0xcf,
+ 0x76, 0x3d, 0xc7, 0x35, 0xdc, 0x7d, 0x47, 0xdb, 0x92, 0x5c, 0x89, 0x41, 0x6f, 0xdf, 0xd5, 0xb6,
+ 0xf5, 0x2b, 0x6c, 0x3b, 0xe6, 0xd0, 0xe9, 0xd5, 0xb5, 0x1d, 0x39, 0xd1, 0x9e, 0xdd, 0xdb, 0xb7,
+ 0x38, 0xec, 0xb2, 0x24, 0xe3, 0x1c, 0x01, 0xa4, 0x49, 0x32, 0xae, 0x0e, 0x1c, 0x76, 0x45, 0xbf,
+ 0xcd, 0x6e, 0x70, 0x58, 0x67, 0xbf, 0xed, 0xb6, 0x2c, 0xc3, 0x76, 0xe5, 0x7e, 0x75, 0xbd, 0xc4,
+ 0xae, 0x2d, 0xe1, 0x60, 0xbb, 0x57, 0x25, 0xa6, 0x6a, 0xd8, 0x76, 0xcb, 0xb4, 0xe5, 0x98, 0x6b,
+ 0xfa, 0x0d, 0xa6, 0x2f, 0x60, 0x60, 0xc4, 0x75, 0xfd, 0x01, 0xbb, 0xcb, 0xe1, 0xcf, 0xf7, 0xcd,
+ 0x7d, 0x73, 0x95, 0x78, 0x6f, 0xe8, 0xf7, 0xd8, 0xee, 0x3a, 0x12, 0xe0, 0x71, 0x53, 0xca, 0xce,
+ 0xee, 0xb5, 0x4d, 0x39, 0xae, 0x24, 0xa5, 0x44, 0x60, 0xa0, 0xbd, 0x25, 0xf7, 0x05, 0x6c, 0x0c,
+ 0xe7, 0x55, 0xb7, 0x26, 0x07, 0xdc, 0x96, 0xab, 0x57, 0x71, 0x30, 0x6a, 0x57, 0x4a, 0xc8, 0x11,
+ 0x18, 0xed, 0x8e, 0x84, 0x75, 0x4c, 0xd7, 0xb4, 0xb9, 0xd4, 0xee, 0x56, 0x6a, 0xf8, 0xbe, 0x7c,
+ 0xe1, 0xab, 0x74, 0x22, 0x6d, 0xf2, 0xb3, 0x16, 0xb6, 0x8a, 0x93, 0x01, 0xec, 0xc0, 0xb4, 0x9d,
+ 0x56, 0xaf, 0x5b, 0x6d, 0xb9, 0x1d, 0xc3, 0xd2, 0x52, 0x15, 0x1f, 0xc3, 0x18, 0xa5, 0x44, 0x58,
+ 0xa4, 0xa1, 0x1e, 0xd4, 0xbc, 0x86, 0x6d, 0xec, 0x09, 0x13, 0xbd, 0x44, 0x7c, 0x09, 0x5a, 0xb7,
+ 0x7b, 0x96, 0x96, 0xa2, 0x5d, 0x13, 0xcc, 0x36, 0x0d, 0xa7, 0xa3, 0xa5, 0x93, 0x84, 0x1d, 0xc3,
+ 0x79, 0xa6, 0x65, 0x2a, 0x4f, 0x71, 0x1a, 0xec, 0xf9, 0x52, 0xb4, 0x24, 0xe5, 0xa8, 0x29, 0xeb,
+ 0x24, 0xe5, 0xae, 0x79, 0x75, 0xd3, 0xb2, 0xcd, 0x9a, 0xe1, 0x9a, 0x75, 0xc1, 0xe1, 0x17, 0xf1,
+ 0x93, 0x58, 0xbc, 0x3a, 0x4c, 0x43, 0xd5, 0x2d, 0xee, 0xb0, 0x02, 0x82, 0xc0, 0x1f, 0xfd, 0x30,
+ 0x15, 0x3f, 0x83, 0xeb, 0x78, 0x9f, 0xaa, 0xfc, 0x4b, 0x0a, 0xd8, 0x89, 0x12, 0x0e, 0xbd, 0x9a,
+ 0xba, 0x02, 0xb9, 0x23, 0x50, 0x6c, 0xb0, 0x01, 0x47, 0x4b, 0x49, 0x81, 0xa0, 0xce, 0x22, 0x34,
+ 0x2d, 0x49, 0xa5, 0xb9, 0x38, 0x5a, 0x56, 0x92, 0xa2, 0x15, 0x20, 0x34, 0x4f, 0xeb, 0xad, 0x79,
+ 0x2d, 0x8b, 0xa4, 0x74, 0x5f, 0x12, 0xa2, 0xa2, 0x21, 0xe1, 0x53, 0xfd, 0x06, 0xd7, 0x2e, 0xe2,
+ 0x59, 0x6d, 0xf7, 0x6a, 0xcf, 0xcc, 0xba, 0xf6, 0x2e, 0x5d, 0x39, 0x55, 0xbe, 0x88, 0x4e, 0x88,
+ 0x6f, 0xc5, 0xe2, 0xc5, 0xf0, 0x7a, 0xef, 0x45, 0x57, 0x4b, 0xc5, 0x74, 0x5d, 0x70, 0x56, 0xb5,
+ 0x03, 0x2d, 0x2b, 0x9c, 0x39, 0x07, 0x35, 0x5e, 0xd4, 0xb5, 0xfb, 0x64, 0x31, 0x08, 0x89, 0x3d,
+ 0xc5, 0xd3, 0xca, 0x9f, 0x5f, 0xe8, 0x76, 0x0b, 0xd1, 0x5b, 0xce, 0xf2, 0xb4, 0x8e, 0xd7, 0x6e,
+ 0x75, 0x9f, 0x2d, 0x4c, 0xeb, 0xc8, 0x5d, 0xa4, 0xc9, 0xbd, 0x72, 0xba, 0x03, 0x53, 0xcb, 0x56,
+ 0xfe, 0x28, 0x8d, 0xdf, 0x21, 0x70, 0xee, 0xb2, 0x6c, 0xa7, 0x81, 0x0d, 0x65, 0x02, 0x09, 0xfa,
+ 0xf4, 0x93, 0x4e, 0xd5, 0x6b, 0xd6, 0x63, 0xf6, 0x04, 0x6a, 0xd4, 0xa5, 0xde, 0x71, 0x10, 0x91,
+ 0x65, 0x17, 0x61, 0x8d, 0xba, 0x96, 0x17, 0xbb, 0x6f, 0x78, 0x9f, 0xee, 0x71, 0x2a, 0x2d, 0x09,
+ 0x69, 0x80, 0x3c, 0x14, 0xf6, 0x08, 0x7a, 0xaa, 0xeb, 0x02, 0xf4, 0x98, 0x40, 0xef, 0x40, 0xff,
+ 0x63, 0xf6, 0x04, 0x4c, 0xeb, 0x57, 0x24, 0x37, 0x17, 0x41, 0x20, 0xf0, 0x22, 0x82, 0x7a, 0x6e,
+ 0xd3, 0xb4, 0xb5, 0x77, 0xf9, 0x98, 0xa8, 0xd6, 0xb3, 0x2c, 0x00, 0x69, 0x31, 0x51, 0xa3, 0x55,
+ 0x05, 0xc8, 0xfd, 0x78, 0x4a, 0x63, 0xdf, 0xed, 0x75, 0xcd, 0x3d, 0xed, 0xdd, 0x53, 0xfd, 0x8a,
+ 0xa0, 0xb2, 0x8c, 0x7d, 0xc7, 0xd4, 0xde, 0xbd, 0x4b, 0xe9, 0x37, 0xb8, 0x2a, 0x09, 0x10, 0xf8,
+ 0x8c, 0x8e, 0xf6, 0xee, 0x5d, 0xba, 0x52, 0x57, 0x94, 0x86, 0x6e, 0x37, 0x6e, 0x73, 0xab, 0xb0,
+ 0x6c, 0xcf, 0xa8, 0x63, 0x0c, 0xdf, 0xc2, 0xc7, 0xba, 0xd9, 0x36, 0x5d, 0x53, 0x4b, 0xc5, 0x90,
+ 0x4e, 0xaf, 0xde, 0x6a, 0xbc, 0xd2, 0xd2, 0x95, 0xcf, 0x50, 0x05, 0xe2, 0xaf, 0xcc, 0x49, 0xa8,
+ 0x1d, 0xae, 0xf4, 0xdd, 0xba, 0x61, 0x03, 0x27, 0x64, 0xdc, 0x71, 0xbd, 0xde, 0xcb, 0x8e, 0x96,
+ 0xaa, 0x7c, 0x1e, 0x7f, 0x46, 0xce, 0xbf, 0x0b, 0x27, 0xbe, 0x2f, 0x3b, 0x35, 0xaf, 0xfb, 0xb2,
+ 0xe3, 0x7d, 0x22, 0xe7, 0x16, 0x90, 0x4f, 0xb5, 0x94, 0xbe, 0xcb, 0xad, 0x1f, 0x20, 0x3d, 0xcb,
+ 0xec, 0x72, 0x0b, 0xac, 0x1a, 0x4e, 0xab, 0x06, 0x9b, 0xd1, 0x6f, 0xf1, 0x68, 0x09, 0xc8, 0x44,
+ 0x84, 0x7d, 0xff, 0x3e, 0x53, 0xf9, 0x5b, 0x79, 0x76, 0x75, 0xc5, 0x97, 0xd9, 0xa4, 0xd4, 0x2f,
+ 0x61, 0x51, 0x8d, 0xaa, 0xcc, 0x4a, 0x2e, 0x91, 0x5b, 0x56, 0xe1, 0xcd, 0x57, 0x88, 0x4b, 0x51,
+ 0x50, 0x16, 0xb8, 0x8e, 0xe9, 0x1a, 0x75, 0xc3, 0x35, 0xb4, 0xf4, 0x02, 0x33, 0xd3, 0x6d, 0x7a,
+ 0x75, 0xc7, 0xd5, 0x32, 0x2b, 0xe0, 0x8e, 0x5d, 0xd3, 0xb2, 0x0b, 0x8c, 0x00, 0xee, 0xbe, 0xb2,
+ 0x4c, 0x19, 0xf6, 0x05, 0xe2, 0xa0, 0x6d, 0x74, 0xbd, 0x83, 0x56, 0x5d, 0xdb, 0x5c, 0x85, 0xb0,
+ 0x6a, 0x96, 0x96, 0x5b, 0xdc, 0x87, 0xe5, 0xd5, 0x9d, 0x9a, 0xa5, 0xe5, 0x29, 0x14, 0x29, 0x70,
+ 0xb3, 0xd6, 0xd5, 0x0a, 0x0b, 0x7c, 0x5a, 0x96, 0x67, 0xd9, 0x3d, 0xb7, 0xa7, 0xb1, 0x25, 0xc4,
+ 0xc1, 0x63, 0xbe, 0xd6, 0xe2, 0x2a, 0x04, 0x6c, 0x6e, 0x6b, 0x61, 0x66, 0xb7, 0x66, 0xf1, 0x01,
+ 0xdb, 0x2b, 0xe0, 0x40, 0xbf, 0xb3, 0x00, 0xdf, 0xaf, 0x23, 0xfd, 0xe5, 0x15, 0x70, 0xa0, 0xd7,
+ 0x16, 0x26, 0x76, 0x6a, 0x2e, 0x0e, 0xb8, 0xb2, 0x0a, 0x51, 0xe7, 0xe9, 0xc0, 0xc2, 0xd9, 0xd5,
+ 0x3a, 0xb0, 0x58, 0x2e, 0xd9, 0xab, 0xab, 0x71, 0xb5, 0x5e, 0xdd, 0xd4, 0xae, 0x2d, 0xc8, 0xca,
+ 0xb0, 0x2d, 0xaf, 0x67, 0x69, 0xd7, 0x17, 0x16, 0x06, 0x60, 0xc7, 0x32, 0xb4, 0x1b, 0x2b, 0xe0,
+ 0xae, 0x65, 0x68, 0x37, 0x57, 0xd1, 0x37, 0x0d, 0xad, 0xb4, 0x8a, 0xbe, 0x69, 0x68, 0xb7, 0x96,
+ 0x25, 0xfb, 0x84, 0x6f, 0xf0, 0xf6, 0x2a, 0x04, 0x6c, 0x70, 0x77, 0x71, 0x13, 0x80, 0x68, 0xb4,
+ 0x8d, 0xaa, 0xd9, 0xd6, 0xee, 0xac, 0xda, 0xe0, 0x13, 0xdc, 0xfc, 0xdd, 0xd5, 0x38, 0xbe, 0xf9,
+ 0x0f, 0xf4, 0xbb, 0xec, 0xd6, 0x22, 0xcf, 0x6e, 0xdd, 0x73, 0x0d, 0x7b, 0xcf, 0x74, 0xb5, 0x7b,
+ 0xab, 0xa6, 0xec, 0xd6, 0x3d, 0xa7, 0xdd, 0xd6, 0xee, 0xaf, 0xc1, 0xb9, 0xed, 0xb6, 0xf6, 0x80,
+ 0xa2, 0xb5, 0xb4, 0x15, 0xab, 0xed, 0x78, 0xb8, 0xd2, 0xf2, 0x82, 0x3c, 0x38, 0xca, 0xad, 0x69,
+ 0x5f, 0x59, 0x34, 0x2f, 0x80, 0x57, 0x7b, 0x8e, 0xf6, 0x70, 0x01, 0x61, 0x55, 0xab, 0x5e, 0xcb,
+ 0x69, 0xd5, 0xb5, 0x0f, 0x29, 0x75, 0x91, 0xaa, 0xb6, 0xdf, 0xed, 0x9a, 0x6d, 0xaf, 0x55, 0xd7,
+ 0xbe, 0xba, 0x6a, 0x69, 0xe6, 0x4b, 0xb7, 0x59, 0xb7, 0xb5, 0xaf, 0x55, 0x3e, 0xc3, 0xea, 0x85,
+ 0x7f, 0x47, 0x3c, 0x1a, 0xea, 0x97, 0xb9, 0xd3, 0x3c, 0x68, 0xd5, 0xbd, 0x6e, 0xaf, 0x6b, 0xf2,
+ 0x90, 0xb5, 0x43, 0x00, 0xcb, 0x36, 0x1d, 0xb3, 0xeb, 0x6a, 0xef, 0xee, 0x57, 0xfe, 0x5d, 0x0a,
+ 0x1b, 0x38, 0xa3, 0xf9, 0xe9, 0x13, 0xfa, 0xee, 0x55, 0xdc, 0x1b, 0x04, 0xea, 0x96, 0xd9, 0x5c,
+ 0x8a, 0x49, 0x00, 0x03, 0x96, 0x2f, 0xc1, 0x77, 0x60, 0x7c, 0x03, 0x90, 0xe9, 0x58, 0x5a, 0x9a,
+ 0x66, 0x85, 0x67, 0x63, 0xdf, 0x6d, 0x6a, 0x59, 0x05, 0x50, 0x87, 0x24, 0x30, 0xaf, 0x00, 0x20,
+ 0x59, 0xd2, 0x34, 0x85, 0xab, 0xdd, 0xdb, 0x07, 0xff, 0x76, 0x5f, 0xe1, 0xda, 0xec, 0x59, 0xda,
+ 0x53, 0x8a, 0x1c, 0xf0, 0xbc, 0xdf, 0xb5, 0x4d, 0x0b, 0xc2, 0x90, 0x0a, 0x72, 0xcc, 0xe7, 0x90,
+ 0x30, 0xfc, 0x20, 0x9d, 0xf8, 0xf0, 0x90, 0xee, 0xf3, 0x02, 0x99, 0xc1, 0x73, 0x78, 0x6b, 0x1f,
+ 0x3c, 0x21, 0x1e, 0x93, 0x01, 0x49, 0xae, 0xf5, 0xca, 0x73, 0xdd, 0x36, 0x4f, 0xef, 0x8b, 0x64,
+ 0x2d, 0x2a, 0xbc, 0xd5, 0x95, 0xee, 0xc0, 0xc0, 0xd4, 0x14, 0x0f, 0xd5, 0x6d, 0x4b, 0xf3, 0x36,
+ 0x5c, 0xaf, 0x6e, 0xd6, 0x62, 0xb8, 0x46, 0x89, 0x81, 0xe1, 0x7a, 0xd6, 0xbe, 0xd3, 0xe4, 0x1e,
+ 0x4d, 0xbb, 0x42, 0xc2, 0x04, 0x60, 0xcf, 0x42, 0x98, 0xbe, 0x40, 0x08, 0x1c, 0xb4, 0xab, 0x49,
+ 0x42, 0x0e, 0xbb, 0x16, 0x13, 0xc2, 0x0a, 0x78, 0xea, 0xa4, 0x5d, 0x27, 0x29, 0x1a, 0x54, 0x7a,
+ 0x68, 0x37, 0x28, 0xb7, 0x22, 0xaa, 0xee, 0x0b, 0xbe, 0x9a, 0x9b, 0x31, 0x14, 0x56, 0x49, 0xd0,
+ 0x52, 0x92, 0x63, 0xa3, 0x65, 0xb6, 0xeb, 0xda, 0x2d, 0x65, 0x6a, 0x58, 0x8f, 0x55, 0xad, 0x6a,
+ 0xb7, 0xe9, 0x68, 0x68, 0x39, 0x00, 0xda, 0xd5, 0x4b, 0x62, 0xdf, 0x4b, 0x21, 0xe9, 0x00, 0x6f,
+ 0x16, 0x28, 0x0d, 0x26, 0xfa, 0xa0, 0x54, 0x64, 0xc7, 0x9d, 0x76, 0xa2, 0x94, 0x66, 0x04, 0x83,
+ 0xe4, 0xf5, 0xbf, 0xbe, 0xcf, 0x50, 0x48, 0x07, 0x48, 0xb7, 0xe7, 0x55, 0xf7, 0x1b, 0x0d, 0xe2,
+ 0xfb, 0x9f, 0x84, 0x8a, 0x2a, 0x1f, 0x8d, 0xf1, 0xb3, 0x25, 0xc5, 0x51, 0x33, 0x62, 0xdc, 0x6f,
+ 0xcb, 0xf5, 0xf6, 0x7a, 0x6e, 0x8f, 0xca, 0xef, 0x14, 0xd9, 0x53, 0xcb, 0xf5, 0x5e, 0xd8, 0x2d,
+ 0xd7, 0x54, 0x23, 0x1c, 0x9a, 0xa0, 0xc4, 0x18, 0x35, 0xb7, 0xd5, 0xeb, 0x3a, 0x5a, 0x26, 0x46,
+ 0x18, 0x96, 0xd5, 0x7e, 0x25, 0x11, 0xd9, 0x18, 0x51, 0x6b, 0x9b, 0x86, 0x2d, 0x11, 0x1b, 0x42,
+ 0xaf, 0xa9, 0x5e, 0xd1, 0x36, 0x49, 0x52, 0xad, 0x15, 0x92, 0xfa, 0x8b, 0xb8, 0xa1, 0xc5, 0x8f,
+ 0xc5, 0x28, 0xa1, 0x68, 0xd4, 0x12, 0x99, 0x4a, 0xa3, 0x26, 0xf2, 0x12, 0x11, 0xa9, 0x25, 0xc4,
+ 0x73, 0x5c, 0xbb, 0x55, 0x83, 0xf2, 0x5c, 0x92, 0x52, 0x52, 0x93, 0x89, 0x49, 0x11, 0x22, 0x48,
+ 0xb3, 0x95, 0x7f, 0x48, 0x6f, 0x8e, 0xe4, 0xec, 0x68, 0xef, 0x28, 0xcc, 0x86, 0x9a, 0x82, 0x12,
+ 0x8b, 0x86, 0xe7, 0x98, 0xdd, 0xba, 0x2c, 0x9c, 0xe3, 0x65, 0x34, 0xbc, 0x5a, 0xd3, 0xac, 0x3d,
+ 0xf3, 0x7a, 0x07, 0xa6, 0xdd, 0x36, 0x2c, 0x99, 0x30, 0x34, 0x1a, 0x1e, 0x38, 0x18, 0xb0, 0xa4,
+ 0xfd, 0xae, 0x1b, 0x0b, 0xad, 0xd1, 0xe0, 0xa9, 0xf6, 0x33, 0x89, 0xc8, 0x27, 0x10, 0xd5, 0x57,
+ 0x12, 0xa1, 0x55, 0x1c, 0x2c, 0x7d, 0xf0, 0xb3, 0x5e, 0xdc, 0xdd, 0xde, 0x52, 0x23, 0x66, 0x4f,
+ 0x69, 0xc4, 0x08, 0x48, 0xdc, 0x35, 0x91, 0x10, 0xd9, 0x08, 0xf9, 0x2e, 0xbe, 0x9d, 0x59, 0xfa,
+ 0xfc, 0x8a, 0x04, 0xbf, 0x97, 0x14, 0xfc, 0x9e, 0x22, 0x78, 0x09, 0x21, 0xf9, 0xa6, 0x2b, 0x8e,
+ 0xfa, 0x2e, 0x9e, 0xab, 0x23, 0x31, 0xc1, 0xea, 0x4b, 0x32, 0x01, 0x23, 0x6b, 0x9b, 0x35, 0xf0,
+ 0x95, 0x68, 0x06, 0x7b, 0xa0, 0xaf, 0xf5, 0x96, 0x6d, 0xf2, 0x83, 0xdb, 0xc2, 0x45, 0xba, 0x5e,
+ 0xa3, 0xa1, 0x65, 0x2a, 0x16, 0x2a, 0xc6, 0xe2, 0x47, 0x4a, 0x74, 0x38, 0x36, 0x48, 0xa9, 0x63,
+ 0xb8, 0xb5, 0xa6, 0x76, 0x89, 0xd4, 0x4d, 0x28, 0xa0, 0x2c, 0xd8, 0x6c, 0x21, 0x24, 0x6e, 0xea,
+ 0xe9, 0xca, 0xdf, 0x48, 0x61, 0x67, 0x7d, 0xc5, 0xe7, 0x3f, 0x74, 0x5a, 0xb6, 0xed, 0xb5, 0xea,
+ 0x6d, 0xd3, 0x73, 0x5b, 0x1d, 0xb3, 0xa7, 0x78, 0x48, 0xdb, 0xf6, 0x9a, 0x86, 0x5d, 0x97, 0x70,
+ 0x21, 0x04, 0x5b, 0x66, 0xce, 0xe9, 0x98, 0x12, 0x4b, 0x3f, 0xa9, 0x7c, 0x12, 0x8e, 0xb5, 0x3b,
+ 0xc1, 0xb3, 0x95, 0x29, 0xfd, 0x8f, 0x27, 0xfe, 0x3a, 0x92, 0xd2, 0x67, 0xef, 0x97, 0x4c, 0xbb,
+ 0x27, 0x8f, 0xb4, 0x83, 0x47, 0xfa, 0xee, 0x07, 0xef, 0x73, 0xfa, 0x75, 0xbe, 0xeb, 0x8e, 0xe7,
+ 0xb4, 0x7b, 0x2f, 0x2c, 0xc3, 0x6d, 0x52, 0xd3, 0x0b, 0xbb, 0x61, 0x1d, 0xb5, 0x1b, 0xa6, 0x76,
+ 0xbe, 0x3a, 0x58, 0xfd, 0xf2, 0x03, 0x9f, 0x2c, 0x7d, 0x2a, 0xa3, 0x26, 0xf3, 0x55, 0xd5, 0x73,
+ 0xa0, 0x3c, 0x01, 0x46, 0x75, 0x3e, 0xee, 0x81, 0x03, 0x9c, 0x1a, 0xd4, 0xb0, 0x1d, 0xc3, 0x7e,
+ 0xa6, 0x89, 0xa4, 0x1c, 0xe0, 0x4b, 0x76, 0xfd, 0x5d, 0xf5, 0x6b, 0xa1, 0x65, 0xfd, 0xea, 0x24,
+ 0xf5, 0xab, 0xb3, 0xa4, 0x5f, 0x1d, 0x45, 0xbf, 0x8e, 0xd4, 0x57, 0xf0, 0xaa, 0x89, 0x76, 0x1a,
+ 0x89, 0x0e, 0x00, 0x43, 0xd0, 0xb3, 0xaa, 0x05, 0x55, 0x3b, 0xed, 0xa2, 0x01, 0x56, 0x66, 0x39,
+ 0x32, 0x1e, 0x77, 0x1a, 0x5e, 0x75, 0xdf, 0x76, 0x5c, 0x19, 0x8f, 0x3b, 0x0d, 0x51, 0xa7, 0x57,
+ 0x7e, 0x9f, 0x6e, 0x77, 0xe1, 0x07, 0x18, 0x5c, 0x3e, 0xb8, 0x75, 0x93, 0x9a, 0x84, 0x5e, 0xc3,
+ 0x68, 0xb5, 0x4d, 0x98, 0x0d, 0x43, 0xa4, 0xe9, 0x7a, 0x55, 0xa3, 0x2e, 0xdb, 0x3a, 0x42, 0xf3,
+ 0x08, 0x4c, 0xfa, 0x98, 0xa6, 0x4c, 0x89, 0xa0, 0xad, 0xae, 0xe3, 0xda, 0xfb, 0x88, 0xca, 0x50,
+ 0xfc, 0x21, 0x14, 0x2a, 0x74, 0x36, 0xa6, 0x17, 0xfd, 0x35, 0x31, 0xef, 0x06, 0x65, 0x3d, 0xa6,
+ 0xd2, 0x67, 0x13, 0xb8, 0xcd, 0x78, 0x98, 0xe8, 0xb7, 0x09, 0x54, 0x2e, 0x1e, 0x26, 0xfb, 0x6e,
+ 0x02, 0x97, 0x8f, 0x87, 0x61, 0x2f, 0xa2, 0x67, 0x09, 0x54, 0x41, 0xff, 0x80, 0xdd, 0x46, 0x94,
+ 0xf3, 0xa2, 0xe5, 0xd6, 0x9a, 0xa2, 0x19, 0x46, 0x78, 0x46, 0x99, 0xa5, 0x99, 0x6c, 0x87, 0x09,
+ 0x74, 0x31, 0x9e, 0x55, 0xf6, 0xad, 0x04, 0x6e, 0x8b, 0x3a, 0x6d, 0x72, 0x45, 0xb2, 0x0b, 0x4a,
+ 0x04, 0xdb, 0x14, 0x33, 0xcc, 0x15, 0xba, 0x55, 0x55, 0xff, 0x83, 0xe3, 0xeb, 0xfe, 0x68, 0xcc,
+ 0x6f, 0xf9, 0xf1, 0x7f, 0x80, 0x04, 0xfa, 0xd8, 0x6c, 0xd4, 0xbc, 0x56, 0xb7, 0xd6, 0xeb, 0x58,
+ 0x86, 0xdb, 0x82, 0xa8, 0x27, 0xb4, 0x0c, 0x10, 0xa6, 0x65, 0xda, 0x50, 0xa1, 0xfe, 0x49, 0x1a,
+ 0xfd, 0xcb, 0x61, 0x7f, 0x28, 0xde, 0x17, 0x21, 0x0f, 0x3c, 0xf0, 0xaa, 0x5d, 0xe3, 0x27, 0x42,
+ 0xfd, 0x32, 0xd9, 0xe5, 0x10, 0x70, 0x9e, 0x75, 0x8b, 0x68, 0x2a, 0x80, 0xb2, 0x47, 0xa9, 0xa5,
+ 0xa9, 0x89, 0x2b, 0x30, 0x89, 0x2d, 0x88, 0x80, 0xa4, 0x20, 0x91, 0x9f, 0xe8, 0xcc, 0x00, 0x02,
+ 0xd7, 0xb9, 0x41, 0xf6, 0x29, 0x48, 0xdb, 0x66, 0x57, 0x56, 0x8a, 0x1c, 0xc6, 0x53, 0x03, 0xcf,
+ 0xec, 0x58, 0xee, 0x2b, 0xd9, 0x1c, 0x56, 0x10, 0xfb, 0xdd, 0x67, 0xdd, 0xde, 0x8b, 0xae, 0x8c,
+ 0x2e, 0x72, 0xf9, 0x5c, 0xe6, 0x2d, 0x38, 0xe2, 0x78, 0x5f, 0x2d, 0xc7, 0x73, 0xda, 0xc6, 0x81,
+ 0xa9, 0xb1, 0x85, 0xcd, 0xf2, 0xda, 0x58, 0x64, 0x85, 0x12, 0xc8, 0xdb, 0x44, 0xda, 0x96, 0xfe,
+ 0x90, 0xdd, 0x27, 0x70, 0xdc, 0xa3, 0xa5, 0xe9, 0x21, 0x1a, 0x82, 0x0a, 0x6b, 0xdb, 0x95, 0xdf,
+ 0xcd, 0xa0, 0xff, 0x01, 0x79, 0x53, 0x52, 0xca, 0xc5, 0x4d, 0x33, 0x19, 0x8a, 0x58, 0x45, 0xaf,
+ 0x51, 0x00, 0x61, 0xd3, 0x29, 0x21, 0x50, 0x63, 0x85, 0x40, 0x45, 0xee, 0xa2, 0x20, 0x91, 0x53,
+ 0x66, 0x01, 0xd1, 0xdb, 0x47, 0xdb, 0x90, 0x61, 0x58, 0x20, 0x0c, 0x7b, 0x6f, 0x1f, 0x98, 0x69,
+ 0x1b, 0xe2, 0x08, 0x0c, 0x71, 0x04, 0x9b, 0xca, 0x12, 0xdd, 0x1e, 0x04, 0x9d, 0x2e, 0x88, 0x1a,
+ 0x0d, 0x5d, 0x8c, 0xc7, 0x54, 0x34, 0x2f, 0xf4, 0x41, 0x99, 0x0e, 0x73, 0xd2, 0x02, 0x59, 0x0a,
+ 0x60, 0xb8, 0x91, 0x73, 0x05, 0xed, 0x3a, 0x2d, 0xc7, 0x85, 0x59, 0x99, 0x7e, 0x87, 0x95, 0x08,
+ 0xbd, 0xdf, 0x75, 0xf6, 0x2d, 0x58, 0xa4, 0x59, 0xf7, 0x7a, 0x76, 0xdd, 0xb4, 0xb5, 0xe2, 0x82,
+ 0x3c, 0x5c, 0x63, 0x4f, 0xdb, 0x5a, 0xd8, 0x00, 0xa4, 0x18, 0x7c, 0xcb, 0xa2, 0x38, 0x57, 0x11,
+ 0x20, 0xc0, 0x9d, 0x05, 0x01, 0xf2, 0xee, 0xb2, 0xd8, 0xf5, 0xe5, 0xca, 0x9f, 0xa6, 0x58, 0x49,
+ 0x1c, 0x8f, 0x9a, 0x5c, 0x2a, 0x66, 0x55, 0x6d, 0xd5, 0x84, 0x3e, 0x71, 0x1f, 0x26, 0x9d, 0x20,
+ 0x22, 0x9c, 0x7d, 0x0b, 0xc1, 0x29, 0x85, 0x3e, 0xa1, 0x6b, 0xc2, 0x0f, 0xc6, 0xf4, 0x32, 0xfb,
+ 0xcc, 0x90, 0xa7, 0x59, 0x46, 0x61, 0xff, 0x37, 0x2b, 0x56, 0xdf, 0x5a, 0x71, 0xfc, 0x1b, 0x0b,
+ 0x13, 0xca, 0xe3, 0xdf, 0x14, 0x82, 0x6b, 0xc5, 0x8a, 0x94, 0x13, 0x07, 0xdc, 0x12, 0x07, 0x9c,
+ 0xaf, 0xfc, 0x23, 0xba, 0xb7, 0x0d, 0x9b, 0xc7, 0x3e, 0x97, 0xaa, 0x9a, 0x9d, 0x55, 0xaa, 0xd9,
+ 0x51, 0x55, 0x33, 0x09, 0x83, 0xe3, 0x91, 0xf6, 0x4f, 0xb0, 0x7a, 0x1b, 0xc2, 0x9d, 0x4d, 0xcd,
+ 0xec, 0x05, 0x64, 0xf7, 0x85, 0x82, 0xcc, 0x0a, 0x1d, 0x22, 0xe4, 0x8b, 0x56, 0xbb, 0x5e, 0x33,
+ 0xec, 0x3a, 0xa4, 0xd5, 0xa4, 0x73, 0x84, 0xc1, 0x62, 0x65, 0x73, 0x01, 0x7a, 0x60, 0xb4, 0xf7,
+ 0x4d, 0x2d, 0xb7, 0xb0, 0x78, 0xce, 0x5a, 0x74, 0x8c, 0x04, 0xd0, 0xb2, 0x4d, 0xdb, 0x7c, 0xae,
+ 0x15, 0x14, 0x0e, 0xf5, 0x7d, 0x8b, 0xf8, 0x32, 0x21, 0xa7, 0x8e, 0x90, 0x53, 0xb1, 0xf2, 0x07,
+ 0xa4, 0x24, 0x71, 0xba, 0xac, 0xf8, 0x5e, 0x9c, 0xb0, 0xd1, 0x69, 0x48, 0x2d, 0x91, 0xe9, 0x13,
+ 0x07, 0x92, 0x9b, 0xdf, 0x6f, 0xb7, 0xa5, 0xdf, 0xe4, 0xf0, 0x05, 0x15, 0x51, 0xd8, 0x88, 0x5c,
+ 0x3a, 0x23, 0x12, 0xf2, 0x8e, 0xf4, 0xdf, 0x32, 0x8d, 0x96, 0x1c, 0x28, 0x33, 0xdb, 0x58, 0x44,
+ 0xd4, 0x7a, 0x9d, 0x8e, 0xd1, 0x05, 0x39, 0xe1, 0xe6, 0x25, 0xa2, 0xd1, 0x36, 0xf6, 0x1c, 0x2d,
+ 0x57, 0xf9, 0xbd, 0x0c, 0x7e, 0xf8, 0x13, 0x67, 0xc2, 0xea, 0xae, 0x70, 0xa1, 0x7b, 0x30, 0x08,
+ 0x03, 0xae, 0xf9, 0xb2, 0xe5, 0xb8, 0x8e, 0x7c, 0x57, 0xc1, 0x31, 0x22, 0xcd, 0x44, 0x5b, 0x4f,
+ 0x91, 0x2e, 0x73, 0xd4, 0x0b, 0xb3, 0xb5, 0xd7, 0x74, 0x55, 0xa3, 0x96, 0x66, 0xc0, 0xf1, 0xe0,
+ 0x22, 0x7a, 0x0d, 0x1c, 0x09, 0xb5, 0x16, 0x46, 0x4c, 0x15, 0x55, 0xdd, 0x07, 0x3f, 0x0b, 0x95,
+ 0xc3, 0x7d, 0x76, 0x47, 0xe0, 0x6a, 0x4d, 0xa3, 0xd5, 0x6d, 0x75, 0xf7, 0x12, 0x8c, 0x37, 0xc8,
+ 0xc9, 0xe0, 0xc4, 0xdc, 0xcb, 0xa8, 0xe8, 0x4d, 0x91, 0x86, 0x03, 0xba, 0xdd, 0xeb, 0x59, 0x32,
+ 0x60, 0xec, 0x29, 0x87, 0x46, 0x9b, 0xc8, 0xab, 0x28, 0x3e, 0x9b, 0x59, 0x97, 0xbe, 0x0c, 0xf5,
+ 0x65, 0x4f, 0xca, 0x1e, 0x2c, 0x43, 0xb4, 0x17, 0xf7, 0x16, 0x05, 0x5f, 0x24, 0x25, 0x90, 0x08,
+ 0xdc, 0x90, 0xb6, 0x45, 0x07, 0x22, 0xe1, 0x7c, 0xc5, 0xf2, 0xdd, 0xe2, 0x5e, 0x7c, 0xd8, 0x3b,
+ 0x95, 0xdf, 0x26, 0xc5, 0x13, 0xff, 0x9c, 0x35, 0x71, 0x44, 0xb8, 0x1a, 0x4b, 0xb0, 0xa1, 0x26,
+ 0x2f, 0xae, 0x46, 0x42, 0x9b, 0x68, 0x63, 0x32, 0x97, 0xb5, 0xe2, 0x65, 0xf2, 0x17, 0xa5, 0xe2,
+ 0x50, 0x24, 0xdc, 0xa8, 0x1f, 0x98, 0xb6, 0xdb, 0x72, 0x4c, 0xa9, 0x7e, 0x96, 0xa2, 0x7e, 0x95,
+ 0x5f, 0x46, 0xa5, 0x91, 0xff, 0xc1, 0x38, 0xb1, 0x22, 0x7a, 0x47, 0x98, 0xd0, 0x6e, 0x69, 0x0c,
+ 0xee, 0xc2, 0xcc, 0xe2, 0x5d, 0x86, 0x1b, 0xb3, 0x4f, 0x57, 0x7e, 0x09, 0xf7, 0x8b, 0x77, 0x71,
+ 0x66, 0xf3, 0x15, 0xfb, 0x7d, 0xde, 0x4b, 0xee, 0x17, 0xe7, 0x94, 0x50, 0x0c, 0x48, 0x82, 0x37,
+ 0x07, 0x0b, 0xde, 0x7f, 0x81, 0xdd, 0x5d, 0xfa, 0x5f, 0xce, 0x2b, 0x96, 0xef, 0xd4, 0x12, 0x86,
+ 0x22, 0x12, 0x20, 0x09, 0x46, 0xd7, 0x87, 0xfc, 0x39, 0x30, 0x5e, 0xfb, 0x9d, 0xc5, 0x9b, 0x38,
+ 0x09, 0xf6, 0x54, 0xc0, 0xd9, 0x8d, 0x1a, 0xe4, 0xdd, 0x5c, 0x32, 0x0a, 0x88, 0x6b, 0x6c, 0x5c,
+ 0xc2, 0xd9, 0x34, 0x1b, 0xe4, 0x97, 0x5a, 0xba, 0xf2, 0xaf, 0xd3, 0x28, 0xf7, 0xb8, 0xac, 0x58,
+ 0x76, 0x41, 0x9d, 0xa4, 0x0b, 0x42, 0x0b, 0xe6, 0x40, 0xcc, 0x42, 0xc9, 0x82, 0x53, 0x74, 0xe2,
+ 0x1d, 0xd5, 0x82, 0xb1, 0x5f, 0x91, 0x56, 0x51, 0xc2, 0x2e, 0x10, 0x25, 0x32, 0x8a, 0xce, 0xa2,
+ 0x9a, 0x67, 0x49, 0x6c, 0x9d, 0xa4, 0x7f, 0x11, 0x4e, 0x5b, 0x82, 0x6d, 0xc3, 0x35, 0xa5, 0x33,
+ 0xea, 0xc4, 0x36, 0x61, 0xf3, 0xb7, 0xfb, 0x0b, 0xc4, 0x55, 0xe0, 0x9c, 0x27, 0xa7, 0x90, 0x80,
+ 0x92, 0x9f, 0x2f, 0xa8, 0x2b, 0x25, 0x87, 0xc1, 0x17, 0xea, 0x68, 0x4c, 0xdd, 0xb9, 0xf0, 0x25,
+ 0x46, 0xb7, 0xee, 0x68, 0xc5, 0xca, 0x3f, 0x4e, 0xad, 0xf8, 0x92, 0x2b, 0x5c, 0xa5, 0xc3, 0x8d,
+ 0x05, 0x1d, 0xa6, 0xd7, 0xd6, 0x02, 0x2c, 0x03, 0xb8, 0x38, 0xb0, 0x78, 0x00, 0x38, 0x05, 0x79,
+ 0x57, 0xa2, 0xa1, 0x28, 0x4d, 0x66, 0x91, 0x89, 0x4c, 0x43, 0xb2, 0xc2, 0x14, 0x1a, 0x52, 0x9d,
+ 0x36, 0x2a, 0xff, 0x91, 0x82, 0x73, 0xf2, 0x3b, 0x6f, 0x51, 0xed, 0x41, 0xa1, 0xed, 0xd4, 0xe2,
+ 0xea, 0x8f, 0x5f, 0x1f, 0x79, 0x21, 0x5f, 0x4d, 0x77, 0x2c, 0xcf, 0xd8, 0xdb, 0xb3, 0xcd, 0x3d,
+ 0x83, 0xd7, 0xe8, 0x54, 0xf0, 0x89, 0xcb, 0x28, 0x19, 0x21, 0x6f, 0x2b, 0xf9, 0x12, 0x57, 0x92,
+ 0xa1, 0x15, 0x6d, 0xc4, 0x00, 0xf4, 0x80, 0x9b, 0xf1, 0x38, 0x51, 0xec, 0x3b, 0x35, 0x2d, 0x27,
+ 0x04, 0x2e, 0xa0, 0xa2, 0xa4, 0x91, 0x8d, 0xde, 0x8e, 0x45, 0x5a, 0x54, 0x10, 0x15, 0x35, 0x01,
+ 0x84, 0x2f, 0x60, 0x31, 0x0b, 0x84, 0x4b, 0x16, 0xc5, 0x18, 0x93, 0xac, 0x97, 0xe4, 0x0d, 0x0d,
+ 0xb1, 0x09, 0xbe, 0x16, 0x51, 0x3d, 0x75, 0xac, 0x55, 0x95, 0xf9, 0xee, 0xca, 0xef, 0xfb, 0x3d,
+ 0xf1, 0xad, 0x32, 0x0e, 0x6c, 0x40, 0x39, 0xb7, 0xf4, 0x96, 0x57, 0xc0, 0x3b, 0x3d, 0xdb, 0xd4,
+ 0x52, 0x95, 0x36, 0x99, 0x63, 0xf2, 0x9b, 0x7d, 0xe2, 0x24, 0x56, 0xdc, 0xc0, 0xab, 0x0d, 0x0a,
+ 0x2f, 0xd2, 0x7e, 0x89, 0x21, 0x6e, 0x7f, 0x9c, 0xc1, 0xa5, 0xad, 0xf9, 0x9a, 0x55, 0xea, 0x8d,
+ 0xe5, 0xaa, 0x45, 0x34, 0xf8, 0x26, 0x0c, 0x7c, 0x4b, 0x18, 0xaf, 0xd3, 0x72, 0x1c, 0x99, 0x90,
+ 0x72, 0x74, 0xd7, 0x7c, 0x49, 0x25, 0xa7, 0xa3, 0xa5, 0x29, 0xed, 0x5e, 0x44, 0xe0, 0xb0, 0x8c,
+ 0xb8, 0x8e, 0x00, 0xd8, 0x64, 0x4f, 0x34, 0x4b, 0x21, 0x7e, 0x19, 0x85, 0x43, 0x37, 0xd4, 0xa1,
+ 0xc9, 0xae, 0xe9, 0xa6, 0x3a, 0x34, 0x81, 0xc2, 0xa1, 0x39, 0x69, 0x03, 0x96, 0x4b, 0xfd, 0x80,
+ 0xbc, 0x34, 0x46, 0x98, 0x4d, 0xe6, 0x83, 0x4c, 0xdc, 0x2f, 0x89, 0x17, 0xe1, 0x98, 0x2e, 0x66,
+ 0x6f, 0xa2, 0xbc, 0x5e, 0x81, 0xc3, 0x69, 0xb6, 0xd5, 0xc1, 0xb8, 0x0c, 0x39, 0x78, 0x47, 0x1d,
+ 0x9c, 0xc4, 0xe1, 0xe0, 0xcb, 0xfa, 0xed, 0xf8, 0x24, 0x12, 0xfa, 0xf5, 0xc3, 0xf7, 0x19, 0xfd,
+ 0x5e, 0x7c, 0x16, 0x2a, 0x0e, 0x87, 0x82, 0x02, 0xfe, 0x0e, 0xfd, 0x83, 0x03, 0xcc, 0xb8, 0x12,
+ 0x17, 0x32, 0xa8, 0x2d, 0xd8, 0xa8, 0x2d, 0x5d, 0x5e, 0x01, 0x18, 0x76, 0x0f, 0x29, 0xa7, 0xd2,
+ 0x52, 0x22, 0x59, 0x8a, 0x31, 0xed, 0xd6, 0x81, 0xd9, 0x35, 0x9d, 0xf8, 0x76, 0xc6, 0x9e, 0x92,
+ 0x2b, 0x69, 0x59, 0x65, 0x80, 0x4c, 0xa0, 0x78, 0xdb, 0xd6, 0xd1, 0xf2, 0x95, 0xcf, 0xb1, 0x1f,
+ 0x10, 0xdf, 0x3f, 0xc6, 0x2b, 0xc7, 0x22, 0x82, 0xaa, 0xfd, 0x31, 0x5c, 0xe5, 0x73, 0xd7, 0xeb,
+ 0xb4, 0xba, 0xe8, 0xd0, 0x53, 0x0a, 0xcc, 0x78, 0x89, 0xb0, 0x34, 0xd9, 0xe0, 0xf3, 0x15, 0x1d,
+ 0x8c, 0xef, 0x61, 0x31, 0xbc, 0x70, 0x01, 0x95, 0xf4, 0xb4, 0x66, 0x63, 0x3b, 0xa5, 0xdb, 0xab,
+ 0x35, 0x8d, 0xee, 0x9e, 0x29, 0x7b, 0xf9, 0x02, 0x61, 0x3e, 0xdf, 0x37, 0xda, 0xf2, 0x7e, 0x9a,
+ 0x80, 0x76, 0x0c, 0x07, 0x83, 0x57, 0x92, 0x18, 0x4b, 0xfa, 0x8c, 0x95, 0x3a, 0xdc, 0xe4, 0xff,
+ 0x5c, 0xfb, 0xb3, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xda, 0xf6, 0x7f, 0xb9, 0x63, 0x00,
+ 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/ponsim/ponsim.pb.go b/netopeer/voltha-grpc-client/voltha/ponsim/ponsim.pb.go
new file mode 100644
index 0000000..6831013
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/ponsim/ponsim.pb.go
@@ -0,0 +1,337 @@
+// Code generated by protoc-gen-go.
+// source: ponsim.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+ ponsim.proto
+
+It has these top-level messages:
+ PonSimDeviceInfo
+ FlowTable
+ PonSimPacketCounter
+ PonSimPortMetrics
+ PonSimMetrics
+*/
+package ponsim
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/ptypes/empty"
+import openflow_13 "github.com/opencord/voltha/netconf/translator/voltha/openflow_13"
+
+import (
+ context "golang.org/x/net/context"
+ grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type PonSimDeviceInfo struct {
+ NniPort int32 `protobuf:"varint,1,opt,name=nni_port,json=nniPort" json:"nni_port,omitempty"`
+ UniPorts []int32 `protobuf:"varint,2,rep,packed,name=uni_ports,json=uniPorts" json:"uni_ports,omitempty"`
+}
+
+func (m *PonSimDeviceInfo) Reset() { *m = PonSimDeviceInfo{} }
+func (m *PonSimDeviceInfo) String() string { return proto.CompactTextString(m) }
+func (*PonSimDeviceInfo) ProtoMessage() {}
+func (*PonSimDeviceInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *PonSimDeviceInfo) GetNniPort() int32 {
+ if m != nil {
+ return m.NniPort
+ }
+ return 0
+}
+
+func (m *PonSimDeviceInfo) GetUniPorts() []int32 {
+ if m != nil {
+ return m.UniPorts
+ }
+ return nil
+}
+
+type FlowTable struct {
+ Port int32 `protobuf:"varint,1,opt,name=port" json:"port,omitempty"`
+ Flows []*openflow_13.OfpFlowStats `protobuf:"bytes,2,rep,name=flows" json:"flows,omitempty"`
+}
+
+func (m *FlowTable) Reset() { *m = FlowTable{} }
+func (m *FlowTable) String() string { return proto.CompactTextString(m) }
+func (*FlowTable) ProtoMessage() {}
+func (*FlowTable) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *FlowTable) GetPort() int32 {
+ if m != nil {
+ return m.Port
+ }
+ return 0
+}
+
+func (m *FlowTable) GetFlows() []*openflow_13.OfpFlowStats {
+ if m != nil {
+ return m.Flows
+ }
+ return nil
+}
+
+type PonSimPacketCounter struct {
+ Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Value int64 `protobuf:"varint,2,opt,name=value" json:"value,omitempty"`
+}
+
+func (m *PonSimPacketCounter) Reset() { *m = PonSimPacketCounter{} }
+func (m *PonSimPacketCounter) String() string { return proto.CompactTextString(m) }
+func (*PonSimPacketCounter) ProtoMessage() {}
+func (*PonSimPacketCounter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *PonSimPacketCounter) GetName() string {
+ if m != nil {
+ return m.Name
+ }
+ return ""
+}
+
+func (m *PonSimPacketCounter) GetValue() int64 {
+ if m != nil {
+ return m.Value
+ }
+ return 0
+}
+
+type PonSimPortMetrics struct {
+ PortName string `protobuf:"bytes,1,opt,name=port_name,json=portName" json:"port_name,omitempty"`
+ Packets []*PonSimPacketCounter `protobuf:"bytes,2,rep,name=packets" json:"packets,omitempty"`
+}
+
+func (m *PonSimPortMetrics) Reset() { *m = PonSimPortMetrics{} }
+func (m *PonSimPortMetrics) String() string { return proto.CompactTextString(m) }
+func (*PonSimPortMetrics) ProtoMessage() {}
+func (*PonSimPortMetrics) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *PonSimPortMetrics) GetPortName() string {
+ if m != nil {
+ return m.PortName
+ }
+ return ""
+}
+
+func (m *PonSimPortMetrics) GetPackets() []*PonSimPacketCounter {
+ if m != nil {
+ return m.Packets
+ }
+ return nil
+}
+
+type PonSimMetrics struct {
+ Device string `protobuf:"bytes,1,opt,name=device" json:"device,omitempty"`
+ Metrics []*PonSimPortMetrics `protobuf:"bytes,2,rep,name=metrics" json:"metrics,omitempty"`
+}
+
+func (m *PonSimMetrics) Reset() { *m = PonSimMetrics{} }
+func (m *PonSimMetrics) String() string { return proto.CompactTextString(m) }
+func (*PonSimMetrics) ProtoMessage() {}
+func (*PonSimMetrics) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *PonSimMetrics) GetDevice() string {
+ if m != nil {
+ return m.Device
+ }
+ return ""
+}
+
+func (m *PonSimMetrics) GetMetrics() []*PonSimPortMetrics {
+ if m != nil {
+ return m.Metrics
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*PonSimDeviceInfo)(nil), "voltha.PonSimDeviceInfo")
+ proto.RegisterType((*FlowTable)(nil), "voltha.FlowTable")
+ proto.RegisterType((*PonSimPacketCounter)(nil), "voltha.PonSimPacketCounter")
+ proto.RegisterType((*PonSimPortMetrics)(nil), "voltha.PonSimPortMetrics")
+ proto.RegisterType((*PonSimMetrics)(nil), "voltha.PonSimMetrics")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for PonSim service
+
+type PonSimClient interface {
+ GetDeviceInfo(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*PonSimDeviceInfo, error)
+ UpdateFlowTable(ctx context.Context, in *FlowTable, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ GetStats(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*PonSimMetrics, error)
+}
+
+type ponSimClient struct {
+ cc *grpc.ClientConn
+}
+
+func NewPonSimClient(cc *grpc.ClientConn) PonSimClient {
+ return &ponSimClient{cc}
+}
+
+func (c *ponSimClient) GetDeviceInfo(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*PonSimDeviceInfo, error) {
+ out := new(PonSimDeviceInfo)
+ err := grpc.Invoke(ctx, "/voltha.PonSim/GetDeviceInfo", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *ponSimClient) UpdateFlowTable(ctx context.Context, in *FlowTable, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.PonSim/UpdateFlowTable", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *ponSimClient) GetStats(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*PonSimMetrics, error) {
+ out := new(PonSimMetrics)
+ err := grpc.Invoke(ctx, "/voltha.PonSim/GetStats", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// Server API for PonSim service
+
+type PonSimServer interface {
+ GetDeviceInfo(context.Context, *google_protobuf.Empty) (*PonSimDeviceInfo, error)
+ UpdateFlowTable(context.Context, *FlowTable) (*google_protobuf.Empty, error)
+ GetStats(context.Context, *google_protobuf.Empty) (*PonSimMetrics, error)
+}
+
+func RegisterPonSimServer(s *grpc.Server, srv PonSimServer) {
+ s.RegisterService(&_PonSim_serviceDesc, srv)
+}
+
+func _PonSim_GetDeviceInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(PonSimServer).GetDeviceInfo(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.PonSim/GetDeviceInfo",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(PonSimServer).GetDeviceInfo(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _PonSim_UpdateFlowTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(FlowTable)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(PonSimServer).UpdateFlowTable(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.PonSim/UpdateFlowTable",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(PonSimServer).UpdateFlowTable(ctx, req.(*FlowTable))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _PonSim_GetStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(PonSimServer).GetStats(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.PonSim/GetStats",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(PonSimServer).GetStats(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _PonSim_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "voltha.PonSim",
+ HandlerType: (*PonSimServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "GetDeviceInfo",
+ Handler: _PonSim_GetDeviceInfo_Handler,
+ },
+ {
+ MethodName: "UpdateFlowTable",
+ Handler: _PonSim_UpdateFlowTable_Handler,
+ },
+ {
+ MethodName: "GetStats",
+ Handler: _PonSim_GetStats_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "ponsim.proto",
+}
+
+func init() { proto.RegisterFile("ponsim.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 391 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0x41, 0x8f, 0xd3, 0x30,
+ 0x10, 0x85, 0x9b, 0x5d, 0x92, 0xa6, 0x03, 0x2b, 0xa8, 0x81, 0x55, 0x36, 0xbd, 0x54, 0x3e, 0xf5,
+ 0x94, 0xd5, 0xb6, 0xe2, 0x84, 0x04, 0x87, 0x02, 0x15, 0x48, 0xa0, 0xca, 0x85, 0x1b, 0x52, 0x94,
+ 0xb6, 0x4e, 0x89, 0x48, 0x3c, 0x56, 0xe2, 0xb4, 0xe2, 0x2f, 0xf2, 0xab, 0x90, 0xed, 0x84, 0xa4,
+ 0x88, 0xde, 0xc6, 0x33, 0xcf, 0xdf, 0x3c, 0xfb, 0xc1, 0x13, 0x89, 0xa2, 0xca, 0x8a, 0x48, 0x96,
+ 0xa8, 0x90, 0x78, 0x47, 0xcc, 0xd5, 0x8f, 0x24, 0x9c, 0x1c, 0x10, 0x0f, 0x39, 0xbf, 0x37, 0xdd,
+ 0x6d, 0x9d, 0xde, 0xf3, 0x42, 0xaa, 0x5f, 0x56, 0x14, 0x8e, 0x51, 0x72, 0x91, 0xe6, 0x78, 0x8a,
+ 0x1f, 0x16, 0xb6, 0x45, 0x3f, 0xc1, 0xb3, 0x35, 0x8a, 0x4d, 0x56, 0xbc, 0xe3, 0xc7, 0x6c, 0xc7,
+ 0x3f, 0x8a, 0x14, 0xc9, 0x1d, 0xf8, 0x42, 0x64, 0xb1, 0xc4, 0x52, 0x05, 0xce, 0xd4, 0x99, 0xb9,
+ 0x6c, 0x28, 0x44, 0xb6, 0xc6, 0x52, 0x91, 0x09, 0x8c, 0xea, 0x66, 0x54, 0x05, 0x57, 0xd3, 0xeb,
+ 0x99, 0xcb, 0xfc, 0xda, 0xce, 0x2a, 0xca, 0x60, 0xf4, 0x21, 0xc7, 0xd3, 0xd7, 0x64, 0x9b, 0x73,
+ 0x42, 0xe0, 0x51, 0x0f, 0x60, 0x6a, 0xf2, 0x00, 0xae, 0xde, 0x6e, 0x6f, 0x3e, 0x9e, 0x4f, 0xa2,
+ 0xbe, 0x1f, 0x4c, 0x65, 0x6c, 0xea, 0x4a, 0x25, 0xaa, 0x62, 0x56, 0x49, 0xdf, 0xc2, 0x73, 0xeb,
+ 0x6f, 0x9d, 0xec, 0x7e, 0x72, 0xb5, 0xc4, 0x5a, 0x28, 0x5e, 0x6a, 0xba, 0x48, 0x0a, 0x6e, 0xe8,
+ 0x23, 0x66, 0x6a, 0xf2, 0x02, 0xdc, 0x63, 0x92, 0xd7, 0x3c, 0xb8, 0x9a, 0x3a, 0xb3, 0x6b, 0x66,
+ 0x0f, 0xf4, 0x00, 0xe3, 0x06, 0x80, 0xa5, 0xfa, 0xcc, 0x55, 0x99, 0xed, 0x2a, 0xfd, 0x0c, 0x6d,
+ 0x28, 0xee, 0x31, 0x7c, 0xdd, 0xf8, 0xa2, 0x39, 0xaf, 0x60, 0x28, 0xcd, 0xb2, 0xce, 0xa7, 0xfd,
+ 0xdc, 0xe8, 0x3f, 0x4e, 0x58, 0xab, 0xa5, 0xdf, 0xe1, 0xc6, 0xce, 0xdb, 0x25, 0xb7, 0xe0, 0xed,
+ 0xcd, 0xa7, 0x36, 0x1b, 0x9a, 0x13, 0x59, 0xc0, 0xb0, 0xb0, 0x92, 0x86, 0x7f, 0xf7, 0x0f, 0xbf,
+ 0x33, 0xca, 0x5a, 0xe5, 0xfc, 0xb7, 0x03, 0x9e, 0x1d, 0x93, 0x25, 0xdc, 0xac, 0xb8, 0xea, 0xe5,
+ 0x75, 0x1b, 0xd9, 0xd0, 0xa3, 0x36, 0xf4, 0xe8, 0xbd, 0x0e, 0x3d, 0x0c, 0xce, 0xb9, 0xdd, 0x0d,
+ 0x3a, 0x20, 0x6f, 0xe0, 0xe9, 0x37, 0xb9, 0x4f, 0x14, 0xef, 0x12, 0x1b, 0xb7, 0xf2, 0xbf, 0xad,
+ 0xf0, 0x02, 0x99, 0x0e, 0xc8, 0x6b, 0xf0, 0x57, 0x5c, 0x6d, 0x74, 0x54, 0x17, 0xf7, 0xbf, 0x3c,
+ 0xdf, 0xdf, 0xbc, 0x89, 0x0e, 0xb6, 0x9e, 0x11, 0x2e, 0xfe, 0x04, 0x00, 0x00, 0xff, 0xff, 0x68,
+ 0x97, 0xc4, 0x14, 0xc3, 0x02, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/schema/schema.pb.go b/netopeer/voltha-grpc-client/voltha/schema/schema.pb.go
new file mode 100644
index 0000000..d46e1a4
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/schema/schema.pb.go
@@ -0,0 +1,208 @@
+// Code generated by protoc-gen-go.
+// source: schema.proto
+// DO NOT EDIT!
+
+/*
+Package schema is a generated protocol buffer package.
+
+It is generated from these files:
+ schema.proto
+
+It has these top-level messages:
+ ProtoFile
+ Schemas
+*/
+package schema
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf1 "github.com/golang/protobuf/ptypes/empty"
+
+import (
+ context "golang.org/x/net/context"
+ grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Contains the name and content of a *.proto file
+type ProtoFile struct {
+ FileName string `protobuf:"bytes,1,opt,name=file_name,json=fileName" json:"file_name,omitempty"`
+ Proto string `protobuf:"bytes,2,opt,name=proto" json:"proto,omitempty"`
+ Descriptor_ []byte `protobuf:"bytes,3,opt,name=descriptor,proto3" json:"descriptor,omitempty"`
+}
+
+func (m *ProtoFile) Reset() { *m = ProtoFile{} }
+func (m *ProtoFile) String() string { return proto.CompactTextString(m) }
+func (*ProtoFile) ProtoMessage() {}
+func (*ProtoFile) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *ProtoFile) GetFileName() string {
+ if m != nil {
+ return m.FileName
+ }
+ return ""
+}
+
+func (m *ProtoFile) GetProto() string {
+ if m != nil {
+ return m.Proto
+ }
+ return ""
+}
+
+func (m *ProtoFile) GetDescriptor_() []byte {
+ if m != nil {
+ return m.Descriptor_
+ }
+ return nil
+}
+
+// Proto files and compiled descriptors for this interface
+type Schemas struct {
+ // Proto files
+ Protos []*ProtoFile `protobuf:"bytes,1,rep,name=protos" json:"protos,omitempty"`
+ // Proto file name from which swagger.json shall be generated
+ SwaggerFrom string `protobuf:"bytes,2,opt,name=swagger_from,json=swaggerFrom" json:"swagger_from,omitempty"`
+ // Proto file name from which yang schemas shall be generated
+ YangFrom string `protobuf:"bytes,3,opt,name=yang_from,json=yangFrom" json:"yang_from,omitempty"`
+}
+
+func (m *Schemas) Reset() { *m = Schemas{} }
+func (m *Schemas) String() string { return proto.CompactTextString(m) }
+func (*Schemas) ProtoMessage() {}
+func (*Schemas) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *Schemas) GetProtos() []*ProtoFile {
+ if m != nil {
+ return m.Protos
+ }
+ return nil
+}
+
+func (m *Schemas) GetSwaggerFrom() string {
+ if m != nil {
+ return m.SwaggerFrom
+ }
+ return ""
+}
+
+func (m *Schemas) GetYangFrom() string {
+ if m != nil {
+ return m.YangFrom
+ }
+ return ""
+}
+
+func init() {
+ proto.RegisterType((*ProtoFile)(nil), "schema.ProtoFile")
+ proto.RegisterType((*Schemas)(nil), "schema.Schemas")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for SchemaService service
+
+type SchemaServiceClient interface {
+ // Return active grpc schemas
+ GetSchema(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*Schemas, error)
+}
+
+type schemaServiceClient struct {
+ cc *grpc.ClientConn
+}
+
+func NewSchemaServiceClient(cc *grpc.ClientConn) SchemaServiceClient {
+ return &schemaServiceClient{cc}
+}
+
+func (c *schemaServiceClient) GetSchema(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*Schemas, error) {
+ out := new(Schemas)
+ err := grpc.Invoke(ctx, "/schema.SchemaService/GetSchema", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// Server API for SchemaService service
+
+type SchemaServiceServer interface {
+ // Return active grpc schemas
+ GetSchema(context.Context, *google_protobuf1.Empty) (*Schemas, error)
+}
+
+func RegisterSchemaServiceServer(s *grpc.Server, srv SchemaServiceServer) {
+ s.RegisterService(&_SchemaService_serviceDesc, srv)
+}
+
+func _SchemaService_GetSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf1.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(SchemaServiceServer).GetSchema(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/schema.SchemaService/GetSchema",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(SchemaServiceServer).GetSchema(ctx, req.(*google_protobuf1.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _SchemaService_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "schema.SchemaService",
+ HandlerType: (*SchemaServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "GetSchema",
+ Handler: _SchemaService_GetSchema_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "schema.proto",
+}
+
+func init() { proto.RegisterFile("schema.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 278 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x90, 0xc1, 0x4a, 0xc3, 0x40,
+ 0x10, 0x86, 0x49, 0x8b, 0xad, 0x99, 0x56, 0x8a, 0x8b, 0x48, 0x48, 0x45, 0x62, 0x4e, 0xf1, 0x92,
+ 0x40, 0x7d, 0x86, 0xd6, 0x9b, 0x48, 0x0a, 0x1e, 0x2d, 0xdb, 0x38, 0x89, 0x0b, 0xd9, 0x6c, 0xd8,
+ 0x5d, 0x95, 0x5e, 0x7d, 0x05, 0x1f, 0xcd, 0x57, 0xf0, 0x41, 0x64, 0x33, 0x5b, 0xf1, 0xb6, 0xf3,
+ 0x7f, 0x33, 0xcc, 0xb7, 0x03, 0x73, 0x53, 0xbd, 0xa2, 0xe4, 0x79, 0xaf, 0x95, 0x55, 0x6c, 0x42,
+ 0x55, 0x7c, 0xd5, 0x28, 0xd5, 0xb4, 0x58, 0xf0, 0x5e, 0x14, 0xbc, 0xeb, 0x94, 0xe5, 0x56, 0xa8,
+ 0xce, 0x50, 0x57, 0xbc, 0xf4, 0x74, 0xa8, 0xf6, 0x6f, 0x75, 0x81, 0xb2, 0xb7, 0x07, 0x82, 0xe9,
+ 0x33, 0x84, 0x8f, 0xee, 0xb1, 0x11, 0x2d, 0xb2, 0x25, 0x84, 0xb5, 0x68, 0x71, 0xd7, 0x71, 0x89,
+ 0x51, 0x90, 0x04, 0x59, 0x58, 0x9e, 0xba, 0xe0, 0x81, 0x4b, 0x64, 0x17, 0x70, 0x32, 0x8c, 0x44,
+ 0xa3, 0x01, 0x50, 0xc1, 0xae, 0x01, 0x5e, 0xd0, 0x54, 0x5a, 0xf4, 0x56, 0xe9, 0x68, 0x9c, 0x04,
+ 0xd9, 0xbc, 0xfc, 0x97, 0xa4, 0x16, 0xa6, 0xdb, 0x41, 0xd2, 0xb0, 0x5b, 0x98, 0x0c, 0x33, 0x26,
+ 0x0a, 0x92, 0x71, 0x36, 0x5b, 0x9d, 0xe7, 0xfe, 0x33, 0x7f, 0x02, 0xa5, 0x6f, 0x60, 0x37, 0x30,
+ 0x37, 0x1f, 0xbc, 0x69, 0x50, 0xef, 0x6a, 0xad, 0xa4, 0x5f, 0x39, 0xf3, 0xd9, 0x46, 0x2b, 0xe9,
+ 0x5c, 0x0f, 0xbc, 0x6b, 0x88, 0x8f, 0xc9, 0xd5, 0x05, 0x0e, 0xae, 0x9e, 0xe0, 0x8c, 0xb6, 0x6e,
+ 0x51, 0xbf, 0x8b, 0x0a, 0xd9, 0x1a, 0xc2, 0x7b, 0xb4, 0x94, 0xb1, 0xcb, 0x9c, 0x2e, 0x92, 0x1f,
+ 0x2f, 0x92, 0xaf, 0xdd, 0x45, 0xe2, 0xc5, 0x51, 0xc8, 0x1b, 0xa7, 0x8b, 0xcf, 0xef, 0x9f, 0xaf,
+ 0x51, 0xc8, 0xa6, 0x05, 0x81, 0x3d, 0xf9, 0xdd, 0xfd, 0x06, 0x00, 0x00, 0xff, 0xff, 0xae, 0xf9,
+ 0x7e, 0x49, 0x87, 0x01, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/voltha.pb.go b/netopeer/voltha-grpc-client/voltha/voltha.pb.go
new file mode 100644
index 0000000..f1656f6
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/voltha.pb.go
@@ -0,0 +1,6114 @@
+// Code generated by protoc-gen-go.
+// source: voltha.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+ voltha.proto
+
+It has these top-level messages:
+ DeviceGroup
+ DeviceGroups
+ AlarmFilterRuleKey
+ AlarmFilterRule
+ AlarmFilter
+ AlarmFilters
+ VolthaInstance
+ VolthaInstances
+ Voltha
+*/
+package voltha
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/ptypes/empty"
+import _ "github.com/golang/protobuf/ptypes/any"
+import voltha2 "github.com/opencord/voltha/netconf/translator/voltha/meta"
+import voltha3 "github.com/opencord/voltha/netconf/translator/voltha/common"
+import voltha4 "github.com/opencord/voltha/netconf/translator/voltha/health"
+import voltha5 "github.com/opencord/voltha/netconf/translator/voltha/logical_device"
+import voltha6 "github.com/opencord/voltha/netconf/translator/voltha/device"
+import voltha7 "github.com/opencord/voltha/netconf/translator/voltha/adapter"
+import openflow_13 "github.com/opencord/voltha/netconf/translator/voltha/openflow_13"
+
+import (
+ context "golang.org/x/net/context"
+ grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// ChildNode from public import meta.proto
+type ChildNode voltha2.ChildNode
+
+func (m *ChildNode) Reset() { (*voltha2.ChildNode)(m).Reset() }
+func (m *ChildNode) String() string { return (*voltha2.ChildNode)(m).String() }
+func (*ChildNode) ProtoMessage() {}
+func (m *ChildNode) GetKey() string { return (*voltha2.ChildNode)(m).GetKey() }
+
+// Access from public import meta.proto
+type Access voltha2.Access
+
+var Access_name = voltha2.Access_name
+var Access_value = voltha2.Access_value
+
+func (x Access) String() string { return (voltha2.Access)(x).String() }
+
+const Access_CONFIG = Access(voltha2.Access_CONFIG)
+const Access_READ_ONLY = Access(voltha2.Access_READ_ONLY)
+const Access_REAL_TIME = Access(voltha2.Access_REAL_TIME)
+
+// child_node from public import meta.proto
+var E_ChildNode = voltha2.E_ChildNode
+
+// access from public import meta.proto
+var E_Access = voltha2.E_Access
+
+// ID from public import common.proto
+type ID voltha3.ID
+
+func (m *ID) Reset() { (*voltha3.ID)(m).Reset() }
+func (m *ID) String() string { return (*voltha3.ID)(m).String() }
+func (*ID) ProtoMessage() {}
+func (m *ID) GetId() string { return (*voltha3.ID)(m).GetId() }
+
+// LogLevel from public import common.proto
+type LogLevel voltha3.LogLevel
+
+func (m *LogLevel) Reset() { (*voltha3.LogLevel)(m).Reset() }
+func (m *LogLevel) String() string { return (*voltha3.LogLevel)(m).String() }
+func (*LogLevel) ProtoMessage() {}
+
+// AdminState from public import common.proto
+type AdminState voltha3.AdminState
+
+func (m *AdminState) Reset() { (*voltha3.AdminState)(m).Reset() }
+func (m *AdminState) String() string { return (*voltha3.AdminState)(m).String() }
+func (*AdminState) ProtoMessage() {}
+
+// OperStatus from public import common.proto
+type OperStatus voltha3.OperStatus
+
+func (m *OperStatus) Reset() { (*voltha3.OperStatus)(m).Reset() }
+func (m *OperStatus) String() string { return (*voltha3.OperStatus)(m).String() }
+func (*OperStatus) ProtoMessage() {}
+
+// ConnectStatus from public import common.proto
+type ConnectStatus voltha3.ConnectStatus
+
+func (m *ConnectStatus) Reset() { (*voltha3.ConnectStatus)(m).Reset() }
+func (m *ConnectStatus) String() string { return (*voltha3.ConnectStatus)(m).String() }
+func (*ConnectStatus) ProtoMessage() {}
+
+// LogLevel from public import common.proto
+type LogLevel_LogLevel voltha3.LogLevel_LogLevel
+
+var LogLevel_LogLevel_name = voltha3.LogLevel_LogLevel_name
+var LogLevel_LogLevel_value = voltha3.LogLevel_LogLevel_value
+
+func (x LogLevel_LogLevel) String() string { return (voltha3.LogLevel_LogLevel)(x).String() }
+
+const LogLevel_DEBUG = LogLevel_LogLevel(voltha3.LogLevel_DEBUG)
+const LogLevel_INFO = LogLevel_LogLevel(voltha3.LogLevel_INFO)
+const LogLevel_WARNING = LogLevel_LogLevel(voltha3.LogLevel_WARNING)
+const LogLevel_ERROR = LogLevel_LogLevel(voltha3.LogLevel_ERROR)
+const LogLevel_CRITICAL = LogLevel_LogLevel(voltha3.LogLevel_CRITICAL)
+
+// AdminState from public import common.proto
+type AdminState_AdminState voltha3.AdminState_AdminState
+
+var AdminState_AdminState_name = voltha3.AdminState_AdminState_name
+var AdminState_AdminState_value = voltha3.AdminState_AdminState_value
+
+func (x AdminState_AdminState) String() string { return (voltha3.AdminState_AdminState)(x).String() }
+
+const AdminState_UNKNOWN = AdminState_AdminState(voltha3.AdminState_UNKNOWN)
+const AdminState_PREPROVISIONED = AdminState_AdminState(voltha3.AdminState_PREPROVISIONED)
+const AdminState_ENABLED = AdminState_AdminState(voltha3.AdminState_ENABLED)
+const AdminState_DISABLED = AdminState_AdminState(voltha3.AdminState_DISABLED)
+
+// OperStatus from public import common.proto
+type OperStatus_OperStatus voltha3.OperStatus_OperStatus
+
+var OperStatus_OperStatus_name = voltha3.OperStatus_OperStatus_name
+var OperStatus_OperStatus_value = voltha3.OperStatus_OperStatus_value
+
+func (x OperStatus_OperStatus) String() string { return (voltha3.OperStatus_OperStatus)(x).String() }
+
+const OperStatus_UNKNOWN = OperStatus_OperStatus(voltha3.OperStatus_UNKNOWN)
+const OperStatus_DISCOVERED = OperStatus_OperStatus(voltha3.OperStatus_DISCOVERED)
+const OperStatus_ACTIVATING = OperStatus_OperStatus(voltha3.OperStatus_ACTIVATING)
+const OperStatus_TESTING = OperStatus_OperStatus(voltha3.OperStatus_TESTING)
+const OperStatus_ACTIVE = OperStatus_OperStatus(voltha3.OperStatus_ACTIVE)
+const OperStatus_FAILED = OperStatus_OperStatus(voltha3.OperStatus_FAILED)
+
+// ConnectStatus from public import common.proto
+type ConnectStatus_ConnectStatus voltha3.ConnectStatus_ConnectStatus
+
+var ConnectStatus_ConnectStatus_name = voltha3.ConnectStatus_ConnectStatus_name
+var ConnectStatus_ConnectStatus_value = voltha3.ConnectStatus_ConnectStatus_value
+
+func (x ConnectStatus_ConnectStatus) String() string {
+ return (voltha3.ConnectStatus_ConnectStatus)(x).String()
+}
+
+const ConnectStatus_UNKNOWN = ConnectStatus_ConnectStatus(voltha3.ConnectStatus_UNKNOWN)
+const ConnectStatus_UNREACHABLE = ConnectStatus_ConnectStatus(voltha3.ConnectStatus_UNREACHABLE)
+const ConnectStatus_REACHABLE = ConnectStatus_ConnectStatus(voltha3.ConnectStatus_REACHABLE)
+
+// HealthStatus from public import health.proto
+type HealthStatus voltha4.HealthStatus
+
+func (m *HealthStatus) Reset() { (*voltha4.HealthStatus)(m).Reset() }
+func (m *HealthStatus) String() string { return (*voltha4.HealthStatus)(m).String() }
+func (*HealthStatus) ProtoMessage() {}
+func (m *HealthStatus) GetState() HealthStatus_HealthState {
+ return (HealthStatus_HealthState)((*voltha4.HealthStatus)(m).GetState())
+}
+
+// HealthState from public import health.proto
+type HealthStatus_HealthState voltha4.HealthStatus_HealthState
+
+var HealthStatus_HealthState_name = voltha4.HealthStatus_HealthState_name
+var HealthStatus_HealthState_value = voltha4.HealthStatus_HealthState_value
+
+func (x HealthStatus_HealthState) String() string {
+ return (voltha4.HealthStatus_HealthState)(x).String()
+}
+
+const HealthStatus_HEALTHY = HealthStatus_HealthState(voltha4.HealthStatus_HEALTHY)
+const HealthStatus_OVERLOADED = HealthStatus_HealthState(voltha4.HealthStatus_OVERLOADED)
+const HealthStatus_DYING = HealthStatus_HealthState(voltha4.HealthStatus_DYING)
+
+// LogicalPort from public import logical_device.proto
+type LogicalPort voltha5.LogicalPort
+
+func (m *LogicalPort) Reset() { (*voltha5.LogicalPort)(m).Reset() }
+func (m *LogicalPort) String() string { return (*voltha5.LogicalPort)(m).String() }
+func (*LogicalPort) ProtoMessage() {}
+func (m *LogicalPort) GetId() string { return (*voltha5.LogicalPort)(m).GetId() }
+func (m *LogicalPort) GetDeviceId() string { return (*voltha5.LogicalPort)(m).GetDeviceId() }
+func (m *LogicalPort) GetDevicePortNo() uint32 { return (*voltha5.LogicalPort)(m).GetDevicePortNo() }
+func (m *LogicalPort) GetRootPort() bool { return (*voltha5.LogicalPort)(m).GetRootPort() }
+
+// LogicalPorts from public import logical_device.proto
+type LogicalPorts voltha5.LogicalPorts
+
+func (m *LogicalPorts) Reset() { (*voltha5.LogicalPorts)(m).Reset() }
+func (m *LogicalPorts) String() string { return (*voltha5.LogicalPorts)(m).String() }
+func (*LogicalPorts) ProtoMessage() {}
+func (m *LogicalPorts) GetItems() []*LogicalPort {
+ o := (*voltha5.LogicalPorts)(m).GetItems()
+ if o == nil {
+ return nil
+ }
+ s := make([]*LogicalPort, len(o))
+ for i, x := range o {
+ s[i] = (*LogicalPort)(x)
+ }
+ return s
+}
+
+// LogicalDevice from public import logical_device.proto
+type LogicalDevice voltha5.LogicalDevice
+
+func (m *LogicalDevice) Reset() { (*voltha5.LogicalDevice)(m).Reset() }
+func (m *LogicalDevice) String() string { return (*voltha5.LogicalDevice)(m).String() }
+func (*LogicalDevice) ProtoMessage() {}
+func (m *LogicalDevice) GetId() string { return (*voltha5.LogicalDevice)(m).GetId() }
+func (m *LogicalDevice) GetDatapathId() uint64 { return (*voltha5.LogicalDevice)(m).GetDatapathId() }
+func (m *LogicalDevice) GetRootDeviceId() string { return (*voltha5.LogicalDevice)(m).GetRootDeviceId() }
+func (m *LogicalDevice) GetPorts() []*LogicalPort {
+ o := (*voltha5.LogicalDevice)(m).GetPorts()
+ if o == nil {
+ return nil
+ }
+ s := make([]*LogicalPort, len(o))
+ for i, x := range o {
+ s[i] = (*LogicalPort)(x)
+ }
+ return s
+}
+
+// LogicalDevices from public import logical_device.proto
+type LogicalDevices voltha5.LogicalDevices
+
+func (m *LogicalDevices) Reset() { (*voltha5.LogicalDevices)(m).Reset() }
+func (m *LogicalDevices) String() string { return (*voltha5.LogicalDevices)(m).String() }
+func (*LogicalDevices) ProtoMessage() {}
+func (m *LogicalDevices) GetItems() []*LogicalDevice {
+ o := (*voltha5.LogicalDevices)(m).GetItems()
+ if o == nil {
+ return nil
+ }
+ s := make([]*LogicalDevice, len(o))
+ for i, x := range o {
+ s[i] = (*LogicalDevice)(x)
+ }
+ return s
+}
+
+// DeviceType from public import device.proto
+type DeviceType voltha6.DeviceType
+
+func (m *DeviceType) Reset() { (*voltha6.DeviceType)(m).Reset() }
+func (m *DeviceType) String() string { return (*voltha6.DeviceType)(m).String() }
+func (*DeviceType) ProtoMessage() {}
+func (m *DeviceType) GetId() string { return (*voltha6.DeviceType)(m).GetId() }
+func (m *DeviceType) GetAdapter() string { return (*voltha6.DeviceType)(m).GetAdapter() }
+func (m *DeviceType) GetAcceptsBulkFlowUpdate() bool {
+ return (*voltha6.DeviceType)(m).GetAcceptsBulkFlowUpdate()
+}
+func (m *DeviceType) GetAcceptsAddRemoveFlowUpdates() bool {
+ return (*voltha6.DeviceType)(m).GetAcceptsAddRemoveFlowUpdates()
+}
+
+// DeviceTypes from public import device.proto
+type DeviceTypes voltha6.DeviceTypes
+
+func (m *DeviceTypes) Reset() { (*voltha6.DeviceTypes)(m).Reset() }
+func (m *DeviceTypes) String() string { return (*voltha6.DeviceTypes)(m).String() }
+func (*DeviceTypes) ProtoMessage() {}
+func (m *DeviceTypes) GetItems() []*DeviceType {
+ o := (*voltha6.DeviceTypes)(m).GetItems()
+ if o == nil {
+ return nil
+ }
+ s := make([]*DeviceType, len(o))
+ for i, x := range o {
+ s[i] = (*DeviceType)(x)
+ }
+ return s
+}
+
+// PmConfig from public import device.proto
+type PmConfig voltha6.PmConfig
+
+func (m *PmConfig) Reset() { (*voltha6.PmConfig)(m).Reset() }
+func (m *PmConfig) String() string { return (*voltha6.PmConfig)(m).String() }
+func (*PmConfig) ProtoMessage() {}
+func (m *PmConfig) GetName() string { return (*voltha6.PmConfig)(m).GetName() }
+func (m *PmConfig) GetType() PmConfig_PmType {
+ return (PmConfig_PmType)((*voltha6.PmConfig)(m).GetType())
+}
+func (m *PmConfig) GetEnabled() bool { return (*voltha6.PmConfig)(m).GetEnabled() }
+func (m *PmConfig) GetSampleFreq() uint32 { return (*voltha6.PmConfig)(m).GetSampleFreq() }
+
+// PmGroupConfig from public import device.proto
+type PmGroupConfig voltha6.PmGroupConfig
+
+func (m *PmGroupConfig) Reset() { (*voltha6.PmGroupConfig)(m).Reset() }
+func (m *PmGroupConfig) String() string { return (*voltha6.PmGroupConfig)(m).String() }
+func (*PmGroupConfig) ProtoMessage() {}
+func (m *PmGroupConfig) GetGroupName() string { return (*voltha6.PmGroupConfig)(m).GetGroupName() }
+func (m *PmGroupConfig) GetGroupFreq() uint32 { return (*voltha6.PmGroupConfig)(m).GetGroupFreq() }
+func (m *PmGroupConfig) GetEnabled() bool { return (*voltha6.PmGroupConfig)(m).GetEnabled() }
+func (m *PmGroupConfig) GetMetrics() []*PmConfig {
+ o := (*voltha6.PmGroupConfig)(m).GetMetrics()
+ if o == nil {
+ return nil
+ }
+ s := make([]*PmConfig, len(o))
+ for i, x := range o {
+ s[i] = (*PmConfig)(x)
+ }
+ return s
+}
+
+// PmConfigs from public import device.proto
+type PmConfigs voltha6.PmConfigs
+
+func (m *PmConfigs) Reset() { (*voltha6.PmConfigs)(m).Reset() }
+func (m *PmConfigs) String() string { return (*voltha6.PmConfigs)(m).String() }
+func (*PmConfigs) ProtoMessage() {}
+func (m *PmConfigs) GetId() string { return (*voltha6.PmConfigs)(m).GetId() }
+func (m *PmConfigs) GetDefaultFreq() uint32 { return (*voltha6.PmConfigs)(m).GetDefaultFreq() }
+func (m *PmConfigs) GetGrouped() bool { return (*voltha6.PmConfigs)(m).GetGrouped() }
+func (m *PmConfigs) GetFreqOverride() bool { return (*voltha6.PmConfigs)(m).GetFreqOverride() }
+func (m *PmConfigs) GetGroups() []*PmGroupConfig {
+ o := (*voltha6.PmConfigs)(m).GetGroups()
+ if o == nil {
+ return nil
+ }
+ s := make([]*PmGroupConfig, len(o))
+ for i, x := range o {
+ s[i] = (*PmGroupConfig)(x)
+ }
+ return s
+}
+func (m *PmConfigs) GetMetrics() []*PmConfig {
+ o := (*voltha6.PmConfigs)(m).GetMetrics()
+ if o == nil {
+ return nil
+ }
+ s := make([]*PmConfig, len(o))
+ for i, x := range o {
+ s[i] = (*PmConfig)(x)
+ }
+ return s
+}
+
+// Port from public import device.proto
+type Port voltha6.Port
+
+func (m *Port) Reset() { (*voltha6.Port)(m).Reset() }
+func (m *Port) String() string { return (*voltha6.Port)(m).String() }
+func (*Port) ProtoMessage() {}
+func (m *Port) GetPortNo() uint32 { return (*voltha6.Port)(m).GetPortNo() }
+func (m *Port) GetLabel() string { return (*voltha6.Port)(m).GetLabel() }
+func (m *Port) GetType() Port_PortType { return (Port_PortType)((*voltha6.Port)(m).GetType()) }
+func (m *Port) GetDeviceId() string { return (*voltha6.Port)(m).GetDeviceId() }
+func (m *Port) GetPeers() []*Port_PeerPort {
+ o := (*voltha6.Port)(m).GetPeers()
+ if o == nil {
+ return nil
+ }
+ s := make([]*Port_PeerPort, len(o))
+ for i, x := range o {
+ s[i] = (*Port_PeerPort)(x)
+ }
+ return s
+}
+
+// PeerPort from public import device.proto
+type Port_PeerPort voltha6.Port_PeerPort
+
+func (m *Port_PeerPort) Reset() { (*voltha6.Port_PeerPort)(m).Reset() }
+func (m *Port_PeerPort) String() string { return (*voltha6.Port_PeerPort)(m).String() }
+func (*Port_PeerPort) ProtoMessage() {}
+func (m *Port_PeerPort) GetDeviceId() string { return (*voltha6.Port_PeerPort)(m).GetDeviceId() }
+func (m *Port_PeerPort) GetPortNo() uint32 { return (*voltha6.Port_PeerPort)(m).GetPortNo() }
+
+// Ports from public import device.proto
+type Ports voltha6.Ports
+
+func (m *Ports) Reset() { (*voltha6.Ports)(m).Reset() }
+func (m *Ports) String() string { return (*voltha6.Ports)(m).String() }
+func (*Ports) ProtoMessage() {}
+func (m *Ports) GetItems() []*Port {
+ o := (*voltha6.Ports)(m).GetItems()
+ if o == nil {
+ return nil
+ }
+ s := make([]*Port, len(o))
+ for i, x := range o {
+ s[i] = (*Port)(x)
+ }
+ return s
+}
+
+// Device from public import device.proto
+type Device voltha6.Device
+
+func (m *Device) Reset() { (*voltha6.Device)(m).Reset() }
+func (m *Device) String() string { return (*voltha6.Device)(m).String() }
+func (*Device) ProtoMessage() {}
+func (m *Device) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+ return _Device_OneofMarshaler, _Device_OneofUnmarshaler, _Device_OneofSizer, nil
+}
+func _Device_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*Device)
+ m0 := (*voltha6.Device)(m)
+ enc, _, _, _ := m0.XXX_OneofFuncs()
+ return enc(m0, b)
+}
+func _Device_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*Device)
+ m0 := (*voltha6.Device)(m)
+ _, dec, _, _ := m0.XXX_OneofFuncs()
+ return dec(m0, tag, wire, b)
+}
+func _Device_OneofSizer(msg proto.Message) int {
+ m := msg.(*Device)
+ m0 := (*voltha6.Device)(m)
+ _, _, size, _ := m0.XXX_OneofFuncs()
+ return size(m0)
+}
+func (m *Device) GetId() string { return (*voltha6.Device)(m).GetId() }
+func (m *Device) GetType() string { return (*voltha6.Device)(m).GetType() }
+func (m *Device) GetRoot() bool { return (*voltha6.Device)(m).GetRoot() }
+func (m *Device) GetParentId() string { return (*voltha6.Device)(m).GetParentId() }
+func (m *Device) GetParentPortNo() uint32 { return (*voltha6.Device)(m).GetParentPortNo() }
+func (m *Device) GetVendor() string { return (*voltha6.Device)(m).GetVendor() }
+func (m *Device) GetModel() string { return (*voltha6.Device)(m).GetModel() }
+func (m *Device) GetHardwareVersion() string { return (*voltha6.Device)(m).GetHardwareVersion() }
+func (m *Device) GetFirmwareVersion() string { return (*voltha6.Device)(m).GetFirmwareVersion() }
+func (m *Device) GetSoftwareVersion() string { return (*voltha6.Device)(m).GetSoftwareVersion() }
+func (m *Device) GetSerialNumber() string { return (*voltha6.Device)(m).GetSerialNumber() }
+func (m *Device) GetAdapter() string { return (*voltha6.Device)(m).GetAdapter() }
+func (m *Device) GetVlan() uint32 { return (*voltha6.Device)(m).GetVlan() }
+func (m *Device) GetMacAddress() string { return (*voltha6.Device)(m).GetMacAddress() }
+func (m *Device) GetIpv4Address() string { return (*voltha6.Device)(m).GetIpv4Address() }
+func (m *Device) GetIpv6Address() string { return (*voltha6.Device)(m).GetIpv6Address() }
+func (m *Device) GetHostAndPort() string { return (*voltha6.Device)(m).GetHostAndPort() }
+func (m *Device) GetProxyAddress() *Device_ProxyAddress {
+ return (*Device_ProxyAddress)((*voltha6.Device)(m).GetProxyAddress())
+}
+func (m *Device) GetReason() string { return (*voltha6.Device)(m).GetReason() }
+func (m *Device) GetPorts() []*Port {
+ o := (*voltha6.Device)(m).GetPorts()
+ if o == nil {
+ return nil
+ }
+ s := make([]*Port, len(o))
+ for i, x := range o {
+ s[i] = (*Port)(x)
+ }
+ return s
+}
+func (m *Device) GetPmConfigs() *PmConfigs { return (*PmConfigs)((*voltha6.Device)(m).GetPmConfigs()) }
+
+// ProxyAddress from public import device.proto
+type Device_ProxyAddress voltha6.Device_ProxyAddress
+
+func (m *Device_ProxyAddress) Reset() { (*voltha6.Device_ProxyAddress)(m).Reset() }
+func (m *Device_ProxyAddress) String() string { return (*voltha6.Device_ProxyAddress)(m).String() }
+func (*Device_ProxyAddress) ProtoMessage() {}
+func (m *Device_ProxyAddress) GetDeviceId() string {
+ return (*voltha6.Device_ProxyAddress)(m).GetDeviceId()
+}
+func (m *Device_ProxyAddress) GetChannelId() uint32 {
+ return (*voltha6.Device_ProxyAddress)(m).GetChannelId()
+}
+func (m *Device_ProxyAddress) GetOnuId() uint32 { return (*voltha6.Device_ProxyAddress)(m).GetOnuId() }
+func (m *Device_ProxyAddress) GetOnuSessionId() uint32 {
+ return (*voltha6.Device_ProxyAddress)(m).GetOnuSessionId()
+}
+
+// Devices from public import device.proto
+type Devices voltha6.Devices
+
+func (m *Devices) Reset() { (*voltha6.Devices)(m).Reset() }
+func (m *Devices) String() string { return (*voltha6.Devices)(m).String() }
+func (*Devices) ProtoMessage() {}
+func (m *Devices) GetItems() []*Device {
+ o := (*voltha6.Devices)(m).GetItems()
+ if o == nil {
+ return nil
+ }
+ s := make([]*Device, len(o))
+ for i, x := range o {
+ s[i] = (*Device)(x)
+ }
+ return s
+}
+
+// PmType from public import device.proto
+type PmConfig_PmType voltha6.PmConfig_PmType
+
+var PmConfig_PmType_name = voltha6.PmConfig_PmType_name
+var PmConfig_PmType_value = voltha6.PmConfig_PmType_value
+
+func (x PmConfig_PmType) String() string { return (voltha6.PmConfig_PmType)(x).String() }
+
+const PmConfig_COUNTER = PmConfig_PmType(voltha6.PmConfig_COUNTER)
+const PmConfig_GUAGE = PmConfig_PmType(voltha6.PmConfig_GUAGE)
+const PmConfig_STATE = PmConfig_PmType(voltha6.PmConfig_STATE)
+
+// PortType from public import device.proto
+type Port_PortType voltha6.Port_PortType
+
+var Port_PortType_name = voltha6.Port_PortType_name
+var Port_PortType_value = voltha6.Port_PortType_value
+
+func (x Port_PortType) String() string { return (voltha6.Port_PortType)(x).String() }
+
+const Port_UNKNOWN = Port_PortType(voltha6.Port_UNKNOWN)
+const Port_ETHERNET_NNI = Port_PortType(voltha6.Port_ETHERNET_NNI)
+const Port_ETHERNET_UNI = Port_PortType(voltha6.Port_ETHERNET_UNI)
+const Port_PON_OLT = Port_PortType(voltha6.Port_PON_OLT)
+const Port_PON_ONU = Port_PortType(voltha6.Port_PON_ONU)
+
+// AdapterConfig from public import adapter.proto
+type AdapterConfig voltha7.AdapterConfig
+
+func (m *AdapterConfig) Reset() { (*voltha7.AdapterConfig)(m).Reset() }
+func (m *AdapterConfig) String() string { return (*voltha7.AdapterConfig)(m).String() }
+func (*AdapterConfig) ProtoMessage() {}
+
+// Adapter from public import adapter.proto
+type Adapter voltha7.Adapter
+
+func (m *Adapter) Reset() { (*voltha7.Adapter)(m).Reset() }
+func (m *Adapter) String() string { return (*voltha7.Adapter)(m).String() }
+func (*Adapter) ProtoMessage() {}
+func (m *Adapter) GetId() string { return (*voltha7.Adapter)(m).GetId() }
+func (m *Adapter) GetVendor() string { return (*voltha7.Adapter)(m).GetVendor() }
+func (m *Adapter) GetVersion() string { return (*voltha7.Adapter)(m).GetVersion() }
+func (m *Adapter) GetConfig() *AdapterConfig {
+ return (*AdapterConfig)((*voltha7.Adapter)(m).GetConfig())
+}
+func (m *Adapter) GetLogicalDeviceIds() []string { return (*voltha7.Adapter)(m).GetLogicalDeviceIds() }
+
+// Adapters from public import adapter.proto
+type Adapters voltha7.Adapters
+
+func (m *Adapters) Reset() { (*voltha7.Adapters)(m).Reset() }
+func (m *Adapters) String() string { return (*voltha7.Adapters)(m).String() }
+func (*Adapters) ProtoMessage() {}
+func (m *Adapters) GetItems() []*Adapter {
+ o := (*voltha7.Adapters)(m).GetItems()
+ if o == nil {
+ return nil
+ }
+ s := make([]*Adapter, len(o))
+ for i, x := range o {
+ s[i] = (*Adapter)(x)
+ }
+ return s
+}
+
+// ofp_header from public import openflow_13.proto
+type OfpHeader openflow_13.OfpHeader
+
+func (m *OfpHeader) Reset() { (*openflow_13.OfpHeader)(m).Reset() }
+func (m *OfpHeader) String() string { return (*openflow_13.OfpHeader)(m).String() }
+func (*OfpHeader) ProtoMessage() {}
+func (m *OfpHeader) GetVersion() uint32 { return (*openflow_13.OfpHeader)(m).GetVersion() }
+func (m *OfpHeader) GetType() OfpType { return (OfpType)((*openflow_13.OfpHeader)(m).GetType()) }
+func (m *OfpHeader) GetXid() uint32 { return (*openflow_13.OfpHeader)(m).GetXid() }
+
+// ofp_hello_elem_header from public import openflow_13.proto
+type OfpHelloElemHeader openflow_13.OfpHelloElemHeader
+
+func (m *OfpHelloElemHeader) Reset() { (*openflow_13.OfpHelloElemHeader)(m).Reset() }
+func (m *OfpHelloElemHeader) String() string { return (*openflow_13.OfpHelloElemHeader)(m).String() }
+func (*OfpHelloElemHeader) ProtoMessage() {}
+func (m *OfpHelloElemHeader) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+ return _OfpHelloElemHeader_OneofMarshaler, _OfpHelloElemHeader_OneofUnmarshaler, _OfpHelloElemHeader_OneofSizer, nil
+}
+func _OfpHelloElemHeader_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpHelloElemHeader)
+ m0 := (*openflow_13.OfpHelloElemHeader)(m)
+ enc, _, _, _ := m0.XXX_OneofFuncs()
+ return enc(m0, b)
+}
+func _OfpHelloElemHeader_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpHelloElemHeader)
+ m0 := (*openflow_13.OfpHelloElemHeader)(m)
+ _, dec, _, _ := m0.XXX_OneofFuncs()
+ return dec(m0, tag, wire, b)
+}
+func _OfpHelloElemHeader_OneofSizer(msg proto.Message) int {
+ m := msg.(*OfpHelloElemHeader)
+ m0 := (*openflow_13.OfpHelloElemHeader)(m)
+ _, _, size, _ := m0.XXX_OneofFuncs()
+ return size(m0)
+}
+func (m *OfpHelloElemHeader) GetType() OfpHelloElemType {
+ return (OfpHelloElemType)((*openflow_13.OfpHelloElemHeader)(m).GetType())
+}
+func (m *OfpHelloElemHeader) GetVersionbitmap() *OfpHelloElemVersionbitmap {
+ return (*OfpHelloElemVersionbitmap)((*openflow_13.OfpHelloElemHeader)(m).GetVersionbitmap())
+}
+
+// ofp_hello_elem_versionbitmap from public import openflow_13.proto
+type OfpHelloElemVersionbitmap openflow_13.OfpHelloElemVersionbitmap
+
+func (m *OfpHelloElemVersionbitmap) Reset() { (*openflow_13.OfpHelloElemVersionbitmap)(m).Reset() }
+func (m *OfpHelloElemVersionbitmap) String() string {
+ return (*openflow_13.OfpHelloElemVersionbitmap)(m).String()
+}
+func (*OfpHelloElemVersionbitmap) ProtoMessage() {}
+func (m *OfpHelloElemVersionbitmap) GetBitmaps() []uint32 {
+ return (*openflow_13.OfpHelloElemVersionbitmap)(m).GetBitmaps()
+}
+
+// ofp_hello from public import openflow_13.proto
+type OfpHello openflow_13.OfpHello
+
+func (m *OfpHello) Reset() { (*openflow_13.OfpHello)(m).Reset() }
+func (m *OfpHello) String() string { return (*openflow_13.OfpHello)(m).String() }
+func (*OfpHello) ProtoMessage() {}
+func (m *OfpHello) GetElements() []*OfpHelloElemHeader {
+ o := (*openflow_13.OfpHello)(m).GetElements()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpHelloElemHeader, len(o))
+ for i, x := range o {
+ s[i] = (*OfpHelloElemHeader)(x)
+ }
+ return s
+}
+
+// ofp_switch_config from public import openflow_13.proto
+type OfpSwitchConfig openflow_13.OfpSwitchConfig
+
+func (m *OfpSwitchConfig) Reset() { (*openflow_13.OfpSwitchConfig)(m).Reset() }
+func (m *OfpSwitchConfig) String() string { return (*openflow_13.OfpSwitchConfig)(m).String() }
+func (*OfpSwitchConfig) ProtoMessage() {}
+func (m *OfpSwitchConfig) GetFlags() uint32 { return (*openflow_13.OfpSwitchConfig)(m).GetFlags() }
+func (m *OfpSwitchConfig) GetMissSendLen() uint32 {
+ return (*openflow_13.OfpSwitchConfig)(m).GetMissSendLen()
+}
+
+// ofp_table_mod from public import openflow_13.proto
+type OfpTableMod openflow_13.OfpTableMod
+
+func (m *OfpTableMod) Reset() { (*openflow_13.OfpTableMod)(m).Reset() }
+func (m *OfpTableMod) String() string { return (*openflow_13.OfpTableMod)(m).String() }
+func (*OfpTableMod) ProtoMessage() {}
+func (m *OfpTableMod) GetTableId() uint32 { return (*openflow_13.OfpTableMod)(m).GetTableId() }
+func (m *OfpTableMod) GetConfig() uint32 { return (*openflow_13.OfpTableMod)(m).GetConfig() }
+
+// ofp_port from public import openflow_13.proto
+type OfpPort openflow_13.OfpPort
+
+func (m *OfpPort) Reset() { (*openflow_13.OfpPort)(m).Reset() }
+func (m *OfpPort) String() string { return (*openflow_13.OfpPort)(m).String() }
+func (*OfpPort) ProtoMessage() {}
+func (m *OfpPort) GetPortNo() uint32 { return (*openflow_13.OfpPort)(m).GetPortNo() }
+func (m *OfpPort) GetHwAddr() []uint32 { return (*openflow_13.OfpPort)(m).GetHwAddr() }
+func (m *OfpPort) GetName() string { return (*openflow_13.OfpPort)(m).GetName() }
+func (m *OfpPort) GetConfig() uint32 { return (*openflow_13.OfpPort)(m).GetConfig() }
+func (m *OfpPort) GetState() uint32 { return (*openflow_13.OfpPort)(m).GetState() }
+func (m *OfpPort) GetCurr() uint32 { return (*openflow_13.OfpPort)(m).GetCurr() }
+func (m *OfpPort) GetAdvertised() uint32 { return (*openflow_13.OfpPort)(m).GetAdvertised() }
+func (m *OfpPort) GetSupported() uint32 { return (*openflow_13.OfpPort)(m).GetSupported() }
+func (m *OfpPort) GetPeer() uint32 { return (*openflow_13.OfpPort)(m).GetPeer() }
+func (m *OfpPort) GetCurrSpeed() uint32 { return (*openflow_13.OfpPort)(m).GetCurrSpeed() }
+func (m *OfpPort) GetMaxSpeed() uint32 { return (*openflow_13.OfpPort)(m).GetMaxSpeed() }
+
+// ofp_switch_features from public import openflow_13.proto
+type OfpSwitchFeatures openflow_13.OfpSwitchFeatures
+
+func (m *OfpSwitchFeatures) Reset() { (*openflow_13.OfpSwitchFeatures)(m).Reset() }
+func (m *OfpSwitchFeatures) String() string { return (*openflow_13.OfpSwitchFeatures)(m).String() }
+func (*OfpSwitchFeatures) ProtoMessage() {}
+func (m *OfpSwitchFeatures) GetDatapathId() uint64 {
+ return (*openflow_13.OfpSwitchFeatures)(m).GetDatapathId()
+}
+func (m *OfpSwitchFeatures) GetNBuffers() uint32 {
+ return (*openflow_13.OfpSwitchFeatures)(m).GetNBuffers()
+}
+func (m *OfpSwitchFeatures) GetNTables() uint32 {
+ return (*openflow_13.OfpSwitchFeatures)(m).GetNTables()
+}
+func (m *OfpSwitchFeatures) GetAuxiliaryId() uint32 {
+ return (*openflow_13.OfpSwitchFeatures)(m).GetAuxiliaryId()
+}
+func (m *OfpSwitchFeatures) GetCapabilities() uint32 {
+ return (*openflow_13.OfpSwitchFeatures)(m).GetCapabilities()
+}
+
+// ofp_port_status from public import openflow_13.proto
+type OfpPortStatus openflow_13.OfpPortStatus
+
+func (m *OfpPortStatus) Reset() { (*openflow_13.OfpPortStatus)(m).Reset() }
+func (m *OfpPortStatus) String() string { return (*openflow_13.OfpPortStatus)(m).String() }
+func (*OfpPortStatus) ProtoMessage() {}
+func (m *OfpPortStatus) GetReason() OfpPortReason {
+ return (OfpPortReason)((*openflow_13.OfpPortStatus)(m).GetReason())
+}
+func (m *OfpPortStatus) GetDesc() *OfpPort {
+ return (*OfpPort)((*openflow_13.OfpPortStatus)(m).GetDesc())
+}
+
+// ofp_port_mod from public import openflow_13.proto
+type OfpPortMod openflow_13.OfpPortMod
+
+func (m *OfpPortMod) Reset() { (*openflow_13.OfpPortMod)(m).Reset() }
+func (m *OfpPortMod) String() string { return (*openflow_13.OfpPortMod)(m).String() }
+func (*OfpPortMod) ProtoMessage() {}
+func (m *OfpPortMod) GetPortNo() uint32 { return (*openflow_13.OfpPortMod)(m).GetPortNo() }
+func (m *OfpPortMod) GetHwAddr() []uint32 { return (*openflow_13.OfpPortMod)(m).GetHwAddr() }
+func (m *OfpPortMod) GetConfig() uint32 { return (*openflow_13.OfpPortMod)(m).GetConfig() }
+func (m *OfpPortMod) GetMask() uint32 { return (*openflow_13.OfpPortMod)(m).GetMask() }
+func (m *OfpPortMod) GetAdvertise() uint32 { return (*openflow_13.OfpPortMod)(m).GetAdvertise() }
+
+// ofp_match from public import openflow_13.proto
+type OfpMatch openflow_13.OfpMatch
+
+func (m *OfpMatch) Reset() { (*openflow_13.OfpMatch)(m).Reset() }
+func (m *OfpMatch) String() string { return (*openflow_13.OfpMatch)(m).String() }
+func (*OfpMatch) ProtoMessage() {}
+func (m *OfpMatch) GetType() OfpMatchType { return (OfpMatchType)((*openflow_13.OfpMatch)(m).GetType()) }
+func (m *OfpMatch) GetOxmFields() []*OfpOxmField {
+ o := (*openflow_13.OfpMatch)(m).GetOxmFields()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpOxmField, len(o))
+ for i, x := range o {
+ s[i] = (*OfpOxmField)(x)
+ }
+ return s
+}
+
+// ofp_oxm_field from public import openflow_13.proto
+type OfpOxmField openflow_13.OfpOxmField
+
+func (m *OfpOxmField) Reset() { (*openflow_13.OfpOxmField)(m).Reset() }
+func (m *OfpOxmField) String() string { return (*openflow_13.OfpOxmField)(m).String() }
+func (*OfpOxmField) ProtoMessage() {}
+func (m *OfpOxmField) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+ return _OfpOxmField_OneofMarshaler, _OfpOxmField_OneofUnmarshaler, _OfpOxmField_OneofSizer, nil
+}
+func _OfpOxmField_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpOxmField)
+ m0 := (*openflow_13.OfpOxmField)(m)
+ enc, _, _, _ := m0.XXX_OneofFuncs()
+ return enc(m0, b)
+}
+func _OfpOxmField_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpOxmField)
+ m0 := (*openflow_13.OfpOxmField)(m)
+ _, dec, _, _ := m0.XXX_OneofFuncs()
+ return dec(m0, tag, wire, b)
+}
+func _OfpOxmField_OneofSizer(msg proto.Message) int {
+ m := msg.(*OfpOxmField)
+ m0 := (*openflow_13.OfpOxmField)(m)
+ _, _, size, _ := m0.XXX_OneofFuncs()
+ return size(m0)
+}
+func (m *OfpOxmField) GetOxmClass() OfpOxmClass {
+ return (OfpOxmClass)((*openflow_13.OfpOxmField)(m).GetOxmClass())
+}
+func (m *OfpOxmField) GetOfbField() *OfpOxmOfbField {
+ return (*OfpOxmOfbField)((*openflow_13.OfpOxmField)(m).GetOfbField())
+}
+func (m *OfpOxmField) GetExperimenterField() *OfpOxmExperimenterField {
+ return (*OfpOxmExperimenterField)((*openflow_13.OfpOxmField)(m).GetExperimenterField())
+}
+
+// ofp_oxm_ofb_field from public import openflow_13.proto
+type OfpOxmOfbField openflow_13.OfpOxmOfbField
+
+func (m *OfpOxmOfbField) Reset() { (*openflow_13.OfpOxmOfbField)(m).Reset() }
+func (m *OfpOxmOfbField) String() string { return (*openflow_13.OfpOxmOfbField)(m).String() }
+func (*OfpOxmOfbField) ProtoMessage() {}
+func (m *OfpOxmOfbField) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+ return _OfpOxmOfbField_OneofMarshaler, _OfpOxmOfbField_OneofUnmarshaler, _OfpOxmOfbField_OneofSizer, nil
+}
+func _OfpOxmOfbField_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpOxmOfbField)
+ m0 := (*openflow_13.OfpOxmOfbField)(m)
+ enc, _, _, _ := m0.XXX_OneofFuncs()
+ return enc(m0, b)
+}
+func _OfpOxmOfbField_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpOxmOfbField)
+ m0 := (*openflow_13.OfpOxmOfbField)(m)
+ _, dec, _, _ := m0.XXX_OneofFuncs()
+ return dec(m0, tag, wire, b)
+}
+func _OfpOxmOfbField_OneofSizer(msg proto.Message) int {
+ m := msg.(*OfpOxmOfbField)
+ m0 := (*openflow_13.OfpOxmOfbField)(m)
+ _, _, size, _ := m0.XXX_OneofFuncs()
+ return size(m0)
+}
+func (m *OfpOxmOfbField) GetType() OxmOfbFieldTypes {
+ return (OxmOfbFieldTypes)((*openflow_13.OfpOxmOfbField)(m).GetType())
+}
+func (m *OfpOxmOfbField) GetHasMask() bool { return (*openflow_13.OfpOxmOfbField)(m).GetHasMask() }
+func (m *OfpOxmOfbField) GetPort() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetPort() }
+func (m *OfpOxmOfbField) GetPhysicalPort() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetPhysicalPort()
+}
+func (m *OfpOxmOfbField) GetTableMetadata() uint64 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetTableMetadata()
+}
+func (m *OfpOxmOfbField) GetEthDst() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetEthDst() }
+func (m *OfpOxmOfbField) GetEthSrc() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetEthSrc() }
+func (m *OfpOxmOfbField) GetEthType() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetEthType() }
+func (m *OfpOxmOfbField) GetVlanVid() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetVlanVid() }
+func (m *OfpOxmOfbField) GetVlanPcp() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetVlanPcp() }
+func (m *OfpOxmOfbField) GetIpDscp() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetIpDscp() }
+func (m *OfpOxmOfbField) GetIpEcn() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetIpEcn() }
+func (m *OfpOxmOfbField) GetIpProto() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetIpProto() }
+func (m *OfpOxmOfbField) GetIpv4Src() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetIpv4Src() }
+func (m *OfpOxmOfbField) GetIpv4Dst() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetIpv4Dst() }
+func (m *OfpOxmOfbField) GetTcpSrc() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetTcpSrc() }
+func (m *OfpOxmOfbField) GetTcpDst() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetTcpDst() }
+func (m *OfpOxmOfbField) GetUdpSrc() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetUdpSrc() }
+func (m *OfpOxmOfbField) GetUdpDst() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetUdpDst() }
+func (m *OfpOxmOfbField) GetSctpSrc() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetSctpSrc() }
+func (m *OfpOxmOfbField) GetSctpDst() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetSctpDst() }
+func (m *OfpOxmOfbField) GetIcmpv4Type() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIcmpv4Type()
+}
+func (m *OfpOxmOfbField) GetIcmpv4Code() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIcmpv4Code()
+}
+func (m *OfpOxmOfbField) GetArpOp() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetArpOp() }
+func (m *OfpOxmOfbField) GetArpSpa() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetArpSpa() }
+func (m *OfpOxmOfbField) GetArpTpa() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetArpTpa() }
+func (m *OfpOxmOfbField) GetArpSha() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetArpSha() }
+func (m *OfpOxmOfbField) GetArpTha() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetArpTha() }
+func (m *OfpOxmOfbField) GetIpv6Src() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetIpv6Src() }
+func (m *OfpOxmOfbField) GetIpv6Dst() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetIpv6Dst() }
+func (m *OfpOxmOfbField) GetIpv6Flabel() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIpv6Flabel()
+}
+func (m *OfpOxmOfbField) GetIcmpv6Type() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIcmpv6Type()
+}
+func (m *OfpOxmOfbField) GetIcmpv6Code() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIcmpv6Code()
+}
+func (m *OfpOxmOfbField) GetIpv6NdTarget() []byte {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIpv6NdTarget()
+}
+func (m *OfpOxmOfbField) GetIpv6NdSsl() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetIpv6NdSsl() }
+func (m *OfpOxmOfbField) GetIpv6NdTll() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetIpv6NdTll() }
+func (m *OfpOxmOfbField) GetMplsLabel() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetMplsLabel() }
+func (m *OfpOxmOfbField) GetMplsTc() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetMplsTc() }
+func (m *OfpOxmOfbField) GetMplsBos() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetMplsBos() }
+func (m *OfpOxmOfbField) GetPbbIsid() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetPbbIsid() }
+func (m *OfpOxmOfbField) GetTunnelId() uint64 { return (*openflow_13.OfpOxmOfbField)(m).GetTunnelId() }
+func (m *OfpOxmOfbField) GetIpv6Exthdr() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIpv6Exthdr()
+}
+func (m *OfpOxmOfbField) GetTableMetadataMask() uint64 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetTableMetadataMask()
+}
+func (m *OfpOxmOfbField) GetEthDstMask() []byte {
+ return (*openflow_13.OfpOxmOfbField)(m).GetEthDstMask()
+}
+func (m *OfpOxmOfbField) GetEthSrcMask() []byte {
+ return (*openflow_13.OfpOxmOfbField)(m).GetEthSrcMask()
+}
+func (m *OfpOxmOfbField) GetVlanVidMask() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetVlanVidMask()
+}
+func (m *OfpOxmOfbField) GetIpv4SrcMask() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIpv4SrcMask()
+}
+func (m *OfpOxmOfbField) GetIpv4DstMask() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIpv4DstMask()
+}
+func (m *OfpOxmOfbField) GetArpSpaMask() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetArpSpaMask()
+}
+func (m *OfpOxmOfbField) GetArpTpaMask() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetArpTpaMask()
+}
+func (m *OfpOxmOfbField) GetIpv6SrcMask() []byte {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIpv6SrcMask()
+}
+func (m *OfpOxmOfbField) GetIpv6DstMask() []byte {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIpv6DstMask()
+}
+func (m *OfpOxmOfbField) GetIpv6FlabelMask() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIpv6FlabelMask()
+}
+func (m *OfpOxmOfbField) GetPbbIsidMask() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetPbbIsidMask()
+}
+func (m *OfpOxmOfbField) GetTunnelIdMask() uint64 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetTunnelIdMask()
+}
+func (m *OfpOxmOfbField) GetIpv6ExthdrMask() uint32 {
+ return (*openflow_13.OfpOxmOfbField)(m).GetIpv6ExthdrMask()
+}
+
+// ofp_oxm_experimenter_field from public import openflow_13.proto
+type OfpOxmExperimenterField openflow_13.OfpOxmExperimenterField
+
+func (m *OfpOxmExperimenterField) Reset() { (*openflow_13.OfpOxmExperimenterField)(m).Reset() }
+func (m *OfpOxmExperimenterField) String() string {
+ return (*openflow_13.OfpOxmExperimenterField)(m).String()
+}
+func (*OfpOxmExperimenterField) ProtoMessage() {}
+func (m *OfpOxmExperimenterField) GetOxmHeader() uint32 {
+ return (*openflow_13.OfpOxmExperimenterField)(m).GetOxmHeader()
+}
+func (m *OfpOxmExperimenterField) GetExperimenter() uint32 {
+ return (*openflow_13.OfpOxmExperimenterField)(m).GetExperimenter()
+}
+
+// ofp_action from public import openflow_13.proto
+type OfpAction openflow_13.OfpAction
+
+func (m *OfpAction) Reset() { (*openflow_13.OfpAction)(m).Reset() }
+func (m *OfpAction) String() string { return (*openflow_13.OfpAction)(m).String() }
+func (*OfpAction) ProtoMessage() {}
+func (m *OfpAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+ return _OfpAction_OneofMarshaler, _OfpAction_OneofUnmarshaler, _OfpAction_OneofSizer, nil
+}
+func _OfpAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpAction)
+ m0 := (*openflow_13.OfpAction)(m)
+ enc, _, _, _ := m0.XXX_OneofFuncs()
+ return enc(m0, b)
+}
+func _OfpAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpAction)
+ m0 := (*openflow_13.OfpAction)(m)
+ _, dec, _, _ := m0.XXX_OneofFuncs()
+ return dec(m0, tag, wire, b)
+}
+func _OfpAction_OneofSizer(msg proto.Message) int {
+ m := msg.(*OfpAction)
+ m0 := (*openflow_13.OfpAction)(m)
+ _, _, size, _ := m0.XXX_OneofFuncs()
+ return size(m0)
+}
+func (m *OfpAction) GetType() OfpActionType {
+ return (OfpActionType)((*openflow_13.OfpAction)(m).GetType())
+}
+func (m *OfpAction) GetOutput() *OfpActionOutput {
+ return (*OfpActionOutput)((*openflow_13.OfpAction)(m).GetOutput())
+}
+func (m *OfpAction) GetMplsTtl() *OfpActionMplsTtl {
+ return (*OfpActionMplsTtl)((*openflow_13.OfpAction)(m).GetMplsTtl())
+}
+func (m *OfpAction) GetPush() *OfpActionPush {
+ return (*OfpActionPush)((*openflow_13.OfpAction)(m).GetPush())
+}
+func (m *OfpAction) GetPopMpls() *OfpActionPopMpls {
+ return (*OfpActionPopMpls)((*openflow_13.OfpAction)(m).GetPopMpls())
+}
+func (m *OfpAction) GetGroup() *OfpActionGroup {
+ return (*OfpActionGroup)((*openflow_13.OfpAction)(m).GetGroup())
+}
+func (m *OfpAction) GetNwTtl() *OfpActionNwTtl {
+ return (*OfpActionNwTtl)((*openflow_13.OfpAction)(m).GetNwTtl())
+}
+func (m *OfpAction) GetSetField() *OfpActionSetField {
+ return (*OfpActionSetField)((*openflow_13.OfpAction)(m).GetSetField())
+}
+func (m *OfpAction) GetExperimenter() *OfpActionExperimenter {
+ return (*OfpActionExperimenter)((*openflow_13.OfpAction)(m).GetExperimenter())
+}
+
+// ofp_action_output from public import openflow_13.proto
+type OfpActionOutput openflow_13.OfpActionOutput
+
+func (m *OfpActionOutput) Reset() { (*openflow_13.OfpActionOutput)(m).Reset() }
+func (m *OfpActionOutput) String() string { return (*openflow_13.OfpActionOutput)(m).String() }
+func (*OfpActionOutput) ProtoMessage() {}
+func (m *OfpActionOutput) GetPort() uint32 { return (*openflow_13.OfpActionOutput)(m).GetPort() }
+func (m *OfpActionOutput) GetMaxLen() uint32 { return (*openflow_13.OfpActionOutput)(m).GetMaxLen() }
+
+// ofp_action_mpls_ttl from public import openflow_13.proto
+type OfpActionMplsTtl openflow_13.OfpActionMplsTtl
+
+func (m *OfpActionMplsTtl) Reset() { (*openflow_13.OfpActionMplsTtl)(m).Reset() }
+func (m *OfpActionMplsTtl) String() string { return (*openflow_13.OfpActionMplsTtl)(m).String() }
+func (*OfpActionMplsTtl) ProtoMessage() {}
+func (m *OfpActionMplsTtl) GetMplsTtl() uint32 { return (*openflow_13.OfpActionMplsTtl)(m).GetMplsTtl() }
+
+// ofp_action_push from public import openflow_13.proto
+type OfpActionPush openflow_13.OfpActionPush
+
+func (m *OfpActionPush) Reset() { (*openflow_13.OfpActionPush)(m).Reset() }
+func (m *OfpActionPush) String() string { return (*openflow_13.OfpActionPush)(m).String() }
+func (*OfpActionPush) ProtoMessage() {}
+func (m *OfpActionPush) GetEthertype() uint32 { return (*openflow_13.OfpActionPush)(m).GetEthertype() }
+
+// ofp_action_pop_mpls from public import openflow_13.proto
+type OfpActionPopMpls openflow_13.OfpActionPopMpls
+
+func (m *OfpActionPopMpls) Reset() { (*openflow_13.OfpActionPopMpls)(m).Reset() }
+func (m *OfpActionPopMpls) String() string { return (*openflow_13.OfpActionPopMpls)(m).String() }
+func (*OfpActionPopMpls) ProtoMessage() {}
+func (m *OfpActionPopMpls) GetEthertype() uint32 {
+ return (*openflow_13.OfpActionPopMpls)(m).GetEthertype()
+}
+
+// ofp_action_group from public import openflow_13.proto
+type OfpActionGroup openflow_13.OfpActionGroup
+
+func (m *OfpActionGroup) Reset() { (*openflow_13.OfpActionGroup)(m).Reset() }
+func (m *OfpActionGroup) String() string { return (*openflow_13.OfpActionGroup)(m).String() }
+func (*OfpActionGroup) ProtoMessage() {}
+func (m *OfpActionGroup) GetGroupId() uint32 { return (*openflow_13.OfpActionGroup)(m).GetGroupId() }
+
+// ofp_action_nw_ttl from public import openflow_13.proto
+type OfpActionNwTtl openflow_13.OfpActionNwTtl
+
+func (m *OfpActionNwTtl) Reset() { (*openflow_13.OfpActionNwTtl)(m).Reset() }
+func (m *OfpActionNwTtl) String() string { return (*openflow_13.OfpActionNwTtl)(m).String() }
+func (*OfpActionNwTtl) ProtoMessage() {}
+func (m *OfpActionNwTtl) GetNwTtl() uint32 { return (*openflow_13.OfpActionNwTtl)(m).GetNwTtl() }
+
+// ofp_action_set_field from public import openflow_13.proto
+type OfpActionSetField openflow_13.OfpActionSetField
+
+func (m *OfpActionSetField) Reset() { (*openflow_13.OfpActionSetField)(m).Reset() }
+func (m *OfpActionSetField) String() string { return (*openflow_13.OfpActionSetField)(m).String() }
+func (*OfpActionSetField) ProtoMessage() {}
+func (m *OfpActionSetField) GetField() *OfpOxmField {
+ return (*OfpOxmField)((*openflow_13.OfpActionSetField)(m).GetField())
+}
+
+// ofp_action_experimenter from public import openflow_13.proto
+type OfpActionExperimenter openflow_13.OfpActionExperimenter
+
+func (m *OfpActionExperimenter) Reset() { (*openflow_13.OfpActionExperimenter)(m).Reset() }
+func (m *OfpActionExperimenter) String() string {
+ return (*openflow_13.OfpActionExperimenter)(m).String()
+}
+func (*OfpActionExperimenter) ProtoMessage() {}
+func (m *OfpActionExperimenter) GetExperimenter() uint32 {
+ return (*openflow_13.OfpActionExperimenter)(m).GetExperimenter()
+}
+func (m *OfpActionExperimenter) GetData() []byte {
+ return (*openflow_13.OfpActionExperimenter)(m).GetData()
+}
+
+// ofp_instruction from public import openflow_13.proto
+type OfpInstruction openflow_13.OfpInstruction
+
+func (m *OfpInstruction) Reset() { (*openflow_13.OfpInstruction)(m).Reset() }
+func (m *OfpInstruction) String() string { return (*openflow_13.OfpInstruction)(m).String() }
+func (*OfpInstruction) ProtoMessage() {}
+func (m *OfpInstruction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+ return _OfpInstruction_OneofMarshaler, _OfpInstruction_OneofUnmarshaler, _OfpInstruction_OneofSizer, nil
+}
+func _OfpInstruction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpInstruction)
+ m0 := (*openflow_13.OfpInstruction)(m)
+ enc, _, _, _ := m0.XXX_OneofFuncs()
+ return enc(m0, b)
+}
+func _OfpInstruction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpInstruction)
+ m0 := (*openflow_13.OfpInstruction)(m)
+ _, dec, _, _ := m0.XXX_OneofFuncs()
+ return dec(m0, tag, wire, b)
+}
+func _OfpInstruction_OneofSizer(msg proto.Message) int {
+ m := msg.(*OfpInstruction)
+ m0 := (*openflow_13.OfpInstruction)(m)
+ _, _, size, _ := m0.XXX_OneofFuncs()
+ return size(m0)
+}
+func (m *OfpInstruction) GetType() uint32 { return (*openflow_13.OfpInstruction)(m).GetType() }
+func (m *OfpInstruction) GetGotoTable() *OfpInstructionGotoTable {
+ return (*OfpInstructionGotoTable)((*openflow_13.OfpInstruction)(m).GetGotoTable())
+}
+func (m *OfpInstruction) GetWriteMetadata() *OfpInstructionWriteMetadata {
+ return (*OfpInstructionWriteMetadata)((*openflow_13.OfpInstruction)(m).GetWriteMetadata())
+}
+func (m *OfpInstruction) GetActions() *OfpInstructionActions {
+ return (*OfpInstructionActions)((*openflow_13.OfpInstruction)(m).GetActions())
+}
+func (m *OfpInstruction) GetMeter() *OfpInstructionMeter {
+ return (*OfpInstructionMeter)((*openflow_13.OfpInstruction)(m).GetMeter())
+}
+func (m *OfpInstruction) GetExperimenter() *OfpInstructionExperimenter {
+ return (*OfpInstructionExperimenter)((*openflow_13.OfpInstruction)(m).GetExperimenter())
+}
+
+// ofp_instruction_goto_table from public import openflow_13.proto
+type OfpInstructionGotoTable openflow_13.OfpInstructionGotoTable
+
+func (m *OfpInstructionGotoTable) Reset() { (*openflow_13.OfpInstructionGotoTable)(m).Reset() }
+func (m *OfpInstructionGotoTable) String() string {
+ return (*openflow_13.OfpInstructionGotoTable)(m).String()
+}
+func (*OfpInstructionGotoTable) ProtoMessage() {}
+func (m *OfpInstructionGotoTable) GetTableId() uint32 {
+ return (*openflow_13.OfpInstructionGotoTable)(m).GetTableId()
+}
+
+// ofp_instruction_write_metadata from public import openflow_13.proto
+type OfpInstructionWriteMetadata openflow_13.OfpInstructionWriteMetadata
+
+func (m *OfpInstructionWriteMetadata) Reset() { (*openflow_13.OfpInstructionWriteMetadata)(m).Reset() }
+func (m *OfpInstructionWriteMetadata) String() string {
+ return (*openflow_13.OfpInstructionWriteMetadata)(m).String()
+}
+func (*OfpInstructionWriteMetadata) ProtoMessage() {}
+func (m *OfpInstructionWriteMetadata) GetMetadata() uint64 {
+ return (*openflow_13.OfpInstructionWriteMetadata)(m).GetMetadata()
+}
+func (m *OfpInstructionWriteMetadata) GetMetadataMask() uint64 {
+ return (*openflow_13.OfpInstructionWriteMetadata)(m).GetMetadataMask()
+}
+
+// ofp_instruction_actions from public import openflow_13.proto
+type OfpInstructionActions openflow_13.OfpInstructionActions
+
+func (m *OfpInstructionActions) Reset() { (*openflow_13.OfpInstructionActions)(m).Reset() }
+func (m *OfpInstructionActions) String() string {
+ return (*openflow_13.OfpInstructionActions)(m).String()
+}
+func (*OfpInstructionActions) ProtoMessage() {}
+func (m *OfpInstructionActions) GetActions() []*OfpAction {
+ o := (*openflow_13.OfpInstructionActions)(m).GetActions()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpAction, len(o))
+ for i, x := range o {
+ s[i] = (*OfpAction)(x)
+ }
+ return s
+}
+
+// ofp_instruction_meter from public import openflow_13.proto
+type OfpInstructionMeter openflow_13.OfpInstructionMeter
+
+func (m *OfpInstructionMeter) Reset() { (*openflow_13.OfpInstructionMeter)(m).Reset() }
+func (m *OfpInstructionMeter) String() string { return (*openflow_13.OfpInstructionMeter)(m).String() }
+func (*OfpInstructionMeter) ProtoMessage() {}
+func (m *OfpInstructionMeter) GetMeterId() uint32 {
+ return (*openflow_13.OfpInstructionMeter)(m).GetMeterId()
+}
+
+// ofp_instruction_experimenter from public import openflow_13.proto
+type OfpInstructionExperimenter openflow_13.OfpInstructionExperimenter
+
+func (m *OfpInstructionExperimenter) Reset() { (*openflow_13.OfpInstructionExperimenter)(m).Reset() }
+func (m *OfpInstructionExperimenter) String() string {
+ return (*openflow_13.OfpInstructionExperimenter)(m).String()
+}
+func (*OfpInstructionExperimenter) ProtoMessage() {}
+func (m *OfpInstructionExperimenter) GetExperimenter() uint32 {
+ return (*openflow_13.OfpInstructionExperimenter)(m).GetExperimenter()
+}
+func (m *OfpInstructionExperimenter) GetData() []byte {
+ return (*openflow_13.OfpInstructionExperimenter)(m).GetData()
+}
+
+// ofp_flow_mod from public import openflow_13.proto
+type OfpFlowMod openflow_13.OfpFlowMod
+
+func (m *OfpFlowMod) Reset() { (*openflow_13.OfpFlowMod)(m).Reset() }
+func (m *OfpFlowMod) String() string { return (*openflow_13.OfpFlowMod)(m).String() }
+func (*OfpFlowMod) ProtoMessage() {}
+func (m *OfpFlowMod) GetCookie() uint64 { return (*openflow_13.OfpFlowMod)(m).GetCookie() }
+func (m *OfpFlowMod) GetCookieMask() uint64 { return (*openflow_13.OfpFlowMod)(m).GetCookieMask() }
+func (m *OfpFlowMod) GetTableId() uint32 { return (*openflow_13.OfpFlowMod)(m).GetTableId() }
+func (m *OfpFlowMod) GetCommand() OfpFlowModCommand {
+ return (OfpFlowModCommand)((*openflow_13.OfpFlowMod)(m).GetCommand())
+}
+func (m *OfpFlowMod) GetIdleTimeout() uint32 { return (*openflow_13.OfpFlowMod)(m).GetIdleTimeout() }
+func (m *OfpFlowMod) GetHardTimeout() uint32 { return (*openflow_13.OfpFlowMod)(m).GetHardTimeout() }
+func (m *OfpFlowMod) GetPriority() uint32 { return (*openflow_13.OfpFlowMod)(m).GetPriority() }
+func (m *OfpFlowMod) GetBufferId() uint32 { return (*openflow_13.OfpFlowMod)(m).GetBufferId() }
+func (m *OfpFlowMod) GetOutPort() uint32 { return (*openflow_13.OfpFlowMod)(m).GetOutPort() }
+func (m *OfpFlowMod) GetOutGroup() uint32 { return (*openflow_13.OfpFlowMod)(m).GetOutGroup() }
+func (m *OfpFlowMod) GetFlags() uint32 { return (*openflow_13.OfpFlowMod)(m).GetFlags() }
+func (m *OfpFlowMod) GetMatch() *OfpMatch { return (*OfpMatch)((*openflow_13.OfpFlowMod)(m).GetMatch()) }
+func (m *OfpFlowMod) GetInstructions() []*OfpInstruction {
+ o := (*openflow_13.OfpFlowMod)(m).GetInstructions()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpInstruction, len(o))
+ for i, x := range o {
+ s[i] = (*OfpInstruction)(x)
+ }
+ return s
+}
+
+// ofp_bucket from public import openflow_13.proto
+type OfpBucket openflow_13.OfpBucket
+
+func (m *OfpBucket) Reset() { (*openflow_13.OfpBucket)(m).Reset() }
+func (m *OfpBucket) String() string { return (*openflow_13.OfpBucket)(m).String() }
+func (*OfpBucket) ProtoMessage() {}
+func (m *OfpBucket) GetWeight() uint32 { return (*openflow_13.OfpBucket)(m).GetWeight() }
+func (m *OfpBucket) GetWatchPort() uint32 { return (*openflow_13.OfpBucket)(m).GetWatchPort() }
+func (m *OfpBucket) GetWatchGroup() uint32 { return (*openflow_13.OfpBucket)(m).GetWatchGroup() }
+func (m *OfpBucket) GetActions() []*OfpAction {
+ o := (*openflow_13.OfpBucket)(m).GetActions()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpAction, len(o))
+ for i, x := range o {
+ s[i] = (*OfpAction)(x)
+ }
+ return s
+}
+
+// ofp_group_mod from public import openflow_13.proto
+type OfpGroupMod openflow_13.OfpGroupMod
+
+func (m *OfpGroupMod) Reset() { (*openflow_13.OfpGroupMod)(m).Reset() }
+func (m *OfpGroupMod) String() string { return (*openflow_13.OfpGroupMod)(m).String() }
+func (*OfpGroupMod) ProtoMessage() {}
+func (m *OfpGroupMod) GetCommand() OfpGroupModCommand {
+ return (OfpGroupModCommand)((*openflow_13.OfpGroupMod)(m).GetCommand())
+}
+func (m *OfpGroupMod) GetType() OfpGroupType {
+ return (OfpGroupType)((*openflow_13.OfpGroupMod)(m).GetType())
+}
+func (m *OfpGroupMod) GetGroupId() uint32 { return (*openflow_13.OfpGroupMod)(m).GetGroupId() }
+func (m *OfpGroupMod) GetBuckets() []*OfpBucket {
+ o := (*openflow_13.OfpGroupMod)(m).GetBuckets()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpBucket, len(o))
+ for i, x := range o {
+ s[i] = (*OfpBucket)(x)
+ }
+ return s
+}
+
+// ofp_packet_out from public import openflow_13.proto
+type OfpPacketOut openflow_13.OfpPacketOut
+
+func (m *OfpPacketOut) Reset() { (*openflow_13.OfpPacketOut)(m).Reset() }
+func (m *OfpPacketOut) String() string { return (*openflow_13.OfpPacketOut)(m).String() }
+func (*OfpPacketOut) ProtoMessage() {}
+func (m *OfpPacketOut) GetBufferId() uint32 { return (*openflow_13.OfpPacketOut)(m).GetBufferId() }
+func (m *OfpPacketOut) GetInPort() uint32 { return (*openflow_13.OfpPacketOut)(m).GetInPort() }
+func (m *OfpPacketOut) GetActions() []*OfpAction {
+ o := (*openflow_13.OfpPacketOut)(m).GetActions()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpAction, len(o))
+ for i, x := range o {
+ s[i] = (*OfpAction)(x)
+ }
+ return s
+}
+func (m *OfpPacketOut) GetData() []byte { return (*openflow_13.OfpPacketOut)(m).GetData() }
+
+// ofp_packet_in from public import openflow_13.proto
+type OfpPacketIn openflow_13.OfpPacketIn
+
+func (m *OfpPacketIn) Reset() { (*openflow_13.OfpPacketIn)(m).Reset() }
+func (m *OfpPacketIn) String() string { return (*openflow_13.OfpPacketIn)(m).String() }
+func (*OfpPacketIn) ProtoMessage() {}
+func (m *OfpPacketIn) GetBufferId() uint32 { return (*openflow_13.OfpPacketIn)(m).GetBufferId() }
+func (m *OfpPacketIn) GetReason() OfpPacketInReason {
+ return (OfpPacketInReason)((*openflow_13.OfpPacketIn)(m).GetReason())
+}
+func (m *OfpPacketIn) GetTableId() uint32 { return (*openflow_13.OfpPacketIn)(m).GetTableId() }
+func (m *OfpPacketIn) GetCookie() uint64 { return (*openflow_13.OfpPacketIn)(m).GetCookie() }
+func (m *OfpPacketIn) GetMatch() *OfpMatch {
+ return (*OfpMatch)((*openflow_13.OfpPacketIn)(m).GetMatch())
+}
+func (m *OfpPacketIn) GetData() []byte { return (*openflow_13.OfpPacketIn)(m).GetData() }
+
+// ofp_flow_removed from public import openflow_13.proto
+type OfpFlowRemoved openflow_13.OfpFlowRemoved
+
+func (m *OfpFlowRemoved) Reset() { (*openflow_13.OfpFlowRemoved)(m).Reset() }
+func (m *OfpFlowRemoved) String() string { return (*openflow_13.OfpFlowRemoved)(m).String() }
+func (*OfpFlowRemoved) ProtoMessage() {}
+func (m *OfpFlowRemoved) GetCookie() uint64 { return (*openflow_13.OfpFlowRemoved)(m).GetCookie() }
+func (m *OfpFlowRemoved) GetPriority() uint32 { return (*openflow_13.OfpFlowRemoved)(m).GetPriority() }
+func (m *OfpFlowRemoved) GetReason() OfpFlowRemovedReason {
+ return (OfpFlowRemovedReason)((*openflow_13.OfpFlowRemoved)(m).GetReason())
+}
+func (m *OfpFlowRemoved) GetTableId() uint32 { return (*openflow_13.OfpFlowRemoved)(m).GetTableId() }
+func (m *OfpFlowRemoved) GetDurationSec() uint32 {
+ return (*openflow_13.OfpFlowRemoved)(m).GetDurationSec()
+}
+func (m *OfpFlowRemoved) GetDurationNsec() uint32 {
+ return (*openflow_13.OfpFlowRemoved)(m).GetDurationNsec()
+}
+func (m *OfpFlowRemoved) GetIdleTimeout() uint32 {
+ return (*openflow_13.OfpFlowRemoved)(m).GetIdleTimeout()
+}
+func (m *OfpFlowRemoved) GetHardTimeout() uint32 {
+ return (*openflow_13.OfpFlowRemoved)(m).GetHardTimeout()
+}
+func (m *OfpFlowRemoved) GetPacketCount() uint64 {
+ return (*openflow_13.OfpFlowRemoved)(m).GetPacketCount()
+}
+func (m *OfpFlowRemoved) GetByteCount() uint64 { return (*openflow_13.OfpFlowRemoved)(m).GetByteCount() }
+func (m *OfpFlowRemoved) GetMatch() *OfpMatch {
+ return (*OfpMatch)((*openflow_13.OfpFlowRemoved)(m).GetMatch())
+}
+
+// ofp_meter_band_header from public import openflow_13.proto
+type OfpMeterBandHeader openflow_13.OfpMeterBandHeader
+
+func (m *OfpMeterBandHeader) Reset() { (*openflow_13.OfpMeterBandHeader)(m).Reset() }
+func (m *OfpMeterBandHeader) String() string { return (*openflow_13.OfpMeterBandHeader)(m).String() }
+func (*OfpMeterBandHeader) ProtoMessage() {}
+func (m *OfpMeterBandHeader) GetType() OfpMeterBandType {
+ return (OfpMeterBandType)((*openflow_13.OfpMeterBandHeader)(m).GetType())
+}
+func (m *OfpMeterBandHeader) GetLen() uint32 { return (*openflow_13.OfpMeterBandHeader)(m).GetLen() }
+func (m *OfpMeterBandHeader) GetRate() uint32 { return (*openflow_13.OfpMeterBandHeader)(m).GetRate() }
+func (m *OfpMeterBandHeader) GetBurstSize() uint32 {
+ return (*openflow_13.OfpMeterBandHeader)(m).GetBurstSize()
+}
+
+// ofp_meter_band_drop from public import openflow_13.proto
+type OfpMeterBandDrop openflow_13.OfpMeterBandDrop
+
+func (m *OfpMeterBandDrop) Reset() { (*openflow_13.OfpMeterBandDrop)(m).Reset() }
+func (m *OfpMeterBandDrop) String() string { return (*openflow_13.OfpMeterBandDrop)(m).String() }
+func (*OfpMeterBandDrop) ProtoMessage() {}
+func (m *OfpMeterBandDrop) GetType() uint32 { return (*openflow_13.OfpMeterBandDrop)(m).GetType() }
+func (m *OfpMeterBandDrop) GetLen() uint32 { return (*openflow_13.OfpMeterBandDrop)(m).GetLen() }
+func (m *OfpMeterBandDrop) GetRate() uint32 { return (*openflow_13.OfpMeterBandDrop)(m).GetRate() }
+func (m *OfpMeterBandDrop) GetBurstSize() uint32 {
+ return (*openflow_13.OfpMeterBandDrop)(m).GetBurstSize()
+}
+
+// ofp_meter_band_dscp_remark from public import openflow_13.proto
+type OfpMeterBandDscpRemark openflow_13.OfpMeterBandDscpRemark
+
+func (m *OfpMeterBandDscpRemark) Reset() { (*openflow_13.OfpMeterBandDscpRemark)(m).Reset() }
+func (m *OfpMeterBandDscpRemark) String() string {
+ return (*openflow_13.OfpMeterBandDscpRemark)(m).String()
+}
+func (*OfpMeterBandDscpRemark) ProtoMessage() {}
+func (m *OfpMeterBandDscpRemark) GetType() uint32 {
+ return (*openflow_13.OfpMeterBandDscpRemark)(m).GetType()
+}
+func (m *OfpMeterBandDscpRemark) GetLen() uint32 {
+ return (*openflow_13.OfpMeterBandDscpRemark)(m).GetLen()
+}
+func (m *OfpMeterBandDscpRemark) GetRate() uint32 {
+ return (*openflow_13.OfpMeterBandDscpRemark)(m).GetRate()
+}
+func (m *OfpMeterBandDscpRemark) GetBurstSize() uint32 {
+ return (*openflow_13.OfpMeterBandDscpRemark)(m).GetBurstSize()
+}
+func (m *OfpMeterBandDscpRemark) GetPrecLevel() uint32 {
+ return (*openflow_13.OfpMeterBandDscpRemark)(m).GetPrecLevel()
+}
+
+// ofp_meter_band_experimenter from public import openflow_13.proto
+type OfpMeterBandExperimenter openflow_13.OfpMeterBandExperimenter
+
+func (m *OfpMeterBandExperimenter) Reset() { (*openflow_13.OfpMeterBandExperimenter)(m).Reset() }
+func (m *OfpMeterBandExperimenter) String() string {
+ return (*openflow_13.OfpMeterBandExperimenter)(m).String()
+}
+func (*OfpMeterBandExperimenter) ProtoMessage() {}
+func (m *OfpMeterBandExperimenter) GetType() OfpMeterBandType {
+ return (OfpMeterBandType)((*openflow_13.OfpMeterBandExperimenter)(m).GetType())
+}
+func (m *OfpMeterBandExperimenter) GetLen() uint32 {
+ return (*openflow_13.OfpMeterBandExperimenter)(m).GetLen()
+}
+func (m *OfpMeterBandExperimenter) GetRate() uint32 {
+ return (*openflow_13.OfpMeterBandExperimenter)(m).GetRate()
+}
+func (m *OfpMeterBandExperimenter) GetBurstSize() uint32 {
+ return (*openflow_13.OfpMeterBandExperimenter)(m).GetBurstSize()
+}
+func (m *OfpMeterBandExperimenter) GetExperimenter() uint32 {
+ return (*openflow_13.OfpMeterBandExperimenter)(m).GetExperimenter()
+}
+
+// ofp_meter_mod from public import openflow_13.proto
+type OfpMeterMod openflow_13.OfpMeterMod
+
+func (m *OfpMeterMod) Reset() { (*openflow_13.OfpMeterMod)(m).Reset() }
+func (m *OfpMeterMod) String() string { return (*openflow_13.OfpMeterMod)(m).String() }
+func (*OfpMeterMod) ProtoMessage() {}
+func (m *OfpMeterMod) GetCommand() OfpMeterModCommand {
+ return (OfpMeterModCommand)((*openflow_13.OfpMeterMod)(m).GetCommand())
+}
+func (m *OfpMeterMod) GetFlags() uint32 { return (*openflow_13.OfpMeterMod)(m).GetFlags() }
+func (m *OfpMeterMod) GetMeterId() uint32 { return (*openflow_13.OfpMeterMod)(m).GetMeterId() }
+func (m *OfpMeterMod) GetBands() []*OfpMeterBandHeader {
+ o := (*openflow_13.OfpMeterMod)(m).GetBands()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpMeterBandHeader, len(o))
+ for i, x := range o {
+ s[i] = (*OfpMeterBandHeader)(x)
+ }
+ return s
+}
+
+// ofp_error_msg from public import openflow_13.proto
+type OfpErrorMsg openflow_13.OfpErrorMsg
+
+func (m *OfpErrorMsg) Reset() { (*openflow_13.OfpErrorMsg)(m).Reset() }
+func (m *OfpErrorMsg) String() string { return (*openflow_13.OfpErrorMsg)(m).String() }
+func (*OfpErrorMsg) ProtoMessage() {}
+func (m *OfpErrorMsg) GetType() uint32 { return (*openflow_13.OfpErrorMsg)(m).GetType() }
+func (m *OfpErrorMsg) GetCode() uint32 { return (*openflow_13.OfpErrorMsg)(m).GetCode() }
+func (m *OfpErrorMsg) GetData() []byte { return (*openflow_13.OfpErrorMsg)(m).GetData() }
+
+// ofp_error_experimenter_msg from public import openflow_13.proto
+type OfpErrorExperimenterMsg openflow_13.OfpErrorExperimenterMsg
+
+func (m *OfpErrorExperimenterMsg) Reset() { (*openflow_13.OfpErrorExperimenterMsg)(m).Reset() }
+func (m *OfpErrorExperimenterMsg) String() string {
+ return (*openflow_13.OfpErrorExperimenterMsg)(m).String()
+}
+func (*OfpErrorExperimenterMsg) ProtoMessage() {}
+func (m *OfpErrorExperimenterMsg) GetType() uint32 {
+ return (*openflow_13.OfpErrorExperimenterMsg)(m).GetType()
+}
+func (m *OfpErrorExperimenterMsg) GetExpType() uint32 {
+ return (*openflow_13.OfpErrorExperimenterMsg)(m).GetExpType()
+}
+func (m *OfpErrorExperimenterMsg) GetExperimenter() uint32 {
+ return (*openflow_13.OfpErrorExperimenterMsg)(m).GetExperimenter()
+}
+func (m *OfpErrorExperimenterMsg) GetData() []byte {
+ return (*openflow_13.OfpErrorExperimenterMsg)(m).GetData()
+}
+
+// ofp_multipart_request from public import openflow_13.proto
+type OfpMultipartRequest openflow_13.OfpMultipartRequest
+
+func (m *OfpMultipartRequest) Reset() { (*openflow_13.OfpMultipartRequest)(m).Reset() }
+func (m *OfpMultipartRequest) String() string { return (*openflow_13.OfpMultipartRequest)(m).String() }
+func (*OfpMultipartRequest) ProtoMessage() {}
+func (m *OfpMultipartRequest) GetType() OfpMultipartType {
+ return (OfpMultipartType)((*openflow_13.OfpMultipartRequest)(m).GetType())
+}
+func (m *OfpMultipartRequest) GetFlags() uint32 {
+ return (*openflow_13.OfpMultipartRequest)(m).GetFlags()
+}
+func (m *OfpMultipartRequest) GetBody() []byte { return (*openflow_13.OfpMultipartRequest)(m).GetBody() }
+
+// ofp_multipart_reply from public import openflow_13.proto
+type OfpMultipartReply openflow_13.OfpMultipartReply
+
+func (m *OfpMultipartReply) Reset() { (*openflow_13.OfpMultipartReply)(m).Reset() }
+func (m *OfpMultipartReply) String() string { return (*openflow_13.OfpMultipartReply)(m).String() }
+func (*OfpMultipartReply) ProtoMessage() {}
+func (m *OfpMultipartReply) GetType() OfpMultipartType {
+ return (OfpMultipartType)((*openflow_13.OfpMultipartReply)(m).GetType())
+}
+func (m *OfpMultipartReply) GetFlags() uint32 { return (*openflow_13.OfpMultipartReply)(m).GetFlags() }
+func (m *OfpMultipartReply) GetBody() []byte { return (*openflow_13.OfpMultipartReply)(m).GetBody() }
+
+// ofp_desc from public import openflow_13.proto
+type OfpDesc openflow_13.OfpDesc
+
+func (m *OfpDesc) Reset() { (*openflow_13.OfpDesc)(m).Reset() }
+func (m *OfpDesc) String() string { return (*openflow_13.OfpDesc)(m).String() }
+func (*OfpDesc) ProtoMessage() {}
+func (m *OfpDesc) GetMfrDesc() string { return (*openflow_13.OfpDesc)(m).GetMfrDesc() }
+func (m *OfpDesc) GetHwDesc() string { return (*openflow_13.OfpDesc)(m).GetHwDesc() }
+func (m *OfpDesc) GetSwDesc() string { return (*openflow_13.OfpDesc)(m).GetSwDesc() }
+func (m *OfpDesc) GetSerialNum() string { return (*openflow_13.OfpDesc)(m).GetSerialNum() }
+func (m *OfpDesc) GetDpDesc() string { return (*openflow_13.OfpDesc)(m).GetDpDesc() }
+
+// ofp_flow_stats_request from public import openflow_13.proto
+type OfpFlowStatsRequest openflow_13.OfpFlowStatsRequest
+
+func (m *OfpFlowStatsRequest) Reset() { (*openflow_13.OfpFlowStatsRequest)(m).Reset() }
+func (m *OfpFlowStatsRequest) String() string { return (*openflow_13.OfpFlowStatsRequest)(m).String() }
+func (*OfpFlowStatsRequest) ProtoMessage() {}
+func (m *OfpFlowStatsRequest) GetTableId() uint32 {
+ return (*openflow_13.OfpFlowStatsRequest)(m).GetTableId()
+}
+func (m *OfpFlowStatsRequest) GetOutPort() uint32 {
+ return (*openflow_13.OfpFlowStatsRequest)(m).GetOutPort()
+}
+func (m *OfpFlowStatsRequest) GetOutGroup() uint32 {
+ return (*openflow_13.OfpFlowStatsRequest)(m).GetOutGroup()
+}
+func (m *OfpFlowStatsRequest) GetCookie() uint64 {
+ return (*openflow_13.OfpFlowStatsRequest)(m).GetCookie()
+}
+func (m *OfpFlowStatsRequest) GetCookieMask() uint64 {
+ return (*openflow_13.OfpFlowStatsRequest)(m).GetCookieMask()
+}
+func (m *OfpFlowStatsRequest) GetMatch() *OfpMatch {
+ return (*OfpMatch)((*openflow_13.OfpFlowStatsRequest)(m).GetMatch())
+}
+
+// ofp_flow_stats from public import openflow_13.proto
+type OfpFlowStats openflow_13.OfpFlowStats
+
+func (m *OfpFlowStats) Reset() { (*openflow_13.OfpFlowStats)(m).Reset() }
+func (m *OfpFlowStats) String() string { return (*openflow_13.OfpFlowStats)(m).String() }
+func (*OfpFlowStats) ProtoMessage() {}
+func (m *OfpFlowStats) GetId() uint64 { return (*openflow_13.OfpFlowStats)(m).GetId() }
+func (m *OfpFlowStats) GetTableId() uint32 { return (*openflow_13.OfpFlowStats)(m).GetTableId() }
+func (m *OfpFlowStats) GetDurationSec() uint32 { return (*openflow_13.OfpFlowStats)(m).GetDurationSec() }
+func (m *OfpFlowStats) GetDurationNsec() uint32 {
+ return (*openflow_13.OfpFlowStats)(m).GetDurationNsec()
+}
+func (m *OfpFlowStats) GetPriority() uint32 { return (*openflow_13.OfpFlowStats)(m).GetPriority() }
+func (m *OfpFlowStats) GetIdleTimeout() uint32 { return (*openflow_13.OfpFlowStats)(m).GetIdleTimeout() }
+func (m *OfpFlowStats) GetHardTimeout() uint32 { return (*openflow_13.OfpFlowStats)(m).GetHardTimeout() }
+func (m *OfpFlowStats) GetFlags() uint32 { return (*openflow_13.OfpFlowStats)(m).GetFlags() }
+func (m *OfpFlowStats) GetCookie() uint64 { return (*openflow_13.OfpFlowStats)(m).GetCookie() }
+func (m *OfpFlowStats) GetPacketCount() uint64 { return (*openflow_13.OfpFlowStats)(m).GetPacketCount() }
+func (m *OfpFlowStats) GetByteCount() uint64 { return (*openflow_13.OfpFlowStats)(m).GetByteCount() }
+func (m *OfpFlowStats) GetMatch() *OfpMatch {
+ return (*OfpMatch)((*openflow_13.OfpFlowStats)(m).GetMatch())
+}
+func (m *OfpFlowStats) GetInstructions() []*OfpInstruction {
+ o := (*openflow_13.OfpFlowStats)(m).GetInstructions()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpInstruction, len(o))
+ for i, x := range o {
+ s[i] = (*OfpInstruction)(x)
+ }
+ return s
+}
+
+// ofp_aggregate_stats_request from public import openflow_13.proto
+type OfpAggregateStatsRequest openflow_13.OfpAggregateStatsRequest
+
+func (m *OfpAggregateStatsRequest) Reset() { (*openflow_13.OfpAggregateStatsRequest)(m).Reset() }
+func (m *OfpAggregateStatsRequest) String() string {
+ return (*openflow_13.OfpAggregateStatsRequest)(m).String()
+}
+func (*OfpAggregateStatsRequest) ProtoMessage() {}
+func (m *OfpAggregateStatsRequest) GetTableId() uint32 {
+ return (*openflow_13.OfpAggregateStatsRequest)(m).GetTableId()
+}
+func (m *OfpAggregateStatsRequest) GetOutPort() uint32 {
+ return (*openflow_13.OfpAggregateStatsRequest)(m).GetOutPort()
+}
+func (m *OfpAggregateStatsRequest) GetOutGroup() uint32 {
+ return (*openflow_13.OfpAggregateStatsRequest)(m).GetOutGroup()
+}
+func (m *OfpAggregateStatsRequest) GetCookie() uint64 {
+ return (*openflow_13.OfpAggregateStatsRequest)(m).GetCookie()
+}
+func (m *OfpAggregateStatsRequest) GetCookieMask() uint64 {
+ return (*openflow_13.OfpAggregateStatsRequest)(m).GetCookieMask()
+}
+func (m *OfpAggregateStatsRequest) GetMatch() *OfpMatch {
+ return (*OfpMatch)((*openflow_13.OfpAggregateStatsRequest)(m).GetMatch())
+}
+
+// ofp_aggregate_stats_reply from public import openflow_13.proto
+type OfpAggregateStatsReply openflow_13.OfpAggregateStatsReply
+
+func (m *OfpAggregateStatsReply) Reset() { (*openflow_13.OfpAggregateStatsReply)(m).Reset() }
+func (m *OfpAggregateStatsReply) String() string {
+ return (*openflow_13.OfpAggregateStatsReply)(m).String()
+}
+func (*OfpAggregateStatsReply) ProtoMessage() {}
+func (m *OfpAggregateStatsReply) GetPacketCount() uint64 {
+ return (*openflow_13.OfpAggregateStatsReply)(m).GetPacketCount()
+}
+func (m *OfpAggregateStatsReply) GetByteCount() uint64 {
+ return (*openflow_13.OfpAggregateStatsReply)(m).GetByteCount()
+}
+func (m *OfpAggregateStatsReply) GetFlowCount() uint32 {
+ return (*openflow_13.OfpAggregateStatsReply)(m).GetFlowCount()
+}
+
+// ofp_table_feature_property from public import openflow_13.proto
+type OfpTableFeatureProperty openflow_13.OfpTableFeatureProperty
+
+func (m *OfpTableFeatureProperty) Reset() { (*openflow_13.OfpTableFeatureProperty)(m).Reset() }
+func (m *OfpTableFeatureProperty) String() string {
+ return (*openflow_13.OfpTableFeatureProperty)(m).String()
+}
+func (*OfpTableFeatureProperty) ProtoMessage() {}
+func (m *OfpTableFeatureProperty) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+ return _OfpTableFeatureProperty_OneofMarshaler, _OfpTableFeatureProperty_OneofUnmarshaler, _OfpTableFeatureProperty_OneofSizer, nil
+}
+func _OfpTableFeatureProperty_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*OfpTableFeatureProperty)
+ m0 := (*openflow_13.OfpTableFeatureProperty)(m)
+ enc, _, _, _ := m0.XXX_OneofFuncs()
+ return enc(m0, b)
+}
+func _OfpTableFeatureProperty_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*OfpTableFeatureProperty)
+ m0 := (*openflow_13.OfpTableFeatureProperty)(m)
+ _, dec, _, _ := m0.XXX_OneofFuncs()
+ return dec(m0, tag, wire, b)
+}
+func _OfpTableFeatureProperty_OneofSizer(msg proto.Message) int {
+ m := msg.(*OfpTableFeatureProperty)
+ m0 := (*openflow_13.OfpTableFeatureProperty)(m)
+ _, _, size, _ := m0.XXX_OneofFuncs()
+ return size(m0)
+}
+func (m *OfpTableFeatureProperty) GetType() OfpTableFeaturePropType {
+ return (OfpTableFeaturePropType)((*openflow_13.OfpTableFeatureProperty)(m).GetType())
+}
+func (m *OfpTableFeatureProperty) GetInstructions() *OfpTableFeaturePropInstructions {
+ return (*OfpTableFeaturePropInstructions)((*openflow_13.OfpTableFeatureProperty)(m).GetInstructions())
+}
+func (m *OfpTableFeatureProperty) GetNextTables() *OfpTableFeaturePropNextTables {
+ return (*OfpTableFeaturePropNextTables)((*openflow_13.OfpTableFeatureProperty)(m).GetNextTables())
+}
+func (m *OfpTableFeatureProperty) GetActions() *OfpTableFeaturePropActions {
+ return (*OfpTableFeaturePropActions)((*openflow_13.OfpTableFeatureProperty)(m).GetActions())
+}
+func (m *OfpTableFeatureProperty) GetOxm() *OfpTableFeaturePropOxm {
+ return (*OfpTableFeaturePropOxm)((*openflow_13.OfpTableFeatureProperty)(m).GetOxm())
+}
+func (m *OfpTableFeatureProperty) GetExperimenter() *OfpTableFeaturePropExperimenter {
+ return (*OfpTableFeaturePropExperimenter)((*openflow_13.OfpTableFeatureProperty)(m).GetExperimenter())
+}
+
+// ofp_table_feature_prop_instructions from public import openflow_13.proto
+type OfpTableFeaturePropInstructions openflow_13.OfpTableFeaturePropInstructions
+
+func (m *OfpTableFeaturePropInstructions) Reset() {
+ (*openflow_13.OfpTableFeaturePropInstructions)(m).Reset()
+}
+func (m *OfpTableFeaturePropInstructions) String() string {
+ return (*openflow_13.OfpTableFeaturePropInstructions)(m).String()
+}
+func (*OfpTableFeaturePropInstructions) ProtoMessage() {}
+func (m *OfpTableFeaturePropInstructions) GetInstructions() []*OfpInstruction {
+ o := (*openflow_13.OfpTableFeaturePropInstructions)(m).GetInstructions()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpInstruction, len(o))
+ for i, x := range o {
+ s[i] = (*OfpInstruction)(x)
+ }
+ return s
+}
+
+// ofp_table_feature_prop_next_tables from public import openflow_13.proto
+type OfpTableFeaturePropNextTables openflow_13.OfpTableFeaturePropNextTables
+
+func (m *OfpTableFeaturePropNextTables) Reset() {
+ (*openflow_13.OfpTableFeaturePropNextTables)(m).Reset()
+}
+func (m *OfpTableFeaturePropNextTables) String() string {
+ return (*openflow_13.OfpTableFeaturePropNextTables)(m).String()
+}
+func (*OfpTableFeaturePropNextTables) ProtoMessage() {}
+func (m *OfpTableFeaturePropNextTables) GetNextTableIds() []uint32 {
+ return (*openflow_13.OfpTableFeaturePropNextTables)(m).GetNextTableIds()
+}
+
+// ofp_table_feature_prop_actions from public import openflow_13.proto
+type OfpTableFeaturePropActions openflow_13.OfpTableFeaturePropActions
+
+func (m *OfpTableFeaturePropActions) Reset() { (*openflow_13.OfpTableFeaturePropActions)(m).Reset() }
+func (m *OfpTableFeaturePropActions) String() string {
+ return (*openflow_13.OfpTableFeaturePropActions)(m).String()
+}
+func (*OfpTableFeaturePropActions) ProtoMessage() {}
+func (m *OfpTableFeaturePropActions) GetActions() []*OfpAction {
+ o := (*openflow_13.OfpTableFeaturePropActions)(m).GetActions()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpAction, len(o))
+ for i, x := range o {
+ s[i] = (*OfpAction)(x)
+ }
+ return s
+}
+
+// ofp_table_feature_prop_oxm from public import openflow_13.proto
+type OfpTableFeaturePropOxm openflow_13.OfpTableFeaturePropOxm
+
+func (m *OfpTableFeaturePropOxm) Reset() { (*openflow_13.OfpTableFeaturePropOxm)(m).Reset() }
+func (m *OfpTableFeaturePropOxm) String() string {
+ return (*openflow_13.OfpTableFeaturePropOxm)(m).String()
+}
+func (*OfpTableFeaturePropOxm) ProtoMessage() {}
+func (m *OfpTableFeaturePropOxm) GetOxmIds() []uint32 {
+ return (*openflow_13.OfpTableFeaturePropOxm)(m).GetOxmIds()
+}
+
+// ofp_table_feature_prop_experimenter from public import openflow_13.proto
+type OfpTableFeaturePropExperimenter openflow_13.OfpTableFeaturePropExperimenter
+
+func (m *OfpTableFeaturePropExperimenter) Reset() {
+ (*openflow_13.OfpTableFeaturePropExperimenter)(m).Reset()
+}
+func (m *OfpTableFeaturePropExperimenter) String() string {
+ return (*openflow_13.OfpTableFeaturePropExperimenter)(m).String()
+}
+func (*OfpTableFeaturePropExperimenter) ProtoMessage() {}
+func (m *OfpTableFeaturePropExperimenter) GetExperimenter() uint32 {
+ return (*openflow_13.OfpTableFeaturePropExperimenter)(m).GetExperimenter()
+}
+func (m *OfpTableFeaturePropExperimenter) GetExpType() uint32 {
+ return (*openflow_13.OfpTableFeaturePropExperimenter)(m).GetExpType()
+}
+func (m *OfpTableFeaturePropExperimenter) GetExperimenterData() []uint32 {
+ return (*openflow_13.OfpTableFeaturePropExperimenter)(m).GetExperimenterData()
+}
+
+// ofp_table_features from public import openflow_13.proto
+type OfpTableFeatures openflow_13.OfpTableFeatures
+
+func (m *OfpTableFeatures) Reset() { (*openflow_13.OfpTableFeatures)(m).Reset() }
+func (m *OfpTableFeatures) String() string { return (*openflow_13.OfpTableFeatures)(m).String() }
+func (*OfpTableFeatures) ProtoMessage() {}
+func (m *OfpTableFeatures) GetTableId() uint32 { return (*openflow_13.OfpTableFeatures)(m).GetTableId() }
+func (m *OfpTableFeatures) GetName() string { return (*openflow_13.OfpTableFeatures)(m).GetName() }
+func (m *OfpTableFeatures) GetMetadataMatch() uint64 {
+ return (*openflow_13.OfpTableFeatures)(m).GetMetadataMatch()
+}
+func (m *OfpTableFeatures) GetMetadataWrite() uint64 {
+ return (*openflow_13.OfpTableFeatures)(m).GetMetadataWrite()
+}
+func (m *OfpTableFeatures) GetConfig() uint32 { return (*openflow_13.OfpTableFeatures)(m).GetConfig() }
+func (m *OfpTableFeatures) GetMaxEntries() uint32 {
+ return (*openflow_13.OfpTableFeatures)(m).GetMaxEntries()
+}
+func (m *OfpTableFeatures) GetProperties() []*OfpTableFeatureProperty {
+ o := (*openflow_13.OfpTableFeatures)(m).GetProperties()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpTableFeatureProperty, len(o))
+ for i, x := range o {
+ s[i] = (*OfpTableFeatureProperty)(x)
+ }
+ return s
+}
+
+// ofp_table_stats from public import openflow_13.proto
+type OfpTableStats openflow_13.OfpTableStats
+
+func (m *OfpTableStats) Reset() { (*openflow_13.OfpTableStats)(m).Reset() }
+func (m *OfpTableStats) String() string { return (*openflow_13.OfpTableStats)(m).String() }
+func (*OfpTableStats) ProtoMessage() {}
+func (m *OfpTableStats) GetTableId() uint32 { return (*openflow_13.OfpTableStats)(m).GetTableId() }
+func (m *OfpTableStats) GetActiveCount() uint32 {
+ return (*openflow_13.OfpTableStats)(m).GetActiveCount()
+}
+func (m *OfpTableStats) GetLookupCount() uint64 {
+ return (*openflow_13.OfpTableStats)(m).GetLookupCount()
+}
+func (m *OfpTableStats) GetMatchedCount() uint64 {
+ return (*openflow_13.OfpTableStats)(m).GetMatchedCount()
+}
+
+// ofp_port_stats_request from public import openflow_13.proto
+type OfpPortStatsRequest openflow_13.OfpPortStatsRequest
+
+func (m *OfpPortStatsRequest) Reset() { (*openflow_13.OfpPortStatsRequest)(m).Reset() }
+func (m *OfpPortStatsRequest) String() string { return (*openflow_13.OfpPortStatsRequest)(m).String() }
+func (*OfpPortStatsRequest) ProtoMessage() {}
+func (m *OfpPortStatsRequest) GetPortNo() uint32 {
+ return (*openflow_13.OfpPortStatsRequest)(m).GetPortNo()
+}
+
+// ofp_port_stats from public import openflow_13.proto
+type OfpPortStats openflow_13.OfpPortStats
+
+func (m *OfpPortStats) Reset() { (*openflow_13.OfpPortStats)(m).Reset() }
+func (m *OfpPortStats) String() string { return (*openflow_13.OfpPortStats)(m).String() }
+func (*OfpPortStats) ProtoMessage() {}
+func (m *OfpPortStats) GetPortNo() uint32 { return (*openflow_13.OfpPortStats)(m).GetPortNo() }
+func (m *OfpPortStats) GetRxPackets() uint64 { return (*openflow_13.OfpPortStats)(m).GetRxPackets() }
+func (m *OfpPortStats) GetTxPackets() uint64 { return (*openflow_13.OfpPortStats)(m).GetTxPackets() }
+func (m *OfpPortStats) GetRxBytes() uint64 { return (*openflow_13.OfpPortStats)(m).GetRxBytes() }
+func (m *OfpPortStats) GetTxBytes() uint64 { return (*openflow_13.OfpPortStats)(m).GetTxBytes() }
+func (m *OfpPortStats) GetRxDropped() uint64 { return (*openflow_13.OfpPortStats)(m).GetRxDropped() }
+func (m *OfpPortStats) GetTxDropped() uint64 { return (*openflow_13.OfpPortStats)(m).GetTxDropped() }
+func (m *OfpPortStats) GetRxErrors() uint64 { return (*openflow_13.OfpPortStats)(m).GetRxErrors() }
+func (m *OfpPortStats) GetTxErrors() uint64 { return (*openflow_13.OfpPortStats)(m).GetTxErrors() }
+func (m *OfpPortStats) GetRxFrameErr() uint64 { return (*openflow_13.OfpPortStats)(m).GetRxFrameErr() }
+func (m *OfpPortStats) GetRxOverErr() uint64 { return (*openflow_13.OfpPortStats)(m).GetRxOverErr() }
+func (m *OfpPortStats) GetRxCrcErr() uint64 { return (*openflow_13.OfpPortStats)(m).GetRxCrcErr() }
+func (m *OfpPortStats) GetCollisions() uint64 { return (*openflow_13.OfpPortStats)(m).GetCollisions() }
+func (m *OfpPortStats) GetDurationSec() uint32 { return (*openflow_13.OfpPortStats)(m).GetDurationSec() }
+func (m *OfpPortStats) GetDurationNsec() uint32 {
+ return (*openflow_13.OfpPortStats)(m).GetDurationNsec()
+}
+
+// ofp_group_stats_request from public import openflow_13.proto
+type OfpGroupStatsRequest openflow_13.OfpGroupStatsRequest
+
+func (m *OfpGroupStatsRequest) Reset() { (*openflow_13.OfpGroupStatsRequest)(m).Reset() }
+func (m *OfpGroupStatsRequest) String() string { return (*openflow_13.OfpGroupStatsRequest)(m).String() }
+func (*OfpGroupStatsRequest) ProtoMessage() {}
+func (m *OfpGroupStatsRequest) GetGroupId() uint32 {
+ return (*openflow_13.OfpGroupStatsRequest)(m).GetGroupId()
+}
+
+// ofp_bucket_counter from public import openflow_13.proto
+type OfpBucketCounter openflow_13.OfpBucketCounter
+
+func (m *OfpBucketCounter) Reset() { (*openflow_13.OfpBucketCounter)(m).Reset() }
+func (m *OfpBucketCounter) String() string { return (*openflow_13.OfpBucketCounter)(m).String() }
+func (*OfpBucketCounter) ProtoMessage() {}
+func (m *OfpBucketCounter) GetPacketCount() uint64 {
+ return (*openflow_13.OfpBucketCounter)(m).GetPacketCount()
+}
+func (m *OfpBucketCounter) GetByteCount() uint64 {
+ return (*openflow_13.OfpBucketCounter)(m).GetByteCount()
+}
+
+// ofp_group_stats from public import openflow_13.proto
+type OfpGroupStats openflow_13.OfpGroupStats
+
+func (m *OfpGroupStats) Reset() { (*openflow_13.OfpGroupStats)(m).Reset() }
+func (m *OfpGroupStats) String() string { return (*openflow_13.OfpGroupStats)(m).String() }
+func (*OfpGroupStats) ProtoMessage() {}
+func (m *OfpGroupStats) GetGroupId() uint32 { return (*openflow_13.OfpGroupStats)(m).GetGroupId() }
+func (m *OfpGroupStats) GetRefCount() uint32 { return (*openflow_13.OfpGroupStats)(m).GetRefCount() }
+func (m *OfpGroupStats) GetPacketCount() uint64 {
+ return (*openflow_13.OfpGroupStats)(m).GetPacketCount()
+}
+func (m *OfpGroupStats) GetByteCount() uint64 { return (*openflow_13.OfpGroupStats)(m).GetByteCount() }
+func (m *OfpGroupStats) GetDurationSec() uint32 {
+ return (*openflow_13.OfpGroupStats)(m).GetDurationSec()
+}
+func (m *OfpGroupStats) GetDurationNsec() uint32 {
+ return (*openflow_13.OfpGroupStats)(m).GetDurationNsec()
+}
+func (m *OfpGroupStats) GetBucketStats() []*OfpBucketCounter {
+ o := (*openflow_13.OfpGroupStats)(m).GetBucketStats()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpBucketCounter, len(o))
+ for i, x := range o {
+ s[i] = (*OfpBucketCounter)(x)
+ }
+ return s
+}
+
+// ofp_group_desc from public import openflow_13.proto
+type OfpGroupDesc openflow_13.OfpGroupDesc
+
+func (m *OfpGroupDesc) Reset() { (*openflow_13.OfpGroupDesc)(m).Reset() }
+func (m *OfpGroupDesc) String() string { return (*openflow_13.OfpGroupDesc)(m).String() }
+func (*OfpGroupDesc) ProtoMessage() {}
+func (m *OfpGroupDesc) GetType() OfpGroupType {
+ return (OfpGroupType)((*openflow_13.OfpGroupDesc)(m).GetType())
+}
+func (m *OfpGroupDesc) GetGroupId() uint32 { return (*openflow_13.OfpGroupDesc)(m).GetGroupId() }
+func (m *OfpGroupDesc) GetBuckets() []*OfpBucket {
+ o := (*openflow_13.OfpGroupDesc)(m).GetBuckets()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpBucket, len(o))
+ for i, x := range o {
+ s[i] = (*OfpBucket)(x)
+ }
+ return s
+}
+
+// ofp_group_entry from public import openflow_13.proto
+type OfpGroupEntry openflow_13.OfpGroupEntry
+
+func (m *OfpGroupEntry) Reset() { (*openflow_13.OfpGroupEntry)(m).Reset() }
+func (m *OfpGroupEntry) String() string { return (*openflow_13.OfpGroupEntry)(m).String() }
+func (*OfpGroupEntry) ProtoMessage() {}
+func (m *OfpGroupEntry) GetDesc() *OfpGroupDesc {
+ return (*OfpGroupDesc)((*openflow_13.OfpGroupEntry)(m).GetDesc())
+}
+func (m *OfpGroupEntry) GetStats() *OfpGroupStats {
+ return (*OfpGroupStats)((*openflow_13.OfpGroupEntry)(m).GetStats())
+}
+
+// ofp_group_features from public import openflow_13.proto
+type OfpGroupFeatures openflow_13.OfpGroupFeatures
+
+func (m *OfpGroupFeatures) Reset() { (*openflow_13.OfpGroupFeatures)(m).Reset() }
+func (m *OfpGroupFeatures) String() string { return (*openflow_13.OfpGroupFeatures)(m).String() }
+func (*OfpGroupFeatures) ProtoMessage() {}
+func (m *OfpGroupFeatures) GetTypes() uint32 { return (*openflow_13.OfpGroupFeatures)(m).GetTypes() }
+func (m *OfpGroupFeatures) GetCapabilities() uint32 {
+ return (*openflow_13.OfpGroupFeatures)(m).GetCapabilities()
+}
+func (m *OfpGroupFeatures) GetMaxGroups() []uint32 {
+ return (*openflow_13.OfpGroupFeatures)(m).GetMaxGroups()
+}
+func (m *OfpGroupFeatures) GetActions() []uint32 {
+ return (*openflow_13.OfpGroupFeatures)(m).GetActions()
+}
+
+// ofp_meter_multipart_request from public import openflow_13.proto
+type OfpMeterMultipartRequest openflow_13.OfpMeterMultipartRequest
+
+func (m *OfpMeterMultipartRequest) Reset() { (*openflow_13.OfpMeterMultipartRequest)(m).Reset() }
+func (m *OfpMeterMultipartRequest) String() string {
+ return (*openflow_13.OfpMeterMultipartRequest)(m).String()
+}
+func (*OfpMeterMultipartRequest) ProtoMessage() {}
+func (m *OfpMeterMultipartRequest) GetMeterId() uint32 {
+ return (*openflow_13.OfpMeterMultipartRequest)(m).GetMeterId()
+}
+
+// ofp_meter_band_stats from public import openflow_13.proto
+type OfpMeterBandStats openflow_13.OfpMeterBandStats
+
+func (m *OfpMeterBandStats) Reset() { (*openflow_13.OfpMeterBandStats)(m).Reset() }
+func (m *OfpMeterBandStats) String() string { return (*openflow_13.OfpMeterBandStats)(m).String() }
+func (*OfpMeterBandStats) ProtoMessage() {}
+func (m *OfpMeterBandStats) GetPacketBandCount() uint64 {
+ return (*openflow_13.OfpMeterBandStats)(m).GetPacketBandCount()
+}
+func (m *OfpMeterBandStats) GetByteBandCount() uint64 {
+ return (*openflow_13.OfpMeterBandStats)(m).GetByteBandCount()
+}
+
+// ofp_meter_stats from public import openflow_13.proto
+type OfpMeterStats openflow_13.OfpMeterStats
+
+func (m *OfpMeterStats) Reset() { (*openflow_13.OfpMeterStats)(m).Reset() }
+func (m *OfpMeterStats) String() string { return (*openflow_13.OfpMeterStats)(m).String() }
+func (*OfpMeterStats) ProtoMessage() {}
+func (m *OfpMeterStats) GetMeterId() uint32 { return (*openflow_13.OfpMeterStats)(m).GetMeterId() }
+func (m *OfpMeterStats) GetFlowCount() uint32 { return (*openflow_13.OfpMeterStats)(m).GetFlowCount() }
+func (m *OfpMeterStats) GetPacketInCount() uint64 {
+ return (*openflow_13.OfpMeterStats)(m).GetPacketInCount()
+}
+func (m *OfpMeterStats) GetByteInCount() uint64 {
+ return (*openflow_13.OfpMeterStats)(m).GetByteInCount()
+}
+func (m *OfpMeterStats) GetDurationSec() uint32 {
+ return (*openflow_13.OfpMeterStats)(m).GetDurationSec()
+}
+func (m *OfpMeterStats) GetDurationNsec() uint32 {
+ return (*openflow_13.OfpMeterStats)(m).GetDurationNsec()
+}
+func (m *OfpMeterStats) GetBandStats() []*OfpMeterBandStats {
+ o := (*openflow_13.OfpMeterStats)(m).GetBandStats()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpMeterBandStats, len(o))
+ for i, x := range o {
+ s[i] = (*OfpMeterBandStats)(x)
+ }
+ return s
+}
+
+// ofp_meter_config from public import openflow_13.proto
+type OfpMeterConfig openflow_13.OfpMeterConfig
+
+func (m *OfpMeterConfig) Reset() { (*openflow_13.OfpMeterConfig)(m).Reset() }
+func (m *OfpMeterConfig) String() string { return (*openflow_13.OfpMeterConfig)(m).String() }
+func (*OfpMeterConfig) ProtoMessage() {}
+func (m *OfpMeterConfig) GetFlags() uint32 { return (*openflow_13.OfpMeterConfig)(m).GetFlags() }
+func (m *OfpMeterConfig) GetMeterId() uint32 { return (*openflow_13.OfpMeterConfig)(m).GetMeterId() }
+func (m *OfpMeterConfig) GetBands() []*OfpMeterBandHeader {
+ o := (*openflow_13.OfpMeterConfig)(m).GetBands()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpMeterBandHeader, len(o))
+ for i, x := range o {
+ s[i] = (*OfpMeterBandHeader)(x)
+ }
+ return s
+}
+
+// ofp_meter_features from public import openflow_13.proto
+type OfpMeterFeatures openflow_13.OfpMeterFeatures
+
+func (m *OfpMeterFeatures) Reset() { (*openflow_13.OfpMeterFeatures)(m).Reset() }
+func (m *OfpMeterFeatures) String() string { return (*openflow_13.OfpMeterFeatures)(m).String() }
+func (*OfpMeterFeatures) ProtoMessage() {}
+func (m *OfpMeterFeatures) GetMaxMeter() uint32 {
+ return (*openflow_13.OfpMeterFeatures)(m).GetMaxMeter()
+}
+func (m *OfpMeterFeatures) GetBandTypes() uint32 {
+ return (*openflow_13.OfpMeterFeatures)(m).GetBandTypes()
+}
+func (m *OfpMeterFeatures) GetCapabilities() uint32 {
+ return (*openflow_13.OfpMeterFeatures)(m).GetCapabilities()
+}
+func (m *OfpMeterFeatures) GetMaxBands() uint32 {
+ return (*openflow_13.OfpMeterFeatures)(m).GetMaxBands()
+}
+func (m *OfpMeterFeatures) GetMaxColor() uint32 {
+ return (*openflow_13.OfpMeterFeatures)(m).GetMaxColor()
+}
+
+// ofp_experimenter_multipart_header from public import openflow_13.proto
+type OfpExperimenterMultipartHeader openflow_13.OfpExperimenterMultipartHeader
+
+func (m *OfpExperimenterMultipartHeader) Reset() {
+ (*openflow_13.OfpExperimenterMultipartHeader)(m).Reset()
+}
+func (m *OfpExperimenterMultipartHeader) String() string {
+ return (*openflow_13.OfpExperimenterMultipartHeader)(m).String()
+}
+func (*OfpExperimenterMultipartHeader) ProtoMessage() {}
+func (m *OfpExperimenterMultipartHeader) GetExperimenter() uint32 {
+ return (*openflow_13.OfpExperimenterMultipartHeader)(m).GetExperimenter()
+}
+func (m *OfpExperimenterMultipartHeader) GetExpType() uint32 {
+ return (*openflow_13.OfpExperimenterMultipartHeader)(m).GetExpType()
+}
+func (m *OfpExperimenterMultipartHeader) GetData() []byte {
+ return (*openflow_13.OfpExperimenterMultipartHeader)(m).GetData()
+}
+
+// ofp_experimenter_header from public import openflow_13.proto
+type OfpExperimenterHeader openflow_13.OfpExperimenterHeader
+
+func (m *OfpExperimenterHeader) Reset() { (*openflow_13.OfpExperimenterHeader)(m).Reset() }
+func (m *OfpExperimenterHeader) String() string {
+ return (*openflow_13.OfpExperimenterHeader)(m).String()
+}
+func (*OfpExperimenterHeader) ProtoMessage() {}
+func (m *OfpExperimenterHeader) GetExperimenter() uint32 {
+ return (*openflow_13.OfpExperimenterHeader)(m).GetExperimenter()
+}
+func (m *OfpExperimenterHeader) GetExpType() uint32 {
+ return (*openflow_13.OfpExperimenterHeader)(m).GetExpType()
+}
+func (m *OfpExperimenterHeader) GetData() []byte {
+ return (*openflow_13.OfpExperimenterHeader)(m).GetData()
+}
+
+// ofp_queue_prop_header from public import openflow_13.proto
+type OfpQueuePropHeader openflow_13.OfpQueuePropHeader
+
+func (m *OfpQueuePropHeader) Reset() { (*openflow_13.OfpQueuePropHeader)(m).Reset() }
+func (m *OfpQueuePropHeader) String() string { return (*openflow_13.OfpQueuePropHeader)(m).String() }
+func (*OfpQueuePropHeader) ProtoMessage() {}
+func (m *OfpQueuePropHeader) GetProperty() uint32 {
+ return (*openflow_13.OfpQueuePropHeader)(m).GetProperty()
+}
+func (m *OfpQueuePropHeader) GetLen() uint32 { return (*openflow_13.OfpQueuePropHeader)(m).GetLen() }
+
+// ofp_queue_prop_min_rate from public import openflow_13.proto
+type OfpQueuePropMinRate openflow_13.OfpQueuePropMinRate
+
+func (m *OfpQueuePropMinRate) Reset() { (*openflow_13.OfpQueuePropMinRate)(m).Reset() }
+func (m *OfpQueuePropMinRate) String() string { return (*openflow_13.OfpQueuePropMinRate)(m).String() }
+func (*OfpQueuePropMinRate) ProtoMessage() {}
+func (m *OfpQueuePropMinRate) GetPropHeader() *OfpQueuePropHeader {
+ return (*OfpQueuePropHeader)((*openflow_13.OfpQueuePropMinRate)(m).GetPropHeader())
+}
+func (m *OfpQueuePropMinRate) GetRate() uint32 { return (*openflow_13.OfpQueuePropMinRate)(m).GetRate() }
+
+// ofp_queue_prop_max_rate from public import openflow_13.proto
+type OfpQueuePropMaxRate openflow_13.OfpQueuePropMaxRate
+
+func (m *OfpQueuePropMaxRate) Reset() { (*openflow_13.OfpQueuePropMaxRate)(m).Reset() }
+func (m *OfpQueuePropMaxRate) String() string { return (*openflow_13.OfpQueuePropMaxRate)(m).String() }
+func (*OfpQueuePropMaxRate) ProtoMessage() {}
+func (m *OfpQueuePropMaxRate) GetPropHeader() *OfpQueuePropHeader {
+ return (*OfpQueuePropHeader)((*openflow_13.OfpQueuePropMaxRate)(m).GetPropHeader())
+}
+func (m *OfpQueuePropMaxRate) GetRate() uint32 { return (*openflow_13.OfpQueuePropMaxRate)(m).GetRate() }
+
+// ofp_queue_prop_experimenter from public import openflow_13.proto
+type OfpQueuePropExperimenter openflow_13.OfpQueuePropExperimenter
+
+func (m *OfpQueuePropExperimenter) Reset() { (*openflow_13.OfpQueuePropExperimenter)(m).Reset() }
+func (m *OfpQueuePropExperimenter) String() string {
+ return (*openflow_13.OfpQueuePropExperimenter)(m).String()
+}
+func (*OfpQueuePropExperimenter) ProtoMessage() {}
+func (m *OfpQueuePropExperimenter) GetPropHeader() *OfpQueuePropHeader {
+ return (*OfpQueuePropHeader)((*openflow_13.OfpQueuePropExperimenter)(m).GetPropHeader())
+}
+func (m *OfpQueuePropExperimenter) GetExperimenter() uint32 {
+ return (*openflow_13.OfpQueuePropExperimenter)(m).GetExperimenter()
+}
+func (m *OfpQueuePropExperimenter) GetData() []byte {
+ return (*openflow_13.OfpQueuePropExperimenter)(m).GetData()
+}
+
+// ofp_packet_queue from public import openflow_13.proto
+type OfpPacketQueue openflow_13.OfpPacketQueue
+
+func (m *OfpPacketQueue) Reset() { (*openflow_13.OfpPacketQueue)(m).Reset() }
+func (m *OfpPacketQueue) String() string { return (*openflow_13.OfpPacketQueue)(m).String() }
+func (*OfpPacketQueue) ProtoMessage() {}
+func (m *OfpPacketQueue) GetQueueId() uint32 { return (*openflow_13.OfpPacketQueue)(m).GetQueueId() }
+func (m *OfpPacketQueue) GetPort() uint32 { return (*openflow_13.OfpPacketQueue)(m).GetPort() }
+func (m *OfpPacketQueue) GetProperties() []*OfpQueuePropHeader {
+ o := (*openflow_13.OfpPacketQueue)(m).GetProperties()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpQueuePropHeader, len(o))
+ for i, x := range o {
+ s[i] = (*OfpQueuePropHeader)(x)
+ }
+ return s
+}
+
+// ofp_queue_get_config_request from public import openflow_13.proto
+type OfpQueueGetConfigRequest openflow_13.OfpQueueGetConfigRequest
+
+func (m *OfpQueueGetConfigRequest) Reset() { (*openflow_13.OfpQueueGetConfigRequest)(m).Reset() }
+func (m *OfpQueueGetConfigRequest) String() string {
+ return (*openflow_13.OfpQueueGetConfigRequest)(m).String()
+}
+func (*OfpQueueGetConfigRequest) ProtoMessage() {}
+func (m *OfpQueueGetConfigRequest) GetPort() uint32 {
+ return (*openflow_13.OfpQueueGetConfigRequest)(m).GetPort()
+}
+
+// ofp_queue_get_config_reply from public import openflow_13.proto
+type OfpQueueGetConfigReply openflow_13.OfpQueueGetConfigReply
+
+func (m *OfpQueueGetConfigReply) Reset() { (*openflow_13.OfpQueueGetConfigReply)(m).Reset() }
+func (m *OfpQueueGetConfigReply) String() string {
+ return (*openflow_13.OfpQueueGetConfigReply)(m).String()
+}
+func (*OfpQueueGetConfigReply) ProtoMessage() {}
+func (m *OfpQueueGetConfigReply) GetPort() uint32 {
+ return (*openflow_13.OfpQueueGetConfigReply)(m).GetPort()
+}
+func (m *OfpQueueGetConfigReply) GetQueues() []*OfpPacketQueue {
+ o := (*openflow_13.OfpQueueGetConfigReply)(m).GetQueues()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpPacketQueue, len(o))
+ for i, x := range o {
+ s[i] = (*OfpPacketQueue)(x)
+ }
+ return s
+}
+
+// ofp_action_set_queue from public import openflow_13.proto
+type OfpActionSetQueue openflow_13.OfpActionSetQueue
+
+func (m *OfpActionSetQueue) Reset() { (*openflow_13.OfpActionSetQueue)(m).Reset() }
+func (m *OfpActionSetQueue) String() string { return (*openflow_13.OfpActionSetQueue)(m).String() }
+func (*OfpActionSetQueue) ProtoMessage() {}
+func (m *OfpActionSetQueue) GetType() uint32 { return (*openflow_13.OfpActionSetQueue)(m).GetType() }
+func (m *OfpActionSetQueue) GetQueueId() uint32 {
+ return (*openflow_13.OfpActionSetQueue)(m).GetQueueId()
+}
+
+// ofp_queue_stats_request from public import openflow_13.proto
+type OfpQueueStatsRequest openflow_13.OfpQueueStatsRequest
+
+func (m *OfpQueueStatsRequest) Reset() { (*openflow_13.OfpQueueStatsRequest)(m).Reset() }
+func (m *OfpQueueStatsRequest) String() string { return (*openflow_13.OfpQueueStatsRequest)(m).String() }
+func (*OfpQueueStatsRequest) ProtoMessage() {}
+func (m *OfpQueueStatsRequest) GetPortNo() uint32 {
+ return (*openflow_13.OfpQueueStatsRequest)(m).GetPortNo()
+}
+func (m *OfpQueueStatsRequest) GetQueueId() uint32 {
+ return (*openflow_13.OfpQueueStatsRequest)(m).GetQueueId()
+}
+
+// ofp_queue_stats from public import openflow_13.proto
+type OfpQueueStats openflow_13.OfpQueueStats
+
+func (m *OfpQueueStats) Reset() { (*openflow_13.OfpQueueStats)(m).Reset() }
+func (m *OfpQueueStats) String() string { return (*openflow_13.OfpQueueStats)(m).String() }
+func (*OfpQueueStats) ProtoMessage() {}
+func (m *OfpQueueStats) GetPortNo() uint32 { return (*openflow_13.OfpQueueStats)(m).GetPortNo() }
+func (m *OfpQueueStats) GetQueueId() uint32 { return (*openflow_13.OfpQueueStats)(m).GetQueueId() }
+func (m *OfpQueueStats) GetTxBytes() uint64 { return (*openflow_13.OfpQueueStats)(m).GetTxBytes() }
+func (m *OfpQueueStats) GetTxPackets() uint64 { return (*openflow_13.OfpQueueStats)(m).GetTxPackets() }
+func (m *OfpQueueStats) GetTxErrors() uint64 { return (*openflow_13.OfpQueueStats)(m).GetTxErrors() }
+func (m *OfpQueueStats) GetDurationSec() uint32 {
+ return (*openflow_13.OfpQueueStats)(m).GetDurationSec()
+}
+func (m *OfpQueueStats) GetDurationNsec() uint32 {
+ return (*openflow_13.OfpQueueStats)(m).GetDurationNsec()
+}
+
+// ofp_role_request from public import openflow_13.proto
+type OfpRoleRequest openflow_13.OfpRoleRequest
+
+func (m *OfpRoleRequest) Reset() { (*openflow_13.OfpRoleRequest)(m).Reset() }
+func (m *OfpRoleRequest) String() string { return (*openflow_13.OfpRoleRequest)(m).String() }
+func (*OfpRoleRequest) ProtoMessage() {}
+func (m *OfpRoleRequest) GetRole() OfpControllerRole {
+ return (OfpControllerRole)((*openflow_13.OfpRoleRequest)(m).GetRole())
+}
+func (m *OfpRoleRequest) GetGenerationId() uint64 {
+ return (*openflow_13.OfpRoleRequest)(m).GetGenerationId()
+}
+
+// ofp_async_config from public import openflow_13.proto
+type OfpAsyncConfig openflow_13.OfpAsyncConfig
+
+func (m *OfpAsyncConfig) Reset() { (*openflow_13.OfpAsyncConfig)(m).Reset() }
+func (m *OfpAsyncConfig) String() string { return (*openflow_13.OfpAsyncConfig)(m).String() }
+func (*OfpAsyncConfig) ProtoMessage() {}
+func (m *OfpAsyncConfig) GetPacketInMask() []uint32 {
+ return (*openflow_13.OfpAsyncConfig)(m).GetPacketInMask()
+}
+func (m *OfpAsyncConfig) GetPortStatusMask() []uint32 {
+ return (*openflow_13.OfpAsyncConfig)(m).GetPortStatusMask()
+}
+func (m *OfpAsyncConfig) GetFlowRemovedMask() []uint32 {
+ return (*openflow_13.OfpAsyncConfig)(m).GetFlowRemovedMask()
+}
+
+// FlowTableUpdate from public import openflow_13.proto
+type FlowTableUpdate openflow_13.FlowTableUpdate
+
+func (m *FlowTableUpdate) Reset() { (*openflow_13.FlowTableUpdate)(m).Reset() }
+func (m *FlowTableUpdate) String() string { return (*openflow_13.FlowTableUpdate)(m).String() }
+func (*FlowTableUpdate) ProtoMessage() {}
+func (m *FlowTableUpdate) GetId() string { return (*openflow_13.FlowTableUpdate)(m).GetId() }
+func (m *FlowTableUpdate) GetFlowMod() *OfpFlowMod {
+ return (*OfpFlowMod)((*openflow_13.FlowTableUpdate)(m).GetFlowMod())
+}
+
+// FlowGroupTableUpdate from public import openflow_13.proto
+type FlowGroupTableUpdate openflow_13.FlowGroupTableUpdate
+
+func (m *FlowGroupTableUpdate) Reset() { (*openflow_13.FlowGroupTableUpdate)(m).Reset() }
+func (m *FlowGroupTableUpdate) String() string { return (*openflow_13.FlowGroupTableUpdate)(m).String() }
+func (*FlowGroupTableUpdate) ProtoMessage() {}
+func (m *FlowGroupTableUpdate) GetId() string { return (*openflow_13.FlowGroupTableUpdate)(m).GetId() }
+func (m *FlowGroupTableUpdate) GetGroupMod() *OfpGroupMod {
+ return (*OfpGroupMod)((*openflow_13.FlowGroupTableUpdate)(m).GetGroupMod())
+}
+
+// Flows from public import openflow_13.proto
+type Flows openflow_13.Flows
+
+func (m *Flows) Reset() { (*openflow_13.Flows)(m).Reset() }
+func (m *Flows) String() string { return (*openflow_13.Flows)(m).String() }
+func (*Flows) ProtoMessage() {}
+func (m *Flows) GetItems() []*OfpFlowStats {
+ o := (*openflow_13.Flows)(m).GetItems()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpFlowStats, len(o))
+ for i, x := range o {
+ s[i] = (*OfpFlowStats)(x)
+ }
+ return s
+}
+
+// FlowGroups from public import openflow_13.proto
+type FlowGroups openflow_13.FlowGroups
+
+func (m *FlowGroups) Reset() { (*openflow_13.FlowGroups)(m).Reset() }
+func (m *FlowGroups) String() string { return (*openflow_13.FlowGroups)(m).String() }
+func (*FlowGroups) ProtoMessage() {}
+func (m *FlowGroups) GetItems() []*OfpGroupEntry {
+ o := (*openflow_13.FlowGroups)(m).GetItems()
+ if o == nil {
+ return nil
+ }
+ s := make([]*OfpGroupEntry, len(o))
+ for i, x := range o {
+ s[i] = (*OfpGroupEntry)(x)
+ }
+ return s
+}
+
+// PacketIn from public import openflow_13.proto
+type PacketIn openflow_13.PacketIn
+
+func (m *PacketIn) Reset() { (*openflow_13.PacketIn)(m).Reset() }
+func (m *PacketIn) String() string { return (*openflow_13.PacketIn)(m).String() }
+func (*PacketIn) ProtoMessage() {}
+func (m *PacketIn) GetId() string { return (*openflow_13.PacketIn)(m).GetId() }
+func (m *PacketIn) GetPacketIn() *OfpPacketIn {
+ return (*OfpPacketIn)((*openflow_13.PacketIn)(m).GetPacketIn())
+}
+
+// PacketOut from public import openflow_13.proto
+type PacketOut openflow_13.PacketOut
+
+func (m *PacketOut) Reset() { (*openflow_13.PacketOut)(m).Reset() }
+func (m *PacketOut) String() string { return (*openflow_13.PacketOut)(m).String() }
+func (*PacketOut) ProtoMessage() {}
+func (m *PacketOut) GetId() string { return (*openflow_13.PacketOut)(m).GetId() }
+func (m *PacketOut) GetPacketOut() *OfpPacketOut {
+ return (*OfpPacketOut)((*openflow_13.PacketOut)(m).GetPacketOut())
+}
+
+// ChangeEvent from public import openflow_13.proto
+type ChangeEvent openflow_13.ChangeEvent
+
+func (m *ChangeEvent) Reset() { (*openflow_13.ChangeEvent)(m).Reset() }
+func (m *ChangeEvent) String() string { return (*openflow_13.ChangeEvent)(m).String() }
+func (*ChangeEvent) ProtoMessage() {}
+func (m *ChangeEvent) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+ return _ChangeEvent_OneofMarshaler, _ChangeEvent_OneofUnmarshaler, _ChangeEvent_OneofSizer, nil
+}
+func _ChangeEvent_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*ChangeEvent)
+ m0 := (*openflow_13.ChangeEvent)(m)
+ enc, _, _, _ := m0.XXX_OneofFuncs()
+ return enc(m0, b)
+}
+func _ChangeEvent_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*ChangeEvent)
+ m0 := (*openflow_13.ChangeEvent)(m)
+ _, dec, _, _ := m0.XXX_OneofFuncs()
+ return dec(m0, tag, wire, b)
+}
+func _ChangeEvent_OneofSizer(msg proto.Message) int {
+ m := msg.(*ChangeEvent)
+ m0 := (*openflow_13.ChangeEvent)(m)
+ _, _, size, _ := m0.XXX_OneofFuncs()
+ return size(m0)
+}
+func (m *ChangeEvent) GetId() string { return (*openflow_13.ChangeEvent)(m).GetId() }
+func (m *ChangeEvent) GetPortStatus() *OfpPortStatus {
+ return (*OfpPortStatus)((*openflow_13.ChangeEvent)(m).GetPortStatus())
+}
+
+// ofp_port_no from public import openflow_13.proto
+type OfpPortNo openflow_13.OfpPortNo
+
+var OfpPortNo_name = openflow_13.OfpPortNo_name
+var OfpPortNo_value = openflow_13.OfpPortNo_value
+
+func (x OfpPortNo) String() string { return (openflow_13.OfpPortNo)(x).String() }
+
+const OfpPortNo_OFPP_INVALID = OfpPortNo(openflow_13.OfpPortNo_OFPP_INVALID)
+const OfpPortNo_OFPP_MAX = OfpPortNo(openflow_13.OfpPortNo_OFPP_MAX)
+const OfpPortNo_OFPP_IN_PORT = OfpPortNo(openflow_13.OfpPortNo_OFPP_IN_PORT)
+const OfpPortNo_OFPP_TABLE = OfpPortNo(openflow_13.OfpPortNo_OFPP_TABLE)
+const OfpPortNo_OFPP_NORMAL = OfpPortNo(openflow_13.OfpPortNo_OFPP_NORMAL)
+const OfpPortNo_OFPP_FLOOD = OfpPortNo(openflow_13.OfpPortNo_OFPP_FLOOD)
+const OfpPortNo_OFPP_ALL = OfpPortNo(openflow_13.OfpPortNo_OFPP_ALL)
+const OfpPortNo_OFPP_CONTROLLER = OfpPortNo(openflow_13.OfpPortNo_OFPP_CONTROLLER)
+const OfpPortNo_OFPP_LOCAL = OfpPortNo(openflow_13.OfpPortNo_OFPP_LOCAL)
+const OfpPortNo_OFPP_ANY = OfpPortNo(openflow_13.OfpPortNo_OFPP_ANY)
+
+// ofp_type from public import openflow_13.proto
+type OfpType openflow_13.OfpType
+
+var OfpType_name = openflow_13.OfpType_name
+var OfpType_value = openflow_13.OfpType_value
+
+func (x OfpType) String() string { return (openflow_13.OfpType)(x).String() }
+
+const OfpType_OFPT_HELLO = OfpType(openflow_13.OfpType_OFPT_HELLO)
+const OfpType_OFPT_ERROR = OfpType(openflow_13.OfpType_OFPT_ERROR)
+const OfpType_OFPT_ECHO_REQUEST = OfpType(openflow_13.OfpType_OFPT_ECHO_REQUEST)
+const OfpType_OFPT_ECHO_REPLY = OfpType(openflow_13.OfpType_OFPT_ECHO_REPLY)
+const OfpType_OFPT_EXPERIMENTER = OfpType(openflow_13.OfpType_OFPT_EXPERIMENTER)
+const OfpType_OFPT_FEATURES_REQUEST = OfpType(openflow_13.OfpType_OFPT_FEATURES_REQUEST)
+const OfpType_OFPT_FEATURES_REPLY = OfpType(openflow_13.OfpType_OFPT_FEATURES_REPLY)
+const OfpType_OFPT_GET_CONFIG_REQUEST = OfpType(openflow_13.OfpType_OFPT_GET_CONFIG_REQUEST)
+const OfpType_OFPT_GET_CONFIG_REPLY = OfpType(openflow_13.OfpType_OFPT_GET_CONFIG_REPLY)
+const OfpType_OFPT_SET_CONFIG = OfpType(openflow_13.OfpType_OFPT_SET_CONFIG)
+const OfpType_OFPT_PACKET_IN = OfpType(openflow_13.OfpType_OFPT_PACKET_IN)
+const OfpType_OFPT_FLOW_REMOVED = OfpType(openflow_13.OfpType_OFPT_FLOW_REMOVED)
+const OfpType_OFPT_PORT_STATUS = OfpType(openflow_13.OfpType_OFPT_PORT_STATUS)
+const OfpType_OFPT_PACKET_OUT = OfpType(openflow_13.OfpType_OFPT_PACKET_OUT)
+const OfpType_OFPT_FLOW_MOD = OfpType(openflow_13.OfpType_OFPT_FLOW_MOD)
+const OfpType_OFPT_GROUP_MOD = OfpType(openflow_13.OfpType_OFPT_GROUP_MOD)
+const OfpType_OFPT_PORT_MOD = OfpType(openflow_13.OfpType_OFPT_PORT_MOD)
+const OfpType_OFPT_TABLE_MOD = OfpType(openflow_13.OfpType_OFPT_TABLE_MOD)
+const OfpType_OFPT_MULTIPART_REQUEST = OfpType(openflow_13.OfpType_OFPT_MULTIPART_REQUEST)
+const OfpType_OFPT_MULTIPART_REPLY = OfpType(openflow_13.OfpType_OFPT_MULTIPART_REPLY)
+const OfpType_OFPT_BARRIER_REQUEST = OfpType(openflow_13.OfpType_OFPT_BARRIER_REQUEST)
+const OfpType_OFPT_BARRIER_REPLY = OfpType(openflow_13.OfpType_OFPT_BARRIER_REPLY)
+const OfpType_OFPT_QUEUE_GET_CONFIG_REQUEST = OfpType(openflow_13.OfpType_OFPT_QUEUE_GET_CONFIG_REQUEST)
+const OfpType_OFPT_QUEUE_GET_CONFIG_REPLY = OfpType(openflow_13.OfpType_OFPT_QUEUE_GET_CONFIG_REPLY)
+const OfpType_OFPT_ROLE_REQUEST = OfpType(openflow_13.OfpType_OFPT_ROLE_REQUEST)
+const OfpType_OFPT_ROLE_REPLY = OfpType(openflow_13.OfpType_OFPT_ROLE_REPLY)
+const OfpType_OFPT_GET_ASYNC_REQUEST = OfpType(openflow_13.OfpType_OFPT_GET_ASYNC_REQUEST)
+const OfpType_OFPT_GET_ASYNC_REPLY = OfpType(openflow_13.OfpType_OFPT_GET_ASYNC_REPLY)
+const OfpType_OFPT_SET_ASYNC = OfpType(openflow_13.OfpType_OFPT_SET_ASYNC)
+const OfpType_OFPT_METER_MOD = OfpType(openflow_13.OfpType_OFPT_METER_MOD)
+
+// ofp_hello_elem_type from public import openflow_13.proto
+type OfpHelloElemType openflow_13.OfpHelloElemType
+
+var OfpHelloElemType_name = openflow_13.OfpHelloElemType_name
+var OfpHelloElemType_value = openflow_13.OfpHelloElemType_value
+
+func (x OfpHelloElemType) String() string { return (openflow_13.OfpHelloElemType)(x).String() }
+
+const OfpHelloElemType_OFPHET_INVALID = OfpHelloElemType(openflow_13.OfpHelloElemType_OFPHET_INVALID)
+const OfpHelloElemType_OFPHET_VERSIONBITMAP = OfpHelloElemType(openflow_13.OfpHelloElemType_OFPHET_VERSIONBITMAP)
+
+// ofp_config_flags from public import openflow_13.proto
+type OfpConfigFlags openflow_13.OfpConfigFlags
+
+var OfpConfigFlags_name = openflow_13.OfpConfigFlags_name
+var OfpConfigFlags_value = openflow_13.OfpConfigFlags_value
+
+func (x OfpConfigFlags) String() string { return (openflow_13.OfpConfigFlags)(x).String() }
+
+const OfpConfigFlags_OFPC_FRAG_NORMAL = OfpConfigFlags(openflow_13.OfpConfigFlags_OFPC_FRAG_NORMAL)
+const OfpConfigFlags_OFPC_FRAG_DROP = OfpConfigFlags(openflow_13.OfpConfigFlags_OFPC_FRAG_DROP)
+const OfpConfigFlags_OFPC_FRAG_REASM = OfpConfigFlags(openflow_13.OfpConfigFlags_OFPC_FRAG_REASM)
+const OfpConfigFlags_OFPC_FRAG_MASK = OfpConfigFlags(openflow_13.OfpConfigFlags_OFPC_FRAG_MASK)
+
+// ofp_table_config from public import openflow_13.proto
+type OfpTableConfig openflow_13.OfpTableConfig
+
+var OfpTableConfig_name = openflow_13.OfpTableConfig_name
+var OfpTableConfig_value = openflow_13.OfpTableConfig_value
+
+func (x OfpTableConfig) String() string { return (openflow_13.OfpTableConfig)(x).String() }
+
+const OfpTableConfig_OFPTC_INVALID = OfpTableConfig(openflow_13.OfpTableConfig_OFPTC_INVALID)
+const OfpTableConfig_OFPTC_DEPRECATED_MASK = OfpTableConfig(openflow_13.OfpTableConfig_OFPTC_DEPRECATED_MASK)
+
+// ofp_table from public import openflow_13.proto
+type OfpTable openflow_13.OfpTable
+
+var OfpTable_name = openflow_13.OfpTable_name
+var OfpTable_value = openflow_13.OfpTable_value
+
+func (x OfpTable) String() string { return (openflow_13.OfpTable)(x).String() }
+
+const OfpTable_OFPTT_INVALID = OfpTable(openflow_13.OfpTable_OFPTT_INVALID)
+const OfpTable_OFPTT_MAX = OfpTable(openflow_13.OfpTable_OFPTT_MAX)
+const OfpTable_OFPTT_ALL = OfpTable(openflow_13.OfpTable_OFPTT_ALL)
+
+// ofp_capabilities from public import openflow_13.proto
+type OfpCapabilities openflow_13.OfpCapabilities
+
+var OfpCapabilities_name = openflow_13.OfpCapabilities_name
+var OfpCapabilities_value = openflow_13.OfpCapabilities_value
+
+func (x OfpCapabilities) String() string { return (openflow_13.OfpCapabilities)(x).String() }
+
+const OfpCapabilities_OFPC_INVALID = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_INVALID)
+const OfpCapabilities_OFPC_FLOW_STATS = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_FLOW_STATS)
+const OfpCapabilities_OFPC_TABLE_STATS = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_TABLE_STATS)
+const OfpCapabilities_OFPC_PORT_STATS = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_PORT_STATS)
+const OfpCapabilities_OFPC_GROUP_STATS = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_GROUP_STATS)
+const OfpCapabilities_OFPC_IP_REASM = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_IP_REASM)
+const OfpCapabilities_OFPC_QUEUE_STATS = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_QUEUE_STATS)
+const OfpCapabilities_OFPC_PORT_BLOCKED = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_PORT_BLOCKED)
+
+// ofp_port_config from public import openflow_13.proto
+type OfpPortConfig openflow_13.OfpPortConfig
+
+var OfpPortConfig_name = openflow_13.OfpPortConfig_name
+var OfpPortConfig_value = openflow_13.OfpPortConfig_value
+
+func (x OfpPortConfig) String() string { return (openflow_13.OfpPortConfig)(x).String() }
+
+const OfpPortConfig_OFPPC_INVALID = OfpPortConfig(openflow_13.OfpPortConfig_OFPPC_INVALID)
+const OfpPortConfig_OFPPC_PORT_DOWN = OfpPortConfig(openflow_13.OfpPortConfig_OFPPC_PORT_DOWN)
+const OfpPortConfig_OFPPC_NO_RECV = OfpPortConfig(openflow_13.OfpPortConfig_OFPPC_NO_RECV)
+const OfpPortConfig_OFPPC_NO_FWD = OfpPortConfig(openflow_13.OfpPortConfig_OFPPC_NO_FWD)
+const OfpPortConfig_OFPPC_NO_PACKET_IN = OfpPortConfig(openflow_13.OfpPortConfig_OFPPC_NO_PACKET_IN)
+
+// ofp_port_state from public import openflow_13.proto
+type OfpPortState openflow_13.OfpPortState
+
+var OfpPortState_name = openflow_13.OfpPortState_name
+var OfpPortState_value = openflow_13.OfpPortState_value
+
+func (x OfpPortState) String() string { return (openflow_13.OfpPortState)(x).String() }
+
+const OfpPortState_OFPPS_INVALID = OfpPortState(openflow_13.OfpPortState_OFPPS_INVALID)
+const OfpPortState_OFPPS_LINK_DOWN = OfpPortState(openflow_13.OfpPortState_OFPPS_LINK_DOWN)
+const OfpPortState_OFPPS_BLOCKED = OfpPortState(openflow_13.OfpPortState_OFPPS_BLOCKED)
+const OfpPortState_OFPPS_LIVE = OfpPortState(openflow_13.OfpPortState_OFPPS_LIVE)
+
+// ofp_port_features from public import openflow_13.proto
+type OfpPortFeatures openflow_13.OfpPortFeatures
+
+var OfpPortFeatures_name = openflow_13.OfpPortFeatures_name
+var OfpPortFeatures_value = openflow_13.OfpPortFeatures_value
+
+func (x OfpPortFeatures) String() string { return (openflow_13.OfpPortFeatures)(x).String() }
+
+const OfpPortFeatures_OFPPF_INVALID = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_INVALID)
+const OfpPortFeatures_OFPPF_10MB_HD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_10MB_HD)
+const OfpPortFeatures_OFPPF_10MB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_10MB_FD)
+const OfpPortFeatures_OFPPF_100MB_HD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_100MB_HD)
+const OfpPortFeatures_OFPPF_100MB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_100MB_FD)
+const OfpPortFeatures_OFPPF_1GB_HD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_1GB_HD)
+const OfpPortFeatures_OFPPF_1GB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_1GB_FD)
+const OfpPortFeatures_OFPPF_10GB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_10GB_FD)
+const OfpPortFeatures_OFPPF_40GB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_40GB_FD)
+const OfpPortFeatures_OFPPF_100GB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_100GB_FD)
+const OfpPortFeatures_OFPPF_1TB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_1TB_FD)
+const OfpPortFeatures_OFPPF_OTHER = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_OTHER)
+const OfpPortFeatures_OFPPF_COPPER = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_COPPER)
+const OfpPortFeatures_OFPPF_FIBER = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_FIBER)
+const OfpPortFeatures_OFPPF_AUTONEG = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_AUTONEG)
+const OfpPortFeatures_OFPPF_PAUSE = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_PAUSE)
+const OfpPortFeatures_OFPPF_PAUSE_ASYM = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_PAUSE_ASYM)
+
+// ofp_port_reason from public import openflow_13.proto
+type OfpPortReason openflow_13.OfpPortReason
+
+var OfpPortReason_name = openflow_13.OfpPortReason_name
+var OfpPortReason_value = openflow_13.OfpPortReason_value
+
+func (x OfpPortReason) String() string { return (openflow_13.OfpPortReason)(x).String() }
+
+const OfpPortReason_OFPPR_ADD = OfpPortReason(openflow_13.OfpPortReason_OFPPR_ADD)
+const OfpPortReason_OFPPR_DELETE = OfpPortReason(openflow_13.OfpPortReason_OFPPR_DELETE)
+const OfpPortReason_OFPPR_MODIFY = OfpPortReason(openflow_13.OfpPortReason_OFPPR_MODIFY)
+
+// ofp_match_type from public import openflow_13.proto
+type OfpMatchType openflow_13.OfpMatchType
+
+var OfpMatchType_name = openflow_13.OfpMatchType_name
+var OfpMatchType_value = openflow_13.OfpMatchType_value
+
+func (x OfpMatchType) String() string { return (openflow_13.OfpMatchType)(x).String() }
+
+const OfpMatchType_OFPMT_STANDARD = OfpMatchType(openflow_13.OfpMatchType_OFPMT_STANDARD)
+const OfpMatchType_OFPMT_OXM = OfpMatchType(openflow_13.OfpMatchType_OFPMT_OXM)
+
+// ofp_oxm_class from public import openflow_13.proto
+type OfpOxmClass openflow_13.OfpOxmClass
+
+var OfpOxmClass_name = openflow_13.OfpOxmClass_name
+var OfpOxmClass_value = openflow_13.OfpOxmClass_value
+
+func (x OfpOxmClass) String() string { return (openflow_13.OfpOxmClass)(x).String() }
+
+const OfpOxmClass_OFPXMC_NXM_0 = OfpOxmClass(openflow_13.OfpOxmClass_OFPXMC_NXM_0)
+const OfpOxmClass_OFPXMC_NXM_1 = OfpOxmClass(openflow_13.OfpOxmClass_OFPXMC_NXM_1)
+const OfpOxmClass_OFPXMC_OPENFLOW_BASIC = OfpOxmClass(openflow_13.OfpOxmClass_OFPXMC_OPENFLOW_BASIC)
+const OfpOxmClass_OFPXMC_EXPERIMENTER = OfpOxmClass(openflow_13.OfpOxmClass_OFPXMC_EXPERIMENTER)
+
+// oxm_ofb_field_types from public import openflow_13.proto
+type OxmOfbFieldTypes openflow_13.OxmOfbFieldTypes
+
+var OxmOfbFieldTypes_name = openflow_13.OxmOfbFieldTypes_name
+var OxmOfbFieldTypes_value = openflow_13.OxmOfbFieldTypes_value
+
+func (x OxmOfbFieldTypes) String() string { return (openflow_13.OxmOfbFieldTypes)(x).String() }
+
+const OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT)
+const OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT)
+const OxmOfbFieldTypes_OFPXMT_OFB_METADATA = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_METADATA)
+const OxmOfbFieldTypes_OFPXMT_OFB_ETH_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_ETH_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE)
+const OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID)
+const OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP)
+const OxmOfbFieldTypes_OFPXMT_OFB_IP_DSCP = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IP_DSCP)
+const OxmOfbFieldTypes_OFPXMT_OFB_IP_ECN = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IP_ECN)
+const OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV4_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_TCP_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_TCP_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_TCP_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_TCP_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_SCTP_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_SCTP_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_SCTP_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_SCTP_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_TYPE = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_TYPE)
+const OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_CODE = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_CODE)
+const OxmOfbFieldTypes_OFPXMT_OFB_ARP_OP = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ARP_OP)
+const OxmOfbFieldTypes_OFPXMT_OFB_ARP_SPA = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ARP_SPA)
+const OxmOfbFieldTypes_OFPXMT_OFB_ARP_TPA = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ARP_TPA)
+const OxmOfbFieldTypes_OFPXMT_OFB_ARP_SHA = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ARP_SHA)
+const OxmOfbFieldTypes_OFPXMT_OFB_ARP_THA = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ARP_THA)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_FLABEL = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_FLABEL)
+const OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_TYPE = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_TYPE)
+const OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_CODE = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_CODE)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TARGET = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TARGET)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_SLL = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_SLL)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TLL = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TLL)
+const OxmOfbFieldTypes_OFPXMT_OFB_MPLS_LABEL = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_MPLS_LABEL)
+const OxmOfbFieldTypes_OFPXMT_OFB_MPLS_TC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_MPLS_TC)
+const OxmOfbFieldTypes_OFPXMT_OFB_MPLS_BOS = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_MPLS_BOS)
+const OxmOfbFieldTypes_OFPXMT_OFB_PBB_ISID = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_PBB_ISID)
+const OxmOfbFieldTypes_OFPXMT_OFB_TUNNEL_ID = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_TUNNEL_ID)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_EXTHDR = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_EXTHDR)
+
+// ofp_vlan_id from public import openflow_13.proto
+type OfpVlanId openflow_13.OfpVlanId
+
+var OfpVlanId_name = openflow_13.OfpVlanId_name
+var OfpVlanId_value = openflow_13.OfpVlanId_value
+
+func (x OfpVlanId) String() string { return (openflow_13.OfpVlanId)(x).String() }
+
+const OfpVlanId_OFPVID_NONE = OfpVlanId(openflow_13.OfpVlanId_OFPVID_NONE)
+const OfpVlanId_OFPVID_PRESENT = OfpVlanId(openflow_13.OfpVlanId_OFPVID_PRESENT)
+
+// ofp_ipv6exthdr_flags from public import openflow_13.proto
+type OfpIpv6ExthdrFlags openflow_13.OfpIpv6ExthdrFlags
+
+var OfpIpv6ExthdrFlags_name = openflow_13.OfpIpv6ExthdrFlags_name
+var OfpIpv6ExthdrFlags_value = openflow_13.OfpIpv6ExthdrFlags_value
+
+func (x OfpIpv6ExthdrFlags) String() string { return (openflow_13.OfpIpv6ExthdrFlags)(x).String() }
+
+const OfpIpv6ExthdrFlags_OFPIEH_INVALID = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_INVALID)
+const OfpIpv6ExthdrFlags_OFPIEH_NONEXT = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_NONEXT)
+const OfpIpv6ExthdrFlags_OFPIEH_ESP = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_ESP)
+const OfpIpv6ExthdrFlags_OFPIEH_AUTH = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_AUTH)
+const OfpIpv6ExthdrFlags_OFPIEH_DEST = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_DEST)
+const OfpIpv6ExthdrFlags_OFPIEH_FRAG = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_FRAG)
+const OfpIpv6ExthdrFlags_OFPIEH_ROUTER = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_ROUTER)
+const OfpIpv6ExthdrFlags_OFPIEH_HOP = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_HOP)
+const OfpIpv6ExthdrFlags_OFPIEH_UNREP = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_UNREP)
+const OfpIpv6ExthdrFlags_OFPIEH_UNSEQ = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_UNSEQ)
+
+// ofp_action_type from public import openflow_13.proto
+type OfpActionType openflow_13.OfpActionType
+
+var OfpActionType_name = openflow_13.OfpActionType_name
+var OfpActionType_value = openflow_13.OfpActionType_value
+
+func (x OfpActionType) String() string { return (openflow_13.OfpActionType)(x).String() }
+
+const OfpActionType_OFPAT_OUTPUT = OfpActionType(openflow_13.OfpActionType_OFPAT_OUTPUT)
+const OfpActionType_OFPAT_COPY_TTL_OUT = OfpActionType(openflow_13.OfpActionType_OFPAT_COPY_TTL_OUT)
+const OfpActionType_OFPAT_COPY_TTL_IN = OfpActionType(openflow_13.OfpActionType_OFPAT_COPY_TTL_IN)
+const OfpActionType_OFPAT_SET_MPLS_TTL = OfpActionType(openflow_13.OfpActionType_OFPAT_SET_MPLS_TTL)
+const OfpActionType_OFPAT_DEC_MPLS_TTL = OfpActionType(openflow_13.OfpActionType_OFPAT_DEC_MPLS_TTL)
+const OfpActionType_OFPAT_PUSH_VLAN = OfpActionType(openflow_13.OfpActionType_OFPAT_PUSH_VLAN)
+const OfpActionType_OFPAT_POP_VLAN = OfpActionType(openflow_13.OfpActionType_OFPAT_POP_VLAN)
+const OfpActionType_OFPAT_PUSH_MPLS = OfpActionType(openflow_13.OfpActionType_OFPAT_PUSH_MPLS)
+const OfpActionType_OFPAT_POP_MPLS = OfpActionType(openflow_13.OfpActionType_OFPAT_POP_MPLS)
+const OfpActionType_OFPAT_SET_QUEUE = OfpActionType(openflow_13.OfpActionType_OFPAT_SET_QUEUE)
+const OfpActionType_OFPAT_GROUP = OfpActionType(openflow_13.OfpActionType_OFPAT_GROUP)
+const OfpActionType_OFPAT_SET_NW_TTL = OfpActionType(openflow_13.OfpActionType_OFPAT_SET_NW_TTL)
+const OfpActionType_OFPAT_DEC_NW_TTL = OfpActionType(openflow_13.OfpActionType_OFPAT_DEC_NW_TTL)
+const OfpActionType_OFPAT_SET_FIELD = OfpActionType(openflow_13.OfpActionType_OFPAT_SET_FIELD)
+const OfpActionType_OFPAT_PUSH_PBB = OfpActionType(openflow_13.OfpActionType_OFPAT_PUSH_PBB)
+const OfpActionType_OFPAT_POP_PBB = OfpActionType(openflow_13.OfpActionType_OFPAT_POP_PBB)
+const OfpActionType_OFPAT_EXPERIMENTER = OfpActionType(openflow_13.OfpActionType_OFPAT_EXPERIMENTER)
+
+// ofp_controller_max_len from public import openflow_13.proto
+type OfpControllerMaxLen openflow_13.OfpControllerMaxLen
+
+var OfpControllerMaxLen_name = openflow_13.OfpControllerMaxLen_name
+var OfpControllerMaxLen_value = openflow_13.OfpControllerMaxLen_value
+
+func (x OfpControllerMaxLen) String() string { return (openflow_13.OfpControllerMaxLen)(x).String() }
+
+const OfpControllerMaxLen_OFPCML_INVALID = OfpControllerMaxLen(openflow_13.OfpControllerMaxLen_OFPCML_INVALID)
+const OfpControllerMaxLen_OFPCML_MAX = OfpControllerMaxLen(openflow_13.OfpControllerMaxLen_OFPCML_MAX)
+const OfpControllerMaxLen_OFPCML_NO_BUFFER = OfpControllerMaxLen(openflow_13.OfpControllerMaxLen_OFPCML_NO_BUFFER)
+
+// ofp_instruction_type from public import openflow_13.proto
+type OfpInstructionType openflow_13.OfpInstructionType
+
+var OfpInstructionType_name = openflow_13.OfpInstructionType_name
+var OfpInstructionType_value = openflow_13.OfpInstructionType_value
+
+func (x OfpInstructionType) String() string { return (openflow_13.OfpInstructionType)(x).String() }
+
+const OfpInstructionType_OFPIT_INVALID = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_INVALID)
+const OfpInstructionType_OFPIT_GOTO_TABLE = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_GOTO_TABLE)
+const OfpInstructionType_OFPIT_WRITE_METADATA = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_WRITE_METADATA)
+const OfpInstructionType_OFPIT_WRITE_ACTIONS = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_WRITE_ACTIONS)
+const OfpInstructionType_OFPIT_APPLY_ACTIONS = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_APPLY_ACTIONS)
+const OfpInstructionType_OFPIT_CLEAR_ACTIONS = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_CLEAR_ACTIONS)
+const OfpInstructionType_OFPIT_METER = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_METER)
+const OfpInstructionType_OFPIT_EXPERIMENTER = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_EXPERIMENTER)
+
+// ofp_flow_mod_command from public import openflow_13.proto
+type OfpFlowModCommand openflow_13.OfpFlowModCommand
+
+var OfpFlowModCommand_name = openflow_13.OfpFlowModCommand_name
+var OfpFlowModCommand_value = openflow_13.OfpFlowModCommand_value
+
+func (x OfpFlowModCommand) String() string { return (openflow_13.OfpFlowModCommand)(x).String() }
+
+const OfpFlowModCommand_OFPFC_ADD = OfpFlowModCommand(openflow_13.OfpFlowModCommand_OFPFC_ADD)
+const OfpFlowModCommand_OFPFC_MODIFY = OfpFlowModCommand(openflow_13.OfpFlowModCommand_OFPFC_MODIFY)
+const OfpFlowModCommand_OFPFC_MODIFY_STRICT = OfpFlowModCommand(openflow_13.OfpFlowModCommand_OFPFC_MODIFY_STRICT)
+const OfpFlowModCommand_OFPFC_DELETE = OfpFlowModCommand(openflow_13.OfpFlowModCommand_OFPFC_DELETE)
+const OfpFlowModCommand_OFPFC_DELETE_STRICT = OfpFlowModCommand(openflow_13.OfpFlowModCommand_OFPFC_DELETE_STRICT)
+
+// ofp_flow_mod_flags from public import openflow_13.proto
+type OfpFlowModFlags openflow_13.OfpFlowModFlags
+
+var OfpFlowModFlags_name = openflow_13.OfpFlowModFlags_name
+var OfpFlowModFlags_value = openflow_13.OfpFlowModFlags_value
+
+func (x OfpFlowModFlags) String() string { return (openflow_13.OfpFlowModFlags)(x).String() }
+
+const OfpFlowModFlags_OFPFF_INVALID = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_INVALID)
+const OfpFlowModFlags_OFPFF_SEND_FLOW_REM = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_SEND_FLOW_REM)
+const OfpFlowModFlags_OFPFF_CHECK_OVERLAP = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_CHECK_OVERLAP)
+const OfpFlowModFlags_OFPFF_RESET_COUNTS = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_RESET_COUNTS)
+const OfpFlowModFlags_OFPFF_NO_PKT_COUNTS = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_NO_PKT_COUNTS)
+const OfpFlowModFlags_OFPFF_NO_BYT_COUNTS = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_NO_BYT_COUNTS)
+
+// ofp_group from public import openflow_13.proto
+type OfpGroup openflow_13.OfpGroup
+
+var OfpGroup_name = openflow_13.OfpGroup_name
+var OfpGroup_value = openflow_13.OfpGroup_value
+
+func (x OfpGroup) String() string { return (openflow_13.OfpGroup)(x).String() }
+
+const OfpGroup_OFPG_INVALID = OfpGroup(openflow_13.OfpGroup_OFPG_INVALID)
+const OfpGroup_OFPG_MAX = OfpGroup(openflow_13.OfpGroup_OFPG_MAX)
+const OfpGroup_OFPG_ALL = OfpGroup(openflow_13.OfpGroup_OFPG_ALL)
+const OfpGroup_OFPG_ANY = OfpGroup(openflow_13.OfpGroup_OFPG_ANY)
+
+// ofp_group_mod_command from public import openflow_13.proto
+type OfpGroupModCommand openflow_13.OfpGroupModCommand
+
+var OfpGroupModCommand_name = openflow_13.OfpGroupModCommand_name
+var OfpGroupModCommand_value = openflow_13.OfpGroupModCommand_value
+
+func (x OfpGroupModCommand) String() string { return (openflow_13.OfpGroupModCommand)(x).String() }
+
+const OfpGroupModCommand_OFPGC_ADD = OfpGroupModCommand(openflow_13.OfpGroupModCommand_OFPGC_ADD)
+const OfpGroupModCommand_OFPGC_MODIFY = OfpGroupModCommand(openflow_13.OfpGroupModCommand_OFPGC_MODIFY)
+const OfpGroupModCommand_OFPGC_DELETE = OfpGroupModCommand(openflow_13.OfpGroupModCommand_OFPGC_DELETE)
+
+// ofp_group_type from public import openflow_13.proto
+type OfpGroupType openflow_13.OfpGroupType
+
+var OfpGroupType_name = openflow_13.OfpGroupType_name
+var OfpGroupType_value = openflow_13.OfpGroupType_value
+
+func (x OfpGroupType) String() string { return (openflow_13.OfpGroupType)(x).String() }
+
+const OfpGroupType_OFPGT_ALL = OfpGroupType(openflow_13.OfpGroupType_OFPGT_ALL)
+const OfpGroupType_OFPGT_SELECT = OfpGroupType(openflow_13.OfpGroupType_OFPGT_SELECT)
+const OfpGroupType_OFPGT_INDIRECT = OfpGroupType(openflow_13.OfpGroupType_OFPGT_INDIRECT)
+const OfpGroupType_OFPGT_FF = OfpGroupType(openflow_13.OfpGroupType_OFPGT_FF)
+
+// ofp_packet_in_reason from public import openflow_13.proto
+type OfpPacketInReason openflow_13.OfpPacketInReason
+
+var OfpPacketInReason_name = openflow_13.OfpPacketInReason_name
+var OfpPacketInReason_value = openflow_13.OfpPacketInReason_value
+
+func (x OfpPacketInReason) String() string { return (openflow_13.OfpPacketInReason)(x).String() }
+
+const OfpPacketInReason_OFPR_NO_MATCH = OfpPacketInReason(openflow_13.OfpPacketInReason_OFPR_NO_MATCH)
+const OfpPacketInReason_OFPR_ACTION = OfpPacketInReason(openflow_13.OfpPacketInReason_OFPR_ACTION)
+const OfpPacketInReason_OFPR_INVALID_TTL = OfpPacketInReason(openflow_13.OfpPacketInReason_OFPR_INVALID_TTL)
+
+// ofp_flow_removed_reason from public import openflow_13.proto
+type OfpFlowRemovedReason openflow_13.OfpFlowRemovedReason
+
+var OfpFlowRemovedReason_name = openflow_13.OfpFlowRemovedReason_name
+var OfpFlowRemovedReason_value = openflow_13.OfpFlowRemovedReason_value
+
+func (x OfpFlowRemovedReason) String() string { return (openflow_13.OfpFlowRemovedReason)(x).String() }
+
+const OfpFlowRemovedReason_OFPRR_IDLE_TIMEOUT = OfpFlowRemovedReason(openflow_13.OfpFlowRemovedReason_OFPRR_IDLE_TIMEOUT)
+const OfpFlowRemovedReason_OFPRR_HARD_TIMEOUT = OfpFlowRemovedReason(openflow_13.OfpFlowRemovedReason_OFPRR_HARD_TIMEOUT)
+const OfpFlowRemovedReason_OFPRR_DELETE = OfpFlowRemovedReason(openflow_13.OfpFlowRemovedReason_OFPRR_DELETE)
+const OfpFlowRemovedReason_OFPRR_GROUP_DELETE = OfpFlowRemovedReason(openflow_13.OfpFlowRemovedReason_OFPRR_GROUP_DELETE)
+const OfpFlowRemovedReason_OFPRR_METER_DELETE = OfpFlowRemovedReason(openflow_13.OfpFlowRemovedReason_OFPRR_METER_DELETE)
+
+// ofp_meter from public import openflow_13.proto
+type OfpMeter openflow_13.OfpMeter
+
+var OfpMeter_name = openflow_13.OfpMeter_name
+var OfpMeter_value = openflow_13.OfpMeter_value
+
+func (x OfpMeter) String() string { return (openflow_13.OfpMeter)(x).String() }
+
+const OfpMeter_OFPM_ZERO = OfpMeter(openflow_13.OfpMeter_OFPM_ZERO)
+const OfpMeter_OFPM_MAX = OfpMeter(openflow_13.OfpMeter_OFPM_MAX)
+const OfpMeter_OFPM_SLOWPATH = OfpMeter(openflow_13.OfpMeter_OFPM_SLOWPATH)
+const OfpMeter_OFPM_CONTROLLER = OfpMeter(openflow_13.OfpMeter_OFPM_CONTROLLER)
+const OfpMeter_OFPM_ALL = OfpMeter(openflow_13.OfpMeter_OFPM_ALL)
+
+// ofp_meter_band_type from public import openflow_13.proto
+type OfpMeterBandType openflow_13.OfpMeterBandType
+
+var OfpMeterBandType_name = openflow_13.OfpMeterBandType_name
+var OfpMeterBandType_value = openflow_13.OfpMeterBandType_value
+
+func (x OfpMeterBandType) String() string { return (openflow_13.OfpMeterBandType)(x).String() }
+
+const OfpMeterBandType_OFPMBT_INVALID = OfpMeterBandType(openflow_13.OfpMeterBandType_OFPMBT_INVALID)
+const OfpMeterBandType_OFPMBT_DROP = OfpMeterBandType(openflow_13.OfpMeterBandType_OFPMBT_DROP)
+const OfpMeterBandType_OFPMBT_DSCP_REMARK = OfpMeterBandType(openflow_13.OfpMeterBandType_OFPMBT_DSCP_REMARK)
+const OfpMeterBandType_OFPMBT_EXPERIMENTER = OfpMeterBandType(openflow_13.OfpMeterBandType_OFPMBT_EXPERIMENTER)
+
+// ofp_meter_mod_command from public import openflow_13.proto
+type OfpMeterModCommand openflow_13.OfpMeterModCommand
+
+var OfpMeterModCommand_name = openflow_13.OfpMeterModCommand_name
+var OfpMeterModCommand_value = openflow_13.OfpMeterModCommand_value
+
+func (x OfpMeterModCommand) String() string { return (openflow_13.OfpMeterModCommand)(x).String() }
+
+const OfpMeterModCommand_OFPMC_ADD = OfpMeterModCommand(openflow_13.OfpMeterModCommand_OFPMC_ADD)
+const OfpMeterModCommand_OFPMC_MODIFY = OfpMeterModCommand(openflow_13.OfpMeterModCommand_OFPMC_MODIFY)
+const OfpMeterModCommand_OFPMC_DELETE = OfpMeterModCommand(openflow_13.OfpMeterModCommand_OFPMC_DELETE)
+
+// ofp_meter_flags from public import openflow_13.proto
+type OfpMeterFlags openflow_13.OfpMeterFlags
+
+var OfpMeterFlags_name = openflow_13.OfpMeterFlags_name
+var OfpMeterFlags_value = openflow_13.OfpMeterFlags_value
+
+func (x OfpMeterFlags) String() string { return (openflow_13.OfpMeterFlags)(x).String() }
+
+const OfpMeterFlags_OFPMF_INVALID = OfpMeterFlags(openflow_13.OfpMeterFlags_OFPMF_INVALID)
+const OfpMeterFlags_OFPMF_KBPS = OfpMeterFlags(openflow_13.OfpMeterFlags_OFPMF_KBPS)
+const OfpMeterFlags_OFPMF_PKTPS = OfpMeterFlags(openflow_13.OfpMeterFlags_OFPMF_PKTPS)
+const OfpMeterFlags_OFPMF_BURST = OfpMeterFlags(openflow_13.OfpMeterFlags_OFPMF_BURST)
+const OfpMeterFlags_OFPMF_STATS = OfpMeterFlags(openflow_13.OfpMeterFlags_OFPMF_STATS)
+
+// ofp_error_type from public import openflow_13.proto
+type OfpErrorType openflow_13.OfpErrorType
+
+var OfpErrorType_name = openflow_13.OfpErrorType_name
+var OfpErrorType_value = openflow_13.OfpErrorType_value
+
+func (x OfpErrorType) String() string { return (openflow_13.OfpErrorType)(x).String() }
+
+const OfpErrorType_OFPET_HELLO_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_HELLO_FAILED)
+const OfpErrorType_OFPET_BAD_REQUEST = OfpErrorType(openflow_13.OfpErrorType_OFPET_BAD_REQUEST)
+const OfpErrorType_OFPET_BAD_ACTION = OfpErrorType(openflow_13.OfpErrorType_OFPET_BAD_ACTION)
+const OfpErrorType_OFPET_BAD_INSTRUCTION = OfpErrorType(openflow_13.OfpErrorType_OFPET_BAD_INSTRUCTION)
+const OfpErrorType_OFPET_BAD_MATCH = OfpErrorType(openflow_13.OfpErrorType_OFPET_BAD_MATCH)
+const OfpErrorType_OFPET_FLOW_MOD_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_FLOW_MOD_FAILED)
+const OfpErrorType_OFPET_GROUP_MOD_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_GROUP_MOD_FAILED)
+const OfpErrorType_OFPET_PORT_MOD_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_PORT_MOD_FAILED)
+const OfpErrorType_OFPET_TABLE_MOD_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_TABLE_MOD_FAILED)
+const OfpErrorType_OFPET_QUEUE_OP_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_QUEUE_OP_FAILED)
+const OfpErrorType_OFPET_SWITCH_CONFIG_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_SWITCH_CONFIG_FAILED)
+const OfpErrorType_OFPET_ROLE_REQUEST_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_ROLE_REQUEST_FAILED)
+const OfpErrorType_OFPET_METER_MOD_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_METER_MOD_FAILED)
+const OfpErrorType_OFPET_TABLE_FEATURES_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_TABLE_FEATURES_FAILED)
+const OfpErrorType_OFPET_EXPERIMENTER = OfpErrorType(openflow_13.OfpErrorType_OFPET_EXPERIMENTER)
+
+// ofp_hello_failed_code from public import openflow_13.proto
+type OfpHelloFailedCode openflow_13.OfpHelloFailedCode
+
+var OfpHelloFailedCode_name = openflow_13.OfpHelloFailedCode_name
+var OfpHelloFailedCode_value = openflow_13.OfpHelloFailedCode_value
+
+func (x OfpHelloFailedCode) String() string { return (openflow_13.OfpHelloFailedCode)(x).String() }
+
+const OfpHelloFailedCode_OFPHFC_INCOMPATIBLE = OfpHelloFailedCode(openflow_13.OfpHelloFailedCode_OFPHFC_INCOMPATIBLE)
+const OfpHelloFailedCode_OFPHFC_EPERM = OfpHelloFailedCode(openflow_13.OfpHelloFailedCode_OFPHFC_EPERM)
+
+// ofp_bad_request_code from public import openflow_13.proto
+type OfpBadRequestCode openflow_13.OfpBadRequestCode
+
+var OfpBadRequestCode_name = openflow_13.OfpBadRequestCode_name
+var OfpBadRequestCode_value = openflow_13.OfpBadRequestCode_value
+
+func (x OfpBadRequestCode) String() string { return (openflow_13.OfpBadRequestCode)(x).String() }
+
+const OfpBadRequestCode_OFPBRC_BAD_VERSION = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_VERSION)
+const OfpBadRequestCode_OFPBRC_BAD_TYPE = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_TYPE)
+const OfpBadRequestCode_OFPBRC_BAD_MULTIPART = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_MULTIPART)
+const OfpBadRequestCode_OFPBRC_BAD_EXPERIMENTER = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_EXPERIMENTER)
+const OfpBadRequestCode_OFPBRC_BAD_EXP_TYPE = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_EXP_TYPE)
+const OfpBadRequestCode_OFPBRC_EPERM = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_EPERM)
+const OfpBadRequestCode_OFPBRC_BAD_LEN = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_LEN)
+const OfpBadRequestCode_OFPBRC_BUFFER_EMPTY = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BUFFER_EMPTY)
+const OfpBadRequestCode_OFPBRC_BUFFER_UNKNOWN = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BUFFER_UNKNOWN)
+const OfpBadRequestCode_OFPBRC_BAD_TABLE_ID = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_TABLE_ID)
+const OfpBadRequestCode_OFPBRC_IS_SLAVE = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_IS_SLAVE)
+const OfpBadRequestCode_OFPBRC_BAD_PORT = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_PORT)
+const OfpBadRequestCode_OFPBRC_BAD_PACKET = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_PACKET)
+const OfpBadRequestCode_OFPBRC_MULTIPART_BUFFER_OVERFLOW = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_MULTIPART_BUFFER_OVERFLOW)
+
+// ofp_bad_action_code from public import openflow_13.proto
+type OfpBadActionCode openflow_13.OfpBadActionCode
+
+var OfpBadActionCode_name = openflow_13.OfpBadActionCode_name
+var OfpBadActionCode_value = openflow_13.OfpBadActionCode_value
+
+func (x OfpBadActionCode) String() string { return (openflow_13.OfpBadActionCode)(x).String() }
+
+const OfpBadActionCode_OFPBAC_BAD_TYPE = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_TYPE)
+const OfpBadActionCode_OFPBAC_BAD_LEN = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_LEN)
+const OfpBadActionCode_OFPBAC_BAD_EXPERIMENTER = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_EXPERIMENTER)
+const OfpBadActionCode_OFPBAC_BAD_EXP_TYPE = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_EXP_TYPE)
+const OfpBadActionCode_OFPBAC_BAD_OUT_PORT = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_OUT_PORT)
+const OfpBadActionCode_OFPBAC_BAD_ARGUMENT = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_ARGUMENT)
+const OfpBadActionCode_OFPBAC_EPERM = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_EPERM)
+const OfpBadActionCode_OFPBAC_TOO_MANY = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_TOO_MANY)
+const OfpBadActionCode_OFPBAC_BAD_QUEUE = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_QUEUE)
+const OfpBadActionCode_OFPBAC_BAD_OUT_GROUP = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_OUT_GROUP)
+const OfpBadActionCode_OFPBAC_MATCH_INCONSISTENT = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_MATCH_INCONSISTENT)
+const OfpBadActionCode_OFPBAC_UNSUPPORTED_ORDER = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_UNSUPPORTED_ORDER)
+const OfpBadActionCode_OFPBAC_BAD_TAG = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_TAG)
+const OfpBadActionCode_OFPBAC_BAD_SET_TYPE = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_SET_TYPE)
+const OfpBadActionCode_OFPBAC_BAD_SET_LEN = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_SET_LEN)
+const OfpBadActionCode_OFPBAC_BAD_SET_ARGUMENT = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_SET_ARGUMENT)
+
+// ofp_bad_instruction_code from public import openflow_13.proto
+type OfpBadInstructionCode openflow_13.OfpBadInstructionCode
+
+var OfpBadInstructionCode_name = openflow_13.OfpBadInstructionCode_name
+var OfpBadInstructionCode_value = openflow_13.OfpBadInstructionCode_value
+
+func (x OfpBadInstructionCode) String() string { return (openflow_13.OfpBadInstructionCode)(x).String() }
+
+const OfpBadInstructionCode_OFPBIC_UNKNOWN_INST = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_UNKNOWN_INST)
+const OfpBadInstructionCode_OFPBIC_UNSUP_INST = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_UNSUP_INST)
+const OfpBadInstructionCode_OFPBIC_BAD_TABLE_ID = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_BAD_TABLE_ID)
+const OfpBadInstructionCode_OFPBIC_UNSUP_METADATA = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_UNSUP_METADATA)
+const OfpBadInstructionCode_OFPBIC_UNSUP_METADATA_MASK = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_UNSUP_METADATA_MASK)
+const OfpBadInstructionCode_OFPBIC_BAD_EXPERIMENTER = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_BAD_EXPERIMENTER)
+const OfpBadInstructionCode_OFPBIC_BAD_EXP_TYPE = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_BAD_EXP_TYPE)
+const OfpBadInstructionCode_OFPBIC_BAD_LEN = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_BAD_LEN)
+const OfpBadInstructionCode_OFPBIC_EPERM = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_EPERM)
+
+// ofp_bad_match_code from public import openflow_13.proto
+type OfpBadMatchCode openflow_13.OfpBadMatchCode
+
+var OfpBadMatchCode_name = openflow_13.OfpBadMatchCode_name
+var OfpBadMatchCode_value = openflow_13.OfpBadMatchCode_value
+
+func (x OfpBadMatchCode) String() string { return (openflow_13.OfpBadMatchCode)(x).String() }
+
+const OfpBadMatchCode_OFPBMC_BAD_TYPE = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_TYPE)
+const OfpBadMatchCode_OFPBMC_BAD_LEN = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_LEN)
+const OfpBadMatchCode_OFPBMC_BAD_TAG = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_TAG)
+const OfpBadMatchCode_OFPBMC_BAD_DL_ADDR_MASK = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_DL_ADDR_MASK)
+const OfpBadMatchCode_OFPBMC_BAD_NW_ADDR_MASK = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_NW_ADDR_MASK)
+const OfpBadMatchCode_OFPBMC_BAD_WILDCARDS = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_WILDCARDS)
+const OfpBadMatchCode_OFPBMC_BAD_FIELD = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_FIELD)
+const OfpBadMatchCode_OFPBMC_BAD_VALUE = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_VALUE)
+const OfpBadMatchCode_OFPBMC_BAD_MASK = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_MASK)
+const OfpBadMatchCode_OFPBMC_BAD_PREREQ = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_PREREQ)
+const OfpBadMatchCode_OFPBMC_DUP_FIELD = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_DUP_FIELD)
+const OfpBadMatchCode_OFPBMC_EPERM = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_EPERM)
+
+// ofp_flow_mod_failed_code from public import openflow_13.proto
+type OfpFlowModFailedCode openflow_13.OfpFlowModFailedCode
+
+var OfpFlowModFailedCode_name = openflow_13.OfpFlowModFailedCode_name
+var OfpFlowModFailedCode_value = openflow_13.OfpFlowModFailedCode_value
+
+func (x OfpFlowModFailedCode) String() string { return (openflow_13.OfpFlowModFailedCode)(x).String() }
+
+const OfpFlowModFailedCode_OFPFMFC_UNKNOWN = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_UNKNOWN)
+const OfpFlowModFailedCode_OFPFMFC_TABLE_FULL = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_TABLE_FULL)
+const OfpFlowModFailedCode_OFPFMFC_BAD_TABLE_ID = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_BAD_TABLE_ID)
+const OfpFlowModFailedCode_OFPFMFC_OVERLAP = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_OVERLAP)
+const OfpFlowModFailedCode_OFPFMFC_EPERM = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_EPERM)
+const OfpFlowModFailedCode_OFPFMFC_BAD_TIMEOUT = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_BAD_TIMEOUT)
+const OfpFlowModFailedCode_OFPFMFC_BAD_COMMAND = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_BAD_COMMAND)
+const OfpFlowModFailedCode_OFPFMFC_BAD_FLAGS = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_BAD_FLAGS)
+
+// ofp_group_mod_failed_code from public import openflow_13.proto
+type OfpGroupModFailedCode openflow_13.OfpGroupModFailedCode
+
+var OfpGroupModFailedCode_name = openflow_13.OfpGroupModFailedCode_name
+var OfpGroupModFailedCode_value = openflow_13.OfpGroupModFailedCode_value
+
+func (x OfpGroupModFailedCode) String() string { return (openflow_13.OfpGroupModFailedCode)(x).String() }
+
+const OfpGroupModFailedCode_OFPGMFC_GROUP_EXISTS = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_GROUP_EXISTS)
+const OfpGroupModFailedCode_OFPGMFC_INVALID_GROUP = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_INVALID_GROUP)
+const OfpGroupModFailedCode_OFPGMFC_WEIGHT_UNSUPPORTED = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_WEIGHT_UNSUPPORTED)
+const OfpGroupModFailedCode_OFPGMFC_OUT_OF_GROUPS = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_OUT_OF_GROUPS)
+const OfpGroupModFailedCode_OFPGMFC_OUT_OF_BUCKETS = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_OUT_OF_BUCKETS)
+const OfpGroupModFailedCode_OFPGMFC_CHAINING_UNSUPPORTED = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_CHAINING_UNSUPPORTED)
+const OfpGroupModFailedCode_OFPGMFC_WATCH_UNSUPPORTED = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_WATCH_UNSUPPORTED)
+const OfpGroupModFailedCode_OFPGMFC_LOOP = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_LOOP)
+const OfpGroupModFailedCode_OFPGMFC_UNKNOWN_GROUP = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_UNKNOWN_GROUP)
+const OfpGroupModFailedCode_OFPGMFC_CHAINED_GROUP = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_CHAINED_GROUP)
+const OfpGroupModFailedCode_OFPGMFC_BAD_TYPE = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_BAD_TYPE)
+const OfpGroupModFailedCode_OFPGMFC_BAD_COMMAND = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_BAD_COMMAND)
+const OfpGroupModFailedCode_OFPGMFC_BAD_BUCKET = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_BAD_BUCKET)
+const OfpGroupModFailedCode_OFPGMFC_BAD_WATCH = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_BAD_WATCH)
+const OfpGroupModFailedCode_OFPGMFC_EPERM = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_EPERM)
+
+// ofp_port_mod_failed_code from public import openflow_13.proto
+type OfpPortModFailedCode openflow_13.OfpPortModFailedCode
+
+var OfpPortModFailedCode_name = openflow_13.OfpPortModFailedCode_name
+var OfpPortModFailedCode_value = openflow_13.OfpPortModFailedCode_value
+
+func (x OfpPortModFailedCode) String() string { return (openflow_13.OfpPortModFailedCode)(x).String() }
+
+const OfpPortModFailedCode_OFPPMFC_BAD_PORT = OfpPortModFailedCode(openflow_13.OfpPortModFailedCode_OFPPMFC_BAD_PORT)
+const OfpPortModFailedCode_OFPPMFC_BAD_HW_ADDR = OfpPortModFailedCode(openflow_13.OfpPortModFailedCode_OFPPMFC_BAD_HW_ADDR)
+const OfpPortModFailedCode_OFPPMFC_BAD_CONFIG = OfpPortModFailedCode(openflow_13.OfpPortModFailedCode_OFPPMFC_BAD_CONFIG)
+const OfpPortModFailedCode_OFPPMFC_BAD_ADVERTISE = OfpPortModFailedCode(openflow_13.OfpPortModFailedCode_OFPPMFC_BAD_ADVERTISE)
+const OfpPortModFailedCode_OFPPMFC_EPERM = OfpPortModFailedCode(openflow_13.OfpPortModFailedCode_OFPPMFC_EPERM)
+
+// ofp_table_mod_failed_code from public import openflow_13.proto
+type OfpTableModFailedCode openflow_13.OfpTableModFailedCode
+
+var OfpTableModFailedCode_name = openflow_13.OfpTableModFailedCode_name
+var OfpTableModFailedCode_value = openflow_13.OfpTableModFailedCode_value
+
+func (x OfpTableModFailedCode) String() string { return (openflow_13.OfpTableModFailedCode)(x).String() }
+
+const OfpTableModFailedCode_OFPTMFC_BAD_TABLE = OfpTableModFailedCode(openflow_13.OfpTableModFailedCode_OFPTMFC_BAD_TABLE)
+const OfpTableModFailedCode_OFPTMFC_BAD_CONFIG = OfpTableModFailedCode(openflow_13.OfpTableModFailedCode_OFPTMFC_BAD_CONFIG)
+const OfpTableModFailedCode_OFPTMFC_EPERM = OfpTableModFailedCode(openflow_13.OfpTableModFailedCode_OFPTMFC_EPERM)
+
+// ofp_queue_op_failed_code from public import openflow_13.proto
+type OfpQueueOpFailedCode openflow_13.OfpQueueOpFailedCode
+
+var OfpQueueOpFailedCode_name = openflow_13.OfpQueueOpFailedCode_name
+var OfpQueueOpFailedCode_value = openflow_13.OfpQueueOpFailedCode_value
+
+func (x OfpQueueOpFailedCode) String() string { return (openflow_13.OfpQueueOpFailedCode)(x).String() }
+
+const OfpQueueOpFailedCode_OFPQOFC_BAD_PORT = OfpQueueOpFailedCode(openflow_13.OfpQueueOpFailedCode_OFPQOFC_BAD_PORT)
+const OfpQueueOpFailedCode_OFPQOFC_BAD_QUEUE = OfpQueueOpFailedCode(openflow_13.OfpQueueOpFailedCode_OFPQOFC_BAD_QUEUE)
+const OfpQueueOpFailedCode_OFPQOFC_EPERM = OfpQueueOpFailedCode(openflow_13.OfpQueueOpFailedCode_OFPQOFC_EPERM)
+
+// ofp_switch_config_failed_code from public import openflow_13.proto
+type OfpSwitchConfigFailedCode openflow_13.OfpSwitchConfigFailedCode
+
+var OfpSwitchConfigFailedCode_name = openflow_13.OfpSwitchConfigFailedCode_name
+var OfpSwitchConfigFailedCode_value = openflow_13.OfpSwitchConfigFailedCode_value
+
+func (x OfpSwitchConfigFailedCode) String() string {
+ return (openflow_13.OfpSwitchConfigFailedCode)(x).String()
+}
+
+const OfpSwitchConfigFailedCode_OFPSCFC_BAD_FLAGS = OfpSwitchConfigFailedCode(openflow_13.OfpSwitchConfigFailedCode_OFPSCFC_BAD_FLAGS)
+const OfpSwitchConfigFailedCode_OFPSCFC_BAD_LEN = OfpSwitchConfigFailedCode(openflow_13.OfpSwitchConfigFailedCode_OFPSCFC_BAD_LEN)
+const OfpSwitchConfigFailedCode_OFPSCFC_EPERM = OfpSwitchConfigFailedCode(openflow_13.OfpSwitchConfigFailedCode_OFPSCFC_EPERM)
+
+// ofp_role_request_failed_code from public import openflow_13.proto
+type OfpRoleRequestFailedCode openflow_13.OfpRoleRequestFailedCode
+
+var OfpRoleRequestFailedCode_name = openflow_13.OfpRoleRequestFailedCode_name
+var OfpRoleRequestFailedCode_value = openflow_13.OfpRoleRequestFailedCode_value
+
+func (x OfpRoleRequestFailedCode) String() string {
+ return (openflow_13.OfpRoleRequestFailedCode)(x).String()
+}
+
+const OfpRoleRequestFailedCode_OFPRRFC_STALE = OfpRoleRequestFailedCode(openflow_13.OfpRoleRequestFailedCode_OFPRRFC_STALE)
+const OfpRoleRequestFailedCode_OFPRRFC_UNSUP = OfpRoleRequestFailedCode(openflow_13.OfpRoleRequestFailedCode_OFPRRFC_UNSUP)
+const OfpRoleRequestFailedCode_OFPRRFC_BAD_ROLE = OfpRoleRequestFailedCode(openflow_13.OfpRoleRequestFailedCode_OFPRRFC_BAD_ROLE)
+
+// ofp_meter_mod_failed_code from public import openflow_13.proto
+type OfpMeterModFailedCode openflow_13.OfpMeterModFailedCode
+
+var OfpMeterModFailedCode_name = openflow_13.OfpMeterModFailedCode_name
+var OfpMeterModFailedCode_value = openflow_13.OfpMeterModFailedCode_value
+
+func (x OfpMeterModFailedCode) String() string { return (openflow_13.OfpMeterModFailedCode)(x).String() }
+
+const OfpMeterModFailedCode_OFPMMFC_UNKNOWN = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_UNKNOWN)
+const OfpMeterModFailedCode_OFPMMFC_METER_EXISTS = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_METER_EXISTS)
+const OfpMeterModFailedCode_OFPMMFC_INVALID_METER = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_INVALID_METER)
+const OfpMeterModFailedCode_OFPMMFC_UNKNOWN_METER = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_UNKNOWN_METER)
+const OfpMeterModFailedCode_OFPMMFC_BAD_COMMAND = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_COMMAND)
+const OfpMeterModFailedCode_OFPMMFC_BAD_FLAGS = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_FLAGS)
+const OfpMeterModFailedCode_OFPMMFC_BAD_RATE = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_RATE)
+const OfpMeterModFailedCode_OFPMMFC_BAD_BURST = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_BURST)
+const OfpMeterModFailedCode_OFPMMFC_BAD_BAND = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_BAND)
+const OfpMeterModFailedCode_OFPMMFC_BAD_BAND_VALUE = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_BAND_VALUE)
+const OfpMeterModFailedCode_OFPMMFC_OUT_OF_METERS = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_OUT_OF_METERS)
+const OfpMeterModFailedCode_OFPMMFC_OUT_OF_BANDS = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_OUT_OF_BANDS)
+
+// ofp_table_features_failed_code from public import openflow_13.proto
+type OfpTableFeaturesFailedCode openflow_13.OfpTableFeaturesFailedCode
+
+var OfpTableFeaturesFailedCode_name = openflow_13.OfpTableFeaturesFailedCode_name
+var OfpTableFeaturesFailedCode_value = openflow_13.OfpTableFeaturesFailedCode_value
+
+func (x OfpTableFeaturesFailedCode) String() string {
+ return (openflow_13.OfpTableFeaturesFailedCode)(x).String()
+}
+
+const OfpTableFeaturesFailedCode_OFPTFFC_BAD_TABLE = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_BAD_TABLE)
+const OfpTableFeaturesFailedCode_OFPTFFC_BAD_METADATA = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_BAD_METADATA)
+const OfpTableFeaturesFailedCode_OFPTFFC_BAD_TYPE = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_BAD_TYPE)
+const OfpTableFeaturesFailedCode_OFPTFFC_BAD_LEN = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_BAD_LEN)
+const OfpTableFeaturesFailedCode_OFPTFFC_BAD_ARGUMENT = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_BAD_ARGUMENT)
+const OfpTableFeaturesFailedCode_OFPTFFC_EPERM = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_EPERM)
+
+// ofp_multipart_type from public import openflow_13.proto
+type OfpMultipartType openflow_13.OfpMultipartType
+
+var OfpMultipartType_name = openflow_13.OfpMultipartType_name
+var OfpMultipartType_value = openflow_13.OfpMultipartType_value
+
+func (x OfpMultipartType) String() string { return (openflow_13.OfpMultipartType)(x).String() }
+
+const OfpMultipartType_OFPMP_DESC = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_DESC)
+const OfpMultipartType_OFPMP_FLOW = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_FLOW)
+const OfpMultipartType_OFPMP_AGGREGATE = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_AGGREGATE)
+const OfpMultipartType_OFPMP_TABLE = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_TABLE)
+const OfpMultipartType_OFPMP_PORT_STATS = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_PORT_STATS)
+const OfpMultipartType_OFPMP_QUEUE = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_QUEUE)
+const OfpMultipartType_OFPMP_GROUP = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_GROUP)
+const OfpMultipartType_OFPMP_GROUP_DESC = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_GROUP_DESC)
+const OfpMultipartType_OFPMP_GROUP_FEATURES = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_GROUP_FEATURES)
+const OfpMultipartType_OFPMP_METER = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_METER)
+const OfpMultipartType_OFPMP_METER_CONFIG = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_METER_CONFIG)
+const OfpMultipartType_OFPMP_METER_FEATURES = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_METER_FEATURES)
+const OfpMultipartType_OFPMP_TABLE_FEATURES = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_TABLE_FEATURES)
+const OfpMultipartType_OFPMP_PORT_DESC = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_PORT_DESC)
+const OfpMultipartType_OFPMP_EXPERIMENTER = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_EXPERIMENTER)
+
+// ofp_multipart_request_flags from public import openflow_13.proto
+type OfpMultipartRequestFlags openflow_13.OfpMultipartRequestFlags
+
+var OfpMultipartRequestFlags_name = openflow_13.OfpMultipartRequestFlags_name
+var OfpMultipartRequestFlags_value = openflow_13.OfpMultipartRequestFlags_value
+
+func (x OfpMultipartRequestFlags) String() string {
+ return (openflow_13.OfpMultipartRequestFlags)(x).String()
+}
+
+const OfpMultipartRequestFlags_OFPMPF_REQ_INVALID = OfpMultipartRequestFlags(openflow_13.OfpMultipartRequestFlags_OFPMPF_REQ_INVALID)
+const OfpMultipartRequestFlags_OFPMPF_REQ_MORE = OfpMultipartRequestFlags(openflow_13.OfpMultipartRequestFlags_OFPMPF_REQ_MORE)
+
+// ofp_multipart_reply_flags from public import openflow_13.proto
+type OfpMultipartReplyFlags openflow_13.OfpMultipartReplyFlags
+
+var OfpMultipartReplyFlags_name = openflow_13.OfpMultipartReplyFlags_name
+var OfpMultipartReplyFlags_value = openflow_13.OfpMultipartReplyFlags_value
+
+func (x OfpMultipartReplyFlags) String() string {
+ return (openflow_13.OfpMultipartReplyFlags)(x).String()
+}
+
+const OfpMultipartReplyFlags_OFPMPF_REPLY_INVALID = OfpMultipartReplyFlags(openflow_13.OfpMultipartReplyFlags_OFPMPF_REPLY_INVALID)
+const OfpMultipartReplyFlags_OFPMPF_REPLY_MORE = OfpMultipartReplyFlags(openflow_13.OfpMultipartReplyFlags_OFPMPF_REPLY_MORE)
+
+// ofp_table_feature_prop_type from public import openflow_13.proto
+type OfpTableFeaturePropType openflow_13.OfpTableFeaturePropType
+
+var OfpTableFeaturePropType_name = openflow_13.OfpTableFeaturePropType_name
+var OfpTableFeaturePropType_value = openflow_13.OfpTableFeaturePropType_value
+
+func (x OfpTableFeaturePropType) String() string {
+ return (openflow_13.OfpTableFeaturePropType)(x).String()
+}
+
+const OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS)
+const OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS_MISS)
+const OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES)
+const OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES_MISS)
+const OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS)
+const OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS_MISS)
+const OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS)
+const OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS_MISS)
+const OfpTableFeaturePropType_OFPTFPT_MATCH = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_MATCH)
+const OfpTableFeaturePropType_OFPTFPT_WILDCARDS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_WILDCARDS)
+const OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD)
+const OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD_MISS)
+const OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD)
+const OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD_MISS)
+const OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER)
+const OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER_MISS)
+
+// ofp_group_capabilities from public import openflow_13.proto
+type OfpGroupCapabilities openflow_13.OfpGroupCapabilities
+
+var OfpGroupCapabilities_name = openflow_13.OfpGroupCapabilities_name
+var OfpGroupCapabilities_value = openflow_13.OfpGroupCapabilities_value
+
+func (x OfpGroupCapabilities) String() string { return (openflow_13.OfpGroupCapabilities)(x).String() }
+
+const OfpGroupCapabilities_OFPGFC_INVALID = OfpGroupCapabilities(openflow_13.OfpGroupCapabilities_OFPGFC_INVALID)
+const OfpGroupCapabilities_OFPGFC_SELECT_WEIGHT = OfpGroupCapabilities(openflow_13.OfpGroupCapabilities_OFPGFC_SELECT_WEIGHT)
+const OfpGroupCapabilities_OFPGFC_SELECT_LIVENESS = OfpGroupCapabilities(openflow_13.OfpGroupCapabilities_OFPGFC_SELECT_LIVENESS)
+const OfpGroupCapabilities_OFPGFC_CHAINING = OfpGroupCapabilities(openflow_13.OfpGroupCapabilities_OFPGFC_CHAINING)
+const OfpGroupCapabilities_OFPGFC_CHAINING_CHECKS = OfpGroupCapabilities(openflow_13.OfpGroupCapabilities_OFPGFC_CHAINING_CHECKS)
+
+// ofp_queue_properties from public import openflow_13.proto
+type OfpQueueProperties openflow_13.OfpQueueProperties
+
+var OfpQueueProperties_name = openflow_13.OfpQueueProperties_name
+var OfpQueueProperties_value = openflow_13.OfpQueueProperties_value
+
+func (x OfpQueueProperties) String() string { return (openflow_13.OfpQueueProperties)(x).String() }
+
+const OfpQueueProperties_OFPQT_INVALID = OfpQueueProperties(openflow_13.OfpQueueProperties_OFPQT_INVALID)
+const OfpQueueProperties_OFPQT_MIN_RATE = OfpQueueProperties(openflow_13.OfpQueueProperties_OFPQT_MIN_RATE)
+const OfpQueueProperties_OFPQT_MAX_RATE = OfpQueueProperties(openflow_13.OfpQueueProperties_OFPQT_MAX_RATE)
+const OfpQueueProperties_OFPQT_EXPERIMENTER = OfpQueueProperties(openflow_13.OfpQueueProperties_OFPQT_EXPERIMENTER)
+
+// ofp_controller_role from public import openflow_13.proto
+type OfpControllerRole openflow_13.OfpControllerRole
+
+var OfpControllerRole_name = openflow_13.OfpControllerRole_name
+var OfpControllerRole_value = openflow_13.OfpControllerRole_value
+
+func (x OfpControllerRole) String() string { return (openflow_13.OfpControllerRole)(x).String() }
+
+const OfpControllerRole_OFPCR_ROLE_NOCHANGE = OfpControllerRole(openflow_13.OfpControllerRole_OFPCR_ROLE_NOCHANGE)
+const OfpControllerRole_OFPCR_ROLE_EQUAL = OfpControllerRole(openflow_13.OfpControllerRole_OFPCR_ROLE_EQUAL)
+const OfpControllerRole_OFPCR_ROLE_MASTER = OfpControllerRole(openflow_13.OfpControllerRole_OFPCR_ROLE_MASTER)
+const OfpControllerRole_OFPCR_ROLE_SLAVE = OfpControllerRole(openflow_13.OfpControllerRole_OFPCR_ROLE_SLAVE)
+
+type AlarmFilterRuleKey_AlarmFilterRuleKey int32
+
+const (
+ AlarmFilterRuleKey_id AlarmFilterRuleKey_AlarmFilterRuleKey = 0
+ AlarmFilterRuleKey_type AlarmFilterRuleKey_AlarmFilterRuleKey = 1
+ AlarmFilterRuleKey_severity AlarmFilterRuleKey_AlarmFilterRuleKey = 2
+ AlarmFilterRuleKey_resource_id AlarmFilterRuleKey_AlarmFilterRuleKey = 3
+ AlarmFilterRuleKey_category AlarmFilterRuleKey_AlarmFilterRuleKey = 4
+ AlarmFilterRuleKey_device_id AlarmFilterRuleKey_AlarmFilterRuleKey = 5
+)
+
+var AlarmFilterRuleKey_AlarmFilterRuleKey_name = map[int32]string{
+ 0: "id",
+ 1: "type",
+ 2: "severity",
+ 3: "resource_id",
+ 4: "category",
+ 5: "device_id",
+}
+var AlarmFilterRuleKey_AlarmFilterRuleKey_value = map[string]int32{
+ "id": 0,
+ "type": 1,
+ "severity": 2,
+ "resource_id": 3,
+ "category": 4,
+ "device_id": 5,
+}
+
+func (x AlarmFilterRuleKey_AlarmFilterRuleKey) String() string {
+ return proto.EnumName(AlarmFilterRuleKey_AlarmFilterRuleKey_name, int32(x))
+}
+func (AlarmFilterRuleKey_AlarmFilterRuleKey) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor0, []int{2, 0}
+}
+
+type DeviceGroup struct {
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ LogicalDevices []*voltha5.LogicalDevice `protobuf:"bytes,2,rep,name=logical_devices,json=logicalDevices" json:"logical_devices,omitempty"`
+ Devices []*voltha6.Device `protobuf:"bytes,3,rep,name=devices" json:"devices,omitempty"`
+}
+
+func (m *DeviceGroup) Reset() { *m = DeviceGroup{} }
+func (m *DeviceGroup) String() string { return proto.CompactTextString(m) }
+func (*DeviceGroup) ProtoMessage() {}
+func (*DeviceGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *DeviceGroup) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *DeviceGroup) GetLogicalDevices() []*voltha5.LogicalDevice {
+ if m != nil {
+ return m.LogicalDevices
+ }
+ return nil
+}
+
+func (m *DeviceGroup) GetDevices() []*voltha6.Device {
+ if m != nil {
+ return m.Devices
+ }
+ return nil
+}
+
+type DeviceGroups struct {
+ Items []*DeviceGroup `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *DeviceGroups) Reset() { *m = DeviceGroups{} }
+func (m *DeviceGroups) String() string { return proto.CompactTextString(m) }
+func (*DeviceGroups) ProtoMessage() {}
+func (*DeviceGroups) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *DeviceGroups) GetItems() []*DeviceGroup {
+ if m != nil {
+ return m.Items
+ }
+ return nil
+}
+
+type AlarmFilterRuleKey struct {
+}
+
+func (m *AlarmFilterRuleKey) Reset() { *m = AlarmFilterRuleKey{} }
+func (m *AlarmFilterRuleKey) String() string { return proto.CompactTextString(m) }
+func (*AlarmFilterRuleKey) ProtoMessage() {}
+func (*AlarmFilterRuleKey) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+type AlarmFilterRule struct {
+ Key AlarmFilterRuleKey_AlarmFilterRuleKey `protobuf:"varint,1,opt,name=key,enum=voltha.AlarmFilterRuleKey_AlarmFilterRuleKey" json:"key,omitempty"`
+ Value string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
+}
+
+func (m *AlarmFilterRule) Reset() { *m = AlarmFilterRule{} }
+func (m *AlarmFilterRule) String() string { return proto.CompactTextString(m) }
+func (*AlarmFilterRule) ProtoMessage() {}
+func (*AlarmFilterRule) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *AlarmFilterRule) GetKey() AlarmFilterRuleKey_AlarmFilterRuleKey {
+ if m != nil {
+ return m.Key
+ }
+ return AlarmFilterRuleKey_id
+}
+
+func (m *AlarmFilterRule) GetValue() string {
+ if m != nil {
+ return m.Value
+ }
+ return ""
+}
+
+type AlarmFilter struct {
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ Rules []*AlarmFilterRule `protobuf:"bytes,2,rep,name=rules" json:"rules,omitempty"`
+}
+
+func (m *AlarmFilter) Reset() { *m = AlarmFilter{} }
+func (m *AlarmFilter) String() string { return proto.CompactTextString(m) }
+func (*AlarmFilter) ProtoMessage() {}
+func (*AlarmFilter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *AlarmFilter) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *AlarmFilter) GetRules() []*AlarmFilterRule {
+ if m != nil {
+ return m.Rules
+ }
+ return nil
+}
+
+type AlarmFilters struct {
+ Filters []*AlarmFilter `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"`
+}
+
+func (m *AlarmFilters) Reset() { *m = AlarmFilters{} }
+func (m *AlarmFilters) String() string { return proto.CompactTextString(m) }
+func (*AlarmFilters) ProtoMessage() {}
+func (*AlarmFilters) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+func (m *AlarmFilters) GetFilters() []*AlarmFilter {
+ if m != nil {
+ return m.Filters
+ }
+ return nil
+}
+
+// Top-level (root) node for a Voltha Instance
+type VolthaInstance struct {
+ InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceId" json:"instance_id,omitempty"`
+ Version string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
+ LogLevel voltha3.LogLevel_LogLevel `protobuf:"varint,3,opt,name=log_level,json=logLevel,enum=voltha.LogLevel_LogLevel" json:"log_level,omitempty"`
+ Health *voltha4.HealthStatus `protobuf:"bytes,10,opt,name=health" json:"health,omitempty"`
+ Adapters []*voltha7.Adapter `protobuf:"bytes,11,rep,name=adapters" json:"adapters,omitempty"`
+ LogicalDevices []*voltha5.LogicalDevice `protobuf:"bytes,12,rep,name=logical_devices,json=logicalDevices" json:"logical_devices,omitempty"`
+ Devices []*voltha6.Device `protobuf:"bytes,13,rep,name=devices" json:"devices,omitempty"`
+ DeviceTypes []*voltha6.DeviceType `protobuf:"bytes,14,rep,name=device_types,json=deviceTypes" json:"device_types,omitempty"`
+ DeviceGroups []*DeviceGroup `protobuf:"bytes,15,rep,name=device_groups,json=deviceGroups" json:"device_groups,omitempty"`
+ AlarmFilters []*AlarmFilter `protobuf:"bytes,16,rep,name=alarm_filters,json=alarmFilters" json:"alarm_filters,omitempty"`
+}
+
+func (m *VolthaInstance) Reset() { *m = VolthaInstance{} }
+func (m *VolthaInstance) String() string { return proto.CompactTextString(m) }
+func (*VolthaInstance) ProtoMessage() {}
+func (*VolthaInstance) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+func (m *VolthaInstance) GetInstanceId() string {
+ if m != nil {
+ return m.InstanceId
+ }
+ return ""
+}
+
+func (m *VolthaInstance) GetVersion() string {
+ if m != nil {
+ return m.Version
+ }
+ return ""
+}
+
+func (m *VolthaInstance) GetLogLevel() voltha3.LogLevel_LogLevel {
+ if m != nil {
+ return m.LogLevel
+ }
+ return voltha3.LogLevel_DEBUG
+}
+
+func (m *VolthaInstance) GetHealth() *voltha4.HealthStatus {
+ if m != nil {
+ return m.Health
+ }
+ return nil
+}
+
+func (m *VolthaInstance) GetAdapters() []*voltha7.Adapter {
+ if m != nil {
+ return m.Adapters
+ }
+ return nil
+}
+
+func (m *VolthaInstance) GetLogicalDevices() []*voltha5.LogicalDevice {
+ if m != nil {
+ return m.LogicalDevices
+ }
+ return nil
+}
+
+func (m *VolthaInstance) GetDevices() []*voltha6.Device {
+ if m != nil {
+ return m.Devices
+ }
+ return nil
+}
+
+func (m *VolthaInstance) GetDeviceTypes() []*voltha6.DeviceType {
+ if m != nil {
+ return m.DeviceTypes
+ }
+ return nil
+}
+
+func (m *VolthaInstance) GetDeviceGroups() []*DeviceGroup {
+ if m != nil {
+ return m.DeviceGroups
+ }
+ return nil
+}
+
+func (m *VolthaInstance) GetAlarmFilters() []*AlarmFilter {
+ if m != nil {
+ return m.AlarmFilters
+ }
+ return nil
+}
+
+type VolthaInstances struct {
+ Items []string `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *VolthaInstances) Reset() { *m = VolthaInstances{} }
+func (m *VolthaInstances) String() string { return proto.CompactTextString(m) }
+func (*VolthaInstances) ProtoMessage() {}
+func (*VolthaInstances) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+func (m *VolthaInstances) GetItems() []string {
+ if m != nil {
+ return m.Items
+ }
+ return nil
+}
+
+// Voltha representing the entire Voltha cluster
+type Voltha struct {
+ Version string `protobuf:"bytes,1,opt,name=version" json:"version,omitempty"`
+ LogLevel voltha3.LogLevel_LogLevel `protobuf:"varint,2,opt,name=log_level,json=logLevel,enum=voltha.LogLevel_LogLevel" json:"log_level,omitempty"`
+ Instances []*VolthaInstance `protobuf:"bytes,3,rep,name=instances" json:"instances,omitempty"`
+ Adapters []*voltha7.Adapter `protobuf:"bytes,11,rep,name=adapters" json:"adapters,omitempty"`
+ LogicalDevices []*voltha5.LogicalDevice `protobuf:"bytes,12,rep,name=logical_devices,json=logicalDevices" json:"logical_devices,omitempty"`
+ Devices []*voltha6.Device `protobuf:"bytes,13,rep,name=devices" json:"devices,omitempty"`
+ DeviceGroups []*DeviceGroup `protobuf:"bytes,15,rep,name=device_groups,json=deviceGroups" json:"device_groups,omitempty"`
+}
+
+func (m *Voltha) Reset() { *m = Voltha{} }
+func (m *Voltha) String() string { return proto.CompactTextString(m) }
+func (*Voltha) ProtoMessage() {}
+func (*Voltha) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+func (m *Voltha) GetVersion() string {
+ if m != nil {
+ return m.Version
+ }
+ return ""
+}
+
+func (m *Voltha) GetLogLevel() voltha3.LogLevel_LogLevel {
+ if m != nil {
+ return m.LogLevel
+ }
+ return voltha3.LogLevel_DEBUG
+}
+
+func (m *Voltha) GetInstances() []*VolthaInstance {
+ if m != nil {
+ return m.Instances
+ }
+ return nil
+}
+
+func (m *Voltha) GetAdapters() []*voltha7.Adapter {
+ if m != nil {
+ return m.Adapters
+ }
+ return nil
+}
+
+func (m *Voltha) GetLogicalDevices() []*voltha5.LogicalDevice {
+ if m != nil {
+ return m.LogicalDevices
+ }
+ return nil
+}
+
+func (m *Voltha) GetDevices() []*voltha6.Device {
+ if m != nil {
+ return m.Devices
+ }
+ return nil
+}
+
+func (m *Voltha) GetDeviceGroups() []*DeviceGroup {
+ if m != nil {
+ return m.DeviceGroups
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*DeviceGroup)(nil), "voltha.DeviceGroup")
+ proto.RegisterType((*DeviceGroups)(nil), "voltha.DeviceGroups")
+ proto.RegisterType((*AlarmFilterRuleKey)(nil), "voltha.AlarmFilterRuleKey")
+ proto.RegisterType((*AlarmFilterRule)(nil), "voltha.AlarmFilterRule")
+ proto.RegisterType((*AlarmFilter)(nil), "voltha.AlarmFilter")
+ proto.RegisterType((*AlarmFilters)(nil), "voltha.AlarmFilters")
+ proto.RegisterType((*VolthaInstance)(nil), "voltha.VolthaInstance")
+ proto.RegisterType((*VolthaInstances)(nil), "voltha.VolthaInstances")
+ proto.RegisterType((*Voltha)(nil), "voltha.Voltha")
+ proto.RegisterEnum("voltha.AlarmFilterRuleKey_AlarmFilterRuleKey", AlarmFilterRuleKey_AlarmFilterRuleKey_name, AlarmFilterRuleKey_AlarmFilterRuleKey_value)
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for VolthaGlobalService service
+
+type VolthaGlobalServiceClient interface {
+ // Get high level information on the Voltha cluster
+ GetVoltha(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*Voltha, error)
+ // List all Voltha cluster instances
+ ListVolthaInstances(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VolthaInstances, error)
+ // Get details on a Voltha cluster instance
+ GetVolthaInstance(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*VolthaInstance, error)
+ // List all logical devices managed by the Voltha cluster
+ ListLogicalDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha5.LogicalDevices, error)
+ // Get additional information on a given logical device
+ GetLogicalDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalDevice, error)
+ // List ports of a logical device
+ ListLogicalDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalPorts, error)
+ // List all flows of a logical device
+ ListLogicalDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error)
+ // Update flow table for logical device
+ UpdateLogicalDeviceFlowTable(ctx context.Context, in *openflow_13.FlowTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // List all flow groups of a logical device
+ ListLogicalDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error)
+ // Update group table for device
+ UpdateLogicalDeviceFlowGroupTable(ctx context.Context, in *openflow_13.FlowGroupTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // List all physical devices controlled by the Voltha cluster
+ ListDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.Devices, error)
+ // Get more information on a given physical device
+ GetDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Device, error)
+ // Pre-provision a new physical device
+ CreateDevice(ctx context.Context, in *voltha6.Device, opts ...grpc.CallOption) (*voltha6.Device, error)
+ // Enable a device. If the device was in pre-provisioned state then it
+ // will tansition to ENABLED state. If it was is DISABLED state then it
+ // will tansition to ENABLED state as well.
+ EnableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // Disable a device
+ DisableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // Reboot a device
+ RebootDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // Delete a device
+ DeleteDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // List ports of a device
+ ListDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Ports, error)
+ // List pm config of a device
+ ListDevicePmConfigs(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.PmConfigs, error)
+ // Update the pm config of a device
+ UpdateDevicePmConfigs(ctx context.Context, in *voltha6.PmConfigs, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // List all flows of a device
+ ListDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error)
+ // List all flow groups of a device
+ ListDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error)
+ // List device types known to Voltha
+ ListDeviceTypes(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.DeviceTypes, error)
+ // Get additional information on a device type
+ GetDeviceType(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.DeviceType, error)
+ // List all device sharding groups
+ ListDeviceGroups(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*DeviceGroups, error)
+ // Get additional information on a device group
+ GetDeviceGroup(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*DeviceGroup, error)
+ CreateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error)
+ GetAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*AlarmFilter, error)
+ UpdateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error)
+ DeleteAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ ListAlarmFilters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*AlarmFilters, error)
+}
+
+type volthaGlobalServiceClient struct {
+ cc *grpc.ClientConn
+}
+
+func NewVolthaGlobalServiceClient(cc *grpc.ClientConn) VolthaGlobalServiceClient {
+ return &volthaGlobalServiceClient{cc}
+}
+
+func (c *volthaGlobalServiceClient) GetVoltha(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*Voltha, error) {
+ out := new(Voltha)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetVoltha", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListVolthaInstances(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VolthaInstances, error) {
+ out := new(VolthaInstances)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListVolthaInstances", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetVolthaInstance(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*VolthaInstance, error) {
+ out := new(VolthaInstance)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetVolthaInstance", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListLogicalDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha5.LogicalDevices, error) {
+ out := new(voltha5.LogicalDevices)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListLogicalDevices", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetLogicalDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalDevice, error) {
+ out := new(voltha5.LogicalDevice)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetLogicalDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListLogicalDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalPorts, error) {
+ out := new(voltha5.LogicalPorts)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListLogicalDevicePorts", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListLogicalDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error) {
+ out := new(openflow_13.Flows)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListLogicalDeviceFlows", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) UpdateLogicalDeviceFlowTable(ctx context.Context, in *openflow_13.FlowTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/UpdateLogicalDeviceFlowTable", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListLogicalDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error) {
+ out := new(openflow_13.FlowGroups)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListLogicalDeviceFlowGroups", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) UpdateLogicalDeviceFlowGroupTable(ctx context.Context, in *openflow_13.FlowGroupTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/UpdateLogicalDeviceFlowGroupTable", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.Devices, error) {
+ out := new(voltha6.Devices)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDevices", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Device, error) {
+ out := new(voltha6.Device)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) CreateDevice(ctx context.Context, in *voltha6.Device, opts ...grpc.CallOption) (*voltha6.Device, error) {
+ out := new(voltha6.Device)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/CreateDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) EnableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/EnableDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) DisableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/DisableDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) RebootDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/RebootDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) DeleteDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/DeleteDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Ports, error) {
+ out := new(voltha6.Ports)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDevicePorts", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDevicePmConfigs(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.PmConfigs, error) {
+ out := new(voltha6.PmConfigs)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDevicePmConfigs", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) UpdateDevicePmConfigs(ctx context.Context, in *voltha6.PmConfigs, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/UpdateDevicePmConfigs", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error) {
+ out := new(openflow_13.Flows)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDeviceFlows", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error) {
+ out := new(openflow_13.FlowGroups)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDeviceFlowGroups", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDeviceTypes(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.DeviceTypes, error) {
+ out := new(voltha6.DeviceTypes)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDeviceTypes", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetDeviceType(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.DeviceType, error) {
+ out := new(voltha6.DeviceType)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetDeviceType", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDeviceGroups(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*DeviceGroups, error) {
+ out := new(DeviceGroups)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDeviceGroups", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetDeviceGroup(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*DeviceGroup, error) {
+ out := new(DeviceGroup)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetDeviceGroup", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) CreateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error) {
+ out := new(AlarmFilter)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/CreateAlarmFilter", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*AlarmFilter, error) {
+ out := new(AlarmFilter)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetAlarmFilter", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) UpdateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error) {
+ out := new(AlarmFilter)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/UpdateAlarmFilter", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) DeleteAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/DeleteAlarmFilter", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListAlarmFilters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*AlarmFilters, error) {
+ out := new(AlarmFilters)
+ err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListAlarmFilters", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// Server API for VolthaGlobalService service
+
+type VolthaGlobalServiceServer interface {
+ // Get high level information on the Voltha cluster
+ GetVoltha(context.Context, *google_protobuf.Empty) (*Voltha, error)
+ // List all Voltha cluster instances
+ ListVolthaInstances(context.Context, *google_protobuf.Empty) (*VolthaInstances, error)
+ // Get details on a Voltha cluster instance
+ GetVolthaInstance(context.Context, *voltha3.ID) (*VolthaInstance, error)
+ // List all logical devices managed by the Voltha cluster
+ ListLogicalDevices(context.Context, *google_protobuf.Empty) (*voltha5.LogicalDevices, error)
+ // Get additional information on a given logical device
+ GetLogicalDevice(context.Context, *voltha3.ID) (*voltha5.LogicalDevice, error)
+ // List ports of a logical device
+ ListLogicalDevicePorts(context.Context, *voltha3.ID) (*voltha5.LogicalPorts, error)
+ // List all flows of a logical device
+ ListLogicalDeviceFlows(context.Context, *voltha3.ID) (*openflow_13.Flows, error)
+ // Update flow table for logical device
+ UpdateLogicalDeviceFlowTable(context.Context, *openflow_13.FlowTableUpdate) (*google_protobuf.Empty, error)
+ // List all flow groups of a logical device
+ ListLogicalDeviceFlowGroups(context.Context, *voltha3.ID) (*openflow_13.FlowGroups, error)
+ // Update group table for device
+ UpdateLogicalDeviceFlowGroupTable(context.Context, *openflow_13.FlowGroupTableUpdate) (*google_protobuf.Empty, error)
+ // List all physical devices controlled by the Voltha cluster
+ ListDevices(context.Context, *google_protobuf.Empty) (*voltha6.Devices, error)
+ // Get more information on a given physical device
+ GetDevice(context.Context, *voltha3.ID) (*voltha6.Device, error)
+ // Pre-provision a new physical device
+ CreateDevice(context.Context, *voltha6.Device) (*voltha6.Device, error)
+ // Enable a device. If the device was in pre-provisioned state then it
+ // will tansition to ENABLED state. If it was is DISABLED state then it
+ // will tansition to ENABLED state as well.
+ EnableDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+ // Disable a device
+ DisableDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+ // Reboot a device
+ RebootDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+ // Delete a device
+ DeleteDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+ // List ports of a device
+ ListDevicePorts(context.Context, *voltha3.ID) (*voltha6.Ports, error)
+ // List pm config of a device
+ ListDevicePmConfigs(context.Context, *voltha3.ID) (*voltha6.PmConfigs, error)
+ // Update the pm config of a device
+ UpdateDevicePmConfigs(context.Context, *voltha6.PmConfigs) (*google_protobuf.Empty, error)
+ // List all flows of a device
+ ListDeviceFlows(context.Context, *voltha3.ID) (*openflow_13.Flows, error)
+ // List all flow groups of a device
+ ListDeviceFlowGroups(context.Context, *voltha3.ID) (*openflow_13.FlowGroups, error)
+ // List device types known to Voltha
+ ListDeviceTypes(context.Context, *google_protobuf.Empty) (*voltha6.DeviceTypes, error)
+ // Get additional information on a device type
+ GetDeviceType(context.Context, *voltha3.ID) (*voltha6.DeviceType, error)
+ // List all device sharding groups
+ ListDeviceGroups(context.Context, *google_protobuf.Empty) (*DeviceGroups, error)
+ // Get additional information on a device group
+ GetDeviceGroup(context.Context, *voltha3.ID) (*DeviceGroup, error)
+ CreateAlarmFilter(context.Context, *AlarmFilter) (*AlarmFilter, error)
+ GetAlarmFilter(context.Context, *voltha3.ID) (*AlarmFilter, error)
+ UpdateAlarmFilter(context.Context, *AlarmFilter) (*AlarmFilter, error)
+ DeleteAlarmFilter(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+ ListAlarmFilters(context.Context, *google_protobuf.Empty) (*AlarmFilters, error)
+}
+
+func RegisterVolthaGlobalServiceServer(s *grpc.Server, srv VolthaGlobalServiceServer) {
+ s.RegisterService(&_VolthaGlobalService_serviceDesc, srv)
+}
+
+func _VolthaGlobalService_GetVoltha_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).GetVoltha(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/GetVoltha",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).GetVoltha(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListVolthaInstances_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListVolthaInstances(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListVolthaInstances",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListVolthaInstances(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetVolthaInstance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).GetVolthaInstance(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/GetVolthaInstance",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).GetVolthaInstance(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListLogicalDevices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListLogicalDevices(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListLogicalDevices",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListLogicalDevices(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetLogicalDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).GetLogicalDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/GetLogicalDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).GetLogicalDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListLogicalDevicePorts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListLogicalDevicePorts(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListLogicalDevicePorts",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListLogicalDevicePorts(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListLogicalDeviceFlows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListLogicalDeviceFlows(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListLogicalDeviceFlows",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListLogicalDeviceFlows(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_UpdateLogicalDeviceFlowTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(openflow_13.FlowTableUpdate)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).UpdateLogicalDeviceFlowTable(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/UpdateLogicalDeviceFlowTable",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).UpdateLogicalDeviceFlowTable(ctx, req.(*openflow_13.FlowTableUpdate))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListLogicalDeviceFlowGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListLogicalDeviceFlowGroups(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListLogicalDeviceFlowGroups",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListLogicalDeviceFlowGroups(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_UpdateLogicalDeviceFlowGroupTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(openflow_13.FlowGroupTableUpdate)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).UpdateLogicalDeviceFlowGroupTable(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/UpdateLogicalDeviceFlowGroupTable",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).UpdateLogicalDeviceFlowGroupTable(ctx, req.(*openflow_13.FlowGroupTableUpdate))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDevices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListDevices(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListDevices",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListDevices(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).GetDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/GetDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).GetDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_CreateDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha6.Device)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).CreateDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/CreateDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).CreateDevice(ctx, req.(*voltha6.Device))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_EnableDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).EnableDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/EnableDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).EnableDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_DisableDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).DisableDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/DisableDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).DisableDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_RebootDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).RebootDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/RebootDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).RebootDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_DeleteDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).DeleteDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/DeleteDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).DeleteDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDevicePorts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListDevicePorts(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListDevicePorts",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListDevicePorts(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDevicePmConfigs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListDevicePmConfigs(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListDevicePmConfigs",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListDevicePmConfigs(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_UpdateDevicePmConfigs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha6.PmConfigs)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).UpdateDevicePmConfigs(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/UpdateDevicePmConfigs",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).UpdateDevicePmConfigs(ctx, req.(*voltha6.PmConfigs))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDeviceFlows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListDeviceFlows(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListDeviceFlows",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListDeviceFlows(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDeviceFlowGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListDeviceFlowGroups(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListDeviceFlowGroups",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListDeviceFlowGroups(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDeviceTypes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListDeviceTypes(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListDeviceTypes",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListDeviceTypes(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetDeviceType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).GetDeviceType(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/GetDeviceType",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).GetDeviceType(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDeviceGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListDeviceGroups(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListDeviceGroups",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListDeviceGroups(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetDeviceGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).GetDeviceGroup(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/GetDeviceGroup",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).GetDeviceGroup(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_CreateAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(AlarmFilter)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).CreateAlarmFilter(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/CreateAlarmFilter",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).CreateAlarmFilter(ctx, req.(*AlarmFilter))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).GetAlarmFilter(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/GetAlarmFilter",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).GetAlarmFilter(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_UpdateAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(AlarmFilter)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).UpdateAlarmFilter(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/UpdateAlarmFilter",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).UpdateAlarmFilter(ctx, req.(*AlarmFilter))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_DeleteAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).DeleteAlarmFilter(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/DeleteAlarmFilter",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).DeleteAlarmFilter(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListAlarmFilters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaGlobalServiceServer).ListAlarmFilters(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaGlobalService/ListAlarmFilters",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaGlobalServiceServer).ListAlarmFilters(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _VolthaGlobalService_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "voltha.VolthaGlobalService",
+ HandlerType: (*VolthaGlobalServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "GetVoltha",
+ Handler: _VolthaGlobalService_GetVoltha_Handler,
+ },
+ {
+ MethodName: "ListVolthaInstances",
+ Handler: _VolthaGlobalService_ListVolthaInstances_Handler,
+ },
+ {
+ MethodName: "GetVolthaInstance",
+ Handler: _VolthaGlobalService_GetVolthaInstance_Handler,
+ },
+ {
+ MethodName: "ListLogicalDevices",
+ Handler: _VolthaGlobalService_ListLogicalDevices_Handler,
+ },
+ {
+ MethodName: "GetLogicalDevice",
+ Handler: _VolthaGlobalService_GetLogicalDevice_Handler,
+ },
+ {
+ MethodName: "ListLogicalDevicePorts",
+ Handler: _VolthaGlobalService_ListLogicalDevicePorts_Handler,
+ },
+ {
+ MethodName: "ListLogicalDeviceFlows",
+ Handler: _VolthaGlobalService_ListLogicalDeviceFlows_Handler,
+ },
+ {
+ MethodName: "UpdateLogicalDeviceFlowTable",
+ Handler: _VolthaGlobalService_UpdateLogicalDeviceFlowTable_Handler,
+ },
+ {
+ MethodName: "ListLogicalDeviceFlowGroups",
+ Handler: _VolthaGlobalService_ListLogicalDeviceFlowGroups_Handler,
+ },
+ {
+ MethodName: "UpdateLogicalDeviceFlowGroupTable",
+ Handler: _VolthaGlobalService_UpdateLogicalDeviceFlowGroupTable_Handler,
+ },
+ {
+ MethodName: "ListDevices",
+ Handler: _VolthaGlobalService_ListDevices_Handler,
+ },
+ {
+ MethodName: "GetDevice",
+ Handler: _VolthaGlobalService_GetDevice_Handler,
+ },
+ {
+ MethodName: "CreateDevice",
+ Handler: _VolthaGlobalService_CreateDevice_Handler,
+ },
+ {
+ MethodName: "EnableDevice",
+ Handler: _VolthaGlobalService_EnableDevice_Handler,
+ },
+ {
+ MethodName: "DisableDevice",
+ Handler: _VolthaGlobalService_DisableDevice_Handler,
+ },
+ {
+ MethodName: "RebootDevice",
+ Handler: _VolthaGlobalService_RebootDevice_Handler,
+ },
+ {
+ MethodName: "DeleteDevice",
+ Handler: _VolthaGlobalService_DeleteDevice_Handler,
+ },
+ {
+ MethodName: "ListDevicePorts",
+ Handler: _VolthaGlobalService_ListDevicePorts_Handler,
+ },
+ {
+ MethodName: "ListDevicePmConfigs",
+ Handler: _VolthaGlobalService_ListDevicePmConfigs_Handler,
+ },
+ {
+ MethodName: "UpdateDevicePmConfigs",
+ Handler: _VolthaGlobalService_UpdateDevicePmConfigs_Handler,
+ },
+ {
+ MethodName: "ListDeviceFlows",
+ Handler: _VolthaGlobalService_ListDeviceFlows_Handler,
+ },
+ {
+ MethodName: "ListDeviceFlowGroups",
+ Handler: _VolthaGlobalService_ListDeviceFlowGroups_Handler,
+ },
+ {
+ MethodName: "ListDeviceTypes",
+ Handler: _VolthaGlobalService_ListDeviceTypes_Handler,
+ },
+ {
+ MethodName: "GetDeviceType",
+ Handler: _VolthaGlobalService_GetDeviceType_Handler,
+ },
+ {
+ MethodName: "ListDeviceGroups",
+ Handler: _VolthaGlobalService_ListDeviceGroups_Handler,
+ },
+ {
+ MethodName: "GetDeviceGroup",
+ Handler: _VolthaGlobalService_GetDeviceGroup_Handler,
+ },
+ {
+ MethodName: "CreateAlarmFilter",
+ Handler: _VolthaGlobalService_CreateAlarmFilter_Handler,
+ },
+ {
+ MethodName: "GetAlarmFilter",
+ Handler: _VolthaGlobalService_GetAlarmFilter_Handler,
+ },
+ {
+ MethodName: "UpdateAlarmFilter",
+ Handler: _VolthaGlobalService_UpdateAlarmFilter_Handler,
+ },
+ {
+ MethodName: "DeleteAlarmFilter",
+ Handler: _VolthaGlobalService_DeleteAlarmFilter_Handler,
+ },
+ {
+ MethodName: "ListAlarmFilters",
+ Handler: _VolthaGlobalService_ListAlarmFilters_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "voltha.proto",
+}
+
+// Client API for VolthaLocalService service
+
+type VolthaLocalServiceClient interface {
+ // Get information on this Voltha instance
+ GetVolthaInstance(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VolthaInstance, error)
+ // Get the health state of the Voltha instance
+ GetHealth(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha4.HealthStatus, error)
+ // List all active adapters (plugins) in this Voltha instance
+ ListAdapters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha7.Adapters, error)
+ // List all logical devices managed by this Voltha instance
+ ListLogicalDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha5.LogicalDevices, error)
+ // Get additional information on given logical device
+ GetLogicalDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalDevice, error)
+ // List ports of a logical device
+ ListLogicalDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalPorts, error)
+ // List all flows of a logical device
+ ListLogicalDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error)
+ // Update flow table for logical device
+ UpdateLogicalDeviceFlowTable(ctx context.Context, in *openflow_13.FlowTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // List all flow groups of a logical device
+ ListLogicalDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error)
+ // Update group table for logical device
+ UpdateLogicalDeviceFlowGroupTable(ctx context.Context, in *openflow_13.FlowGroupTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // List all physical devices managed by this Voltha instance
+ ListDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.Devices, error)
+ // Get additional information on this device
+ GetDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Device, error)
+ // Pre-provision a new physical device
+ CreateDevice(ctx context.Context, in *voltha6.Device, opts ...grpc.CallOption) (*voltha6.Device, error)
+ // Enable a device. If the device was in pre-provisioned state then it
+ // will tansition to ENABLED state. If it was is DISABLED state then it
+ // will tansition to ENABLED state as well.
+ EnableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // Disable a device
+ DisableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // Reboot a device
+ RebootDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // Delete a device
+ DeleteDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // List ports of a device
+ ListDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Ports, error)
+ // List pm config of a device
+ ListDevicePmConfigs(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.PmConfigs, error)
+ // Update the pm config of a device
+ UpdateDevicePmConfigs(ctx context.Context, in *voltha6.PmConfigs, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ // List all flows of a device
+ ListDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error)
+ // List all flow groups of a device
+ ListDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error)
+ // List device types know to Voltha instance
+ ListDeviceTypes(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.DeviceTypes, error)
+ // Get additional information on given device type
+ GetDeviceType(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.DeviceType, error)
+ // List device sharding groups managed by this Voltha instance
+ ListDeviceGroups(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*DeviceGroups, error)
+ // Get more information on given device shard
+ GetDeviceGroup(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*DeviceGroup, error)
+ // Stream control packets to the dataplane
+ StreamPacketsOut(ctx context.Context, opts ...grpc.CallOption) (VolthaLocalService_StreamPacketsOutClient, error)
+ // Receive control packet stream
+ ReceivePacketsIn(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (VolthaLocalService_ReceivePacketsInClient, error)
+ ReceiveChangeEvents(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (VolthaLocalService_ReceiveChangeEventsClient, error)
+ CreateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error)
+ GetAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*AlarmFilter, error)
+ UpdateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error)
+ DeleteAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+ ListAlarmFilters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*AlarmFilters, error)
+}
+
+type volthaLocalServiceClient struct {
+ cc *grpc.ClientConn
+}
+
+func NewVolthaLocalServiceClient(cc *grpc.ClientConn) VolthaLocalServiceClient {
+ return &volthaLocalServiceClient{cc}
+}
+
+func (c *volthaLocalServiceClient) GetVolthaInstance(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VolthaInstance, error) {
+ out := new(VolthaInstance)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetVolthaInstance", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetHealth(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha4.HealthStatus, error) {
+ out := new(voltha4.HealthStatus)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetHealth", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListAdapters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha7.Adapters, error) {
+ out := new(voltha7.Adapters)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListAdapters", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListLogicalDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha5.LogicalDevices, error) {
+ out := new(voltha5.LogicalDevices)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListLogicalDevices", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetLogicalDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalDevice, error) {
+ out := new(voltha5.LogicalDevice)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetLogicalDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListLogicalDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalPorts, error) {
+ out := new(voltha5.LogicalPorts)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListLogicalDevicePorts", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListLogicalDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error) {
+ out := new(openflow_13.Flows)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListLogicalDeviceFlows", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) UpdateLogicalDeviceFlowTable(ctx context.Context, in *openflow_13.FlowTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/UpdateLogicalDeviceFlowTable", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListLogicalDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error) {
+ out := new(openflow_13.FlowGroups)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListLogicalDeviceFlowGroups", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) UpdateLogicalDeviceFlowGroupTable(ctx context.Context, in *openflow_13.FlowGroupTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/UpdateLogicalDeviceFlowGroupTable", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.Devices, error) {
+ out := new(voltha6.Devices)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDevices", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Device, error) {
+ out := new(voltha6.Device)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) CreateDevice(ctx context.Context, in *voltha6.Device, opts ...grpc.CallOption) (*voltha6.Device, error) {
+ out := new(voltha6.Device)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/CreateDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) EnableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/EnableDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) DisableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/DisableDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) RebootDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/RebootDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) DeleteDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/DeleteDevice", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Ports, error) {
+ out := new(voltha6.Ports)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDevicePorts", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDevicePmConfigs(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.PmConfigs, error) {
+ out := new(voltha6.PmConfigs)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDevicePmConfigs", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) UpdateDevicePmConfigs(ctx context.Context, in *voltha6.PmConfigs, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/UpdateDevicePmConfigs", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error) {
+ out := new(openflow_13.Flows)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDeviceFlows", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error) {
+ out := new(openflow_13.FlowGroups)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDeviceFlowGroups", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDeviceTypes(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.DeviceTypes, error) {
+ out := new(voltha6.DeviceTypes)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDeviceTypes", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetDeviceType(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.DeviceType, error) {
+ out := new(voltha6.DeviceType)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetDeviceType", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDeviceGroups(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*DeviceGroups, error) {
+ out := new(DeviceGroups)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDeviceGroups", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetDeviceGroup(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*DeviceGroup, error) {
+ out := new(DeviceGroup)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetDeviceGroup", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) StreamPacketsOut(ctx context.Context, opts ...grpc.CallOption) (VolthaLocalService_StreamPacketsOutClient, error) {
+ stream, err := grpc.NewClientStream(ctx, &_VolthaLocalService_serviceDesc.Streams[0], c.cc, "/voltha.VolthaLocalService/StreamPacketsOut", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &volthaLocalServiceStreamPacketsOutClient{stream}
+ return x, nil
+}
+
+type VolthaLocalService_StreamPacketsOutClient interface {
+ Send(*openflow_13.PacketOut) error
+ CloseAndRecv() (*google_protobuf.Empty, error)
+ grpc.ClientStream
+}
+
+type volthaLocalServiceStreamPacketsOutClient struct {
+ grpc.ClientStream
+}
+
+func (x *volthaLocalServiceStreamPacketsOutClient) Send(m *openflow_13.PacketOut) error {
+ return x.ClientStream.SendMsg(m)
+}
+
+func (x *volthaLocalServiceStreamPacketsOutClient) CloseAndRecv() (*google_protobuf.Empty, error) {
+ if err := x.ClientStream.CloseSend(); err != nil {
+ return nil, err
+ }
+ m := new(google_protobuf.Empty)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+func (c *volthaLocalServiceClient) ReceivePacketsIn(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (VolthaLocalService_ReceivePacketsInClient, error) {
+ stream, err := grpc.NewClientStream(ctx, &_VolthaLocalService_serviceDesc.Streams[1], c.cc, "/voltha.VolthaLocalService/ReceivePacketsIn", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &volthaLocalServiceReceivePacketsInClient{stream}
+ if err := x.ClientStream.SendMsg(in); err != nil {
+ return nil, err
+ }
+ if err := x.ClientStream.CloseSend(); err != nil {
+ return nil, err
+ }
+ return x, nil
+}
+
+type VolthaLocalService_ReceivePacketsInClient interface {
+ Recv() (*openflow_13.PacketIn, error)
+ grpc.ClientStream
+}
+
+type volthaLocalServiceReceivePacketsInClient struct {
+ grpc.ClientStream
+}
+
+func (x *volthaLocalServiceReceivePacketsInClient) Recv() (*openflow_13.PacketIn, error) {
+ m := new(openflow_13.PacketIn)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+func (c *volthaLocalServiceClient) ReceiveChangeEvents(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (VolthaLocalService_ReceiveChangeEventsClient, error) {
+ stream, err := grpc.NewClientStream(ctx, &_VolthaLocalService_serviceDesc.Streams[2], c.cc, "/voltha.VolthaLocalService/ReceiveChangeEvents", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &volthaLocalServiceReceiveChangeEventsClient{stream}
+ if err := x.ClientStream.SendMsg(in); err != nil {
+ return nil, err
+ }
+ if err := x.ClientStream.CloseSend(); err != nil {
+ return nil, err
+ }
+ return x, nil
+}
+
+type VolthaLocalService_ReceiveChangeEventsClient interface {
+ Recv() (*openflow_13.ChangeEvent, error)
+ grpc.ClientStream
+}
+
+type volthaLocalServiceReceiveChangeEventsClient struct {
+ grpc.ClientStream
+}
+
+func (x *volthaLocalServiceReceiveChangeEventsClient) Recv() (*openflow_13.ChangeEvent, error) {
+ m := new(openflow_13.ChangeEvent)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+func (c *volthaLocalServiceClient) CreateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error) {
+ out := new(AlarmFilter)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/CreateAlarmFilter", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*AlarmFilter, error) {
+ out := new(AlarmFilter)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetAlarmFilter", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) UpdateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error) {
+ out := new(AlarmFilter)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/UpdateAlarmFilter", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) DeleteAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+ out := new(google_protobuf.Empty)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/DeleteAlarmFilter", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListAlarmFilters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*AlarmFilters, error) {
+ out := new(AlarmFilters)
+ err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListAlarmFilters", in, out, c.cc, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// Server API for VolthaLocalService service
+
+type VolthaLocalServiceServer interface {
+ // Get information on this Voltha instance
+ GetVolthaInstance(context.Context, *google_protobuf.Empty) (*VolthaInstance, error)
+ // Get the health state of the Voltha instance
+ GetHealth(context.Context, *google_protobuf.Empty) (*voltha4.HealthStatus, error)
+ // List all active adapters (plugins) in this Voltha instance
+ ListAdapters(context.Context, *google_protobuf.Empty) (*voltha7.Adapters, error)
+ // List all logical devices managed by this Voltha instance
+ ListLogicalDevices(context.Context, *google_protobuf.Empty) (*voltha5.LogicalDevices, error)
+ // Get additional information on given logical device
+ GetLogicalDevice(context.Context, *voltha3.ID) (*voltha5.LogicalDevice, error)
+ // List ports of a logical device
+ ListLogicalDevicePorts(context.Context, *voltha3.ID) (*voltha5.LogicalPorts, error)
+ // List all flows of a logical device
+ ListLogicalDeviceFlows(context.Context, *voltha3.ID) (*openflow_13.Flows, error)
+ // Update flow table for logical device
+ UpdateLogicalDeviceFlowTable(context.Context, *openflow_13.FlowTableUpdate) (*google_protobuf.Empty, error)
+ // List all flow groups of a logical device
+ ListLogicalDeviceFlowGroups(context.Context, *voltha3.ID) (*openflow_13.FlowGroups, error)
+ // Update group table for logical device
+ UpdateLogicalDeviceFlowGroupTable(context.Context, *openflow_13.FlowGroupTableUpdate) (*google_protobuf.Empty, error)
+ // List all physical devices managed by this Voltha instance
+ ListDevices(context.Context, *google_protobuf.Empty) (*voltha6.Devices, error)
+ // Get additional information on this device
+ GetDevice(context.Context, *voltha3.ID) (*voltha6.Device, error)
+ // Pre-provision a new physical device
+ CreateDevice(context.Context, *voltha6.Device) (*voltha6.Device, error)
+ // Enable a device. If the device was in pre-provisioned state then it
+ // will tansition to ENABLED state. If it was is DISABLED state then it
+ // will tansition to ENABLED state as well.
+ EnableDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+ // Disable a device
+ DisableDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+ // Reboot a device
+ RebootDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+ // Delete a device
+ DeleteDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+ // List ports of a device
+ ListDevicePorts(context.Context, *voltha3.ID) (*voltha6.Ports, error)
+ // List pm config of a device
+ ListDevicePmConfigs(context.Context, *voltha3.ID) (*voltha6.PmConfigs, error)
+ // Update the pm config of a device
+ UpdateDevicePmConfigs(context.Context, *voltha6.PmConfigs) (*google_protobuf.Empty, error)
+ // List all flows of a device
+ ListDeviceFlows(context.Context, *voltha3.ID) (*openflow_13.Flows, error)
+ // List all flow groups of a device
+ ListDeviceFlowGroups(context.Context, *voltha3.ID) (*openflow_13.FlowGroups, error)
+ // List device types know to Voltha instance
+ ListDeviceTypes(context.Context, *google_protobuf.Empty) (*voltha6.DeviceTypes, error)
+ // Get additional information on given device type
+ GetDeviceType(context.Context, *voltha3.ID) (*voltha6.DeviceType, error)
+ // List device sharding groups managed by this Voltha instance
+ ListDeviceGroups(context.Context, *google_protobuf.Empty) (*DeviceGroups, error)
+ // Get more information on given device shard
+ GetDeviceGroup(context.Context, *voltha3.ID) (*DeviceGroup, error)
+ // Stream control packets to the dataplane
+ StreamPacketsOut(VolthaLocalService_StreamPacketsOutServer) error
+ // Receive control packet stream
+ ReceivePacketsIn(*google_protobuf.Empty, VolthaLocalService_ReceivePacketsInServer) error
+ ReceiveChangeEvents(*google_protobuf.Empty, VolthaLocalService_ReceiveChangeEventsServer) error
+ CreateAlarmFilter(context.Context, *AlarmFilter) (*AlarmFilter, error)
+ GetAlarmFilter(context.Context, *voltha3.ID) (*AlarmFilter, error)
+ UpdateAlarmFilter(context.Context, *AlarmFilter) (*AlarmFilter, error)
+ DeleteAlarmFilter(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+ ListAlarmFilters(context.Context, *google_protobuf.Empty) (*AlarmFilters, error)
+}
+
+func RegisterVolthaLocalServiceServer(s *grpc.Server, srv VolthaLocalServiceServer) {
+ s.RegisterService(&_VolthaLocalService_serviceDesc, srv)
+}
+
+func _VolthaLocalService_GetVolthaInstance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).GetVolthaInstance(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/GetVolthaInstance",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).GetVolthaInstance(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetHealth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).GetHealth(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/GetHealth",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).GetHealth(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListAdapters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListAdapters(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListAdapters",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListAdapters(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListLogicalDevices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListLogicalDevices(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListLogicalDevices",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListLogicalDevices(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetLogicalDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).GetLogicalDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/GetLogicalDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).GetLogicalDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListLogicalDevicePorts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListLogicalDevicePorts(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListLogicalDevicePorts",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListLogicalDevicePorts(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListLogicalDeviceFlows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListLogicalDeviceFlows(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListLogicalDeviceFlows",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListLogicalDeviceFlows(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_UpdateLogicalDeviceFlowTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(openflow_13.FlowTableUpdate)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).UpdateLogicalDeviceFlowTable(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/UpdateLogicalDeviceFlowTable",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).UpdateLogicalDeviceFlowTable(ctx, req.(*openflow_13.FlowTableUpdate))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListLogicalDeviceFlowGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListLogicalDeviceFlowGroups(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListLogicalDeviceFlowGroups",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListLogicalDeviceFlowGroups(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_UpdateLogicalDeviceFlowGroupTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(openflow_13.FlowGroupTableUpdate)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).UpdateLogicalDeviceFlowGroupTable(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/UpdateLogicalDeviceFlowGroupTable",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).UpdateLogicalDeviceFlowGroupTable(ctx, req.(*openflow_13.FlowGroupTableUpdate))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDevices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListDevices(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListDevices",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListDevices(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).GetDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/GetDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).GetDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_CreateDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha6.Device)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).CreateDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/CreateDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).CreateDevice(ctx, req.(*voltha6.Device))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_EnableDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).EnableDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/EnableDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).EnableDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_DisableDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).DisableDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/DisableDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).DisableDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_RebootDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).RebootDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/RebootDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).RebootDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_DeleteDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).DeleteDevice(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/DeleteDevice",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).DeleteDevice(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDevicePorts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListDevicePorts(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListDevicePorts",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListDevicePorts(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDevicePmConfigs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListDevicePmConfigs(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListDevicePmConfigs",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListDevicePmConfigs(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_UpdateDevicePmConfigs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha6.PmConfigs)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).UpdateDevicePmConfigs(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/UpdateDevicePmConfigs",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).UpdateDevicePmConfigs(ctx, req.(*voltha6.PmConfigs))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDeviceFlows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListDeviceFlows(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListDeviceFlows",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListDeviceFlows(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDeviceFlowGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListDeviceFlowGroups(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListDeviceFlowGroups",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListDeviceFlowGroups(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDeviceTypes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListDeviceTypes(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListDeviceTypes",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListDeviceTypes(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetDeviceType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).GetDeviceType(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/GetDeviceType",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).GetDeviceType(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDeviceGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListDeviceGroups(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListDeviceGroups",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListDeviceGroups(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetDeviceGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).GetDeviceGroup(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/GetDeviceGroup",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).GetDeviceGroup(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_StreamPacketsOut_Handler(srv interface{}, stream grpc.ServerStream) error {
+ return srv.(VolthaLocalServiceServer).StreamPacketsOut(&volthaLocalServiceStreamPacketsOutServer{stream})
+}
+
+type VolthaLocalService_StreamPacketsOutServer interface {
+ SendAndClose(*google_protobuf.Empty) error
+ Recv() (*openflow_13.PacketOut, error)
+ grpc.ServerStream
+}
+
+type volthaLocalServiceStreamPacketsOutServer struct {
+ grpc.ServerStream
+}
+
+func (x *volthaLocalServiceStreamPacketsOutServer) SendAndClose(m *google_protobuf.Empty) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+func (x *volthaLocalServiceStreamPacketsOutServer) Recv() (*openflow_13.PacketOut, error) {
+ m := new(openflow_13.PacketOut)
+ if err := x.ServerStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+func _VolthaLocalService_ReceivePacketsIn_Handler(srv interface{}, stream grpc.ServerStream) error {
+ m := new(google_protobuf.Empty)
+ if err := stream.RecvMsg(m); err != nil {
+ return err
+ }
+ return srv.(VolthaLocalServiceServer).ReceivePacketsIn(m, &volthaLocalServiceReceivePacketsInServer{stream})
+}
+
+type VolthaLocalService_ReceivePacketsInServer interface {
+ Send(*openflow_13.PacketIn) error
+ grpc.ServerStream
+}
+
+type volthaLocalServiceReceivePacketsInServer struct {
+ grpc.ServerStream
+}
+
+func (x *volthaLocalServiceReceivePacketsInServer) Send(m *openflow_13.PacketIn) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+func _VolthaLocalService_ReceiveChangeEvents_Handler(srv interface{}, stream grpc.ServerStream) error {
+ m := new(google_protobuf.Empty)
+ if err := stream.RecvMsg(m); err != nil {
+ return err
+ }
+ return srv.(VolthaLocalServiceServer).ReceiveChangeEvents(m, &volthaLocalServiceReceiveChangeEventsServer{stream})
+}
+
+type VolthaLocalService_ReceiveChangeEventsServer interface {
+ Send(*openflow_13.ChangeEvent) error
+ grpc.ServerStream
+}
+
+type volthaLocalServiceReceiveChangeEventsServer struct {
+ grpc.ServerStream
+}
+
+func (x *volthaLocalServiceReceiveChangeEventsServer) Send(m *openflow_13.ChangeEvent) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+func _VolthaLocalService_CreateAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(AlarmFilter)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).CreateAlarmFilter(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/CreateAlarmFilter",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).CreateAlarmFilter(ctx, req.(*AlarmFilter))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).GetAlarmFilter(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/GetAlarmFilter",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).GetAlarmFilter(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_UpdateAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(AlarmFilter)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).UpdateAlarmFilter(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/UpdateAlarmFilter",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).UpdateAlarmFilter(ctx, req.(*AlarmFilter))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_DeleteAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(voltha3.ID)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).DeleteAlarmFilter(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/DeleteAlarmFilter",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).DeleteAlarmFilter(ctx, req.(*voltha3.ID))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListAlarmFilters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(google_protobuf.Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(VolthaLocalServiceServer).ListAlarmFilters(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/voltha.VolthaLocalService/ListAlarmFilters",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(VolthaLocalServiceServer).ListAlarmFilters(ctx, req.(*google_protobuf.Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _VolthaLocalService_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "voltha.VolthaLocalService",
+ HandlerType: (*VolthaLocalServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "GetVolthaInstance",
+ Handler: _VolthaLocalService_GetVolthaInstance_Handler,
+ },
+ {
+ MethodName: "GetHealth",
+ Handler: _VolthaLocalService_GetHealth_Handler,
+ },
+ {
+ MethodName: "ListAdapters",
+ Handler: _VolthaLocalService_ListAdapters_Handler,
+ },
+ {
+ MethodName: "ListLogicalDevices",
+ Handler: _VolthaLocalService_ListLogicalDevices_Handler,
+ },
+ {
+ MethodName: "GetLogicalDevice",
+ Handler: _VolthaLocalService_GetLogicalDevice_Handler,
+ },
+ {
+ MethodName: "ListLogicalDevicePorts",
+ Handler: _VolthaLocalService_ListLogicalDevicePorts_Handler,
+ },
+ {
+ MethodName: "ListLogicalDeviceFlows",
+ Handler: _VolthaLocalService_ListLogicalDeviceFlows_Handler,
+ },
+ {
+ MethodName: "UpdateLogicalDeviceFlowTable",
+ Handler: _VolthaLocalService_UpdateLogicalDeviceFlowTable_Handler,
+ },
+ {
+ MethodName: "ListLogicalDeviceFlowGroups",
+ Handler: _VolthaLocalService_ListLogicalDeviceFlowGroups_Handler,
+ },
+ {
+ MethodName: "UpdateLogicalDeviceFlowGroupTable",
+ Handler: _VolthaLocalService_UpdateLogicalDeviceFlowGroupTable_Handler,
+ },
+ {
+ MethodName: "ListDevices",
+ Handler: _VolthaLocalService_ListDevices_Handler,
+ },
+ {
+ MethodName: "GetDevice",
+ Handler: _VolthaLocalService_GetDevice_Handler,
+ },
+ {
+ MethodName: "CreateDevice",
+ Handler: _VolthaLocalService_CreateDevice_Handler,
+ },
+ {
+ MethodName: "EnableDevice",
+ Handler: _VolthaLocalService_EnableDevice_Handler,
+ },
+ {
+ MethodName: "DisableDevice",
+ Handler: _VolthaLocalService_DisableDevice_Handler,
+ },
+ {
+ MethodName: "RebootDevice",
+ Handler: _VolthaLocalService_RebootDevice_Handler,
+ },
+ {
+ MethodName: "DeleteDevice",
+ Handler: _VolthaLocalService_DeleteDevice_Handler,
+ },
+ {
+ MethodName: "ListDevicePorts",
+ Handler: _VolthaLocalService_ListDevicePorts_Handler,
+ },
+ {
+ MethodName: "ListDevicePmConfigs",
+ Handler: _VolthaLocalService_ListDevicePmConfigs_Handler,
+ },
+ {
+ MethodName: "UpdateDevicePmConfigs",
+ Handler: _VolthaLocalService_UpdateDevicePmConfigs_Handler,
+ },
+ {
+ MethodName: "ListDeviceFlows",
+ Handler: _VolthaLocalService_ListDeviceFlows_Handler,
+ },
+ {
+ MethodName: "ListDeviceFlowGroups",
+ Handler: _VolthaLocalService_ListDeviceFlowGroups_Handler,
+ },
+ {
+ MethodName: "ListDeviceTypes",
+ Handler: _VolthaLocalService_ListDeviceTypes_Handler,
+ },
+ {
+ MethodName: "GetDeviceType",
+ Handler: _VolthaLocalService_GetDeviceType_Handler,
+ },
+ {
+ MethodName: "ListDeviceGroups",
+ Handler: _VolthaLocalService_ListDeviceGroups_Handler,
+ },
+ {
+ MethodName: "GetDeviceGroup",
+ Handler: _VolthaLocalService_GetDeviceGroup_Handler,
+ },
+ {
+ MethodName: "CreateAlarmFilter",
+ Handler: _VolthaLocalService_CreateAlarmFilter_Handler,
+ },
+ {
+ MethodName: "GetAlarmFilter",
+ Handler: _VolthaLocalService_GetAlarmFilter_Handler,
+ },
+ {
+ MethodName: "UpdateAlarmFilter",
+ Handler: _VolthaLocalService_UpdateAlarmFilter_Handler,
+ },
+ {
+ MethodName: "DeleteAlarmFilter",
+ Handler: _VolthaLocalService_DeleteAlarmFilter_Handler,
+ },
+ {
+ MethodName: "ListAlarmFilters",
+ Handler: _VolthaLocalService_ListAlarmFilters_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{
+ {
+ StreamName: "StreamPacketsOut",
+ Handler: _VolthaLocalService_StreamPacketsOut_Handler,
+ ClientStreams: true,
+ },
+ {
+ StreamName: "ReceivePacketsIn",
+ Handler: _VolthaLocalService_ReceivePacketsIn_Handler,
+ ServerStreams: true,
+ },
+ {
+ StreamName: "ReceiveChangeEvents",
+ Handler: _VolthaLocalService_ReceiveChangeEvents_Handler,
+ ServerStreams: true,
+ },
+ },
+ Metadata: "voltha.proto",
+}
+
+func init() { proto.RegisterFile("voltha.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 2029 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x4b, 0x73, 0x1b, 0x59,
+ 0x15, 0x4e, 0xfb, 0xad, 0x23, 0xc9, 0x92, 0xae, 0x5f, 0xb2, 0x6c, 0x4f, 0xec, 0x9b, 0x49, 0xc6,
+ 0xf1, 0x94, 0xa5, 0xc4, 0x66, 0x42, 0x4d, 0x18, 0x8a, 0xc1, 0x8f, 0x24, 0x26, 0x2e, 0xa2, 0x52,
+ 0x32, 0x33, 0x40, 0x48, 0xa9, 0xda, 0xd2, 0x8d, 0xdc, 0x4c, 0xab, 0x5b, 0xd5, 0xdd, 0xd2, 0x8c,
+ 0x6a, 0x60, 0xc1, 0xb0, 0x82, 0x25, 0xd9, 0xc0, 0x9e, 0x0d, 0x6c, 0xf8, 0x25, 0x59, 0x50, 0xfc,
+ 0x03, 0x8a, 0x05, 0xbf, 0x60, 0x60, 0x49, 0xdd, 0x97, 0xd4, 0x8f, 0xdb, 0x7a, 0xd9, 0xb3, 0x98,
+ 0x5d, 0xf7, 0x7d, 0x7c, 0xdf, 0x39, 0xa7, 0xcf, 0x39, 0xf7, 0x7e, 0x0d, 0xa9, 0x8e, 0x6d, 0x7a,
+ 0x97, 0x7a, 0xb1, 0xe5, 0xd8, 0x9e, 0x8d, 0xe6, 0xf8, 0x5b, 0x61, 0xa3, 0x61, 0xdb, 0x0d, 0x93,
+ 0x94, 0xd8, 0xe8, 0x45, 0xfb, 0x75, 0x89, 0x34, 0x5b, 0x5e, 0x97, 0x2f, 0x2a, 0xac, 0x87, 0x27,
+ 0x75, 0x4b, 0x4e, 0x6d, 0x8a, 0x29, 0xbd, 0x65, 0x94, 0x74, 0xcb, 0xb2, 0x3d, 0xdd, 0x33, 0x6c,
+ 0xcb, 0x15, 0xb3, 0xa8, 0xab, 0x5b, 0x8d, 0xaa, 0xdd, 0xf2, 0x8f, 0x41, 0x93, 0x78, 0x82, 0xbd,
+ 0x90, 0xaa, 0xd9, 0xcd, 0xa6, 0x6d, 0xc9, 0xb7, 0x4b, 0xa2, 0x9b, 0xde, 0xa5, 0x78, 0x5b, 0x36,
+ 0xed, 0x86, 0x51, 0xd3, 0xcd, 0x6a, 0x9d, 0x74, 0x8c, 0x1a, 0x91, 0x6b, 0x02, 0x6f, 0x69, 0xbd,
+ 0xae, 0xb7, 0x3c, 0xe2, 0x88, 0xd7, 0x9c, 0xdd, 0x22, 0xd6, 0x6b, 0xd3, 0xfe, 0xa2, 0x7a, 0xff,
+ 0x90, 0x0f, 0xe1, 0xbf, 0x68, 0x90, 0x3c, 0x61, 0x5b, 0x1e, 0x3b, 0x76, 0xbb, 0x85, 0x56, 0x60,
+ 0xca, 0xa8, 0xe7, 0xb5, 0x6d, 0x6d, 0x37, 0x71, 0x34, 0xfb, 0x9f, 0x6f, 0xde, 0x6e, 0x69, 0x95,
+ 0x29, 0xa3, 0x8e, 0xce, 0x20, 0x13, 0xa4, 0x73, 0xf3, 0x53, 0xdb, 0xd3, 0xbb, 0xc9, 0x83, 0x95,
+ 0xa2, 0x08, 0xd7, 0x39, 0x9f, 0xe6, 0x58, 0x47, 0x89, 0x7f, 0x7d, 0xf3, 0x76, 0x6b, 0x86, 0x62,
+ 0x55, 0x16, 0x4d, 0xff, 0x8c, 0x8b, 0x0e, 0x61, 0x5e, 0x42, 0x4c, 0x33, 0x88, 0x45, 0x09, 0x11,
+ 0xdd, 0x2b, 0x57, 0xe2, 0x0f, 0x21, 0xe5, 0xb3, 0xd2, 0x45, 0x77, 0x61, 0xd6, 0xf0, 0x48, 0xd3,
+ 0xcd, 0x6b, 0x0c, 0x62, 0x29, 0x08, 0xc1, 0x16, 0x55, 0xf8, 0x0a, 0xfc, 0x25, 0xa0, 0x1f, 0x9b,
+ 0xba, 0xd3, 0x7c, 0x64, 0x98, 0x1e, 0x71, 0x2a, 0x6d, 0x93, 0x3c, 0x25, 0x5d, 0x7c, 0xa1, 0x1a,
+ 0x45, 0x73, 0x94, 0x35, 0x7b, 0x03, 0x2d, 0xc0, 0x8c, 0xd7, 0x6d, 0x91, 0xac, 0x86, 0x52, 0xb0,
+ 0xe0, 0x92, 0x0e, 0x71, 0x0c, 0xaf, 0x9b, 0x9d, 0x42, 0x19, 0x48, 0x3a, 0xc4, 0xb5, 0xdb, 0x4e,
+ 0x8d, 0x54, 0x8d, 0x7a, 0x76, 0x9a, 0x4e, 0xd7, 0x74, 0x8f, 0x34, 0x6c, 0xa7, 0x9b, 0x9d, 0x41,
+ 0x69, 0x48, 0x70, 0x83, 0xe9, 0xe4, 0x2c, 0xbe, 0x84, 0x4c, 0x88, 0x03, 0xfd, 0x08, 0xa6, 0x3f,
+ 0x27, 0x5d, 0x16, 0xdf, 0xc5, 0x83, 0x7d, 0x69, 0x75, 0xd4, 0x12, 0xc5, 0x50, 0x85, 0xee, 0x44,
+ 0xcb, 0x30, 0xdb, 0xd1, 0xcd, 0x36, 0xc9, 0x4f, 0xd1, 0x4f, 0x54, 0xe1, 0x2f, 0xf8, 0x39, 0x24,
+ 0x7d, 0x1b, 0xe2, 0x3e, 0xe2, 0x3e, 0xcc, 0x3a, 0x6d, 0xb3, 0xf7, 0xe9, 0xd6, 0x62, 0xe8, 0x2b,
+ 0x7c, 0x15, 0xfe, 0x21, 0xa4, 0x7c, 0x33, 0x2e, 0xda, 0x87, 0xf9, 0xd7, 0xfc, 0x31, 0x1c, 0x75,
+ 0x3f, 0x80, 0x5c, 0x83, 0xff, 0x31, 0x03, 0x8b, 0x9f, 0xb2, 0xf9, 0x33, 0xcb, 0xf5, 0x74, 0xab,
+ 0x46, 0xd0, 0x1d, 0x48, 0x1a, 0xe2, 0xb9, 0x1a, 0x36, 0x10, 0xe4, 0xcc, 0x59, 0x1d, 0xdd, 0x84,
+ 0xf9, 0x0e, 0x71, 0x5c, 0xc3, 0xb6, 0xb8, 0x9b, 0x72, 0x8d, 0x1c, 0x45, 0x0f, 0x20, 0x61, 0xda,
+ 0x8d, 0xaa, 0x49, 0x3a, 0xc4, 0xcc, 0x4f, 0xb3, 0x60, 0xae, 0xfb, 0x12, 0xf1, 0x9c, 0x8e, 0xf7,
+ 0x1e, 0x2a, 0x0b, 0xa6, 0x78, 0x42, 0x87, 0x30, 0xc7, 0x6b, 0x28, 0x0f, 0xdb, 0xda, 0x6e, 0xf2,
+ 0x60, 0x59, 0x6e, 0x7a, 0xc2, 0x46, 0x9f, 0x7b, 0xba, 0xd7, 0x76, 0x8f, 0x66, 0x69, 0x02, 0xde,
+ 0xa8, 0x88, 0xa5, 0xe8, 0x01, 0x2c, 0x88, 0x32, 0x72, 0xf3, 0x49, 0xe6, 0x78, 0xa6, 0xe7, 0x38,
+ 0x1f, 0xf7, 0xa7, 0x6c, 0x6f, 0xad, 0xaa, 0x66, 0x52, 0x57, 0xaf, 0x99, 0xf4, 0xa8, 0x35, 0x83,
+ 0x3e, 0x06, 0xd1, 0x0c, 0xaa, 0x34, 0x97, 0xdd, 0xfc, 0x22, 0xdb, 0x89, 0x82, 0x3b, 0x5f, 0x74,
+ 0x5b, 0x81, 0xdd, 0xc9, 0x7a, 0x6f, 0xd8, 0x45, 0xc7, 0x90, 0x16, 0x08, 0x0d, 0x56, 0x76, 0xf9,
+ 0x4c, 0x6c, 0xb5, 0xf9, 0x31, 0x04, 0xad, 0x28, 0xd5, 0x63, 0x48, 0xeb, 0x34, 0x3f, 0xaa, 0x32,
+ 0x79, 0xb2, 0xb1, 0xc9, 0x13, 0x00, 0xd1, 0x7d, 0xb9, 0xf7, 0x70, 0xf6, 0x7f, 0x34, 0x01, 0x70,
+ 0x11, 0x32, 0xc1, 0x94, 0x72, 0x69, 0x41, 0xf4, 0x3b, 0x41, 0x42, 0x14, 0xbd, 0x5c, 0xff, 0xf7,
+ 0x69, 0x98, 0xe3, 0x1b, 0xfc, 0x39, 0xa5, 0x0d, 0xcf, 0xa9, 0xa9, 0xd1, 0x73, 0xea, 0x09, 0x24,
+ 0x64, 0xea, 0xca, 0x8e, 0xb6, 0x2a, 0xf7, 0x05, 0x8d, 0x3d, 0x42, 0xd4, 0xbd, 0x74, 0xa0, 0x08,
+ 0x2a, 0xfd, 0xcd, 0xdf, 0xd9, 0x44, 0xbb, 0x8e, 0x34, 0x11, 0x5f, 0xec, 0xe0, 0xcd, 0x3a, 0x2c,
+ 0xf1, 0xa8, 0x3d, 0x36, 0xed, 0x0b, 0xdd, 0x7c, 0x4e, 0x1c, 0xba, 0x08, 0x9d, 0x40, 0xe2, 0x31,
+ 0xf1, 0xc4, 0xb7, 0x5c, 0x2d, 0xf2, 0x53, 0xb5, 0x28, 0x0f, 0xdc, 0xe2, 0x29, 0x3d, 0x8d, 0x0b,
+ 0x8b, 0xc1, 0xb8, 0xe3, 0xcc, 0xd7, 0xff, 0xfc, 0xf7, 0x9b, 0xa9, 0x04, 0x9a, 0x67, 0xc7, 0x6f,
+ 0xe7, 0x3e, 0xea, 0xc2, 0xd2, 0xb9, 0xe1, 0x7a, 0xe1, 0x1c, 0x8a, 0xc3, 0x5b, 0x53, 0x7f, 0x47,
+ 0x17, 0xdf, 0xff, 0xc3, 0x7f, 0xdf, 0x6e, 0xcd, 0x8b, 0xcc, 0x63, 0xcf, 0x88, 0x3f, 0x33, 0xc2,
+ 0x25, 0x94, 0x13, 0x84, 0xa5, 0xfe, 0xc7, 0xfd, 0x0c, 0x72, 0x3d, 0x07, 0x7a, 0x0d, 0x11, 0x24,
+ 0xc1, 0xd9, 0x49, 0x21, 0x26, 0x69, 0xf0, 0x3b, 0x0c, 0x33, 0x8f, 0x56, 0x23, 0x98, 0xa5, 0xaf,
+ 0x8c, 0xfa, 0x6f, 0xd0, 0x57, 0x80, 0xa8, 0x4f, 0xe7, 0xc1, 0x0f, 0x19, 0xe7, 0xd2, 0xaa, 0x32,
+ 0x25, 0x5c, 0xfc, 0x01, 0xf5, 0x22, 0x17, 0x49, 0x24, 0xc6, 0xbd, 0x8e, 0xd6, 0x24, 0x77, 0x68,
+ 0x1a, 0xbd, 0x84, 0xec, 0x63, 0x12, 0xe4, 0x0e, 0x38, 0xa5, 0xce, 0x40, 0xfc, 0x2e, 0xc3, 0x7d,
+ 0x07, 0x6d, 0xc6, 0xe0, 0x72, 0xcf, 0x1c, 0x58, 0x8d, 0x78, 0x56, 0xb6, 0x1d, 0xcf, 0x0d, 0x50,
+ 0x2c, 0x87, 0x28, 0xd8, 0x0a, 0xfc, 0x40, 0x7c, 0xa1, 0x16, 0x7d, 0x63, 0x6c, 0xef, 0x22, 0x3c,
+ 0x88, 0xad, 0xc4, 0x56, 0xa2, 0x5f, 0x2b, 0x38, 0x1f, 0x99, 0xf6, 0x17, 0x41, 0x4e, 0x54, 0xf4,
+ 0xdf, 0xa4, 0xd8, 0x3c, 0x3e, 0x12, 0x8c, 0x74, 0x34, 0x9a, 0x13, 0xc3, 0xd8, 0xd9, 0x2e, 0xf4,
+ 0x3b, 0x0d, 0x36, 0x3f, 0x69, 0xd5, 0x75, 0x8f, 0x44, 0x0c, 0x78, 0xa1, 0x5f, 0x98, 0x04, 0x6d,
+ 0x46, 0x88, 0xd9, 0x38, 0xdf, 0x53, 0x88, 0xf9, 0xe8, 0x78, 0x9f, 0x99, 0xf0, 0x1e, 0x1e, 0xc1,
+ 0x84, 0x87, 0xda, 0x1e, 0xfa, 0xa3, 0x06, 0x1b, 0xca, 0x20, 0x88, 0x8e, 0xee, 0x8f, 0xc4, 0x5a,
+ 0xc4, 0x20, 0xbe, 0x08, 0xff, 0x94, 0x86, 0x20, 0x0d, 0x49, 0x36, 0xc5, 0xfb, 0x42, 0x24, 0x28,
+ 0x7b, 0x68, 0x77, 0xa8, 0x45, 0x62, 0x2f, 0x7a, 0xa3, 0xc1, 0x4e, 0x4c, 0x68, 0x18, 0x23, 0x8f,
+ 0xcf, 0x8e, 0xda, 0x9c, 0x51, 0x82, 0x74, 0xc8, 0x4c, 0xda, 0xc7, 0x23, 0x9b, 0x44, 0x43, 0xf5,
+ 0x0a, 0x92, 0x34, 0x52, 0xc3, 0xaa, 0x2e, 0x13, 0x6c, 0x85, 0x2e, 0xbe, 0x4d, 0x63, 0x91, 0xe8,
+ 0x35, 0x5b, 0x46, 0x9d, 0x43, 0x19, 0x49, 0x2d, 0xcb, 0xeb, 0x94, 0x75, 0x3d, 0x45, 0x5d, 0x85,
+ 0xda, 0x32, 0xde, 0x64, 0x08, 0xab, 0x68, 0x39, 0x84, 0xc0, 0x0b, 0xe9, 0x27, 0x90, 0x3a, 0x76,
+ 0x88, 0xee, 0x11, 0x81, 0x14, 0xda, 0x1d, 0x41, 0x2b, 0x30, 0xb4, 0x65, 0x1c, 0xb6, 0x87, 0x7a,
+ 0xfc, 0x19, 0xa4, 0x4e, 0x2d, 0x1a, 0x4e, 0x85, 0x55, 0x71, 0xa1, 0xbd, 0xc5, 0xf0, 0xb6, 0xf0,
+ 0x86, 0xca, 0xba, 0x12, 0x61, 0x70, 0xe8, 0xe7, 0x90, 0x3e, 0x31, 0xdc, 0x31, 0x91, 0x45, 0x23,
+ 0xc1, 0x9b, 0x4a, 0xe4, 0x3a, 0xc7, 0xa3, 0x36, 0x57, 0xc8, 0x85, 0x6d, 0x7b, 0xd7, 0x66, 0xb3,
+ 0xc3, 0xe0, 0x28, 0xf0, 0x09, 0x31, 0x89, 0x37, 0x41, 0x30, 0xf6, 0xd4, 0xc0, 0x75, 0x06, 0x87,
+ 0x7e, 0x09, 0x99, 0x7e, 0x5e, 0x45, 0x7b, 0x5e, 0x5a, 0x3e, 0xf3, 0x66, 0x57, 0x8c, 0x34, 0xbb,
+ 0x4d, 0x54, 0x50, 0xc2, 0xf3, 0x26, 0xf7, 0x8a, 0x1f, 0x83, 0x02, 0xbd, 0x79, 0x6c, 0x5b, 0xaf,
+ 0x8d, 0x46, 0x90, 0x21, 0xd7, 0x63, 0x90, 0xd3, 0xf8, 0x3d, 0x86, 0xbc, 0x83, 0x6e, 0xaa, 0x91,
+ 0x9b, 0xd5, 0x9a, 0xc0, 0xb1, 0x60, 0x85, 0xd7, 0x5a, 0x98, 0x20, 0x0a, 0x1a, 0x1b, 0xa5, 0x3d,
+ 0xde, 0x35, 0xf1, 0x30, 0x32, 0x9a, 0x92, 0x4d, 0x7f, 0xb0, 0x46, 0x6b, 0xd6, 0x0f, 0x07, 0x36,
+ 0xeb, 0xb8, 0xe8, 0xf5, 0x9a, 0xf4, 0x72, 0x90, 0x6f, 0x9c, 0xbe, 0xf8, 0x68, 0x84, 0xbe, 0x88,
+ 0xd1, 0x76, 0x2c, 0xbf, 0xec, 0x87, 0xb6, 0xdf, 0x69, 0x7e, 0x5d, 0x8f, 0xeb, 0x3e, 0x4b, 0xd1,
+ 0x2b, 0xbf, 0x8b, 0x4b, 0x94, 0x75, 0x31, 0x28, 0x11, 0xd4, 0x4d, 0x84, 0xcf, 0xa1, 0x0a, 0xa4,
+ 0x7b, 0xbd, 0x88, 0x42, 0x84, 0x62, 0x1c, 0xa1, 0xc0, 0x3b, 0x0c, 0x6e, 0x03, 0xad, 0xab, 0xe0,
+ 0x78, 0x63, 0x72, 0x21, 0xdb, 0x77, 0x42, 0x44, 0x31, 0xce, 0x8b, 0x65, 0xc5, 0x75, 0x52, 0xdc,
+ 0xc4, 0x32, 0xa1, 0x0b, 0x28, 0x23, 0x5e, 0x43, 0x2b, 0x21, 0x62, 0x11, 0xb9, 0x4f, 0x60, 0xb1,
+ 0xe7, 0x08, 0xff, 0xe9, 0xe1, 0xf7, 0x44, 0x75, 0x6b, 0xc5, 0x58, 0x9d, 0x16, 0x02, 0x91, 0xfb,
+ 0x52, 0x85, 0x1c, 0x6f, 0xb2, 0x7e, 0x25, 0xae, 0x52, 0x39, 0x05, 0xd5, 0x20, 0xde, 0x66, 0x14,
+ 0x05, 0xdc, 0x33, 0x3a, 0x20, 0x9a, 0x68, 0x9a, 0x73, 0xbb, 0xfd, 0xe8, 0x4a, 0xbb, 0xfd, 0xa0,
+ 0x11, 0xbb, 0x03, 0xa0, 0xdc, 0xee, 0x3a, 0xe4, 0x78, 0xb5, 0x4e, 0x66, 0xf7, 0x6d, 0x46, 0x71,
+ 0xb3, 0x30, 0x80, 0x82, 0x1a, 0xff, 0x12, 0x72, 0xbc, 0x53, 0xc6, 0xd9, 0x1f, 0xd7, 0x08, 0x84,
+ 0x0b, 0x7b, 0x83, 0x5c, 0xa8, 0xf2, 0x34, 0x0a, 0xfc, 0xad, 0x18, 0x9a, 0x46, 0xfe, 0xd5, 0x78,
+ 0x2b, 0x9c, 0x32, 0x01, 0x96, 0x83, 0xbf, 0x6e, 0x02, 0xe2, 0xd7, 0xf2, 0x73, 0xbb, 0xd6, 0x17,
+ 0x25, 0xbf, 0x50, 0xdd, 0xe9, 0x87, 0xde, 0xbc, 0x43, 0xf7, 0xfb, 0x15, 0x46, 0x9d, 0x41, 0xe9,
+ 0xfe, 0xbd, 0xa3, 0xa6, 0x9b, 0xa8, 0xce, 0x8e, 0x7e, 0xfe, 0x5f, 0x62, 0xb8, 0x33, 0xfe, 0xff,
+ 0x17, 0xf8, 0x2e, 0xad, 0x89, 0x05, 0xf9, 0xab, 0x23, 0x5c, 0xd4, 0x0c, 0xbe, 0x24, 0xfe, 0x6d,
+ 0x34, 0x20, 0xc5, 0x22, 0x27, 0xa5, 0x64, 0x1c, 0x51, 0x36, 0x24, 0x44, 0x5d, 0xbc, 0x4f, 0x49,
+ 0xa0, 0xaf, 0x58, 0xc3, 0x2a, 0x85, 0xd3, 0xf4, 0x34, 0xea, 0x6f, 0xb5, 0x6b, 0x91, 0x29, 0x3f,
+ 0x18, 0x20, 0x53, 0x6e, 0xa2, 0xad, 0x20, 0x79, 0x58, 0xac, 0xe8, 0x93, 0x89, 0x95, 0xbd, 0xe8,
+ 0x05, 0x5e, 0x81, 0xce, 0x33, 0xf1, 0xcb, 0x2b, 0x48, 0x96, 0x8f, 0x22, 0xa7, 0x78, 0xe0, 0x7e,
+ 0x1c, 0xc7, 0x29, 0xce, 0xf4, 0xaf, 0xb5, 0x89, 0x95, 0xcb, 0x93, 0x81, 0x87, 0xe1, 0x68, 0x46,
+ 0xf0, 0xa3, 0xf1, 0xf7, 0xdf, 0x8e, 0x7e, 0x51, 0x5c, 0xcd, 0x07, 0x1b, 0x42, 0x3b, 0xce, 0x9f,
+ 0xae, 0x43, 0xc5, 0xbc, 0x18, 0xe1, 0xb4, 0xbe, 0x87, 0x8a, 0x23, 0xda, 0x25, 0x4f, 0xa0, 0x3f,
+ 0x7f, 0xdb, 0x5a, 0xe6, 0x43, 0x66, 0xd8, 0x21, 0x1e, 0xd3, 0x30, 0x1a, 0xb6, 0xda, 0x84, 0x8a,
+ 0xe6, 0x7d, 0x85, 0xa2, 0xf1, 0xf5, 0x53, 0x6e, 0x80, 0xac, 0xc4, 0xa7, 0xa3, 0xea, 0x9a, 0xc8,
+ 0x01, 0x16, 0xc0, 0xe1, 0x35, 0x57, 0x1e, 0x53, 0xdd, 0x44, 0x4e, 0xda, 0x00, 0x26, 0x57, 0x75,
+ 0xe3, 0x6b, 0x9c, 0xbb, 0x0c, 0xf5, 0x16, 0xde, 0x89, 0xb7, 0x54, 0x2a, 0x9d, 0xea, 0x24, 0x4a,
+ 0x47, 0x5e, 0x88, 0xf1, 0x00, 0x7c, 0xa9, 0x77, 0x5e, 0x4d, 0xa0, 0x77, 0x46, 0xb1, 0x5f, 0xa8,
+ 0x9e, 0x57, 0x13, 0xa8, 0x1e, 0x01, 0xbf, 0x37, 0x08, 0x5e, 0x68, 0x9f, 0x8b, 0xb1, 0xb4, 0xcf,
+ 0xf7, 0x22, 0x5d, 0xd3, 0x77, 0x7b, 0x56, 0x90, 0xf0, 0x6e, 0x59, 0x9b, 0x48, 0x01, 0x89, 0xff,
+ 0x28, 0xe8, 0xf6, 0x20, 0xfc, 0xbe, 0x0e, 0xf2, 0xae, 0x41, 0x07, 0xdd, 0xe3, 0x3d, 0x18, 0x8f,
+ 0x46, 0x49, 0x93, 0xd7, 0x1d, 0x5f, 0x0d, 0x7d, 0x3c, 0xf0, 0x00, 0x18, 0x1c, 0xcf, 0x5e, 0xe3,
+ 0xbf, 0x82, 0x26, 0x3a, 0x1f, 0xa1, 0xcb, 0xee, 0xa2, 0x3b, 0x43, 0xac, 0x90, 0xdd, 0xb5, 0x7d,
+ 0x45, 0x65, 0xf4, 0x41, 0x9c, 0x32, 0x8a, 0x69, 0x43, 0x42, 0x1f, 0xfd, 0x6c, 0x5c, 0x7d, 0x14,
+ 0xd1, 0xd3, 0x51, 0x50, 0xde, 0xe0, 0xba, 0x57, 0x56, 0x49, 0xdf, 0x8f, 0x55, 0x49, 0x5b, 0x68,
+ 0x43, 0x49, 0x2f, 0x62, 0xf9, 0x72, 0x7c, 0xad, 0xb4, 0x3b, 0x28, 0x69, 0x02, 0x8a, 0xe9, 0x11,
+ 0x64, 0x9f, 0x7b, 0x0e, 0xd1, 0x9b, 0x65, 0xbd, 0xf6, 0x39, 0xf1, 0xdc, 0x67, 0x6d, 0x0f, 0xad,
+ 0x06, 0x72, 0x84, 0x4f, 0x3c, 0x6b, 0x7b, 0xb1, 0xf5, 0x71, 0x63, 0x57, 0x43, 0xa7, 0x90, 0xad,
+ 0x90, 0x1a, 0x31, 0x3a, 0x44, 0x00, 0x9d, 0x59, 0xb1, 0xf1, 0x59, 0x51, 0xe0, 0x9f, 0x59, 0xf8,
+ 0xc6, 0x3d, 0x0d, 0x3d, 0x85, 0x25, 0x01, 0x73, 0x7c, 0xa9, 0x5b, 0x0d, 0x72, 0xda, 0x21, 0x96,
+ 0x17, 0x1f, 0xe9, 0x7c, 0x00, 0xc9, 0xb7, 0x85, 0x81, 0x91, 0xab, 0xa9, 0xc1, 0x3b, 0x2c, 0x88,
+ 0xdb, 0x38, 0xf4, 0x71, 0x22, 0x9a, 0xf0, 0xe5, 0xf8, 0x9a, 0x30, 0xe6, 0xfb, 0x28, 0x64, 0xd5,
+ 0xaf, 0xae, 0xa6, 0x0c, 0xdf, 0x67, 0x44, 0xb7, 0x0b, 0x43, 0x89, 0xa8, 0x23, 0xfa, 0xa4, 0xfa,
+ 0x50, 0xb8, 0xb3, 0x37, 0xdc, 0x1d, 0x72, 0x65, 0x95, 0x78, 0x4b, 0x5d, 0x32, 0x01, 0xae, 0xa3,
+ 0x8f, 0x60, 0xc9, 0x76, 0x1a, 0x2c, 0x39, 0x6a, 0xb6, 0x53, 0x17, 0x40, 0x47, 0x29, 0x2e, 0xfb,
+ 0xca, 0x94, 0xc7, 0xfd, 0xdb, 0xd4, 0xea, 0x33, 0x39, 0xff, 0xa9, 0x5f, 0x15, 0x96, 0x67, 0xca,
+ 0xb3, 0xe5, 0xb9, 0xf2, 0x7c, 0x79, 0xa1, 0x9c, 0x28, 0xc3, 0xc5, 0x1c, 0x33, 0xeb, 0xf0, 0xff,
+ 0x01, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x33, 0xad, 0xd7, 0x94, 0x22, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/yang_options/yang_options.pb.go b/netopeer/voltha-grpc-client/voltha/yang_options/yang_options.pb.go
new file mode 100644
index 0000000..4876a98
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/yang_options/yang_options.pb.go
@@ -0,0 +1,193 @@
+// Code generated by protoc-gen-go.
+// source: yang_options.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+ yang_options.proto
+
+It has these top-level messages:
+ InlineNode
+ RpcReturnDef
+*/
+package yang_options
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type MessageParserOption int32
+
+const (
+ // Move any enclosing child enum/message definition to the same level
+ // as the parent (this message) in the yang generated file
+ MessageParserOption_MOVE_TO_PARENT_LEVEL MessageParserOption = 0
+ // Create both a grouping and a container for this message. The container
+ // name will be the message name. The grouping name will be the message
+ // name prefixed with "grouping_"
+ MessageParserOption_CREATE_BOTH_GROUPING_AND_CONTAINER MessageParserOption = 1
+)
+
+var MessageParserOption_name = map[int32]string{
+ 0: "MOVE_TO_PARENT_LEVEL",
+ 1: "CREATE_BOTH_GROUPING_AND_CONTAINER",
+}
+var MessageParserOption_value = map[string]int32{
+ "MOVE_TO_PARENT_LEVEL": 0,
+ "CREATE_BOTH_GROUPING_AND_CONTAINER": 1,
+}
+
+func (x MessageParserOption) String() string {
+ return proto.EnumName(MessageParserOption_name, int32(x))
+}
+func (MessageParserOption) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type InlineNode struct {
+ Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+ Type string `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
+}
+
+func (m *InlineNode) Reset() { *m = InlineNode{} }
+func (m *InlineNode) String() string { return proto.CompactTextString(m) }
+func (*InlineNode) ProtoMessage() {}
+func (*InlineNode) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *InlineNode) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *InlineNode) GetType() string {
+ if m != nil {
+ return m.Type
+ }
+ return ""
+}
+
+type RpcReturnDef struct {
+ // The gRPC methods return message types. NETCONF expects an actual
+ // attribute as defined in the YANG schema. The xnl_tag will be used
+ // as the top most tag when translating a gRPC response into an xml
+ // response
+ XmlTag string `protobuf:"bytes,1,opt,name=xml_tag,json=xmlTag" json:"xml_tag,omitempty"`
+ // When the gRPC response is a list of items, we need to differentiate
+ // between a YANG schema attribute whose name is "items" and when "items"
+ // is used only to indicate a list of items is being returned. The default
+ // behavior assumes a list is returned when "items" is present in
+ // the response. This option will therefore be used when the attribute
+ // name in the YANG schema is 'items'
+ ListItemsName string `protobuf:"bytes,2,opt,name=list_items_name,json=listItemsName" json:"list_items_name,omitempty"`
+}
+
+func (m *RpcReturnDef) Reset() { *m = RpcReturnDef{} }
+func (m *RpcReturnDef) String() string { return proto.CompactTextString(m) }
+func (*RpcReturnDef) ProtoMessage() {}
+func (*RpcReturnDef) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *RpcReturnDef) GetXmlTag() string {
+ if m != nil {
+ return m.XmlTag
+ }
+ return ""
+}
+
+func (m *RpcReturnDef) GetListItemsName() string {
+ if m != nil {
+ return m.ListItemsName
+ }
+ return ""
+}
+
+var E_YangChildRule = &proto.ExtensionDesc{
+ ExtendedType: (*google_protobuf.MessageOptions)(nil),
+ ExtensionType: (*MessageParserOption)(nil),
+ Field: 7761774,
+ Name: "voltha.yang_child_rule",
+ Tag: "varint,7761774,opt,name=yang_child_rule,json=yangChildRule,enum=voltha.MessageParserOption",
+ Filename: "yang_options.proto",
+}
+
+var E_YangMessageRule = &proto.ExtensionDesc{
+ ExtendedType: (*google_protobuf.MessageOptions)(nil),
+ ExtensionType: (*MessageParserOption)(nil),
+ Field: 7761775,
+ Name: "voltha.yang_message_rule",
+ Tag: "varint,7761775,opt,name=yang_message_rule,json=yangMessageRule,enum=voltha.MessageParserOption",
+ Filename: "yang_options.proto",
+}
+
+var E_YangInlineNode = &proto.ExtensionDesc{
+ ExtendedType: (*google_protobuf.FieldOptions)(nil),
+ ExtensionType: (*InlineNode)(nil),
+ Field: 7761776,
+ Name: "voltha.yang_inline_node",
+ Tag: "bytes,7761776,opt,name=yang_inline_node,json=yangInlineNode",
+ Filename: "yang_options.proto",
+}
+
+var E_YangXmlTag = &proto.ExtensionDesc{
+ ExtendedType: (*google_protobuf.MethodOptions)(nil),
+ ExtensionType: (*RpcReturnDef)(nil),
+ Field: 7761777,
+ Name: "voltha.yang_xml_tag",
+ Tag: "bytes,7761777,opt,name=yang_xml_tag,json=yangXmlTag",
+ Filename: "yang_options.proto",
+}
+
+func init() {
+ proto.RegisterType((*InlineNode)(nil), "voltha.InlineNode")
+ proto.RegisterType((*RpcReturnDef)(nil), "voltha.RpcReturnDef")
+ proto.RegisterEnum("voltha.MessageParserOption", MessageParserOption_name, MessageParserOption_value)
+ proto.RegisterExtension(E_YangChildRule)
+ proto.RegisterExtension(E_YangMessageRule)
+ proto.RegisterExtension(E_YangInlineNode)
+ proto.RegisterExtension(E_YangXmlTag)
+}
+
+func init() { proto.RegisterFile("yang_options.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+ // 416 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xcf, 0x8e, 0xd3, 0x30,
+ 0x10, 0x87, 0x49, 0x41, 0x45, 0x0c, 0xbb, 0xdd, 0x62, 0x56, 0x22, 0x02, 0x01, 0x55, 0x0f, 0xab,
+ 0x15, 0x87, 0x2c, 0x5a, 0x6e, 0xbd, 0x85, 0x6e, 0x28, 0x91, 0xda, 0xa4, 0xb2, 0x42, 0x81, 0x0b,
+ 0x96, 0xdb, 0xb8, 0xa9, 0x85, 0x13, 0x47, 0xb1, 0x83, 0xda, 0x47, 0xe5, 0xc2, 0x23, 0xf0, 0xe7,
+ 0x0d, 0x50, 0x9c, 0x84, 0x22, 0x6d, 0x0f, 0xbd, 0x25, 0x13, 0xe7, 0xfb, 0x3c, 0xf3, 0x1b, 0x40,
+ 0x3b, 0x9a, 0x25, 0x44, 0xe6, 0x9a, 0xcb, 0x4c, 0x39, 0x79, 0x21, 0xb5, 0x44, 0xdd, 0x6f, 0x52,
+ 0xe8, 0x0d, 0x7d, 0x3a, 0x48, 0xa4, 0x4c, 0x04, 0xbb, 0x32, 0xd5, 0x65, 0xb9, 0xbe, 0x8a, 0x99,
+ 0x5a, 0x15, 0x3c, 0xd7, 0xb2, 0xa8, 0x4f, 0x0e, 0x5f, 0x03, 0xf8, 0x99, 0xe0, 0x19, 0x0b, 0x64,
+ 0xcc, 0x50, 0x0f, 0x3a, 0x3c, 0xb6, 0xad, 0x81, 0x75, 0xf9, 0x00, 0x77, 0x78, 0x8c, 0x10, 0xdc,
+ 0xd3, 0xbb, 0x9c, 0xd9, 0x1d, 0x53, 0x31, 0xcf, 0xc3, 0x10, 0x4e, 0x70, 0xbe, 0xc2, 0x4c, 0x97,
+ 0x45, 0x76, 0xc3, 0xd6, 0xe8, 0x09, 0xdc, 0xdf, 0xa6, 0x82, 0x68, 0x9a, 0x34, 0x3f, 0x76, 0xb7,
+ 0xa9, 0x88, 0x68, 0x82, 0x2e, 0xe0, 0x4c, 0x70, 0xa5, 0x09, 0xd7, 0x2c, 0x55, 0x24, 0xa3, 0x69,
+ 0xcb, 0x39, 0xad, 0xca, 0x7e, 0x55, 0x0d, 0x68, 0xca, 0x5e, 0x7d, 0x84, 0xc7, 0x33, 0xa6, 0x14,
+ 0x4d, 0xd8, 0x9c, 0x16, 0x8a, 0x15, 0xa1, 0x69, 0x05, 0xd9, 0x70, 0x3e, 0x0b, 0x17, 0x1e, 0x89,
+ 0x42, 0x32, 0x77, 0xb1, 0x17, 0x44, 0x64, 0xea, 0x2d, 0xbc, 0x69, 0xff, 0x0e, 0xba, 0x80, 0xe1,
+ 0x18, 0x7b, 0x6e, 0xe4, 0x91, 0xb7, 0x61, 0xf4, 0x9e, 0x4c, 0x70, 0xf8, 0x61, 0xee, 0x07, 0x13,
+ 0xe2, 0x06, 0x37, 0x64, 0x1c, 0x06, 0x91, 0xeb, 0x07, 0x1e, 0xee, 0x5b, 0xa3, 0x04, 0xce, 0xcc,
+ 0x6c, 0x56, 0x1b, 0x2e, 0x62, 0x52, 0x94, 0x82, 0xa1, 0x97, 0x4e, 0x3d, 0x11, 0xa7, 0x9d, 0x88,
+ 0xd3, 0xa8, 0x6b, 0xa9, 0xb2, 0x7f, 0xfe, 0xf8, 0x7e, 0x77, 0x60, 0x5d, 0xf6, 0xae, 0x9f, 0x39,
+ 0xf5, 0x0c, 0x9d, 0x03, 0x77, 0xc3, 0xa7, 0x15, 0x77, 0x5c, 0x61, 0x71, 0x29, 0xd8, 0xe8, 0x2b,
+ 0x3c, 0x32, 0xa2, 0xb4, 0x3e, 0x7a, 0xa4, 0xea, 0xd7, 0x51, 0x2a, 0xd3, 0x42, 0xf3, 0xc1, 0xc8,
+ 0xbe, 0x40, 0xdf, 0xc8, 0xb8, 0x89, 0x8d, 0x64, 0x55, 0x6e, 0xcf, 0x6f, 0xb9, 0xde, 0x71, 0x26,
+ 0xe2, 0xd6, 0xf4, 0xbb, 0x36, 0x3d, 0xbc, 0x46, 0xad, 0x69, 0x9f, 0x39, 0xee, 0x55, 0xb4, 0xfd,
+ 0xfb, 0xe8, 0x33, 0x9c, 0x18, 0x7e, 0x13, 0x2a, 0x7a, 0x71, 0xa0, 0x0f, 0xbd, 0x91, 0xff, 0xe0,
+ 0x7f, 0x5a, 0xf8, 0x79, 0x0b, 0xff, 0x7f, 0x3d, 0x30, 0x54, 0xb0, 0x4f, 0x66, 0x23, 0x96, 0x5d,
+ 0x83, 0x78, 0xf3, 0x37, 0x00, 0x00, 0xff, 0xff, 0x4e, 0x8b, 0xcb, 0x68, 0xb3, 0x02, 0x00, 0x00,
+}