return err
	}
	if ri.Complete {
		return nil
	}
	globalBatchJobsMetrics.save(job.ID, ri)

	retryAttempts := job.Replicate.Flags.Retry.Attempts
	if retryAttempts <= 0 {
		retryAttempts = batchReplJobDefaultRetries
	}
	delay := job.Replicate.Flags.Retry.Delay
	if delay <= 0 {
		delay = batchReplJobDefaultRetryDelay
	}
	rnd := rand.New(rand.NewSource(time.Now().UnixNano()))

        // Retry logic for delete operation
        boolean deleted = false;
        for (int i = 0; i < 3 && !deleted; i++) {
            try {
                fileToDelete.delete();
                deleted = true;
            } catch (SmbException e) {
                if (i < 2 && e.getMessage().contains("handle")) {
                    log.debug("Retry delete attempt {} after handle error", i + 1);

 *  Fix: Don't miss whole operation timeouts when calls redirect.
 *  Fix: Don't leak connections if web sockets have malformed responses or if `onOpen()` throws.
 *  Fix: Don't retry when request bodies fail due to `FileNotFoundException`.
 *  Fix: Don't crash when URLs have IPv4-mapped IPv6 addresses.
 *  Fix: Don't crash when building `HandshakeCertificates` on Android API 28.

* Fix logrotate config on GCI ([#29139](https://github.com/kubernetes/kubernetes/pull/29139), [@adityakali](https://github.com/adityakali))
* Do not query the metadata server to find out if running on GCE.  Retry metadata server query for gcr if running on gce. ([#28871](https://github.com/kubernetes/kubernetes/pull/28871), [@vishh](https://github.com/vishh))

      "RequestHeadersEnd",
      "ResponseFailed",
      "RetryDecision",
      "ConnectionReleased",
      "CallFailed",
    )
    assertThat(listener.findEvent<RetryDecision>()).all {
      prop(RetryDecision::retry).isFalse()
    }
  }

  @Test
  fun failedDribbledCallEventSequence() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("0123456789")

		})
		if err != nil {
			if !configRetriableErrors(err) {
				logger.Fatal(err, "Unable to initialize backend")
			}
			retry := time.Duration(r.Float64() * float64(5*time.Second))
			storageLogIf(ctx, fmt.Errorf("Unable to initialize backend: %w, retrying in %s", err, retry))
			time.Sleep(retry)
			attempt++
			continue
		}
		break
	}

	// initialize the incomplete uploads cache

   *       UncheckedExecutionException} (if the cause is an {@code Exception}) or {@link
   *       ExecutionError} (if the cause is an {@code Error}).
   *   <li>Any {@link InterruptedException} causes a retry of the {@code get} call. The interrupt is
   *       restored before {@code getUnchecked} returns.
   *   <li>Any {@link CancellationException} is propagated untouched. So is any other {@link

                            if (channel != null) {
                                channelManager.handleChannelFailure(channel, e);
                                // Retry with primary transport
                                response = this.transport.send(request, response, params);
                            } else {
                                throw e;
                            }

     */
    fun eventListenerFactory(eventListenerFactory: EventListener.Factory) =
      apply {
        this.eventListenerFactory = eventListenerFactory
      }

    /**
     * Configure this client to retry or not when a connectivity problem is encountered. By default,
     * this client silently recovers from the following problems:
     *
     * * **Unreachable IP addresses.** If the URL's host has multiple IP addresses,

    val uri = newBuilder().reencodeForUri().toString()
    return try {
      URI(uri)
    } catch (e: URISyntaxException) {
      // Unlikely edge case: the URI has a forbidden character in the fragment. Strip it & retry.
      try {
        val stripped = uri.replace(Regex("[\\u0000-\\u001F\\u007F-\\u009F\\p{javaWhitespace}]"), "")
        URI.create(stripped)
      } catch (e1: Exception) {