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

Update docs and examples and tests to use NewClient instead of Dial (#7068) 

Co-authored-by: Arvind Bright <arvind.bright100@gmail.com>
Co-authored-by: Doug Fawley <dfawley@google.com>
This commit is contained in:
Elisha Silas 2024-04-19 20:55:23 +03:00 committed by GitHub
parent 9cf408ec48
commit 09e6fddbcd
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
78 changed files with 272 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

213
Documentation/anti-patterns.md
View File

@ -1,103 +1,97 @@
## Anti-Patterns ## Anti-Patterns of Client creation
### Dialing in gRPC ### How to properly create a `ClientConn`: `grpc.NewClient`
[`grpc.Dial`](https://pkg.go.dev/google.golang.org/grpc#Dial) is a function in
the gRPC library that creates a virtual connection from the gRPC client to the [`grpc.NewClient`](https://pkg.go.dev/google.golang.org/grpc#NewClient) is the
gRPC server. It takes a target URI (which can represent the name of a logical function in the gRPC library that creates a virtual connection from a client
backend service and could resolve to multiple actual addresses) and a list of application to a gRPC server. It takes a target URI (which represents the name
options, and returns a of a logical backend service and resolves to one or more physical addresses) and
a list of options, and returns a
[`ClientConn`](https://pkg.go.dev/google.golang.org/grpc#ClientConn) object that [`ClientConn`](https://pkg.go.dev/google.golang.org/grpc#ClientConn) object that
represents the connection to the server. The `ClientConn` contains one or more represents the virtual connection to the server. The `ClientConn` contains one
actual connections to real server backends and attempts to keep these or more actual connections to real servers and attempts to maintain these
connections healthy by automatically reconnecting to them when they break. connections by automatically reconnecting to them when they break. `NewClient`
was introduced in gRPC-Go v1.63.
The `Dial` function can also be configured with various options to customize the ### The wrong way: `grpc.Dial`
behavior of the client connection. For example, developers could use options
such a
[`WithTransportCredentials`](https://pkg.go.dev/google.golang.org/grpc#WithTransportCredentials)
to configure the transport credentials to use.
While `Dial` is commonly referred to as a "dialing" function, it doesn't [`grpc.Dial`](https://pkg.go.dev/google.golang.org/grpc#Dial) is a deprecated
actually perform the low-level network dialing operation like function that also creates the same virtual connection pool as `grpc.NewClient`.
[`net.Dial`](https://pkg.go.dev/net#Dial) would. Instead, it creates a virtual However, unlike `grpc.NewClient`, it immediately starts connecting and supports
connection from the gRPC client to the gRPC server. a few additional `DialOption`s that control this initial connection attempt.
These are: `WithBlock`, `WithTimeout`, `WithReturnConnectionError`, and
`FailOnNonTempDialError.
`Dial` does initiate the process of connecting to the server, but it uses the That `grpc.Dial` creates connections immediately is not a problem in and of
ClientConn object to manage and maintain that connection over time. This is why itself, but this behavior differs from how gRPC works in all other languages,
errors encountered during the initial connection are no different from those and it can be convenient to have a constructor that does not perform I/O. It
that occur later on, and why it's important to handle errors from RPCs rather can also be confusing to users, as most people expect a function called `Dial`
than relying on options like to create _a_ connection which may need to be recreated if it is lost.
[`FailOnNonTempDialError`](https://pkg.go.dev/google.golang.org/grpc#FailOnNonTempDialError),
[`WithBlock`](https://pkg.go.dev/google.golang.org/grpc#WithBlock), and
[`WithReturnConnectionError`](https://pkg.go.dev/google.golang.org/grpc#WithReturnConnectionError).
In fact, `Dial` does not always establish a connection to servers by default.
The connection behavior is determined by the load balancing policy being used.
For instance, an "active" load balancing policy such as Round Robin attempts to
maintain a constant connection, while the default "pick first" policy delays
connection until an RPC is executed. Instead of using the WithBlock option, which
may not be recommended in some cases, you can call the
[`ClientConn.Connect`](https://pkg.go.dev/google.golang.org/grpc#ClientConn.Connect)
method to explicitly initiate a connection.
### Using `FailOnNonTempDialError`, `WithBlock`, and `WithReturnConnectionError` `grpc.Dial` uses "passthrough" as the default name resolver for backward
compatibility while `grpc.NewClient` uses "dns" as its default name resolver.
This subtle diffrence is important to legacy systems that also specified a
custom dialer and expected it to receive the target string directly.
The gRPC API provides several options that can be used to configure the behavior For these reasons, using `grpc.Dial` is discouraged. Even though it is marked
of dialing and connecting to a gRPC server. Some of these options, such as as deprecated, we will continue to support it until a v2 is released (and no
`FailOnNonTempDialError`, `WithBlock`, and `WithReturnConnectionError`, rely on plans for a v2 exist at the time this was written).
failures at dial time. However, we strongly discourage developers from using
these options, as they can introduce race conditions and result in unreliable
and difficult-to-debug code.
One of the most important reasons for avoiding these options, which is often ### Especially bad: using deprecated `DialOptions`
overlooked, is that connections can fail at any point in time. This means that
you need to handle RPC failures caused by connection issues, regardless of
whether a connection was never established in the first place, or if it was
created and then immediately lost. Implementing proper error handling for RPCs
is crucial for maintaining the reliability and stability of your gRPC
communication.
### Why we discourage using `FailOnNonTempDialError`, `WithBlock`, and `WithReturnConnectionError` `FailOnNonTempDialError`, `WithBlock`, and `WithReturnConnectionError` are three
`DialOption`s that are only supported by `Dial` because they only affect the
behavior of `Dial` itself. `WithBlock` causes `Dial` to wait until the
`ClientConn` reports its `State` as `connectivity.Connected`. The other two deal
with returning connection errors before the timeout (`WithTimeout` or on the
context when using `DialContext`).
When a client attempts to connect to a gRPC server, it can encounter a variety The reason these options can be a problem is that connections with a
of errors, including network connectivity issues, server-side errors, and `ClientConn` are dynamic -- they may come and go over time. If your client
incorrect usage of the gRPC API. The options `FailOnNonTempDialError`, successfully connects, the server could go down 1 second later, and your RPCs
`WithBlock`, and `WithReturnConnectionError` are designed to handle some of will fail. "Knowing you are connected" does not tell you much in this regard.
these errors, but they do so by relying on failures at dial time. This means
that they may not provide reliable or accurate information about the status of
the connection.
For example, if a client uses `WithBlock` to wait for a connection to be Additionally, _all_ RPCs created on an "idle" or a "connecting" `ClientConn`
established, it may end up waiting indefinitely if the server is not responding. will wait until their deadline or until a connection is established before
Similarly, if a client uses `WithReturnConnectionError` to return a connection failing. This means that you don't need to check that a `ClientConn` is "ready"
error if dialing fails, it may miss opportunities to recover from transient before starting your RPCs. By default, RPCs will fail if the `ClientConn`
network issues that are resolved shortly after the initial dial attempt. enters the "transient failure" state, but setting `WaitForReady(true)` on a
call will cause it to queue even in the "transient failure" state, and it will
only ever fail due to a deadline, a server response, or a connection loss after
the RPC was sent to a server.
Some users of `Dial` use it as a way to validate the configuration of their
system. If you wish to maintain this behavior but migrate to `NewClient`, you
can call `State` and `WaitForStateChange` until the channel is connected.
However, if this fails, it does not mean that your configuration was bad - it
could also mean the service is not reachable by the client due to connectivity
reasons.
## Best practices for error handling in gRPC ## Best practices for error handling in gRPC
Instead of relying on failures at dial time, we strongly encourage developers to Instead of relying on failures at dial time, we strongly encourage developers to
rely on errors from RPCs. When a client makes an RPC, it can receive an error rely on errors from RPCs. When a client makes an RPC, it can receive an error
response from the server. These errors can provide valuable information about response from the server. These errors can provide valuable information about
what went wrong, including information about network issues, server-side errors, what went wrong, including information about network issues, server-side errors,
and incorrect usage of the gRPC API. and incorrect usage of the gRPC API.
By handling errors from RPCs correctly, developers can write more reliable and By handling errors from RPCs correctly, developers can write more reliable and
robust gRPC applications. Here are some best practices for error handling in robust gRPC applications. Here are some best practices for error handling in
gRPC: gRPC:
- Always check for error responses from RPCs and handle them appropriately. - Always check for error responses from RPCs and handle them appropriately.
- Use the `status` field of the error response to determine the type of error that - Use the `status` field of the error response to determine the type of error
occurred. that occurred.
- When retrying failed RPCs, consider using the built-in retry mechanism - When retrying failed RPCs, consider using the built-in retry mechanism
provided by gRPC-Go, if available, instead of manually implementing retries. provided by gRPC-Go, if available, instead of manually implementing retries.
Refer to the [gRPC-Go retry example Refer to the [gRPC-Go retry example
documentation](https://github.com/grpc/grpc-go/blob/master/examples/features/retry/README.md) documentation](https://github.com/grpc/grpc-go/blob/master/examples/features/retry/README.md)
for more information. for more information. Note that this is not a substitute for client-side
- Avoid using `FailOnNonTempDialError`, `WithBlock`, and retries as errors that occur after an RPC starts on a server cannot be
`WithReturnConnectionError`, as these options can introduce race conditions and retried through gRPC's built-in mechanism.
result in unreliable and difficult-to-debug code. - If making an outgoing RPC from a server handler, be sure to translate the
- If making the outgoing RPC in order to handle an incoming RPC, be sure to status code before returning the error from your method handler. For example,
translate the status code before returning the error from your method handler. if the error is an `INVALID_ARGUMENT` status code, that probably means
For example, if the error is an `INVALID_ARGUMENT` error, that probably means
your service has a bug (otherwise it shouldn't have triggered this error), in your service has a bug (otherwise it shouldn't have triggered this error), in
which case `INTERNAL` is more appropriate to return back to your users. which case `INTERNAL` is more appropriate to return back to your users.
@ -106,7 +100,7 @@ gRPC:
The following code snippet demonstrates how to handle errors from an RPC in The following code snippet demonstrates how to handle errors from an RPC in
gRPC: gRPC:
```go ```go
ctx, cancel := context.WithTimeout(context.Background(), time.Second) ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel() defer cancel()
@ -118,89 +112,72 @@ if err != nil {
return nil, err return nil, err
} }
// Use the response as appropriate // Use the response as appropriate
log.Printf("MyRPC response: %v", res) log.Printf("MyRPC response: %v", res)
``` ```
To determine the type of error that occurred, you can use the status field of To determine the type of error that occurred, you can use the status field of
the error response: the error response:
```go ```go
resp, err := client.MakeRPC(context.Background(), request) resp, err := client.MakeRPC(context.TODO(), request)
if err != nil { if err != nil {
status, ok := status.FromError(err) if status, ok := status.FromError(err); ok {
if ok { // Handle the error based on its status code
// Handle the error based on its status code
if status.Code() == codes.NotFound { if status.Code() == codes.NotFound {
log.Println("Requested resource not found") log.Println("Requested resource not found")
} else { } else {
log.Printf("RPC error: %v", status.Message()) log.Printf("RPC error: %v", status.Message())
} }
} else { } else {
//Handle non-RPC errors // Handle non-RPC errors
log.Printf("Non-RPC error: %v", err) log.Printf("Non-RPC error: %v", err)
} }
return return
} }
// Use the response as needed // Use the response as needed
log.Printf("Response received: %v", resp) log.Printf("Response received: %v", resp)
``` ```
### Example: Using a backoff strategy ### Example: Using a backoff strategy
When retrying failed RPCs, use a backoff strategy to avoid overwhelming the When retrying failed RPCs, use a backoff strategy to avoid overwhelming the
server or exacerbating network issues: server or exacerbating network issues:
```go
```go
var res *MyResponse var res *MyResponse
var err error var err error
// If the user doesn't have a context with a deadline, create one retryableStatusCodes := map[codes.Code]bool{
ctx, cancel := context.WithTimeout(context.Background(), time.Second) codes.Unavailable: true, // etc
defer cancel() }
// Retry the RPC call a maximum number of times // Retry the RPC a maximum number of times.
for i := 0; i < maxRetries; i++ { for i := 0; i < maxRetries; i++ {
// Make the RPC.
// Make the RPC call res, err = client.MyRPC(context.TODO(), &MyRequest{})
res, err = client.MyRPC(ctx, &MyRequest{})
// Check if the RPC was successful.
// Check if the RPC call was successful if !retryableStatusCodes[status.Code(err)] {
if err == nil { // The RPC was successful or errored in a non-retryable way;
// The RPC was successful, so break out of the loop // do not retry.
break break
} }
// The RPC failed, so wait for a backoff period before retrying // The RPC is retryable; wait for a backoff period before retrying.
backoff := time.Duration(i) * time.Second backoff := time.Duration(i+1) * time.Second
log.Printf("Error calling MyRPC: %v; retrying in %v", err, backoff) log.Printf("Error calling MyRPC: %v; retrying in %v", err, backoff)
time.Sleep(backoff) time.Sleep(backoff)
} }
// Check if the RPC call was successful after all retries // Check if the RPC was successful after all retries.
if err != nil { if err != nil {
// All retries failed, so handle the error appropriately // All retries failed, so handle the error appropriately
log.Printf("Error calling MyRPC: %v", err) log.Printf("Error calling MyRPC: %v", err)
return nil, err return nil, err
} }
// Use the response as appropriate // Use the response as appropriate.
log.Printf("MyRPC response: %v", res) log.Printf("MyRPC response: %v", res)
``` ```
## Conclusion
The
[`FailOnNonTempDialError`](https://pkg.go.dev/google.golang.org/grpc#FailOnNonTempDialError),
[`WithBlock`](https://pkg.go.dev/google.golang.org/grpc#WithBlock), and
[`WithReturnConnectionError`](https://pkg.go.dev/google.golang.org/grpc#WithReturnConnectionError)
options are designed to handle errors at dial time, but they can introduce race
conditions and result in unreliable and difficult-to-debug code. Instead of
relying on these options, we strongly encourage developers to rely on errors
from RPCs for error handling. By following best practices for error handling in
gRPC, developers can write more reliable and robust gRPC applications.

4
authz/audit/audit_logging_test.go
View File

@ -279,9 +279,9 @@ func (s) TestAuditLogger(t *testing.T) {
go s.Serve(lis) go s.Serve(lis)
// Setup gRPC test client with certificates containing a SPIFFE Id. // Setup gRPC test client with certificates containing a SPIFFE Id.
clientConn, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(clientCreds)) clientConn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(clientCreds))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%v) failed: %v", lis.Addr().String(), err) t.Fatalf("grpc.NewClient(%v) failed: %v", lis.Addr().String(), err)
} }
defer clientConn.Close() defer clientConn.Close()
client := testgrpc.NewTestServiceClient(clientConn) client := testgrpc.NewTestServiceClient(clientConn)

28
authz/grpc_authz_end2end_test.go
View File

@ -326,9 +326,9 @@ func (s) TestStaticPolicyEnd2End(t *testing.T) {
go s.Serve(lis) go s.Serve(lis)
// Establish a connection to the server. // Establish a connection to the server.
clientConn, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) clientConn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%v) failed: %v", lis.Addr().String(), err) t.Fatalf("grpc.NewClient(%v) failed: %v", lis.Addr().String(), err)
} }
defer clientConn.Close() defer clientConn.Close()
client := testgrpc.NewTestServiceClient(clientConn) client := testgrpc.NewTestServiceClient(clientConn)
@ -400,9 +400,9 @@ func (s) TestAllowsRPCRequestWithPrincipalsFieldOnTLSAuthenticatedConnection(t *
if err != nil { if err != nil {
t.Fatalf("failed to load credentials: %v", err) t.Fatalf("failed to load credentials: %v", err)
} }
clientConn, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(creds)) clientConn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(creds))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%v) failed: %v", lis.Addr().String(), err) t.Fatalf("grpc.NewClient(%v) failed: %v", lis.Addr().String(), err)
} }
defer clientConn.Close() defer clientConn.Close()
client := testgrpc.NewTestServiceClient(clientConn) client := testgrpc.NewTestServiceClient(clientConn)
@ -478,9 +478,9 @@ func (s) TestAllowsRPCRequestWithPrincipalsFieldOnMTLSAuthenticatedConnection(t
RootCAs: roots, RootCAs: roots,
ServerName: "x.test.example.com", ServerName: "x.test.example.com",
}) })
clientConn, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(creds)) clientConn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(creds))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%v) failed: %v", lis.Addr().String(), err) t.Fatalf("grpc.NewClient(%v) failed: %v", lis.Addr().String(), err)
} }
defer clientConn.Close() defer clientConn.Close()
client := testgrpc.NewTestServiceClient(clientConn) client := testgrpc.NewTestServiceClient(clientConn)
@ -516,9 +516,9 @@ func (s) TestFileWatcherEnd2End(t *testing.T) {
go s.Serve(lis) go s.Serve(lis)
// Establish a connection to the server. // Establish a connection to the server.
clientConn, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) clientConn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%v) failed: %v", lis.Addr().String(), err) t.Fatalf("grpc.NewClient(%v) failed: %v", lis.Addr().String(), err)
} }
defer clientConn.Close() defer clientConn.Close()
client := testgrpc.NewTestServiceClient(clientConn) client := testgrpc.NewTestServiceClient(clientConn)
@ -585,9 +585,9 @@ func (s) TestFileWatcher_ValidPolicyRefresh(t *testing.T) {
go s.Serve(lis) go s.Serve(lis)
// Establish a connection to the server. // Establish a connection to the server.
clientConn, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) clientConn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%v) failed: %v", lis.Addr().String(), err) t.Fatalf("grpc.NewClient(%v) failed: %v", lis.Addr().String(), err)
} }
defer clientConn.Close() defer clientConn.Close()
client := testgrpc.NewTestServiceClient(clientConn) client := testgrpc.NewTestServiceClient(clientConn)
@ -633,9 +633,9 @@ func (s) TestFileWatcher_InvalidPolicySkipReload(t *testing.T) {
go s.Serve(lis) go s.Serve(lis)
// Establish a connection to the server. // Establish a connection to the server.
clientConn, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) clientConn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%v) failed: %v", lis.Addr().String(), err) t.Fatalf("grpc.NewClient(%v) failed: %v", lis.Addr().String(), err)
} }
defer clientConn.Close() defer clientConn.Close()
client := testgrpc.NewTestServiceClient(clientConn) client := testgrpc.NewTestServiceClient(clientConn)
@ -684,9 +684,9 @@ func (s) TestFileWatcher_RecoversFromReloadFailure(t *testing.T) {
go s.Serve(lis) go s.Serve(lis)
// Establish a connection to the server. // Establish a connection to the server.
clientConn, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) clientConn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%v) failed: %v", lis.Addr().String(), err) t.Fatalf("grpc.NewClient(%v) failed: %v", lis.Addr().String(), err)
} }
defer clientConn.Close() defer clientConn.Close()
client := testgrpc.NewTestServiceClient(clientConn) client := testgrpc.NewTestServiceClient(clientConn)

10
balancer/grpclb/grpclb_test.go
View File

@ -458,7 +458,7 @@ func (s) TestGRPCLB_Basic(t *testing.T) {
grpc.WithContextDialer(fakeNameDialer), grpc.WithContextDialer(fakeNameDialer),
grpc.WithUserAgent(testUserAgent), grpc.WithUserAgent(testUserAgent),
} }
cc, err := grpc.Dial(r.Scheme()+":///"+beServerName, dopts...) cc, err := grpc.NewClient(r.Scheme()+":///"+beServerName, dopts...)
if err != nil { if err != nil {
t.Fatalf("Failed to dial to the backend %v", err) t.Fatalf("Failed to dial to the backend %v", err)
} }
@ -515,7 +515,7 @@ func (s) TestGRPCLB_Weighted(t *testing.T) {
grpc.WithTransportCredentials(&serverNameCheckCreds{}), grpc.WithTransportCredentials(&serverNameCheckCreds{}),
grpc.WithContextDialer(fakeNameDialer), grpc.WithContextDialer(fakeNameDialer),
} }
cc, err := grpc.Dial(r.Scheme()+":///"+beServerName, dopts...) cc, err := grpc.NewClient(r.Scheme()+":///"+beServerName, dopts...)
if err != nil { if err != nil {
t.Fatalf("Failed to dial to the backend %v", err) t.Fatalf("Failed to dial to the backend %v", err)
} }
@ -595,7 +595,7 @@ func (s) TestGRPCLB_DropRequest(t *testing.T) {
grpc.WithTransportCredentials(&serverNameCheckCreds{}), grpc.WithTransportCredentials(&serverNameCheckCreds{}),
grpc.WithContextDialer(fakeNameDialer), grpc.WithContextDialer(fakeNameDialer),
} }
cc, err := grpc.Dial(r.Scheme()+":///"+beServerName, dopts...) cc, err := grpc.NewClient(r.Scheme()+":///"+beServerName, dopts...)
if err != nil { if err != nil {
t.Fatalf("Failed to dial to the backend %v", err) t.Fatalf("Failed to dial to the backend %v", err)
} }
@ -767,7 +767,7 @@ func (s) TestGRPCLB_BalancerDisconnects(t *testing.T) {
grpc.WithTransportCredentials(&serverNameCheckCreds{}), grpc.WithTransportCredentials(&serverNameCheckCreds{}),
grpc.WithContextDialer(fakeNameDialer), grpc.WithContextDialer(fakeNameDialer),
} }
cc, err := grpc.Dial(r.Scheme()+":///"+beServerName, dopts...) cc, err := grpc.NewClient(r.Scheme()+":///"+beServerName, dopts...)
if err != nil { if err != nil {
t.Fatalf("Failed to dial to the backend %v", err) t.Fatalf("Failed to dial to the backend %v", err)
} }
@ -938,7 +938,7 @@ func (s) TestGRPCLB_ExplicitFallback(t *testing.T) {
grpc.WithTransportCredentials(&serverNameCheckCreds{}), grpc.WithTransportCredentials(&serverNameCheckCreds{}),
grpc.WithContextDialer(fakeNameDialer), grpc.WithContextDialer(fakeNameDialer),
} }
cc, err := grpc.Dial(r.Scheme()+":///"+beServerName, dopts...) cc, err := grpc.NewClient(r.Scheme()+":///"+beServerName, dopts...)
if err != nil { if err != nil {
t.Fatalf("Failed to dial to the backend %v", err) t.Fatalf("Failed to dial to the backend %v", err)
} }

12
balancer/leastrequest/balancer_test.go
View File

@ -232,9 +232,9 @@ func (s) TestLeastRequestE2E(t *testing.T) {
ServiceConfig: sc, ServiceConfig: sc,
}) })
cc, err := grpc.Dial(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
defer cc.Close() defer cc.Close()
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
@ -347,9 +347,9 @@ func (s) TestLeastRequestPersistsCounts(t *testing.T) {
ServiceConfig: sc, ServiceConfig: sc,
}) })
cc, err := grpc.Dial(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
defer cc.Close() defer cc.Close()
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
@ -488,9 +488,9 @@ func (s) TestConcurrentRPCs(t *testing.T) {
ServiceConfig: sc, ServiceConfig: sc,
}) })
cc, err := grpc.Dial(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
defer cc.Close() defer cc.Close()
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)

2
binarylog/binarylog_end2end_test.go
View File

@ -316,7 +316,7 @@ func (te *test) clientConn() *grpc.ClientConn {
opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithBlock()} opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithBlock()}
var err error var err error
te.cc, err = grpc.Dial(te.srvAddr, opts...) te.cc, err = grpc.NewClient(te.srvAddr, opts...)
if err != nil { if err != nil {
te.t.Fatalf("Dial(%q) = %v", te.srvAddr, err) te.t.Fatalf("Dial(%q) = %v", te.srvAddr, err)
} }

4
clientconn_authority_test.go
View File

@ -128,8 +128,8 @@ func (s) TestClientConnAuthority_CredsAndDialOptionMismatch(t *testing.T) {
t.Fatalf("credentials.NewClientTLSFromFile(_, %q) failed: %v", err, serverNameOverride) t.Fatalf("credentials.NewClientTLSFromFile(_, %q) failed: %v", err, serverNameOverride)
} }
opts := []DialOption{WithTransportCredentials(creds), WithAuthority("authority-override")} opts := []DialOption{WithTransportCredentials(creds), WithAuthority("authority-override")}
if cc, err := Dial("Non-Existent.Server:8000", opts...); err == nil { if cc, err := NewClient("Non-Existent.Server:8000", opts...); err == nil {
cc.Close() cc.Close()
t.Fatal("grpc.Dial() succeeded when expected to fail") t.Fatal("grpc.NewClient() succeeded when expected to fail")
} }
} }

4
credentials/alts/alts_test.go
View File

@ -385,9 +385,9 @@ func versions(minMajor, minMinor, maxMajor, maxMinor uint32) *altspb.RpcProtocol
func establishAltsConnection(t *testing.T, handshakerAddress, serverAddress string) { func establishAltsConnection(t *testing.T, handshakerAddress, serverAddress string) {
clientCreds := NewClientCreds(&ClientOptions{HandshakerServiceAddress: handshakerAddress}) clientCreds := NewClientCreds(&ClientOptions{HandshakerServiceAddress: handshakerAddress})
conn, err := grpc.Dial(serverAddress, grpc.WithTransportCredentials(clientCreds)) conn, err := grpc.NewClient(serverAddress, grpc.WithTransportCredentials(clientCreds))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%v) failed: %v", serverAddress, err) t.Fatalf("grpc.NewClient(%v) failed: %v", serverAddress, err)
} }
defer conn.Close() defer conn.Close()
ctx, cancel := context.WithTimeout(context.Background(), defaultTestLongTimeout) ctx, cancel := context.WithTimeout(context.Background(), defaultTestLongTimeout)

8
credentials/tls_ext_test.go
View File

@ -103,9 +103,9 @@ func (s) TestTLS_MinVersion12(t *testing.T) {
} }
defer ss.Stop() defer ss.Stop()
cc, err := grpc.Dial(ss.Address, grpc.WithTransportCredentials(clientCreds)) cc, err := grpc.NewClient(ss.Address, grpc.WithTransportCredentials(clientCreds))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial error: %v", err) t.Fatalf("grpc.NewClient error: %v", err)
} }
defer cc.Close() defer cc.Close()
@ -189,9 +189,9 @@ func (s) TestTLS_CipherSuites(t *testing.T) {
} }
defer ss.Stop() defer ss.Stop()
cc, err := grpc.Dial("dns:"+ss.Address, grpc.WithTransportCredentials(clientCreds)) cc, err := grpc.NewClient("dns:"+ss.Address, grpc.WithTransportCredentials(clientCreds))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial error: %v", err) t.Fatalf("grpc.NewClient error: %v", err)
} }
defer cc.Close() defer cc.Close()

10
encoding/encoding_test.go
View File

@ -122,7 +122,7 @@ func (s) TestEncodeDoesntPanicOnServer(t *testing.T) {
defer backend.Stop() defer backend.Stop()
// Create a channel to the above server. // Create a channel to the above server.
cc, err := grpc.Dial(backend.Address, grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(backend.Address, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("Failed to dial test backend at %q: %v", backend.Address, err) t.Fatalf("Failed to dial test backend at %q: %v", backend.Address, err)
} }
@ -159,7 +159,7 @@ func (s) TestDecodeDoesntPanicOnServer(t *testing.T) {
// Create a channel to the above server. Since we do not specify any codec // Create a channel to the above server. Since we do not specify any codec
// here, the proto codec will get automatically used. // here, the proto codec will get automatically used.
cc, err := grpc.Dial(backend.Address, grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(backend.Address, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("Failed to dial test backend at %q: %v", backend.Address, err) t.Fatalf("Failed to dial test backend at %q: %v", backend.Address, err)
} }
@ -196,7 +196,7 @@ func (s) TestEncodeDoesntPanicOnClient(t *testing.T) {
ec := &errProtoCodec{name: t.Name(), encodingErr: encodingErr} ec := &errProtoCodec{name: t.Name(), encodingErr: encodingErr}
// Create a channel to the above server. // Create a channel to the above server.
cc, err := grpc.Dial(backend.Address, grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(backend.Address, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("Failed to dial test backend at %q: %v", backend.Address, err) t.Fatalf("Failed to dial test backend at %q: %v", backend.Address, err)
} }
@ -232,7 +232,7 @@ func (s) TestDecodeDoesntPanicOnClient(t *testing.T) {
ec := &errProtoCodec{name: t.Name(), decodingErr: decodingErr} ec := &errProtoCodec{name: t.Name(), decodingErr: decodingErr}
// Create a channel to the above server. // Create a channel to the above server.
cc, err := grpc.Dial(backend.Address, grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(backend.Address, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("Failed to dial test backend at %q: %v", backend.Address, err) t.Fatalf("Failed to dial test backend at %q: %v", backend.Address, err)
} }
@ -288,7 +288,7 @@ func (s) TestForceServerCodec(t *testing.T) {
defer backend.Stop() defer backend.Stop()
// Create a channel to the above server. // Create a channel to the above server.
cc, err := grpc.Dial(backend.Address, grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(backend.Address, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("Failed to dial test backend at %q: %v", backend.Address, err) t.Fatalf("Failed to dial test backend at %q: %v", backend.Address, err)
} }

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

@ -66,7 +66,7 @@ func main() {
grpc.WithTransportCredentials(creds), grpc.WithTransportCredentials(creds),
} }
conn, err := grpc.Dial(*addr, opts...) conn, err := grpc.NewClient(*addr, opts...)
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

4
examples/features/authz/client/main.go
View File

@ -99,9 +99,9 @@ func main() {
log.Fatalf("failed to load credentials: %v", err) log.Fatalf("failed to load credentials: %v", err)
} }
// Set up a connection to the server. // Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(creds)) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(creds))
if err != nil { if err != nil {
log.Fatalf("grpc.Dial(%q): %v", *addr, err) log.Fatalf("grpc.NewClient(%q): %v", *addr, err)
} }
defer conn.Close() defer conn.Close()

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

@ -56,7 +56,7 @@ func main() {
flag.Parse() flag.Parse()
// Set up a connection to the server. // Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

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

@ -38,7 +38,7 @@ func main() {
flag.Parse() flag.Parse()
// Set up a connection to the server. // Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

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

@ -73,7 +73,7 @@ func streamingCall(c pb.EchoClient, requestID int, message string, want codes.Co
func main() { func main() {
flag.Parse() flag.Parse()
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

2
examples/features/deadline/server/main.go
View File

@ -95,7 +95,7 @@ func (s *server) Close() {
func newEchoServer() *server { func newEchoServer() *server {
target := fmt.Sprintf("localhost:%v", *port) target := fmt.Sprintf("localhost:%v", *port)
cc, err := grpc.Dial(target, grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(target, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

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

@ -60,7 +60,7 @@ func main() {
/***** Initialize manual resolver and Dial *****/ /***** Initialize manual resolver and Dial *****/
r := manual.NewBuilderWithScheme("whatever") r := manual.NewBuilderWithScheme("whatever")
// Set up a connection to the server. // Set up a connection to the server.
conn, err := grpc.Dial(r.Scheme()+":///test.server", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r), grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy":"round_robin"}`)) conn, err := grpc.NewClient(r.Scheme()+":///test.server", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r), grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy":"round_robin"}`))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

2
examples/features/encryption/ALTS/client/main.go
View File

@ -50,7 +50,7 @@ func main() {
altsTC := alts.NewClientCreds(alts.DefaultClientOptions()) altsTC := alts.NewClientCreds(alts.DefaultClientOptions())
// Set up a connection to the server. // Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(altsTC)) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(altsTC))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

2
examples/features/encryption/TLS/client/main.go
View File

@ -54,7 +54,7 @@ func main() {
} }
// Set up a connection to the server. // Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(creds)) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(creds))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

2
examples/features/encryption/mTLS/client/main.go
View File

@ -71,7 +71,7 @@ func main() {
RootCAs: ca, RootCAs: ca,
} }
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig))) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

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

