cadence: go.uber.org/cadence/internal/common/backoff Index | Files

package backoff

import "go.uber.org/cadence/internal/common/backoff"

Index

Package Files

retry.go retrypolicy.go

Constants

const (
    // NoInterval represents Maximim interval
    NoInterval = 0

    // DefaultBackoffCoefficient is default backOffCoefficient for retryPolicy
    DefaultBackoffCoefficient = 2.0
)

Variables

var SystemClock = systemClock{}

SystemClock implements Clock interface that uses time.Now().

func IgnoreErrors Uses

func IgnoreErrors(errorsToExclude []error) func(error) bool

IgnoreErrors can be used as IsRetryable handler for Retry function to exclude certain errors from the retry list

func Retry Uses

func Retry(ctx context.Context, operation Operation, policy RetryPolicy, isRetryable IsRetryable) error

Retry function can be used to wrap any call with retry logic using the passed in policy

type Clock Uses

type Clock interface {
    Now() time.Time
}

Clock used by ExponentialRetryPolicy implementation to get the current time. Mainly used for unit testing

type ConcurrentRetrier Uses

type ConcurrentRetrier struct {
    sync.Mutex
    // contains filtered or unexported fields
}

ConcurrentRetrier is used for client-side throttling. It determines whether to throttle outgoing traffic in case downstream backend server rejects requests due to out-of-quota or server busy errors.

func NewConcurrentRetrier Uses

func NewConcurrentRetrier(retryPolicy RetryPolicy) *ConcurrentRetrier

NewConcurrentRetrier returns an instance of concurrent backoff retrier.

func (*ConcurrentRetrier) Failed Uses

func (c *ConcurrentRetrier) Failed()

Failed marks client request failed because backend is busy.

func (*ConcurrentRetrier) Succeeded Uses

func (c *ConcurrentRetrier) Succeeded()

Succeeded marks client request succeeded.

func (*ConcurrentRetrier) Throttle Uses

func (c *ConcurrentRetrier) Throttle()

Throttle Sleep if there were failures since the last success call.

type ExponentialRetryPolicy Uses

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

ExponentialRetryPolicy provides the implementation for retry policy using a coefficient to compute the next delay. Formula used to compute the next delay is: initialInterval * math.Pow(backoffCoefficient, currentAttempt)

func NewExponentialRetryPolicy Uses

func NewExponentialRetryPolicy(initialInterval time.Duration) *ExponentialRetryPolicy

NewExponentialRetryPolicy returns an instance of ExponentialRetryPolicy using the provided initialInterval

func (*ExponentialRetryPolicy) ComputeNextDelay Uses

func (p *ExponentialRetryPolicy) ComputeNextDelay(elapsedTime time.Duration, numAttempts int) time.Duration

ComputeNextDelay returns the next delay interval. This is used by Retrier to delay calling the operation again

func (*ExponentialRetryPolicy) SetBackoffCoefficient Uses

func (p *ExponentialRetryPolicy) SetBackoffCoefficient(backoffCoefficient float64)

SetBackoffCoefficient sets the coefficient used by ExponentialRetryPolicy to compute next delay for each retry All retries are computed using the following formula: initialInterval * math.Pow(backoffCoefficient, currentAttempt)

func (*ExponentialRetryPolicy) SetExpirationInterval Uses

func (p *ExponentialRetryPolicy) SetExpirationInterval(expirationInterval time.Duration)

SetExpirationInterval sets the absolute expiration interval for all retries

func (*ExponentialRetryPolicy) SetInitialInterval Uses

func (p *ExponentialRetryPolicy) SetInitialInterval(initialInterval time.Duration)

SetInitialInterval sets the initial interval used by ExponentialRetryPolicy for the very first retry All later retries are computed using the following formula: initialInterval * math.Pow(backoffCoefficient, currentAttempt)

func (*ExponentialRetryPolicy) SetMaximumAttempts Uses

func (p *ExponentialRetryPolicy) SetMaximumAttempts(maximumAttempts int)

SetMaximumAttempts sets the maximum number of retry attempts

func (*ExponentialRetryPolicy) SetMaximumInterval Uses

func (p *ExponentialRetryPolicy) SetMaximumInterval(maximumInterval time.Duration)

SetMaximumInterval sets the maximum interval for each retry

type IsRetryable Uses

type IsRetryable func(error) bool

IsRetryable handler can be used to exclude certain errors during retry

type Operation Uses

type Operation func() error

Operation to retry

type Retrier Uses

type Retrier interface {
    NextBackOff() time.Duration
    Reset()
}

Retrier manages the state of retry operation

func NewRetrier Uses

func NewRetrier(policy RetryPolicy, clock Clock) Retrier

NewRetrier is used for creating a new instance of Retrier

type RetryPolicy Uses

type RetryPolicy interface {
    ComputeNextDelay(elapsedTime time.Duration, numAttempts int) time.Duration
}

RetryPolicy is the API which needs to be implemented by various retry policy implementations

Package backoff imports 5 packages (graph) and is imported by 4 packages. Updated 2019-07-18. Refresh now. Tools for package owners.