Method runRetry

upstream/upstream_executor.go:178–230

(
	ctx context.Context,
	req *common.NormalizedRequest,
	hedgeWrapped func(ctx context.Context) (*common.NormalizedResponse, error),
)

}

func (e *upstreamExecutor) runRetry(
	ctx context.Context,
	req *common.NormalizedRequest,
	hedgeWrapped func(ctx context.Context) (*common.NormalizedResponse, error),
) (*common.NormalizedResponse, error) {
	startTime := time.Now()
	maxAttempts := 1
	if e.cfg != nil && e.cfg.Retry != nil && e.cfg.Retry.MaxAttempts > 0 {
		maxAttempts = e.cfg.Retry.MaxAttempts
	}

	var lastErr error
	var lastResp *common.NormalizedResponse
	retriesAttempted := 0
	for attempt := 0; attempt < maxAttempts; attempt++ {
		if st := req.ExecState(); st != nil {
			st.UpstreamAttempts.Add(1)
			if attempt > 0 {
				st.UpstreamRetries.Add(1)
			}
		}
		resp, err := hedgeWrapped(ctx)
		if attempt+1 >= maxAttempts || !e.shouldRetry(req, resp, err, attempt) {
			if err != nil && retriesAttempted > 0 {
				if lastResp != nil {
					return lastResp, nil
				}
				return nil, common.NewErrFailsafeRetryExceeded(common.ScopeUpstream, err, &startTime)
			}
			return resp, err
		}
		lastErr = err
		retriesAttempted++
		if resp != nil {
			if lastResp != nil {
				lastResp.Release()
			}
			lastResp = resp
		}

		d := e.computeDelay(req, resp, err, attempt)
		if d > 0 {
			if serr := failsafe.SleepCtx(ctx, d); serr != nil {
				return lastResp, serr
			}
		}
	}

	if lastErr != nil {
		return lastResp, common.NewErrFailsafeRetryExceeded(common.ScopeUpstream, lastErr, &startTime)
	}
	return lastResp, nil
}

func (e *upstreamExecutor) shouldRetry(req *common.NormalizedRequest, _ *common.NormalizedResponse, err error, _ int) bool {
	if err == nil {