@ -39,7 +39,7 @@ func main() {
flag.Parse() flag.Parse()
// Set up a connection to the server. // Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

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

@ -44,7 +44,7 @@ func main() {
} }
// Set up a connection to the server. // Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("Failed to connect: %v", err) log.Fatalf("Failed to connect: %v", err)
} }

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

@ -41,7 +41,7 @@ func main() {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel() defer cancel()
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

4
examples/features/health/client/main.go
View File

@ -72,9 +72,9 @@ func main() {
grpc.WithDefaultServiceConfig(serviceConfig), grpc.WithDefaultServiceConfig(serviceConfig),
} }
conn, err := grpc.Dial(address, options...) conn, err := grpc.NewClient(address, options...)
if err != nil { if err != nil {
log.Fatalf("grpc.Dial(%q): %v", address, err) log.Fatalf("grpc.NewClient(%q): %v", address, err)
} }
defer conn.Close() defer conn.Close()

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

@ -153,7 +153,7 @@ func main() {
} }
// Set up a connection to the server. // Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(creds), grpc.WithUnaryInterceptor(unaryInterceptor), grpc.WithStreamInterceptor(streamInterceptor)) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(creds), grpc.WithUnaryInterceptor(unaryInterceptor), grpc.WithStreamInterceptor(streamInterceptor))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

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

