/**
     * Sends a request to the remote endpoint.
     *
     * @param request the request to send
     * @throws IOException if an I/O error occurs
     */
    protected abstract void doSend(Request request) throws IOException;

    /**
     * Receives a response from the remote endpoint.
     *
     * @param response the response object to populate
     * @throws IOException if an I/O error occurs

     * @throws IOException if an I/O error occurs
     */
    protected <T extends Response> long doSend(final Request request, final T response, final Set<RequestParam> params, final long timeout)
            throws IOException {
        final long firstKey = prepareRequests(request, response, params, timeout);
        doSend(request);
        return firstKey;
    }

    /**
     * @param request
     * @param response

     *
     * @param request the request to send
     * @throws IOException if an I/O error occurs
     */
    protected void doSend0(final Request request) throws IOException {
        try {
            doSend(request);
        } catch (final IOException ioe) {
            if (LogStream.level > 2) {
                ioe.printStackTrace(log);
            }
            try {

            if (recvException != null) {
                throw recvException;
            }
            return peekedKey;
        }

        @Override
        protected void doSend(Request request) throws IOException {
            if (sendException != null) {
                throw sendException;
            }
        }

        @Override

        maxReadWriteSize = Math.min(maxReadWriteSize, response.getMaxReadWriteSize());
        maxReceiveSize = Math.min(maxReceiveSize, response.getMaxReceiveSize());
    }
    
    @Override
    protected void doSend(ServerMessageBlock2 request) throws IOException {
        if (shouldUseRdmaReadWrite(request)) {
            sendWithRdmaReadWrite(request);
        } else {
            sendWithRdmaSendReceive(request);
        }

                }
                return true;
            }
        }
        return false;
    }

    protected void doSend0(final Request request) throws IOException {
        try {
            doSend(request);
        } catch (final IOException ioe) {
            log.warn("send failed", ioe);
            try {
                disconnect(true);

  LazyLogger(Class<?> ownerOfLogger) {
    this.loggerName = ownerOfLogger.getName();
  }

  Logger get() {
    /*
     * We use double-checked locking. We could the try racy single-check idiom, but that would
     * depend on Logger to not contain mutable state.
     *
     * We could use Suppliers.memoizingSupplier here, but I micro-optimized to this implementation

/// tip | Consejo

Para que esto funcione, necesitas `pip install python-dotenv`.

///

### El archivo `.env`

Podrías tener un archivo `.env` con:

```bash
ADMIN_EMAIL="******@****.***"
APP_NAME="ChimichangApp"
```

  ) {
    logWithTime("dnsStart: $domainName")

    delegate.dnsStart(call, domainName)
  }

  override fun dnsEnd(
    call: Call,
    domainName: String,
    inetAddressList: List<InetAddress>,
  ) {
    logWithTime("dnsEnd: $inetAddressList")

    delegate.dnsEnd(call, domainName, inetAddressList)
  }

  override fun connectStart(
    call: Call,
    inetSocketAddress: InetSocketAddress,

    assertThat(dnsStart.call).isSameAs(call)
    assertThat(dnsStart.domainName).isEqualTo(server.hostName)
    val dnsEnd: DnsEnd = listener.removeUpToEvent<DnsEnd>()
    assertThat(dnsEnd.call).isSameAs(call)
    assertThat(dnsEnd.domainName).isEqualTo(server.hostName)
    assertThat(dnsEnd.inetAddressList.size).isEqualTo(1)
  }

  @Test
  fun noDnsLookupOnPooledConnection() {
    server.enqueue(MockResponse())