grpc_service_config

type Config struct {
	// contains filtered or unexported fields
}

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"`
	// contains filtered or unexported fields
}

type LoadBalancingConfig struct {

	// Exactly one LB policy may be configured.
	//
	// Types that are assignable to Policy:
	//
	//	*LoadBalancingConfig_PickFirst
	//	*LoadBalancingConfig_RoundRobin
	//	*LoadBalancingConfig_Xds
	//	*LoadBalancingConfig_Grpclb
	//	*LoadBalancingConfig_XdsExperimental
	Policy isLoadBalancingConfig_Policy `protobuf_oneof:"policy"`
	// contains filtered or unexported fields
}

type LoadBalancingConfig_Grpclb struct {
	Grpclb *GrpcLbConfig `protobuf:"bytes,3,opt,name=grpclb,proto3,oneof"`
}

type LoadBalancingConfig_PickFirst struct {
	// For each new LB policy supported by gRPC, a new field must be added
	// here.  The field's name must be the LB policy name and its type is a
	// message that provides whatever configuration parameters are needed
	// by the LB policy.  The configuration message will be passed to the
	// LB policy when it is instantiated on the client.
	//
	// If the LB policy does not require any configuration parameters, the
	// message for that LB policy may be empty.
	//
	// Note that if an LB policy contains another nested LB policy
	// (e.g., a gslb policy picks the cluster and then delegates to
	// a round_robin policy to pick the backend within that cluster), its
	// configuration message may include a nested instance of the
	// LoadBalancingConfig message to configure the nested LB policy.
	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_Xds struct {
	// xds field should not be used unless people know what they're
	// doing.
	Xds *XdsConfig `protobuf:"bytes,2,opt,name=xds,proto3,oneof"`
}

type LoadBalancingConfig_XdsExperimental struct {
	// xds_experimental field should only be used for testing the xds
	// lbpolicy on the gRPC client.
	// TODO(rekarthik): remove this field after xds migration is done.
	XdsExperimental *XdsConfig `protobuf:"bytes,5,opt,name=xds_experimental,proto3,oneof"` // Next available ID: 6
}

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 *wrapperspb.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 *durationpb.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 minumum 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 *wrapperspb.UInt32Value `` /* 131-byte string literal not displayed */
	// 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 minumum 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 *wrapperspb.UInt32Value `` /* 134-byte string literal not displayed */
	// 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 assignable to RetryOrHedgingPolicy:
	//
	//	*MethodConfig_RetryPolicy_
	//	*MethodConfig_HedgingPolicy_
	RetryOrHedgingPolicy isMethodConfig_RetryOrHedgingPolicy `protobuf_oneof:"retry_or_hedging_policy"`
	// contains filtered or unexported fields
}

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 *durationpb.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 `` /* 151-byte string literal not displayed */
	// contains filtered or unexported fields
}

type MethodConfig_HedgingPolicy_ struct {
	HedgingPolicy *MethodConfig_HedgingPolicy `protobuf:"bytes,7,opt,name=hedging_policy,json=hedgingPolicy,proto3,oneof"`
}

type MethodConfig_Name struct {
	Service string `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"` // Required. Includes proto package name.
	Method  string `protobuf:"bytes,2,opt,name=method,proto3" json:"method,omitempty"`
	// contains filtered or unexported fields
}

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 *durationpb.Duration `protobuf:"bytes,2,opt,name=initial_backoff,json=initialBackoff,proto3" json:"initial_backoff,omitempty"`
	// Required. Must be greater than zero.
	MaxBackoff        *durationpb.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"` // Required. Must be greater than zero.
	// The set of status codes which may be retried.
	//
	// This field is required and must be non-empty.
	RetryableStatusCodes []code.Code `` /* 152-byte string literal not displayed */
	// contains filtered or unexported fields
}

type MethodConfig_RetryPolicy_ struct {
	RetryPolicy *MethodConfig_RetryPolicy `protobuf:"bytes,6,opt,name=retry_policy,json=retryPolicy,proto3,oneof"`
}

type PickFirstConfig struct {
	// contains filtered or unexported fields
}

type RoundRobinConfig struct {
	// contains filtered or unexported fields
}

type ServiceConfig struct {

	// Deprecated: Marked as deprecated in grpc_service_config.proto.
	LoadBalancingPolicy ServiceConfig_LoadBalancingPolicy `` /* 184-byte string literal not displayed */
	// 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"`
	// contains filtered or unexported fields
}

type ServiceConfig_HealthCheckConfig struct {

	// Service name to use in the health-checking request.
	ServiceName *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	// contains filtered or unexported fields
}

type ServiceConfig_LoadBalancingPolicy int32

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"`
	// contains filtered or unexported fields
}

type XdsConfig struct {

	// Required.  Name of balancer to connect to.
	BalancerName string `protobuf:"bytes,1,opt,name=balancer_name,json=balancerName,proto3" json:"balancer_name,omitempty"`
	// 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"`
	// contains filtered or unexported fields
}