Method runRetry

erpc/network_executor.go:205–349

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

}

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

	var bestResp *common.NormalizedResponse
	var lastErr error
	// firstInformativeErr captures the first attempt's error that
	// contains real upstream details (ErrUpstreamsExhausted with
	// children, ErrExecutionException, etc.) — subsequent retry
	// attempts can degenerate into bare ErrNoUpstreamsLeftToSelect
	// which loses that info; the final wrap uses this instead.
	var firstInformativeErr error
	retriesAttempted := 0

	for attempt := 0; attempt < maxAttempts; attempt++ {
		// Bail out early if the lifecycle context has fired — the timeout
		// owns the classification, not retry-exhausted.
		if ctxErr := ctx.Err(); ctxErr != nil {
			cause := context.Cause(ctx)
			if cause != nil {
				return bestResp, cause
			}
			return bestResp, ctxErr
		}

		if attempt > 0 && st != nil {
			st.NetworkRetries.Add(1)
			retriesAttempted++
		}
		if st != nil {
			st.NetworkAttempts.Add(1)
		}

		resp, err := hedged(ctx)

		// If the lifecycle context fired during the attempt, surface the
		// ctx cause directly instead of wrapping as retry-exhausted.
		if ctxErr := ctx.Err(); ctxErr != nil {
			cause := context.Cause(ctx)
			if cause != nil {
				return bestResp, cause
			}
			return bestResp, ctxErr
		}

		// If this is the last attempt OR shouldRetry says no, return.
		retryReason := ""
		if attempt+1 < maxAttempts {
			retryReason = e.shouldRetryWithReason(req, resp, err, attempt)
		}