adding IsReady to dialer interface

chained/algeneva_impl.go

@@ -73,6 +73,10 @@ func (a *algenevaImpl) dialServer(op *ops.Op, ctx context.Context) (net.Conn, er
 	return conn, nil
 }
 
+func (*algenevaImpl) ready() <-chan error {
+	return nil
+}
+
 // algenevaDialer is a algeneva.Dialer wrapper around a reportDialCore. algeneva accepts an optional
 // Dialer interface which it will use to dial the server and then wrap the resulting connection.
 type algenevaDialer struct {

chained/broflake_impl.go

@@ -55,6 +55,10 @@ func newBroflakeImpl(pc *config.ProxyConfig, reportDialCore reportDialCoreFn) (p
 	}, nil
 }
 
+func (*broflakeImpl) ready() <-chan error {
+	return nil
+}
+
 func (b *broflakeImpl) dialServer(op *ops.Op, ctx context.Context) (net.Conn, error) {
 	// TODO: I don't know what to do with 'op'
 	return b.QUICLayer.DialContext(ctx)

chained/chained_test.go

@@ -51,6 +51,10 @@ func (impl *testImpl) dialServer(op *ops.Op, ctx context.Context) (net.Conn, err
 	return impl.d(ctx)
 }
 
+func (*testImpl) ready() <-chan error {
+	return nil
+}
+
 func newDialer(dialServer func(ctx context.Context) (net.Conn, error)) (func(network, addr string) (net.Conn, error), error) {
 	p, err := newProxy("test", "addr:567", "proto", "netw", &config.ProxyConfig{
 		AuthToken: "token",

chained/http_impl.go

@@ -22,3 +22,7 @@ func newHTTPImpl(addr string, dialCore coreDialer) proxyImpl {
 func (impl *httpImpl) dialServer(op *ops.Op, ctx context.Context) (net.Conn, error) {
 	return impl.dialCore(op, ctx, impl.addr)
 }
+
+func (*httpImpl) ready() <-chan error {
+	return nil
+}

chained/https_impl.go

@@ -106,6 +106,10 @@ func (impl *httpsImpl) dialServer(op *ops.Op, ctx context.Context) (net.Conn, er
 	return result.Conn, nil
 }
 
+func (*httpsImpl) ready() <-chan error {
+	return nil
+}
+
 func timeoutFor(ctx context.Context) time.Duration {
 	deadline, ok := ctx.Deadline()
 	if ok {

chained/multipath.go

@@ -49,6 +49,10 @@ func (impl *multipathImpl) FormatStats() []string {
 	return impl.dialer.(multipath.Stats).FormatStats()
 }
 
+func (*multipathImpl) ready() <-chan error {
+	return nil
+}
+
 func CreateMPDialer(configDir, endpoint string, ss map[string]*config.ProxyConfig, uc common.UserConfig) (dialer.ProxyDialer, error) {
 	if len(ss) < 1 {
 		return nil, errors.New("no dialers")

chained/multiplexed_impl.go

@@ -51,6 +51,10 @@ func (impl *multiplexedImpl) dialServer(op *ops.Op, ctx context.Context) (net.Co
 	return impl.multiplexedDial(ctx, "", "")
 }
 
+func (impl *multiplexedImpl) ready() <-chan error {
+	return nil
+}
+
 // createMultiplexedProtocol configures a cmux multiplexing protocol
 // according to settings.
 func createMultiplexedProtocol(s *config.ProxyConfig) (cmux.Protocol, error) {

chained/preconnecting_dialer.go

@@ -73,6 +73,10 @@ func (pd *preconnectingDialer) dialServer(op *ops.Op, ctx context.Context) (conn
 	}
 }
 
+func (*preconnectingDialer) ready() <-chan error {
+	return nil
+}
+
 func (pd *preconnectingDialer) preconnectIfNecessary(op *ops.Op) {
 	pd.statsMutex.Lock()
 	defer pd.statsMutex.Unlock()

chained/proxy.go

@@ -67,6 +67,8 @@ type proxyImpl interface {
 	dialServer(op *ops.Op, ctx context.Context) (net.Conn, error)
 	// close releases the resources associated with the implementation, if any.
 	close()
+	// isReady returns if the implementation is ready to dial
+	ready() <-chan error
 }
 
 // nopCloser is a mixin to implement a do-nothing close() method of proxyImpl.
@@ -250,7 +252,8 @@ func createImpl(configDir, name, addr, transport string, s *config.ProxyConfig,
 func isAMultiplexedTransport(transport string) bool {
 	return transport == "tlsmasq" ||
 		transport == "starbridge" ||
-		transport == "algeneva"
+		transport == "algeneva" ||
+		transport == "water"
 }
 
 // ForceProxy forces everything through the HTTP proxy at forceAddr using
@@ -339,7 +342,7 @@ func newProxy(name, addr, protocol, network string, s *config.ProxyConfig, uc co
 		name:             name,
 		protocol:         protocol,
 		network:          network,
-		multiplexed:      s.MultiplexedAddr != "",
+		multiplexed:      s.MultiplexedAddr != "" || isAMultiplexedTransport(name),
 		addr:             addr,
 		authToken:        s.AuthToken,
 		user:             uc,
@@ -583,3 +586,7 @@ func splitClientHello(hello []byte) [][]byte {
 	splits = append(splits, hello[start:])
 	return splits
 }
+
+func (p *proxy) Ready() <-chan error {
+	return p.impl.ready()
+}

chained/quic_impl.go

@@ -71,3 +71,7 @@ func (impl *quicImpl) dialServer(op *ops.Op, ctx context.Context) (net.Conn, err
 		return conn, err
 	})
 }
+
+func (*quicImpl) ready() <-chan error {
+	return nil
+}

chained/shadowsocks_impl.go

@@ -36,6 +36,7 @@ type shadowsocksImpl struct {
 	rng            *mrand.Rand
 	rngmx          sync.Mutex
 	tlsConfig      *tls.Config
+	nopCloser
 }
 
 type PrefixSaltGen struct {
@@ -125,9 +126,6 @@ func newShadowsocksImpl(name, addr string, pc *config.ProxyConfig, reportDialCor
 	}, nil
 }
 
-func (impl *shadowsocksImpl) close() {
-}
-
 func (impl *shadowsocksImpl) dialServer(op *ops.Op, ctx context.Context) (net.Conn, error) {
 	return impl.reportDialCore(op, func() (net.Conn, error) {
 		conn, err := impl.client.DialStream(ctx, impl.generateUpstream())
@@ -142,6 +140,10 @@ func (impl *shadowsocksImpl) dialServer(op *ops.Op, ctx context.Context) (net.Co
 	})
 }
 
+func (*shadowsocksImpl) ready() <-chan error {
+	return nil
+}
+
 // generateUpstream() creates a marker upstream address.  This isn't an
 // acutal upstream that will be dialed, it signals that the upstream
 // should be determined by other methods.  It's just a bit random just to

chained/starbridge_impl.go

@@ -67,6 +67,10 @@ func newStarbridgeImpl(name, addr string, pc *config.ProxyConfig, reportDialCore
 	}, nil
 }
 
+func (*starbridge) ready() <-chan error {
+	return nil
+}
+
 // Adapted from https://github.com/OperatorFoundation/Starbridge-go/blob/v3.0.12/Starbridge/v3/starbridge.go#L237-L253
 func getClientConfig(serverPublicKey string) replicant.ClientConfig {
 	polishClientConfig := polish.DarkStarPolishClientConfig{

chained/tlsmasq_impl.go

@@ -111,6 +111,10 @@ func newTLSMasqImpl(configDir, name, addr string, pc *config.ProxyConfig, uc com
 	}, nil
 }
 
+func (*tlsMasqImpl) ready() <-chan error {
+	return nil
+}
+
 func decodeUint16(s string) (uint16, error) {
 	b, err := hex.DecodeString(strings.TrimPrefix(s, "0x"))
 	if err != nil {