retry

type AttemptMiddleware ¶

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

AttemptMiddleware is a Smithy FinalizeMiddleware that handles retry attempts using the provided Retryer implementation

func NewAttemptMiddleware(retryer Retryer, requestCloner RequestCloner) AttemptMiddleware

func (r AttemptMiddleware) HandleFinalize(ctx context.Context, in smithymiddle.FinalizeInput, next smithymiddle.FinalizeHandler) (
	out smithymiddle.FinalizeOutput, metadata smithymiddle.Metadata, err error,
)

func (r AttemptMiddleware) ID() string

type AwsRetryMiddlewareConfig ¶

type AwsRetryMiddlewareConfig interface {
	GetRetryer() Retryer
}

AwsRetryMiddlewareConfig interface for retry middleware config

type AwsRetryMiddlewares ¶

type AwsRetryMiddlewares struct {
	AttemptMiddleware       *AttemptMiddleware
	MetricsHeaderMiddleware *MetricsHeaderMiddleware
}

AwsRetryMiddlewares represents the Aws middleware's for Retry

type BackoffDelayer ¶

type BackoffDelayer interface {
	BackoffDelay(attempt int, err error) (time.Duration, error)
}

BackoffDelayer provides the interface for determining the delay to before another request attempt, that previously failed.

type BackoffDelayerFunc ¶

type BackoffDelayerFunc func(int, error) (time.Duration, error)

BackoffDelayerFunc provides a wrapper around a function to determine the backoff delay of an attempt retry.

func (fn BackoffDelayerFunc) BackoffDelay(attempt int, err error) (time.Duration, error)

type ExponentialJitterBackoff ¶

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

ExponentialJitterBackoff provides backoff delays with jitter based on the number of attempts.

func NewExponentialJitterBackoff(maxBackoff time.Duration) *ExponentialJitterBackoff

func (j *ExponentialJitterBackoff) BackoffDelay(attempt int, err error) (time.Duration, error)

type IsErrorRetryable ¶

type IsErrorRetryable interface {
	IsErrorRetryable(error) aws.Ternary
}

IsErrorRetryable provides the interface of an implementation to determine if a error as the result of an operation is retryable.

type IsErrorRetryableFunc ¶

type IsErrorRetryableFunc func(error) aws.Ternary

IsErrorRetryableFunc wraps a function with the IsErrorRetryable interface.

func (fn IsErrorRetryableFunc) IsErrorRetryable(err error) aws.Ternary

type IsErrorRetryables ¶

type IsErrorRetryables []IsErrorRetryable

IsErrorRetryables is a collection of checks to determine of the error is retryable. Iterates through the checks and returns the state of retryable if any check returns something other than unknown.

func (r IsErrorRetryables) IsErrorRetryable(err error) aws.Ternary

type IsErrorTimeout ¶

type IsErrorTimeout interface {
	IsErrorTimeout(err error) aws.Ternary
}

IsErrorTimeout provides the interface of an implementation to determine if a error matches.

type IsErrorTimeoutFunc ¶

type IsErrorTimeoutFunc func(error) aws.Ternary

IsErrorTimeoutFunc wraps a function with the IsErrorTimeout interface.

func (fn IsErrorTimeoutFunc) IsErrorTimeout(err error) aws.Ternary

type IsErrorTimeouts ¶

type IsErrorTimeouts []IsErrorTimeout

IsErrorTimeouts is a collection of checks to determine of the error is retryable. Iterates through the checks and returns the state of retryable if any check returns something other than unknown.

func (ts IsErrorTimeouts) IsErrorTimeout(err error) aws.Ternary

type MaxAttemptsError ¶

type MaxAttemptsError struct {
	Attempt int
	Err     error
}

MaxAttemptsError provides the error when the maximum number of attempts have been exceeded.

func (e *MaxAttemptsError) Error() string

func (e *MaxAttemptsError) Unwrap() error

type MetricsHeaderMiddleware ¶

type MetricsHeaderMiddleware struct{}

MetricsHeaderMiddleware attaches SDK request metric header for retries to the transport

func (r MetricsHeaderMiddleware) HandleFinalize(ctx context.Context, in smithymiddle.FinalizeInput, next smithymiddle.FinalizeHandler) (
	out smithymiddle.FinalizeOutput, metadata smithymiddle.Metadata, err error,
)

func (r MetricsHeaderMiddleware) ID() string

