telegraf/plugins/inputs/jti_openconfig_telemetry/oc/oc.pb.go

1304 lines
48 KiB
Go
Raw Normal View History

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: oc.proto
/*
Package telemetry is a generated protocol buffer package.
It is generated from these files:
oc.proto
It has these top-level messages:
SubscriptionRequest
SubscriptionInput
Collector
Path
SubscriptionAdditionalConfig
SubscriptionReply
SubscriptionResponse
OpenConfigData
KeyValue
Delete
Eom
CancelSubscriptionRequest
CancelSubscriptionReply
GetSubscriptionsRequest
GetSubscriptionsReply
GetOperationalStateRequest
GetOperationalStateReply
DataEncodingRequest
DataEncodingReply
*/
package telemetry
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
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
// Result of the operation
type ReturnCode int32
const (
ReturnCode_SUCCESS ReturnCode = 0
ReturnCode_NO_SUBSCRIPTION_ENTRY ReturnCode = 1
ReturnCode_UNKNOWN_ERROR ReturnCode = 2
)
var ReturnCode_name = map[int32]string{
0: "SUCCESS",
1: "NO_SUBSCRIPTION_ENTRY",
2: "UNKNOWN_ERROR",
}
var ReturnCode_value = map[string]int32{
"SUCCESS": 0,
"NO_SUBSCRIPTION_ENTRY": 1,
"UNKNOWN_ERROR": 2,
}
func (x ReturnCode) String() string {
return proto.EnumName(ReturnCode_name, int32(x))
}
func (ReturnCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
// Verbosity Level
type VerbosityLevel int32
const (
VerbosityLevel_DETAIL VerbosityLevel = 0
VerbosityLevel_TERSE VerbosityLevel = 1
VerbosityLevel_BRIEF VerbosityLevel = 2
)
var VerbosityLevel_name = map[int32]string{
0: "DETAIL",
1: "TERSE",
2: "BRIEF",
}
var VerbosityLevel_value = map[string]int32{
"DETAIL": 0,
"TERSE": 1,
"BRIEF": 2,
}
func (x VerbosityLevel) String() string {
return proto.EnumName(VerbosityLevel_name, int32(x))
}
func (VerbosityLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
// Encoding Type Supported
type EncodingType int32
const (
EncodingType_UNDEFINED EncodingType = 0
EncodingType_XML EncodingType = 1
EncodingType_JSON_IETF EncodingType = 2
EncodingType_PROTO3 EncodingType = 3
)
var EncodingType_name = map[int32]string{
0: "UNDEFINED",
1: "XML",
2: "JSON_IETF",
3: "PROTO3",
}
var EncodingType_value = map[string]int32{
"UNDEFINED": 0,
"XML": 1,
"JSON_IETF": 2,
"PROTO3": 3,
}
func (x EncodingType) String() string {
return proto.EnumName(EncodingType_name, int32(x))
}
func (EncodingType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
// Message sent for a telemetry subscription request
type SubscriptionRequest struct {
// Data associated with a telemetry subscription
Input *SubscriptionInput `protobuf:"bytes,1,opt,name=input" json:"input,omitempty"`
// List of data models paths and filters
// which are used in a telemetry operation.
PathList []*Path `protobuf:"bytes,2,rep,name=path_list,json=pathList" json:"path_list,omitempty"`
// The below configuration is not defined in Openconfig RPC.
// It is a proposed extension to configure additional
// subscription request features.
AdditionalConfig *SubscriptionAdditionalConfig `protobuf:"bytes,3,opt,name=additional_config,json=additionalConfig" json:"additional_config,omitempty"`
}
func (m *SubscriptionRequest) Reset() { *m = SubscriptionRequest{} }
func (m *SubscriptionRequest) String() string { return proto.CompactTextString(m) }
func (*SubscriptionRequest) ProtoMessage() {}
func (*SubscriptionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *SubscriptionRequest) GetInput() *SubscriptionInput {
if m != nil {
return m.Input
}
return nil
}
func (m *SubscriptionRequest) GetPathList() []*Path {
if m != nil {
return m.PathList
}
return nil
}
func (m *SubscriptionRequest) GetAdditionalConfig() *SubscriptionAdditionalConfig {
if m != nil {
return m.AdditionalConfig
}
return nil
}
// Data associated with a telemetry subscription
type SubscriptionInput struct {
// List of optional collector endpoints to send data for
// this subscription.
// If no collector destinations are specified, the collector
// destination is assumed to be the requester on the rpc channel.
CollectorList []*Collector `protobuf:"bytes,1,rep,name=collector_list,json=collectorList" json:"collector_list,omitempty"`
}
func (m *SubscriptionInput) Reset() { *m = SubscriptionInput{} }
func (m *SubscriptionInput) String() string { return proto.CompactTextString(m) }
func (*SubscriptionInput) ProtoMessage() {}
func (*SubscriptionInput) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *SubscriptionInput) GetCollectorList() []*Collector {
if m != nil {
return m.CollectorList
}
return nil
}
// Collector endpoints to send data specified as an ip+port combination.
type Collector struct {
// IP address of collector endpoint
Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
// Transport protocol port number for the collector destination.
Port uint32 `protobuf:"varint,2,opt,name=port" json:"port,omitempty"`
}
func (m *Collector) Reset() { *m = Collector{} }
func (m *Collector) String() string { return proto.CompactTextString(m) }
func (*Collector) ProtoMessage() {}
func (*Collector) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *Collector) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func (m *Collector) GetPort() uint32 {
if m != nil {
return m.Port
}
return 0
}
// Data model path
type Path struct {
// Data model path of interest
// Path specification for elements of OpenConfig data models
Path string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
// Regular expression to be used in filtering state leaves
Filter string `protobuf:"bytes,2,opt,name=filter" json:"filter,omitempty"`
// If this is set to true, the target device will only send
// updates to the collector upon a change in data value
SuppressUnchanged bool `protobuf:"varint,3,opt,name=suppress_unchanged,json=suppressUnchanged" json:"suppress_unchanged,omitempty"`
// Maximum time in ms the target device may go without sending
// a message to the collector. If this time expires with
// suppress-unchanged set, the target device must send an update
// message regardless if the data values have changed.
MaxSilentInterval uint32 `protobuf:"varint,4,opt,name=max_silent_interval,json=maxSilentInterval" json:"max_silent_interval,omitempty"`
// Time in ms between collection and transmission of the
// specified data to the collector platform. The target device
// will sample the corresponding data (e.g,. a counter) and
// immediately send to the collector destination.
//
// If sample-frequency is set to 0, then the network device
// must emit an update upon every datum change.
SampleFrequency uint32 `protobuf:"varint,5,opt,name=sample_frequency,json=sampleFrequency" json:"sample_frequency,omitempty"`
// EOM needed for each walk cycle of this path?
// For periodic sensor, applicable for each complete reap
// For event sensor, applicable when initial dump is over
// (same as EOS)
// This feature is not implemented currently.
NeedEom bool `protobuf:"varint,6,opt,name=need_eom,json=needEom" json:"need_eom,omitempty"`
}
func (m *Path) Reset() { *m = Path{} }
func (m *Path) String() string { return proto.CompactTextString(m) }
func (*Path) ProtoMessage() {}
func (*Path) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *Path) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func (m *Path) GetFilter() string {
if m != nil {
return m.Filter
}
return ""
}
func (m *Path) GetSuppressUnchanged() bool {
if m != nil {
return m.SuppressUnchanged
}
return false
}
func (m *Path) GetMaxSilentInterval() uint32 {
if m != nil {
return m.MaxSilentInterval
}
return 0
}
func (m *Path) GetSampleFrequency() uint32 {
if m != nil {
return m.SampleFrequency
}
return 0
}
func (m *Path) GetNeedEom() bool {
if m != nil {
return m.NeedEom
}
return false
}
// Configure subscription request additional features.
type SubscriptionAdditionalConfig struct {
// limit the number of records sent in the stream
LimitRecords int32 `protobuf:"varint,1,opt,name=limit_records,json=limitRecords" json:"limit_records,omitempty"`
// limit the time the stream remains open
LimitTimeSeconds int32 `protobuf:"varint,2,opt,name=limit_time_seconds,json=limitTimeSeconds" json:"limit_time_seconds,omitempty"`
// EOS needed for this subscription?
NeedEos bool `protobuf:"varint,3,opt,name=need_eos,json=needEos" json:"need_eos,omitempty"`
}
func (m *SubscriptionAdditionalConfig) Reset() { *m = SubscriptionAdditionalConfig{} }
func (m *SubscriptionAdditionalConfig) String() string { return proto.CompactTextString(m) }
func (*SubscriptionAdditionalConfig) ProtoMessage() {}
func (*SubscriptionAdditionalConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
func (m *SubscriptionAdditionalConfig) GetLimitRecords() int32 {
if m != nil {
return m.LimitRecords
}
return 0
}
func (m *SubscriptionAdditionalConfig) GetLimitTimeSeconds() int32 {
if m != nil {
return m.LimitTimeSeconds
}
return 0
}
func (m *SubscriptionAdditionalConfig) GetNeedEos() bool {
if m != nil {
return m.NeedEos
}
return false
}
// 1. Reply data message sent out using out-of-band channel.
type SubscriptionReply struct {
// Response message to a telemetry subscription creation or
// get request.
Response *SubscriptionResponse `protobuf:"bytes,1,opt,name=response" json:"response,omitempty"`
// List of data models paths and filters
// which are used in a telemetry operation.
PathList []*Path `protobuf:"bytes,2,rep,name=path_list,json=pathList" json:"path_list,omitempty"`
}
func (m *SubscriptionReply) Reset() { *m = SubscriptionReply{} }
func (m *SubscriptionReply) String() string { return proto.CompactTextString(m) }
func (*SubscriptionReply) ProtoMessage() {}
func (*SubscriptionReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
func (m *SubscriptionReply) GetResponse() *SubscriptionResponse {
if m != nil {
return m.Response
}
return nil
}
func (m *SubscriptionReply) GetPathList() []*Path {
if m != nil {
return m.PathList
}
return nil
}
// Response message to a telemetry subscription creation or get request.
type SubscriptionResponse struct {
// Unique id for the subscription on the device. This is
// generated by the device and returned in a subscription
// request or when listing existing subscriptions
SubscriptionId uint32 `protobuf:"varint,1,opt,name=subscription_id,json=subscriptionId" json:"subscription_id,omitempty"`
}
func (m *SubscriptionResponse) Reset() { *m = SubscriptionResponse{} }
func (m *SubscriptionResponse) String() string { return proto.CompactTextString(m) }
func (*SubscriptionResponse) ProtoMessage() {}
func (*SubscriptionResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
func (m *SubscriptionResponse) GetSubscriptionId() uint32 {
if m != nil {
return m.SubscriptionId
}
return 0
}
// 2. Telemetry data send back on the same connection as the
// subscription request.
type OpenConfigData struct {
// router name:export IP address
SystemId string `protobuf:"bytes,1,opt,name=system_id,json=systemId" json:"system_id,omitempty"`
// line card / RE (slot number)
ComponentId uint32 `protobuf:"varint,2,opt,name=component_id,json=componentId" json:"component_id,omitempty"`
// PFE (if applicable)
SubComponentId uint32 `protobuf:"varint,3,opt,name=sub_component_id,json=subComponentId" json:"sub_component_id,omitempty"`
// Path specification for elements of OpenConfig data models
Path string `protobuf:"bytes,4,opt,name=path" json:"path,omitempty"`
// Sequence number, monotonically increasing for each
// system_id, component_id, sub_component_id + path.
SequenceNumber uint64 `protobuf:"varint,5,opt,name=sequence_number,json=sequenceNumber" json:"sequence_number,omitempty"`
// timestamp (milliseconds since epoch)
Timestamp uint64 `protobuf:"varint,6,opt,name=timestamp" json:"timestamp,omitempty"`
// List of key-value pairs
Kv []*KeyValue `protobuf:"bytes,7,rep,name=kv" json:"kv,omitempty"`
// For delete. If filled, it indicates delete
Delete []*Delete `protobuf:"bytes,8,rep,name=delete" json:"delete,omitempty"`
// If filled, it indicates end of marker for the
// respective path in the list.
Eom []*Eom `protobuf:"bytes,9,rep,name=eom" json:"eom,omitempty"`
// If filled, it indicates end of sync for complete subscription
SyncResponse bool `protobuf:"varint,10,opt,name=sync_response,json=syncResponse" json:"sync_response,omitempty"`
}
func (m *OpenConfigData) Reset() { *m = OpenConfigData{} }
func (m *OpenConfigData) String() string { return proto.CompactTextString(m) }
func (*OpenConfigData) ProtoMessage() {}
func (*OpenConfigData) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
func (m *OpenConfigData) GetSystemId() string {
if m != nil {
return m.SystemId
}
return ""
}
func (m *OpenConfigData) GetComponentId() uint32 {
if m != nil {
return m.ComponentId
}
return 0
}
func (m *OpenConfigData) GetSubComponentId() uint32 {
if m != nil {
return m.SubComponentId
}
return 0
}
func (m *OpenConfigData) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func (m *OpenConfigData) GetSequenceNumber() uint64 {
if m != nil {
return m.SequenceNumber
}
return 0
}
func (m *OpenConfigData) GetTimestamp() uint64 {
if m != nil {
return m.Timestamp
}
return 0
}
func (m *OpenConfigData) GetKv() []*KeyValue {
if m != nil {
return m.Kv
}
return nil
}
func (m *OpenConfigData) GetDelete() []*Delete {
if m != nil {
return m.Delete
}
return nil
}
func (m *OpenConfigData) GetEom() []*Eom {
if m != nil {
return m.Eom
}
return nil
}
func (m *OpenConfigData) GetSyncResponse() bool {
if m != nil {
return m.SyncResponse
}
return false
}
// Simple Key-value, where value could be one of scalar types
type KeyValue struct {
// Key
Key string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
// One of possible values
//
// Types that are valid to be assigned to Value:
// *KeyValue_DoubleValue
// *KeyValue_IntValue
// *KeyValue_UintValue
// *KeyValue_SintValue
// *KeyValue_BoolValue
// *KeyValue_StrValue
// *KeyValue_BytesValue
Value isKeyValue_Value `protobuf_oneof:"value"`
}
func (m *KeyValue) Reset() { *m = KeyValue{} }
func (m *KeyValue) String() string { return proto.CompactTextString(m) }
func (*KeyValue) ProtoMessage() {}
func (*KeyValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
type isKeyValue_Value interface {
isKeyValue_Value()
}
type KeyValue_DoubleValue struct {
DoubleValue float64 `protobuf:"fixed64,5,opt,name=double_value,json=doubleValue,oneof"`
}
type KeyValue_IntValue struct {
IntValue int64 `protobuf:"varint,6,opt,name=int_value,json=intValue,oneof"`
}
type KeyValue_UintValue struct {
UintValue uint64 `protobuf:"varint,7,opt,name=uint_value,json=uintValue,oneof"`
}
type KeyValue_SintValue struct {
SintValue int64 `protobuf:"zigzag64,8,opt,name=sint_value,json=sintValue,oneof"`
}
type KeyValue_BoolValue struct {
BoolValue bool `protobuf:"varint,9,opt,name=bool_value,json=boolValue,oneof"`
}
type KeyValue_StrValue struct {
StrValue string `protobuf:"bytes,10,opt,name=str_value,json=strValue,oneof"`
}
type KeyValue_BytesValue struct {
BytesValue []byte `protobuf:"bytes,11,opt,name=bytes_value,json=bytesValue,proto3,oneof"`
}
func (*KeyValue_DoubleValue) isKeyValue_Value() {}
func (*KeyValue_IntValue) isKeyValue_Value() {}
func (*KeyValue_UintValue) isKeyValue_Value() {}
func (*KeyValue_SintValue) isKeyValue_Value() {}
func (*KeyValue_BoolValue) isKeyValue_Value() {}
func (*KeyValue_StrValue) isKeyValue_Value() {}
func (*KeyValue_BytesValue) isKeyValue_Value() {}
func (m *KeyValue) GetValue() isKeyValue_Value {
if m != nil {
return m.Value
}
return nil
}
func (m *KeyValue) GetKey() string {
if m != nil {
return m.Key
}
return ""
}
func (m *KeyValue) GetDoubleValue() float64 {
if x, ok := m.GetValue().(*KeyValue_DoubleValue); ok {
return x.DoubleValue
}
return 0
}
func (m *KeyValue) GetIntValue() int64 {
if x, ok := m.GetValue().(*KeyValue_IntValue); ok {
return x.IntValue
}
return 0
}
func (m *KeyValue) GetUintValue() uint64 {
if x, ok := m.GetValue().(*KeyValue_UintValue); ok {
return x.UintValue
}
return 0
}
func (m *KeyValue) GetSintValue() int64 {
if x, ok := m.GetValue().(*KeyValue_SintValue); ok {
return x.SintValue
}
return 0
}
func (m *KeyValue) GetBoolValue() bool {
if x, ok := m.GetValue().(*KeyValue_BoolValue); ok {
return x.BoolValue
}
return false
}
func (m *KeyValue) GetStrValue() string {
if x, ok := m.GetValue().(*KeyValue_StrValue); ok {
return x.StrValue
}
return ""
}
func (m *KeyValue) GetBytesValue() []byte {
if x, ok := m.GetValue().(*KeyValue_BytesValue); ok {
return x.BytesValue
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*KeyValue) 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 _KeyValue_OneofMarshaler, _KeyValue_OneofUnmarshaler, _KeyValue_OneofSizer, []interface{}{
(*KeyValue_DoubleValue)(nil),
(*KeyValue_IntValue)(nil),
(*KeyValue_UintValue)(nil),
(*KeyValue_SintValue)(nil),
(*KeyValue_BoolValue)(nil),
(*KeyValue_StrValue)(nil),
(*KeyValue_BytesValue)(nil),
}
}
func _KeyValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*KeyValue)
// value
switch x := m.Value.(type) {
case *KeyValue_DoubleValue:
b.EncodeVarint(5<<3 | proto.WireFixed64)
b.EncodeFixed64(math.Float64bits(x.DoubleValue))
case *KeyValue_IntValue:
b.EncodeVarint(6<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.IntValue))
case *KeyValue_UintValue:
b.EncodeVarint(7<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.UintValue))
case *KeyValue_SintValue:
b.EncodeVarint(8<<3 | proto.WireVarint)
b.EncodeZigzag64(uint64(x.SintValue))
case *KeyValue_BoolValue:
t := uint64(0)
if x.BoolValue {
t = 1
}
b.EncodeVarint(9<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *KeyValue_StrValue:
b.EncodeVarint(10<<3 | proto.WireBytes)
b.EncodeStringBytes(x.StrValue)
case *KeyValue_BytesValue:
b.EncodeVarint(11<<3 | proto.WireBytes)
b.EncodeRawBytes(x.BytesValue)
case nil:
default:
return fmt.Errorf("KeyValue.Value has unexpected type %T", x)
}
return nil
}
func _KeyValue_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*KeyValue)
switch tag {
case 5: // value.double_value
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.Value = &KeyValue_DoubleValue{math.Float64frombits(x)}
return true, err
case 6: // value.int_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &KeyValue_IntValue{int64(x)}
return true, err
case 7: // value.uint_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &KeyValue_UintValue{x}
return true, err
case 8: // value.sint_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeZigzag64()
m.Value = &KeyValue_SintValue{int64(x)}
return true, err
case 9: // value.bool_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &KeyValue_BoolValue{x != 0}
return true, err
case 10: // value.str_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Value = &KeyValue_StrValue{x}
return true, err
case 11: // value.bytes_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeRawBytes(true)
m.Value = &KeyValue_BytesValue{x}
return true, err
default:
return false, nil
}
}
func _KeyValue_OneofSizer(msg proto.Message) (n int) {
m := msg.(*KeyValue)
// value
switch x := m.Value.(type) {
case *KeyValue_DoubleValue:
n += proto.SizeVarint(5<<3 | proto.WireFixed64)
n += 8
case *KeyValue_IntValue:
n += proto.SizeVarint(6<<3 | proto.WireVarint)
n += proto.SizeVarint(uint64(x.IntValue))
case *KeyValue_UintValue:
n += proto.SizeVarint(7<<3 | proto.WireVarint)
n += proto.SizeVarint(uint64(x.UintValue))
case *KeyValue_SintValue:
n += proto.SizeVarint(8<<3 | proto.WireVarint)
n += proto.SizeVarint(uint64(uint64(x.SintValue<<1) ^ uint64((int64(x.SintValue) >> 63))))
case *KeyValue_BoolValue:
n += proto.SizeVarint(9<<3 | proto.WireVarint)
n += 1
case *KeyValue_StrValue:
n += proto.SizeVarint(10<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.StrValue)))
n += len(x.StrValue)
case *KeyValue_BytesValue:
n += proto.SizeVarint(11<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.BytesValue)))
n += len(x.BytesValue)
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// Message indicating delete for a particular path
type Delete struct {
Path string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
}
func (m *Delete) Reset() { *m = Delete{} }
func (m *Delete) String() string { return proto.CompactTextString(m) }
func (*Delete) ProtoMessage() {}
func (*Delete) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
func (m *Delete) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
// Message indicating EOM for a particular path
type Eom struct {
Path string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
}
func (m *Eom) Reset() { *m = Eom{} }
func (m *Eom) String() string { return proto.CompactTextString(m) }
func (*Eom) ProtoMessage() {}
func (*Eom) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
func (m *Eom) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
// Message sent for a telemetry subscription cancellation request
type CancelSubscriptionRequest struct {
// Subscription identifier as returned by the device when
// subscription was requested
SubscriptionId uint32 `protobuf:"varint,1,opt,name=subscription_id,json=subscriptionId" json:"subscription_id,omitempty"`
}
func (m *CancelSubscriptionRequest) Reset() { *m = CancelSubscriptionRequest{} }
func (m *CancelSubscriptionRequest) String() string { return proto.CompactTextString(m) }
func (*CancelSubscriptionRequest) ProtoMessage() {}
func (*CancelSubscriptionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
func (m *CancelSubscriptionRequest) GetSubscriptionId() uint32 {
if m != nil {
return m.SubscriptionId
}
return 0
}
// Reply to telemetry subscription cancellation request
type CancelSubscriptionReply struct {
// Return code
Code ReturnCode `protobuf:"varint,1,opt,name=code,enum=telemetry.ReturnCode" json:"code,omitempty"`
// Return code string
CodeStr string `protobuf:"bytes,2,opt,name=code_str,json=codeStr" json:"code_str,omitempty"`
}
func (m *CancelSubscriptionReply) Reset() { *m = CancelSubscriptionReply{} }
func (m *CancelSubscriptionReply) String() string { return proto.CompactTextString(m) }
func (*CancelSubscriptionReply) ProtoMessage() {}
func (*CancelSubscriptionReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
func (m *CancelSubscriptionReply) GetCode() ReturnCode {
if m != nil {
return m.Code
}
return ReturnCode_SUCCESS
}
func (m *CancelSubscriptionReply) GetCodeStr() string {
if m != nil {
return m.CodeStr
}
return ""
}
// Message sent for a telemetry get request
type GetSubscriptionsRequest struct {
// Subscription identifier as returned by the device when
// subscription was requested
// --- or ---
// 0xFFFFFFFF for all subscription identifiers
SubscriptionId uint32 `protobuf:"varint,1,opt,name=subscription_id,json=subscriptionId" json:"subscription_id,omitempty"`
}
func (m *GetSubscriptionsRequest) Reset() { *m = GetSubscriptionsRequest{} }
func (m *GetSubscriptionsRequest) String() string { return proto.CompactTextString(m) }
func (*GetSubscriptionsRequest) ProtoMessage() {}
func (*GetSubscriptionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
func (m *GetSubscriptionsRequest) GetSubscriptionId() uint32 {
if m != nil {
return m.SubscriptionId
}
return 0
}
// Reply to telemetry subscription get request
type GetSubscriptionsReply struct {
// List of current telemetry subscriptions
SubscriptionList []*SubscriptionReply `protobuf:"bytes,1,rep,name=subscription_list,json=subscriptionList" json:"subscription_list,omitempty"`
}
func (m *GetSubscriptionsReply) Reset() { *m = GetSubscriptionsReply{} }
func (m *GetSubscriptionsReply) String() string { return proto.CompactTextString(m) }
func (*GetSubscriptionsReply) ProtoMessage() {}
func (*GetSubscriptionsReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
func (m *GetSubscriptionsReply) GetSubscriptionList() []*SubscriptionReply {
if m != nil {
return m.SubscriptionList
}
return nil
}
// Message sent for telemetry agent operational states request
type GetOperationalStateRequest struct {
// Per-subscription_id level operational state can be requested.
//
// Subscription identifier as returned by the device when
// subscription was requested
// --- or ---
// 0xFFFFFFFF for all subscription identifiers including agent-level
// operational stats
// --- or ---
// If subscription_id is not present then sent only agent-level
// operational stats
SubscriptionId uint32 `protobuf:"varint,1,opt,name=subscription_id,json=subscriptionId" json:"subscription_id,omitempty"`
// Control verbosity of the output
Verbosity VerbosityLevel `protobuf:"varint,2,opt,name=verbosity,enum=telemetry.VerbosityLevel" json:"verbosity,omitempty"`
}
func (m *GetOperationalStateRequest) Reset() { *m = GetOperationalStateRequest{} }
func (m *GetOperationalStateRequest) String() string { return proto.CompactTextString(m) }
func (*GetOperationalStateRequest) ProtoMessage() {}
func (*GetOperationalStateRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
func (m *GetOperationalStateRequest) GetSubscriptionId() uint32 {
if m != nil {
return m.SubscriptionId
}
return 0
}
func (m *GetOperationalStateRequest) GetVerbosity() VerbosityLevel {
if m != nil {
return m.Verbosity
}
return VerbosityLevel_DETAIL
}
// Reply to telemetry agent operational states request
type GetOperationalStateReply struct {
// List of key-value pairs where
// key = operational state definition
// value = operational state value
Kv []*KeyValue `protobuf:"bytes,1,rep,name=kv" json:"kv,omitempty"`
}
func (m *GetOperationalStateReply) Reset() { *m = GetOperationalStateReply{} }
func (m *GetOperationalStateReply) String() string { return proto.CompactTextString(m) }
func (*GetOperationalStateReply) ProtoMessage() {}
func (*GetOperationalStateReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
func (m *GetOperationalStateReply) GetKv() []*KeyValue {
if m != nil {
return m.Kv
}
return nil
}
// Message sent for a data encoding request
type DataEncodingRequest struct {
}
func (m *DataEncodingRequest) Reset() { *m = DataEncodingRequest{} }
func (m *DataEncodingRequest) String() string { return proto.CompactTextString(m) }
func (*DataEncodingRequest) ProtoMessage() {}
func (*DataEncodingRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
// Reply to data encodings supported request
type DataEncodingReply struct {
EncodingList []EncodingType `protobuf:"varint,1,rep,packed,name=encoding_list,json=encodingList,enum=telemetry.EncodingType" json:"encoding_list,omitempty"`
}
func (m *DataEncodingReply) Reset() { *m = DataEncodingReply{} }
func (m *DataEncodingReply) String() string { return proto.CompactTextString(m) }
func (*DataEncodingReply) ProtoMessage() {}
func (*DataEncodingReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
func (m *DataEncodingReply) GetEncodingList() []EncodingType {
if m != nil {
return m.EncodingList
}
return nil
}
func init() {
proto.RegisterType((*SubscriptionRequest)(nil), "telemetry.SubscriptionRequest")
proto.RegisterType((*SubscriptionInput)(nil), "telemetry.SubscriptionInput")
proto.RegisterType((*Collector)(nil), "telemetry.Collector")
proto.RegisterType((*Path)(nil), "telemetry.Path")
proto.RegisterType((*SubscriptionAdditionalConfig)(nil), "telemetry.SubscriptionAdditionalConfig")
proto.RegisterType((*SubscriptionReply)(nil), "telemetry.SubscriptionReply")
proto.RegisterType((*SubscriptionResponse)(nil), "telemetry.SubscriptionResponse")
proto.RegisterType((*OpenConfigData)(nil), "telemetry.OpenConfigData")
proto.RegisterType((*KeyValue)(nil), "telemetry.KeyValue")
proto.RegisterType((*Delete)(nil), "telemetry.Delete")
proto.RegisterType((*Eom)(nil), "telemetry.Eom")
proto.RegisterType((*CancelSubscriptionRequest)(nil), "telemetry.CancelSubscriptionRequest")
proto.RegisterType((*CancelSubscriptionReply)(nil), "telemetry.CancelSubscriptionReply")
proto.RegisterType((*GetSubscriptionsRequest)(nil), "telemetry.GetSubscriptionsRequest")
proto.RegisterType((*GetSubscriptionsReply)(nil), "telemetry.GetSubscriptionsReply")
proto.RegisterType((*GetOperationalStateRequest)(nil), "telemetry.GetOperationalStateRequest")
proto.RegisterType((*GetOperationalStateReply)(nil), "telemetry.GetOperationalStateReply")
proto.RegisterType((*DataEncodingRequest)(nil), "telemetry.DataEncodingRequest")
proto.RegisterType((*DataEncodingReply)(nil), "telemetry.DataEncodingReply")
proto.RegisterEnum("telemetry.ReturnCode", ReturnCode_name, ReturnCode_value)
proto.RegisterEnum("telemetry.VerbosityLevel", VerbosityLevel_name, VerbosityLevel_value)
proto.RegisterEnum("telemetry.EncodingType", EncodingType_name, EncodingType_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 OpenConfigTelemetry service
type OpenConfigTelemetryClient interface {
// Request an inline subscription for data at the specified path.
// The device should send telemetry data back on the same
// connection as the subscription request.
TelemetrySubscribe(ctx context.Context, in *SubscriptionRequest, opts ...grpc.CallOption) (OpenConfigTelemetry_TelemetrySubscribeClient, error)
// Terminates and removes an exisiting telemetry subscription
CancelTelemetrySubscription(ctx context.Context, in *CancelSubscriptionRequest, opts ...grpc.CallOption) (*CancelSubscriptionReply, error)
// Get the list of current telemetry subscriptions from the
// target. This command returns a list of existing subscriptions
// not including those that are established via configuration.
GetTelemetrySubscriptions(ctx context.Context, in *GetSubscriptionsRequest, opts ...grpc.CallOption) (*GetSubscriptionsReply, error)
// Get Telemetry Agent Operational States
GetTelemetryOperationalState(ctx context.Context, in *GetOperationalStateRequest, opts ...grpc.CallOption) (*GetOperationalStateReply, error)
// Return the set of data encodings supported by the device for
// telemetry data
GetDataEncodings(ctx context.Context, in *DataEncodingRequest, opts ...grpc.CallOption) (*DataEncodingReply, error)
}
type openConfigTelemetryClient struct {
cc *grpc.ClientConn
}
func NewOpenConfigTelemetryClient(cc *grpc.ClientConn) OpenConfigTelemetryClient {
return &openConfigTelemetryClient{cc}
}
func (c *openConfigTelemetryClient) TelemetrySubscribe(ctx context.Context, in *SubscriptionRequest, opts ...grpc.CallOption) (OpenConfigTelemetry_TelemetrySubscribeClient, error) {
stream, err := grpc.NewClientStream(ctx, &_OpenConfigTelemetry_serviceDesc.Streams[0], c.cc, "/telemetry.OpenConfigTelemetry/telemetrySubscribe", opts...)
if err != nil {
return nil, err
}
x := &openConfigTelemetryTelemetrySubscribeClient{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 OpenConfigTelemetry_TelemetrySubscribeClient interface {
Recv() (*OpenConfigData, error)
grpc.ClientStream
}
type openConfigTelemetryTelemetrySubscribeClient struct {
grpc.ClientStream
}
func (x *openConfigTelemetryTelemetrySubscribeClient) Recv() (*OpenConfigData, error) {
m := new(OpenConfigData)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *openConfigTelemetryClient) CancelTelemetrySubscription(ctx context.Context, in *CancelSubscriptionRequest, opts ...grpc.CallOption) (*CancelSubscriptionReply, error) {
out := new(CancelSubscriptionReply)
err := grpc.Invoke(ctx, "/telemetry.OpenConfigTelemetry/cancelTelemetrySubscription", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *openConfigTelemetryClient) GetTelemetrySubscriptions(ctx context.Context, in *GetSubscriptionsRequest, opts ...grpc.CallOption) (*GetSubscriptionsReply, error) {
out := new(GetSubscriptionsReply)
err := grpc.Invoke(ctx, "/telemetry.OpenConfigTelemetry/getTelemetrySubscriptions", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *openConfigTelemetryClient) GetTelemetryOperationalState(ctx context.Context, in *GetOperationalStateRequest, opts ...grpc.CallOption) (*GetOperationalStateReply, error) {
out := new(GetOperationalStateReply)
err := grpc.Invoke(ctx, "/telemetry.OpenConfigTelemetry/getTelemetryOperationalState", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *openConfigTelemetryClient) GetDataEncodings(ctx context.Context, in *DataEncodingRequest, opts ...grpc.CallOption) (*DataEncodingReply, error) {
out := new(DataEncodingReply)
err := grpc.Invoke(ctx, "/telemetry.OpenConfigTelemetry/getDataEncodings", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for OpenConfigTelemetry service
type OpenConfigTelemetryServer interface {
// Request an inline subscription for data at the specified path.
// The device should send telemetry data back on the same
// connection as the subscription request.
TelemetrySubscribe(*SubscriptionRequest, OpenConfigTelemetry_TelemetrySubscribeServer) error
// Terminates and removes an exisiting telemetry subscription
CancelTelemetrySubscription(context.Context, *CancelSubscriptionRequest) (*CancelSubscriptionReply, error)
// Get the list of current telemetry subscriptions from the
// target. This command returns a list of existing subscriptions
// not including those that are established via configuration.
GetTelemetrySubscriptions(context.Context, *GetSubscriptionsRequest) (*GetSubscriptionsReply, error)
// Get Telemetry Agent Operational States
GetTelemetryOperationalState(context.Context, *GetOperationalStateRequest) (*GetOperationalStateReply, error)
// Return the set of data encodings supported by the device for
// telemetry data
GetDataEncodings(context.Context, *DataEncodingRequest) (*DataEncodingReply, error)
}
func RegisterOpenConfigTelemetryServer(s *grpc.Server, srv OpenConfigTelemetryServer) {
s.RegisterService(&_OpenConfigTelemetry_serviceDesc, srv)
}
func _OpenConfigTelemetry_TelemetrySubscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(SubscriptionRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(OpenConfigTelemetryServer).TelemetrySubscribe(m, &openConfigTelemetryTelemetrySubscribeServer{stream})
}
type OpenConfigTelemetry_TelemetrySubscribeServer interface {
Send(*OpenConfigData) error
grpc.ServerStream
}
type openConfigTelemetryTelemetrySubscribeServer struct {
grpc.ServerStream
}
func (x *openConfigTelemetryTelemetrySubscribeServer) Send(m *OpenConfigData) error {
return x.ServerStream.SendMsg(m)
}
func _OpenConfigTelemetry_CancelTelemetrySubscription_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CancelSubscriptionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OpenConfigTelemetryServer).CancelTelemetrySubscription(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/telemetry.OpenConfigTelemetry/CancelTelemetrySubscription",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OpenConfigTelemetryServer).CancelTelemetrySubscription(ctx, req.(*CancelSubscriptionRequest))
}
return interceptor(ctx, in, info, handler)
}
func _OpenConfigTelemetry_GetTelemetrySubscriptions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetSubscriptionsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OpenConfigTelemetryServer).GetTelemetrySubscriptions(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/telemetry.OpenConfigTelemetry/GetTelemetrySubscriptions",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OpenConfigTelemetryServer).GetTelemetrySubscriptions(ctx, req.(*GetSubscriptionsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _OpenConfigTelemetry_GetTelemetryOperationalState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetOperationalStateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OpenConfigTelemetryServer).GetTelemetryOperationalState(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/telemetry.OpenConfigTelemetry/GetTelemetryOperationalState",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OpenConfigTelemetryServer).GetTelemetryOperationalState(ctx, req.(*GetOperationalStateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _OpenConfigTelemetry_GetDataEncodings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DataEncodingRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OpenConfigTelemetryServer).GetDataEncodings(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/telemetry.OpenConfigTelemetry/GetDataEncodings",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OpenConfigTelemetryServer).GetDataEncodings(ctx, req.(*DataEncodingRequest))
}
return interceptor(ctx, in, info, handler)
}
var _OpenConfigTelemetry_serviceDesc = grpc.ServiceDesc{
ServiceName: "telemetry.OpenConfigTelemetry",
HandlerType: (*OpenConfigTelemetryServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "cancelTelemetrySubscription",
Handler: _OpenConfigTelemetry_CancelTelemetrySubscription_Handler,
},
{
MethodName: "getTelemetrySubscriptions",
Handler: _OpenConfigTelemetry_GetTelemetrySubscriptions_Handler,
},
{
MethodName: "getTelemetryOperationalState",
Handler: _OpenConfigTelemetry_GetTelemetryOperationalState_Handler,
},
{
MethodName: "getDataEncodings",
Handler: _OpenConfigTelemetry_GetDataEncodings_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "telemetrySubscribe",
Handler: _OpenConfigTelemetry_TelemetrySubscribe_Handler,
ServerStreams: true,
},
},
Metadata: "oc.proto",
}
func init() { proto.RegisterFile("oc.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 1254 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0xcd, 0x6e, 0xdb, 0x46,
0x17, 0x15, 0x25, 0xd9, 0x12, 0xaf, 0x7e, 0x42, 0x8d, 0xe3, 0x2f, 0xb2, 0xa3, 0xaf, 0x71, 0xe8,
0x16, 0x71, 0x82, 0xd4, 0x28, 0x94, 0x45, 0x51, 0xa4, 0x40, 0x10, 0xcb, 0x74, 0xac, 0xc6, 0x95,
0xdc, 0xa1, 0x9c, 0xb6, 0x2b, 0x82, 0x22, 0x27, 0x36, 0x11, 0xfe, 0x95, 0x33, 0x12, 0xc2, 0x4d,
0x9e, 0xa0, 0xe8, 0x9b, 0x75, 0xdd, 0x97, 0xe8, 0x23, 0x74, 0x51, 0xcc, 0x90, 0x94, 0x46, 0x89,
0x94, 0x34, 0x2b, 0x91, 0xe7, 0x9e, 0xb9, 0xf7, 0xcc, 0xbd, 0x67, 0x86, 0x82, 0x7a, 0xe4, 0x1c,
0xc7, 0x49, 0xc4, 0x22, 0xa4, 0x32, 0xe2, 0x93, 0x80, 0xb0, 0x24, 0xd5, 0xff, 0x54, 0x60, 0xc7,
0x9c, 0x4d, 0xa9, 0x93, 0x78, 0x31, 0xf3, 0xa2, 0x10, 0x93, 0xdf, 0x66, 0x84, 0x32, 0xd4, 0x87,
0x2d, 0x2f, 0x8c, 0x67, 0xac, 0xab, 0x1c, 0x28, 0x47, 0x8d, 0x7e, 0xef, 0x78, 0xb1, 0xe4, 0x58,
0xa6, 0x0f, 0x39, 0x07, 0x67, 0x54, 0xf4, 0x18, 0xd4, 0xd8, 0x66, 0x37, 0x96, 0xef, 0x51, 0xd6,
0x2d, 0x1f, 0x54, 0x8e, 0x1a, 0xfd, 0x5b, 0xd2, 0xba, 0x4b, 0x9b, 0xdd, 0xe0, 0x3a, 0x67, 0x5c,
0x78, 0x94, 0xa1, 0x09, 0x74, 0x6c, 0xd7, 0xf5, 0x78, 0x16, 0xdb, 0xb7, 0x9c, 0x28, 0x7c, 0xed,
0x5d, 0x77, 0x2b, 0xa2, 0xda, 0x83, 0x0d, 0xd5, 0x9e, 0x2f, 0xf8, 0x03, 0x41, 0xc7, 0x9a, 0xfd,
0x1e, 0xa2, 0x5f, 0x42, 0xe7, 0x03, 0x7d, 0xe8, 0x29, 0xb4, 0x9d, 0xc8, 0xf7, 0x89, 0xc3, 0xa2,
0x24, 0x53, 0xa7, 0x08, 0x75, 0xb7, 0xa5, 0x3a, 0x83, 0x82, 0x80, 0x5b, 0x0b, 0x2e, 0xd7, 0xa9,
0x7f, 0x07, 0xea, 0x22, 0x86, 0xba, 0x50, 0xb3, 0x5d, 0x37, 0x21, 0x94, 0x8a, 0xc6, 0xa8, 0xb8,
0x78, 0x45, 0x08, 0xaa, 0x71, 0x94, 0xf0, 0x7d, 0x2b, 0x47, 0x2d, 0x2c, 0x9e, 0xf5, 0xbf, 0x14,
0xa8, 0xf2, 0x5d, 0x8b, 0xa0, 0xcd, 0x6e, 0xf2, 0x35, 0xe2, 0x19, 0xfd, 0x0f, 0xb6, 0x5f, 0x7b,
0x3e, 0x23, 0x89, 0x58, 0xa2, 0xe2, 0xfc, 0x0d, 0x7d, 0x0d, 0x88, 0xce, 0xe2, 0x98, 0x27, 0xb5,
0x66, 0xa1, 0x73, 0x63, 0x87, 0xd7, 0xc4, 0x15, 0x8d, 0xa9, 0xe3, 0x4e, 0x11, 0xb9, 0x2a, 0x02,
0xe8, 0x18, 0x76, 0x02, 0xfb, 0xad, 0x45, 0x3d, 0x9f, 0x84, 0xcc, 0xf2, 0x42, 0x46, 0x92, 0xb9,
0xed, 0x77, 0xab, 0x42, 0x46, 0x27, 0xb0, 0xdf, 0x9a, 0x22, 0x32, 0xcc, 0x03, 0xe8, 0x21, 0x68,
0xd4, 0x0e, 0x62, 0x9f, 0x58, 0xaf, 0x13, 0x3e, 0xeb, 0xd0, 0x49, 0xbb, 0x5b, 0x82, 0x7c, 0x2b,
0xc3, 0xcf, 0x0a, 0x18, 0xed, 0x41, 0x3d, 0x24, 0xc4, 0xb5, 0x48, 0x14, 0x74, 0xb7, 0x45, 0xfd,
0x1a, 0x7f, 0x37, 0xa2, 0x40, 0xff, 0x5d, 0x81, 0xde, 0xc7, 0x26, 0x83, 0x0e, 0xa1, 0xe5, 0x7b,
0x81, 0xc7, 0xac, 0x84, 0x38, 0x51, 0xe2, 0x66, 0xed, 0xda, 0xc2, 0x4d, 0x01, 0xe2, 0x0c, 0x43,
0x8f, 0x01, 0x65, 0x24, 0xe6, 0x05, 0xc4, 0xa2, 0xc4, 0x89, 0x42, 0x97, 0x8a, 0x76, 0x6c, 0x61,
0x4d, 0x44, 0x26, 0x5e, 0x40, 0xcc, 0x0c, 0x97, 0xe4, 0xd0, 0xbc, 0x1d, 0xb9, 0x1c, 0xaa, 0xbf,
0x5b, 0x9d, 0x3a, 0x26, 0xb1, 0x9f, 0xa2, 0xa7, 0x50, 0x4f, 0x08, 0x8d, 0xa3, 0x90, 0x92, 0xdc,
0xc5, 0xf7, 0x36, 0xf8, 0x0a, 0xe7, 0x34, 0xbc, 0x58, 0xf0, 0x79, 0x5e, 0xd6, 0x9f, 0xc1, 0xed,
0x75, 0xf9, 0xd0, 0x03, 0xb8, 0x45, 0x25, 0xdc, 0xf2, 0x5c, 0xa1, 0xa4, 0x85, 0xdb, 0x32, 0x3c,
0x74, 0xf5, 0xbf, 0xcb, 0xd0, 0x1e, 0xc7, 0x24, 0xcc, 0xba, 0x77, 0x6a, 0x33, 0x1b, 0xdd, 0x05,
0x95, 0xa6, 0x94, 0x91, 0xa0, 0x58, 0xa5, 0xe2, 0x7a, 0x06, 0x0c, 0x5d, 0x74, 0x1f, 0x9a, 0x4e,
0x14, 0xc4, 0x51, 0x28, 0x86, 0xee, 0xe6, 0xae, 0x6b, 0x2c, 0xb0, 0xa1, 0x8b, 0x8e, 0x40, 0xa3,
0xb3, 0xa9, 0xb5, 0x42, 0xab, 0x2c, 0x8a, 0x0f, 0x24, 0x66, 0xe1, 0xce, 0xaa, 0xe4, 0x4e, 0xae,
0x3c, 0xf3, 0x01, 0xb1, 0xc2, 0x59, 0x30, 0x25, 0x89, 0x70, 0x49, 0x15, 0xb7, 0x0b, 0x78, 0x24,
0x50, 0xd4, 0x03, 0x95, 0x4f, 0x8f, 0x32, 0x3b, 0x88, 0x85, 0x4b, 0xaa, 0x78, 0x09, 0xa0, 0x43,
0x28, 0xbf, 0x99, 0x77, 0x6b, 0xa2, 0x7f, 0x3b, 0x52, 0xff, 0x5e, 0x92, 0xf4, 0x95, 0xed, 0xcf,
0x08, 0x2e, 0xbf, 0x99, 0xa3, 0x87, 0xb0, 0xed, 0x12, 0x9f, 0x30, 0xd2, 0xad, 0x0b, 0x62, 0x47,
0x22, 0x9e, 0x8a, 0x00, 0xce, 0x09, 0xe8, 0x00, 0x2a, 0xdc, 0x8d, 0xaa, 0xe0, 0xb5, 0x25, 0x9e,
0x11, 0x05, 0x98, 0x87, 0xb8, 0xf1, 0x68, 0x1a, 0x3a, 0xd6, 0x62, 0xf4, 0x20, 0xac, 0xd2, 0xe4,
0x60, 0x31, 0x17, 0xfd, 0x8f, 0x32, 0xd4, 0x0b, 0x09, 0x48, 0x83, 0xca, 0x1b, 0x92, 0xe6, 0x2d,
0xe6, 0x8f, 0xe8, 0x10, 0x9a, 0x6e, 0x34, 0x9b, 0xfa, 0xc4, 0x9a, 0x73, 0x86, 0xd8, 0xb9, 0x72,
0x5e, 0xc2, 0x8d, 0x0c, 0xcd, 0x96, 0xfd, 0x1f, 0x54, 0x2f, 0x64, 0x39, 0x83, 0x6f, 0xbc, 0x72,
0x5e, 0xc2, 0x75, 0x2f, 0x64, 0x59, 0xf8, 0x1e, 0xc0, 0x6c, 0x19, 0xaf, 0xf1, 0xc6, 0x9c, 0x97,
0xb0, 0x3a, 0x93, 0x09, 0x74, 0x49, 0xa8, 0x1f, 0x28, 0x47, 0x88, 0x13, 0xa8, 0x4c, 0x98, 0x46,
0x91, 0x9f, 0x13, 0x54, 0xbe, 0x0d, 0x4e, 0xe0, 0xd8, 0x42, 0x01, 0x65, 0x49, 0x1e, 0xe7, 0xdb,
0x54, 0xb9, 0x02, 0xca, 0x92, 0x2c, 0x7c, 0x1f, 0x1a, 0xd3, 0x94, 0x11, 0x9a, 0x13, 0x1a, 0x07,
0xca, 0x51, 0xf3, 0xbc, 0x84, 0x41, 0x80, 0x82, 0x72, 0x52, 0x83, 0x2d, 0x11, 0xd4, 0x7b, 0xb0,
0x9d, 0x75, 0x7a, 0xdd, 0x55, 0xa5, 0xef, 0x41, 0xc5, 0x88, 0x82, 0xb5, 0xa1, 0x53, 0xd8, 0x1b,
0xd8, 0xa1, 0x43, 0xfc, 0x75, 0x1f, 0x91, 0xff, 0x6c, 0x7f, 0x0b, 0xee, 0xac, 0xcb, 0xc2, 0x4f,
0xf1, 0x43, 0xa8, 0x3a, 0x91, 0x9b, 0x9d, 0xe0, 0x76, 0x7f, 0x57, 0x1a, 0x39, 0x26, 0x6c, 0x96,
0x84, 0x83, 0xc8, 0x25, 0x58, 0x50, 0xf8, 0x05, 0xc1, 0x7f, 0x2d, 0xca, 0x8a, 0x3b, 0xb5, 0xc6,
0xdf, 0x4d, 0x96, 0xe8, 0x27, 0x70, 0xe7, 0x05, 0x61, 0x72, 0x76, 0xfa, 0xd9, 0x22, 0xa7, 0xb0,
0xfb, 0x61, 0x0e, 0x2e, 0x71, 0x08, 0x9d, 0x95, 0x0c, 0xd2, 0x17, 0xa6, 0xb7, 0xf1, 0xc6, 0x89,
0xfd, 0x14, 0x6b, 0xf2, 0x32, 0x71, 0x91, 0xbc, 0x83, 0xfd, 0x17, 0x84, 0x8d, 0x63, 0x92, 0xd8,
0xd9, 0x75, 0x6a, 0x32, 0x9b, 0x91, 0xcf, 0x95, 0x8a, 0xbe, 0x05, 0x75, 0x4e, 0x92, 0x69, 0x44,
0x3d, 0x96, 0x8a, 0x56, 0xb4, 0xfb, 0x7b, 0x92, 0x92, 0x57, 0x45, 0xec, 0x82, 0xcc, 0x89, 0x8f,
0x97, 0x5c, 0xfd, 0x19, 0x74, 0xd7, 0xd6, 0xe7, 0xdb, 0xcc, 0xce, 0xb2, 0xf2, 0xd1, 0xb3, 0xac,
0xef, 0xc2, 0x0e, 0xbf, 0xbd, 0x8c, 0xd0, 0x89, 0x5c, 0x2f, 0xbc, 0xce, 0x95, 0xeb, 0x3f, 0x41,
0x67, 0x15, 0xe6, 0x09, 0xbf, 0x87, 0x16, 0xc9, 0x81, 0x65, 0xcf, 0xda, 0xfd, 0x3b, 0xf2, 0xb1,
0xce, 0xe3, 0x93, 0x34, 0x26, 0xb8, 0x59, 0xb0, 0x79, 0xab, 0x1e, 0xbd, 0x00, 0x58, 0x3a, 0x00,
0x35, 0xa0, 0x66, 0x5e, 0x0d, 0x06, 0x86, 0x69, 0x6a, 0x25, 0xb4, 0x07, 0xbb, 0xa3, 0xb1, 0x65,
0x5e, 0x9d, 0x98, 0x03, 0x3c, 0xbc, 0x9c, 0x0c, 0xc7, 0x23, 0xcb, 0x18, 0x4d, 0xf0, 0xaf, 0x9a,
0x82, 0x3a, 0xd0, 0xba, 0x1a, 0xbd, 0x1c, 0x8d, 0x7f, 0x1e, 0x59, 0x06, 0xc6, 0x63, 0xac, 0x95,
0x1f, 0xf5, 0xa1, 0xbd, 0xda, 0x10, 0x04, 0xb0, 0x7d, 0x6a, 0x4c, 0x9e, 0x0f, 0x2f, 0xb4, 0x12,
0x52, 0x61, 0x6b, 0x62, 0x60, 0xd3, 0xd0, 0x14, 0xfe, 0x78, 0x82, 0x87, 0xc6, 0x99, 0x56, 0x7e,
0xf4, 0x1c, 0x9a, 0xb2, 0x34, 0xd4, 0x02, 0xf5, 0x6a, 0x74, 0x6a, 0x9c, 0x0d, 0x47, 0xc6, 0xa9,
0x56, 0x42, 0x35, 0xa8, 0xfc, 0xf2, 0xe3, 0x85, 0xa6, 0x70, 0xfc, 0x07, 0x73, 0x3c, 0xb2, 0x86,
0xc6, 0xe4, 0x4c, 0x2b, 0xf3, 0xc4, 0x97, 0x78, 0x3c, 0x19, 0x3f, 0xd1, 0x2a, 0xfd, 0x7f, 0x2a,
0xb0, 0xb3, 0xbc, 0xf2, 0x27, 0xc5, 0x96, 0x91, 0x09, 0x68, 0xb1, 0xff, 0xdc, 0x32, 0x53, 0x82,
0xbe, 0xd8, 0x68, 0x24, 0xd1, 0xe0, 0x7d, 0x79, 0xbc, 0xab, 0x1f, 0x12, 0xbd, 0xf4, 0x8d, 0x82,
0x3c, 0xb8, 0xeb, 0x88, 0x03, 0x36, 0x79, 0x2f, 0xb5, 0x48, 0x82, 0xbe, 0x94, 0xff, 0x08, 0x6d,
0x3a, 0xce, 0xfb, 0xfa, 0x27, 0x58, 0xb1, 0x9f, 0xea, 0x25, 0xe4, 0xc0, 0xde, 0x35, 0x61, 0x6b,
0xeb, 0x50, 0x24, 0xa7, 0xd8, 0x70, 0x20, 0xf7, 0x0f, 0x3e, 0xca, 0xc9, 0x8a, 0xf8, 0xd0, 0x93,
0x8b, 0xbc, 0x6f, 0x58, 0xf4, 0xd5, 0x6a, 0x8e, 0x0d, 0x07, 0x6a, 0xff, 0xf0, 0x53, 0xb4, 0xac,
0x1a, 0x06, 0xed, 0x9a, 0x30, 0xd9, 0xc0, 0x74, 0x65, 0x20, 0x6b, 0x1c, 0xbf, 0xdf, 0xdb, 0x18,
0x17, 0x39, 0xa7, 0xdb, 0xe2, 0xaf, 0xf8, 0x93, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc9, 0xe3,
0x4f, 0x0d, 0x96, 0x0b, 0x00, 0x00,
}