From 7ddbe469d36ac42a4c8884de9f50aa674755ea07 Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Mon, 23 Dec 2024 07:09:57 +0000 Subject: [PATCH 01/12] replace dial with newclient --- test/goaway_test.go | 5 +++-- test/healthcheck_test.go | 5 +++-- test/resolver_update_test.go | 12 ++++++------ test/xds/xds_client_certificate_providers_test.go | 5 +++-- 4 files changed, 15 insertions(+), 12 deletions(-) diff --git a/test/goaway_test.go b/test/goaway_test.go index 65d2cc02d05a..cdffecb35245 100644 --- a/test/goaway_test.go +++ b/test/goaway_test.go @@ -672,11 +672,12 @@ func (s) TestGoAwayStreamIDSmallerThanCreatedStreams(t *testing.T) { ctCh.Send(ct) }() - cc, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) + cc, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - t.Fatalf("error dialing: %v", err) + t.Fatalf("NewClient() failed: %v", err) } defer cc.Close() + cc.Connect() ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) defer cancel() diff --git a/test/healthcheck_test.go b/test/healthcheck_test.go index fac565240ab7..42fdb4518e42 100644 --- a/test/healthcheck_test.go +++ b/test/healthcheck_test.go @@ -224,10 +224,11 @@ func setupClient(t *testing.T, c *clientConfig) (*grpc.ClientConn, *manual.Resol opts = append(opts, c.extraDialOption...) } - cc, err := grpc.Dial(r.Scheme()+":///test.server", opts...) + cc, err := grpc.NewClient(r.Scheme()+":///test.server", opts...) if err != nil { - t.Fatalf("grpc.Dial() failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } + cc.Connect() t.Cleanup(func() { cc.Close() }) return cc, r } diff --git a/test/resolver_update_test.go b/test/resolver_update_test.go index 619979b9b045..d6a7eefb2413 100644 --- a/test/resolver_update_test.go +++ b/test/resolver_update_test.go @@ -112,12 +112,12 @@ func (s) TestResolverUpdateDuringBuild_ServiceConfigInvalidTypeError(t *testing. func (s) TestResolverUpdate_InvalidServiceConfigAsFirstUpdate(t *testing.T) { r := manual.NewBuilderWithScheme("whatever") - cc, err := grpc.Dial(r.Scheme()+":///test.server", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r)) + cc, err := grpc.NewClient(r.Scheme()+":///test.server", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r)) if err != nil { - t.Fatalf("Dial(_, _) = _, %v; want _, nil", err) + t.Fatalf("NewClient(_, _) = _, %v; want _, nil", err) } defer cc.Close() - + cc.Connect() scpr := r.CC.ParseServiceConfig("bad json service config") r.UpdateState(resolver.State{ServiceConfig: scpr}) @@ -195,12 +195,12 @@ func (s) TestResolverUpdate_InvalidServiceConfigAfterGoodUpdate(t *testing.T) { r := manual.NewBuilderWithScheme("whatever") - cc, err := grpc.Dial(r.Scheme()+":///test.server", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r)) + cc, err := grpc.NewClient(r.Scheme()+":///test.server", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r)) if err != nil { - t.Fatalf("Dial(_, _) = _, %v; want _, nil", err) + t.Fatalf("NewClient(_, _) = _, %v; want _, nil", err) } defer cc.Close() - + cc.Connect() // Push a resolver update and verify that our balancer receives the update. addrs := []resolver.Address{{Addr: backend.Address}} const lbCfg = "wrapping balancer LB policy config" diff --git a/test/xds/xds_client_certificate_providers_test.go b/test/xds/xds_client_certificate_providers_test.go index 03d9f7f19519..af580cb47085 100644 --- a/test/xds/xds_client_certificate_providers_test.go +++ b/test/xds/xds_client_certificate_providers_test.go @@ -167,11 +167,12 @@ func (s) TestClientSideXDS_WithNoCertificateProvidersInBootstrap_Failure(t *test } // Create a ClientConn and ensure that it moves to TRANSIENT_FAILURE. - cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(creds), grpc.WithResolvers(resolverBuilder)) + cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(creds), grpc.WithResolvers(resolverBuilder)) if err != nil { - t.Fatalf("failed to dial local test server: %v", err) + t.Fatalf("NewClient() failed: %v", err) } defer cc.Close() + cc.Connect() testutils.AwaitState(ctx, t, cc, connectivity.TransientFailure) // Make an RPC and ensure that expected error is returned. From 9650b1a45e91e29570dd704f60130d4a5e074ad0 Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Thu, 26 Dec 2024 06:29:19 +0000 Subject: [PATCH 02/12] replace dial with newclient --- admin/test/utils.go | 2 +- balancer/grpclb/grpclb_remote_balancer.go | 5 +++-- balancer/rls/control_channel.go | 3 ++- benchmark/benchmark.go | 4 ++-- credentials/alts/internal/handshaker/service/service.go | 2 +- internal/stubserver/stubserver.go | 5 +++-- interop/alts/client/client.go | 4 ++-- interop/client/client.go | 4 ++-- interop/grpclb_fallback/client_linux.go | 4 ++-- interop/http2/negative_http2_client.go | 4 ++-- interop/observability/client/client.go | 4 ++-- interop/stress/client/main.go | 2 +- interop/stress/metrics_client/main.go | 2 +- interop/test_utils.go | 2 +- interop/xds/client/client.go | 4 ++-- interop/xds_federation/client.go | 4 ++-- profiling/cmd/remote.go | 4 ++-- resolver/manual/manual.go | 4 ++-- resolver/manual/manual_test.go | 4 ++-- xds/internal/test/e2e/e2e.go | 2 +- 20 files changed, 36 insertions(+), 33 deletions(-) diff --git a/admin/test/utils.go b/admin/test/utils.go index 26391c41ee03..a3ae07881374 100644 --- a/admin/test/utils.go +++ b/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) } diff --git a/balancer/grpclb/grpclb_remote_balancer.go b/balancer/grpclb/grpclb_remote_balancer.go index 506fae0d4e2d..f2df56120fec 100644 --- a/balancer/grpclb/grpclb_remote_balancer.go +++ b/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, diff --git a/balancer/rls/control_channel.go b/balancer/rls/control_channel.go index f2ad8bc720e4..5631770b7730 100644 --- a/balancer/rls/control_channel.go +++ b/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) diff --git a/benchmark/benchmark.go b/benchmark/benchmark.go index 0d4558f4ec80..2585f88047d4 100644 --- a/benchmark/benchmark.go +++ b/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) } diff --git a/credentials/alts/internal/handshaker/service/service.go b/credentials/alts/internal/handshaker/service/service.go index fbfde5d047fe..e0a1afc118cc 100644 --- a/credentials/alts/internal/handshaker/service/service.go +++ b/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 } diff --git a/internal/stubserver/stubserver.go b/internal/stubserver/stubserver.go index 2e404e294bf6..3114a3b8424f 100644 --- a/internal/stubserver/stubserver.go +++ b/internal/stubserver/stubserver.go @@ -214,10 +214,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}}}) diff --git a/interop/alts/client/client.go b/interop/alts/client/client.go index aef601ff885b..6f71f61ae53a 100644 --- a/interop/alts/client/client.go +++ b/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: NewClient() failed %v: %v", *serverAddr, err) } defer conn.Close() grpcClient := testgrpc.NewTestServiceClient(conn) diff --git a/interop/client/client.go b/interop/client/client.go index f50139fe6dbb..539e6b315e5a 100644 --- a/interop/client/client.go +++ b/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("NewClient() failed: %v", err) } defer conn.Close() tc := testgrpc.NewTestServiceClient(conn) diff --git a/interop/grpclb_fallback/client_linux.go b/interop/grpclb_fallback/client_linux.go index 9498182493b1..47556ec3c6f5 100644 --- a/interop/grpclb_fallback/client_linux.go +++ b/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("NewClient() failed: %v", err) } return conn } diff --git a/interop/http2/negative_http2_client.go b/interop/http2/negative_http2_client.go index 771845309c29..367faa2ada86 100644 --- a/interop/http2/negative_http2_client.go +++ b/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("NewClient() failed: %v", err) } defer conn.Close() tc := testgrpc.NewTestServiceClient(conn) diff --git a/interop/observability/client/client.go b/interop/observability/client/client.go index 0a07994bb853..5888a6055fd8 100644 --- a/interop/observability/client/client.go +++ b/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("NewClient() failed: %v", err) } defer conn.Close() tc := testgrpc.NewTestServiceClient(conn) diff --git a/interop/stress/client/main.go b/interop/stress/client/main.go index 8b22716bf0d4..457ff54c05c6 100644 --- a/interop/stress/client/main.go +++ b/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() { diff --git a/interop/stress/metrics_client/main.go b/interop/stress/metrics_client/main.go index f6e16abddad2..02f12ca4d571 100644 --- a/interop/stress/metrics_client/main.go +++ b/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) } diff --git a/interop/test_utils.go b/interop/test_utils.go index 71d0b0f060be..98f377cb054a 100644 --- a/interop/test_utils.go +++ b/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 } diff --git a/interop/xds/client/client.go b/interop/xds/client/client.go index e74831add335..a2f6bf592003 100644 --- a/interop/xds/client/client.go +++ b/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("NewClient() failed: %v", err) } defer conn.Close() clients[i] = testgrpc.NewTestServiceClient(conn) diff --git a/interop/xds_federation/client.go b/interop/xds_federation/client.go index 56572e4a35c3..df738d463384 100644 --- a/interop/xds_federation/client.go +++ b/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("NewClient() failed %v: %v", uris[i], err) } defer cc.Close() clients = append(clients, clientConfig{ diff --git a/profiling/cmd/remote.go b/profiling/cmd/remote.go index b75c3e3bb33b..fa79ae277617 100644 --- a/profiling/cmd/remote.go +++ b/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.Errorf("NewClient() failed %s: %v", *flagAddress, err) return err } defer cc.Close() diff --git a/resolver/manual/manual.go b/resolver/manual/manual.go index 09e864a89d35..4d8e1aceba20 100644 --- a/resolver/manual/manual.go +++ b/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 grpc.NewClient with resolver has not been called") } 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) } diff --git a/resolver/manual/manual_test.go b/resolver/manual/manual_test.go index 2d089268b778..a0e10e93be0e 100644 --- a/resolver/manual/manual_test.go +++ b/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 grpc.NewClient with resolver has not been called" 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) } diff --git a/xds/internal/test/e2e/e2e.go b/xds/internal/test/e2e/e2e.go index 30b125b787a1..2869a9300f36 100644 --- a/xds/internal/test/e2e/e2e.go +++ b/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 } From 0068eaaa2558eecd3ef0c60ba56966ff725aaaf9 Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Thu, 26 Dec 2024 09:19:38 +0000 Subject: [PATCH 03/12] updating error messages --- interop/alts/client/client.go | 2 +- interop/client/client.go | 2 +- interop/grpclb_fallback/client_linux.go | 2 +- interop/http2/negative_http2_client.go | 2 +- interop/observability/client/client.go | 2 +- interop/xds/client/client.go | 2 +- interop/xds_federation/client.go | 2 +- profiling/cmd/remote.go | 2 +- resolver/manual/manual.go | 2 +- resolver/manual/manual_test.go | 2 +- 10 files changed, 10 insertions(+), 10 deletions(-) diff --git a/interop/alts/client/client.go b/interop/alts/client/client.go index 6f71f61ae53a..7b88f7cdabeb 100644 --- a/interop/alts/client/client.go +++ b/interop/alts/client/client.go @@ -50,7 +50,7 @@ func main() { // Block until the server is ready. conn, err := grpc.NewClient(*serverAddr, grpc.WithTransportCredentials(altsTC), grpc.WithBlock()) if err != nil { - logger.Fatalf("gRPC Client: NewClient() failed %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) diff --git a/interop/client/client.go b/interop/client/client.go index 539e6b315e5a..e7c51ea7bbcb 100644 --- a/interop/client/client.go +++ b/interop/client/client.go @@ -263,7 +263,7 @@ func main() { } conn, err := grpc.NewClient(serverAddr, opts...) if err != nil { - logger.Fatalf("NewClient() failed: %v", err) + logger.Fatalf("Failed to create a client: %v", err) } defer conn.Close() tc := testgrpc.NewTestServiceClient(conn) diff --git a/interop/grpclb_fallback/client_linux.go b/interop/grpclb_fallback/client_linux.go index 47556ec3c6f5..f68d95561cae 100644 --- a/interop/grpclb_fallback/client_linux.go +++ b/interop/grpclb_fallback/client_linux.go @@ -114,7 +114,7 @@ func createTestConn() *grpc.ClientConn { } conn, err := grpc.NewClient(*serverURI, opts...) if err != nil { - errorLog.Fatalf("NewClient() failed: %v", err) + errorLog.Fatalf("Failed to create a client: %v", err) } return conn } diff --git a/interop/http2/negative_http2_client.go b/interop/http2/negative_http2_client.go index 367faa2ada86..4ef9e22324f0 100644 --- a/interop/http2/negative_http2_client.go +++ b/interop/http2/negative_http2_client.go @@ -135,7 +135,7 @@ func main() { opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient(serverAddr, opts...) if err != nil { - logger.Fatalf("NewClient() failed: %v", err) + logger.Fatalf("Failed to create a client: %v", err) } defer conn.Close() tc := testgrpc.NewTestServiceClient(conn) diff --git a/interop/observability/client/client.go b/interop/observability/client/client.go index 5888a6055fd8..cf7cdb1a8f4f 100644 --- a/interop/observability/client/client.go +++ b/interop/observability/client/client.go @@ -59,7 +59,7 @@ func main() { } conn, err := grpc.NewClient(serverAddr, grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - log.Fatalf("NewClient() failed: %v", err) + log.Fatalf("Failed to create a client: %v", err) } defer conn.Close() tc := testgrpc.NewTestServiceClient(conn) diff --git a/interop/xds/client/client.go b/interop/xds/client/client.go index a2f6bf592003..53d43bbed352 100644 --- a/interop/xds/client/client.go +++ b/interop/xds/client/client.go @@ -439,7 +439,7 @@ func main() { for i := 0; i < *numChannels; i++ { conn, err := grpc.NewClient(*server, grpc.WithTransportCredentials(creds)) if err != nil { - logger.Fatalf("NewClient() failed: %v", err) + logger.Fatalf("Failed to create a client: %v", err) } defer conn.Close() clients[i] = testgrpc.NewTestServiceClient(conn) diff --git a/interop/xds_federation/client.go b/interop/xds_federation/client.go index df738d463384..fe4ee4bbf134 100644 --- a/interop/xds_federation/client.go +++ b/interop/xds_federation/client.go @@ -103,7 +103,7 @@ func main() { } cc, err := grpc.NewClient(uris[i], opts...) if err != nil { - logger.Fatalf("NewClient() failed %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{ diff --git a/profiling/cmd/remote.go b/profiling/cmd/remote.go index fa79ae277617..2613f6353e20 100644 --- a/profiling/cmd/remote.go +++ b/profiling/cmd/remote.go @@ -81,7 +81,7 @@ func remoteCommand() error { logger.Infof("dialing %s", *flagAddress) cc, err := grpc.NewClient(*flagAddress, grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - logger.Errorf("NewClient() failed %s: %v", *flagAddress, err) + logger.Errorf("Failed to create a client for server %q: %v", *flagAddress, err) return err } defer cc.Close() diff --git a/resolver/manual/manual.go b/resolver/manual/manual.go index 4d8e1aceba20..2ad8be8dca98 100644 --- a/resolver/manual/manual.go +++ b/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.NewClient 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 diff --git a/resolver/manual/manual_test.go b/resolver/manual/manual_test.go index a0e10e93be0e..3ae769c4b61e 100644 --- a/resolver/manual/manual_test.go +++ b/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.NewClient 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) } From 2ec28ced13f5413ce8c3738f5974602ceefa78fd Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Fri, 31 Jan 2025 12:02:37 +0000 Subject: [PATCH 04/12] updating comments --- admin/test/utils.go | 2 +- resolver/manual/manual.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/admin/test/utils.go b/admin/test/utils.go index a3ae07881374..eaab5a472a69 100644 --- a/admin/test/utils.go +++ b/admin/test/utils.go @@ -70,7 +70,7 @@ func RunRegisterTests(t *testing.T, ec ExpectedStatusCodes) { conn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - t.Fatalf("cannot connect to server: %v", err) + t.Fatalf("Failed to create a client for server: %v", err) } t.Run("channelz", func(t *testing.T) { diff --git a/resolver/manual/manual.go b/resolver/manual/manual.go index 2ad8be8dca98..8400b5f2b659 100644 --- a/resolver/manual/manual.go +++ b/resolver/manual/manual.go @@ -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.NewClient with resolver has not been called") + panic("cannot report error as channel has not exited IDLE state") } r.CC.ReportError(err) } From a7b5bd2c0cbf02e54d2448e0deb579fea2f00ade Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Fri, 31 Jan 2025 17:47:40 +0000 Subject: [PATCH 05/12] resolving merge conflicts --- interop/test_utils.go | 97 ------------------------------------------- 1 file changed, 97 deletions(-) diff --git a/interop/test_utils.go b/interop/test_utils.go index 98f377cb054a..3aa7bd307a9b 100644 --- a/interop/test_utils.go +++ b/interop/test_utils.go @@ -24,7 +24,6 @@ package interop import ( - "bytes" "context" "fmt" "io" @@ -36,12 +35,10 @@ import ( "golang.org/x/oauth2" "golang.org/x/oauth2/google" "google.golang.org/grpc" - "google.golang.org/grpc/benchmark/stats" "google.golang.org/grpc/codes" "google.golang.org/grpc/grpclog" "google.golang.org/grpc/metadata" "google.golang.org/grpc/orca" - "google.golang.org/grpc/peer" "google.golang.org/grpc/status" "google.golang.org/protobuf/proto" @@ -684,100 +681,6 @@ func DoPickFirstUnary(ctx context.Context, tc testgrpc.TestServiceClient) { } } -func doOneSoakIteration(ctx context.Context, tc testgrpc.TestServiceClient, resetChannel bool, serverAddr string, soakRequestSize int, soakResponseSize int, dopts []grpc.DialOption, copts []grpc.CallOption) (latency time.Duration, err error) { - start := time.Now() - client := tc - if resetChannel { - var conn *grpc.ClientConn - conn, err = grpc.NewClient(serverAddr, dopts...) - if err != nil { - return - } - defer conn.Close() - client = testgrpc.NewTestServiceClient(conn) - } - // per test spec, don't include channel shutdown in latency measurement - defer func() { latency = time.Since(start) }() - // do a large-unary RPC - pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, soakRequestSize) - req := &testpb.SimpleRequest{ - ResponseType: testpb.PayloadType_COMPRESSABLE, - ResponseSize: int32(soakResponseSize), - Payload: pl, - } - var reply *testpb.SimpleResponse - reply, err = client.UnaryCall(ctx, req, copts...) - if err != nil { - err = fmt.Errorf("/TestService/UnaryCall RPC failed: %s", err) - return - } - t := reply.GetPayload().GetType() - s := len(reply.GetPayload().GetBody()) - if t != testpb.PayloadType_COMPRESSABLE || s != soakResponseSize { - err = fmt.Errorf("got the reply with type %d len %d; want %d, %d", t, s, testpb.PayloadType_COMPRESSABLE, soakResponseSize) - return - } - return -} - -// DoSoakTest runs large unary RPCs in a loop for a configurable number of times, with configurable failure thresholds. -// If resetChannel is false, then each RPC will be performed on tc. Otherwise, each RPC will be performed on a new -// stub that is created with the provided server address and dial options. -// TODO(mohanli-ml): Create SoakTestOptions as a parameter for this method. -func DoSoakTest(ctx context.Context, tc testgrpc.TestServiceClient, serverAddr string, dopts []grpc.DialOption, resetChannel bool, soakIterations int, maxFailures int, soakRequestSize int, soakResponseSize int, perIterationMaxAcceptableLatency time.Duration, minTimeBetweenRPCs time.Duration) { - start := time.Now() - var elapsedTime float64 - iterationsDone := 0 - totalFailures := 0 - hopts := stats.HistogramOptions{ - NumBuckets: 20, - GrowthFactor: 1, - BaseBucketSize: 1, - MinValue: 0, - } - h := stats.NewHistogram(hopts) - for i := 0; i < soakIterations; i++ { - if ctx.Err() != nil { - elapsedTime = time.Since(start).Seconds() - break - } - earliestNextStart := time.After(minTimeBetweenRPCs) - iterationsDone++ - var p peer.Peer - latency, err := doOneSoakIteration(ctx, tc, resetChannel, serverAddr, soakRequestSize, soakResponseSize, dopts, []grpc.CallOption{grpc.Peer(&p)}) - latencyMs := int64(latency / time.Millisecond) - h.Add(latencyMs) - if err != nil { - totalFailures++ - addrStr := "nil" - if p.Addr != nil { - addrStr = p.Addr.String() - } - fmt.Fprintf(os.Stderr, "soak iteration: %d elapsed_ms: %d peer: %s server_uri: %s failed: %s\n", i, latencyMs, addrStr, serverAddr, err) - <-earliestNextStart - continue - } - if latency > perIterationMaxAcceptableLatency { - totalFailures++ - fmt.Fprintf(os.Stderr, "soak iteration: %d elapsed_ms: %d peer: %s server_uri: %s exceeds max acceptable latency: %d\n", i, latencyMs, p.Addr.String(), serverAddr, perIterationMaxAcceptableLatency.Milliseconds()) - <-earliestNextStart - continue - } - fmt.Fprintf(os.Stderr, "soak iteration: %d elapsed_ms: %d peer: %s server_uri: %s succeeded\n", i, latencyMs, p.Addr.String(), serverAddr) - <-earliestNextStart - } - var b bytes.Buffer - h.Print(&b) - fmt.Fprintf(os.Stderr, "(server_uri: %s) histogram of per-iteration latencies in milliseconds: %s\n", serverAddr, b.String()) - fmt.Fprintf(os.Stderr, "(server_uri: %s) soak test ran: %d / %d iterations. total failures: %d. max failures threshold: %d. See breakdown above for which iterations succeeded, failed, and why for more info.\n", serverAddr, iterationsDone, soakIterations, totalFailures, maxFailures) - if iterationsDone < soakIterations { - logger.Fatalf("(server_uri: %s) soak test consumed all %f seconds of time and quit early, only having ran %d out of desired %d iterations.", serverAddr, elapsedTime, iterationsDone, soakIterations) - } - if totalFailures > maxFailures { - logger.Fatalf("(server_uri: %s) soak test total failures: %d exceeds max failures threshold: %d.", serverAddr, totalFailures, maxFailures) - } -} - type testServer struct { testgrpc.UnimplementedTestServiceServer From d07a5ec857052c719bb97fa9280652643e3209f8 Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Fri, 31 Jan 2025 18:20:55 +0000 Subject: [PATCH 06/12] updating error msg --- resolver/manual/manual_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/resolver/manual/manual_test.go b/resolver/manual/manual_test.go index 3ae769c4b61e..9f1701b10053 100644 --- a/resolver/manual/manual_test.go +++ b/resolver/manual/manual_test.go @@ -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.NewClient 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) } From dc427c919f9eace31748df3be9dd682c099216cb Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Fri, 14 Feb 2025 07:54:25 +0000 Subject: [PATCH 07/12] reverting conflict file --- balancer/rls/control_channel.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/balancer/rls/control_channel.go b/balancer/rls/control_channel.go index 5631770b7730..f2ad8bc720e4 100644 --- a/balancer/rls/control_channel.go +++ b/balancer/rls/control_channel.go @@ -75,11 +75,10 @@ func newControlChannel(rlsServerName, serviceConfig string, rpcTimeout time.Dura if err != nil { return nil, err } - ctrlCh.cc, err = grpc.NewClient(rlsServerName, dopts...) + ctrlCh.cc, err = grpc.Dial(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) From 4a69262e065694e5c889e3bcf829e731e9c53768 Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Mon, 17 Feb 2025 07:06:51 +0000 Subject: [PATCH 08/12] Revert "reverting conflict file" This reverts commit dc427c919f9eace31748df3be9dd682c099216cb. --- balancer/rls/control_channel.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/balancer/rls/control_channel.go b/balancer/rls/control_channel.go index f2ad8bc720e4..5631770b7730 100644 --- a/balancer/rls/control_channel.go +++ b/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) From 1c8710670fa797d4b870f064ac0c0f39f9b5caf8 Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Mon, 17 Feb 2025 07:14:48 +0000 Subject: [PATCH 09/12] Reapply "reverting conflict file" This reverts commit 4a69262e065694e5c889e3bcf829e731e9c53768. --- balancer/rls/control_channel.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/balancer/rls/control_channel.go b/balancer/rls/control_channel.go index 5631770b7730..f2ad8bc720e4 100644 --- a/balancer/rls/control_channel.go +++ b/balancer/rls/control_channel.go @@ -75,11 +75,10 @@ func newControlChannel(rlsServerName, serviceConfig string, rpcTimeout time.Dura if err != nil { return nil, err } - ctrlCh.cc, err = grpc.NewClient(rlsServerName, dopts...) + ctrlCh.cc, err = grpc.Dial(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) From d7f8602fe224e020f367a3c5199c4b3128594ffd Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Tue, 25 Feb 2025 11:32:52 +0000 Subject: [PATCH 10/12] removing redundant call --- test/resolver_update_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/resolver_update_test.go b/test/resolver_update_test.go index d46dbcff3306..b8a2d443f40f 100644 --- a/test/resolver_update_test.go +++ b/test/resolver_update_test.go @@ -118,7 +118,7 @@ func (s) TestResolverUpdate_InvalidServiceConfigAsFirstUpdate(t *testing.T) { } cc.Connect() defer cc.Close() - cc.Connect() + scpr := r.CC.ParseServiceConfig("bad json service config") r.UpdateState(resolver.State{ServiceConfig: scpr}) From 20d197211cb037907a34d8337c0d8d9883606090 Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Tue, 25 Feb 2025 12:16:34 +0000 Subject: [PATCH 11/12] updating fatal msg --- admin/test/utils.go | 2 +- benchmark/benchmark.go | 2 +- interop/alts/client/client.go | 4 ++-- interop/client/client.go | 2 +- interop/grpclb_fallback/client_linux.go | 2 +- interop/http2/negative_http2_client.go | 2 +- interop/observability/client/client.go | 2 +- interop/stress/metrics_client/main.go | 2 +- interop/xds/client/client.go | 2 +- interop/xds_federation/client.go | 2 +- profiling/cmd/remote.go | 2 +- test/goaway_test.go | 2 +- test/xds/xds_client_certificate_providers_test.go | 2 +- 13 files changed, 14 insertions(+), 14 deletions(-) diff --git a/admin/test/utils.go b/admin/test/utils.go index eaab5a472a69..2f86c15c38d0 100644 --- a/admin/test/utils.go +++ b/admin/test/utils.go @@ -70,7 +70,7 @@ func RunRegisterTests(t *testing.T, ec ExpectedStatusCodes) { conn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - t.Fatalf("Failed to create a client for server: %v", err) + t.Fatalf("grpc.NewClient(%q) = %v", lis.Addr().String(), err) } t.Run("channelz", func(t *testing.T) { diff --git a/benchmark/benchmark.go b/benchmark/benchmark.go index 2585f88047d4..5c3dcd51db9d 100644 --- a/benchmark/benchmark.go +++ b/benchmark/benchmark.go @@ -343,7 +343,7 @@ func NewClientConn(addr string, opts ...grpc.DialOption) *grpc.ClientConn { 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 } diff --git a/interop/alts/client/client.go b/interop/alts/client/client.go index 7b88f7cdabeb..d46280282efe 100644 --- a/interop/alts/client/client.go +++ b/interop/alts/client/client.go @@ -48,9 +48,9 @@ func main() { } altsTC := alts.NewClientCreds(opts) // Block until the server is ready. - conn, err := grpc.NewClient(*serverAddr, grpc.WithTransportCredentials(altsTC), grpc.WithBlock()) + conn, err := grpc.NewClient(*serverAddr, grpc.WithTransportCredentials(altsTC)) if err != nil { - logger.Fatalf("gRPC Client: failed to create a client for server at %q: %v", *serverAddr, err) + logger.Fatalf("grpc.NewClient(%q) = %v", *serverAddr, err) } defer conn.Close() grpcClient := testgrpc.NewTestServiceClient(conn) diff --git a/interop/client/client.go b/interop/client/client.go index 42ed7e74208a..249dd637ab9d 100644 --- a/interop/client/client.go +++ b/interop/client/client.go @@ -280,7 +280,7 @@ func main() { } conn, err := grpc.NewClient(serverAddr, opts...) if err != nil { - logger.Fatalf("Failed to create a client: %v", err) + logger.Fatalf("grpc.NewClient(%q) = %v", serverAddr, err) } defer conn.Close() tc := testgrpc.NewTestServiceClient(conn) diff --git a/interop/grpclb_fallback/client_linux.go b/interop/grpclb_fallback/client_linux.go index f68d95561cae..47c16ad3aa04 100644 --- a/interop/grpclb_fallback/client_linux.go +++ b/interop/grpclb_fallback/client_linux.go @@ -114,7 +114,7 @@ func createTestConn() *grpc.ClientConn { } conn, err := grpc.NewClient(*serverURI, opts...) if err != nil { - errorLog.Fatalf("Failed to create a client: %v", err) + errorLog.Fatalf("grpc.NewClient(%q) = %v", *serverURI, err) } return conn } diff --git a/interop/http2/negative_http2_client.go b/interop/http2/negative_http2_client.go index 4ef9e22324f0..35c7b54a4444 100644 --- a/interop/http2/negative_http2_client.go +++ b/interop/http2/negative_http2_client.go @@ -135,7 +135,7 @@ func main() { opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient(serverAddr, opts...) if err != nil { - logger.Fatalf("Failed to create a client: %v", err) + logger.Fatalf("grpc.NewClient(%q) = %v", serverAddr, err) } defer conn.Close() tc := testgrpc.NewTestServiceClient(conn) diff --git a/interop/observability/client/client.go b/interop/observability/client/client.go index cf7cdb1a8f4f..0850e706ed44 100644 --- a/interop/observability/client/client.go +++ b/interop/observability/client/client.go @@ -59,7 +59,7 @@ func main() { } conn, err := grpc.NewClient(serverAddr, grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - log.Fatalf("Failed to create a client: %v", err) + log.Fatalf("grpc.NewClient(%q) = %v", serverAddr, err) } defer conn.Close() tc := testgrpc.NewTestServiceClient(conn) diff --git a/interop/stress/metrics_client/main.go b/interop/stress/metrics_client/main.go index 02f12ca4d571..84b4e6b508bb 100644 --- a/interop/stress/metrics_client/main.go +++ b/interop/stress/metrics_client/main.go @@ -77,7 +77,7 @@ func main() { 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() diff --git a/interop/xds/client/client.go b/interop/xds/client/client.go index 53d43bbed352..a46640c54d84 100644 --- a/interop/xds/client/client.go +++ b/interop/xds/client/client.go @@ -439,7 +439,7 @@ func main() { for i := 0; i < *numChannels; i++ { conn, err := grpc.NewClient(*server, grpc.WithTransportCredentials(creds)) if err != nil { - logger.Fatalf("Failed to create a client: %v", err) + logger.Fatalf("grpc.NewClient(%q) = %v", server, err) } defer conn.Close() clients[i] = testgrpc.NewTestServiceClient(conn) diff --git a/interop/xds_federation/client.go b/interop/xds_federation/client.go index a762369b9380..d7e9fd3ec637 100644 --- a/interop/xds_federation/client.go +++ b/interop/xds_federation/client.go @@ -95,7 +95,7 @@ func main() { } cc, err := grpc.NewClient(uris[i], opts...) if err != nil { - logger.Fatalf("Failed to create a client for server %q: %v", uris[i], err) + logger.Fatalf("grpc.NewClient(%q) = %v", uris[i], err) } defer cc.Close() clients = append(clients, clientConfig{ diff --git a/profiling/cmd/remote.go b/profiling/cmd/remote.go index 2613f6353e20..e21ef146211f 100644 --- a/profiling/cmd/remote.go +++ b/profiling/cmd/remote.go @@ -81,7 +81,7 @@ func remoteCommand() error { logger.Infof("dialing %s", *flagAddress) cc, err := grpc.NewClient(*flagAddress, grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - logger.Errorf("Failed to create a client for server %q: %v", *flagAddress, err) + logger.Fatalf("grpc.NewClient(%q) = %v", *flagAddress, err) return err } defer cc.Close() diff --git a/test/goaway_test.go b/test/goaway_test.go index a9285bb514e4..1e23a65f790e 100644 --- a/test/goaway_test.go +++ b/test/goaway_test.go @@ -676,7 +676,7 @@ func (s) TestGoAwayStreamIDSmallerThanCreatedStreams(t *testing.T) { cc, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - t.Fatalf("NewClient() failed: %v", err) + t.Fatalf("grpc.NewClient(%q) = %v", lis.Addr().String(), err) } defer cc.Close() cc.Connect() diff --git a/test/xds/xds_client_certificate_providers_test.go b/test/xds/xds_client_certificate_providers_test.go index 37fa7f9785e6..7f5ade582663 100644 --- a/test/xds/xds_client_certificate_providers_test.go +++ b/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() From 37d9883b3db50ec78b40006146179ee42f611bb2 Mon Sep 17 00:00:00 2001 From: Vissa Janardhan Krishna Sai Date: Thu, 27 Feb 2025 11:00:08 +0000 Subject: [PATCH 12/12] dereferencing the server pointer in the log message --- interop/xds/client/client.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interop/xds/client/client.go b/interop/xds/client/client.go index a46640c54d84..d3ab7eb64a64 100644 --- a/interop/xds/client/client.go +++ b/interop/xds/client/client.go @@ -439,7 +439,7 @@ func main() { for i := 0; i < *numChannels; i++ { conn, err := grpc.NewClient(*server, grpc.WithTransportCredentials(creds)) if err != nil { - logger.Fatalf("grpc.NewClient(%q) = %v", server, err) + logger.Fatalf("grpc.NewClient(%q) = %v", *server, err) } defer conn.Close() clients[i] = testgrpc.NewTestServiceClient(conn)