@ -43,7 +43,7 @@ var kacp = keepalive.ClientParameters{
func main() { func main() {
flag.Parse() flag.Parse()
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithKeepaliveParams(kacp)) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithKeepaliveParams(kacp))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

4
examples/features/load_balancing/client/main.go
View File

@ -57,7 +57,7 @@ func makeRPCs(cc *grpc.ClientConn, n int) {
func main() { func main() {
// "pick_first" is the default, so there's no need to set the load balancing policy. // "pick_first" is the default, so there's no need to set the load balancing policy.
pickfirstConn, err := grpc.Dial( pickfirstConn, err := grpc.NewClient(
fmt.Sprintf("%s:///%s", exampleScheme, exampleServiceName), fmt.Sprintf("%s:///%s", exampleScheme, exampleServiceName),
grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithTransportCredentials(insecure.NewCredentials()),
) )
@ -72,7 +72,7 @@ func main() {
fmt.Println() fmt.Println()
// Make another ClientConn with round_robin policy. // Make another ClientConn with round_robin policy.
roundrobinConn, err := grpc.Dial( roundrobinConn, err := grpc.NewClient(
fmt.Sprintf("%s:///%s", exampleScheme, exampleServiceName), fmt.Sprintf("%s:///%s", exampleScheme, exampleServiceName),
grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`), // This sets the initial balancing policy. grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`), // This sets the initial balancing policy.
grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithTransportCredentials(insecure.NewCredentials()),

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

@ -287,7 +287,7 @@ const message = "this is examples/metadata"
func main() { func main() {
flag.Parse() flag.Parse()
// Set up a connection to the server. // Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

4
examples/features/metadata_interceptor/client/main.go
View File

@ -69,9 +69,9 @@ func callBidiStreamingEcho(ctx context.Context, client pb.EchoClient) {
func main() { func main() {
flag.Parse() flag.Parse()
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("grpc.Dial(%q): %v", *addr, err) log.Fatalf("grpc.NewClient(%q): %v", *addr, err)
} }
defer conn.Close() defer conn.Close()

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

@ -59,7 +59,7 @@ func callUnaryEcho(client ecpb.EchoClient, message string) {
func main() { func main() {
flag.Parse() flag.Parse()
// Set up a connection to the server. // Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

4
examples/features/name_resolving/client/main.go
View File

@ -56,7 +56,7 @@ func makeRPCs(cc *grpc.ClientConn, n int) {
} }
func main() { func main() {
passthroughConn, err := grpc.Dial( passthroughConn, err := grpc.NewClient(
fmt.Sprintf("passthrough:///%s", backendAddr), // Dial to "passthrough:///localhost:50051" fmt.Sprintf("passthrough:///%s", backendAddr), // Dial to "passthrough:///localhost:50051"
grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithTransportCredentials(insecure.NewCredentials()),
) )
@ -70,7 +70,7 @@ func main() {
fmt.Println() fmt.Println()
exampleConn, err := grpc.Dial( exampleConn, err := grpc.NewClient(
fmt.Sprintf("%s:///%s", exampleScheme, exampleServiceName), // Dial to "example:///resolver.example.grpc.io" fmt.Sprintf("%s:///%s", exampleScheme, exampleServiceName), // Dial to "example:///resolver.example.grpc.io"
grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithTransportCredentials(insecure.NewCredentials()),
) )

9
examples/features/orca/client/main.go
View File

@ -44,7 +44,7 @@ func main() {
// Set up a connection to the server. Configure to use our custom LB // Set up a connection to the server. Configure to use our custom LB
// policy which will receive all the ORCA load reports. // policy which will receive all the ORCA load reports.
conn, err := grpc.Dial(*addr, conn, err := grpc.NewClient(*addr,
grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"orca_example":{}}]}`), grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"orca_example":{}}]}`),
) )
@ -97,14 +97,7 @@ type orcaLB struct {
} }
func (o *orcaLB) UpdateClientConnState(ccs balancer.ClientConnState) error { func (o *orcaLB) UpdateClientConnState(ccs balancer.ClientConnState) error {
// We assume only one update, ever, containing exactly one address, given
// the use of the "passthrough" (default) name resolver.
addrs := ccs.ResolverState.Addresses addrs := ccs.ResolverState.Addresses
if len(addrs) != 1 {
return fmt.Errorf("orcaLB: expected 1 address; received: %v", addrs)
}
// Create one SubConn for the address and connect it. // Create one SubConn for the address and connect it.
var sc balancer.SubConn var sc balancer.SubConn
sc, err := o.cc.NewSubConn(addrs, balancer.NewSubConnOptions{ sc, err := o.cc.NewSubConn(addrs, balancer.NewSubConnOptions{

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

@ -49,7 +49,7 @@ var (
// use grpc.WithDefaultServiceConfig() to set service config // use grpc.WithDefaultServiceConfig() to set service config
func retryDial() (*grpc.ClientConn, error) { func retryDial() (*grpc.ClientConn, error) {
return grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultServiceConfig(retryPolicy)) return grpc.NewClient(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultServiceConfig(retryPolicy))
} }
func main() { func main() {

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

@ -41,7 +41,7 @@ func main() {
grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithStatsHandler(statshandler.New()), grpc.WithStatsHandler(statshandler.New()),
} }
conn, err := grpc.Dial(*addr, opts...) conn, err := grpc.NewClient(*addr, opts...)
if err != nil { if err != nil {
log.Fatalf("failed to connect to server %q: %v", *addr, err) log.Fatalf("failed to connect to server %q: %v", *addr, err)
} }

4
examples/features/unix_abstract/client/main.go
View File

@ -63,9 +63,9 @@ func makeRPCs(cc *grpc.ClientConn, n int) {
func main() { func main() {
flag.Parse() flag.Parse()
sockAddr := fmt.Sprintf("unix-abstract:%v", *addr) sockAddr := fmt.Sprintf("unix-abstract:%v", *addr)
cc, err := grpc.Dial(sockAddr, grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(sockAddr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("grpc.Dial(%q) failed: %v", sockAddr, err) log.Fatalf("grpc.NewClient(%q) failed: %v", sockAddr, err)
} }
defer cc.Close() defer cc.Close()

2
examples/features/wait_for_ready/main.go
View File

@ -59,7 +59,7 @@ func serve() {
} }
func main() { func main() {
conn, err := grpc.Dial("localhost:50053", grpc.WithTransportCredentials(insecure.NewCredentials())) conn, err := grpc.NewClient("localhost:50053", grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
log.Fatalf("did not connect: %v", err) log.Fatalf("did not connect: %v", err)
} }

4
examples/features/xds/client/main.go
View File

@ -56,9 +56,9 @@ func main() {
log.Fatalf("failed to create client-side xDS credentials: %v", err) log.Fatalf("failed to create client-side xDS credentials: %v", err)
} }
} }
conn, err := grpc.Dial(*target, grpc.WithTransportCredentials(creds)) conn, err := grpc.NewClient(*target, grpc.WithTransportCredentials(creds))
if err != nil { if err != nil {
log.Fatalf("grpc.Dial(%s) failed: %v", *target, err) log.Fatalf("grpc.NewClient(%s) failed: %v", *target, err)
} }
defer conn.Close() defer conn.Close()

12
internal/idle/idle_e2e_test.go
View File

@ -488,9 +488,9 @@ func (s) TestChannelIdleness_Enabled_IdleTimeoutRacesWithRPCs(t *testing.T) {
grpc.WithIdleTimeout(defaultTestShortTimeout), grpc.WithIdleTimeout(defaultTestShortTimeout),
grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`), grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`),
} }
cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...)
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
defer cc.Close() defer cc.Close()
@ -531,9 +531,9 @@ func (s) TestChannelIdleness_Connect(t *testing.T) {
grpc.WithIdleTimeout(defaultTestShortIdleTimeout), grpc.WithIdleTimeout(defaultTestShortIdleTimeout),
grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`), grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`),
} }
cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...)
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
defer cc.Close() defer cc.Close()
@ -581,9 +581,9 @@ func (s) TestChannelIdleness_RaceBetweenEnterAndExitIdleMode(t *testing.T) {
grpc.WithIdleTimeout(30 * time.Minute), grpc.WithIdleTimeout(30 * time.Minute),
grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"pick_first":{}}]}`), grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"pick_first":{}}]}`),
} }
cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...)
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
defer cc.Close() defer cc.Close()

4
interop/xds/custom_lb_test.go
View File

@ -105,9 +105,9 @@ func (s) TestCustomLB(t *testing.T) {
ServiceConfig: sc, ServiceConfig: sc,
}) })
cc, err := grpc.Dial(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
defer cc.Close() defer cc.Close()
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)

8
orca/call_metrics_test.go
View File

@ -118,9 +118,9 @@ func (s) TestE2ECallMetricsUnary(t *testing.T) {
defer srv.Stop() defer srv.Stop()
// Dial the stub server. // Dial the stub server.
cc, err := grpc.Dial(srv.Address, grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(srv.Address, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%s) failed: %v", srv.Address, err) t.Fatalf("grpc.NewClient(%s) failed: %v", srv.Address, err)
} }
defer cc.Close() defer cc.Close()
@ -239,9 +239,9 @@ func (s) TestE2ECallMetricsStreaming(t *testing.T) {
defer srv.Stop() defer srv.Stop()
// Dial the stub server. // Dial the stub server.
cc, err := grpc.Dial(srv.Address, grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(srv.Address, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%s) failed: %v", srv.Address, err) t.Fatalf("grpc.NewClient(%s) failed: %v", srv.Address, err)
} }
defer cc.Close() defer cc.Close()

4
orca/service_test.go
View File

@ -106,9 +106,9 @@ func (s) TestE2E_CustomBackendMetrics_OutOfBand(t *testing.T) {
t.Logf("Started gRPC server at %s...", lis.Addr().String()) t.Logf("Started gRPC server at %s...", lis.Addr().String())
// Dial the test server. // Dial the test server.
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 { if err != nil {
t.Fatalf("grpc.Dial(%s) failed: %v", lis.Addr().String(), err) t.Fatalf("grpc.NewClient(%s) failed: %v", lis.Addr().String(), err)
} }
defer cc.Close() defer cc.Close()

2
reflection/test/serverreflection_test.go
View File

@ -413,7 +413,7 @@ func (x) TestReflectionEnd2end(t *testing.T) {
t.Cleanup(s.Stop) t.Cleanup(s.Stop)
// Create client. // Create client.
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 { if err != nil {
t.Fatalf("cannot connect to server: %v", err) t.Fatalf("cannot connect to server: %v", err)
} }

12
resolver_balancer_ext_test.go
View File

@ -150,9 +150,9 @@ func (s) TestEnterIdleDuringResolverUpdateState(t *testing.T) {
} }
resolver.Register(rb) resolver.Register(rb)
cc, err := grpc.Dial(name+":///", grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(name+":///", grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial error: %v", err) t.Fatalf("grpc.NewClient error: %v", err)
} }
defer cc.Close() defer cc.Close()
@ -196,12 +196,12 @@ func (s) TestEnterIdleDuringBalancerUpdateState(t *testing.T) {
} }
resolver.Register(rb) resolver.Register(rb)
cc, err := grpc.Dial( cc, err := grpc.NewClient(
name+":///", name+":///",
grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"`+name+`":{}}]}`)) grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"`+name+`":{}}]}`))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial error: %v", err) t.Fatalf("grpc.NewClient error: %v", err)
} }
defer cc.Close() defer cc.Close()
@ -241,12 +241,12 @@ func (s) TestEnterIdleDuringBalancerNewSubConn(t *testing.T) {
} }
resolver.Register(rb) resolver.Register(rb)
cc, err := grpc.Dial( cc, err := grpc.NewClient(
name+":///", name+":///",
grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"`+name+`":{}}]}`)) grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"`+name+`":{}}]}`))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial error: %v", err) t.Fatalf("grpc.NewClient error: %v", err)
} }
defer cc.Close() defer cc.Close()

