upstream minio {
        server minio1:9000 max_fails=1 fail_timeout=10s;
        server minio2:9000 max_fails=1 fail_timeout=10s;
        server minio3:9000 max_fails=1 fail_timeout=10s;
    }

    upstream console {
        ip_hash;
        server minio1:9001;
        server minio2:9001;
        server minio3:9001;
        server minio4:9001;
    }

    server {
        listen       9000;

            task a { }
            task b {
                dependsOn a
                doFirst {
                    ${server.callFromBuild("run_:b")}
                }
            }
        """

        server.expectConcurrent("run_:b", "handle1_:a", "handle2_:a")
        server.expectConcurrent("handle1_:b", "handle2_:b")

        when:
        run("b")

        then:
        noExceptionThrown()
    }

    }

    @Override
    public void expectGet() {
        server.expectGetDirectoryListing(path, directory)
    }

    public void allowGet() {
        server.allowGetDirectoryListing(path, directory)
    }

    @Override
    public void expectGetMissing() {
        server.expectGetMissing(path)
    }

    @Override
    public void expectGetBroken() {
        server.expectGetBroken(path)
    }

    MavenHttpRepository(HttpServer server, String contextPath = "/repo", HttpRepository.MetadataType metadataType = HttpRepository.MetadataType.DEFAULT, MavenFileRepository backingRepository) {
        if (!contextPath.startsWith("/")) {
            throw new IllegalArgumentException("Context path must start with '/'")
        }
        this.contextPath = contextPath
        this.server = server
        this.metadataType = metadataType

import org.gradle.launcher.daemon.server.exec.ExecuteBuild;
import org.gradle.launcher.daemon.server.exec.ForwardClientInput;
import org.gradle.launcher.daemon.server.exec.HandleCancel;
import org.gradle.launcher.daemon.server.exec.LogAndCheckHealth;
import org.gradle.launcher.daemon.server.exec.LogToClient;
import org.gradle.launcher.daemon.server.exec.RequestStopIfSingleUsedDaemon;

 * limitations under the License.
 */

package org.gradle.test.fixtures.server.http

import groovy.transform.CompileStatic
import org.eclipse.jetty.security.ConstraintSecurityHandler
import org.eclipse.jetty.server.Handler
import org.eclipse.jetty.server.Request
import org.eclipse.jetty.server.Server
import org.eclipse.jetty.server.handler.HandlerCollection

import javax.servlet.ServletException

    private final HttpServer server
    private final String repoRoot
    private final String moduleRootUriPath
    private final String uriPath
    private final MavenFileModule backingModule

    MavenHttpModule(HttpServer server, String repoRoot, MavenFileModule backingModule) {
        super(backingModule)
        this.backingModule = backingModule
        this.server = server
        this.repoRoot = repoRoot

    }

    void expectGetBlocking() {
        server.expectGetBlocking(getPath())
    }

    void expectGetMissing(PasswordCredentials credentials = null) {
        server.expectGetMissing(getPath(), credentials)
    }

    @Override
    void expectGetRevalidate() {
        server.expectGetRevalidate(getPath(), file)
    }

    void expectHead() {

        given:
        server.expect(server.head("/$TEST_DISTRIBUTION_URL"))
        def baseUrl = getAuthenticatedBaseUrl()
        prepareWrapper(baseUrl)
        server.expect(server.get("/$TEST_DISTRIBUTION_URL")
            .sendFile(distribution.binDistribution))
        server.expect(server.get("/versions/current").send("""{ "version" : "7.6" }"""))
        server.expect(server.head("/distributions/gradle-7.6-bin.zip"))

    String modulePath

    public HttpArtifact(HttpServer server, String modulePath) {
        super(server)
        this.modulePath = modulePath
    }

    @Override
    HttpResource getMd5() {
        return new BasicHttpResource(server, getMd5File(), "${path}.md5")
    }

    @Override
    HttpResource getSha1() {
        return new BasicHttpResource(server, getSha1File(), "${path}.sha1")
    }

    @Override