// Since it does nothing, it should be inherently thread-safe
        final NullResponseProcessor processor = new NullResponseProcessor();

        // Create multiple response data objects
        final ResponseData[] responseDataArray = new ResponseData[10];
        for (int i = 0; i < 10; i++) {
            responseDataArray[i] = new ResponseData();

#### The time to answer helps the attackers { #the-time-to-answer-helps-the-attackers }

At that point, by noticing that the server took some microseconds longer to send the "Incorrect username or password" response, the attackers will know that they got _something_ right, some of the initial letters were right.

And then they can try again knowing that it's probably something more similar to `stanleyjobsox` than to `johndoe`.

     *
     * This does not provide any actual downgrade protection if SMB1 is allowed.
     *
     * It will also break connections with SMB2 servers that do not properly sign error responses.
     *
     * @return whether to enforce the use of secure negotiation.
     */
    boolean isRequireSecureNegotiate();

    /**
     * Enable port 139 failover
     *

Example:

```sh
minio server /data
```

Default trace is succinct only to indicate the API operations being called and the HTTP response status.

```sh
mc admin trace myminio
```

To trace entire HTTP request

```sh
mc admin trace --verbose myminio
```

To trace entire HTTP request and also internode communication

```sh

If synchronous replication is configured above, replication is attempted right away prior to returning the PUT object response. In the event that the replication target is down, the `X-Amz-Replication-Status` is marked as `FAILED` and resynced with target when the scanner runs again.

    private int capabilities;

    /**
     * Constructs a session setup AndX request.
     *
     * @param tc the CIFS context containing configuration and credentials
     * @param negotiated the negotiation response containing server capabilities
     * @param andx the next command in the AndX chain, or null
     * @param cred the authentication credentials to use for the session
     * @throws SmbException if an SMB protocol error occurs

    /**
     * Negotiate RDMA parameters
     *
     * @param request negotiation request parameters
     * @return negotiation response
     * @throws IOException if negotiation fails
     */
    public abstract RdmaNegotiateResponse negotiate(RdmaNegotiateRequest request) throws IOException;

    /**
     * Reset connection after recoverable error

  // Backing memory for missing_unused_key_names values.
  std::vector<tensorflow::string> missing_unused_key_names_data;
};

struct TF_DeviceList {
  std::vector<tensorflow::DeviceAttributes> response;
};

struct TF_Function {
  tensorflow::FunctionRecord* record;
};

struct TF_ApiDefMap {
  explicit TF_ApiDefMap(const tensorflow::OpList& op_list)
      :

    val exception: IOException,
    val retry: Boolean,
  ) : CallEvent()

  data class FollowUpDecision(
    override val timestampNs: Long,
    override val call: Call,
    val networkResponse: Response,
    val nextRequest: Request?,
  ) : CallEvent()

请注意，测试函数现在用的是 `async def`，而不是像以前使用 `TestClient` 时那样只是 `def` 。

///

我们现在可以使用应用程序创建一个 `AsyncClient` ，并使用 `await` 向其发送异步请求。

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

这相当于：

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

我们曾经通过它向 `TestClient` 发出请求。

/// tip

请注意，我们正在将 async/await 与新的 `AsyncClient` 一起使用——请求是异步的。

///

/// warning