4
security/advancedtls/examples/credential_reloading_from_files/client/main.go
View File

@ -90,9 +90,9 @@ func main() {
} }
// Make a connection using the credentials. // Make a connection using the credentials.
conn, err := grpc.Dial(address, grpc.WithTransportCredentials(clientTLSCreds)) conn, err := grpc.NewClient(address, grpc.WithTransportCredentials(clientTLSCreds))
if err != nil { if err != nil {
log.Fatalf("grpc.DialContext to %s failed: %v", address, err) log.Fatalf("grpc.NewClient to %s failed: %v", address, err)
} }
client := pb.NewGreeterClient(conn) client := pb.NewGreeterClient(conn)

4
server_ext_test.go
View File

@ -124,9 +124,9 @@ func (s) TestStreamWorkers_RPCsAndStop(t *testing.T) {
ccs := make([]*grpc.ClientConn, numChannels) ccs := make([]*grpc.ClientConn, numChannels)
for i := 0; i < numChannels; i++ { for i := 0; i < numChannels; i++ {
var err error var err error
ccs[i], err = grpc.Dial(ss.Address, grpc.WithTransportCredentials(insecure.NewCredentials())) ccs[i], err = grpc.NewClient(ss.Address, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("[iteration: %d] grpc.Dial(%s) failed: %v", i, ss.Address, err) t.Fatalf("[iteration: %d] grpc.NewClient(%s) failed: %v", i, ss.Address, err)
} }
defer ccs[i].Close() defer ccs[i].Close()
client := testgrpc.NewTestServiceClient(ccs[i]) client := testgrpc.NewTestServiceClient(ccs[i])

4
test/authority_test.go
View File

@ -228,9 +228,9 @@ func (s) TestAuthorityReplacedWithResolverAddress(t *testing.T) {
r := manual.NewBuilderWithScheme("whatever") r := manual.NewBuilderWithScheme("whatever")
r.InitialState(resolver.State{Addresses: []resolver.Address{{Addr: ss.Address, ServerName: expectedAuthority}}}) r.InitialState(resolver.State{Addresses: []resolver.Address{{Addr: ss.Address, ServerName: expectedAuthority}}})
cc, err := grpc.Dial(r.Scheme()+":///whatever", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r)) cc, err := grpc.NewClient(r.Scheme()+":///whatever", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%q) = %v", ss.Address, err) t.Fatalf("grpc.NewClient(%q) = %v", ss.Address, err)
} }
defer cc.Close() defer cc.Close()

