| // 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{7, 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 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{3} |
| } |
| |
| 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{4} |
| } |
| |
| 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{5} |
| } |
| |
| 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 |
| } |
| |
| // 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_Cds |
| // *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{6} |
| } |
| |
| 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_Cds struct { |
| Cds *CdsConfig `protobuf:"bytes,6,opt,name=cds,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_Cds) 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) GetCds() *CdsConfig { |
| if x, ok := m.GetPolicy().(*LoadBalancingConfig_Cds); ok { |
| return x.Cds |
| } |
| return nil |
| } |
| |
| func (m *LoadBalancingConfig) GetXds() *XdsConfig { |
| if x, ok := m.GetPolicy().(*LoadBalancingConfig_Xds); ok { |
| return x.Xds |
| } |
| return nil |
| } |
| |
| 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_Cds)(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{7} |
| } |
| |
| 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{7, 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{7, 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((*GrpcLbConfig)(nil), "grpc.service_config.GrpcLbConfig") |
| proto.RegisterType((*CdsConfig)(nil), "grpc.service_config.CdsConfig") |
| proto.RegisterType((*XdsConfig)(nil), "grpc.service_config.XdsConfig") |
| 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{ |
| // 1161 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xdb, 0x6e, 0x23, 0x45, |
| 0x10, 0x8d, 0xed, 0x6c, 0xb2, 0x2e, 0x5f, 0xe2, 0x74, 0x48, 0xd6, 0x6b, 0xc1, 0x92, 0x44, 0x2c, |
| 0xf8, 0x25, 0x8e, 0xe4, 0x20, 0x58, 0x2d, 0x12, 0x17, 0x27, 0x31, 0x8e, 0x48, 0xb2, 0xa1, 0x93, |
| 0xb0, 0x41, 0x42, 0x6a, 0xda, 0x33, 0x6d, 0x7b, 0x94, 0x99, 0xe9, 0xa1, 0xa7, 0xcd, 0x3a, 0x2f, |
| 0xfc, 0x0d, 0xe2, 0x1b, 0xf8, 0x13, 0x9e, 0x10, 0x9f, 0x82, 0xfa, 0x32, 0x8e, 0xc7, 0xf6, 0xe2, |
| 0xac, 0x78, 0x9c, 0xaa, 0x3a, 0xa7, 0xab, 0xab, 0x4e, 0x55, 0x0f, 0xd4, 0xfb, 0x22, 0x72, 0xf6, |
| 0x63, 0x26, 0x7e, 0xf5, 0x1c, 0x46, 0x1c, 0x1e, 0xf6, 0xbc, 0xfe, 0xd4, 0x67, 0x23, 0x12, 0x5c, |
| 0x72, 0xb4, 0xa1, 0x22, 0x1b, 0x69, 0x57, 0xed, 0x59, 0x9f, 0xf3, 0xbe, 0xcf, 0xf6, 0x75, 0x48, |
| 0x77, 0xd8, 0xdb, 0x77, 0x87, 0x82, 0x4a, 0x8f, 0x87, 0x06, 0x34, 0xeb, 0x7f, 0x23, 0x68, 0x14, |
| 0x31, 0x11, 0x5b, 0xff, 0xa6, 0xf5, 0xab, 0x24, 0x1c, 0xee, 0x32, 0x63, 0xde, 0xfd, 0xfb, 0x31, |
| 0x14, 0xcf, 0x98, 0x1c, 0x70, 0xf7, 0x50, 0x9f, 0x83, 0x5e, 0xc2, 0x72, 0x48, 0x03, 0x56, 0xcd, |
| 0x6c, 0xe7, 0xea, 0x85, 0xe6, 0xc7, 0x8d, 0x39, 0xb9, 0x34, 0x26, 0x01, 0x8d, 0x73, 0x1a, 0x30, |
| 0xac, 0x31, 0xe8, 0x6b, 0x28, 0xbf, 0xa1, 0x9e, 0x24, 0x3d, 0x2e, 0x88, 0x60, 0xd4, 0xbd, 0xab, |
| 0x66, 0xb7, 0x33, 0xf5, 0x42, 0xb3, 0xd6, 0x30, 0x87, 0x37, 0x92, 0xe4, 0x1a, 0x2d, 0xce, 0xfd, |
| 0x1f, 0xa8, 0x3f, 0x64, 0xb8, 0xa8, 0x10, 0x6d, 0x2e, 0xb0, 0x8a, 0x47, 0x07, 0xb0, 0x2a, 0xbd, |
| 0x80, 0xf1, 0xa1, 0xac, 0xe6, 0x34, 0xf4, 0xe9, 0x0c, 0xf4, 0xc8, 0xde, 0x1b, 0x27, 0x91, 0xe8, |
| 0x35, 0x3c, 0x0d, 0xe8, 0x88, 0x08, 0xf6, 0xcb, 0x90, 0xc5, 0x92, 0x04, 0x2c, 0x8e, 0x69, 0x9f, |
| 0x91, 0xee, 0x9d, 0x64, 0x71, 0x75, 0x59, 0xd3, 0xbc, 0x3f, 0x43, 0x73, 0x7d, 0x12, 0xca, 0x83, |
| 0xa6, 0xc9, 0x61, 0x2b, 0xa0, 0x23, 0x6c, 0xd0, 0x67, 0x06, 0xdc, 0x52, 0x58, 0xf4, 0x23, 0xd4, |
| 0x0c, 0x71, 0x1c, 0xf1, 0x30, 0x66, 0x53, 0xcc, 0x8f, 0x1e, 0xc0, 0xfc, 0x44, 0x33, 0x1b, 0x78, |
| 0x8a, 0x1a, 0x43, 0x51, 0x30, 0x29, 0xee, 0x48, 0xc4, 0x7d, 0xcf, 0xb9, 0xab, 0xae, 0x68, 0xb2, |
| 0xbd, 0xc5, 0xe5, 0xc6, 0x0a, 0x75, 0xa1, 0x41, 0x9d, 0x25, 0x5c, 0x10, 0xf7, 0x9f, 0xe8, 0x06, |
| 0xca, 0x03, 0xe6, 0xf6, 0xbd, 0xb0, 0x9f, 0xb0, 0xae, 0x6a, 0xd6, 0xfd, 0xc5, 0xac, 0x1d, 0x83, |
| 0x1b, 0xf3, 0x96, 0x06, 0x93, 0x86, 0xda, 0x0b, 0x58, 0x56, 0x6d, 0x46, 0x55, 0x58, 0xb5, 0x2c, |
| 0xd5, 0xcc, 0x76, 0xa6, 0x9e, 0xc7, 0xc9, 0x27, 0xda, 0x82, 0x95, 0x40, 0x13, 0xea, 0x96, 0xe7, |
| 0xb1, 0xfd, 0xaa, 0xfd, 0x91, 0x85, 0xc2, 0x44, 0xca, 0x68, 0x07, 0x8a, 0xaa, 0xa4, 0x54, 0x4a, |
| 0x16, 0x44, 0x32, 0xd6, 0x34, 0x25, 0x5c, 0x08, 0xe8, 0xe8, 0x1b, 0x6b, 0x42, 0x2d, 0x58, 0xf3, |
| 0x42, 0x4f, 0x7a, 0xd4, 0x27, 0x5d, 0xea, 0xdc, 0xf2, 0x5e, 0xcf, 0xca, 0xe8, 0x3f, 0xb4, 0x50, |
| 0xb6, 0x88, 0x96, 0x01, 0xa0, 0x97, 0xa0, 0x28, 0xc7, 0xf8, 0x85, 0x5a, 0x82, 0x80, 0x8e, 0x12, |
| 0xec, 0x1e, 0x20, 0x8b, 0x23, 0xc1, 0xd0, 0x97, 0x5e, 0xe4, 0x7b, 0x4c, 0x68, 0x1d, 0x65, 0xf1, |
| 0xba, 0xf5, 0x9c, 0x8d, 0x1d, 0xa8, 0x0d, 0x5b, 0xba, 0x09, 0xb4, 0xeb, 0x33, 0x12, 0x4b, 0x2a, |
| 0x87, 0x31, 0x51, 0x03, 0xa6, 0x04, 0x92, 0xab, 0x97, 0x9b, 0x95, 0xe4, 0x54, 0xd5, 0x83, 0x43, |
| 0xee, 0x32, 0xfc, 0xde, 0x38, 0xfe, 0x52, 0x87, 0x2b, 0x63, 0x5c, 0xfb, 0x33, 0x03, 0xa5, 0x54, |
| 0x1b, 0x1e, 0x52, 0xab, 0x2f, 0x21, 0xe9, 0x14, 0x71, 0x99, 0x4f, 0xef, 0x16, 0x57, 0xaa, 0x68, |
| 0xe3, 0x8f, 0x54, 0x38, 0x3a, 0x86, 0xad, 0x90, 0x87, 0xa4, 0x47, 0x25, 0xf5, 0xd3, 0xc9, 0xe7, |
| 0xde, 0x92, 0xfc, 0x46, 0xc8, 0xc3, 0xb6, 0x0a, 0x9f, 0xc8, 0xbd, 0xf5, 0x14, 0x9e, 0x18, 0x35, |
| 0x73, 0x41, 0xd2, 0x12, 0xdc, 0x5d, 0x87, 0xb5, 0x0b, 0xcf, 0xb9, 0x6d, 0x7b, 0x22, 0x96, 0x46, |
| 0x6c, 0xbb, 0x08, 0x2a, 0x98, 0x0f, 0x43, 0x17, 0xf3, 0xae, 0x17, 0x5a, 0xdb, 0x6f, 0x50, 0xfc, |
| 0x56, 0x44, 0xce, 0x69, 0xd7, 0xae, 0xa1, 0xef, 0xa0, 0xe8, 0x0c, 0x3c, 0xdf, 0x4d, 0x94, 0x6c, |
| 0xd6, 0x51, 0x7d, 0xae, 0x92, 0x4f, 0x39, 0x75, 0x5b, 0xd4, 0xa7, 0xa1, 0xe3, 0x85, 0x7d, 0x83, |
| 0xc7, 0x05, 0x8d, 0xbe, 0x2f, 0x64, 0x02, 0xd1, 0xbb, 0xcd, 0x48, 0xb4, 0x60, 0x6d, 0x4a, 0xd9, |
| 0xbb, 0xcf, 0x21, 0x7f, 0xe8, 0xc6, 0xf6, 0xf0, 0x2a, 0xac, 0x3a, 0xfe, 0x30, 0x96, 0x4c, 0x24, |
| 0x32, 0xb7, 0x9f, 0xbb, 0xff, 0x64, 0x21, 0x7f, 0x33, 0x8e, 0xfb, 0x04, 0x4a, 0x5d, 0x7d, 0x2e, |
| 0x13, 0xc4, 0x2e, 0xcd, 0x4c, 0x3d, 0xdf, 0xca, 0x56, 0x33, 0xb8, 0x98, 0x38, 0xf4, 0xdc, 0x4c, |
| 0xdf, 0x26, 0xfb, 0x7f, 0x6e, 0xf3, 0x3d, 0xac, 0xf5, 0xa8, 0xef, 0x2b, 0x25, 0x26, 0x7c, 0xb9, |
| 0x77, 0xe4, 0x2b, 0x27, 0x04, 0x96, 0xb2, 0x0e, 0x15, 0xe6, 0xc6, 0x24, 0x55, 0xa4, 0x65, 0x7d, |
| 0xf3, 0x32, 0x73, 0xe3, 0xcb, 0xfb, 0x3a, 0xa1, 0x9f, 0xe1, 0x99, 0x2f, 0x62, 0xe2, 0x73, 0xea, |
| 0x12, 0xc1, 0x22, 0x2e, 0xa4, 0xea, 0xb5, 0x02, 0x26, 0x35, 0x78, 0xdb, 0x5a, 0xbc, 0x94, 0xc2, |
| 0x0b, 0xfb, 0x66, 0x2d, 0xd6, 0x7c, 0x11, 0xab, 0xbc, 0x70, 0xc2, 0x70, 0xa9, 0x09, 0x74, 0x27, |
| 0x7e, 0xcf, 0xc1, 0xc6, 0x9c, 0x9c, 0x51, 0x1b, 0x20, 0xf2, 0x9c, 0x5b, 0xd2, 0x53, 0x4a, 0xb2, |
| 0x6b, 0xfd, 0xa3, 0xb9, 0x37, 0x9e, 0xd2, 0x5b, 0x67, 0x09, 0x4f, 0x20, 0xd1, 0x09, 0x14, 0x84, |
| 0x52, 0x1f, 0x11, 0x4a, 0x7e, 0xba, 0x65, 0x85, 0xe6, 0xf3, 0xb9, 0x44, 0xd3, 0x2a, 0xd5, 0x0b, |
| 0xf7, 0x1e, 0x8b, 0xbe, 0x80, 0x15, 0x05, 0xf3, 0xbb, 0x76, 0xc1, 0xec, 0xcc, 0x65, 0x99, 0xd4, |
| 0x75, 0x67, 0x09, 0x5b, 0x08, 0x6a, 0x42, 0xce, 0x71, 0x63, 0xbb, 0xf8, 0x9f, 0xcd, 0x45, 0x8e, |
| 0x15, 0xd9, 0x59, 0xc2, 0x2a, 0x58, 0x61, 0x46, 0x6e, 0x6c, 0x87, 0x7c, 0x3e, 0xe6, 0x66, 0x12, |
| 0x33, 0x72, 0x63, 0x74, 0x0a, 0x95, 0x91, 0x1b, 0x13, 0x36, 0x8a, 0x98, 0xf0, 0x02, 0x16, 0x4a, |
| 0xea, 0xdb, 0x1e, 0x2d, 0x26, 0x98, 0x41, 0xb6, 0x1e, 0xc3, 0x8a, 0x1d, 0xec, 0xbf, 0x1e, 0x41, |
| 0xc9, 0x2a, 0xc3, 0x76, 0x28, 0x84, 0x4d, 0xad, 0x8b, 0x6e, 0xd2, 0xb9, 0xfb, 0xe1, 0xcd, 0xd4, |
| 0xcb, 0xcd, 0xcf, 0xe6, 0x1e, 0x97, 0xa2, 0x48, 0x8b, 0xd5, 0x88, 0x53, 0x8f, 0xd3, 0x86, 0x3f, |
| 0xeb, 0x40, 0x3f, 0xcd, 0x9c, 0x67, 0x38, 0xab, 0xcb, 0xef, 0x38, 0x0e, 0x69, 0xf6, 0xb1, 0xde, |
| 0x4a, 0xe6, 0x0d, 0x4b, 0x58, 0xcd, 0xd0, 0xee, 0x2c, 0x7c, 0x4c, 0x71, 0x31, 0x98, 0xfc, 0xa1, |
| 0x72, 0xa0, 0x62, 0x76, 0xa3, 0x1c, 0x08, 0x2e, 0xa5, 0xef, 0x85, 0x7d, 0x2b, 0x97, 0x17, 0x0f, |
| 0x28, 0x88, 0x7e, 0x3b, 0xaf, 0xc6, 0x48, 0x73, 0x73, 0xbc, 0x26, 0xd2, 0x66, 0xe4, 0xc2, 0xc6, |
| 0x80, 0x51, 0x5f, 0x0e, 0x88, 0x33, 0x60, 0xce, 0x6d, 0x92, 0xb2, 0xe9, 0xf3, 0xa7, 0x0f, 0x38, |
| 0xa7, 0xa3, 0xd1, 0x87, 0x0a, 0x6c, 0x6f, 0xb1, 0x3e, 0x98, 0x36, 0xd5, 0x5e, 0xc3, 0xe6, 0xdc, |
| 0x7c, 0xd0, 0x07, 0xa0, 0x1e, 0x50, 0x22, 0xf9, 0x2d, 0x0b, 0x93, 0x77, 0x2a, 0x1f, 0xd0, 0xd1, |
| 0x95, 0x36, 0xa0, 0x0f, 0xa1, 0xa0, 0x5d, 0x44, 0xbf, 0x41, 0x5a, 0xbe, 0x59, 0x0c, 0xda, 0x84, |
| 0x95, 0xa5, 0x76, 0x05, 0xeb, 0x33, 0x09, 0xa0, 0xaf, 0xa6, 0xb6, 0x76, 0xe6, 0x01, 0x8b, 0x25, |
| 0xb5, 0xd3, 0x3f, 0x9f, 0x5a, 0x24, 0x36, 0xd9, 0x35, 0x28, 0x5c, 0x9f, 0x5f, 0x5e, 0x1c, 0x1f, |
| 0x9e, 0xb4, 0x4f, 0x8e, 0x8f, 0x2a, 0x4b, 0xca, 0x80, 0x5f, 0x5d, 0x9f, 0x1f, 0x11, 0xfc, 0xaa, |
| 0x75, 0x72, 0x5e, 0xc9, 0xb4, 0xf6, 0x60, 0xd3, 0xe3, 0xa9, 0xa2, 0x99, 0x9a, 0xb5, 0x50, 0xaa, |
| 0x68, 0x17, 0x2a, 0x83, 0x8b, 0x4c, 0x77, 0x45, 0xa7, 0x72, 0xf0, 0x6f, 0x00, 0x00, 0x00, 0xff, |
| 0xff, 0x2d, 0xca, 0x96, 0x84, 0xe2, 0x0b, 0x00, 0x00, |
| } |