vendor/google.golang.org/grpc/interop/client/client.go

   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
  19 package main
  20
  21 import (
  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
  35 var (
  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
  67 func 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 }