return bytesReceived.get();
    }

    /**
     * Get number of requests sent
     *
     * @return requests sent
     */
    public long getRequestsSent() {
        return requestsSent.get();
    }

    /**
     * Get number of requests received
     *
     * @return requests received
     */
    public long getRequestsReceived() {
        return requestsReceived.get();

Some use cases include:

* Converting non-JSON request bodies to JSON (e.g. <a href="https://msgpack.org/index.html" class="external-link" target="_blank">`msgpack`</a>).
* Decompressing gzip-compressed request bodies.
* Automatically logging all request bodies.

## Handling custom request body encodings { #handling-custom-request-body-encodings }

Let's see how to make use of a custom `Request` subclass to decompress gzip requests.

		"Number of DELETE tagging requests proxied to replication target",
		bucketL, targetArnL)
	bucketReplProxiedGetRequestsFailuresMD = NewCounterMD(bucketReplProxiedGetRequestsFailures,
		"Number of failures in GET requests proxied to replication target",
		bucketL, targetArnL)
	bucketReplProxiedGetRequestsTotalMD = NewCounterMD(bucketReplProxiedGetRequestsTotal,
		"Number of GET requests proxied to replication target",

Luego podemos crear un `AsyncClient` con la app y enviar requests asíncronos a ella, usando `await`.

{* ../../docs_src/async_tests/app_a_py39/test_main.py hl[9:12] *}

Esto es equivalente a:

```Python
response = client.get('/')
```

...que usábamos para hacer nuestros requests con el `TestClient`.

/// tip | Consejo

Nota que estamos usando async/await con el nuevo `AsyncClient`: el request es asíncrono.

///

It uses a single two-way connection to send and receive messages between servers.

It includes built in muxing of concurrent requests as well as congestion handling for streams.

Requests can be "Single Payload" or "Streamed".

Use the MinIO Grid for:

* Small, frequent requests with low latency requirements.
* Long-running requests with small/medium payloads.

Do *not* use the MinIO Grid for:

* Large payloads.

/// tip | Tipp

Der eigentliche Callback ist nur ein HTTP-Request.

Wenn Sie den Callback selbst implementieren, können Sie beispielsweise <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a> oder <a href="https://requests.readthedocs.io/" class="external-link" target="_blank">Requests</a> verwenden.

///

                  "mode": "fixed"
                }
              }
            ]
          },
          {
            "matcher": {
              "id": "byName",
              "options": "S3 Requests"
            },
            "properties": [
              {
                "id": "color",
                "value": {
                  "fixedColor": "light-green",
                  "mode": "fixed"

            executor.shutdown();

            // Some requests should be rejected due to backpressure
            assertTrue(rejectedCount.get() > 0, "Some requests should be rejected by backpressure");
            assertTrue(successCount.get() > 0, "Some requests should succeed");
            assertEquals(5, rejectedCount.get() + successCount.get(), "Total should be 5");

	m.singleResp = false
	m.RecvSeq = m.SendSeq // Sync
	if cap(requests) > 0 {
		m.outBlock = make(chan struct{}, cap(requests))
	}
	msg := message{
		Op:         OpConnectMux,
		Handler:    h,
		Payload:    payload,
		DeadlineMS: uint32(m.deadline.Milliseconds()),
	}
	msg.setZeroPayloadFlag()
	if requests == nil {
		msg.Flags |= FlagEOF
	}
	if m.subroute != nil {

The middleware responds to two particular types of HTTP request...

### CORS preflight requests { #cors-preflight-requests }

These are any `OPTIONS` request with `Origin` and `Access-Control-Request-Method` headers.

In this case the middleware will intercept the incoming request and respond with appropriate CORS headers, and either a `200` or `400` response for informational purposes.

### Simple requests { #simple-requests }