8
test/balancer_test.go
View File

@ -429,7 +429,7 @@ func (s) TestAddressAttributesInNewSubConn(t *testing.T) {
grpc.WithResolvers(r), grpc.WithResolvers(r),
grpc.WithDefaultServiceConfig(fmt.Sprintf(`{ "loadBalancingConfig": [{"%v": {}}] }`, attrBalancerName)), grpc.WithDefaultServiceConfig(fmt.Sprintf(`{ "loadBalancingConfig": [{"%v": {}}] }`, attrBalancerName)),
} }
cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -753,7 +753,7 @@ func (s) TestAuthorityInBuildOptions(t *testing.T) {
grpc.WithResolvers(r), grpc.WithResolvers(r),
grpc.WithDefaultServiceConfig(fmt.Sprintf(`{ "loadBalancingConfig": [{"%v": {}}] }`, balancerName)), grpc.WithDefaultServiceConfig(fmt.Sprintf(`{ "loadBalancingConfig": [{"%v": {}}] }`, balancerName)),
}, test.dopts...) }, test.dopts...)
cc, err := grpc.Dial(r.Scheme()+":///"+dialTarget, dopts...) cc, err := grpc.NewClient(r.Scheme()+":///"+dialTarget, dopts...)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -863,9 +863,9 @@ func (s) TestMetadataInPickResult(t *testing.T) {
grpc.WithResolvers(r), grpc.WithResolvers(r),
grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"loadBalancingConfig": [{"%s":{}}]}`, t.Name())), grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"loadBalancingConfig": [{"%s":{}}]}`, t.Name())),
} }
cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...)
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(): %v", err) t.Fatalf("grpc.NewClient(): %v", err)
} }
defer cc.Close() defer cc.Close()
tc := testgrpc.NewTestServiceClient(cc) tc := testgrpc.NewTestServiceClient(cc)

