reqInfo := (&logger.ReqInfo{}).AppendTags("peerAddress", thisAddr.String())
		ctx := logger.SetReqInfo(ctx, reqInfo)
		bugLogIf(ctx, err)
		return profilingDataFound
	}

	profilingDataFound = true

	// Send profiling data to zip as file
	for typ, data := range data {
		err := embedFileInZip(zipWriter, fmt.Sprintf("profile-%s-%s", thisAddr, typ), data, 0o600)
		internalLogIf(ctx, err)
	}

	return profilingDataFound

	for dID, v := range state.Peers {
		if v.DeploymentID == globalDeploymentID() {
			continue
		}
		// if individual deployment change like mode, endpoint, default bandwidth
		// send it to all sites. Else send the current node details to all sites
		// for ILM expiry flag update
		var p madmin.PeerInfo
		if peer.DeploymentID != "" {
			p = pi
		} else {
			p = v
		}
		wg.Add(1)

        // When
        int size = response.getReceiveBufferSize();

        // Then
        assertEquals(131072, size);
    }

    @Test
    @DisplayName("Should return send buffer size")
    void testGetSendBufferSize() throws Exception {
        // Given
        setPrivateField(response, "maxWriteSize", 131072);

        // When
        int size = response.getSendBufferSize();

			// itself will not leak.
			<-h.traverseAndHealDoneCh
		}()
	}
}

func (h *healSequence) queueHealTask(source healSource, healType madmin.HealItemType) error {
	// Send heal request
	task := healTask{
		bucket:    source.bucket,
		object:    source.object,
		versionID: source.versionID,
		opts:      h.settings,
	}
	if source.opts != nil {
		task.opts = *source.opts

	if hasSpaceBE(createReq.AccessKey) {
		return ctx, auth.Credentials{}, newServiceAccountOpts{}, madmin.AddServiceAccountReq{}, "", errorCodes.ToAPIErr(ErrAdminResourceInvalidArgument)
	}

	if err := createReq.Validate(); err != nil {
		// Since this validation would happen client side as well, we only send
		// a generic error message here.

			if errors.Is(err, io.EOF) {
				err = nil
			}
			break
		}

		stat = append(stat, st)
	}

	return stat, toStorageErr(err)
}

// ReadMultiple will read multiple files and send each back as response.
// Files are read and returned in the given order.
// The resp channel is closed before the call returns.
// Only a canceled context or network errors returns an error.

        } else {
          throw IllegalStateException()
        }
        if (name == "expect" && value.equals("100-continue", ignoreCase = true)) {
          // Don't read the body unless we've invited the client to send it.
          readBody = false
        }
      }
      val headers = httpHeaders.build()

      val peek = dispatcher.peek()
      for (response in peek.informationalResponses) {

	public abstract fun cancel ()V
	public abstract fun close (ILjava/lang/String;)Z
	public abstract fun queueSize ()J
	public abstract fun request ()Lokhttp3/Request;
	public abstract fun send (Ljava/lang/String;)Z
	public abstract fun send (Lokio/ByteString;)Z
}

public abstract interface class okhttp3/WebSocket$Factory {
	public abstract fun newWebSocket (Lokhttp3/Request;Lokhttp3/WebSocketListener;)Lokhttp3/WebSocket;
}

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.

	}

	ctxt.FTP = ctx.StringSlice("ftp")
	ctxt.SFTP = ctx.StringSlice("sftp")
	ctxt.Interface = ctx.String("interface")
	ctxt.UserTimeout = ctx.Duration("conn-user-timeout")
	ctxt.SendBufSize = ctx.Int("send-buf-size")
	ctxt.RecvBufSize = ctx.Int("recv-buf-size")
	ctxt.IdleTimeout = ctx.Duration("idle-timeout")
	ctxt.UserTimeout = ctx.Duration("conn-user-timeout")

	if conf := ctx.String("config"); len(conf) > 0 {