grpc: move to TransientFailure in pick_first LB policy when all addresses are removed

pickfirst.go

@@ -68,81 +68,83 @@ func (b *pickfirstBalancer) ResolverError(err error) {
 	})
 }
 
-func (b *pickfirstBalancer) UpdateClientConnState(cs balancer.ClientConnState) error {
-	if len(cs.ResolverState.Addresses) == 0 {
+func (b *pickfirstBalancer) UpdateClientConnState(state balancer.ClientConnState) error {
+	if len(state.ResolverState.Addresses) == 0 {
+		// The resolver reported an empty address list. Treat it like an error by
+		// calling b.ResolverError.
 		if b.subConn != nil {
-			// If the resolver returned empty addresses after it gave us non-empty
-			// addresses, we need to close the existing subConn. Setting subConn to nil
-			// here will cause us to return an error picker from ResolverError().
+			// Remove the old subConn. All addresses were removed, so it is no longer
+			// valid.
 			b.cc.RemoveSubConn(b.subConn)
 			b.subConn = nil
 		}
 		b.ResolverError(errors.New("produced zero addresses"))
 		return balancer.ErrBadResolverState
 	}
 
-	if b.subConn == nil {
-		var err error
-		b.subConn, err = b.cc.NewSubConn(cs.ResolverState.Addresses, balancer.NewSubConnOptions{})
-		if err != nil {
-			if logger.V(2) {
-				logger.Errorf("pickfirstBalancer: failed to NewSubConn: %v", err)
-			}
-			b.state = connectivity.TransientFailure
-			b.cc.UpdateState(balancer.State{ConnectivityState: connectivity.TransientFailure,
-				Picker: &picker{err: fmt.Errorf("error creating connection: %v", err)},
-			})
-			return balancer.ErrBadResolverState
+	if b.subConn != nil {
+		b.cc.UpdateAddresses(b.subConn, state.ResolverState.Addresses)
+		return nil
+	}
+
+	subConn, err := b.cc.NewSubConn(state.ResolverState.Addresses, balancer.NewSubConnOptions{})
+	if err != nil {
+		if logger.V(2) {
+			logger.Errorf("pickfirstBalancer: failed to NewSubConn: %v", err)
 		}
-		b.state = connectivity.Idle
+		b.state = connectivity.TransientFailure
 		b.cc.UpdateState(balancer.State{
-			ConnectivityState: connectivity.Idle,
-			Picker:            &picker{result: balancer.PickResult{SubConn: b.subConn}},
+			ConnectivityState: connectivity.TransientFailure,
+			Picker:            &picker{err: fmt.Errorf("error creating connection: %v", err)},
 		})
-		b.subConn.Connect()
-	} else {
-		b.cc.UpdateAddresses(b.subConn, cs.ResolverState.Addresses)
-		b.subConn.Connect()
+		return balancer.ErrBadResolverState
 	}
+	b.subConn = subConn
+	b.state = connectivity.Idle
+	b.cc.UpdateState(balancer.State{
+		ConnectivityState: connectivity.Idle,
+		Picker:            &picker{result: balancer.PickResult{SubConn: b.subConn}},
+	})
+	b.subConn.Connect()
 	return nil
 }
 
-func (b *pickfirstBalancer) UpdateSubConnState(subConn balancer.SubConn, s balancer.SubConnState) {
+func (b *pickfirstBalancer) UpdateSubConnState(subConn balancer.SubConn, state balancer.SubConnState) {
 	if logger.V(2) {
-		logger.Infof("pickfirstBalancer: UpdateSubConnState: %p, %v", subConn, s)
+		logger.Infof("pickfirstBalancer: UpdateSubConnState: %p, %v", subConn, state)
 	}
 	if b.subConn != subConn {
 		if logger.V(2) {
 			logger.Infof("pickfirstBalancer: ignored state change because subConn is not recognized")
 		}
 		return
 	}
-	b.state = s.ConnectivityState
-	if s.ConnectivityState == connectivity.Shutdown {
+	b.state = state.ConnectivityState
+	if state.ConnectivityState == connectivity.Shutdown {
 		b.subConn = nil
 		return
 	}
 
-	switch s.ConnectivityState {
+	switch state.ConnectivityState {
 	case connectivity.Ready:
 		b.cc.UpdateState(balancer.State{
-			ConnectivityState: s.ConnectivityState,
+			ConnectivityState: state.ConnectivityState,
 			Picker:            &picker{result: balancer.PickResult{SubConn: subConn}},
 		})
 	case connectivity.Connecting:
 		b.cc.UpdateState(balancer.State{
-			ConnectivityState: s.ConnectivityState,
+			ConnectivityState: state.ConnectivityState,
 			Picker:            &picker{err: balancer.ErrNoSubConnAvailable},
 		})
 	case connectivity.Idle:
 		b.cc.UpdateState(balancer.State{
-			ConnectivityState: s.ConnectivityState,
+			ConnectivityState: state.ConnectivityState,
 			Picker:            &idlePicker{subConn: subConn},
 		})
 	case connectivity.TransientFailure:
 		b.cc.UpdateState(balancer.State{
-			ConnectivityState: s.ConnectivityState,
-			Picker:            &picker{err: s.ConnectionError},
+			ConnectivityState: state.ConnectivityState,
+			Picker:            &picker{err: state.ConnectionError},
 		})
 	}
 }
@@ -161,7 +163,7 @@ type picker struct {
 	err    error
 }
 
-func (p *picker) Pick(info balancer.PickInfo) (balancer.PickResult, error) {
+func (p *picker) Pick(_ balancer.PickInfo) (balancer.PickResult, error) {
 	return p.result, p.err
 }
 
@@ -171,7 +173,7 @@ type idlePicker struct {
 	subConn balancer.SubConn
 }
 
-func (i *idlePicker) Pick(info balancer.PickInfo) (balancer.PickResult, error) {
+func (i *idlePicker) Pick(_ balancer.PickInfo) (balancer.PickResult, error) {
 	i.subConn.Connect()
 	return balancer.PickResult{}, balancer.ErrNoSubConnAvailable
 }