requests couldn't be canceled by tag. This update avoids crashing when
    `onResponse()` throws an `IOException`. That failure will now be logged
    instead of notifying the thread's uncaught exception handler. We've added a
    new API, `Call.isCanceled()` to check if a call has been canceled.

 *  New: Update `MultipartBuilder` to support content length.

	_, err := opts.UnmarshalMsg(payload)
	if err != nil {
		return grid.NewRemoteErr(err)
	}

	if !s.checkID(opts.DiskID) {
		return grid.NewRemoteErr(errDiskNotFound)
	}

	ctx, cancel := context.WithCancel(ctx)
	defer cancel()
	return grid.NewRemoteErr(s.getStorage().WalkDir(ctx, opts, grid.WriterToChannel(ctx, out)))

		// because of this loop.
		for {
			if !globalCallhomeConfig.Enabled() {
				return
			}

			if !runCallhome(ctx, objAPI) {
				// callhome was disabled or context was canceled
				return
			}

			// callhome running on a different node.
			// sleep for some time and try again.
			duration := max(time.Duration(r.Float64()*float64(globalCallhomeConfig.FrequencyDur())),

	// Channel *must* be closed to signal the end of the stream.
	// If the request context is canceled, the stream will no longer process requests.
	Requests chan<- Req
}

// Results returns the results from the remote server one by one.
// If any error is returned by the callback, the stream will be canceled.
// If the context is canceled, the stream will be canceled.
func (s *TypedStream[Req, Resp]) Results(next func(resp Resp) error) (err error) {

	}
}

func (m *muxClient) close() {
	if debugPrint {
		fmt.Println("closing outgoing mux", m.MuxID)
	}
	if !m.respMu.TryLock() {
		// Cancel before locking - will unblock any pending sends.
		if m.cancelFn != nil {
			m.cancelFn(context.Canceled)
		}
		// Wait for senders to release.
		m.respMu.Lock()
	}

	defer m.respMu.Unlock()
	m.closeLocked()
}

	hstats.totalS3Requests.Inc(api)
	code := w.StatusCode

	switch {
	case code == 0:
	case code == 499:
		// 499 is a good error, shall be counted as canceled.
		hstats.totalS3Canceled.Inc(api)
	case code >= http.StatusBadRequest:
		if code >= http.StatusInternalServerError {
			hstats.totalS35xxErrors.Inc(api)
		} else {
			hstats.totalS34xxErrors.Inc(api)
		}

	// Add new service requests here.
)

// Global service signal channel.
var globalServiceSignalCh = make(chan serviceSignal)

// GlobalContext context that is canceled when server is requested to shut down.
// cancelGlobalContext can be used to indicate server shutdown.
var GlobalContext, cancelGlobalContext = context.WithCancel(context.Background())

			if errors.As(err, &cerr) {
				logger.FatalIf(err, "Unable to initialize the server")
			}

			// If context was canceled
			if errors.Is(err, context.Canceled) {
				logger.FatalIf(err, "Server startup canceled upon user request")
			}

			bootLogIf(GlobalContext, err)
		}

		if !globalServerCtxt.StrictS3Compat {

    } catch (TimeoutException expected) {
    } finally {
      latch.countDown();
    }
  }

  /**
   * Tests that a canceled future throws a cancellation exception.
   *
   * <p>This method checks the cancel, isCancelled, and isDone methods.
   */
  public void testCanceledFutureThrowsCancellation() throws Exception {

    assertFalse(future.isDone());

          },
        ).build()
    val call = client.newCall(Request(server.url("/a")))
    call.enqueue(callback)
    call.cancel()
    latch.countDown()
    callback
      .await(server.url("/a"))
      .assertFailure("canceled", "Canceled", "Socket closed", "Socket is closed")
  }

  @Test
  fun cancelAll() {
    val call = client.newCall(Request(server.url("/")))