2
test/channelz_test.go
View File

@ -302,7 +302,7 @@ func (s) TestCZTopChannelRegistrationAndDeletion(t *testing.T) {
func (s) TestCZTopChannelRegistrationAndDeletionWhenDialFail(t *testing.T) { func (s) TestCZTopChannelRegistrationAndDeletionWhenDialFail(t *testing.T) {
// Make dial fails (due to no transport security specified) // Make dial fails (due to no transport security specified)
_, err := grpc.Dial("fake.addr") _, err := grpc.NewClient("fake.addr")
if err == nil { if err == nil {
t.Fatal("expecting dial to fail") t.Fatal("expecting dial to fail")
} }

4
test/clientconn_test.go
View File

@ -41,9 +41,9 @@ import (
// the expected error code. // the expected error code.
func (s) TestClientConnClose_WithPendingRPC(t *testing.T) { func (s) TestClientConnClose_WithPendingRPC(t *testing.T) {
r := manual.NewBuilderWithScheme("whatever") 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 { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
client := testgrpc.NewTestServiceClient(cc) client := testgrpc.NewTestServiceClient(cc)

2
test/goaway_test.go
View File

@ -73,7 +73,7 @@ func (s) TestGracefulClientOnGoAway(t *testing.T) {
} }
go s.Serve(lis) go s.Serve(lis)
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 { if err != nil {
t.Fatalf("Failed to dial server: %v", err) t.Fatalf("Failed to dial server: %v", err)
} }

4
test/http_header_end2end_test.go
View File

@ -242,9 +242,9 @@ func startServer(t *testing.T, headerFields ...[]string) (serverAddr string, cle
} }
func doHTTPHeaderTest(lisAddr string, errCode codes.Code) error { func doHTTPHeaderTest(lisAddr string, errCode codes.Code) error {
cc, err := grpc.Dial(lisAddr, grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(lisAddr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
return fmt.Errorf("dial(%q): %v", lisAddr, err) return fmt.Errorf("NewClient(%q): %v", lisAddr, err)
} }
defer cc.Close() defer cc.Close()
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)

12
test/insecure_creds_test.go
View File

@ -126,9 +126,9 @@ func (s) TestInsecureCreds(t *testing.T) {
if test.clientInsecureCreds { if test.clientInsecureCreds {
opts = []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())} opts = []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
} }
cc, err := grpc.Dial(addr, opts...) cc, err := grpc.NewClient(addr, opts...)
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%q) failed: %v", addr, err) t.Fatalf("grpc.NewClient(%q) failed: %v", addr, err)
} }
defer cc.Close() defer cc.Close()
@ -165,9 +165,9 @@ func (s) TestInsecureCreds_WithPerRPCCredentials_AsCallOption(t *testing.T) {
dopts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())} dopts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
copts := []grpc.CallOption{grpc.PerRPCCredentials(testLegacyPerRPCCredentials{})} copts := []grpc.CallOption{grpc.PerRPCCredentials(testLegacyPerRPCCredentials{})}
cc, err := grpc.Dial(addr, dopts...) cc, err := grpc.NewClient(addr, dopts...)
if err != nil { if err != nil {
t.Fatalf("grpc.Dial(%q) failed: %v", addr, err) t.Fatalf("grpc.NewClient(%q) failed: %v", addr, err)
} }
defer cc.Close() defer cc.Close()
@ -201,7 +201,7 @@ func (s) TestInsecureCreds_WithPerRPCCredentials_AsDialOption(t *testing.T) {
grpc.WithPerRPCCredentials(testLegacyPerRPCCredentials{}), grpc.WithPerRPCCredentials(testLegacyPerRPCCredentials{}),
} }
const wantErr = "the credentials require transport level security" const wantErr = "the credentials require transport level security"
if _, err := grpc.Dial(addr, dopts...); err == nil || !strings.Contains(err.Error(), wantErr) { if _, err := grpc.NewClient(addr, dopts...); err == nil || !strings.Contains(err.Error(), wantErr) {
t.Fatalf("grpc.Dial(%q) returned err %v, want: %v", addr, err, wantErr) t.Fatalf("grpc.NewClient(%q) returned err %v, want: %v", addr, err, wantErr)
} }
} }

4
test/local_creds_test.go
View File

@ -93,7 +93,7 @@ func testLocalCredsE2ESucceed(network, address string) error {
return net.Dial("unix", addr) return net.Dial("unix", addr)
})) }))
case "tcp": case "tcp":
cc, err = grpc.Dial(lisAddr, grpc.WithTransportCredentials(local.NewCredentials())) cc, err = grpc.NewClient(lisAddr, grpc.WithTransportCredentials(local.NewCredentials()))
default: default:
return fmt.Errorf("unsupported network %q", network) return fmt.Errorf("unsupported network %q", network)
} }
@ -191,7 +191,7 @@ func testLocalCredsE2EFail(dopts []grpc.DialOption) error {
go s.Serve(spoofListener(lis, fakeClientAddr)) go s.Serve(spoofListener(lis, fakeClientAddr))
cc, err := grpc.Dial(lis.Addr().String(), append(dopts, grpc.WithDialer(spoofDialer(fakeServerAddr)))...) cc, err := grpc.NewClient(lis.Addr().String(), append(dopts, grpc.WithDialer(spoofDialer(fakeServerAddr)))...)
if err != nil { if err != nil {
return fmt.Errorf("Failed to dial server: %v, %v", err, lis.Addr().String()) return fmt.Errorf("Failed to dial server: %v, %v", err, lis.Addr().String())
} }

8
test/pickfirst_test.go
View File

@ -80,9 +80,9 @@ func setupPickFirst(t *testing.T, backendCount int, opts ...grpc.DialOption) (*g
grpc.WithDefaultServiceConfig(pickFirstServiceConfig), grpc.WithDefaultServiceConfig(pickFirstServiceConfig),
} }
dopts = append(dopts, opts...) dopts = append(dopts, opts...)
cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...)
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
t.Cleanup(func() { cc.Close() }) t.Cleanup(func() { cc.Close() })
@ -537,9 +537,9 @@ func setupPickFirstWithListenerWrapper(t *testing.T, backendCount int, opts ...g
grpc.WithDefaultServiceConfig(pickFirstServiceConfig), grpc.WithDefaultServiceConfig(pickFirstServiceConfig),
} }
dopts = append(dopts, opts...) dopts = append(dopts, opts...)
cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...)
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
t.Cleanup(func() { cc.Close() }) t.Cleanup(func() { cc.Close() })

