mirror of https://github.com/grpc/grpc-go.git
1669 lines
70 KiB
Go
1669 lines
70 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// source: grpc/service_config/service_config.proto
|
|
|
|
package grpc_service_config
|
|
|
|
import (
|
|
fmt "fmt"
|
|
proto "github.com/golang/protobuf/proto"
|
|
duration "github.com/golang/protobuf/ptypes/duration"
|
|
wrappers "github.com/golang/protobuf/ptypes/wrappers"
|
|
code "google.golang.org/genproto/googleapis/rpc/code"
|
|
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.ProtoPackageIsVersion3 // please upgrade the proto package
|
|
|
|
// Load balancing policy.
|
|
//
|
|
// Note that load_balancing_policy is deprecated in favor of
|
|
// load_balancing_config; the former will be used only if the latter
|
|
// is unset.
|
|
//
|
|
// If no LB policy is configured here, then the default is pick_first.
|
|
// If the policy name is set via the client API, that value overrides
|
|
// the value specified here.
|
|
//
|
|
// If the deprecated load_balancing_policy field is used, note that if the
|
|
// resolver returns at least one balancer address (as opposed to backend
|
|
// addresses), gRPC will use grpclb (see
|
|
// https://github.com/grpc/grpc/blob/master/doc/load-balancing.md),
|
|
// regardless of what policy is configured here. However, if the resolver
|
|
// returns at least one backend address in addition to the balancer
|
|
// address(es), the client may fall back to the requested policy if it
|
|
// is unable to reach any of the grpclb load balancers.
|
|
type ServiceConfig_LoadBalancingPolicy int32
|
|
|
|
const (
|
|
ServiceConfig_UNSPECIFIED ServiceConfig_LoadBalancingPolicy = 0
|
|
ServiceConfig_ROUND_ROBIN ServiceConfig_LoadBalancingPolicy = 1
|
|
)
|
|
|
|
var ServiceConfig_LoadBalancingPolicy_name = map[int32]string{
|
|
0: "UNSPECIFIED",
|
|
1: "ROUND_ROBIN",
|
|
}
|
|
|
|
var ServiceConfig_LoadBalancingPolicy_value = map[string]int32{
|
|
"UNSPECIFIED": 0,
|
|
"ROUND_ROBIN": 1,
|
|
}
|
|
|
|
func (x ServiceConfig_LoadBalancingPolicy) String() string {
|
|
return proto.EnumName(ServiceConfig_LoadBalancingPolicy_name, int32(x))
|
|
}
|
|
|
|
func (ServiceConfig_LoadBalancingPolicy) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{11, 0}
|
|
}
|
|
|
|
// Configuration for a method.
|
|
type MethodConfig struct {
|
|
Name []*MethodConfig_Name `protobuf:"bytes,1,rep,name=name,proto3" json:"name,omitempty"`
|
|
// Whether RPCs sent to this method should wait until the connection is
|
|
// ready by default. If false, the RPC will abort immediately if there is
|
|
// a transient failure connecting to the server. Otherwise, gRPC will
|
|
// attempt to connect until the deadline is exceeded.
|
|
//
|
|
// The value specified via the gRPC client API will override the value
|
|
// set here. However, note that setting the value in the client API will
|
|
// also affect transient errors encountered during name resolution, which
|
|
// cannot be caught by the value here, since the service config is
|
|
// obtained by the gRPC client via name resolution.
|
|
WaitForReady *wrappers.BoolValue `protobuf:"bytes,2,opt,name=wait_for_ready,json=waitForReady,proto3" json:"wait_for_ready,omitempty"`
|
|
// The default timeout in seconds for RPCs sent to this method. This can be
|
|
// overridden in code. If no reply is received in the specified amount of
|
|
// time, the request is aborted and a DEADLINE_EXCEEDED error status
|
|
// is returned to the caller.
|
|
//
|
|
// The actual deadline used will be the minimum of the value specified here
|
|
// and the value set by the application via the gRPC client API. If either
|
|
// one is not set, then the other will be used. If neither is set, then the
|
|
// request has no deadline.
|
|
Timeout *duration.Duration `protobuf:"bytes,3,opt,name=timeout,proto3" json:"timeout,omitempty"`
|
|
// The maximum allowed payload size for an individual request or object in a
|
|
// stream (client->server) in bytes. The size which is measured is the
|
|
// serialized payload after per-message compression (but before stream
|
|
// compression) in bytes. This applies both to streaming and non-streaming
|
|
// requests.
|
|
//
|
|
// The actual value used is the minimum of the value specified here and the
|
|
// value set by the application via the gRPC client API. If either one is
|
|
// not set, then the other will be used. If neither is set, then the
|
|
// built-in default is used.
|
|
//
|
|
// If a client attempts to send an object larger than this value, it will not
|
|
// be sent and the client will see a ClientError.
|
|
// Note that 0 is a valid value, meaning that the request message
|
|
// must be empty.
|
|
MaxRequestMessageBytes *wrappers.UInt32Value `protobuf:"bytes,4,opt,name=max_request_message_bytes,json=maxRequestMessageBytes,proto3" json:"max_request_message_bytes,omitempty"`
|
|
// The maximum allowed payload size for an individual response or object in a
|
|
// stream (server->client) in bytes. The size which is measured is the
|
|
// serialized payload after per-message compression (but before stream
|
|
// compression) in bytes. This applies both to streaming and non-streaming
|
|
// requests.
|
|
//
|
|
// The actual value used is the minimum of the value specified here and the
|
|
// value set by the application via the gRPC client API. If either one is
|
|
// not set, then the other will be used. If neither is set, then the
|
|
// built-in default is used.
|
|
//
|
|
// If a server attempts to send an object larger than this value, it will not
|
|
// be sent, and a ServerError will be sent to the client instead.
|
|
// Note that 0 is a valid value, meaning that the response message
|
|
// must be empty.
|
|
MaxResponseMessageBytes *wrappers.UInt32Value `protobuf:"bytes,5,opt,name=max_response_message_bytes,json=maxResponseMessageBytes,proto3" json:"max_response_message_bytes,omitempty"`
|
|
// Only one of retry_policy or hedging_policy may be set. If neither is set,
|
|
// RPCs will not be retried or hedged.
|
|
//
|
|
// Types that are valid to be assigned to RetryOrHedgingPolicy:
|
|
// *MethodConfig_RetryPolicy_
|
|
// *MethodConfig_HedgingPolicy_
|
|
RetryOrHedgingPolicy isMethodConfig_RetryOrHedgingPolicy `protobuf_oneof:"retry_or_hedging_policy"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *MethodConfig) Reset() { *m = MethodConfig{} }
|
|
func (m *MethodConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*MethodConfig) ProtoMessage() {}
|
|
func (*MethodConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{0}
|
|
}
|
|
|
|
func (m *MethodConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_MethodConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *MethodConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_MethodConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *MethodConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_MethodConfig.Merge(m, src)
|
|
}
|
|
func (m *MethodConfig) XXX_Size() int {
|
|
return xxx_messageInfo_MethodConfig.Size(m)
|
|
}
|
|
func (m *MethodConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_MethodConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_MethodConfig proto.InternalMessageInfo
|
|
|
|
func (m *MethodConfig) GetName() []*MethodConfig_Name {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MethodConfig) GetWaitForReady() *wrappers.BoolValue {
|
|
if m != nil {
|
|
return m.WaitForReady
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MethodConfig) GetTimeout() *duration.Duration {
|
|
if m != nil {
|
|
return m.Timeout
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MethodConfig) GetMaxRequestMessageBytes() *wrappers.UInt32Value {
|
|
if m != nil {
|
|
return m.MaxRequestMessageBytes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MethodConfig) GetMaxResponseMessageBytes() *wrappers.UInt32Value {
|
|
if m != nil {
|
|
return m.MaxResponseMessageBytes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type isMethodConfig_RetryOrHedgingPolicy interface {
|
|
isMethodConfig_RetryOrHedgingPolicy()
|
|
}
|
|
|
|
type MethodConfig_RetryPolicy_ struct {
|
|
RetryPolicy *MethodConfig_RetryPolicy `protobuf:"bytes,6,opt,name=retry_policy,json=retryPolicy,proto3,oneof"`
|
|
}
|
|
|
|
type MethodConfig_HedgingPolicy_ struct {
|
|
HedgingPolicy *MethodConfig_HedgingPolicy `protobuf:"bytes,7,opt,name=hedging_policy,json=hedgingPolicy,proto3,oneof"`
|
|
}
|
|
|
|
func (*MethodConfig_RetryPolicy_) isMethodConfig_RetryOrHedgingPolicy() {}
|
|
|
|
func (*MethodConfig_HedgingPolicy_) isMethodConfig_RetryOrHedgingPolicy() {}
|
|
|
|
func (m *MethodConfig) GetRetryOrHedgingPolicy() isMethodConfig_RetryOrHedgingPolicy {
|
|
if m != nil {
|
|
return m.RetryOrHedgingPolicy
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MethodConfig) GetRetryPolicy() *MethodConfig_RetryPolicy {
|
|
if x, ok := m.GetRetryOrHedgingPolicy().(*MethodConfig_RetryPolicy_); ok {
|
|
return x.RetryPolicy
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MethodConfig) GetHedgingPolicy() *MethodConfig_HedgingPolicy {
|
|
if x, ok := m.GetRetryOrHedgingPolicy().(*MethodConfig_HedgingPolicy_); ok {
|
|
return x.HedgingPolicy
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// XXX_OneofWrappers is for the internal use of the proto package.
|
|
func (*MethodConfig) XXX_OneofWrappers() []interface{} {
|
|
return []interface{}{
|
|
(*MethodConfig_RetryPolicy_)(nil),
|
|
(*MethodConfig_HedgingPolicy_)(nil),
|
|
}
|
|
}
|
|
|
|
// The names of the methods to which this configuration applies.
|
|
// - MethodConfig without names (empty list) will be skipped.
|
|
// - Each name entry must be unique across the entire ServiceConfig.
|
|
// - If the 'method' field is empty, this MethodConfig specifies the defaults
|
|
// for all methods for the specified service.
|
|
// - If the 'service' field is empty, the 'method' field must be empty, and
|
|
// this MethodConfig specifies the default for all methods (it's the default
|
|
// config).
|
|
//
|
|
// When determining which MethodConfig to use for a given RPC, the most
|
|
// specific match wins. For example, let's say that the service config
|
|
// contains the following MethodConfig entries:
|
|
//
|
|
// method_config { name { } ... }
|
|
// method_config { name { service: "MyService" } ... }
|
|
// method_config { name { service: "MyService" method: "Foo" } ... }
|
|
//
|
|
// MyService/Foo will use the third entry, because it exactly matches the
|
|
// service and method name. MyService/Bar will use the second entry, because
|
|
// it provides the default for all methods of MyService. AnotherService/Baz
|
|
// will use the first entry, because it doesn't match the other two.
|
|
//
|
|
// In JSON representation, value "", value `null`, and not present are the
|
|
// same. The following are the same Name:
|
|
// - { "service": "s" }
|
|
// - { "service": "s", "method": null }
|
|
// - { "service": "s", "method": "" }
|
|
type MethodConfig_Name struct {
|
|
Service string `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
|
|
Method string `protobuf:"bytes,2,opt,name=method,proto3" json:"method,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *MethodConfig_Name) Reset() { *m = MethodConfig_Name{} }
|
|
func (m *MethodConfig_Name) String() string { return proto.CompactTextString(m) }
|
|
func (*MethodConfig_Name) ProtoMessage() {}
|
|
func (*MethodConfig_Name) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{0, 0}
|
|
}
|
|
|
|
func (m *MethodConfig_Name) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_MethodConfig_Name.Unmarshal(m, b)
|
|
}
|
|
func (m *MethodConfig_Name) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_MethodConfig_Name.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *MethodConfig_Name) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_MethodConfig_Name.Merge(m, src)
|
|
}
|
|
func (m *MethodConfig_Name) XXX_Size() int {
|
|
return xxx_messageInfo_MethodConfig_Name.Size(m)
|
|
}
|
|
func (m *MethodConfig_Name) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_MethodConfig_Name.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_MethodConfig_Name proto.InternalMessageInfo
|
|
|
|
func (m *MethodConfig_Name) GetService() string {
|
|
if m != nil {
|
|
return m.Service
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *MethodConfig_Name) GetMethod() string {
|
|
if m != nil {
|
|
return m.Method
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// The retry policy for outgoing RPCs.
|
|
type MethodConfig_RetryPolicy struct {
|
|
// The maximum number of RPC attempts, including the original attempt.
|
|
//
|
|
// This field is required and must be greater than 1.
|
|
// Any value greater than 5 will be treated as if it were 5.
|
|
MaxAttempts uint32 `protobuf:"varint,1,opt,name=max_attempts,json=maxAttempts,proto3" json:"max_attempts,omitempty"`
|
|
// Exponential backoff parameters. The initial retry attempt will occur at
|
|
// random(0, initial_backoff). In general, the nth attempt will occur at
|
|
// random(0,
|
|
// min(initial_backoff*backoff_multiplier**(n-1), max_backoff)).
|
|
// Required. Must be greater than zero.
|
|
InitialBackoff *duration.Duration `protobuf:"bytes,2,opt,name=initial_backoff,json=initialBackoff,proto3" json:"initial_backoff,omitempty"`
|
|
// Required. Must be greater than zero.
|
|
MaxBackoff *duration.Duration `protobuf:"bytes,3,opt,name=max_backoff,json=maxBackoff,proto3" json:"max_backoff,omitempty"`
|
|
BackoffMultiplier float32 `protobuf:"fixed32,4,opt,name=backoff_multiplier,json=backoffMultiplier,proto3" json:"backoff_multiplier,omitempty"`
|
|
// The set of status codes which may be retried.
|
|
//
|
|
// This field is required and must be non-empty.
|
|
RetryableStatusCodes []code.Code `protobuf:"varint,5,rep,packed,name=retryable_status_codes,json=retryableStatusCodes,proto3,enum=google.rpc.Code" json:"retryable_status_codes,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *MethodConfig_RetryPolicy) Reset() { *m = MethodConfig_RetryPolicy{} }
|
|
func (m *MethodConfig_RetryPolicy) String() string { return proto.CompactTextString(m) }
|
|
func (*MethodConfig_RetryPolicy) ProtoMessage() {}
|
|
func (*MethodConfig_RetryPolicy) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{0, 1}
|
|
}
|
|
|
|
func (m *MethodConfig_RetryPolicy) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_MethodConfig_RetryPolicy.Unmarshal(m, b)
|
|
}
|
|
func (m *MethodConfig_RetryPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_MethodConfig_RetryPolicy.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *MethodConfig_RetryPolicy) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_MethodConfig_RetryPolicy.Merge(m, src)
|
|
}
|
|
func (m *MethodConfig_RetryPolicy) XXX_Size() int {
|
|
return xxx_messageInfo_MethodConfig_RetryPolicy.Size(m)
|
|
}
|
|
func (m *MethodConfig_RetryPolicy) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_MethodConfig_RetryPolicy.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_MethodConfig_RetryPolicy proto.InternalMessageInfo
|
|
|
|
func (m *MethodConfig_RetryPolicy) GetMaxAttempts() uint32 {
|
|
if m != nil {
|
|
return m.MaxAttempts
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *MethodConfig_RetryPolicy) GetInitialBackoff() *duration.Duration {
|
|
if m != nil {
|
|
return m.InitialBackoff
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MethodConfig_RetryPolicy) GetMaxBackoff() *duration.Duration {
|
|
if m != nil {
|
|
return m.MaxBackoff
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MethodConfig_RetryPolicy) GetBackoffMultiplier() float32 {
|
|
if m != nil {
|
|
return m.BackoffMultiplier
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *MethodConfig_RetryPolicy) GetRetryableStatusCodes() []code.Code {
|
|
if m != nil {
|
|
return m.RetryableStatusCodes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// The hedging policy for outgoing RPCs. Hedged RPCs may execute more than
|
|
// once on the server, so only idempotent methods should specify a hedging
|
|
// policy.
|
|
type MethodConfig_HedgingPolicy struct {
|
|
// The hedging policy will send up to max_requests RPCs.
|
|
// This number represents the total number of all attempts, including
|
|
// the original attempt.
|
|
//
|
|
// This field is required and must be greater than 1.
|
|
// Any value greater than 5 will be treated as if it were 5.
|
|
MaxAttempts uint32 `protobuf:"varint,1,opt,name=max_attempts,json=maxAttempts,proto3" json:"max_attempts,omitempty"`
|
|
// The first RPC will be sent immediately, but the max_requests-1 subsequent
|
|
// hedged RPCs will be sent at intervals of every hedging_delay. Set this
|
|
// to 0 to immediately send all max_requests RPCs.
|
|
HedgingDelay *duration.Duration `protobuf:"bytes,2,opt,name=hedging_delay,json=hedgingDelay,proto3" json:"hedging_delay,omitempty"`
|
|
// The set of status codes which indicate other hedged RPCs may still
|
|
// succeed. If a non-fatal status code is returned by the server, hedged
|
|
// RPCs will continue. Otherwise, outstanding requests will be canceled and
|
|
// the error returned to the client application layer.
|
|
//
|
|
// This field is optional.
|
|
NonFatalStatusCodes []code.Code `protobuf:"varint,3,rep,packed,name=non_fatal_status_codes,json=nonFatalStatusCodes,proto3,enum=google.rpc.Code" json:"non_fatal_status_codes,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *MethodConfig_HedgingPolicy) Reset() { *m = MethodConfig_HedgingPolicy{} }
|
|
func (m *MethodConfig_HedgingPolicy) String() string { return proto.CompactTextString(m) }
|
|
func (*MethodConfig_HedgingPolicy) ProtoMessage() {}
|
|
func (*MethodConfig_HedgingPolicy) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{0, 2}
|
|
}
|
|
|
|
func (m *MethodConfig_HedgingPolicy) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_MethodConfig_HedgingPolicy.Unmarshal(m, b)
|
|
}
|
|
func (m *MethodConfig_HedgingPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_MethodConfig_HedgingPolicy.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *MethodConfig_HedgingPolicy) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_MethodConfig_HedgingPolicy.Merge(m, src)
|
|
}
|
|
func (m *MethodConfig_HedgingPolicy) XXX_Size() int {
|
|
return xxx_messageInfo_MethodConfig_HedgingPolicy.Size(m)
|
|
}
|
|
func (m *MethodConfig_HedgingPolicy) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_MethodConfig_HedgingPolicy.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_MethodConfig_HedgingPolicy proto.InternalMessageInfo
|
|
|
|
func (m *MethodConfig_HedgingPolicy) GetMaxAttempts() uint32 {
|
|
if m != nil {
|
|
return m.MaxAttempts
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *MethodConfig_HedgingPolicy) GetHedgingDelay() *duration.Duration {
|
|
if m != nil {
|
|
return m.HedgingDelay
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MethodConfig_HedgingPolicy) GetNonFatalStatusCodes() []code.Code {
|
|
if m != nil {
|
|
return m.NonFatalStatusCodes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Configuration for pick_first LB policy.
|
|
type PickFirstConfig struct {
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *PickFirstConfig) Reset() { *m = PickFirstConfig{} }
|
|
func (m *PickFirstConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*PickFirstConfig) ProtoMessage() {}
|
|
func (*PickFirstConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{1}
|
|
}
|
|
|
|
func (m *PickFirstConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_PickFirstConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *PickFirstConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_PickFirstConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *PickFirstConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_PickFirstConfig.Merge(m, src)
|
|
}
|
|
func (m *PickFirstConfig) XXX_Size() int {
|
|
return xxx_messageInfo_PickFirstConfig.Size(m)
|
|
}
|
|
func (m *PickFirstConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_PickFirstConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_PickFirstConfig proto.InternalMessageInfo
|
|
|
|
// Configuration for round_robin LB policy.
|
|
type RoundRobinConfig struct {
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *RoundRobinConfig) Reset() { *m = RoundRobinConfig{} }
|
|
func (m *RoundRobinConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*RoundRobinConfig) ProtoMessage() {}
|
|
func (*RoundRobinConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{2}
|
|
}
|
|
|
|
func (m *RoundRobinConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_RoundRobinConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *RoundRobinConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_RoundRobinConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *RoundRobinConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_RoundRobinConfig.Merge(m, src)
|
|
}
|
|
func (m *RoundRobinConfig) XXX_Size() int {
|
|
return xxx_messageInfo_RoundRobinConfig.Size(m)
|
|
}
|
|
func (m *RoundRobinConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_RoundRobinConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_RoundRobinConfig proto.InternalMessageInfo
|
|
|
|
// Configuration for priority LB policy.
|
|
type PriorityLoadBalancingPolicyConfig struct {
|
|
Children map[string]*PriorityLoadBalancingPolicyConfig_Child `protobuf:"bytes,1,rep,name=children,proto3" json:"children,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
|
// A list of child names in decreasing priority order
|
|
// (i.e., first element is the highest priority).
|
|
Priorities []string `protobuf:"bytes,2,rep,name=priorities,proto3" json:"priorities,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *PriorityLoadBalancingPolicyConfig) Reset() { *m = PriorityLoadBalancingPolicyConfig{} }
|
|
func (m *PriorityLoadBalancingPolicyConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*PriorityLoadBalancingPolicyConfig) ProtoMessage() {}
|
|
func (*PriorityLoadBalancingPolicyConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{3}
|
|
}
|
|
|
|
func (m *PriorityLoadBalancingPolicyConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_PriorityLoadBalancingPolicyConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *PriorityLoadBalancingPolicyConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_PriorityLoadBalancingPolicyConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *PriorityLoadBalancingPolicyConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_PriorityLoadBalancingPolicyConfig.Merge(m, src)
|
|
}
|
|
func (m *PriorityLoadBalancingPolicyConfig) XXX_Size() int {
|
|
return xxx_messageInfo_PriorityLoadBalancingPolicyConfig.Size(m)
|
|
}
|
|
func (m *PriorityLoadBalancingPolicyConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_PriorityLoadBalancingPolicyConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_PriorityLoadBalancingPolicyConfig proto.InternalMessageInfo
|
|
|
|
func (m *PriorityLoadBalancingPolicyConfig) GetChildren() map[string]*PriorityLoadBalancingPolicyConfig_Child {
|
|
if m != nil {
|
|
return m.Children
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *PriorityLoadBalancingPolicyConfig) GetPriorities() []string {
|
|
if m != nil {
|
|
return m.Priorities
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// A map of name to child policy configuration.
|
|
// The names are used to allow the priority policy to update
|
|
// existing child policies instead of creating new ones every
|
|
// time it receives a config update.
|
|
type PriorityLoadBalancingPolicyConfig_Child struct {
|
|
Config []*LoadBalancingConfig `protobuf:"bytes,1,rep,name=config,proto3" json:"config,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *PriorityLoadBalancingPolicyConfig_Child) Reset() {
|
|
*m = PriorityLoadBalancingPolicyConfig_Child{}
|
|
}
|
|
func (m *PriorityLoadBalancingPolicyConfig_Child) String() string { return proto.CompactTextString(m) }
|
|
func (*PriorityLoadBalancingPolicyConfig_Child) ProtoMessage() {}
|
|
func (*PriorityLoadBalancingPolicyConfig_Child) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{3, 0}
|
|
}
|
|
|
|
func (m *PriorityLoadBalancingPolicyConfig_Child) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_PriorityLoadBalancingPolicyConfig_Child.Unmarshal(m, b)
|
|
}
|
|
func (m *PriorityLoadBalancingPolicyConfig_Child) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_PriorityLoadBalancingPolicyConfig_Child.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *PriorityLoadBalancingPolicyConfig_Child) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_PriorityLoadBalancingPolicyConfig_Child.Merge(m, src)
|
|
}
|
|
func (m *PriorityLoadBalancingPolicyConfig_Child) XXX_Size() int {
|
|
return xxx_messageInfo_PriorityLoadBalancingPolicyConfig_Child.Size(m)
|
|
}
|
|
func (m *PriorityLoadBalancingPolicyConfig_Child) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_PriorityLoadBalancingPolicyConfig_Child.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_PriorityLoadBalancingPolicyConfig_Child proto.InternalMessageInfo
|
|
|
|
func (m *PriorityLoadBalancingPolicyConfig_Child) GetConfig() []*LoadBalancingConfig {
|
|
if m != nil {
|
|
return m.Config
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Configuration for weighted_target LB policy.
|
|
type WeightedTargetLoadBalancingPolicyConfig struct {
|
|
Targets map[string]*WeightedTargetLoadBalancingPolicyConfig_Target `protobuf:"bytes,1,rep,name=targets,proto3" json:"targets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig) Reset() {
|
|
*m = WeightedTargetLoadBalancingPolicyConfig{}
|
|
}
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*WeightedTargetLoadBalancingPolicyConfig) ProtoMessage() {}
|
|
func (*WeightedTargetLoadBalancingPolicyConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{4}
|
|
}
|
|
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig.Merge(m, src)
|
|
}
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig) XXX_Size() int {
|
|
return xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig.Size(m)
|
|
}
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig proto.InternalMessageInfo
|
|
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig) GetTargets() map[string]*WeightedTargetLoadBalancingPolicyConfig_Target {
|
|
if m != nil {
|
|
return m.Targets
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type WeightedTargetLoadBalancingPolicyConfig_Target struct {
|
|
Weight uint32 `protobuf:"varint,1,opt,name=weight,proto3" json:"weight,omitempty"`
|
|
ChildPolicy []*LoadBalancingConfig `protobuf:"bytes,2,rep,name=child_policy,json=childPolicy,proto3" json:"child_policy,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig_Target) Reset() {
|
|
*m = WeightedTargetLoadBalancingPolicyConfig_Target{}
|
|
}
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig_Target) String() string {
|
|
return proto.CompactTextString(m)
|
|
}
|
|
func (*WeightedTargetLoadBalancingPolicyConfig_Target) ProtoMessage() {}
|
|
func (*WeightedTargetLoadBalancingPolicyConfig_Target) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{4, 0}
|
|
}
|
|
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig_Target) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig_Target.Unmarshal(m, b)
|
|
}
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig_Target) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig_Target.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig_Target) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig_Target.Merge(m, src)
|
|
}
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig_Target) XXX_Size() int {
|
|
return xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig_Target.Size(m)
|
|
}
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig_Target) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig_Target.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_WeightedTargetLoadBalancingPolicyConfig_Target proto.InternalMessageInfo
|
|
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig_Target) GetWeight() uint32 {
|
|
if m != nil {
|
|
return m.Weight
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *WeightedTargetLoadBalancingPolicyConfig_Target) GetChildPolicy() []*LoadBalancingConfig {
|
|
if m != nil {
|
|
return m.ChildPolicy
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Configuration for grpclb LB policy.
|
|
type GrpcLbConfig struct {
|
|
// Optional. What LB policy to use for routing between the backend
|
|
// addresses. If unset, defaults to round_robin.
|
|
// Currently, the only supported values are round_robin and pick_first.
|
|
// Note that this will be used both in balancer mode and in fallback mode.
|
|
// Multiple LB policies can be specified; clients will iterate through
|
|
// the list in order and stop at the first policy that they support.
|
|
ChildPolicy []*LoadBalancingConfig `protobuf:"bytes,1,rep,name=child_policy,json=childPolicy,proto3" json:"child_policy,omitempty"`
|
|
// Optional. If specified, overrides the name of the service to be sent to
|
|
// the balancer.
|
|
ServiceName string `protobuf:"bytes,2,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *GrpcLbConfig) Reset() { *m = GrpcLbConfig{} }
|
|
func (m *GrpcLbConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*GrpcLbConfig) ProtoMessage() {}
|
|
func (*GrpcLbConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{5}
|
|
}
|
|
|
|
func (m *GrpcLbConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_GrpcLbConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *GrpcLbConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_GrpcLbConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *GrpcLbConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GrpcLbConfig.Merge(m, src)
|
|
}
|
|
func (m *GrpcLbConfig) XXX_Size() int {
|
|
return xxx_messageInfo_GrpcLbConfig.Size(m)
|
|
}
|
|
func (m *GrpcLbConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GrpcLbConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GrpcLbConfig proto.InternalMessageInfo
|
|
|
|
func (m *GrpcLbConfig) GetChildPolicy() []*LoadBalancingConfig {
|
|
if m != nil {
|
|
return m.ChildPolicy
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GrpcLbConfig) GetServiceName() string {
|
|
if m != nil {
|
|
return m.ServiceName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Configuration for the cds LB policy.
|
|
type CdsConfig struct {
|
|
Cluster string `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *CdsConfig) Reset() { *m = CdsConfig{} }
|
|
func (m *CdsConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*CdsConfig) ProtoMessage() {}
|
|
func (*CdsConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{6}
|
|
}
|
|
|
|
func (m *CdsConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_CdsConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *CdsConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_CdsConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *CdsConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_CdsConfig.Merge(m, src)
|
|
}
|
|
func (m *CdsConfig) XXX_Size() int {
|
|
return xxx_messageInfo_CdsConfig.Size(m)
|
|
}
|
|
func (m *CdsConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_CdsConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_CdsConfig proto.InternalMessageInfo
|
|
|
|
func (m *CdsConfig) GetCluster() string {
|
|
if m != nil {
|
|
return m.Cluster
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Configuration for xds LB policy.
|
|
type XdsConfig struct {
|
|
// Name of balancer to connect to.
|
|
BalancerName string `protobuf:"bytes,1,opt,name=balancer_name,json=balancerName,proto3" json:"balancer_name,omitempty"` // Deprecated: Do not use.
|
|
// Optional. What LB policy to use for intra-locality routing.
|
|
// If unset, will use whatever algorithm is specified by the balancer.
|
|
// Multiple LB policies can be specified; clients will iterate through
|
|
// the list in order and stop at the first policy that they support.
|
|
ChildPolicy []*LoadBalancingConfig `protobuf:"bytes,2,rep,name=child_policy,json=childPolicy,proto3" json:"child_policy,omitempty"`
|
|
// Optional. What LB policy to use in fallback mode. If not
|
|
// specified, defaults to round_robin.
|
|
// Multiple LB policies can be specified; clients will iterate through
|
|
// the list in order and stop at the first policy that they support.
|
|
FallbackPolicy []*LoadBalancingConfig `protobuf:"bytes,3,rep,name=fallback_policy,json=fallbackPolicy,proto3" json:"fallback_policy,omitempty"`
|
|
// Optional. Name to use in EDS query. If not present, defaults to
|
|
// the server name from the target URI.
|
|
EdsServiceName string `protobuf:"bytes,4,opt,name=eds_service_name,json=edsServiceName,proto3" json:"eds_service_name,omitempty"`
|
|
// LRS server to send load reports to.
|
|
// If not present, load reporting will be disabled.
|
|
// If set to the empty string, load reporting will be sent to the same
|
|
// server that we obtained CDS data from.
|
|
LrsLoadReportingServerName *wrappers.StringValue `protobuf:"bytes,5,opt,name=lrs_load_reporting_server_name,json=lrsLoadReportingServerName,proto3" json:"lrs_load_reporting_server_name,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *XdsConfig) Reset() { *m = XdsConfig{} }
|
|
func (m *XdsConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*XdsConfig) ProtoMessage() {}
|
|
func (*XdsConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{7}
|
|
}
|
|
|
|
func (m *XdsConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_XdsConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *XdsConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_XdsConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *XdsConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_XdsConfig.Merge(m, src)
|
|
}
|
|
func (m *XdsConfig) XXX_Size() int {
|
|
return xxx_messageInfo_XdsConfig.Size(m)
|
|
}
|
|
func (m *XdsConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_XdsConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_XdsConfig proto.InternalMessageInfo
|
|
|
|
// Deprecated: Do not use.
|
|
func (m *XdsConfig) GetBalancerName() string {
|
|
if m != nil {
|
|
return m.BalancerName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *XdsConfig) GetChildPolicy() []*LoadBalancingConfig {
|
|
if m != nil {
|
|
return m.ChildPolicy
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *XdsConfig) GetFallbackPolicy() []*LoadBalancingConfig {
|
|
if m != nil {
|
|
return m.FallbackPolicy
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *XdsConfig) GetEdsServiceName() string {
|
|
if m != nil {
|
|
return m.EdsServiceName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *XdsConfig) GetLrsLoadReportingServerName() *wrappers.StringValue {
|
|
if m != nil {
|
|
return m.LrsLoadReportingServerName
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Configuration for eds LB policy.
|
|
type EdsLoadBalancingPolicyConfig struct {
|
|
// Cluster name. Required.
|
|
Cluster string `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
|
|
// EDS service name, as returned in CDS.
|
|
// May be unset if not specified in CDS.
|
|
EdsServiceName string `protobuf:"bytes,2,opt,name=eds_service_name,json=edsServiceName,proto3" json:"eds_service_name,omitempty"`
|
|
// Server to send load reports to.
|
|
// If unset, no load reporting is done.
|
|
// If set to empty string, load reporting will be sent to the same
|
|
// server as we are getting xds data from.
|
|
LrsLoadReportingServerName *wrappers.StringValue `protobuf:"bytes,3,opt,name=lrs_load_reporting_server_name,json=lrsLoadReportingServerName,proto3" json:"lrs_load_reporting_server_name,omitempty"`
|
|
// Locality-picking policy.
|
|
// This policy's config is expected to be in the format used
|
|
// by the weighted_target policy. Note that the config should include
|
|
// an empty value for the "targets" field; that empty value will be
|
|
// replaced by one that is dynamically generated based on the EDS data.
|
|
// Optional; defaults to "weighted_target".
|
|
LocalityPickingPolicy []*LoadBalancingConfig `protobuf:"bytes,4,rep,name=locality_picking_policy,json=localityPickingPolicy,proto3" json:"locality_picking_policy,omitempty"`
|
|
// Endpoint-picking policy.
|
|
// This will be configured as the policy for each child in the
|
|
// locality-policy's config.
|
|
// Optional; defaults to "round_robin".
|
|
EndpointPickingPolicy []*LoadBalancingConfig `protobuf:"bytes,5,rep,name=endpoint_picking_policy,json=endpointPickingPolicy,proto3" json:"endpoint_picking_policy,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *EdsLoadBalancingPolicyConfig) Reset() { *m = EdsLoadBalancingPolicyConfig{} }
|
|
func (m *EdsLoadBalancingPolicyConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*EdsLoadBalancingPolicyConfig) ProtoMessage() {}
|
|
func (*EdsLoadBalancingPolicyConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{8}
|
|
}
|
|
|
|
func (m *EdsLoadBalancingPolicyConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_EdsLoadBalancingPolicyConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *EdsLoadBalancingPolicyConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_EdsLoadBalancingPolicyConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *EdsLoadBalancingPolicyConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_EdsLoadBalancingPolicyConfig.Merge(m, src)
|
|
}
|
|
func (m *EdsLoadBalancingPolicyConfig) XXX_Size() int {
|
|
return xxx_messageInfo_EdsLoadBalancingPolicyConfig.Size(m)
|
|
}
|
|
func (m *EdsLoadBalancingPolicyConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_EdsLoadBalancingPolicyConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_EdsLoadBalancingPolicyConfig proto.InternalMessageInfo
|
|
|
|
func (m *EdsLoadBalancingPolicyConfig) GetCluster() string {
|
|
if m != nil {
|
|
return m.Cluster
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *EdsLoadBalancingPolicyConfig) GetEdsServiceName() string {
|
|
if m != nil {
|
|
return m.EdsServiceName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *EdsLoadBalancingPolicyConfig) GetLrsLoadReportingServerName() *wrappers.StringValue {
|
|
if m != nil {
|
|
return m.LrsLoadReportingServerName
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *EdsLoadBalancingPolicyConfig) GetLocalityPickingPolicy() []*LoadBalancingConfig {
|
|
if m != nil {
|
|
return m.LocalityPickingPolicy
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *EdsLoadBalancingPolicyConfig) GetEndpointPickingPolicy() []*LoadBalancingConfig {
|
|
if m != nil {
|
|
return m.EndpointPickingPolicy
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Configuration for lrs LB policy.
|
|
type LrsLoadBalancingPolicyConfig struct {
|
|
// Cluster name. Required.
|
|
ClusterName string `protobuf:"bytes,1,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"`
|
|
// EDS service name, as returned in CDS.
|
|
// May be unset if not specified in CDS.
|
|
EdsServiceName string `protobuf:"bytes,2,opt,name=eds_service_name,json=edsServiceName,proto3" json:"eds_service_name,omitempty"`
|
|
// Server to send load reports to. Required.
|
|
// If set to empty string, load reporting will be sent to the same
|
|
// server as we are getting xds data from.
|
|
LrsLoadReportingServerName string `protobuf:"bytes,3,opt,name=lrs_load_reporting_server_name,json=lrsLoadReportingServerName,proto3" json:"lrs_load_reporting_server_name,omitempty"`
|
|
Locality *LrsLoadBalancingPolicyConfig_Locality `protobuf:"bytes,4,opt,name=locality,proto3" json:"locality,omitempty"`
|
|
// Endpoint-picking policy.
|
|
ChildPolicy []*LoadBalancingConfig `protobuf:"bytes,5,rep,name=child_policy,json=childPolicy,proto3" json:"child_policy,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig) Reset() { *m = LrsLoadBalancingPolicyConfig{} }
|
|
func (m *LrsLoadBalancingPolicyConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*LrsLoadBalancingPolicyConfig) ProtoMessage() {}
|
|
func (*LrsLoadBalancingPolicyConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{9}
|
|
}
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_LrsLoadBalancingPolicyConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *LrsLoadBalancingPolicyConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_LrsLoadBalancingPolicyConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *LrsLoadBalancingPolicyConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LrsLoadBalancingPolicyConfig.Merge(m, src)
|
|
}
|
|
func (m *LrsLoadBalancingPolicyConfig) XXX_Size() int {
|
|
return xxx_messageInfo_LrsLoadBalancingPolicyConfig.Size(m)
|
|
}
|
|
func (m *LrsLoadBalancingPolicyConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LrsLoadBalancingPolicyConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LrsLoadBalancingPolicyConfig proto.InternalMessageInfo
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig) GetClusterName() string {
|
|
if m != nil {
|
|
return m.ClusterName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig) GetEdsServiceName() string {
|
|
if m != nil {
|
|
return m.EdsServiceName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig) GetLrsLoadReportingServerName() string {
|
|
if m != nil {
|
|
return m.LrsLoadReportingServerName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig) GetLocality() *LrsLoadBalancingPolicyConfig_Locality {
|
|
if m != nil {
|
|
return m.Locality
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig) GetChildPolicy() []*LoadBalancingConfig {
|
|
if m != nil {
|
|
return m.ChildPolicy
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// The locality for which this policy will report load. Required.
|
|
type LrsLoadBalancingPolicyConfig_Locality struct {
|
|
Region string `protobuf:"bytes,1,opt,name=region,proto3" json:"region,omitempty"`
|
|
Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"`
|
|
Subzone string `protobuf:"bytes,3,opt,name=subzone,proto3" json:"subzone,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig_Locality) Reset() { *m = LrsLoadBalancingPolicyConfig_Locality{} }
|
|
func (m *LrsLoadBalancingPolicyConfig_Locality) String() string { return proto.CompactTextString(m) }
|
|
func (*LrsLoadBalancingPolicyConfig_Locality) ProtoMessage() {}
|
|
func (*LrsLoadBalancingPolicyConfig_Locality) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{9, 0}
|
|
}
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig_Locality) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_LrsLoadBalancingPolicyConfig_Locality.Unmarshal(m, b)
|
|
}
|
|
func (m *LrsLoadBalancingPolicyConfig_Locality) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_LrsLoadBalancingPolicyConfig_Locality.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *LrsLoadBalancingPolicyConfig_Locality) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LrsLoadBalancingPolicyConfig_Locality.Merge(m, src)
|
|
}
|
|
func (m *LrsLoadBalancingPolicyConfig_Locality) XXX_Size() int {
|
|
return xxx_messageInfo_LrsLoadBalancingPolicyConfig_Locality.Size(m)
|
|
}
|
|
func (m *LrsLoadBalancingPolicyConfig_Locality) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LrsLoadBalancingPolicyConfig_Locality.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LrsLoadBalancingPolicyConfig_Locality proto.InternalMessageInfo
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig_Locality) GetRegion() string {
|
|
if m != nil {
|
|
return m.Region
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig_Locality) GetZone() string {
|
|
if m != nil {
|
|
return m.Zone
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *LrsLoadBalancingPolicyConfig_Locality) GetSubzone() string {
|
|
if m != nil {
|
|
return m.Subzone
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Selects LB policy and provides corresponding configuration.
|
|
//
|
|
// In general, all instances of this field should be repeated. Clients will
|
|
// iterate through the list in order and stop at the first policy that they
|
|
// support. This allows the service config to specify custom policies that may
|
|
// not be known to all clients.
|
|
//
|
|
// - If the config for the first supported policy is invalid, the whole service
|
|
// config is invalid.
|
|
// - If the list doesn't contain any supported policy, the whole service config
|
|
// is invalid.
|
|
type LoadBalancingConfig struct {
|
|
// Exactly one LB policy may be configured.
|
|
//
|
|
// Types that are valid to be assigned to Policy:
|
|
// *LoadBalancingConfig_PickFirst
|
|
// *LoadBalancingConfig_RoundRobin
|
|
// *LoadBalancingConfig_Grpclb
|
|
// *LoadBalancingConfig_Priority
|
|
// *LoadBalancingConfig_WeightedTarget
|
|
// *LoadBalancingConfig_Cds
|
|
// *LoadBalancingConfig_Eds
|
|
// *LoadBalancingConfig_Lrs
|
|
// *LoadBalancingConfig_Xds
|
|
// *LoadBalancingConfig_XdsExperimental
|
|
Policy isLoadBalancingConfig_Policy `protobuf_oneof:"policy"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *LoadBalancingConfig) Reset() { *m = LoadBalancingConfig{} }
|
|
func (m *LoadBalancingConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*LoadBalancingConfig) ProtoMessage() {}
|
|
func (*LoadBalancingConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{10}
|
|
}
|
|
|
|
func (m *LoadBalancingConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_LoadBalancingConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *LoadBalancingConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_LoadBalancingConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *LoadBalancingConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LoadBalancingConfig.Merge(m, src)
|
|
}
|
|
func (m *LoadBalancingConfig) XXX_Size() int {
|
|
return xxx_messageInfo_LoadBalancingConfig.Size(m)
|
|
}
|
|
func (m *LoadBalancingConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LoadBalancingConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LoadBalancingConfig proto.InternalMessageInfo
|
|
|
|
type isLoadBalancingConfig_Policy interface {
|
|
isLoadBalancingConfig_Policy()
|
|
}
|
|
|
|
type LoadBalancingConfig_PickFirst struct {
|
|
PickFirst *PickFirstConfig `protobuf:"bytes,4,opt,name=pick_first,proto3,oneof"`
|
|
}
|
|
|
|
type LoadBalancingConfig_RoundRobin struct {
|
|
RoundRobin *RoundRobinConfig `protobuf:"bytes,1,opt,name=round_robin,proto3,oneof"`
|
|
}
|
|
|
|
type LoadBalancingConfig_Grpclb struct {
|
|
Grpclb *GrpcLbConfig `protobuf:"bytes,3,opt,name=grpclb,proto3,oneof"`
|
|
}
|
|
|
|
type LoadBalancingConfig_Priority struct {
|
|
Priority *PriorityLoadBalancingPolicyConfig `protobuf:"bytes,9,opt,name=priority,proto3,oneof"`
|
|
}
|
|
|
|
type LoadBalancingConfig_WeightedTarget struct {
|
|
WeightedTarget *WeightedTargetLoadBalancingPolicyConfig `protobuf:"bytes,10,opt,name=weighted_target,json=weightedTarget,proto3,oneof"`
|
|
}
|
|
|
|
type LoadBalancingConfig_Cds struct {
|
|
Cds *CdsConfig `protobuf:"bytes,6,opt,name=cds,proto3,oneof"`
|
|
}
|
|
|
|
type LoadBalancingConfig_Eds struct {
|
|
Eds *EdsLoadBalancingPolicyConfig `protobuf:"bytes,7,opt,name=eds,proto3,oneof"`
|
|
}
|
|
|
|
type LoadBalancingConfig_Lrs struct {
|
|
Lrs *LrsLoadBalancingPolicyConfig `protobuf:"bytes,8,opt,name=lrs,proto3,oneof"`
|
|
}
|
|
|
|
type LoadBalancingConfig_Xds struct {
|
|
Xds *XdsConfig `protobuf:"bytes,2,opt,name=xds,proto3,oneof"`
|
|
}
|
|
|
|
type LoadBalancingConfig_XdsExperimental struct {
|
|
XdsExperimental *XdsConfig `protobuf:"bytes,5,opt,name=xds_experimental,proto3,oneof"`
|
|
}
|
|
|
|
func (*LoadBalancingConfig_PickFirst) isLoadBalancingConfig_Policy() {}
|
|
|
|
func (*LoadBalancingConfig_RoundRobin) isLoadBalancingConfig_Policy() {}
|
|
|
|
func (*LoadBalancingConfig_Grpclb) isLoadBalancingConfig_Policy() {}
|
|
|
|
func (*LoadBalancingConfig_Priority) isLoadBalancingConfig_Policy() {}
|
|
|
|
func (*LoadBalancingConfig_WeightedTarget) isLoadBalancingConfig_Policy() {}
|
|
|
|
func (*LoadBalancingConfig_Cds) isLoadBalancingConfig_Policy() {}
|
|
|
|
func (*LoadBalancingConfig_Eds) isLoadBalancingConfig_Policy() {}
|
|
|
|
func (*LoadBalancingConfig_Lrs) isLoadBalancingConfig_Policy() {}
|
|
|
|
func (*LoadBalancingConfig_Xds) isLoadBalancingConfig_Policy() {}
|
|
|
|
func (*LoadBalancingConfig_XdsExperimental) isLoadBalancingConfig_Policy() {}
|
|
|
|
func (m *LoadBalancingConfig) GetPolicy() isLoadBalancingConfig_Policy {
|
|
if m != nil {
|
|
return m.Policy
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LoadBalancingConfig) GetPickFirst() *PickFirstConfig {
|
|
if x, ok := m.GetPolicy().(*LoadBalancingConfig_PickFirst); ok {
|
|
return x.PickFirst
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LoadBalancingConfig) GetRoundRobin() *RoundRobinConfig {
|
|
if x, ok := m.GetPolicy().(*LoadBalancingConfig_RoundRobin); ok {
|
|
return x.RoundRobin
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LoadBalancingConfig) GetGrpclb() *GrpcLbConfig {
|
|
if x, ok := m.GetPolicy().(*LoadBalancingConfig_Grpclb); ok {
|
|
return x.Grpclb
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LoadBalancingConfig) GetPriority() *PriorityLoadBalancingPolicyConfig {
|
|
if x, ok := m.GetPolicy().(*LoadBalancingConfig_Priority); ok {
|
|
return x.Priority
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LoadBalancingConfig) GetWeightedTarget() *WeightedTargetLoadBalancingPolicyConfig {
|
|
if x, ok := m.GetPolicy().(*LoadBalancingConfig_WeightedTarget); ok {
|
|
return x.WeightedTarget
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LoadBalancingConfig) GetCds() *CdsConfig {
|
|
if x, ok := m.GetPolicy().(*LoadBalancingConfig_Cds); ok {
|
|
return x.Cds
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LoadBalancingConfig) GetEds() *EdsLoadBalancingPolicyConfig {
|
|
if x, ok := m.GetPolicy().(*LoadBalancingConfig_Eds); ok {
|
|
return x.Eds
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LoadBalancingConfig) GetLrs() *LrsLoadBalancingPolicyConfig {
|
|
if x, ok := m.GetPolicy().(*LoadBalancingConfig_Lrs); ok {
|
|
return x.Lrs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Deprecated: Do not use.
|
|
func (m *LoadBalancingConfig) GetXds() *XdsConfig {
|
|
if x, ok := m.GetPolicy().(*LoadBalancingConfig_Xds); ok {
|
|
return x.Xds
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Deprecated: Do not use.
|
|
func (m *LoadBalancingConfig) GetXdsExperimental() *XdsConfig {
|
|
if x, ok := m.GetPolicy().(*LoadBalancingConfig_XdsExperimental); ok {
|
|
return x.XdsExperimental
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// XXX_OneofWrappers is for the internal use of the proto package.
|
|
func (*LoadBalancingConfig) XXX_OneofWrappers() []interface{} {
|
|
return []interface{}{
|
|
(*LoadBalancingConfig_PickFirst)(nil),
|
|
(*LoadBalancingConfig_RoundRobin)(nil),
|
|
(*LoadBalancingConfig_Grpclb)(nil),
|
|
(*LoadBalancingConfig_Priority)(nil),
|
|
(*LoadBalancingConfig_WeightedTarget)(nil),
|
|
(*LoadBalancingConfig_Cds)(nil),
|
|
(*LoadBalancingConfig_Eds)(nil),
|
|
(*LoadBalancingConfig_Lrs)(nil),
|
|
(*LoadBalancingConfig_Xds)(nil),
|
|
(*LoadBalancingConfig_XdsExperimental)(nil),
|
|
}
|
|
}
|
|
|
|
// A ServiceConfig represents information about a service but is not specific to
|
|
// any name resolver.
|
|
type ServiceConfig struct {
|
|
LoadBalancingPolicy ServiceConfig_LoadBalancingPolicy `protobuf:"varint,1,opt,name=load_balancing_policy,json=loadBalancingPolicy,proto3,enum=grpc.service_config.ServiceConfig_LoadBalancingPolicy" json:"load_balancing_policy,omitempty"` // Deprecated: Do not use.
|
|
// Multiple LB policies can be specified; clients will iterate through
|
|
// the list in order and stop at the first policy that they support. If none
|
|
// are supported, the service config is considered invalid.
|
|
LoadBalancingConfig []*LoadBalancingConfig `protobuf:"bytes,4,rep,name=load_balancing_config,json=loadBalancingConfig,proto3" json:"load_balancing_config,omitempty"`
|
|
// Per-method configuration.
|
|
MethodConfig []*MethodConfig `protobuf:"bytes,2,rep,name=method_config,json=methodConfig,proto3" json:"method_config,omitempty"`
|
|
RetryThrottling *ServiceConfig_RetryThrottlingPolicy `protobuf:"bytes,3,opt,name=retry_throttling,json=retryThrottling,proto3" json:"retry_throttling,omitempty"`
|
|
HealthCheckConfig *ServiceConfig_HealthCheckConfig `protobuf:"bytes,5,opt,name=health_check_config,json=healthCheckConfig,proto3" json:"health_check_config,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ServiceConfig) Reset() { *m = ServiceConfig{} }
|
|
func (m *ServiceConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*ServiceConfig) ProtoMessage() {}
|
|
func (*ServiceConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{11}
|
|
}
|
|
|
|
func (m *ServiceConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_ServiceConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *ServiceConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_ServiceConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *ServiceConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ServiceConfig.Merge(m, src)
|
|
}
|
|
func (m *ServiceConfig) XXX_Size() int {
|
|
return xxx_messageInfo_ServiceConfig.Size(m)
|
|
}
|
|
func (m *ServiceConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ServiceConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ServiceConfig proto.InternalMessageInfo
|
|
|
|
// Deprecated: Do not use.
|
|
func (m *ServiceConfig) GetLoadBalancingPolicy() ServiceConfig_LoadBalancingPolicy {
|
|
if m != nil {
|
|
return m.LoadBalancingPolicy
|
|
}
|
|
return ServiceConfig_UNSPECIFIED
|
|
}
|
|
|
|
func (m *ServiceConfig) GetLoadBalancingConfig() []*LoadBalancingConfig {
|
|
if m != nil {
|
|
return m.LoadBalancingConfig
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ServiceConfig) GetMethodConfig() []*MethodConfig {
|
|
if m != nil {
|
|
return m.MethodConfig
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ServiceConfig) GetRetryThrottling() *ServiceConfig_RetryThrottlingPolicy {
|
|
if m != nil {
|
|
return m.RetryThrottling
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ServiceConfig) GetHealthCheckConfig() *ServiceConfig_HealthCheckConfig {
|
|
if m != nil {
|
|
return m.HealthCheckConfig
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// If a RetryThrottlingPolicy is provided, gRPC will automatically throttle
|
|
// retry attempts and hedged RPCs when the client's ratio of failures to
|
|
// successes exceeds a threshold.
|
|
//
|
|
// For each server name, the gRPC client will maintain a token_count which is
|
|
// initially set to max_tokens. Every outgoing RPC (regardless of service or
|
|
// method invoked) will change token_count as follows:
|
|
//
|
|
// - Every failed RPC will decrement the token_count by 1.
|
|
// - Every successful RPC will increment the token_count by token_ratio.
|
|
//
|
|
// If token_count is less than or equal to max_tokens / 2, then RPCs will not
|
|
// be retried and hedged RPCs will not be sent.
|
|
type ServiceConfig_RetryThrottlingPolicy struct {
|
|
// The number of tokens starts at max_tokens. The token_count will always be
|
|
// between 0 and max_tokens.
|
|
//
|
|
// This field is required and must be greater than zero.
|
|
MaxTokens uint32 `protobuf:"varint,1,opt,name=max_tokens,json=maxTokens,proto3" json:"max_tokens,omitempty"`
|
|
// The amount of tokens to add on each successful RPC. Typically this will
|
|
// be some number between 0 and 1, e.g., 0.1.
|
|
//
|
|
// This field is required and must be greater than zero. Up to 3 decimal
|
|
// places are supported.
|
|
TokenRatio float32 `protobuf:"fixed32,2,opt,name=token_ratio,json=tokenRatio,proto3" json:"token_ratio,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ServiceConfig_RetryThrottlingPolicy) Reset() { *m = ServiceConfig_RetryThrottlingPolicy{} }
|
|
func (m *ServiceConfig_RetryThrottlingPolicy) String() string { return proto.CompactTextString(m) }
|
|
func (*ServiceConfig_RetryThrottlingPolicy) ProtoMessage() {}
|
|
func (*ServiceConfig_RetryThrottlingPolicy) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{11, 0}
|
|
}
|
|
|
|
func (m *ServiceConfig_RetryThrottlingPolicy) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_ServiceConfig_RetryThrottlingPolicy.Unmarshal(m, b)
|
|
}
|
|
func (m *ServiceConfig_RetryThrottlingPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_ServiceConfig_RetryThrottlingPolicy.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *ServiceConfig_RetryThrottlingPolicy) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ServiceConfig_RetryThrottlingPolicy.Merge(m, src)
|
|
}
|
|
func (m *ServiceConfig_RetryThrottlingPolicy) XXX_Size() int {
|
|
return xxx_messageInfo_ServiceConfig_RetryThrottlingPolicy.Size(m)
|
|
}
|
|
func (m *ServiceConfig_RetryThrottlingPolicy) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ServiceConfig_RetryThrottlingPolicy.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ServiceConfig_RetryThrottlingPolicy proto.InternalMessageInfo
|
|
|
|
func (m *ServiceConfig_RetryThrottlingPolicy) GetMaxTokens() uint32 {
|
|
if m != nil {
|
|
return m.MaxTokens
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ServiceConfig_RetryThrottlingPolicy) GetTokenRatio() float32 {
|
|
if m != nil {
|
|
return m.TokenRatio
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type ServiceConfig_HealthCheckConfig struct {
|
|
// Service name to use in the health-checking request.
|
|
ServiceName *wrappers.StringValue `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ServiceConfig_HealthCheckConfig) Reset() { *m = ServiceConfig_HealthCheckConfig{} }
|
|
func (m *ServiceConfig_HealthCheckConfig) String() string { return proto.CompactTextString(m) }
|
|
func (*ServiceConfig_HealthCheckConfig) ProtoMessage() {}
|
|
func (*ServiceConfig_HealthCheckConfig) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_e32d3cb2c41c77ce, []int{11, 1}
|
|
}
|
|
|
|
func (m *ServiceConfig_HealthCheckConfig) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_ServiceConfig_HealthCheckConfig.Unmarshal(m, b)
|
|
}
|
|
func (m *ServiceConfig_HealthCheckConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_ServiceConfig_HealthCheckConfig.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *ServiceConfig_HealthCheckConfig) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ServiceConfig_HealthCheckConfig.Merge(m, src)
|
|
}
|
|
func (m *ServiceConfig_HealthCheckConfig) XXX_Size() int {
|
|
return xxx_messageInfo_ServiceConfig_HealthCheckConfig.Size(m)
|
|
}
|
|
func (m *ServiceConfig_HealthCheckConfig) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ServiceConfig_HealthCheckConfig.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ServiceConfig_HealthCheckConfig proto.InternalMessageInfo
|
|
|
|
func (m *ServiceConfig_HealthCheckConfig) GetServiceName() *wrappers.StringValue {
|
|
if m != nil {
|
|
return m.ServiceName
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterEnum("grpc.service_config.ServiceConfig_LoadBalancingPolicy", ServiceConfig_LoadBalancingPolicy_name, ServiceConfig_LoadBalancingPolicy_value)
|
|
proto.RegisterType((*MethodConfig)(nil), "grpc.service_config.MethodConfig")
|
|
proto.RegisterType((*MethodConfig_Name)(nil), "grpc.service_config.MethodConfig.Name")
|
|
proto.RegisterType((*MethodConfig_RetryPolicy)(nil), "grpc.service_config.MethodConfig.RetryPolicy")
|
|
proto.RegisterType((*MethodConfig_HedgingPolicy)(nil), "grpc.service_config.MethodConfig.HedgingPolicy")
|
|
proto.RegisterType((*PickFirstConfig)(nil), "grpc.service_config.PickFirstConfig")
|
|
proto.RegisterType((*RoundRobinConfig)(nil), "grpc.service_config.RoundRobinConfig")
|
|
proto.RegisterType((*PriorityLoadBalancingPolicyConfig)(nil), "grpc.service_config.PriorityLoadBalancingPolicyConfig")
|
|
proto.RegisterMapType((map[string]*PriorityLoadBalancingPolicyConfig_Child)(nil), "grpc.service_config.PriorityLoadBalancingPolicyConfig.ChildrenEntry")
|
|
proto.RegisterType((*PriorityLoadBalancingPolicyConfig_Child)(nil), "grpc.service_config.PriorityLoadBalancingPolicyConfig.Child")
|
|
proto.RegisterType((*WeightedTargetLoadBalancingPolicyConfig)(nil), "grpc.service_config.WeightedTargetLoadBalancingPolicyConfig")
|
|
proto.RegisterMapType((map[string]*WeightedTargetLoadBalancingPolicyConfig_Target)(nil), "grpc.service_config.WeightedTargetLoadBalancingPolicyConfig.TargetsEntry")
|
|
proto.RegisterType((*WeightedTargetLoadBalancingPolicyConfig_Target)(nil), "grpc.service_config.WeightedTargetLoadBalancingPolicyConfig.Target")
|
|
proto.RegisterType((*GrpcLbConfig)(nil), "grpc.service_config.GrpcLbConfig")
|
|
proto.RegisterType((*CdsConfig)(nil), "grpc.service_config.CdsConfig")
|
|
proto.RegisterType((*XdsConfig)(nil), "grpc.service_config.XdsConfig")
|
|
proto.RegisterType((*EdsLoadBalancingPolicyConfig)(nil), "grpc.service_config.EdsLoadBalancingPolicyConfig")
|
|
proto.RegisterType((*LrsLoadBalancingPolicyConfig)(nil), "grpc.service_config.LrsLoadBalancingPolicyConfig")
|
|
proto.RegisterType((*LrsLoadBalancingPolicyConfig_Locality)(nil), "grpc.service_config.LrsLoadBalancingPolicyConfig.Locality")
|
|
proto.RegisterType((*LoadBalancingConfig)(nil), "grpc.service_config.LoadBalancingConfig")
|
|
proto.RegisterType((*ServiceConfig)(nil), "grpc.service_config.ServiceConfig")
|
|
proto.RegisterType((*ServiceConfig_RetryThrottlingPolicy)(nil), "grpc.service_config.ServiceConfig.RetryThrottlingPolicy")
|
|
proto.RegisterType((*ServiceConfig_HealthCheckConfig)(nil), "grpc.service_config.ServiceConfig.HealthCheckConfig")
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterFile("grpc/service_config/service_config.proto", fileDescriptor_e32d3cb2c41c77ce)
|
|
}
|
|
|
|
var fileDescriptor_e32d3cb2c41c77ce = []byte{
|
|
// 1589 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x5b, 0x73, 0x1a, 0x47,
|
|
0x16, 0x16, 0xa0, 0x1b, 0x07, 0x84, 0x50, 0x6b, 0x25, 0x61, 0xca, 0xab, 0x95, 0xa8, 0xf5, 0x9a,
|
|
0x17, 0xa3, 0x5a, 0x79, 0xcb, 0xeb, 0xd2, 0x6e, 0xed, 0x3a, 0xe8, 0x12, 0x54, 0x91, 0x65, 0xd2,
|
|
0x92, 0x6f, 0x55, 0xa9, 0x1a, 0x0d, 0x33, 0x0d, 0x4c, 0x69, 0x66, 0x9a, 0xf4, 0x34, 0x16, 0xe4,
|
|
0x21, 0x79, 0xcd, 0x2f, 0x49, 0x7e, 0x43, 0xfe, 0x49, 0x9e, 0x52, 0x79, 0xcf, 0x3f, 0xc8, 0x43,
|
|
0x2a, 0xd5, 0x97, 0x41, 0x0c, 0x8c, 0x10, 0xb2, 0xfc, 0xc6, 0x9c, 0xee, 0xef, 0x3b, 0xd7, 0x3e,
|
|
0x7d, 0x1a, 0x28, 0xb7, 0x58, 0xc7, 0xda, 0x09, 0x08, 0xfb, 0xe0, 0x58, 0xc4, 0xb0, 0xa8, 0xdf,
|
|
0x74, 0x5a, 0x23, 0x9f, 0x95, 0x0e, 0xa3, 0x9c, 0xa2, 0x55, 0xb1, 0xb3, 0x12, 0x5d, 0x2a, 0x6e,
|
|
0xb6, 0x28, 0x6d, 0xb9, 0x64, 0x47, 0x6e, 0x69, 0x74, 0x9b, 0x3b, 0x76, 0x97, 0x99, 0xdc, 0xa1,
|
|
0xbe, 0x02, 0x8d, 0xaf, 0x5f, 0x31, 0xb3, 0xd3, 0x21, 0x2c, 0xd0, 0xeb, 0x6b, 0x7a, 0x5d, 0x18,
|
|
0x61, 0x51, 0x9b, 0x28, 0x71, 0xe9, 0x97, 0x45, 0xc8, 0xbe, 0x24, 0xbc, 0x4d, 0xed, 0x7d, 0xa9,
|
|
0x07, 0xed, 0xc1, 0xac, 0x6f, 0x7a, 0xa4, 0x90, 0xd8, 0x4a, 0x95, 0x33, 0xbb, 0xff, 0xa8, 0xc4,
|
|
0xd8, 0x52, 0x19, 0x06, 0x54, 0x4e, 0x4d, 0x8f, 0x60, 0x89, 0x41, 0x2f, 0x20, 0x77, 0x65, 0x3a,
|
|
0xdc, 0x68, 0x52, 0x66, 0x30, 0x62, 0xda, 0xfd, 0x42, 0x72, 0x2b, 0x51, 0xce, 0xec, 0x16, 0x2b,
|
|
0x4a, 0x79, 0x25, 0x34, 0xae, 0x52, 0xa5, 0xd4, 0x7d, 0x63, 0xba, 0x5d, 0x82, 0xb3, 0x02, 0x71,
|
|
0x44, 0x19, 0x16, 0xfb, 0xd1, 0x53, 0x58, 0xe0, 0x8e, 0x47, 0x68, 0x97, 0x17, 0x52, 0x12, 0xfa,
|
|
0x60, 0x0c, 0x7a, 0xa0, 0xfd, 0xc6, 0xe1, 0x4e, 0xf4, 0x16, 0x1e, 0x78, 0x66, 0xcf, 0x60, 0xe4,
|
|
0xeb, 0x2e, 0x09, 0xb8, 0xe1, 0x91, 0x20, 0x30, 0x5b, 0xc4, 0x68, 0xf4, 0x39, 0x09, 0x0a, 0xb3,
|
|
0x92, 0xe6, 0xe1, 0x18, 0xcd, 0xeb, 0x63, 0x9f, 0x3f, 0xdd, 0x55, 0x36, 0xac, 0x7b, 0x66, 0x0f,
|
|
0x2b, 0xf4, 0x4b, 0x05, 0xae, 0x0a, 0x2c, 0x7a, 0x0f, 0x45, 0x45, 0x1c, 0x74, 0xa8, 0x1f, 0x90,
|
|
0x11, 0xe6, 0xb9, 0x29, 0x98, 0x37, 0x24, 0xb3, 0x82, 0x47, 0xa8, 0x31, 0x64, 0x19, 0xe1, 0xac,
|
|
0x6f, 0x74, 0xa8, 0xeb, 0x58, 0xfd, 0xc2, 0xbc, 0x24, 0x7b, 0x72, 0x7b, 0xb8, 0xb1, 0x40, 0xd5,
|
|
0x25, 0xa8, 0x36, 0x83, 0x33, 0xec, 0xfa, 0x13, 0xbd, 0x83, 0x5c, 0x9b, 0xd8, 0x2d, 0xc7, 0x6f,
|
|
0x85, 0xac, 0x0b, 0x92, 0x75, 0xe7, 0x76, 0xd6, 0x9a, 0xc2, 0x0d, 0x78, 0x97, 0xda, 0xc3, 0x82,
|
|
0xe2, 0x73, 0x98, 0x15, 0x69, 0x46, 0x05, 0x58, 0xd0, 0x2c, 0x85, 0xc4, 0x56, 0xa2, 0x9c, 0xc6,
|
|
0xe1, 0x27, 0x5a, 0x87, 0x79, 0x4f, 0x12, 0xca, 0x94, 0xa7, 0xb1, 0xfe, 0x2a, 0xfe, 0x98, 0x84,
|
|
0xcc, 0x90, 0xc9, 0x68, 0x1b, 0xb2, 0x22, 0xa4, 0x26, 0xe7, 0xc4, 0xeb, 0xf0, 0x40, 0xd2, 0x2c,
|
|
0xe1, 0x8c, 0x67, 0xf6, 0x3e, 0xd3, 0x22, 0x54, 0x85, 0x65, 0xc7, 0x77, 0xb8, 0x63, 0xba, 0x46,
|
|
0xc3, 0xb4, 0x2e, 0x69, 0xb3, 0xa9, 0xcb, 0x68, 0x42, 0x2d, 0xe4, 0x34, 0xa2, 0xaa, 0x00, 0x68,
|
|
0x0f, 0x04, 0xe5, 0x00, 0x7f, 0x6b, 0x2d, 0x81, 0x67, 0xf6, 0x42, 0xec, 0x13, 0x40, 0x1a, 0x67,
|
|
0x78, 0x5d, 0x97, 0x3b, 0x1d, 0xd7, 0x21, 0x4c, 0xd6, 0x51, 0x12, 0xaf, 0xe8, 0x95, 0x97, 0x83,
|
|
0x05, 0x74, 0x04, 0xeb, 0x32, 0x09, 0x66, 0xc3, 0x25, 0x46, 0xc0, 0x4d, 0xde, 0x0d, 0x0c, 0x71,
|
|
0xc0, 0x44, 0x81, 0xa4, 0xca, 0xb9, 0xdd, 0x7c, 0xa8, 0x55, 0xe4, 0x60, 0x9f, 0xda, 0x04, 0xff,
|
|
0x65, 0xb0, 0xff, 0x4c, 0x6e, 0x17, 0xc2, 0xa0, 0xf8, 0x53, 0x02, 0x96, 0x22, 0x69, 0x98, 0x26,
|
|
0x56, 0xff, 0x83, 0x30, 0x53, 0x86, 0x4d, 0x5c, 0xb3, 0x7f, 0x7b, 0xa4, 0xb2, 0x7a, 0xff, 0x81,
|
|
0xd8, 0x8e, 0x0e, 0x61, 0xdd, 0xa7, 0xbe, 0xd1, 0x34, 0xb9, 0xe9, 0x46, 0x8d, 0x4f, 0xdd, 0x60,
|
|
0xfc, 0xaa, 0x4f, 0xfd, 0x23, 0xb1, 0x7d, 0xc8, 0xf6, 0xea, 0x03, 0xd8, 0x50, 0xd5, 0x4c, 0x99,
|
|
0x11, 0x2d, 0xc1, 0xd2, 0x0a, 0x2c, 0xd7, 0x1d, 0xeb, 0xf2, 0xc8, 0x61, 0x01, 0x57, 0xc5, 0x56,
|
|
0x42, 0x90, 0xc7, 0xb4, 0xeb, 0xdb, 0x98, 0x36, 0x1c, 0x5f, 0xcb, 0x7e, 0x4b, 0xc2, 0x76, 0x9d,
|
|
0x39, 0x94, 0x39, 0xbc, 0x7f, 0x42, 0x4d, 0xbb, 0x6a, 0xba, 0xa6, 0x6f, 0x0d, 0x62, 0xa1, 0x9b,
|
|
0xd3, 0x05, 0x2c, 0x5a, 0x6d, 0xc7, 0xb5, 0x19, 0xf1, 0x75, 0x83, 0x3a, 0x88, 0xad, 0xed, 0x5b,
|
|
0x99, 0x2a, 0xfb, 0x9a, 0xe6, 0xd0, 0xe7, 0xac, 0x8f, 0x07, 0xac, 0x68, 0x13, 0xa0, 0xa3, 0xc0,
|
|
0x0e, 0x09, 0x0a, 0xc9, 0xad, 0x54, 0x39, 0x8d, 0x87, 0x24, 0xc5, 0x63, 0x98, 0x93, 0x50, 0xf4,
|
|
0x02, 0xe6, 0x95, 0x32, 0x6d, 0x48, 0x39, 0xd6, 0x90, 0x88, 0x01, 0x4a, 0x35, 0xd6, 0xb8, 0x62,
|
|
0x1f, 0x96, 0x22, 0x56, 0xa0, 0x3c, 0xa4, 0x2e, 0x49, 0x5f, 0x9f, 0x2c, 0xf1, 0x13, 0x61, 0x98,
|
|
0xfb, 0x20, 0xfa, 0x88, 0x4e, 0xeb, 0x7f, 0xef, 0xe3, 0x2c, 0x56, 0x54, 0x7b, 0xc9, 0xe7, 0x89,
|
|
0xd2, 0x1f, 0x49, 0x78, 0xfc, 0x96, 0x38, 0xad, 0x36, 0x27, 0xf6, 0xb9, 0xc9, 0x5a, 0x84, 0xdf,
|
|
0x1c, 0x73, 0x0b, 0x16, 0xb8, 0xdc, 0x12, 0x68, 0x4f, 0x8f, 0x63, 0xad, 0x98, 0x92, 0xae, 0xa2,
|
|
0xd6, 0x03, 0x15, 0xf7, 0x90, 0xb9, 0xe8, 0xc1, 0xbc, 0x5a, 0x10, 0x8d, 0xe4, 0x4a, 0x52, 0xe9,
|
|
0x72, 0xd7, 0x5f, 0xe8, 0x0b, 0xc8, 0xca, 0x24, 0x85, 0xad, 0x2d, 0x79, 0xc7, 0xa8, 0x67, 0x24,
|
|
0x5a, 0xf7, 0xb3, 0xef, 0x20, 0x3b, 0x6c, 0x47, 0x4c, 0xe4, 0xdf, 0x47, 0x23, 0xbf, 0xff, 0x09,
|
|
0x7c, 0x1e, 0x4e, 0xc0, 0xb7, 0x90, 0xfd, 0x9c, 0x75, 0xac, 0x93, 0x86, 0x0e, 0xf2, 0xa8, 0x77,
|
|
0x89, 0x7b, 0x78, 0x27, 0xfa, 0x46, 0x08, 0x91, 0x57, 0xb9, 0xea, 0xc8, 0x19, 0x2d, 0x13, 0x8d,
|
|
0xbc, 0xf4, 0x08, 0xd2, 0xfb, 0x76, 0xa0, 0x95, 0x17, 0x60, 0xc1, 0x72, 0xbb, 0x01, 0x27, 0x2c,
|
|
0xec, 0xea, 0xfa, 0xb3, 0xf4, 0x6b, 0x12, 0xd2, 0xef, 0x06, 0xfb, 0x1e, 0xc3, 0x52, 0x43, 0xea,
|
|
0x25, 0xcc, 0xd0, 0x33, 0x42, 0xa2, 0x9c, 0xae, 0x26, 0x0b, 0x09, 0x9c, 0x0d, 0x17, 0xe4, 0x35,
|
|
0xf1, 0x29, 0x73, 0x85, 0xbe, 0x84, 0xe5, 0xa6, 0xe9, 0xba, 0xa2, 0xf1, 0x86, 0x7c, 0xa9, 0x3b,
|
|
0xf2, 0xe5, 0x42, 0x02, 0x4d, 0x59, 0x86, 0x3c, 0xb1, 0x03, 0x23, 0x12, 0xa4, 0x59, 0xe9, 0x79,
|
|
0x8e, 0xd8, 0xc1, 0xd9, 0x75, 0x9c, 0xd0, 0x05, 0x6c, 0xba, 0x2c, 0x30, 0x5c, 0x6a, 0xda, 0x06,
|
|
0x23, 0x1d, 0xca, 0xb8, 0x68, 0x6d, 0x02, 0x18, 0xc6, 0xe0, 0xa6, 0x29, 0xe0, 0x8c, 0x33, 0xc7,
|
|
0x6f, 0xa9, 0x29, 0xa0, 0xe8, 0xb2, 0x40, 0xd8, 0x85, 0x43, 0x86, 0x33, 0x49, 0x20, 0x33, 0xf1,
|
|
0x7d, 0x0a, 0x1e, 0x1e, 0xda, 0xc1, 0xcd, 0xe7, 0xef, 0xc6, 0xec, 0xc4, 0xba, 0x91, 0xfc, 0x48,
|
|
0x37, 0x52, 0xf7, 0x73, 0x03, 0x5d, 0xc0, 0x86, 0x4b, 0x2d, 0xd3, 0x75, 0x78, 0xdf, 0xe8, 0x38,
|
|
0xd6, 0xe5, 0xd0, 0x10, 0x32, 0x7b, 0xc7, 0x6c, 0xad, 0x85, 0x44, 0x75, 0xc5, 0xa3, 0x93, 0x76,
|
|
0x01, 0x1b, 0xc4, 0xb7, 0x3b, 0xd4, 0xf1, 0xf9, 0xa8, 0x86, 0xb9, 0xbb, 0x6a, 0x08, 0x89, 0x22,
|
|
0x1a, 0x4a, 0x3f, 0xa4, 0xe0, 0xe1, 0x09, 0x9b, 0x90, 0x8a, 0x6d, 0xc8, 0xea, 0xd8, 0x0f, 0xd5,
|
|
0x3f, 0xce, 0x68, 0x99, 0x8c, 0xc3, 0xf4, 0x39, 0xa9, 0x4e, 0x95, 0x93, 0xf4, 0xc4, 0xa8, 0xbf,
|
|
0x81, 0xc5, 0x30, 0x58, 0x7a, 0xd0, 0xdd, 0x8b, 0x0f, 0xc2, 0x04, 0xaf, 0x2a, 0x27, 0x9a, 0x01,
|
|
0x0f, 0xb8, 0xc6, 0x0e, 0xf0, 0xdc, 0x7d, 0x9a, 0x6d, 0x1d, 0x16, 0x43, 0x15, 0xa2, 0xbb, 0x33,
|
|
0xd2, 0x72, 0xa8, 0xaf, 0x63, 0xa7, 0xbf, 0x10, 0x82, 0xd9, 0x6f, 0xa8, 0x1f, 0x86, 0x4a, 0xfe,
|
|
0x96, 0xc3, 0x66, 0xb7, 0x21, 0xc5, 0x29, 0x3d, 0x6c, 0xaa, 0xcf, 0xd2, 0xef, 0x73, 0xb0, 0x1a,
|
|
0xa3, 0x16, 0x1d, 0x01, 0x88, 0xca, 0x30, 0x9a, 0x62, 0xd8, 0xd0, 0x01, 0xf9, 0x7b, 0xfc, 0x9d,
|
|
0x19, 0x1d, 0x49, 0x6a, 0x33, 0x78, 0x08, 0x89, 0x8e, 0x21, 0xc3, 0xc4, 0x80, 0x62, 0x30, 0x31,
|
|
0xa1, 0x48, 0x53, 0x33, 0xbb, 0x8f, 0x62, 0x89, 0x46, 0x07, 0x19, 0x39, 0x93, 0x5f, 0x63, 0xd1,
|
|
0x7f, 0x60, 0x5e, 0xc0, 0xdc, 0x86, 0x3e, 0x61, 0xdb, 0xb1, 0x2c, 0xc3, 0x77, 0x41, 0x6d, 0x06,
|
|
0x6b, 0x08, 0x3a, 0x87, 0x45, 0x3d, 0x7a, 0xf4, 0x0b, 0x69, 0x09, 0x7f, 0xf6, 0x71, 0x13, 0x40,
|
|
0x6d, 0x06, 0x0f, 0x98, 0x50, 0x0b, 0x96, 0xaf, 0xf4, 0xc5, 0x65, 0xa8, 0xfb, 0xb7, 0x00, 0x13,
|
|
0xc6, 0x8b, 0x29, 0x2f, 0xb9, 0xda, 0x0c, 0xce, 0x5d, 0x45, 0xb6, 0xa2, 0x5d, 0x48, 0x59, 0x76,
|
|
0xa0, 0x9f, 0x36, 0x9b, 0xb1, 0xe4, 0x83, 0x4b, 0xa8, 0x36, 0x83, 0xc5, 0x66, 0x74, 0x08, 0x29,
|
|
0x62, 0x07, 0xfa, 0xe1, 0xf2, 0xcf, 0x58, 0xcc, 0xa4, 0x6e, 0x29, 0x68, 0x88, 0xa2, 0x71, 0x59,
|
|
0x50, 0x58, 0x9c, 0x40, 0x33, 0xe9, 0x4c, 0x08, 0x1a, 0x97, 0x05, 0xe8, 0x19, 0xa4, 0x7a, 0x76,
|
|
0xa0, 0x67, 0x80, 0x78, 0x0f, 0x06, 0xd7, 0xa3, 0xb8, 0x07, 0x05, 0xae, 0x67, 0x07, 0xa8, 0x0e,
|
|
0xf9, 0x9e, 0x1d, 0x18, 0xa4, 0xd7, 0x21, 0xcc, 0xf1, 0x88, 0xcf, 0x4d, 0x57, 0x5f, 0x14, 0xd3,
|
|
0x91, 0x8c, 0xa1, 0xab, 0x8b, 0x30, 0xaf, 0x07, 0xea, 0x9f, 0xe7, 0x60, 0x49, 0xf7, 0x11, 0x5d,
|
|
0xf6, 0x3e, 0xac, 0xc9, 0x2e, 0xd2, 0x08, 0x5d, 0xb9, 0x9e, 0x22, 0x12, 0xe5, 0xdc, 0x0d, 0x35,
|
|
0x13, 0xa1, 0xa8, 0xc4, 0x44, 0x42, 0xde, 0xeb, 0xab, 0xee, 0xf8, 0x02, 0xfa, 0x6a, 0x4c, 0x9f,
|
|
0x9e, 0x84, 0xef, 0xda, 0xe9, 0xa3, 0xec, 0x83, 0x43, 0xbc, 0xa4, 0xde, 0x8e, 0x21, 0xab, 0x9a,
|
|
0x1e, 0xb6, 0x6f, 0x7d, 0xc4, 0xe2, 0xac, 0x37, 0xfc, 0x47, 0x86, 0x05, 0x79, 0xf5, 0x26, 0xe1,
|
|
0x6d, 0x46, 0x39, 0x77, 0x1d, 0xbf, 0xa5, 0xcf, 0xe0, 0xf3, 0x29, 0x02, 0x22, 0xdf, 0xac, 0xe7,
|
|
0x03, 0xa4, 0xf2, 0x1c, 0x2f, 0xb3, 0xa8, 0x18, 0xd9, 0xb0, 0xda, 0x26, 0xa6, 0xcb, 0xdb, 0x86,
|
|
0xd5, 0x26, 0xd6, 0x65, 0x68, 0xb2, 0xca, 0xf5, 0xbf, 0xa6, 0xd0, 0x53, 0x93, 0xe8, 0x7d, 0x01,
|
|
0xd6, 0x5e, 0xac, 0xb4, 0x47, 0x45, 0xc5, 0xb7, 0xb0, 0x16, 0x6b, 0x0f, 0xfa, 0x2b, 0x88, 0x87,
|
|
0xab, 0xc1, 0xe9, 0x25, 0xf1, 0xc3, 0xf7, 0x61, 0xda, 0x33, 0x7b, 0xe7, 0x52, 0x80, 0xfe, 0x06,
|
|
0x19, 0xb9, 0x64, 0xc8, 0xb7, 0x9f, 0x2c, 0xe3, 0x24, 0x06, 0x29, 0xc2, 0x42, 0x52, 0x3c, 0x87,
|
|
0x95, 0x31, 0x03, 0xd0, 0xff, 0x47, 0xc6, 0xc7, 0xc4, 0x14, 0xa3, 0x41, 0x64, 0xb8, 0xfc, 0xf7,
|
|
0x48, 0x77, 0xd6, 0xc6, 0x2e, 0x43, 0xe6, 0xf5, 0xe9, 0x59, 0xfd, 0x70, 0xff, 0xf8, 0xe8, 0xf8,
|
|
0xf0, 0x20, 0x3f, 0x23, 0x04, 0xf8, 0xd5, 0xeb, 0xd3, 0x03, 0x03, 0xbf, 0xaa, 0x1e, 0x9f, 0xe6,
|
|
0x13, 0xd5, 0x27, 0xb0, 0xe6, 0xd0, 0x48, 0xd0, 0x54, 0xcc, 0xaa, 0x28, 0x12, 0xb4, 0xba, 0xb0,
|
|
0xa0, 0x9e, 0x68, 0xcc, 0x4b, 0x53, 0x9e, 0xfe, 0x19, 0x00, 0x00, 0xff, 0xff, 0xae, 0xd3, 0x19,
|
|
0x42, 0x5a, 0x13, 0x00, 0x00,
|
|
}
|