* that they own the hostnames that they represent. Server authentication is required.
 *
 * To perform server authentication:
 *
 *  * The server's handshake certificates must have a [held certificate][HeldCertificate] (a
 *    certificate and its private key). The certificate's subject alternative names must match the

Recommendations
---------------

Typically servers need a held certificate plus a chain of intermediates. Servers only need the
private key for their own certificate. The chain served by a server doesn't need the root
certificate.

The trusted roots don't need to be the same for client and server when using client authentication.
Clients might rely on the platform certificates and servers might use a private

 *     .build();
 * ```
 *
 * The proxy authenticator may implement preemptive authentication, reactive authentication, or
 * both.
 *
 * Applications may configure OkHttp with an authenticator for origin servers, or proxy servers,
 * or both.
 *
 * ## Authentication Retries
 *
 * If your authentication may be flaky and requires retries you should apply some policy

 2. It attempts to retrieve a connection with that address from the **connection pool**.
 3. If it doesn't find a connection in the pool, it selects a **route** to attempt. This usually means making a DNS request to get the server's IP addresses. It then selects a TLS version and proxy server if necessary.

class DefaultSettingsDecryptionResult implements SettingsDecryptionResult {

    private List<Server> servers;

    private List<Proxy> proxies;

    private List<SettingsProblem> problems;

    DefaultSettingsDecryptionResult(List<Server> servers, List<Proxy> proxies, List<SettingsProblem> problems) {
        this.servers = (servers != null) ? servers : new ArrayList<>();
        this.proxies = (proxies != null) ? proxies : new ArrayList<>();

# Erasure code sizing guide

## Toy Setups

Capacity constrained environments, MinIO will work but not recommended for production.

| servers | drives (per node) | stripe_size | parity chosen (default) | tolerance for reads (servers) | tolerance for writes (servers) |
|--------:|------------------:|------------:|------------------------:|------------------------------:|-------------------------------:|

    }

    @Override
    public List<Server> getServers() {
        if (servers == null) {
            servers = new ArrayList<>();
        }

        return servers;
    }

    @Override
    public DefaultSettingsDecryptionRequest setServers(List<Server> servers) {
        this.servers = servers;

        return this;
    }

    @Override
    public List<Proxy> getProxies() {

        return this;
    }

    public ArtifactResolutionRequest setServers(List<Server> servers) {
        this.servers = servers;

        return this;
    }

    public List<Server> getServers() {
        if (servers == null) {
            servers = new ArrayList<>();
        }

        return servers;
    }

    public ArtifactResolutionRequest setMirrors(List<Mirror> mirrors) {

	debugWaitForExit
	debugSetConnPingDuration
	debugSetClientPingDuration
	debugAddToDeadline
	debugIsOutgoingClosed
	debugBlockInboundMessages
)

// TestGrid contains a grid of servers for testing purposes.
type TestGrid struct {
	Servers     []*httptest.Server
	Listeners   []net.Listener
	Managers    []*Manager
	Mux         []*mux.Router
	Hosts       []string
	cleanupOnce sync.Once
	cancel      context.CancelFunc
}

@Deprecated(since = "4.0.0")
public interface SettingsDecryptionRequest {

    /**
     * Gets the servers whose passwords should be decrypted.
     *
     * @return The servers to decrypt, never {@code null}.
     */
    List<Server> getServers();

    /**
     * Sets the servers whose passwords should be decrypted.
     *
     * @param servers The servers to decrypt, may be {@code null}.
     * @return This request, never {@code null}.
     */