hub.addHandler(channel, handler)
        }

        def connectTo(Participant other) {
            def connector = new TestConnector()
            hub.addConnection(connector.connectionA)
            other.hub.addConnection(connector.connectionB)
        }

        def stop() {
            hub.stop()
        }
    }

				<-o.blockConnect
			}
			c.connect()
		}()
	}
	if debugPrint {
		fmt.Println(c.Local, "->", c.Remote, "Should local connect:", c.shouldConnect(), "side:", c.side)
	}
	if debugReqs {
		fmt.Println("Created connection", c.String())
	}
	return c
}

// Subroute returns a static subroute for the connection.
func (c *Connection) Subroute(s string) *Subroute {
	if c == nil {

 */
interface Connection {
  /** Returns the route used by this connection. */
  fun route(): Route

  /**
   * Returns the socket that this connection is using. Returns an
   * [SSL socket][javax.net.ssl.SSLSocket] if this connection is HTTPS. If this is an HTTP/2
   * connection the socket may be shared by multiple concurrent calls.
   */
  fun socket(): Socket

	"net/http"
	"sync"
	"time"

	"github.com/moby/spdystream"
	"k8s.io/apimachinery/pkg/util/httpstream"
	"k8s.io/klog/v2"
)

// connection maintains state about a spdystream.Connection and its associated
// streams.
type connection struct {
	conn             *spdystream.Connection
	streams          map[uint32]httpstream.Stream
	streamLock       sync.Mutex
	newStreamHandler httpstream.NewStreamHandler

}

func (c *connection) Name() string {
	return c.helper.Name()
}

func (c *connection) TotalRequests() uint64 {
	return c.helper.TotalRequests()
}

func (c *connection) ActiveRequests() uint64 {
	return c.helper.ActiveRequests()
}

func (c *connection) Latency() *timeseries.Instance {
	return c.helper.Latency()
}

func (c *connection) Request(onDone func()) {
	c.helper.Request(c.request, onDone)

        }

        // Wait for an in-flight connect to complete or fail.
        if (connectResult == null) {
          connectResult = awaitTcpConnect(awaitTimeoutNanos, TimeUnit.NANOSECONDS) ?: continue
        }

        if (connectResult.isSuccess) {
          // We have a connected TCP connection. Cancel and defer the racing connects that all lost.
          cancelInFlightConnects()

import org.gradle.launcher.daemon.context.DaemonContext;

import javax.annotation.Nullable;

/**
 * A daemon connector establishes a connection to a daemon.
 */
public interface DaemonConnector {

    /**
     * Attempts to connect to a daemon at the given address.
     *
     * @return A connection to a matching daemon, or null if not running.
     */
    @Nullable

 * <li>should allow stopping or requesting stopping from a different thread than receiving/dispatching</li>
 * <li>don't guarantee allowing multiple threads dispatching</li>
 * </ul>
 */
public interface Connection<T> extends Dispatch<T>, Receive<T>, Stoppable {

        expect:
        def connection = connector.maybeConnect({it.pid == 1} as DummyExplainingSpec)
        connection && connection.connection.num == 1
    }

    def "connect() returns connection to any existing daemon that matches spec"() {
        given:
        startIdleDaemon()
        startIdleDaemon()

        expect:
        def connection = connector.connect({it.pid < 12} as ExplainingSpec)

        def connection = outgoingConnector.connect(acceptor.address).create(serializer)
        thread.blockUntil.connected

        then:
        1 * action.execute(!null) >> { instant.connected }

        cleanup:
        acceptor?.stop()
        connection?.stop()
    }

    def "client throws exception when cannot connect to server"() {