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