type NoRetryCanceledError ¶

type NoRetryCanceledError struct{}

NoRetryCanceledError detects if the error was an request canceled error and returns if so.

func (NoRetryCanceledError) IsErrorRetryable(err error) aws.Ternary

type RateLimiter ¶

type RateLimiter interface {
	GetToken(ctx context.Context, cost uint) (releaseToken func() error, err error)
	AddTokens(uint) error
}

RateLimiter provides the interface for limiting the rate of request retries allowed by the retrier.

type RequestCloner ¶

type RequestCloner func(interface{}) interface{}

RequestCloner is a function that can take an input request type and clone the request for use in a subsequent retry attempt

type RetryableConnectionError ¶

type RetryableConnectionError struct{}

RetryableConnectionError determines if the underlying error is an HTTP connection and returns if it should be retried.

Includes errors such as connection reset, connection refused, net dial, temporary, and timeout errors.

func (r RetryableConnectionError) IsErrorRetryable(err error) aws.Ternary

type RetryableError ¶

type RetryableError struct{}

RetryableError is an IsErrorRetryable implementation which uses the optional interface Retryable on the error value to determine if the error is retryable.

func (RetryableError) IsErrorRetryable(err error) aws.Ternary

type RetryableErrorCode ¶

type RetryableErrorCode struct {
	Codes map[string]struct{}
}

RetryableErrorCode determines if an attempt should be retried based on the API error code.

func (r RetryableErrorCode) IsErrorRetryable(err error) aws.Ternary

type RetryableHTTPStatusCode ¶

type RetryableHTTPStatusCode struct {
	Codes map[int]struct{}
}

RetryableHTTPStatusCode provides a IsErrorRetryable based on HTTP status codes.

func (r RetryableHTTPStatusCode) IsErrorRetryable(err error) aws.Ternary

type Retryer ¶

type Retryer interface {
	// IsErrorRetryable returns if the failed request is retryable. This check
	// should determine if the error can be retried, or if the error is
	// terminal.
	IsErrorRetryable(error) bool

	// MaxAttempts returns the maximum number of attempts that can be made for
	// a request before failing. A value of 0 implies that the request should
	// be retried until it succeeds if the errors are retryable.
	MaxAttempts() int

	// RetryDelay returns the delay that should be used before retrying the
	// request. Will return error if the if the delay could not be determined.
	RetryDelay(attempt int, opErr error) (time.Duration, error)

	// GetRetryToken attempts to deduct the retry cost from the retry token pool.
	// Returning the token release function, or error.
	GetRetryToken(ctx context.Context, opErr error) (releaseToken func(error) error, err error)

	// GetInitalToken returns the initial request token that can increment the
	// retry token pool if the request is successful.
	GetInitialToken() (releaseToken func(error) error)
}

Retryer defines an interface for extension utilities to extend the built in retryer.

func AddWithErrorCodes(r Retryer, codes ...string) Retryer

func AddWithMaxAttempts(r Retryer, max int) Retryer

func AddWithMaxBackoffDelay(r Retryer, delay time.Duration) Retryer

type Standard ¶

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

Standard is the standard retry pattern for the SDK. It uses a set of retryable checks to determine of the failed request should be retried, and what retry delay should be used.

func NewStandard(fnOpts ...func(*StandardOptions)) *Standard

func (s *Standard) GetInitialToken() func(error) error

func (s *Standard) GetRetryToken(ctx context.Context, err error) (func(error) error, error)

func (s *Standard) IsErrorRetryable(err error) bool

func (s *Standard) MaxAttempts() int

func (s *Standard) RetryDelay(attempt int, err error) (time.Duration, error)

type StandardOptions ¶

type StandardOptions struct {
	MaxAttempts int
	MaxBackoff  time.Duration
	Backoff     BackoffDelayer

	Retryables []IsErrorRetryable
	Timeouts   []IsErrorTimeout

	RateLimiter      RateLimiter
	RetryCost        uint
	RetryTimeoutCost uint
	NoRetryIncrement uint
}

StandardOptions provides the functional options for configuring the standard retryable, and delay behavior.

type TimeouterError ¶

type TimeouterError struct{}

TimeouterError provides the IsErrorTimeout implementation for determining if an error is a timeout based on type with the Timeout method.

func (t TimeouterError) IsErrorTimeout(err error) aws.Ternary