Fresh dep ensure

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

@@ -30,10 +30,6 @@ import (
 	testpb "google.golang.org/grpc/interop/grpc_testing"
 )
 
-const (
-	value = "test_value"
-)
-
 var (
 	hsAddr     = flag.String("alts_handshaker_service_address", "", "ALTS handshaker gRPC service address")
 	serverAddr = flag.String("server_address", ":8080", "The port on which the server is listening")

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

@@ -27,17 +27,24 @@ import (
 	_ "google.golang.org/grpc/balancer/grpclb"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/credentials/alts"
+	"google.golang.org/grpc/credentials/google"
 	"google.golang.org/grpc/credentials/oauth"
 	"google.golang.org/grpc/grpclog"
 	"google.golang.org/grpc/interop"
 	testpb "google.golang.org/grpc/interop/grpc_testing"
+	"google.golang.org/grpc/resolver"
 	"google.golang.org/grpc/testdata"
 )
 
+const (
+	googleDefaultCredsName = "google_default_credentials"
+)
+
 var (
 	caFile                = flag.String("ca_file", "", "The file containning the CA root cert file")
 	useTLS                = flag.Bool("use_tls", false, "Connection uses TLS if true")
 	useALTS               = flag.Bool("use_alts", false, "Connection uses ALTS if true (this option can only be used on GCP)")
+	customCredentialsType = flag.String("custom_credentials_type", "", "Custom creds to use, excluding TLS or ALTS")
 	altsHSAddr            = flag.String("alts_handshaker_service_address", "", "ALTS handshaker gRPC service address")
 	testCA                = flag.Bool("use_test_ca", false, "Whether to replace platform root CAs with test CA as the CA root")
 	serviceAccountKeyFile = flag.String("service_account_key_file", "", "Path to service account json key file")
@@ -63,19 +70,49 @@ var (
         cancel_after_begin: cancellation after metadata has been sent but before payloads are sent;
         cancel_after_first_response: cancellation after receiving 1st message from the server;
         status_code_and_message: status code propagated back to client;
+        special_status_message: Unicode and whitespace is correctly processed in status message;
         custom_metadata: server will echo custom metadata;
         unimplemented_method: client attempts to call unimplemented method;
         unimplemented_service: client attempts to call unimplemented service.`)
 )
 
+type credsMode uint8
+
+const (
+	credsNone credsMode = iota
+	credsTLS
+	credsALTS
+	credsGoogleDefaultCreds
+)
+
 func main() {
 	flag.Parse()
-	if *useTLS && *useALTS {
-		grpclog.Fatalf("use_tls and use_alts cannot be both set to true")
+	var useGDC bool // use google default creds
+	if *customCredentialsType != "" {
+		if *customCredentialsType != googleDefaultCredsName {
+			grpclog.Fatalf("custom_credentials_type can only be set to %v or not set", googleDefaultCredsName)
+		}
+		useGDC = true
 	}
+	if (*useTLS && *useALTS) || (*useTLS && useGDC) || (*useALTS && useGDC) {
+		grpclog.Fatalf("only one of TLS, ALTS and google default creds can be used")
+	}
+
+	var credsChosen credsMode
+	switch {
+	case *useTLS:
+		credsChosen = credsTLS
+	case *useALTS:
+		credsChosen = credsALTS
+	case useGDC:
+		credsChosen = credsGoogleDefaultCreds
+	}
+
+	resolver.SetDefaultScheme("dns")
 	serverAddr := net.JoinHostPort(*serverHost, strconv.Itoa(*serverPort))
 	var opts []grpc.DialOption
-	if *useTLS {
+	switch credsChosen {
+	case credsTLS:
 		var sn string
 		if *tlsServerName != "" {
 			sn = *tlsServerName
@@ -94,6 +131,19 @@ func main() {
 			creds = credentials.NewClientTLSFromCert(nil, sn)
 		}
 		opts = append(opts, grpc.WithTransportCredentials(creds))
+	case credsALTS:
+		altsOpts := alts.DefaultClientOptions()
+		if *altsHSAddr != "" {
+			altsOpts.HandshakerServiceAddress = *altsHSAddr
+		}
+		altsTC := alts.NewClientCreds(altsOpts)
+		opts = append(opts, grpc.WithTransportCredentials(altsTC))
+	case credsGoogleDefaultCreds:
+		opts = append(opts, grpc.WithCredentialsBundle(google.NewDefaultCredentials()))
+	default:
+		opts = append(opts, grpc.WithInsecure())
+	}
+	if credsChosen == credsTLS || credsChosen == credsALTS {
 		if *testCase == "compute_engine_creds" {
 			opts = append(opts, grpc.WithPerRPCCredentials(oauth.NewComputeEngine()))
 		} else if *testCase == "service_account_creds" {
@@ -111,15 +161,6 @@ func main() {
 		} else if *testCase == "oauth2_auth_token" {
 			opts = append(opts, grpc.WithPerRPCCredentials(oauth.NewOauthAccess(interop.GetToken(*serviceAccountKeyFile, *oauthScope))))
 		}
-	} else if *useALTS {
-		altsOpts := alts.DefaultClientOptions()
-		if *altsHSAddr != "" {
-			altsOpts.HandshakerServiceAddress = *altsHSAddr
-		}
-		altsTC := alts.NewClientCreds(altsOpts)
-		opts = append(opts, grpc.WithTransportCredentials(altsTC))
-	} else {
-		opts = append(opts, grpc.WithInsecure())
 	}
 	opts = append(opts, grpc.WithBlock())
 	conn, err := grpc.Dial(serverAddr, opts...)
@@ -151,32 +192,32 @@ func main() {
 		interop.DoTimeoutOnSleepingServer(tc)
 		grpclog.Infoln("TimeoutOnSleepingServer done")
 	case "compute_engine_creds":
-		if !*useTLS {
-			grpclog.Fatalf("TLS is not enabled. TLS is required to execute compute_engine_creds test case.")
+		if credsChosen == credsNone {
+			grpclog.Fatalf("Credentials (TLS, ALTS or google default creds) need to be set for compute_engine_creds test case.")
 		}
 		interop.DoComputeEngineCreds(tc, *defaultServiceAccount, *oauthScope)
 		grpclog.Infoln("ComputeEngineCreds done")
 	case "service_account_creds":
-		if !*useTLS {
-			grpclog.Fatalf("TLS is not enabled. TLS is required to execute service_account_creds test case.")
+		if credsChosen == credsNone {
+			grpclog.Fatalf("Credentials (TLS, ALTS or google default creds) need to be set for service_account_creds test case.")
 		}
 		interop.DoServiceAccountCreds(tc, *serviceAccountKeyFile, *oauthScope)
 		grpclog.Infoln("ServiceAccountCreds done")
 	case "jwt_token_creds":
-		if !*useTLS {
-			grpclog.Fatalf("TLS is not enabled. TLS is required to execute jwt_token_creds test case.")
+		if credsChosen == credsNone {
+			grpclog.Fatalf("Credentials (TLS, ALTS or google default creds) need to be set for jwt_token_creds test case.")
 		}
 		interop.DoJWTTokenCreds(tc, *serviceAccountKeyFile)
 		grpclog.Infoln("JWTtokenCreds done")
 	case "per_rpc_creds":
-		if !*useTLS {
-			grpclog.Fatalf("TLS is not enabled. TLS is required to execute per_rpc_creds test case.")
+		if credsChosen == credsNone {
+			grpclog.Fatalf("Credentials (TLS, ALTS or google default creds) need to be set for per_rpc_creds test case.")
 		}
 		interop.DoPerRPCCreds(tc, *serviceAccountKeyFile, *oauthScope)
 		grpclog.Infoln("PerRPCCreds done")
 	case "oauth2_auth_token":
-		if !*useTLS {
-			grpclog.Fatalf("TLS is not enabled. TLS is required to execute oauth2_auth_token test case.")
+		if credsChosen == credsNone {
+			grpclog.Fatalf("Credentials (TLS, ALTS or google default creds) need to be set for oauth2_auth_token test case.")
 		}
 		interop.DoOauth2TokenCreds(tc, *serviceAccountKeyFile, *oauthScope)
 		grpclog.Infoln("Oauth2TokenCreds done")
@@ -189,6 +230,9 @@ func main() {
 	case "status_code_and_message":
 		interop.DoStatusCodeAndMessage(tc)
 		grpclog.Infoln("StatusCodeAndMessage done")
+	case "special_status_message":
+		interop.DoSpecialStatusMessage(tc)
+		grpclog.Infoln("SpecialStatusMessage done")
 	case "custom_metadata":
 		interop.DoCustomMetadata(tc)
 		grpclog.Infoln("CustomMetadata done")

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

@@ -0,0 +1,169 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// This file is for testing only. Runs a fake grpclb balancer server.
+// The name of the service to load balance for and the addresses
+// of that service are provided by command line flags.
+package main
+
+import (
+	"flag"
+	"net"
+	"strconv"
+	"strings"
+	"time"
+
+	"google.golang.org/grpc"
+	lbpb "google.golang.org/grpc/balancer/grpclb/grpc_lb_v1"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/credentials/alts"
+	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/status"
+	"google.golang.org/grpc/testdata"
+)
+
+var (
+	port         = flag.Int("port", 10000, "Port to listen on.")
+	backendAddrs = flag.String("backend_addrs", "", "Comma separated list of backend IP/port addresses.")
+	useALTS      = flag.Bool("use_alts", false, "Listen on ALTS credentials.")
+	useTLS       = flag.Bool("use_tls", false, "Listen on TLS credentials, using a test certificate.")
+	shortStream  = flag.Bool("short_stream", false, "End the balancer stream immediately after sending the first server list.")
+	serviceName  = flag.String("service_name", "UNSET", "Name of the service being load balanced for.")
+)
+
+type loadBalancerServer struct {
+	serverListResponse *lbpb.LoadBalanceResponse
+}
+
+func (l *loadBalancerServer) BalanceLoad(stream lbpb.LoadBalancer_BalanceLoadServer) error {
+	grpclog.Info("Begin handling new BalancerLoad request.")
+	var lbReq *lbpb.LoadBalanceRequest
+	var err error
+	if lbReq, err = stream.Recv(); err != nil {
+		grpclog.Errorf("Error receiving LoadBalanceRequest: %v", err)
+		return err
+	}
+	grpclog.Info("LoadBalancerRequest received.")
+	initialReq := lbReq.GetInitialRequest()
+	if initialReq == nil {
+		grpclog.Info("Expected first request to be an InitialRequest. Got: %v", lbReq)
+		return status.Error(codes.Unknown, "First request not an InitialRequest")
+	}
+	// gRPC clients targeting foo.bar.com:443 can sometimes include the ":443" suffix in
+	// their requested names; handle this case. TODO: make 443 configurable?
+	var cleanedName string
+	var requestedNamePortNumber string
+	if cleanedName, requestedNamePortNumber, err = net.SplitHostPort(initialReq.Name); err != nil {
+		cleanedName = initialReq.Name
+	} else {
+		if requestedNamePortNumber != "443" {
+			grpclog.Info("Bad requested service name port number: %v.", requestedNamePortNumber)
+			return status.Error(codes.Unknown, "Bad requested service name port number")
+		}
+	}
+	if cleanedName != *serviceName {
+		grpclog.Info("Expected requested service name: %v. Got: %v", *serviceName, initialReq.Name)
+		return status.Error(codes.NotFound, "Bad requested service name")
+	}
+	if err := stream.Send(&lbpb.LoadBalanceResponse{
+		LoadBalanceResponseType: &lbpb.LoadBalanceResponse_InitialResponse{
+			InitialResponse: &lbpb.InitialLoadBalanceResponse{},
+		},
+	}); err != nil {
+		grpclog.Errorf("Error sending initial LB response: %v", err)
+		return status.Error(codes.Unknown, "Error sending initial response")
+	}
+	grpclog.Info("Send LoadBalanceResponse: %v", l.serverListResponse)
+	if err := stream.Send(l.serverListResponse); err != nil {
+		grpclog.Errorf("Error sending LB response: %v", err)
+		return status.Error(codes.Unknown, "Error sending response")
+	}
+	if *shortStream {
+		return nil
+	}
+	for {
+		grpclog.Info("Send LoadBalanceResponse: %v", l.serverListResponse)
+		if err := stream.Send(l.serverListResponse); err != nil {
+			grpclog.Errorf("Error sending LB response: %v", err)
+			return status.Error(codes.Unknown, "Error sending response")
+		}
+		time.Sleep(10 * time.Second)
+	}
+}
+
+func main() {
+	flag.Parse()
+	var opts []grpc.ServerOption
+	if *useTLS {
+		certFile := testdata.Path("server1.pem")
+		keyFile := testdata.Path("server1.key")
+		creds, err := credentials.NewServerTLSFromFile(certFile, keyFile)
+		if err != nil {
+			grpclog.Fatalf("Failed to generate credentials %v", err)
+		}
+		opts = append(opts, grpc.Creds(creds))
+	} else if *useALTS {
+		altsOpts := alts.DefaultServerOptions()
+		altsTC := alts.NewServerCreds(altsOpts)
+		opts = append(opts, grpc.Creds(altsTC))
+	}
+	var serverList []*lbpb.Server
+	if len(*backendAddrs) == 0 {
+		serverList = make([]*lbpb.Server, 0)
+	} else {
+		rawBackendAddrs := strings.Split(*backendAddrs, ",")
+		serverList = make([]*lbpb.Server, len(rawBackendAddrs))
+		for i := range rawBackendAddrs {
+			rawIP, rawPort, err := net.SplitHostPort(rawBackendAddrs[i])
+			if err != nil {
+				grpclog.Fatalf("Failed to parse --backend_addrs[%d]=%v, error: %v", i, rawBackendAddrs[i], err)
+			}
+			ip := net.ParseIP(rawIP)
+			if ip == nil {
+				grpclog.Fatalf("Failed to parse ip: %v", rawIP)
+			}
+			numericPort, err := strconv.Atoi(rawPort)
+			if err != nil {
+				grpclog.Fatalf("Failed to convert port %v to int", rawPort)
+			}
+			grpclog.Infof("Adding backend ip: %v, port: %d", ip.String(), numericPort)
+			serverList[i] = &lbpb.Server{
+				IpAddress: ip,
+				Port:      int32(numericPort),
+			}
+		}
+	}
+	serverListResponse := &lbpb.LoadBalanceResponse{
+		LoadBalanceResponseType: &lbpb.LoadBalanceResponse_ServerList{
+			ServerList: &lbpb.ServerList{
+				Servers: serverList,
+			},
+		},
+	}
+	server := grpc.NewServer(opts...)
+	grpclog.Infof("Begin listening on %d.", *port)
+	lis, err := net.Listen("tcp", ":"+strconv.Itoa(*port))
+	if err != nil {
+		grpclog.Fatalf("Failed to listen on port %v: %v", *port, err)
+	}
+	lbpb.RegisterLoadBalancerServer(server, &loadBalancerServer{
+		serverListResponse: serverListResponse,
+	})
+	server.Serve(lis)
+}

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

@@ -563,6 +563,27 @@ func DoStatusCodeAndMessage(tc testpb.TestServiceClient, args ...grpc.CallOption
 	}
 }
 
+// DoSpecialStatusMessage verifies Unicode and whitespace is correctly processed
+// in status message.
+func DoSpecialStatusMessage(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	const (
+		code int32  = 2
+		msg  string = "\t\ntest with whitespace\r\nand Unicode BMP ☺ and non-BMP 😈\t\n"
+	)
+	expectedErr := status.Error(codes.Code(code), msg)
+	req := &testpb.SimpleRequest{
+		ResponseStatus: &testpb.EchoStatus{
+			Code:    code,
+			Message: msg,
+		},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	if _, err := tc.UnaryCall(ctx, req, args...); err == nil || err.Error() != expectedErr.Error() {
+		grpclog.Fatalf("%v.UnaryCall(_, %v) = _, %v, want _, %v", tc, req, err, expectedErr)
+	}
+}
+
 // DoUnimplementedService attempts to call a method from an unimplemented service.
 func DoUnimplementedService(tc testpb.UnimplementedServiceClient) {
 	_, err := tc.UnimplementedCall(context.Background(), &testpb.Empty{})