adding IsReady to dialer interface

bandit/bandit.go

@@ -204,12 +204,14 @@ func (o *BanditDialer) chooseDialerForDomain(network, addr string) (Dialer, int)
 	notAllFailing := hasNotFailing(o.dialers)
 	for i := 0; i < (len(o.dialers) * 2); i++ {
 		dialer = o.dialers[chosenArm]
-		if (dialer.ConsecFailures() > 0 && notAllFailing) || !dialer.SupportsAddr(network, addr) {
+		if (dialer.ConsecFailures() > 0 && notAllFailing) || !dialer.SupportsAddr(network, addr) || !dialer.IsReady() {
 			// If the chosen dialer has consecutive failures and there are other
 			// dialers that are succeeding, we should choose a different dialer.
 			//
 			// If the chosen dialer does not support the address, we should also
 			// choose a different dialer.
+			//
+			// If the dialer isn't ready we should also choose a another dialer.
 			chosenArm = differentArm(chosenArm, len(o.dialers))
 			continue
 		}
@@ -353,6 +355,9 @@ type Dialer interface {
 	// connections created via this dialer.
 	DataRecv() uint64
 
+	// IsReady indicates when the dialer is ready for dialing
+	IsReady() bool
+
 	// Stop stops background processing for this Dialer.
 	Stop()
 

bandit/bandit_test.go

@@ -333,6 +333,10 @@ type tcpConnDialer struct {
 	server     net.Conn
 }
 
+func (*tcpConnDialer) IsReady() bool {
+	return true
+}
+
 // DialProxy implements Dialer.
 func (t *tcpConnDialer) DialProxy(ctx context.Context) (net.Conn, error) {
 	if t.shouldFail {

bypass/bypass.go

@@ -84,24 +84,43 @@ func (b *bypass) OnProxies(infos map[string]*commonconfig.ProxyConfig, configDir
 	}
 
 	dialers := chained.CreateDialersMap(configDir, supportedInfos, userConfig)
-	for k, v := range supportedInfos {
-		dialer := dialers[k]
+	for name, config := range supportedInfos {
+		dialer := dialers[name]
 		if dialer == nil {
-			log.Errorf("No dialer for %v", k)
+			log.Errorf("No dialer for %v", name)
 			continue
 		}
 
-		pc := chained.CopyConfig(v)
-		// Set the name in the info since we know it here.
-		pc.Name = k
-		// Kill the cert to avoid it taking up unnecessary space.
-		pc.Cert = ""
-		p := b.newProxy(k, pc, configDir, userConfig, dialer)
-		b.proxies = append(b.proxies, p)
-		go p.start()
+		// if dialer is not ready, try again in 60s
+		if !dialer.IsReady() {
+			log.Debugf("dialer %q is not ready, starting in background", name)
+			go func() {
+				for {
+					time.Sleep(60 * time.Second)
+					if dialer.IsReady() {
+						b.startProxy(name, config, configDir, userConfig, dialer)
+						break
+					}
+				}
+			}()
+			continue
+		}
+
+		b.startProxy(name, config, configDir, userConfig, dialer)
 	}
 }
 
+func (b *bypass) startProxy(proxyName string, config *commonconfig.ProxyConfig, configDir string, userConfig common.UserConfig, dialer bandit.Dialer) {
+	pc := chained.CopyConfig(config)
+	// Set the name in the info since we know it here.
+	pc.Name = proxyName
+	// Kill the cert to avoid it taking up unnecessary space.
+	pc.Cert = ""
+	p := b.newProxy(proxyName, pc, configDir, userConfig, dialer)
+	b.proxies = append(b.proxies, p)
+	go p.start()
+}
+
 func (b *bypass) newProxy(name string, pc *commonconfig.ProxyConfig, configDir string, userConfig common.UserConfig, dialer bandit.Dialer) *proxy {
 	return &proxy{
 		ProxyConfig:       pc,

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) isReady() bool {
+	return true
+}
+
 // 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) isReady() bool {
+	return true
+}
+
 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) isReady() bool {
+	return true
+}
+
 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) isReady() bool {
+	return true
+}

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) isReady() bool {
+	return true
+}
+
 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) isReady() bool {
+	return true
+}
+
 func CreateMPDialer(configDir, endpoint string, ss map[string]*config.ProxyConfig, uc common.UserConfig) (bandit.Dialer, 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) isReady() bool {
+	return true
+}
+
 // 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) isReady() bool {
+	return true
+}
+
 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
+	isReady() bool
 }
 
 // nopCloser is a mixin to implement a do-nothing close() method of proxyImpl.
@@ -583,3 +585,7 @@ func splitClientHello(hello []byte) [][]byte {
 	splits = append(splits, hello[start:])
 	return splits
 }
+
+func (p *proxy) IsReady() bool {
+	return p.impl.isReady()
+}

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) isReady() bool {
+	return true
+}

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) isReady() bool {
+	return true
+}
+
 // 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) isReady() bool {
+	return true
+}
+
 // 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) isReady() bool {
+	return true
+}
+
 func decodeUint16(s string) (uint16, error) {
 	b, err := hex.DecodeString(strings.TrimPrefix(s, "0x"))
 	if err != nil {