8
test/resolver_update_test.go
View File

@ -56,9 +56,9 @@ func (s) TestResolverUpdateDuringBuild_ServiceConfigParseError(t *testing.T) {
r := manual.NewBuilderWithScheme("whatever") r := manual.NewBuilderWithScheme("whatever")
r.InitialState(resolver.State{ServiceConfig: &serviceconfig.ParseResult{Err: errors.New("resolver build err")}}) r.InitialState(resolver.State{ServiceConfig: &serviceconfig.ParseResult{Err: errors.New("resolver build err")}})
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 { if err != nil {
t.Fatalf("Dial(_, _) = _, %v; want _, nil", err) t.Fatalf("NewClient(_, _) = _, %v; want _, nil", err)
} }
defer cc.Close() defer cc.Close()
@ -88,9 +88,9 @@ func (s) TestResolverUpdateDuringBuild_ServiceConfigInvalidTypeError(t *testing.
r := manual.NewBuilderWithScheme("whatever") r := manual.NewBuilderWithScheme("whatever")
r.InitialState(resolver.State{ServiceConfig: &serviceconfig.ParseResult{Config: fakeConfig{}}}) r.InitialState(resolver.State{ServiceConfig: &serviceconfig.ParseResult{Config: fakeConfig{}}})
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 { if err != nil {
t.Fatalf("Dial(_, _) = _, %v; want _, nil", err) t.Fatalf("NewClient(_, _) = _, %v; want _, nil", err)
} }
defer cc.Close() defer cc.Close()

2
test/retry_test.go
View File

@ -531,7 +531,7 @@ func (s) TestRetryStats(t *testing.T) {
} }
server.start(t, lis) server.start(t, lis)
handler := &retryStatsHandler{} handler := &retryStatsHandler{}
cc, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithStatsHandler(handler), cc, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithStatsHandler(handler),
grpc.WithDefaultServiceConfig((`{ grpc.WithDefaultServiceConfig((`{
"methodConfig": [{ "methodConfig": [{
"name": [{"service": "grpc.testing.TestService"}], "name": [{"service": "grpc.testing.TestService"}],

4
test/roundrobin_test.go
View File

@ -72,9 +72,9 @@ func testRoundRobinBasic(ctx context.Context, t *testing.T, opts ...grpc.DialOpt
grpc.WithDefaultServiceConfig(rrServiceConfig), grpc.WithDefaultServiceConfig(rrServiceConfig),
} }
dopts = append(dopts, opts...) dopts = append(dopts, opts...)
cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...)
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
t.Cleanup(func() { cc.Close() }) t.Cleanup(func() { cc.Close() })
client := testgrpc.NewTestServiceClient(cc) client := testgrpc.NewTestServiceClient(cc)

2
test/xds/xds_client_ack_nack_test.go
View File

@ -142,7 +142,7 @@ func (s) TestClientResourceVersionAfterStreamRestart(t *testing.T) {
} }
// Create a ClientConn and make a successful RPC. // Create a ClientConn and make a successful RPC.
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

2
test/xds/xds_client_affinity_test.go
View File

@ -115,7 +115,7 @@ func (s) TestClientSideAffinitySanityCheck(t *testing.T) {
} }
// Create a ClientConn and make a successful RPC. // Create a ClientConn and make a successful RPC.
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

4
test/xds/xds_client_certificate_providers_test.go
View File

@ -112,7 +112,7 @@ func (s) TestClientSideXDS_WithNoCertificateProvidersInBootstrap_Success(t *test
} }
// Create a ClientConn and make a successful RPC. // Create a ClientConn and make a successful RPC.
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 { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -330,7 +330,7 @@ func (s) TestClientSideXDS_WithValidAndInvalidSecurityConfiguration(t *testing.T
} }
// Create a ClientConn. // Create a ClientConn.
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(creds), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(creds), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

2
test/xds/xds_client_custom_lb_test.go
View File

@ -253,7 +253,7 @@ func (s) TestWrrLocality(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
if err != nil { if err != nil {
t.Fatalf("Failed to dial local test server: %v", err) t.Fatalf("Failed to dial local test server: %v", err)
} }

8
test/xds/xds_client_federation_test.go
View File

@ -128,7 +128,7 @@ func (s) TestClientSideFederation(t *testing.T) {
} }
// Create a ClientConn and make a successful RPC. // Create a ClientConn and make a successful RPC.
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -213,7 +213,7 @@ func (s) TestClientSideFederationWithOnlyXDSTPStyleLDS(t *testing.T) {
} }
// Create a ClientConn and make a successful RPC. // Create a ClientConn and make a successful RPC.
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -258,7 +258,7 @@ func (s) TestFederation_UnknownAuthorityInDialTarget(t *testing.T) {
// Create a ClientConn and make a successful RPC. // Create a ClientConn and make a successful RPC.
target := fmt.Sprintf("xds:///%s", serviceName) target := fmt.Sprintf("xds:///%s", serviceName)
cc, err := grpc.Dial(target, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(target, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("Dialing target %q: %v", target, err) t.Fatalf("Dialing target %q: %v", target, err)
} }
@ -327,7 +327,7 @@ func (s) TestFederation_UnknownAuthorityInReceivedResponse(t *testing.T) {
} }
target := fmt.Sprintf("xds:///%s", serviceName) target := fmt.Sprintf("xds:///%s", serviceName)
cc, err := grpc.Dial(target, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(target, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("Dialing target %q: %v", target, err) t.Fatalf("Dialing target %q: %v", target, err)
} }

8
test/xds/xds_client_ignore_resource_deletion_test.go
View File

@ -158,7 +158,7 @@ func testResourceDeletionIgnored(t *testing.T, initialResource func(string) e2e.
t.Fatal(err) t.Fatal(err)
} }
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsR)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsR))
if err != nil { if err != nil {
t.Fatalf("Failed to dial local test server: %v.", err) t.Fatalf("Failed to dial local test server: %v.", err)
} }
@ -213,7 +213,7 @@ func testResourceDeletionNotIgnored(t *testing.T, initialResource func(string) e
t.Fatal(err) t.Fatal(err)
} }
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsR)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsR))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -375,7 +375,7 @@ func (s) TestListenerResourceDeletionOnServerIgnored(t *testing.T) {
} }
// Create a ClientConn and make a successful RPCs. // Create a ClientConn and make a successful RPCs.
cc, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsR)) cc, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsR))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -442,7 +442,7 @@ func (s) TestListenerResourceDeletionOnServerNotIgnored(t *testing.T) {
} }
// Create a ClientConn and make a successful RPCs. // Create a ClientConn and make a successful RPCs.
cc, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsR)) cc, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(xdsR))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

2
test/xds/xds_client_integration_test.go
View File

@ -70,7 +70,7 @@ func (s) TestClientSideXDS(t *testing.T) {
} }
// Create a ClientConn and make a successful RPC. // Create a ClientConn and make a successful RPC.
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

6
test/xds/xds_client_outlier_detection_test.go
View File

@ -75,7 +75,7 @@ func (s) TestOutlierDetection_NoopConfig(t *testing.T) {
} }
// Create a ClientConn and make a successful RPC. // Create a ClientConn and make a successful RPC.
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -204,7 +204,7 @@ func (s) TestOutlierDetectionWithOutlier(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -291,7 +291,7 @@ func (s) TestOutlierDetectionXDSDefaultOn(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

2
test/xds/xds_client_retry_test.go
View File

@ -69,7 +69,7 @@ func (s) TestClientSideRetry(t *testing.T) {
} }
// Create a ClientConn and make a successful RPC. // Create a ClientConn and make a successful RPC.
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

2
test/xds/xds_rls_clusterspecifier_plugin_test.go
View File

@ -142,7 +142,7 @@ func testRLSinxDS(t *testing.T, lbPolicy e2e.LoadBalancingPolicy) {
}) })
// Create a ClientConn and make a successful RPC. // Create a ClientConn and make a successful RPC.
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

2
test/xds/xds_security_config_nack_test.go
View File

