cleanup: replace dial with newclient

admin/test/utils.go

@@ -68,7 +68,7 @@ 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)
 	}

balancer/grpclb/grpclb_remote_balancer.go

@@ -260,10 +260,11 @@
 	// 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,

balancer/rls/control_channel.go

@@ -75,10 +75,11 @@ func newControlChannel(rlsServerName, serviceConfig string, rpcTimeout time.Dura
 	if err != nil {
 		return nil, err
 	}
-	ctrlCh.cc, err = grpc.Dial(rlsServerName, dopts...)
+	ctrlCh.cc, err = grpc.NewClient(rlsServerName, dopts...)
 	if err != nil {
 		return nil, err
 	}
+	ctrlCh.cc.Connect()
 	ctrlCh.client = rlsgrpc.NewRouteLookupServiceClient(ctrlCh.cc)
 	ctrlCh.logger.Infof("Control channel created to RLS server at: %v", rlsServerName)
 

benchmark/benchmark.go

@@ -340,8 +340,8 @@ 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)
 	}

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

@@ -214,10 +214,11 @@
 		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), grpc.WithBlock())
 	if err != nil {
-		logger.Fatalf("gRPC Client: failed to dial the server at %v: %v", *serverAddr, err)
+		logger.Fatalf("gRPC Client: failed to create a client for server at %q: %v", *serverAddr, err)
 	}
 	defer conn.Close()
 	grpcClient := testgrpc.NewTestServiceClient(conn)

interop/client/client.go

@@ -261,9 +261,9 @@ func main() {
 		}
 		opts = append(opts, grpc.WithUnaryInterceptor(unaryAddMd), grpc.WithStreamInterceptor(streamingAddMd))
 	}
-	conn, err := grpc.Dial(serverAddr, opts...)
+	conn, err := grpc.NewClient(serverAddr, opts...)
 	if err != nil {
-		logger.Fatalf("Fail to dial: %v", err)
+		logger.Fatalf("Failed to create a client: %v", 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("Failed to create a client: %v", 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("Failed to create a client: %v", 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("Failed to create a client: %v", 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,7 +75,7 @@ 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)
 	}

interop/test_utils.go

@@ -689,7 +689,7 @@ func doOneSoakIteration(ctx context.Context, tc testgrpc.TestServiceClient, rese
 	client := tc
 	if resetChannel {
 		var conn *grpc.ClientConn
-		conn, err = grpc.Dial(serverAddr, dopts...)
+		conn, err = grpc.NewClient(serverAddr, dopts...)
 		if err != nil {
 			return
 		}

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("Failed to create a client: %v", err)
 		}
 		defer conn.Close()
 		clients[i] = testgrpc.NewTestServiceClient(conn)

interop/xds_federation/client.go

@@ -101,9 +101,9 @@ func main() {
 		case insecureCredsName:
 			opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
 		}
-		cc, err := grpc.Dial(uris[i], opts...)
+		cc, err := grpc.NewClient(uris[i], opts...)
 		if err != nil {
-			logger.Fatalf("Fail to dial %v: %v", uris[i], err)
+			logger.Fatalf("Failed to create a client for server %q: %v", uris[i], err)
 		}
 		defer cc.Close()
 		clients = append(clients, clientConfig{

profiling/cmd/remote.go

@@ -79,9 +79,9 @@
 	}
 
 	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.Errorf("Failed to create a client for server %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 grpc.NewClient with resolver has not been called")
 	}
 	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 grpc.NewClient with resolver has not been called"
 			if r := recover(); r != want {
 				t.Errorf("expected panic %q, got %q", want, r)
 			}

xds/internal/test/e2e/e2e.go

@@ -71,7 +71,7 @@
 	)
 	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
 	}