Fix GCS

Signed-off-by: Olivier Gambier <olivier@docker.com>

vendor/google.golang.org/grpc/clientconn.go

@@ -35,12 +35,14 @@ package grpc
 
 import (
 	"errors"
+	"fmt"
 	"net"
 	"strings"
 	"sync"
 	"time"
 
 	"golang.org/x/net/context"
+	"golang.org/x/net/trace"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/grpclog"
 	"google.golang.org/grpc/transport"
@@ -49,20 +51,34 @@ import (
 var (
 	// ErrUnspecTarget indicates that the target address is unspecified.
 	ErrUnspecTarget = errors.New("grpc: target is unspecified")
+	// ErrNoTransportSecurity indicates that there is no transport security
+	// being set for ClientConn. Users should either set one or explicitly
+	// call WithInsecure DialOption to disable security.
+	ErrNoTransportSecurity = errors.New("grpc: no transport security set (use grpc.WithInsecure() explicitly or set credentials)")
+	// ErrCredentialsMisuse indicates that users want to transmit security information
+	// (e.g., oauth2 token) which requires secure connection on an insecure
+	// connection.
+	ErrCredentialsMisuse = errors.New("grpc: the credentials require transport level security (use grpc.WithTransportAuthenticator() to set)")
 	// ErrClientConnClosing indicates that the operation is illegal because
 	// the session is closing.
 	ErrClientConnClosing = errors.New("grpc: the client connection is closing")
 	// ErrClientConnTimeout indicates that the connection could not be
 	// established or re-established within the specified timeout.
 	ErrClientConnTimeout = errors.New("grpc: timed out trying to connect")
+	// minimum time to give a connection to complete
+	minConnectTimeout = 20 * time.Second
 )
 
 // dialOptions configure a Dial call. dialOptions are set by the DialOption
 // values passed to Dial.
 type dialOptions struct {
-	codec Codec
-	block bool
-	copts transport.ConnectOptions
+	codec    Codec
+	cp       Compressor
+	dc       Decompressor
+	picker   Picker
+	block    bool
+	insecure bool
+	copts    transport.ConnectOptions
 }
 
 // DialOption configures how we set up the connection.
@@ -75,6 +91,29 @@ func WithCodec(c Codec) DialOption {
 	}
 }
 
+// WithCompressor returns a DialOption which sets a CompressorGenerator for generating message
+// compressor.
+func WithCompressor(cp Compressor) DialOption {
+	return func(o *dialOptions) {
+		o.cp = cp
+	}
+}
+
+// WithDecompressor returns a DialOption which sets a DecompressorGenerator for generating
+// message decompressor.
+func WithDecompressor(dc Decompressor) DialOption {
+	return func(o *dialOptions) {
+		o.dc = dc
+	}
+}
+
+// WithPicker returns a DialOption which sets a picker for connection selection.
+func WithPicker(p Picker) DialOption {
+	return func(o *dialOptions) {
+		o.picker = p
+	}
+}
+
 // WithBlock returns a DialOption which makes caller of Dial blocks until the underlying
 // connection is up. Without this, Dial returns immediately and connecting the server
 // happens in background.
@@ -84,6 +123,14 @@ func WithBlock() DialOption {
 	}
 }
 
+// WithInsecure returns a DialOption which disables transport security for this ClientConn.
+// Note that transport security is required unless WithInsecure is set.
+func WithInsecure() DialOption {
+	return func(o *dialOptions) {
+		o.insecure = true
+	}
+}
+
 // WithTransportCredentials returns a DialOption which configures a
 // connection level security credentials (e.g., TLS/SSL).
 func WithTransportCredentials(creds credentials.TransportAuthenticator) DialOption {
@@ -114,84 +161,247 @@ func WithDialer(f func(addr string, timeout time.Duration) (net.Conn, error)) Di
 	}
 }
 
