PassHost:     true,
		RoundTripper: ep.Transport,
		ErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) {
			success = false
			if err != nil && !errors.Is(err, context.Canceled) {
				proxyLogIf(GlobalContext, err)
			}
			if returnErr {
				writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
			}
		},
	})

	r.URL.Scheme = "http"
	if globalIsTLS {

					if err := healFreshDisk(ctx, z, disk); err != nil {
						globalBackgroundHealState.setDiskHealingStatus(disk, false)
						timedout := OperationTimedOut{}
						if !errors.Is(err, context.Canceled) && !errors.As(err, &timedout) && !errors.Is(err, errRetryHealing) {
							printEndpointError(disk, err, false)
						}
						return
					}
					// Only upon success pop the healed disk.

	}
	defer func() {
		if debugReqs {
			_, ok := c.outgoing.Load(client.MuxID)
			fmt.Println(client.MuxID, c.String(), "Connection.Request: DELETING MUX. Exists:", ok)
		}
		client.cancelFn(context.Canceled)
		c.outgoing.Delete(client.MuxID)
	}()
	return client.traceRoundtrip(ctx, c.trace, h, req)
}

// Request allows to do a single remote request.
// 'req' will not be used after the call and caller can reuse.

		}
		res = append(res, meta)
	}
	return metaCacheEntriesSorted{o: res}, nil
}

// readAll will return all remaining objects on the dst channel and close it when done.
// The context allows the operation to be canceled.
func (r *metacacheReader) readAll(ctx context.Context, dst chan<- metaCacheEntry) error {
	r.checkInit()
	if r.err != nil {
		return r.err
	}
	defer xioutil.SafeClose(dst)
	if r.current.name != "" {

		if !isDirQueue {
			err = h.send(ctx, buf.Bytes(), count, h.payloadType, h.httpTimeout)
		} else {
			_, err = h.store.PutMultiple(entries)
		}

		if err != nil {
			if errors.Is(err, context.Canceled) {
				return
			}

			h.config.LogOnceIf(
				context.Background(),
				fmt.Errorf("unable to send audit/log entry(s) to '%s' err '%w': %d", name, err, count),
				name,
			)

 *  Fix: Honor `RequestBody.isOneShot()` in `MultipartBody`

 *  Fix in `okhttp-coroutines`: Don't leak response bodies in `executeAsync()`. We had a bug where
    we didn't call `Response.close()` if the coroutine was canceled before its response was
    returned.

 *  Upgrade: [Okio 3.9.0][okio_3_9_0].

 *  Upgrade: [Kotlin 1.9.23][kotlin_1_9_23].

 *  Upgrade: [Unicode® IDNA 15.1.0][idna_15_1_0]

	ctx = lkctx.Context()
	defer nsLock.Unlock(lkctx)

	// Freeze all incoming S3 API calls before running speedtest.
	globalNotificationSys.ServiceFreeze(ctx, true)

	// Unfreeze as soon as request context is canceled or when the function returns.
	go func() {
		<-ctx.Done()
		globalNotificationSys.ServiceFreeze(ctx, false)
	}()

	durationStr := r.Form.Get(peerRESTDuration)

	err = saveConfig(ctx, objAPI, backgroundHealInfoPath, b)
	if err != nil {
		internalLogIf(ctx, err)
	}
}

// runDataScanner will start a data scanner.
// The function will block until the context is canceled.
// There should only ever be one scanner running per cluster.
func runDataScanner(ctx context.Context, objAPI ObjectLayer) {
	ctx, cancel := globalLeaderLock.GetLock(ctx)
	defer cancel()

  public boolean cancel(boolean mayInterruptIfRunning) {
    logger.get().log(FINER, "cancelling {0}", this);
    boolean cancelled = future.cancel(mayInterruptIfRunning);
    if (cancelled) {
      close();
    }
    return cancelled;
  }

  private void close() {
    logger.get().log(FINER, "closing {0}", this);
    closeables.close();
  }

}

// ReadMultiple will read multiple files and send each back as response.
// Files are read and returned in the given order.
// The resp channel is closed before the call returns.
// Only a canceled context or network errors returns an error.
func (client *storageRESTClient) ReadMultiple(ctx context.Context, req ReadMultipleReq, resp chan<- ReadMultipleResp) error {
	defer xioutil.SafeClose(resp)