ReplicaSize int64 `json:"replicaSize"`

	// Total number of replica received
	ReplicaCount int64 `json:"replicaCount"`
	// Queued operations
	Queued InQueueMetric `json:"queued"`
	// Proxy stats
	Proxied ProxyMetric `json:"proxied"`
	// replication metrics summary for each site replication peer
	Metrics map[string]SRMetric `json:"replMetrics"`
	// uptime of node being queried for site replication metrics
	Uptime int64 `json:"uptime"`

  /**
   * By default delegates to {@link Object#hashCode}. The dynamic proxies' {@code hashCode()} will
   * delegate to this method. Subclasses can override this method to provide custom equality.
   */
  @Override
  public int hashCode() {
    return super.hashCode();
  }

  /**
   * By default delegates to {@link Object#toString}. The dynamic proxies' {@code toString()} will

```

Distributed instances are now accessible on the host using the Minio CLI on port 9000 and the Minio Web Console on port 9001. Proceed to access the Web browser at <http://127.0.0.1:9001/>. Here 4 MinIO server instances are reverse proxied through Nginx load balancing.

### Notes

    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<>();

    SettingsDecryptionRequest setServers(List<Server> servers);

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

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

                            -1,
                            -1,
                            e));
                }
            }

            proxies.add(proxy);
        }

        return new DefaultSettingsDecryptionResult(servers, proxies, problems);
    }

import java.net.URI
import okhttp3.internal.format

class RecordingProxySelector : ProxySelector() {
  @JvmField val proxies = mutableListOf<Proxy>()

  val requestedUris = mutableListOf<URI>()
  val failures = mutableListOf<String>()

  override fun select(uri: URI): List<Proxy> {
    requestedUris.add(uri)
    return proxies
  }

  fun assertRequests(vararg expectedUris: URI?) {

    }

    call.eventListener.proxySelectStart(call, url)
    proxies = selectProxies()
    nextProxyIndex = 0
    call.eventListener.proxySelectEnd(call, url, proxies)
  }

  /** Returns true if there's another proxy to try. */
  private fun hasNextProxy(): Boolean = nextProxyIndex < proxies.size

  /** Returns the next proxy to try. May be PROXY.NO_PROXY but never null. */

        return mirrors;
    }

    public ArtifactResolutionRequest setProxies(List<Proxy> proxies) {
        this.proxies = proxies;

        return this;
    }

    public List<Proxy> getProxies() {
        if (proxies == null) {
            proxies = new ArrayList<>();
        }

        return proxies;
    }

    //

    call: Call,
    url: HttpUrl,
  ) = onEvent(ProxySelectStart(System.nanoTime(), call, url))

  override fun proxySelectEnd(
    call: Call,
    url: HttpUrl,
    proxies: List<Proxy>,
  ) = onEvent(ProxySelectEnd(System.nanoTime(), call, url, proxies))

  override fun dnsStart(
    call: Call,
    domainName: String,
  ) = onEvent(DnsStart(System.nanoTime(), call, domainName))

  override fun dnsEnd(
    call: Call,