cleanup: replace dial with newclient (#7970)

admin/test/utils.go

@@ -68,9 +68,9 @@ func RunRegisterTests(t *testing.T, ec ExpectedStatusCodes) {
 		server.Serve(lis)
 	}()
 
-	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
+	conn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
-		t.Fatalf("cannot connect to server: %v", err)
+		t.Fatalf("grpc.NewClient(%q) = %v", lis.Addr().String(), err)
 	}
 
 	t.Run("channelz", func(t *testing.T) {

balancer/grpclb/grpclb_remote_balancer.go

@@ -260,10 +260,11 @@ func (lb *lbBalancer) newRemoteBalancerCCWrapper() error {
 	// The grpclb server addresses will set field ServerName, and creds will
 	// receive ServerName as authority.
 	target := lb.manualResolver.Scheme() + ":///grpclb.subClientConn"
-	cc, err := grpc.Dial(target, dopts...)
+	cc, err := grpc.NewClient(target, dopts...)
 	if err != nil {
-		return fmt.Errorf("grpc.Dial(%s): %v", target, err)
+		return fmt.Errorf("grpc.NewClient(%s): %v", target, err)
 	}
+	cc.Connect()
 	ccw := &remoteBalancerCCWrapper{
 		cc:      cc,
 		lb:      lb,

benchmark/benchmark.go

@@ -340,10 +340,10 @@ func NewClientConn(addr string, opts ...grpc.DialOption) *grpc.ClientConn {
 }
 
 // NewClientConnWithContext creates a gRPC client connection to addr using ctx.
-func NewClientConnWithContext(ctx context.Context, addr string, opts ...grpc.DialOption) *grpc.ClientConn {
-	conn, err := grpc.DialContext(ctx, addr, opts...)
+func NewClientConnWithContext(_ context.Context, addr string, opts ...grpc.DialOption) *grpc.ClientConn {
+	conn, err := grpc.NewClient(addr, opts...)
 	if err != nil {
-		logger.Fatalf("NewClientConn(%q) failed to create a ClientConn: %v", addr, err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", addr, err)
 	}
 	return conn
 }

credentials/alts/internal/handshaker/service/service.go

@@ -50,7 +50,7 @@ func Dial(hsAddress string) (*grpc.ClientConn, error) {
 		// Disable the service config to avoid unnecessary TXT record lookups that
 		// cause timeouts with some versions of systemd-resolved.
 		var err error
-		hsConn, err = grpc.Dial(hsAddress, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDisableServiceConfig())
+		hsConn, err = grpc.NewClient(hsAddress, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDisableServiceConfig())
 		if err != nil {
 			return nil, err
 		}

internal/stubserver/stubserver.go

@@ -225,10 +225,11 @@ func (ss *StubServer) StartClient(dopts ...grpc.DialOption) error {
 		opts = append(opts, grpc.WithResolvers(ss.R))
 	}
 
-	cc, err := grpc.Dial(ss.Target, opts...)
+	cc, err := grpc.NewClient(ss.Target, opts...)
 	if err != nil {
-		return fmt.Errorf("grpc.Dial(%q) = %v", ss.Target, err)
+		return fmt.Errorf("grpc.NewClient(%q) = %v", ss.Target, err)
 	}
+	cc.Connect()
 	ss.CC = cc
 	if ss.R != nil {
 		ss.R.UpdateState(resolver.State{Addresses: []resolver.Address{{Addr: ss.Address}}})

interop/alts/client/client.go

@@ -48,9 +48,9 @@ func main() {
 	}
 	altsTC := alts.NewClientCreds(opts)
 	// Block until the server is ready.
-	conn, err := grpc.Dial(*serverAddr, grpc.WithTransportCredentials(altsTC), grpc.WithBlock())
+	conn, err := grpc.NewClient(*serverAddr, grpc.WithTransportCredentials(altsTC))
 	if err != nil {
-		logger.Fatalf("gRPC Client: failed to dial the server at %v: %v", *serverAddr, err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", *serverAddr, err)
 	}
 	defer conn.Close()
 	grpcClient := testgrpc.NewTestServiceClient(conn)

interop/client/client.go

@@ -280,7 +280,7 @@ func main() {
 	}
 	conn, err := grpc.NewClient(serverAddr, opts...)
 	if err != nil {
-		logger.Fatalf("Fail to dial: %v", err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", serverAddr, err)
 	}
 	defer conn.Close()
 	tc := testgrpc.NewTestServiceClient(conn)

interop/grpclb_fallback/client_linux.go

@@ -112,9 +112,9 @@ func createTestConn() *grpc.ClientConn {
 	default:
 		errorLog.Fatalf("Invalid --custom_credentials_type:%v", *customCredentialsType)
 	}
-	conn, err := grpc.Dial(*serverURI, opts...)
+	conn, err := grpc.NewClient(*serverURI, opts...)
 	if err != nil {
-		errorLog.Fatalf("Fail to dial: %v", err)
+		errorLog.Fatalf("grpc.NewClient(%q) = %v", *serverURI, err)
 	}
 	return conn
 }

interop/http2/negative_http2_client.go

@@ -133,9 +133,9 @@ func main() {
 	serverAddr := net.JoinHostPort(*serverHost, strconv.Itoa(*serverPort))
 	var opts []grpc.DialOption
 	opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
-	conn, err := grpc.Dial(serverAddr, opts...)
+	conn, err := grpc.NewClient(serverAddr, opts...)
 	if err != nil {
-		logger.Fatalf("Fail to dial: %v", err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", serverAddr, err)
 	}
 	defer conn.Close()
 	tc := testgrpc.NewTestServiceClient(conn)

interop/observability/client/client.go

@@ -57,9 +57,9 @@ func main() {
 	if *serverPort != 0 {
 		serverAddr = net.JoinHostPort(*serverHost, strconv.Itoa(*serverPort))
 	}
-	conn, err := grpc.Dial(serverAddr, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	conn, err := grpc.NewClient(serverAddr, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
-		log.Fatalf("Fail to dial: %v", err)
+		log.Fatalf("grpc.NewClient(%q) = %v", serverAddr, err)
 	}
 	defer conn.Close()
 	tc := testgrpc.NewTestServiceClient(conn)

interop/stress/client/main.go

@@ -319,7 +319,7 @@ func newConn(address string, useTLS, testCA bool, tlsServerName string) (*grpc.C
 	} else {
 		opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	}
-	return grpc.Dial(address, opts...)
+	return grpc.NewClient(address, opts...)
 }
 
 func main() {

interop/stress/metrics_client/main.go

@@ -75,9 +75,9 @@ func main() {
 		logger.Fatal("-metrics_server_address is unset")
 	}
 
-	conn, err := grpc.Dial(*metricsServerAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	conn, err := grpc.NewClient(*metricsServerAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
-		logger.Fatalf("cannot connect to metrics server: %v", err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", metricsServerAddress, err)
 	}
 	defer conn.Close()
 

interop/xds/client/client.go

@@ -437,9 +437,9 @@ func main() {
 
 	clients := make([]testgrpc.TestServiceClient, *numChannels)
 	for i := 0; i < *numChannels; i++ {
-		conn, err := grpc.Dial(*server, grpc.WithTransportCredentials(creds))
+		conn, err := grpc.NewClient(*server, grpc.WithTransportCredentials(creds))
 		if err != nil {
-			logger.Fatalf("Fail to dial: %v", err)
+			logger.Fatalf("grpc.NewClient(%q) = %v", *server, err)
 		}
 		defer conn.Close()
 		clients[i] = testgrpc.NewTestServiceClient(conn)

interop/xds_federation/client.go

@@ -95,7 +95,7 @@ func main() {
 		}
 		cc, err := grpc.NewClient(uris[i], opts...)
 		if err != nil {
-			logger.Fatalf("Fail to dial %v: %v", uris[i], err)
+			logger.Fatalf("grpc.NewClient(%q) = %v", uris[i], err)
 		}
 		defer cc.Close()
 		clients = append(clients, clientConfig{

profiling/cmd/remote.go

@@ -79,9 +79,9 @@ func remoteCommand() error {
 	}
 
 	logger.Infof("dialing %s", *flagAddress)
-	cc, err := grpc.Dial(*flagAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	cc, err := grpc.NewClient(*flagAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
-		logger.Errorf("cannot dial %s: %v", *flagAddress, err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", *flagAddress, err)
 		return err
 	}
 	defer cc.Close()

resolver/manual/manual.go

@@ -110,7 +110,7 @@ func (r *Resolver) UpdateState(s resolver.State) {
 	defer r.mu.Unlock()
 	var err error
 	if r.CC == nil {
-		panic("cannot update state as grpc.Dial with resolver has not been called")
+		panic("cannot update state as channel has not exited IDLE state")
 	}
 	err = r.CC.UpdateState(s)
 	r.lastSeenState = &s
@@ -122,7 +122,7 @@ func (r *Resolver) ReportError(err error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	if r.CC == nil {
-		panic("cannot report error as grpc.Dial with resolver has not been called")
+		panic("cannot report error as channel has not exited IDLE state")
 	}
 	r.CC.ReportError(err)
 }

resolver/manual/manual_test.go

@@ -38,7 +38,7 @@ func TestResolver(t *testing.T) {
 
 	t.Run("update_state_panics", func(t *testing.T) {
 		defer func() {
-			want := "cannot update state as grpc.Dial with resolver has not been called"
+			want := "cannot update state as channel has not exited IDLE state"
 			if r := recover(); r != want {
 				t.Errorf("expected panic %q, got %q", want, r)
 			}
@@ -50,7 +50,7 @@ func TestResolver(t *testing.T) {
 	})
 	t.Run("report_error_panics", func(t *testing.T) {
 		defer func() {
-			want := "cannot report error as grpc.Dial with resolver has not been called"
+			want := "cannot report error as channel has not exited IDLE state"
 			if r := recover(); r != want {
 				t.Errorf("expected panic %q, got %q", want, r)
 			}

test/goaway_test.go

@@ -677,6 +677,7 @@ func (s) TestGoAwayStreamIDSmallerThanCreatedStreams(t *testing.T) {
 	}
 	defer cc.Close()
 	cc.Connect()
+
 	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
 	defer cancel()
 

test/xds/xds_client_certificate_providers_test.go

@@ -169,7 +169,7 @@ func (s) TestClientSideXDS_WithNoCertificateProvidersInBootstrap_Failure(t *test
 	// Create a ClientConn and ensure that it moves to TRANSIENT_FAILURE.
 	cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(creds), grpc.WithResolvers(resolverBuilder))
 	if err != nil {
-		t.Fatalf("failed to create a client for server: %v", err)
+		t.Fatalf("grpc.NewClient() failed: %v", err)
 	}
 	defer cc.Close()
 	cc.Connect()

xds/internal/test/e2e/e2e.go

@@ -71,7 +71,7 @@ func newClient(target, binaryPath, bootstrap string, logger io.Writer, flags ...
 	)
 	cmd.Start()
 
-	cc, err := grpc.Dial(fmt.Sprintf("localhost:%d", clientStatsPort), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultCallOptions(grpc.WaitForReady(true)))
+	cc, err := grpc.NewClient(fmt.Sprintf("localhost:%d", clientStatsPort), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultCallOptions(grpc.WaitForReady(true)))
 	if err != nil {
 		return nil, err
 	}