1/*
2 *
3 * Copyright 2014 gRPC authors.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 */
18
19package main
20
21import (
22	"flag"
23	"net"
24	"strconv"
25
26	"google.golang.org/grpc"
27	"google.golang.org/grpc/credentials"
28	"google.golang.org/grpc/credentials/oauth"
29	"google.golang.org/grpc/grpclog"
30	"google.golang.org/grpc/interop"
31	testpb "google.golang.org/grpc/interop/grpc_testing"
32	"google.golang.org/grpc/testdata"
33)
34
35var (
36	caFile                = flag.String("ca_file", "", "The file containning the CA root cert file")
37	useTLS                = flag.Bool("use_tls", false, "Connection uses TLS if true, else plain TCP")
38	testCA                = flag.Bool("use_test_ca", false, "Whether to replace platform root CAs with test CA as the CA root")
39	serviceAccountKeyFile = flag.String("service_account_key_file", "", "Path to service account json key file")
40	oauthScope            = flag.String("oauth_scope", "", "The scope for OAuth2 tokens")
41	defaultServiceAccount = flag.String("default_service_account", "", "Email of GCE default service account")
42	serverHost            = flag.String("server_host", "localhost", "The server host name")
43	serverPort            = flag.Int("server_port", 10000, "The server port number")
44	tlsServerName         = flag.String("server_host_override", "", "The server name use to verify the hostname returned by TLS handshake if it is not empty. Otherwise, --server_host is used.")
45	testCase              = flag.String("test_case", "large_unary",
46		`Configure different test cases. Valid options are:
47        empty_unary : empty (zero bytes) request and response;
48        large_unary : single request and (large) response;
49        client_streaming : request streaming with single response;
50        server_streaming : single request with response streaming;
51        ping_pong : full-duplex streaming;
52        empty_stream : full-duplex streaming with zero message;
53        timeout_on_sleeping_server: fullduplex streaming on a sleeping server;
54        compute_engine_creds: large_unary with compute engine auth;
55        service_account_creds: large_unary with service account auth;
56        jwt_token_creds: large_unary with jwt token auth;
57        per_rpc_creds: large_unary with per rpc token;
58        oauth2_auth_token: large_unary with oauth2 token auth;
59        cancel_after_begin: cancellation after metadata has been sent but before payloads are sent;
60        cancel_after_first_response: cancellation after receiving 1st message from the server;
61        status_code_and_message: status code propagated back to client;
62        custom_metadata: server will echo custom metadata;
63        unimplemented_method: client attempts to call unimplemented method;
64        unimplemented_service: client attempts to call unimplemented service.`)
65)
66
67func main() {
68	flag.Parse()
69	serverAddr := net.JoinHostPort(*serverHost, strconv.Itoa(*serverPort))
70	var opts []grpc.DialOption
71	if *useTLS {
72		var sn string
73		if *tlsServerName != "" {
74			sn = *tlsServerName
75		}
76		var creds credentials.TransportCredentials
77		if *testCA {
78			var err error
79			if *caFile == "" {
80				*caFile = testdata.Path("ca.pem")
81			}
82			creds, err = credentials.NewClientTLSFromFile(*caFile, sn)
83			if err != nil {
84				grpclog.Fatalf("Failed to create TLS credentials %v", err)
85			}
86		} else {
87			creds = credentials.NewClientTLSFromCert(nil, sn)
88		}
89		opts = append(opts, grpc.WithTransportCredentials(creds))
90		if *testCase == "compute_engine_creds" {
91			opts = append(opts, grpc.WithPerRPCCredentials(oauth.NewComputeEngine()))
92		} else if *testCase == "service_account_creds" {
93			jwtCreds, err := oauth.NewServiceAccountFromFile(*serviceAccountKeyFile, *oauthScope)
94			if err != nil {
95				grpclog.Fatalf("Failed to create JWT credentials: %v", err)
96			}
97			opts = append(opts, grpc.WithPerRPCCredentials(jwtCreds))
98		} else if *testCase == "jwt_token_creds" {
99			jwtCreds, err := oauth.NewJWTAccessFromFile(*serviceAccountKeyFile)
100			if err != nil {
101				grpclog.Fatalf("Failed to create JWT credentials: %v", err)
102			}
103			opts = append(opts, grpc.WithPerRPCCredentials(jwtCreds))
104		} else if *testCase == "oauth2_auth_token" {
105			opts = append(opts, grpc.WithPerRPCCredentials(oauth.NewOauthAccess(interop.GetToken(*serviceAccountKeyFile, *oauthScope))))
106		}
107	} else {
108		opts = append(opts, grpc.WithInsecure())
109	}
110	opts = append(opts, grpc.WithBlock())
111	conn, err := grpc.Dial(serverAddr, opts...)
112	if err != nil {
113		grpclog.Fatalf("Fail to dial: %v", err)
114	}
115	defer conn.Close()
116	tc := testpb.NewTestServiceClient(conn)
117	switch *testCase {
118	case "empty_unary":
119		interop.DoEmptyUnaryCall(tc)
120		grpclog.Println("EmptyUnaryCall done")
121	case "large_unary":
122		interop.DoLargeUnaryCall(tc)
123		grpclog.Println("LargeUnaryCall done")
124	case "client_streaming":
125		interop.DoClientStreaming(tc)
126		grpclog.Println("ClientStreaming done")
127	case "server_streaming":
128		interop.DoServerStreaming(tc)
129		grpclog.Println("ServerStreaming done")
130	case "ping_pong":
131		interop.DoPingPong(tc)
132		grpclog.Println("Pingpong done")
133	case "empty_stream":
134		interop.DoEmptyStream(tc)
135		grpclog.Println("Emptystream done")
136	case "timeout_on_sleeping_server":
137		interop.DoTimeoutOnSleepingServer(tc)
138		grpclog.Println("TimeoutOnSleepingServer done")
139	case "compute_engine_creds":
140		if !*useTLS {
141			grpclog.Fatalf("TLS is not enabled. TLS is required to execute compute_engine_creds test case.")
142		}
143		interop.DoComputeEngineCreds(tc, *defaultServiceAccount, *oauthScope)
144		grpclog.Println("ComputeEngineCreds done")
145	case "service_account_creds":
146		if !*useTLS {
147			grpclog.Fatalf("TLS is not enabled. TLS is required to execute service_account_creds test case.")
148		}
149		interop.DoServiceAccountCreds(tc, *serviceAccountKeyFile, *oauthScope)
150		grpclog.Println("ServiceAccountCreds done")
151	case "jwt_token_creds":
152		if !*useTLS {
153			grpclog.Fatalf("TLS is not enabled. TLS is required to execute jwt_token_creds test case.")
154		}
155		interop.DoJWTTokenCreds(tc, *serviceAccountKeyFile)
156		grpclog.Println("JWTtokenCreds done")
157	case "per_rpc_creds":
158		if !*useTLS {
159			grpclog.Fatalf("TLS is not enabled. TLS is required to execute per_rpc_creds test case.")
160		}
161		interop.DoPerRPCCreds(tc, *serviceAccountKeyFile, *oauthScope)
162		grpclog.Println("PerRPCCreds done")
163	case "oauth2_auth_token":
164		if !*useTLS {
165			grpclog.Fatalf("TLS is not enabled. TLS is required to execute oauth2_auth_token test case.")
166		}
167		interop.DoOauth2TokenCreds(tc, *serviceAccountKeyFile, *oauthScope)
168		grpclog.Println("Oauth2TokenCreds done")
169	case "cancel_after_begin":
170		interop.DoCancelAfterBegin(tc)
171		grpclog.Println("CancelAfterBegin done")
172	case "cancel_after_first_response":
173		interop.DoCancelAfterFirstResponse(tc)
174		grpclog.Println("CancelAfterFirstResponse done")
175	case "status_code_and_message":
176		interop.DoStatusCodeAndMessage(tc)
177		grpclog.Println("StatusCodeAndMessage done")
178	case "custom_metadata":
179		interop.DoCustomMetadata(tc)
180		grpclog.Println("CustomMetadata done")
181	case "unimplemented_method":
182		interop.DoUnimplementedMethod(conn)
183		grpclog.Println("UnimplementedMethod done")
184	case "unimplemented_service":
185		interop.DoUnimplementedService(testpb.NewUnimplementedServiceClient(conn))
186		grpclog.Println("UnimplementedService done")
187	default:
188		grpclog.Fatal("Unsupported test case: ", *testCase)
189	}
190}
191