module.pom.expectDownload()
        module.artifact.expectDownload()

        when:
        executer.withArguments(
                "-Dorg.gradle.s3.endpoint=${server.uri}",
                "-Dhttp.proxyHost=localhost",
                "-Dhttp.proxyPort=${proxyServer.port}",
                "-Dhttp.nonProxyHosts=foo",
                "-Dhttp.proxyUser=proxyUser",
                "-Dhttp.proxyPassword=proxyPassword"
        )

        }

        // proxy
        final String proxyHost = getInitParameter(PROXY_HOST_PROPERTY, this.proxyHost, String.class);
        final Integer proxyPort = getInitParameter(PROXY_PORT_PROPERTY, this.proxyPort, Integer.class);
        if (proxyHost != null && proxyPort != null) {
            final HttpHost proxy = new HttpHost(proxyHost, proxyPort);

        prepareWrapper(server.uri.toString())
        server.expect(server.get("/$TEST_DISTRIBUTION_URL").sendFile(distribution.binDistribution))

        file("gradle.properties") << """
    systemProp.http.proxyHost=localhost
    systemProp.http.proxyPort=${proxyServer.port}
    systemProp.http.nonProxyHosts=
"""
        when:
        def result = wrapperExecuter.withTasks('hello').run()

        then:

        given:
        proxyServer.start()

        // Note that the HTTPS protocol handler uses the same nonProxyHosts property as the HTTP protocol.
        file("gradle.properties") << """
    systemProp.https.proxyHost=localhost
    systemProp.https.proxyPort=${proxyServer.port}
    systemProp.http.nonProxyHosts=
"""
        server.expect(server.head("/$TEST_DISTRIBUTION_URL"))
        prepareWrapper(getAuthenticatedBaseUrl())

        s3Properties.getMaxErrorRetryCount() >> Optional.absent()
        when:
        S3Client s3Client = new S3Client(credentials(), s3Properties)

        then:
        s3Client.amazonS3Client.clientConfiguration.proxyHost == 'localhost'
        s3Client.amazonS3Client.clientConfiguration.proxyPort == 8080
        s3Client.amazonS3Client.clientConfiguration.proxyPassword == 'password'

        }

        // proxy credentials
        final String proxyHost = paramMap.get(CRAWLER_WEB_PREFIX + "proxyHost");
        final String proxyPort = paramMap.get(CRAWLER_WEB_PREFIX + "proxyPort");
        if (StringUtil.isNotBlank(proxyHost) && StringUtil.isNotBlank(proxyPort)) {
            factoryParamMap.put(HcHttpClient.PROXY_HOST_PROPERTY, proxyHost);
            factoryParamMap.put(HcHttpClient.PROXY_PORT_PROPERTY, proxyPort);

	LegacyBinding       *LegacyBindingREST
	Eviction            *EvictionREST
	Status              *StatusREST
	EphemeralContainers *EphemeralContainersREST
	Log                 *podrest.LogREST
	Proxy               *podrest.ProxyREST
	Exec                *podrest.ExecREST
	Attach              *podrest.AttachREST
	PortForward         *podrest.PortForwardREST
}

// REST implements a RESTStorage for pods
type REST struct {

                rhList.toArray(new org.codelibs.fess.crawler.client.http.RequestHeader[rhList.size()]));

        final String proxyHost = (String) paramMap.get(Param.Client.PROXY_HOST);
        final String proxyPort = (String) paramMap.get(Param.Client.PROXY_PORT);
        if (StringUtil.isNotBlank(proxyHost) && StringUtil.isNotBlank(proxyPort)) {
            // proxy credentials

        }
    }

    void configureProxyHost(GradleExecuter executer, String proxyScheme) {
        assert port > 0
        executer.withArgument("-D${proxyScheme}.proxyHost=localhost")
        executer.withArgument("-D${proxyScheme}.proxyPort=${port}")
        // use proxy even when accessing localhost
        executer.withArgument("-Dhttp.nonProxyHosts=")
    }

// using the generic structures. "Classical" CDS/LDS/RDS/EDS use separate logic -
// this is used for the API-based LDS and generic messages.

var log = istiolog.RegisterScope("grpcgen", "xDS Generator for Proxyless gRPC")

type GrpcConfigGenerator struct{}

func clusterKey(hostname string, port int) string {
	return subsetClusterKey("", hostname, port)
}

func subsetClusterKey(subset, hostname string, port int) string {