@ -344,7 +344,7 @@ func (s) TestUnmarshalCluster_WithUpdateValidatorFunc(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

8
test/xds/xds_server_certificate_providers_test.go
View File

@ -97,7 +97,7 @@ func (s) TestServerSideXDS_WithNoCertificateProvidersInBootstrap_Success(t *test
} }
// Create a client that uses insecure creds and verify RPCs. // Create a client that uses insecure creds and verify RPCs.
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 { if err != nil {
t.Fatalf("Failed to dial local test server: %v", err) t.Fatalf("Failed to dial local test server: %v", err)
} }
@ -225,7 +225,7 @@ func (s) TestServerSideXDS_WithNoCertificateProvidersInBootstrap_Failure(t *test
// Create a client that uses insecure creds and verify that RPCs don't // Create a client that uses insecure creds and verify that RPCs don't
// succeed. // succeed.
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 { if err != nil {
t.Fatalf("Failed to dial local test server: %v", err) t.Fatalf("Failed to dial local test server: %v", err)
} }
@ -443,7 +443,7 @@ func (s) TestServerSideXDS_WithValidAndInvalidSecurityConfiguration(t *testing.T
// Create a client that uses TLS creds and verify RPCs to listener1. // Create a client that uses TLS creds and verify RPCs to listener1.
clientCreds := e2e.CreateClientTLSCredentials(t) clientCreds := e2e.CreateClientTLSCredentials(t)
cc1, err := grpc.Dial(lis1.Addr().String(), grpc.WithTransportCredentials(clientCreds)) cc1, err := grpc.NewClient(lis1.Addr().String(), grpc.WithTransportCredentials(clientCreds))
if err != nil { if err != nil {
t.Fatalf("Failed to dial local test server: %v", err) t.Fatalf("Failed to dial local test server: %v", err)
} }
@ -471,7 +471,7 @@ func (s) TestServerSideXDS_WithValidAndInvalidSecurityConfiguration(t *testing.T
// Create a client that uses insecure creds and verify that RPCs don't // Create a client that uses insecure creds and verify that RPCs don't
// succeed to listener2. // succeed to listener2.
cc2, err := grpc.Dial(lis2.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) cc2, err := grpc.NewClient(lis2.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("Failed to dial local test server: %v", err) t.Fatalf("Failed to dial local test server: %v", err)
} }

6
test/xds/xds_server_serving_mode_test.go
View File

@ -103,7 +103,7 @@ func (s) TestServerSideXDS_RedundantUpdateSuppression(t *testing.T) {
} }
// Create a ClientConn and make a successful RPCs. // Create a ClientConn and make a successful RPCs.
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 { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -265,7 +265,7 @@ func (s) TestServerSideXDS_ServingModeChanges(t *testing.T) {
} }
// Create a ClientConn to the first listener and make a successful RPCs. // Create a ClientConn to the first listener and make a successful RPCs.
cc1, err := grpc.Dial(lis1.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) cc1, err := grpc.NewClient(lis1.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -273,7 +273,7 @@ func (s) TestServerSideXDS_ServingModeChanges(t *testing.T) {
waitForSuccessfulRPC(ctx, t, cc1) waitForSuccessfulRPC(ctx, t, cc1)
// Create a ClientConn to the second listener and make a successful RPCs. // Create a ClientConn to the second listener and make a successful RPCs.
cc2, err := grpc.Dial(lis2.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) cc2, err := grpc.NewClient(lis2.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

10
test/xds/xds_server_test.go
View File

@ -110,7 +110,7 @@ func (s) TestServeLDSRDS(t *testing.T) {
case <-serving.Done(): case <-serving.Done():
} }
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 { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -214,7 +214,7 @@ func (s) TestRDSNack(t *testing.T) {
} }
}() }()
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 { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -277,7 +277,7 @@ func (s) TestResourceNotFoundRDS(t *testing.T) {
} }
}() }()
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 { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -358,7 +358,7 @@ func (s) TestServingModeChanges(t *testing.T) {
t.Errorf("Serve() failed: %v", err) t.Errorf("Serve() failed: %v", err)
} }
}() }()
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 { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -471,7 +471,7 @@ func (s) TestMultipleUpdatesImmediatelySwitch(t *testing.T) {
} }
}() }()
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 { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

4
xds/csds/csds_e2e_test.go
View File

@ -165,7 +165,7 @@ func (s) TestCSDS(t *testing.T) {
}() }()
// Create a client to the CSDS server. // Create a client to the CSDS server.
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 { if err != nil {
t.Fatalf("Failed to dial CSDS server %q: %v", lis.Addr().String(), err) t.Fatalf("Failed to dial CSDS server %q: %v", lis.Addr().String(), err)
} }
@ -434,7 +434,7 @@ func (s) TestCSDSNoXDSClient(t *testing.T) {
defer server.Stop() defer server.Stop()
// Create a client to the CSDS server. // Create a client to the CSDS server.
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 { if err != nil {
t.Fatalf("Failed to dial CSDS server %q: %v", lis.Addr().String(), err) t.Fatalf("Failed to dial CSDS server %q: %v", lis.Addr().String(), err)
} }

2
xds/internal/balancer/clusterimpl/tests/balancer_test.go
View File

@ -92,7 +92,7 @@ func (s) TestConfigUpdateWithSameLoadReportingServerConfig(t *testing.T) {
} }
// Create a ClientConn and make a successful RPC. // Create a ClientConn and make a successful RPC.
cc, err := grpc.Dial(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver)) cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(resolver))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

8
xds/internal/balancer/outlierdetection/e2e_test/outlierdetection_test.go
View File

@ -221,9 +221,9 @@ func (s) TestOutlierDetectionAlgorithmsE2E(t *testing.T) {
ServiceConfig: sc, ServiceConfig: sc,
}) })
cc, err := grpc.Dial(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
defer cc.Close() defer cc.Close()
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
@ -298,9 +298,9 @@ func (s) TestNoopConfiguration(t *testing.T) {
Addresses: fullAddresses, Addresses: fullAddresses,
ServiceConfig: sc, ServiceConfig: sc,
}) })
cc, err := grpc.Dial(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient(mr.Scheme()+":///", grpc.WithResolvers(mr), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("grpc.Dial() failed: %v", err) t.Fatalf("grpc.NewClient() failed: %v", err)
} }
defer cc.Close() defer cc.Close()
ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)

4
xds/internal/httpfilter/fault/fault_test.go
View File

@ -529,7 +529,7 @@ func (s) TestFaultInjection_Unary(t *testing.T) {
} }
// Create a ClientConn and run the test case. // Create a ClientConn and run the test case.
cc, err := grpc.Dial("xds:///"+serviceName, grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient("xds:///"+serviceName, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }
@ -605,7 +605,7 @@ func (s) TestFaultInjection_MaxActiveFaults(t *testing.T) {
} }
// Create a ClientConn // Create a ClientConn
cc, err := grpc.Dial("xds:///myservice", grpc.WithTransportCredentials(insecure.NewCredentials())) cc, err := grpc.NewClient("xds:///myservice", grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { if err != nil {
t.Fatalf("failed to dial local test server: %v", err) t.Fatalf("failed to dial local test server: %v", err)
} }

4
xds/internal/xdsclient/tlscreds/bundle_ext_test.go
View File

@ -168,7 +168,7 @@ func (s) TestCaReloading(t *testing.T) {
serverCredentials := grpc.Creds(e2e.CreateServerTLSCredentials(t, tls.NoClientCert)) serverCredentials := grpc.Creds(e2e.CreateServerTLSCredentials(t, tls.NoClientCert))
server := stubserver.StartTestService(t, nil, serverCredentials) server := stubserver.StartTestService(t, nil, serverCredentials)
conn, err := grpc.Dial( conn, err := grpc.NewClient(
server.Address, server.Address,
grpc.WithCredentialsBundle(tlsBundle), grpc.WithCredentialsBundle(tlsBundle),
grpc.WithAuthority("x.test.example.com"), grpc.WithAuthority("x.test.example.com"),
@ -241,7 +241,7 @@ func (s) TestMTLS(t *testing.T) {
t.Fatalf("Failed to create TLS bundle: %v", err) t.Fatalf("Failed to create TLS bundle: %v", err)
} }
defer stop() defer stop()
conn, err := grpc.Dial(s.Address, grpc.WithCredentialsBundle(tlsBundle), grpc.WithAuthority("x.test.example.com")) conn, err := grpc.NewClient(s.Address, grpc.WithCredentialsBundle(tlsBundle), grpc.WithAuthority("x.test.example.com"))
if err != nil { if err != nil {
t.Fatalf("Error dialing: %v", err) t.Fatalf("Error dialing: %v", err)
} }

2
xds/internal/xdsclient/tlscreds/bundle_test.go
View File

@ -78,7 +78,7 @@ func (s) TestFailingProvider(t *testing.T) {
} }
creds.provider = &failingProvider{} creds.provider = &failingProvider{}
conn, err := grpc.Dial(s.Address, grpc.WithCredentialsBundle(tlsBundle), grpc.WithAuthority("x.test.example.com")) conn, err := grpc.NewClient(s.Address, grpc.WithCredentialsBundle(tlsBundle), grpc.WithAuthority("x.test.example.com"))
if err != nil { if err != nil {
t.Fatalf("Error dialing: %v", err) t.Fatalf("Error dialing: %v", err)
} }

4
xds/internal/xdsclient/transport/transport_test.go
View File

@ -39,7 +39,7 @@ func (s) TestNewWithGRPCDial(t *testing.T) {
customDialerCalled := false customDialerCalled := false
customDialer := func(target string, opts ...grpc.DialOption) (*grpc.ClientConn, error) { customDialer := func(target string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
customDialerCalled = true customDialerCalled = true
return grpc.Dial(target, opts...) return grpc.NewClient(target, opts...)
} }
oldDial := grpcDial oldDial := grpcDial
grpcDial = customDialer grpcDial = customDialer
@ -66,7 +66,7 @@ func (s) TestNewWithGRPCDial(t *testing.T) {
// Reset the dialer, create a new transport and ensure that our custom // Reset the dialer, create a new transport and ensure that our custom
// dialer is no longer called. // dialer is no longer called.
grpcDial = grpc.Dial grpcDial = grpc.NewClient
c, err = New(opts) c, err = New(opts)
defer func() { defer func() {
if c != nil { if c != nil {