// Configure the connector and create the connection
        GradleConnector connector = GradleConnector.newConnector();

        if (args.length > 0) {
            connector.useInstallation(new File(args[0]));
            if (args.length > 1) {
                connector.useGradleUserHomeDir(new File(args[1]));
            }
        }

        connector.forProjectDirectory(new File("."));

        otherVersion.binDistribution.makeReadable()
        executer.withTasks('wrapper').run()

        when:
        toolingApi.withConnector { connector ->
            connector.useBuildDistribution()
            connector.searchUpwards(true)
            connector.forProjectDirectory(projectDir.file('child'))
        }
        toolingApi.withConnection { connection -> connection.newBuild().forTasks('check').run() }

                    GradleConnector connector = GradleConnector.newConnector().useGradleVersion("6.8-20201118175938+0000"); // can be changed to latest release after 6.8 is available
                    ProjectConnection connection = connector.forProjectDirectory(projectLocation).connect();
                    connection.newBuild().forTasks("help").run(new ResultHandler<Void>() {

    }

    static void distributionProgressMessage(connector, String message) {
        connector.distribution = new ConfigurableDistribution(delegate: connector.distribution, operation: { it.description = message })
    }

    static void distributionOperation(connector, Closure operation) {
        connector.distribution = new ConfigurableDistribution(delegate: connector.distribution, operation: operation)
    }

    def "calling disconnect on uninitialized connection does not trigger wrapper download"() {
        when:
        def connector = toolingApi.connector()
        connector.useDistribution(URI.create("http://localhost:${server.port}/custom-dist.zip"))
        connector.connect()
        connector.disconnect()

        then:
        !toolingApi.gradleUserHomeDir.file("wrapper/dists/custom-dist").exists()
    }

	if entryName == "" {
		return nil
	}

	proxy.SetWorkloadEntry(entryName, autoCreate)
	c.adsConnections.Connect(conn)

	err := c.onWorkloadConnect(entryName, proxy, conn.ConnectedAt(), autoCreate)
	if err != nil {
		log.Error(err)
	}
	return err
}

// ensureProxyCanControlEntry ensures the connected proxy's identity matches that of the WorkloadEntry it is associating with.

	origListen      = listenFunc
	origAccept      = poll.AcceptFunc
)

func installTestHooks() {
	wsaSocketFunc = sw.WSASocket
	poll.CloseFunc = sw.Closesocket
	connectFunc = sw.Connect
	poll.ConnectExFunc = sw.ConnectEx
	listenFunc = sw.Listen
	poll.AcceptFunc = sw.AcceptEx
}

func uninstallTestHooks() {
	wsaSocketFunc = origWSASocket
	poll.CloseFunc = origClosesocket
	connectFunc = origConnect

// access to context and to avoid repeated parsing of driver
// configuration.
//
// If a Connector implements [io.Closer], the [database/sql.DB.Close]
// method will call the Close method and return error (if any).
type Connector interface {
	// Connect returns a connection to the database.
	// Connect may return a cached connection (one previously
	// closed), but doing so is unnecessary; the sql package

	adsClients.Total = len(connections)

	for _, c := range connections {
		adsClient := AdsClient{
			ConnectionID: c.ID(),
			ConnectedAt:  c.ConnectedAt(),
			PeerAddress:  c.Peer(),
		}
		adsClients.Connected = append(adsClients.Connected, adsClient)
	}
	writeJSON(w, adsClients, req)
}

// adsz implements a status and debug interface for ADS.
// It is mapped to /debug/adsz

		if w.forwarder == nil {
			// We only want to do reconnects here, if we never connected let the main flow handle it.
			return
		}
		// Only reconnect if the pod is ready
		if !isPodReady(w.pod) {
			return
		}
		con := !w.isConnected()
		if con {
			log.Warnf("pod: %s/%s port forward terminated", w.pod.Namespace, w.pod.Name)
			err := w.connect(w.pod)
			if err != nil {