grpc: google.golang.org/grpc/internal/serviceconfig Index | Files

package serviceconfig

import "google.golang.org/grpc/internal/serviceconfig"

Package serviceconfig contains utility functions to parse service config.

Index

Package Files

serviceconfig.go

type BalancerConfig Uses

type BalancerConfig struct {
    Name   string
    Config externalserviceconfig.LoadBalancingConfig
}

BalancerConfig wraps the name and config associated with one load balancing policy. It corresponds to a single entry of the loadBalancingConfig field from ServiceConfig.

It implements the json.Unmarshaler interface.

https://github.com/grpc/grpc-proto/blob/54713b1e8bc6ed2d4f25fb4dff527842150b91b2/grpc/service_config/service_config.proto#L247

func (*BalancerConfig) UnmarshalJSON Uses

func (bc *BalancerConfig) UnmarshalJSON(b []byte) error

UnmarshalJSON implements the json.Unmarshaler interface.

ServiceConfig contains a list of loadBalancingConfigs, each with a name and config. This method iterates through that list in order, and stops at the first policy that is supported. - 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 MethodConfig Uses

type MethodConfig struct {
    // WaitForReady indicates whether RPCs sent to this method should wait until
    // the connection is ready by default (!failfast). The value specified via the
    // gRPC client API will override the value set here.
    WaitForReady *bool
    // Timeout is the default timeout for RPCs sent to this method. 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 RPC has no deadline.
    Timeout *time.Duration
    // MaxReqSize is the maximum allowed payload size for an individual request 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.
    // 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.
    MaxReqSize *int
    // MaxRespSize is the maximum allowed payload size for an individual response in a
    // stream (server->client) in bytes.
    MaxRespSize *int
    // RetryPolicy configures retry options for the method.
    RetryPolicy *RetryPolicy
}

MethodConfig defines the configuration recommended by the service providers for a particular method.

type RetryPolicy Uses

type RetryPolicy struct {
    // MaxAttempts is the maximum number of attempts, including the original RPC.
    //
    // This field is required and must be two or greater.
    MaxAttempts int

    // Exponential backoff parameters. The initial retry attempt will occur at
    // random(0, initialBackoff). In general, the nth attempt will occur at
    // random(0,
    //   min(initialBackoff*backoffMultiplier**(n-1), maxBackoff)).
    //
    // These fields are required and must be greater than zero.
    InitialBackoff    time.Duration
    MaxBackoff        time.Duration
    BackoffMultiplier float64

    // The set of status codes which may be retried.
    //
    // Status codes are specified as strings, e.g., "UNAVAILABLE".
    //
    // This field is required and must be non-empty.
    // Note: a set is used to store this for easy lookup.
    RetryableStatusCodes map[codes.Code]bool
}

RetryPolicy defines the go-native version of the retry policy defined by the service config here: https://github.com/grpc/proposal/blob/master/A6-client-retries.md#integration-with-service-config

Package serviceconfig imports 7 packages (graph) and is imported by 12 packages. Updated 2020-11-21. Refresh now. Tools for package owners.