- Improved how the API server responds to **list** requests where the response format negotiates to Protobuf. List responses in Protobuf are marshalled one element at the time, drastically reducing memory needed to serve large collections. Streaming list responses can be disabled via the `StreamingCollectionEncodingToProtobuf` feature gate. ([#129407](https://github.com/kubernetes/kubernetes/pull/129407), [@serath...

            }
        });
        return response;
    }

    /**
     * Writes no-cache headers to the response.
     *
     * @param response the stream response
     * @param responseData the response data
     */
    protected void writeNoCache(final StreamResponse response, final ResponseData responseData) {
        response.header("Pragma", "no-cache");
        response.header("Cache-Control", "no-cache");

                        // response
                        if (negoResp.getSelectedDialect().atLeast(DialectVersion.SMB300) || response.isSigned()) {
                            response.setDigest(dgst);
                            byte[] payload = response.getRawPayload();
                            if (!response.verifySignature(payload, 0, payload.length)) {

  - `response.patch` and `response.patchType` are not permitted from validating admission webhooks
  - `apiVersion: "admission.k8s.io/v1"` is required
  - `kind: "AdmissionReview"` is required
  - `response.uid: "<value of request.uid>"` is required

This is the case for most of the web applications.

Many, many users, but your server is waiting 🕙 for their not-so-good connection to send their requests.

And then waiting 🕙 again for the responses to come back.

This "waiting" 🕙 is measured in microseconds, but still, summing it all, it's a lot of waiting in the end.

That's why it makes a lot of sense to use asynchronous ⏸🔀⏯ code for web APIs.

* Fixes a regression proxying responses from aggregated API servers which could cause watch requests to hang until the first event was received ([#75887](https://github.com/kubernetes/kubernetes/pull/75887), [@liggitt](https://github.com/liggitt))

    server.enqueue(MockResponse(body = "b"))
    val request = Request(server.url("/"))
    val response1 = client.newCall(request).execute()
    val response2 = client.newCall(request).execute()
    response1.body.string() // Discard the response body.
    response2.body.string() // Discard the response body.
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)

/**
 * Abstract base class for transport layer response objects.
 * Represents a response that can be received through the SMB1 transport layer.
 */
public abstract class Response {

    /**
     * Default constructor for Response.
     */
    public Response() {
        // Default constructor
    }

    /**
     * The expiration time for this response in milliseconds.
     */
    public long expiration;

- Kube-apiserver: redirect responses are no longer returned from backends by default. Set `--aggregator-reject-forwarding-redirect=false` to continue forwarding redirect responses. ([#112193](https://github.com/kubernetes/kubernetes/pull/112193), [@jindijamie](https://github.com/jindijamie)) [SIG API Machinery and Testing]

	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}
	// generate response
	response := generateListMultipartUploadsResponse(bucket, listMultipartsInfo, encodingType)
	encodedSuccessResponse := encodeResponse(response)

	// write success response.
	writeSuccessResponseXML(w, encodedSuccessResponse)
}

// ListBucketsHandler - GET Service.
// -----------