-// Dial creates a client connection the given target.
-// TODO(zhaoq): Have an option to make Dial return immediately without waiting
-// for connection to complete.
-func Dial(target string, opts ...DialOption) (*ClientConn, error) {
-	if target == "" {
-		return nil, ErrUnspecTarget
+// WithUserAgent returns a DialOption that specifies a user agent string for all the RPCs.
+func WithUserAgent(s string) DialOption {
+	return func(o *dialOptions) {
+		o.copts.UserAgent = s
 	}
+}
+
+// Dial creates a client connection the given target.
+func Dial(target string, opts ...DialOption) (*ClientConn, error) {
 	cc := &ClientConn{
-		target:       target,
-		shutdownChan: make(chan struct{}),
+		target: target,
 	}
 	for _, opt := range opts {
 		opt(&cc.dopts)
 	}
+	if cc.dopts.codec == nil {
+		// Set the default codec.
+		cc.dopts.codec = protoCodec{}
+	}
+	if cc.dopts.picker == nil {
+		cc.dopts.picker = &unicastPicker{
+			target: target,
+		}
+	}
+	if err := cc.dopts.picker.Init(cc); err != nil {
+		return nil, err
+	}
 	colonPos := strings.LastIndex(target, ":")
 	if colonPos == -1 {
 		colonPos = len(target)
 	}
 	cc.authority = target[:colonPos]
-	if cc.dopts.codec == nil {
-		// Set the default codec.
-		cc.dopts.codec = protoCodec{}
-	}
-	if cc.dopts.block {
-		if err := cc.resetTransport(false); err != nil {
-			return nil, err
-		}
-		// Start to monitor the error status of transport.
-		go cc.transportMonitor()
-	} else {
-		// Start a goroutine connecting to the server asynchronously.
-		go func() {
-			if err := cc.resetTransport(false); err != nil {
-				grpclog.Printf("Failed to dial %s: %v; please retry.", target, err)
-				return
-			}
-			go cc.transportMonitor()
-		}()
-	}
 	return cc, nil
 }
 
+// ConnectivityState indicates the state of a client connection.
+type ConnectivityState int
+
+const (
+	// Idle indicates the ClientConn is idle.
+	Idle ConnectivityState = iota
+	// Connecting indicates the ClienConn is connecting.
+	Connecting
+	// Ready indicates the ClientConn is ready for work.
+	Ready
+	// TransientFailure indicates the ClientConn has seen a failure but expects to recover.
+	TransientFailure
+	// Shutdown indicates the ClientConn has started shutting down.
+	Shutdown
+)
+
+func (s ConnectivityState) String() string {
+	switch s {
+	case Idle:
+		return "IDLE"
+	case Connecting:
+		return "CONNECTING"
+	case Ready:
+		return "READY"
+	case TransientFailure:
+		return "TRANSIENT_FAILURE"
+	case Shutdown:
+		return "SHUTDOWN"
+	default:
+		panic(fmt.Sprintf("unknown connectivity state: %d", s))
+	}
+}
+
 // ClientConn represents a client connection to an RPC service.
 type ClientConn struct {
-	target       string
-	authority    string
-	dopts        dialOptions
-	shutdownChan chan struct{}
-
-	mu sync.Mutex
-	// ready is closed and becomes nil when a new transport is up or failed
-	// due to timeout.
-	ready chan struct{}
-	// Indicates the ClientConn is under destruction.
-	closing bool
-	// Every time a new transport is created, this is incremented by 1. Used
-	// to avoid trying to recreate a transport while the new one is already
-	// under construction.
-	transportSeq int
-	transport    transport.ClientTransport
+	target    string
+	authority string
+	dopts     dialOptions
 }
 
-func (cc *ClientConn) resetTransport(closeTransport bool) error {
+// State returns the connectivity state of cc.
+// This is EXPERIMENTAL API.
+func (cc *ClientConn) State() (ConnectivityState, error) {
+	return cc.dopts.picker.State()
+}
+
+// WaitForStateChange blocks until the state changes to something other than the sourceState.
+// It returns the new state or error.
+// This is EXPERIMENTAL API.
+func (cc *ClientConn) WaitForStateChange(ctx context.Context, sourceState ConnectivityState) (ConnectivityState, error) {
+	return cc.dopts.picker.WaitForStateChange(ctx, sourceState)
+}
+
+// Close starts to tear down the ClientConn.
+func (cc *ClientConn) Close() error {
+	return cc.dopts.picker.Close()
+}
+
+// Conn is a client connection to a single destination.
+type Conn struct {
+	target       string
+	dopts        dialOptions
+	resetChan    chan int
+	shutdownChan chan struct{}
+	events       trace.EventLog
+
+	mu      sync.Mutex
+	state   ConnectivityState
+	stateCV *sync.Cond
+	// ready is closed and becomes nil when a new transport is up or failed
+	// due to timeout.
+	ready     chan struct{}
+	transport transport.ClientTransport
+}
+
+// NewConn creates a Conn.
+func NewConn(cc *ClientConn) (*Conn, error) {
+	if cc.target == "" {
+		return nil, ErrUnspecTarget
+	}
+	c := &Conn{
+		target:       cc.target,
+		dopts:        cc.dopts,
+		resetChan:    make(chan int, 1),
+		shutdownChan: make(chan struct{}),
+	}
+	if EnableTracing {
+		c.events = trace.NewEventLog("grpc.ClientConn", c.target)
+	}
+	if !c.dopts.insecure {
+		var ok bool
+		for _, cd := range c.dopts.copts.AuthOptions {
+			if _, ok := cd.(credentials.TransportAuthenticator); !ok {
+				continue
+			}
+			ok = true
+		}
+		if !ok {
+			return nil, ErrNoTransportSecurity
+		}
+	} else {
+		for _, cd := range c.dopts.copts.AuthOptions {
+			if cd.RequireTransportSecurity() {
+				return nil, ErrCredentialsMisuse
+			}
+		}
+	}
+	c.stateCV = sync.NewCond(&c.mu)
+	if c.dopts.block {
+		if err := c.resetTransport(false); err != nil {
+			c.Close()
+			return nil, err
+		}
+		// Start to monitor the error status of transport.
+		go c.transportMonitor()
+	} else {
+		// Start a goroutine connecting to the server asynchronously.
+		go func() {
+			if err := c.resetTransport(false); err != nil {
+				grpclog.Printf("Failed to dial %s: %v; please retry.", c.target, err)
+				c.Close()
+				return
+			}
+			c.transportMonitor()
+		}()
+	}
+	return c, nil
+}
+
+// printf records an event in cc's event log, unless cc has been closed.
+// REQUIRES cc.mu is held.
+func (cc *Conn) printf(format string, a ...interface{}) {
+	if cc.events != nil {
+		cc.events.Printf(format, a...)
+	}
+}
+
+// errorf records an error in cc's event log, unless cc has been closed.
+// REQUIRES cc.mu is held.
+func (cc *Conn) errorf(format string, a ...interface{}) {
+	if cc.events != nil {
+		cc.events.Errorf(format, a...)
+	}
+}
+
+// State returns the connectivity state of the Conn
+func (cc *Conn) State() ConnectivityState {
+	cc.mu.Lock()
+	defer cc.mu.Unlock()
+	return cc.state
+}
+
+// WaitForStateChange blocks until the state changes to something other than the sourceState.
+func (cc *Conn) WaitForStateChange(ctx context.Context, sourceState ConnectivityState) (ConnectivityState, error) {
+	cc.mu.Lock()
+	defer cc.mu.Unlock()
+	if sourceState != cc.state {
+		return cc.state, nil
+	}
+	done := make(chan struct{})
+	var err error
+	go func() {
+		select {
+		case <-ctx.Done():
+			cc.mu.Lock()
+			err = ctx.Err()
+			cc.stateCV.Broadcast()
+			cc.mu.Unlock()
+		case <-done:
+		}
+	}()
+	defer close(done)
+	for sourceState == cc.state {
+		cc.stateCV.Wait()
+		if err != nil {
+			return cc.state, err
+		}
+	}
+	return cc.state, nil
+}
+
+// NotifyReset tries to signal the underlying transport needs to be reset due to
+// for example a name resolution change in flight.
+func (cc *Conn) NotifyReset() {
+	select {
+	case cc.resetChan <- 0:
+	default:
+	}
+}
+
+func (cc *Conn) resetTransport(closeTransport bool) error {
 	var retries int
 	start := time.Now()
 	for {
 		cc.mu.Lock()
-		t := cc.transport
-		ts := cc.transportSeq
-		// Avoid wait() picking up a dying transport unnecessarily.
-		cc.transportSeq = 0
-		if cc.closing {
+		cc.printf("connecting")
+		if cc.state == Shutdown {
+			// cc.Close() has been invoked.
 			cc.mu.Unlock()
 			return ErrClientConnClosing
 		}
+		cc.state = Connecting
+		cc.stateCV.Broadcast()
 		cc.mu.Unlock()
 		if closeTransport {
-			t.Close()
+			cc.transport.Close()
 		}
 		// Adjust timeout for the current try.
 		copts := cc.dopts.copts
@@ -206,29 +416,64 @@ func (cc *ClientConn) resetTransport(closeTransport bool) error {
 				return ErrClientConnTimeout
 			}
 		}
-		newTransport, err := transport.NewClientTransport(cc.target, &copts)
+		sleepTime := backoff(retries)
+		timeout := sleepTime
+		if timeout < minConnectTimeout {
+			timeout = minConnectTimeout
+		}
+		if copts.Timeout == 0 || copts.Timeout > timeout {
+			copts.Timeout = timeout
+		}
+		connectTime := time.Now()
+		addr, err := cc.dopts.picker.PickAddr()
+		var newTransport transport.ClientTransport
+		if err == nil {
+			newTransport, err = transport.NewClientTransport(addr, &copts)
+		}
 		if err != nil {
-			sleepTime := backoff(retries)
+			cc.mu.Lock()
+			if cc.state == Shutdown {
+				// cc.Close() has been invoked.
+				cc.mu.Unlock()
+				return ErrClientConnClosing
+			}
+			cc.errorf("transient failure: %v", err)
+			cc.state = TransientFailure
+			cc.stateCV.Broadcast()
+			if cc.ready != nil {
+				close(cc.ready)
+				cc.ready = nil
+			}
+			cc.mu.Unlock()
+			sleepTime -= time.Since(connectTime)
+			if sleepTime < 0 {
+				sleepTime = 0
+			}
 			// Fail early before falling into sleep.
 			if cc.dopts.copts.Timeout > 0 && cc.dopts.copts.Timeout < sleepTime+time.Since(start) {
+				cc.mu.Lock()
+				cc.errorf("connection timeout")
+				cc.mu.Unlock()
 				cc.Close()
 				return ErrClientConnTimeout
 			}
 			closeTransport = false
 			time.Sleep(sleepTime)
 			retries++
-			grpclog.Printf("grpc: ClientConn.resetTransport failed to create client transport: %v; Reconnecting to %q", err, cc.target)
+			grpclog.Printf("grpc: Conn.resetTransport failed to create client transport: %v; Reconnecting to %q", err, cc.target)
 			continue
 		}
 		cc.mu.Lock()
-		if cc.closing {
+		cc.printf("ready")
+		if cc.state == Shutdown {
 			// cc.Close() has been invoked.
 			cc.mu.Unlock()
 			newTransport.Close()
 			return ErrClientConnClosing
 		}
+		cc.state = Ready
+		cc.stateCV.Broadcast()
 		cc.transport = newTransport
-		cc.transportSeq = ts + 1
 		if cc.ready != nil {
 			close(cc.ready)
 			cc.ready = nil
@@ -238,40 +483,65 @@ func (cc *ClientConn) resetTransport(closeTransport bool) error {
 	}
 }
 
+func (cc *Conn) reconnect() bool {
+	cc.mu.Lock()
+	if cc.state == Shutdown {
+		// cc.Close() has been invoked.
+		cc.mu.Unlock()
+		return false
+	}
+	cc.state = TransientFailure
+	cc.stateCV.Broadcast()
+	cc.mu.Unlock()
+	if err := cc.resetTransport(true); err != nil {
+		// The ClientConn is closing.
+		cc.mu.Lock()
+		cc.printf("transport exiting: %v", err)
+		cc.mu.Unlock()
+		grpclog.Printf("grpc: Conn.transportMonitor exits due to: %v", err)
+		return false
+	}
+	return true
+}
+
 // Run in a goroutine to track the error in transport and create the
 // new transport if an error happens. It returns when the channel is closing.
-func (cc *ClientConn) transportMonitor() {
+func (cc *Conn) transportMonitor() {
 	for {
 		select {
-		// shutdownChan is needed to detect the channel teardown when
+		// shutdownChan is needed to detect the teardown when
 		// the ClientConn is idle (i.e., no RPC in flight).
 		case <-cc.shutdownChan:
 			return
-		case <-cc.transport.Error():
-			if err := cc.resetTransport(true); err != nil {
-				// The channel is closing.
-				grpclog.Printf("grpc: ClientConn.transportMonitor exits due to: %v", err)
+		case <-cc.resetChan:
+			if !cc.reconnect() {
 				return
 			}
-			continue
+		case <-cc.transport.Error():
+			if !cc.reconnect() {
+				return
+			}
+			// Tries to drain reset signal if there is any since it is out-dated.
+			select {
+			case <-cc.resetChan:
+			default:
+			}
 		}
 	}
 }
 
-// When wait returns, either the new transport is up or ClientConn is
-// closing. Used to avoid working on a dying transport. It updates and
-// returns the transport and its version when there is no error.
-func (cc *ClientConn) wait(ctx context.Context, ts int) (transport.ClientTransport, int, error) {
+// Wait blocks until i) the new transport is up or ii) ctx is done or iii) cc is closed.
+func (cc *Conn) Wait(ctx context.Context) (transport.ClientTransport, error) {
 	for {
 		cc.mu.Lock()
 		switch {
-		case cc.closing:
+		case cc.state == Shutdown:
 			cc.mu.Unlock()
-			return nil, 0, ErrClientConnClosing
-		case ts < cc.transportSeq:
-			// Worked on a dying transport. Try the new one immediately.
-			defer cc.mu.Unlock()
-			return cc.transport, cc.transportSeq, nil
+			return nil, ErrClientConnClosing
+		case cc.state == Ready:
+			ct := cc.transport
+			cc.mu.Unlock()
+			return ct, nil
 		default:
 			ready := cc.ready
 			if ready == nil {
@@ -281,7 +551,7 @@ func (cc *ClientConn) wait(ctx context.Context, ts int) (transport.ClientTranspo
 			cc.mu.Unlock()
 			select {
 			case <-ctx.Done():
-				return nil, 0, transport.ContextErr(ctx.Err())
+				return nil, transport.ContextErr(ctx.Err())
 			// Wait until the new transport is ready or failed.
 			case <-ready:
 			}
@@ -289,18 +559,23 @@ func (cc *ClientConn) wait(ctx context.Context, ts int) (transport.ClientTranspo
 	}
 }
 
-// Close starts to tear down the ClientConn. Returns ErrClientConnClosing if
+// Close starts to tear down the Conn. Returns ErrClientConnClosing if
 // it has been closed (mostly due to dial time-out).
 // TODO(zhaoq): Make this synchronous to avoid unbounded memory consumption in
 // some edge cases (e.g., the caller opens and closes many ClientConn's in a
 // tight loop.
-func (cc *ClientConn) Close() error {
+func (cc *Conn) Close() error {
 	cc.mu.Lock()
 	defer cc.mu.Unlock()
-	if cc.closing {
+	if cc.state == Shutdown {
 		return ErrClientConnClosing
 	}
-	cc.closing = true
+	cc.state = Shutdown
+	cc.stateCV.Broadcast()
+	if cc.events != nil {
+		cc.events.Finish()
+		cc.events = nil
+	}
 	if cc.ready != nil {
 		close(cc.ready)
 		cc.ready = nil