PluginDescriptor pluginDescriptor = null;

        File pluginFile = pluginArtifact.getFile();

        try {
            if (pluginFile.isFile()) {
                try (JarFile pluginJar = new JarFile(pluginFile, false)) {
                    ZipEntry pluginDescriptorEntry = pluginJar.getEntry(getPluginDescriptorLocation());

                    logger.debug("generator path: {}", s);
                }
                return s;
            }).allMatch(s -> {
                final boolean found = new File(s).isFile();
                if (found && logger.isDebugEnabled()) {
                    logger.debug("{} is found.", s);
                }
                return found;
            });
        } else {

            String pluginGroup,
            org.eclipse.aether.metadata.Metadata metadata,
            ArtifactRepository repository) {
        if (metadata != null && metadata.getFile() != null && metadata.getFile().isFile()) {
            try {
                Map<String, ?> options = Collections.singletonMap(MetadataReader.IS_STRICT, Boolean.FALSE);

            Versions versions,
            org.eclipse.aether.metadata.Metadata metadata,
            ArtifactRepository repository) {
        if (metadata != null && metadata.getFile() != null && metadata.getFile().isFile()) {
            try {
                Map<String, ?> options = Collections.singletonMap(MetadataReader.IS_STRICT, Boolean.FALSE);

                Metadata repoMetadata = metadataReader.read(metadata.getFile(), options);

                                  format: int32
                                  type: integer
                                idleTimeout:
                                  description: The idle timeout for upstream connection
                                    pool connections.
                                  type: string
                                maxConcurrentStreams:

import okhttp3.TestUtil.assertSuppressed
import okhttp3.internal.DoubleInetAddressDns
import okhttp3.internal.connection.RealConnection
import okhttp3.internal.connection.RealConnection.Companion.IDLE_CONNECTION_HEALTHY_NS
import okhttp3.internal.http.RecordingProxySelector
import okhttp3.testing.Flaky
import okhttp3.testing.PlatformRule
import okio.BufferedSink
import org.junit.jupiter.api.Assertions.assertEquals

		EnvVar: "MINIO_SHUTDOWN_TIMEOUT",
		Hidden: true,
	},
	cli.DurationFlag{
		Name:   "idle-timeout",
		Value:  xhttp.DefaultIdleTimeout,
		Usage:  "idle timeout is the maximum amount of time to wait for the next request when keep-alive are enabled",
		EnvVar: "MINIO_IDLE_TIMEOUT",
		Hidden: true,
	},
	cli.DurationFlag{
		Name:   "read-header-timeout",
		Value:  xhttp.DefaultReadHeaderTimeout,

| `minio_node_cpu_avg_system_max`      | CPU system time (max).                     |
| `minio_node_cpu_avg_idle`            | CPU idle time.                             |
| `minio_node_cpu_avg_idle_avg`        | CPU idle time (avg).                       |
| `minio_node_cpu_avg_idle_max`        | CPU idle time (max).                       |
| `minio_node_cpu_avg_iowait`          | CPU ioWait time.                           |

    // Connections are replaced if they idle out or are evicted from the pool
    evictAllConnections(pool)
    assertThat(pool.connectionCount()).isEqualTo(2)
    forceConnectionsToExpire(pool, expireTime)
    assertThat(pool.connectionCount()).isEqualTo(2)

    // Excess connections aren't removed until they idle out, even if no longer needed

 * used. HTTP/1.x connections can carry either zero or one streams. HTTP/2 connections can carry any
 * number of streams, dynamically configured with `SETTINGS_MAX_CONCURRENT_STREAMS`. A connection
 * currently carrying zero streams is an idle stream. We keep it alive because reusing an existing
 * connection is typically faster than establishing a new one.
 *
 * When a single logical call requires multiple streams due to redirects or authorization