grpc
/
grpc-go
mirror of https://github.com/grpc/grpc-go.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cleanup: replace dial with newclient (#7967)

This commit is contained in:
janardhanvissa 2025-02-28 05:33:14 +05:30 committed by GitHub
parent d48317fafe
commit 52a257e680
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 137 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
balancer_wrapper_test.go
View File

@ -70,10 +70,11 @@ func (s) TestBalancer_StateListenerBeforeConnect(t *testing.T) {
stub.Register(t.Name(), bf)
svcCfg := fmt.Sprintf(`{ "loadBalancingConfig": [{%q: {}}] }`, t.Name())
cc, err := Dial("fake", WithTransportCredentials(insecure.NewCredentials()), WithDefaultServiceConfig(svcCfg))
cc, err := NewClient("passthrough:///test.server", WithTransportCredentials(insecure.NewCredentials()), WithDefaultServiceConfig(svcCfg))
if err != nil {
t.Fatal("Error dialing:", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
cc.Connect()
started.Fire()
// Wait for the LB policy to call NewSubConn and cc.Close.

133
clientconn_test.go
View File

@ -51,6 +51,8 @@ import (
const (
defaultTestTimeout = 10 * time.Second
stateRecordingBalancerName = "state_recording_balancer"
grpclbServiceConfig = `{"loadBalancingConfig": [{"grpclb": {}}]}`
rrServiceConfig = `{"loadBalancingPolicy": [{"round_robin": {}}]}`
)
var testBalancerBuilder = newStateRecordingBalancerBuilder()
@ -108,7 +110,7 @@ func (s) TestDialWithTimeout(t *testing.T) {
}
}
func (s) TestDialWithMultipleBackendsNotSendingServerPreface(t *testing.T) {
func (s) TestNewClientWithMultipleBackendsNotSendingServerPreface(t *testing.T) {
lis1, err := net.Listen("tcp", "localhost:0")
if err != nil {
t.Fatalf("Error while listening. Err: %v", err)
@ -146,10 +148,11 @@ func (s) TestDialWithMultipleBackendsNotSendingServerPreface(t *testing.T) {
r := manual.NewBuilderWithScheme("whatever")
r.InitialState(resolver.State{Addresses: []resolver.Address{lis1Addr, lis2Addr}})
client, err := Dial(r.Scheme()+":///test.server", WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r))
client, err := NewClient(r.Scheme()+":///test.server", WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r))
if err != nil {
t.Fatalf("Dial failed. Err: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
client.Connect()
defer client.Close()
timeout := time.After(5 * time.Second)
select {
@ -313,9 +316,9 @@ func (s) TestCloseConnectionWhenServerPrefaceNotReceived(t *testing.T) {
break
}
}()
client, err := Dial(lis.Addr().String(), WithTransportCredentials(insecure.NewCredentials()), withMinConnectDeadline(func() time.Duration { return time.Millisecond * 500 }))
client, err := NewClient(lis.Addr().String(), WithTransportCredentials(insecure.NewCredentials()), withMinConnectDeadline(func() time.Duration { return time.Millisecond * 500 }))
if err != nil {
t.Fatalf("Error while dialing. Err: %v", err)
t.Fatalf("grpc.NewClient(%q) = %v", lis.Addr().String(), err)
}
go stayConnected(client)
@ -379,9 +382,9 @@ func (s) TestBackoffWhenNoServerPrefaceReceived(t *testing.T) {
Backoff: bc,
MinConnectTimeout: 1 * time.Second,
}
cc, err := Dial(lis.Addr().String(), WithTransportCredentials(insecure.NewCredentials()), WithConnectParams(cp))
cc, err := NewClient(lis.Addr().String(), WithTransportCredentials(insecure.NewCredentials()), WithConnectParams(cp))
if err != nil {
t.Fatalf("Unexpected error from Dial(%v) = %v", lis.Addr(), err)
t.Fatalf("grpc.NewClient(%q) = %v", lis.Addr().String(), err)
}
defer cc.Close()
go stayConnected(cc)
@ -420,7 +423,7 @@ func (s) TestWithTransportCredentialsTLS(t *testing.T) {
// When creating a transport configured with n addresses, only calculate the
// backoff once per "round" of attempts instead of once per address (n times
// per "round" of attempts) for old pickfirst and once per address for new pickfirst.
func (s) TestDial_BackoffCountPerRetryGroup(t *testing.T) {
func (s) TestNewClient_BackoffCountPerRetryGroup(t *testing.T) {
var attempts uint32
wantBackoffs := uint32(1)
if envconfig.NewPickFirstEnabled {
@ -437,9 +440,6 @@ func (s) TestDial_BackoffCountPerRetryGroup(t *testing.T) {
return 0
}
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
lis1, err := net.Listen("tcp", "localhost:0")
if err != nil {
t.Fatalf("Error while listening. Err: %v", err)
@ -482,7 +482,7 @@ func (s) TestDial_BackoffCountPerRetryGroup(t *testing.T) {
{Addr: lis1.Addr().String()},
{Addr: lis2.Addr().String()},
}})
client, err := DialContext(ctx, "whatever:///this-gets-overwritten",
client, err := NewClient("whatever:///this-gets-overwritten",
WithTransportCredentials(insecure.NewCredentials()),
WithResolvers(rb),
withMinConnectDeadline(getMinConnectTimeout))
@ -490,7 +490,7 @@ func (s) TestDial_BackoffCountPerRetryGroup(t *testing.T) {
t.Fatal(err)
}
defer client.Close()
client.Connect()
timeout := time.After(15 * time.Second)
select {
@ -557,8 +557,8 @@ func (b *fakeBundleCreds) TransportCredentials() credentials.TransportCredential
func (s) TestCredentialsMisuse(t *testing.T) {
// Use of no transport creds and no creds bundle must fail.
if _, err := Dial("passthrough:///Non-Existent.Server:80"); err != errNoTransportSecurity {
t.Fatalf("Dial(_, _) = _, %v, want _, %v", err, errNoTransportSecurity)
if _, err := NewClient("passthrough:///Non-Existent.Server:80"); err != errNoTransportSecurity {
t.Fatalf("grpc.NewClient() failed with error: %v, want: %v", err, errNoTransportSecurity)
}
// Use of both transport creds and creds bundle must fail.
@ -570,19 +570,19 @@ func (s) TestCredentialsMisuse(t *testing.T) {
WithTransportCredentials(creds),
WithCredentialsBundle(&fakeBundleCreds{transportCreds: creds}),
}
if _, err := Dial("passthrough:///Non-Existent.Server:80", dopts...); err != errTransportCredsAndBundle {
t.Fatalf("Dial(_, _) = _, %v, want _, %v", err, errTransportCredsAndBundle)
if _, err := NewClient("passthrough:///Non-Existent.Server:80", dopts...); err != errTransportCredsAndBundle {
t.Fatalf("grpc.NewClient() failed with error: %v, want: %v", err, errTransportCredsAndBundle)
}
// Use of perRPC creds requiring transport security over an insecure
// transport must fail.
if _, err := Dial("passthrough:///Non-Existent.Server:80", WithPerRPCCredentials(securePerRPCCredentials{}), WithTransportCredentials(insecure.NewCredentials())); err != errTransportCredentialsMissing {
t.Fatalf("Dial(_, _) = _, %v, want _, %v", err, errTransportCredentialsMissing)
if _, err := NewClient("passthrough:///Non-Existent.Server:80", WithPerRPCCredentials(securePerRPCCredentials{}), WithTransportCredentials(insecure.NewCredentials())); err != errTransportCredentialsMissing {
t.Fatalf("grpc.NewClient() failed with error: %v, want: %v", err, errTransportCredentialsMissing)
}
// Use of a creds bundle with nil transport credentials must fail.
if _, err := Dial("passthrough:///Non-Existent.Server:80", WithCredentialsBundle(&fakeBundleCreds{})); err != errNoTransportCredsInBundle {
t.Fatalf("Dial(_, _) = _, %v, want _, %v", err, errTransportCredsAndBundle)
if _, err := NewClient("passthrough:///Non-Existent.Server:80", WithCredentialsBundle(&fakeBundleCreds{})); err != errNoTransportCredsInBundle {
t.Fatalf("grpc.NewClient() failed with error: %v, want: %v", err, errTransportCredsAndBundle)
}
}
@ -621,9 +621,9 @@ func (s) TestWithConnectParams(t *testing.T) {
func testBackoffConfigSet(t *testing.T, wantBackoff internalbackoff.Exponential, opts ...DialOption) {
opts = append(opts, WithTransportCredentials(insecure.NewCredentials()))
conn, err := Dial("passthrough:///foo:80", opts...)
conn, err := NewClient("passthrough:///foo:80", opts...)
if err != nil {
t.Fatalf("unexpected error dialing connection: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer conn.Close()
@ -644,9 +644,9 @@ func testBackoffConfigSet(t *testing.T, wantBackoff internalbackoff.Exponential,
func (s) TestConnectParamsWithMinConnectTimeout(t *testing.T) {
// Default value specified for minConnectTimeout in the spec is 20 seconds.
mct := 1 * time.Minute
conn, err := Dial("passthrough:///foo:80", WithTransportCredentials(insecure.NewCredentials()), WithConnectParams(ConnectParams{MinConnectTimeout: mct}))
conn, err := NewClient("passthrough:///foo:80", WithTransportCredentials(insecure.NewCredentials()), WithConnectParams(ConnectParams{MinConnectTimeout: mct}))
if err != nil {
t.Fatalf("unexpected error dialing connection: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer conn.Close()
@ -658,15 +658,15 @@ func (s) TestConnectParamsWithMinConnectTimeout(t *testing.T) {
func (s) TestResolverServiceConfigBeforeAddressNotPanic(t *testing.T) {
r := manual.NewBuilderWithScheme("whatever")
cc, err := Dial(r.Scheme()+":///test.server", WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r))
cc, err := NewClient(r.Scheme()+":///test.server", WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r))
if err != nil {
t.Fatalf("failed to dial: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc.Close()
cc.Connect()
// SwitchBalancer before NewAddress. There was no balancer created, this
// makes sure we don't call close on nil balancerWrapper.
r.UpdateState(resolver.State{ServiceConfig: parseCfg(r, `{"loadBalancingPolicy": "round_robin"}`)}) // This should not panic.
r.UpdateState(resolver.State{ServiceConfig: r.CC.ParseServiceConfig(grpclbServiceConfig)}) // This should not panic.
time.Sleep(time.Second) // Sleep to make sure the service config is handled by ClientConn.
}
@ -674,26 +674,26 @@ func (s) TestResolverServiceConfigBeforeAddressNotPanic(t *testing.T) {
func (s) TestResolverServiceConfigWhileClosingNotPanic(t *testing.T) {
for i := 0; i < 10; i++ { // Run this multiple times to make sure it doesn't panic.
r := manual.NewBuilderWithScheme(fmt.Sprintf("whatever-%d", i))
cc, err := Dial(r.Scheme()+":///test.server", WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r))
cc, err := NewClient(r.Scheme()+":///test.server", WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r))
if err != nil {
t.Fatalf("failed to dial: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
cc.Connect()
// Send a new service config while closing the ClientConn.
go cc.Close()
go r.UpdateState(resolver.State{ServiceConfig: parseCfg(r, `{"loadBalancingPolicy": "round_robin"}`)}) // This should not panic.
go r.UpdateState(resolver.State{ServiceConfig: r.CC.ParseServiceConfig(rrServiceConfig)}) // This should not panic.
}
}
func (s) TestResolverEmptyUpdateNotPanic(t *testing.T) {
r := manual.NewBuilderWithScheme("whatever")
cc, err := Dial(r.Scheme()+":///test.server", WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r))
cc, err := NewClient(r.Scheme()+":///test.server", WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r))
if err != nil {
t.Fatalf("failed to dial: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc.Close()
cc.Connect()
// This make sure we don't create addrConn with empty address list.
r.UpdateState(resolver.State{}) // This should not panic.
@ -746,7 +746,7 @@ func (s) TestClientUpdatesParamsAfterGoAway(t *testing.T) {
PermitWithoutStream: true,
}))
if err != nil {
t.Fatalf("Dial(%s, _) = _, %v, want _, <nil>", addr, err)
t.Fatalf("DialContext(%s) failed: %v, want: nil", addr, err)
}
defer cc.Close()
connected.Fire()
@ -769,12 +769,13 @@ func (s) TestClientUpdatesParamsAfterGoAway(t *testing.T) {
func (s) TestDisableServiceConfigOption(t *testing.T) {
r := manual.NewBuilderWithScheme("whatever")
addr := r.Scheme() + ":///non.existent"
cc, err := Dial(addr, WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r), WithDisableServiceConfig())
cc, err := NewClient(addr, WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r), WithDisableServiceConfig())
if err != nil {
t.Fatalf("Dial(%s, _) = _, %v, want _, <nil>", addr, err)
t.Fatalf("grpc.NewClient(%s) failed: %v, want: nil", addr, err)
}
defer cc.Close()
r.UpdateState(resolver.State{ServiceConfig: parseCfg(r, `{
cc.Connect()
r.UpdateState(resolver.State{ServiceConfig: r.CC.ParseServiceConfig(`{
"methodConfig": [
{
"name": [
@ -795,8 +796,8 @@ func (s) TestDisableServiceConfigOption(t *testing.T) {
}
func (s) TestMethodConfigDefaultService(t *testing.T) {
addr := "nonexist:///non.existent"
cc, err := Dial(addr, WithTransportCredentials(insecure.NewCredentials()), WithDefaultServiceConfig(`{
addr := "passthrough:///non.existent"
cc, err := NewClient(addr, WithTransportCredentials(insecure.NewCredentials()), WithDefaultServiceConfig(`{
"methodConfig": [{
"name": [
{
@ -807,8 +808,9 @@ func (s) TestMethodConfigDefaultService(t *testing.T) {
}]
}`))
if err != nil {
t.Fatalf("Dial(%s, _) = _, %v, want _, <nil>", addr, err)
t.Fatalf("grpc.NewClient(%s) failed: %v, want: nil", addr, err)
}
cc.Connect()
defer cc.Close()
m := cc.GetMethodConfig("/foo/Bar")
@ -831,12 +833,12 @@ func (s) TestClientConnCanonicalTarget(t *testing.T) {
{
name: "canonical-target-not-specified",
addr: "no.scheme",
canonicalTargetWant: "passthrough:///no.scheme",
canonicalTargetWant: "dns:///no.scheme",
},
{
name: "canonical-target-nonexistent",
addr: "nonexist:///non.existent",
canonicalTargetWant: "passthrough:///nonexist:///non.existent",
canonicalTargetWant: "dns:///nonexist:///non.existent",
},
{
name: "canonical-target-add-colon-slash",
@ -846,9 +848,9 @@ func (s) TestClientConnCanonicalTarget(t *testing.T) {
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
cc, err := Dial(test.addr, WithTransportCredentials(insecure.NewCredentials()))
cc, err := NewClient(test.addr, WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
t.Fatalf("Dial(%s, _) = _, %v, want _, <nil>", test.addr, err)
t.Fatalf("grpc.NewClient(%s) failed: %v, want: nil", test.addr, err)
}
defer cc.Close()
if cc.Target() != test.addr {
@ -877,9 +879,9 @@ func (s) TestResetConnectBackoff(t *testing.T) {
dials <- struct{}{}
return nil, errors.New("failed to fake dial")
}
cc, err := Dial("any", WithTransportCredentials(insecure.NewCredentials()), WithDialer(dialer), withBackoff(backoffForever{}))
cc, err := NewClient("passthrough:///", WithTransportCredentials(insecure.NewCredentials()), WithDialer(dialer), withBackoff(backoffForever{}))
if err != nil {
t.Fatalf("Dial() = _, %v; want _, nil", err)
t.Fatalf("grpc.NewClient() failed with error: %v, want: nil", err)
}
defer cc.Close()
go stayConnected(cc)
@ -906,18 +908,19 @@ func (s) TestResetConnectBackoff(t *testing.T) {
func (s) TestBackoffCancel(t *testing.T) {
dialStrCh := make(chan string)
cc, err := Dial("any", WithTransportCredentials(insecure.NewCredentials()), WithDialer(func(t string, _ time.Duration) (net.Conn, error) {
cc, err := NewClient("passthrough:///", WithTransportCredentials(insecure.NewCredentials()), WithDialer(func(t string, _ time.Duration) (net.Conn, error) {
dialStrCh <- t
return nil, fmt.Errorf("test dialer, always error")
}))
if err != nil {
t.Fatalf("Failed to create ClientConn: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
cc.Connect()
defer cc.Close()
select {
case <-time.After(defaultTestTimeout):
t.Fatal("Timeout when waiting for custom dialer to be invoked during Dial")
t.Fatal("Timeout when waiting for custom dialer to be invoked during Connect()")
case <-dialStrCh:
}
}
@ -972,9 +975,10 @@ func (s) TestUpdateAddresses_NoopIfCalledWithSameAddresses(t *testing.T) {
return
}
// nextStateNotifier() is updated after balancerBuilder.Build(), which is
// called by grpc.Dial. It's safe to do it here because lis1.Accept blocks
// until balancer is built to process the addresses.
// nextStateNotifier() is updated after balancerBuilder.Build(), which
// is called by ClientConn.Connect in stayConnected. It's safe to do it
// here because lis1.Accept blocks until ClientConn.Connect is called
// and the balancer is built to process the addresses.
stateNotifications := testBalancerBuilder.nextStateNotifier()
// Wait for the transport to become ready.
for {
@ -1158,17 +1162,18 @@ func verifyWaitForReadyEqualsTrue(cc *ClientConn) bool {
}
func testInvalidDefaultServiceConfig(t *testing.T, r *manual.Resolver, addr, sc string) {
_, err := Dial(addr, WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r), WithDefaultServiceConfig(sc))
_, err := NewClient(addr, WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r), WithDefaultServiceConfig(sc))
if !strings.Contains(err.Error(), invalidDefaultServiceConfigErrPrefix) {
t.Fatalf("Dial got err: %v, want err contains: %v", err, invalidDefaultServiceConfigErrPrefix)
t.Fatalf("grpc.NewClient() got err: %v, want err contains: %v", err, invalidDefaultServiceConfigErrPrefix)
}
}
func testDefaultServiceConfigWhenResolverServiceConfigDisabled(t *testing.T, r *manual.Resolver, addr string, js string) {
cc, err := Dial(addr, WithTransportCredentials(insecure.NewCredentials()), WithDisableServiceConfig(), WithResolvers(r), WithDefaultServiceConfig(js))
cc, err := NewClient(addr, WithTransportCredentials(insecure.NewCredentials()), WithDisableServiceConfig(), WithResolvers(r), WithDefaultServiceConfig(js))
if err != nil {
t.Fatalf("Dial(%s, _) = _, %v, want _, <nil>", addr, err)
t.Fatalf("grpc.NewClient(%s) failed: %v, want: nil", addr, err)
}
cc.Connect()
defer cc.Close()
// Resolver service config gets ignored since resolver service config is disabled.
r.UpdateState(resolver.State{
@ -1181,10 +1186,11 @@ func testDefaultServiceConfigWhenResolverServiceConfigDisabled(t *testing.T, r *
}
func testDefaultServiceConfigWhenResolverDoesNotReturnServiceConfig(t *testing.T, r *manual.Resolver, addr string, js string) {
cc, err := Dial(addr, WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r), WithDefaultServiceConfig(js))
cc, err := NewClient(addr, WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r), WithDefaultServiceConfig(js))
if err != nil {
t.Fatalf("Dial(%s, _) = _, %v, want _, <nil>", addr, err)
t.Fatalf("grpc.NewClient(%s) failed: %v, want: nil", addr, err)
}
cc.Connect()
defer cc.Close()
r.UpdateState(resolver.State{
Addresses: []resolver.Address{{Addr: addr}},
@ -1195,10 +1201,11 @@ func testDefaultServiceConfigWhenResolverDoesNotReturnServiceConfig(t *testing.T
}
func testDefaultServiceConfigWhenResolverReturnInvalidServiceConfig(t *testing.T, r *manual.Resolver, addr string, js string) {
cc, err := Dial(addr, WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r), WithDefaultServiceConfig(js))
cc, err := NewClient(addr, WithTransportCredentials(insecure.NewCredentials()), WithResolvers(r), WithDefaultServiceConfig(js))
if err != nil {
t.Fatalf("Dial(%s, _) = _, %v, want _, <nil>", addr, err)
t.Fatalf("grpc.NewClient(%s) failed: %v, want: nil", addr, err)
}
cc.Connect()
defer cc.Close()
r.UpdateState(resolver.State{
Addresses: []resolver.Address{{Addr: addr}},

2
examples/features/customloadbalancer/client/main.go
View File

@ -61,7 +61,7 @@ func main() {
cc, err := grpc.NewClient(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
log.Fatalf("Failed to dial: %v", err)
log.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc.Close()
ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)

5
resolver_test.go
View File

@ -120,13 +120,14 @@ func (s) TestResolverAddressesToEndpoints(t *testing.T) {
a2 := attributes.New("a", "b")
r.InitialState(resolver.State{Addresses: []resolver.Address{{Addr: "addr1", BalancerAttributes: a1}, {Addr: "addr2", BalancerAttributes: a2}}})
cc, err := Dial(r.Scheme()+":///",
cc, err := NewClient(r.Scheme()+":///",
WithTransportCredentials(insecure.NewCredentials()),
WithResolvers(r),
WithDefaultServiceConfig(fmt.Sprintf(`{"loadBalancingConfig": [{"%s":{}}]}`, balancerName)))
if err != nil {
t.Fatalf("Unexpected error dialing: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
cc.Connect()
defer cc.Close()
select {

18
test/clientconn_state_transition_test.go
View File

@ -239,7 +239,7 @@ func (s) TestStateTransitions_ReadyToConnecting(t *testing.T) {
conn.Close()
}()
client, err := grpc.Dial(lis.Addr().String(),
client, err := grpc.NewClient(lis.Addr().String(),
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"loadBalancingConfig": [{"%s":{}}]}`, stateRecordingBalancerName)))
if err != nil {
@ -250,7 +250,7 @@ func (s) TestStateTransitions_ReadyToConnecting(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
defer cancel()
go testutils.StayConnected(ctx, client)
testutils.AwaitNotState(ctx, t, client, connectivity.Idle)
stateNotifications := testBalancerBuilder.nextStateNotifier()
want := []connectivity.State{
@ -327,7 +327,7 @@ func (s) TestStateTransitions_TriesAllAddrsBeforeTransientFailure(t *testing.T)
{Addr: lis1.Addr().String()},
{Addr: lis2.Addr().String()},
}})
client, err := grpc.Dial("whatever:///this-gets-overwritten",
client, err := grpc.NewClient("whatever:///this-gets-overwritten",
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"loadBalancingConfig": [{"%s":{}}]}`, stateRecordingBalancerName)),
grpc.WithConnectParams(grpc.ConnectParams{
@ -342,7 +342,7 @@ func (s) TestStateTransitions_TriesAllAddrsBeforeTransientFailure(t *testing.T)
t.Fatal(err)
}
defer client.Close()
client.Connect()
stateNotifications := testBalancerBuilder.nextStateNotifier()
want := []connectivity.State{
connectivity.Connecting,
@ -430,7 +430,7 @@ func (s) TestStateTransitions_MultipleAddrsEntersReady(t *testing.T) {
{Addr: lis1.Addr().String()},
{Addr: lis2.Addr().String()},
}})
client, err := grpc.Dial("whatever:///this-gets-overwritten",
client, err := grpc.NewClient("whatever:///this-gets-overwritten",
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"loadBalancingConfig": [{"%s":{}}]}`, stateRecordingBalancerName)),
grpc.WithResolvers(rb))
@ -438,7 +438,7 @@ func (s) TestStateTransitions_MultipleAddrsEntersReady(t *testing.T) {
t.Fatal(err)
}
defer client.Close()
client.Connect()
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
defer cancel()
go testutils.StayConnected(ctx, client)
@ -574,15 +574,15 @@ func (s) TestConnectivityStateSubscriber(t *testing.T) {
// Create the ClientConn.
const testResName = "any"
rb := manual.NewBuilderWithScheme(testResName)
cc, err := grpc.Dial(testResName+":///",
cc, err := grpc.NewClient(testResName+":///",
grpc.WithResolvers(rb),
grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"loadBalancingConfig": [{"%s":{}}]}`, testBalName)),
grpc.WithTransportCredentials(insecure.NewCredentials()),
)
if err != nil {
t.Fatalf("Unexpected error from grpc.Dial: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
cc.Connect()
// Subscribe to state updates. Use a buffer size of 1 to allow the
// Shutdown state to go into the channel when Close()ing.
connCh := make(chan connectivity.State, 1)

11
test/goaway_test.go
View File

@ -591,7 +591,7 @@ func (s) TestGoAwayThenClose(t *testing.T) {
{Addr: lis1.Addr().String()},
{Addr: lis2.Addr().String()},
}})
cc, err := grpc.DialContext(ctx, r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials()))
cc, err := grpc.NewClient(r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
t.Fatalf("Error creating client: %v", err)
}
@ -599,9 +599,6 @@ func (s) TestGoAwayThenClose(t *testing.T) {
client := testgrpc.NewTestServiceClient(cc)
t.Log("Waiting for the ClientConn to enter READY state.")
testutils.AwaitState(ctx, t, cc, connectivity.Ready)
// We make a streaming RPC and do an one-message-round-trip to make sure
// it's created on connection 1.
//
@ -674,12 +671,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("grpc.NewClient(%q) = %v", lis.Addr().String(), err)
}
defer cc.Close()
cc.Connect()
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
defer cancel()

10
test/gracefulstop_test.go
View File

@ -138,14 +138,10 @@ func (s) TestGracefulStop(t *testing.T) {
<-dlis.closeCalled // Block until GracefulStop calls dlis.Close()
// Dial the server. This will cause a connection to be accepted. This will
// also unblock the Close method .
ctx, dialCancel := context.WithTimeout(context.Background(), defaultTestTimeout)
defer dialCancel()
dialer := func(ctx context.Context, _ string) (net.Conn, error) { return dlis.Dial(ctx) }
cc, err := grpc.DialContext(ctx, "", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(dialer))
cc, err := grpc.NewClient("passthrough:///", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(dialer))
if err != nil {
t.Fatalf("grpc.DialContext(_, %q, _) = %v", lis.Addr().String(), err)
t.Fatalf("grpc.NewClient(%q) = %v", lis.Addr().String(), err)
}
client := testgrpc.NewTestServiceClient(cc)
defer cc.Close()
@ -153,6 +149,8 @@ func (s) TestGracefulStop(t *testing.T) {
// 4. Make an RPC.
// The server would send a GOAWAY first, but we are delaying the server's
// writes for now until the client writes more than the preface.
// This will cause a connection to be accepted. This will
// also unblock the Close method.
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
if _, err = client.FullDuplexCall(ctx); err == nil || status.Code(err) != codes.Unavailable {
t.Fatalf("FullDuplexCall= _, %v; want _, <status code Unavailable>", err)

2
test/retry_test.go
View File

@ -635,7 +635,7 @@ func (s) TestRetryStats(t *testing.T) {
}
}]}`)))
if err != nil {
t.Fatalf("failed to dial due to err: %v", err)
t.Fatalf("grpc.NewClient(%q) = %v", lis.Addr().String(), err)
}
defer cc.Close()

8
test/xds/xds_client_federation_test.go
View File

@ -138,7 +138,7 @@ func (s) TestClientSideFederation(t *testing.T) {
// Create a ClientConn and make a successful RPC.
cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil {
t.Fatalf("failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc.Close()
@ -234,7 +234,7 @@ func (s) TestClientSideFederationWithOnlyXDSTPStyleLDS(t *testing.T) {
// Create a ClientConn and make a successful RPC.
cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil {
t.Fatalf("failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc.Close()
@ -278,7 +278,7 @@ func (s) TestFederation_UnknownAuthorityInDialTarget(t *testing.T) {
target := fmt.Sprintf("xds:///%s", serviceName)
cc, err := grpc.NewClient(target, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsResolver))
if err != nil {
t.Fatalf("Dialing target %q: %v", target, err)
t.Fatalf("grpc.NewClient() failed %q: %v", target, err)
}
defer cc.Close()
t.Log("Created ClientConn to test service")
@ -333,7 +333,7 @@ func (s) TestFederation_UnknownAuthorityInReceivedResponse(t *testing.T) {
target := fmt.Sprintf("xds:///%s", serviceName)
cc, err := grpc.NewClient(target, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsResolver))
if err != nil {
t.Fatalf("Dialing target %q: %v", target, err)
t.Fatalf("grpc.NewClient() failed %q: %v", target, err)
}
defer cc.Close()
t.Log("Created ClientConn to test service")

6
test/xds/xds_security_config_nack_test.go
View File

@ -191,9 +191,9 @@ func (s) TestUnmarshalListener_WithUpdateValidatorFunc(t *testing.T) {
}
// Create a ClientConn with the xds scheme and make an RPC.
cc, err := grpc.DialContext(ctx, fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(creds), grpc.WithResolvers(xdsResolver))
cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(creds), grpc.WithResolvers(xdsResolver))
if err != nil {
t.Fatalf("failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc.Close()
@ -359,7 +359,7 @@ func (s) TestUnmarshalCluster_WithUpdateValidatorFunc(t *testing.T) {
cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsResolver))
if err != nil {
t.Fatalf("failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc.Close()

12
test/xds/xds_server_rbac_test.go
View File

@ -245,9 +245,9 @@ func (s) TestServerSideXDS_RouteConfiguration(t *testing.T) {
t.Fatal(err)
}
cc, err := grpc.DialContext(ctx, fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsResolver))
cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsResolver))
if err != nil {
t.Fatalf("failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc.Close()
@ -678,9 +678,9 @@ func (s) TestRBACHTTPFilter(t *testing.T) {
t.Fatal(err)
}
cc, err := grpc.DialContext(ctx, fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsResolver))
cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsResolver))
if err != nil {
t.Fatalf("failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc.Close()
@ -860,9 +860,9 @@ func (s) TestRBACToggledOn_WithBadRouteConfiguration(t *testing.T) {
t.Fatal(err)
}
cc, err := grpc.DialContext(ctx, fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsResolver))
cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsResolver))
if err != nil {
t.Fatalf("failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc.Close()

20
test/xds/xds_server_serving_mode_test.go
View File

@ -26,6 +26,7 @@ import (
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/connectivity"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/credentials/insecure"
@ -34,6 +35,7 @@ import (
"google.golang.org/grpc/internal/testutils"
"google.golang.org/grpc/internal/testutils/xds/e2e"
"google.golang.org/grpc/internal/testutils/xds/e2e/setup"
"google.golang.org/grpc/status"
"google.golang.org/grpc/xds"
v3listenerpb "github.com/envoyproxy/go-control-plane/envoy/config/listener/v3"
@ -247,7 +249,7 @@ func (s) TestServerSideXDS_ServingModeChanges(t *testing.T) {
// Create a ClientConn to the first listener and make a successful RPCs.
cc1, err := grpc.NewClient(lis1.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
t.Fatalf("failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc1.Close()
waitForSuccessfulRPC(ctx, t, cc1)
@ -255,7 +257,7 @@ func (s) TestServerSideXDS_ServingModeChanges(t *testing.T) {
// Create a ClientConn to the second listener and make a successful RPCs.
cc2, err := grpc.NewClient(lis2.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
t.Fatalf("failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
defer cc2.Close()
waitForSuccessfulRPC(ctx, t, cc2)
@ -309,12 +311,14 @@ func (s) TestServerSideXDS_ServingModeChanges(t *testing.T) {
waitForFailedRPC(ctx, t, cc1)
waitForFailedRPC(ctx, t, cc2)
// Make sure new connection attempts to "not-serving" servers fail. We use a
// short timeout since we expect this to fail.
sCtx, sCancel := context.WithTimeout(ctx, defaultTestShortTimeout)
defer sCancel()
if _, err := grpc.DialContext(sCtx, lis1.Addr().String(), grpc.WithBlock(), grpc.WithTransportCredentials(insecure.NewCredentials())); err == nil {
t.Fatal("successfully created clientConn to a server in \"not-serving\" state")
// Make sure new connection attempts to "not-serving" servers fail.
if cc1, err = grpc.NewClient(lis1.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())); err != nil {
t.Fatal("Failed to create clientConn to a server in \"not-serving\" state")
}
defer cc1.Close()
if _, err := testgrpc.NewTestServiceClient(cc1).FullDuplexCall(ctx); status.Code(err) != codes.Unavailable {
t.Fatalf("FullDuplexCall failed with status code: %v, want: Unavailable", status.Code(err))
}
// Update the management server with both listener resources.

9
xds/internal/balancer/cdsbalancer/cdsbalancer_security_test.go
View File

@ -167,10 +167,11 @@ func setupForSecurityTests(t *testing.T, bootstrapContents []byte, clientCreds,
r.InitialState(state)
// Create a ClientConn with the specified transport credentials.
cc, err := grpc.Dial(r.Scheme()+":///test.service", grpc.WithTransportCredentials(clientCreds), grpc.WithResolvers(r))
cc, err := grpc.NewClient(r.Scheme()+":///test.service", grpc.WithTransportCredentials(clientCreds), grpc.WithResolvers(r))
if err != nil {
t.Fatalf("Failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
cc.Connect()
t.Cleanup(func() { cc.Close() })
// Start a test service backend with the specified transport credentials.
@ -563,7 +564,7 @@ func (s) TestSecurityConfigUpdate_BadToGood(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
defer cancel()
if err := mgmtServer.Update(ctx, resources); err != nil {
t.Fatal(err)
t.Fatalf("Failed to update management server with initial resources: %v", err)
}
testutils.AwaitState(ctx, t, cc, connectivity.TransientFailure)
@ -578,7 +579,7 @@ func (s) TestSecurityConfigUpdate_BadToGood(t *testing.T) {
SkipValidation: true,
}
if err := mgmtServer.Update(ctx, resources); err != nil {
t.Fatal(err)
t.Fatalf("Failed to update management server with valid resources: %v", err)
}
// Verify that a successful RPC can be made over a secure connection.

15
xds/internal/balancer/cdsbalancer/cdsbalancer_test.go
View File

@ -265,10 +265,11 @@ func setupWithManagementServerAndListener(t *testing.T, lis net.Listener) (*e2e.
scpr := internal.ParseServiceConfig.(func(string) *serviceconfig.ParseResult)(jsonSC)
r.InitialState(xdsclient.SetClient(resolver.State{ServiceConfig: scpr}, xdsC))
cc, err := grpc.Dial(r.Scheme()+":///test.service", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
cc, err := grpc.NewClient(r.Scheme()+":///test.service", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
if err != nil {
t.Fatalf("Failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient(%q) = %v", lis.Addr().String(), err)
}
cc.Connect()
t.Cleanup(func() { cc.Close() })
return mgmtServer, nodeID, cc, r, xdsC, cdsResourceRequestedCh, cdsResourceCanceledCh
@ -400,10 +401,11 @@ func (s) TestConfigurationUpdate_EmptyCluster(t *testing.T) {
r.InitialState(xdsclient.SetClient(resolver.State{ServiceConfig: scpr}, xdsClient))
// Create a ClientConn with the above manual resolver.
cc, err := grpc.Dial(r.Scheme()+":///test.service", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
cc, err := grpc.NewClient(r.Scheme()+":///test.service", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
if err != nil {
t.Fatalf("Failed to dial: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
cc.Connect()
t.Cleanup(func() { cc.Close() })
select {
@ -437,10 +439,11 @@ func (s) TestConfigurationUpdate_MissingXdsClient(t *testing.T) {
r.InitialState(resolver.State{ServiceConfig: scpr})
// Create a ClientConn with the above manual resolver.
cc, err := grpc.Dial(r.Scheme()+":///test.service", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
cc, err := grpc.NewClient(r.Scheme()+":///test.service", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
if err != nil {
t.Fatalf("Failed to dial: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
cc.Connect()
t.Cleanup(func() { cc.Close() })
select {

5
xds/internal/balancer/clusterresolver/e2e_test/balancer_test.go
View File

@ -102,11 +102,12 @@ func setupAndDial(t *testing.T, bootstrapContents []byte) (*grpc.ClientConn, fun
r.InitialState(xdsclient.SetClient(resolver.State{ServiceConfig: scpr}, xdsC))
// Create a ClientConn and make a successful RPC.
cc, err := grpc.Dial(r.Scheme()+":///test.service", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
cc, err := grpc.NewClient(r.Scheme()+":///test.service", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
if err != nil {
xdsClose()
t.Fatalf("Failed to dial local test server: %v", err)
t.Fatalf("grpc.NewClient() failed: %v", err)
}
cc.Connect()
return cc, func() {
xdsClose()
cc.Close()