Bumping k8s dependencies to 1.13

vendor/google.golang.org/grpc/benchmark/worker/benchmark_client.go

@@ -23,7 +23,6 @@ import (
 	"math"
 	"runtime"
 	"sync"
-	"syscall"
 	"time"
 
 	"golang.org/x/net/context"
@@ -34,6 +33,7 @@ import (
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/internal/syscall"
 	"google.golang.org/grpc/status"
 	"google.golang.org/grpc/testdata"
 )
@@ -51,12 +51,12 @@ func (h *lockingHistogram) add(value int64) {
 	h.histogram.Add(value)
 }
 
-// swap sets h.histogram to new, and returns its old value.
-func (h *lockingHistogram) swap(new *stats.Histogram) *stats.Histogram {
+// swap sets h.histogram to o and returns its old value.
+func (h *lockingHistogram) swap(o *stats.Histogram) *stats.Histogram {
 	h.mu.Lock()
 	defer h.mu.Unlock()
 	old := h.histogram
-	h.histogram = new
+	h.histogram = o
 	return old
 }
 
@@ -81,20 +81,20 @@ func printClientConfig(config *testpb.ClientConfig) {
 	//     will always create sync client
 	// - async client threads.
 	// - core list
-	grpclog.Printf(" * client type: %v (ignored, always creates sync client)", config.ClientType)
-	grpclog.Printf(" * async client threads: %v (ignored)", config.AsyncClientThreads)
+	grpclog.Infof(" * client type: %v (ignored, always creates sync client)", config.ClientType)
+	grpclog.Infof(" * async client threads: %v (ignored)", config.AsyncClientThreads)
 	// TODO: use cores specified by CoreList when setting list of cores is supported in go.
-	grpclog.Printf(" * core list: %v (ignored)", config.CoreList)
+	grpclog.Infof(" * core list: %v (ignored)", config.CoreList)
 
-	grpclog.Printf(" - security params: %v", config.SecurityParams)
-	grpclog.Printf(" - core limit: %v", config.CoreLimit)
-	grpclog.Printf(" - payload config: %v", config.PayloadConfig)
-	grpclog.Printf(" - rpcs per chann: %v", config.OutstandingRpcsPerChannel)
-	grpclog.Printf(" - channel number: %v", config.ClientChannels)
-	grpclog.Printf(" - load params: %v", config.LoadParams)
-	grpclog.Printf(" - rpc type: %v", config.RpcType)
-	grpclog.Printf(" - histogram params: %v", config.HistogramParams)
-	grpclog.Printf(" - server targets: %v", config.ServerTargets)
+	grpclog.Infof(" - security params: %v", config.SecurityParams)
+	grpclog.Infof(" - core limit: %v", config.CoreLimit)
+	grpclog.Infof(" - payload config: %v", config.PayloadConfig)
+	grpclog.Infof(" - rpcs per chann: %v", config.OutstandingRpcsPerChannel)
+	grpclog.Infof(" - channel number: %v", config.ClientChannels)
+	grpclog.Infof(" - load params: %v", config.LoadParams)
+	grpclog.Infof(" - rpc type: %v", config.RpcType)
+	grpclog.Infof(" - histogram params: %v", config.HistogramParams)
+	grpclog.Infof(" - server targets: %v", config.ServerTargets)
 }
 
 func setupClientEnv(config *testpb.ClientConfig) {
@@ -118,7 +118,7 @@ func createConns(config *testpb.ClientConfig) ([]*grpc.ClientConn, func(), error
 	case testpb.ClientType_SYNC_CLIENT:
 	case testpb.ClientType_ASYNC_CLIENT:
 	default:
-		return nil, nil, status.Errorf(codes.InvalidArgument, "unknow client type: %v", config.ClientType)
+		return nil, nil, status.Errorf(codes.InvalidArgument, "unknown client type: %v", config.ClientType)
 	}
 
 	// Check and set security options.
@@ -142,13 +142,13 @@ func createConns(config *testpb.ClientConfig) ([]*grpc.ClientConn, func(), error
 			opts = append(opts, grpc.WithDefaultCallOptions(grpc.CallCustomCodec(byteBufCodec{})))
 		case *testpb.PayloadConfig_SimpleParams:
 		default:
-			return nil, nil, status.Errorf(codes.InvalidArgument, "unknow payload config: %v", config.PayloadConfig)
+			return nil, nil, status.Errorf(codes.InvalidArgument, "unknown payload config: %v", config.PayloadConfig)
 		}
 	}
 
 	// Create connections.
 	connCount := int(config.ClientChannels)
-	conns := make([]*grpc.ClientConn, connCount, connCount)
+	conns := make([]*grpc.ClientConn, connCount)
 	for connIndex := 0; connIndex < connCount; connIndex++ {
 		conns[connIndex] = benchmark.NewClientConn(config.ServerTargets[connIndex%len(config.ServerTargets)], opts...)
 	}
@@ -177,7 +177,7 @@ func performRPCs(config *testpb.ClientConfig, conns []*grpc.ClientConn, bc *benc
 			payloadRespSize = int(c.SimpleParams.RespSize)
 			payloadType = "protobuf"
 		default:
-			return status.Errorf(codes.InvalidArgument, "unknow payload config: %v", config.PayloadConfig)
+			return status.Errorf(codes.InvalidArgument, "unknown payload config: %v", config.PayloadConfig)
 		}
 	}
 
@@ -217,9 +217,6 @@ func startBenchmarkClient(config *testpb.ClientConfig) (*benchmarkClient, error)
 		return nil, err
 	}
 
-	rusage := new(syscall.Rusage)
-	syscall.Getrusage(syscall.RUSAGE_SELF, rusage)
-
 	rpcCountPerConn := int(config.OutstandingRpcsPerChannel)
 	bc := &benchmarkClient{
 		histogramOptions: stats.HistogramOptions{
@@ -228,12 +225,12 @@ func startBenchmarkClient(config *testpb.ClientConfig) (*benchmarkClient, error)
 			BaseBucketSize: (1 + config.HistogramParams.Resolution),
 			MinValue:       0,
 		},
-		lockingHistograms: make([]lockingHistogram, rpcCountPerConn*len(conns), rpcCountPerConn*len(conns)),
+		lockingHistograms: make([]lockingHistogram, rpcCountPerConn*len(conns)),
 
 		stop:            make(chan bool),
 		lastResetTime:   time.Now(),
 		closeConns:      closeConns,
-		rusageLastReset: rusage,
+		rusageLastReset: syscall.GetRusage(),
 	}
 
 	if err = performRPCs(config, conns, bc); err != nil {
@@ -335,12 +332,11 @@ func (bc *benchmarkClient) doCloseLoopStreaming(conns []*grpc.ClientConn, rpcCou
 func (bc *benchmarkClient) getStats(reset bool) *testpb.ClientStats {
 	var wallTimeElapsed, uTimeElapsed, sTimeElapsed float64
 	mergedHistogram := stats.NewHistogram(bc.histogramOptions)
-	latestRusage := new(syscall.Rusage)
 
 	if reset {
 		// Merging histogram may take some time.
 		// Put all histograms aside and merge later.
-		toMerge := make([]*stats.Histogram, len(bc.lockingHistograms), len(bc.lockingHistograms))
+		toMerge := make([]*stats.Histogram, len(bc.lockingHistograms))
 		for i := range bc.lockingHistograms {
 			toMerge[i] = bc.lockingHistograms[i].swap(stats.NewHistogram(bc.histogramOptions))
 		}
@@ -350,8 +346,8 @@ func (bc *benchmarkClient) getStats(reset bool) *testpb.ClientStats {
 		}
 
 		wallTimeElapsed = time.Since(bc.lastResetTime).Seconds()
-		syscall.Getrusage(syscall.RUSAGE_SELF, latestRusage)
-		uTimeElapsed, sTimeElapsed = cpuTimeDiff(bc.rusageLastReset, latestRusage)
+		latestRusage := syscall.GetRusage()
+		uTimeElapsed, sTimeElapsed = syscall.CPUTimeDiff(bc.rusageLastReset, latestRusage)
 
 		bc.rusageLastReset = latestRusage
 		bc.lastResetTime = time.Now()
@@ -362,11 +358,10 @@ func (bc *benchmarkClient) getStats(reset bool) *testpb.ClientStats {
 		}
 
 		wallTimeElapsed = time.Since(bc.lastResetTime).Seconds()
-		syscall.Getrusage(syscall.RUSAGE_SELF, latestRusage)
-		uTimeElapsed, sTimeElapsed = cpuTimeDiff(bc.rusageLastReset, latestRusage)
+		uTimeElapsed, sTimeElapsed = syscall.CPUTimeDiff(bc.rusageLastReset, syscall.GetRusage())
 	}
 
-	b := make([]uint32, len(mergedHistogram.Buckets), len(mergedHistogram.Buckets))
+	b := make([]uint32, len(mergedHistogram.Buckets))
 	for i, v := range mergedHistogram.Buckets {
 		b[i] = uint32(v.Count)
 	}

vendor/google.golang.org/grpc/benchmark/worker/benchmark_server.go

@@ -20,11 +20,12 @@ package main
 
 import (
 	"flag"
+	"fmt"
+	"net"
 	"runtime"
 	"strconv"
 	"strings"
 	"sync"
-	"syscall"
 	"time"
 
 	"google.golang.org/grpc"
@@ -33,6 +34,7 @@ import (
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/internal/syscall"
 	"google.golang.org/grpc/status"
 	"google.golang.org/grpc/testdata"
 )
@@ -57,15 +59,15 @@ func printServerConfig(config *testpb.ServerConfig) {
 	//     will always start sync server
 	// - async server threads
 	// - core list
-	grpclog.Printf(" * server type: %v (ignored, always starts sync server)", config.ServerType)
-	grpclog.Printf(" * async server threads: %v (ignored)", config.AsyncServerThreads)
+	grpclog.Infof(" * server type: %v (ignored, always starts sync server)", config.ServerType)
+	grpclog.Infof(" * async server threads: %v (ignored)", config.AsyncServerThreads)
 	// TODO: use cores specified by CoreList when setting list of cores is supported in go.
-	grpclog.Printf(" * core list: %v (ignored)", config.CoreList)
+	grpclog.Infof(" * core list: %v (ignored)", config.CoreList)
 
-	grpclog.Printf(" - security params: %v", config.SecurityParams)
-	grpclog.Printf(" - core limit: %v", config.CoreLimit)
-	grpclog.Printf(" - port: %v", config.Port)
-	grpclog.Printf(" - payload config: %v", config.PayloadConfig)
+	grpclog.Infof(" - security params: %v", config.SecurityParams)
+	grpclog.Infof(" - core limit: %v", config.CoreLimit)
+	grpclog.Infof(" - port: %v", config.Port)
+	grpclog.Infof(" - payload config: %v", config.PayloadConfig)
 }
 
 func startBenchmarkServer(config *testpb.ServerConfig, serverPort int) (*benchmarkServer, error) {
@@ -87,7 +89,7 @@ func startBenchmarkServer(config *testpb.ServerConfig, serverPort int) (*benchma
 	case testpb.ServerType_ASYNC_SERVER:
 	case testpb.ServerType_ASYNC_GENERIC_SERVER:
 	default:
-		return nil, status.Errorf(codes.InvalidArgument, "unknow server type: %v", config.ServerType)
+		return nil, status.Errorf(codes.InvalidArgument, "unknown server type: %v", config.ServerType)
 	}
 
 	// Set security options.
@@ -110,56 +112,54 @@ func startBenchmarkServer(config *testpb.ServerConfig, serverPort int) (*benchma
 	if port == 0 {
 		port = serverPort
 	}
+	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
+	if err != nil {
+		grpclog.Fatalf("Failed to listen: %v", err)
+	}
+	addr := lis.Addr().String()
 
 	// Create different benchmark server according to config.
-	var (
-		addr      string
-		closeFunc func()
-		err       error
-	)
+	var closeFunc func()
 	if config.PayloadConfig != nil {
 		switch payload := config.PayloadConfig.Payload.(type) {
 		case *testpb.PayloadConfig_BytebufParams:
 			opts = append(opts, grpc.CustomCodec(byteBufCodec{}))
-			addr, closeFunc = benchmark.StartServer(benchmark.ServerInfo{
-				Addr:     ":" + strconv.Itoa(port),
+			closeFunc = benchmark.StartServer(benchmark.ServerInfo{
 				Type:     "bytebuf",
 				Metadata: payload.BytebufParams.RespSize,
+				Listener: lis,
 			}, opts...)
 		case *testpb.PayloadConfig_SimpleParams:
-			addr, closeFunc = benchmark.StartServer(benchmark.ServerInfo{
-				Addr: ":" + strconv.Itoa(port),
-				Type: "protobuf",
+			closeFunc = benchmark.StartServer(benchmark.ServerInfo{
+				Type:     "protobuf",
+				Listener: lis,
 			}, opts...)
 		case *testpb.PayloadConfig_ComplexParams:
 			return nil, status.Errorf(codes.Unimplemented, "unsupported payload config: %v", config.PayloadConfig)
 		default:
-			return nil, status.Errorf(codes.InvalidArgument, "unknow payload config: %v", config.PayloadConfig)
+			return nil, status.Errorf(codes.InvalidArgument, "unknown payload config: %v", config.PayloadConfig)
 		}
 	} else {
 		// Start protobuf server if payload config is nil.
-		addr, closeFunc = benchmark.StartServer(benchmark.ServerInfo{
-			Addr: ":" + strconv.Itoa(port),
-			Type: "protobuf",
+		closeFunc = benchmark.StartServer(benchmark.ServerInfo{
+			Type:     "protobuf",
+			Listener: lis,
 		}, opts...)
 	}
 
-	grpclog.Printf("benchmark server listening at %v", addr)
+	grpclog.Infof("benchmark server listening at %v", addr)
 	addrSplitted := strings.Split(addr, ":")
 	p, err := strconv.Atoi(addrSplitted[len(addrSplitted)-1])
 	if err != nil {
 		grpclog.Fatalf("failed to get port number from server address: %v", err)
 	}
 
-	rusage := new(syscall.Rusage)
-	syscall.Getrusage(syscall.RUSAGE_SELF, rusage)
-
 	return &benchmarkServer{
 		port:            p,
 		cores:           numOfCores,
 		closeFunc:       closeFunc,
 		lastResetTime:   time.Now(),
-		rusageLastReset: rusage,
+		rusageLastReset: syscall.GetRusage(),
 	}, nil
 }
 
@@ -169,9 +169,8 @@ func (bs *benchmarkServer) getStats(reset bool) *testpb.ServerStats {
 	bs.mu.RLock()
 	defer bs.mu.RUnlock()
 	wallTimeElapsed := time.Since(bs.lastResetTime).Seconds()
-	rusageLatest := new(syscall.Rusage)
-	syscall.Getrusage(syscall.RUSAGE_SELF, rusageLatest)
-	uTimeElapsed, sTimeElapsed := cpuTimeDiff(bs.rusageLastReset, rusageLatest)
+	rusageLatest := syscall.GetRusage()
+	uTimeElapsed, sTimeElapsed := syscall.CPUTimeDiff(bs.rusageLastReset, rusageLatest)
 
 	if reset {
 		bs.lastResetTime = time.Now()

vendor/google.golang.org/grpc/benchmark/worker/main.go

@@ -79,7 +79,7 @@ func (s *workerServer) RunServer(stream testpb.WorkerService_RunServerServer) er
 	var bs *benchmarkServer
 	defer func() {
 		// Close benchmark server when stream ends.
-		grpclog.Printf("closing benchmark server")
+		grpclog.Infof("closing benchmark server")
 		if bs != nil {
 			bs.closeFunc()
 		}
@@ -96,9 +96,9 @@ func (s *workerServer) RunServer(stream testpb.WorkerService_RunServerServer) er
 		var out *testpb.ServerStatus
 		switch argtype := in.Argtype.(type) {
 		case *testpb.ServerArgs_Setup:
-			grpclog.Printf("server setup received:")
+			grpclog.Infof("server setup received:")
 			if bs != nil {
-				grpclog.Printf("server setup received when server already exists, closing the existing server")
+				grpclog.Infof("server setup received when server already exists, closing the existing server")
 				bs.closeFunc()
 			}
 			bs, err = startBenchmarkServer(argtype.Setup, s.serverPort)
@@ -112,8 +112,8 @@ func (s *workerServer) RunServer(stream testpb.WorkerService_RunServerServer) er
 			}
 
 		case *testpb.ServerArgs_Mark:
-			grpclog.Printf("server mark received:")
-			grpclog.Printf(" - %v", argtype)
+			grpclog.Infof("server mark received:")
+			grpclog.Infof(" - %v", argtype)
 			if bs == nil {
 				return status.Error(codes.InvalidArgument, "server does not exist when mark received")
 			}
@@ -134,7 +134,7 @@ func (s *workerServer) RunClient(stream testpb.WorkerService_RunClientServer) er
 	var bc *benchmarkClient
 	defer func() {
 		// Shut down benchmark client when stream ends.
-		grpclog.Printf("shuting down benchmark client")
+		grpclog.Infof("shuting down benchmark client")
 		if bc != nil {
 			bc.shutdown()
 		}
@@ -151,9 +151,9 @@ func (s *workerServer) RunClient(stream testpb.WorkerService_RunClientServer) er
 		var out *testpb.ClientStatus
 		switch t := in.Argtype.(type) {
 		case *testpb.ClientArgs_Setup:
-			grpclog.Printf("client setup received:")
+			grpclog.Infof("client setup received:")
 			if bc != nil {
-				grpclog.Printf("client setup received when client already exists, shuting down the existing client")
+				grpclog.Infof("client setup received when client already exists, shuting down the existing client")
 				bc.shutdown()
 			}
 			bc, err = startBenchmarkClient(t.Setup)
@@ -165,8 +165,8 @@ func (s *workerServer) RunClient(stream testpb.WorkerService_RunClientServer) er
 			}
 
 		case *testpb.ClientArgs_Mark:
-			grpclog.Printf("client mark received:")
-			grpclog.Printf(" - %v", t)
+			grpclog.Infof("client mark received:")
+			grpclog.Infof(" - %v", t)
 			if bc == nil {
 				return status.Error(codes.InvalidArgument, "client does not exist when mark received")
 			}
@@ -182,12 +182,12 @@ func (s *workerServer) RunClient(stream testpb.WorkerService_RunClientServer) er
 }
 
 func (s *workerServer) CoreCount(ctx context.Context, in *testpb.CoreRequest) (*testpb.CoreResponse, error) {
-	grpclog.Printf("core count: %v", runtime.NumCPU())
+	grpclog.Infof("core count: %v", runtime.NumCPU())
 	return &testpb.CoreResponse{Cores: int32(runtime.NumCPU())}, nil
 }
 
 func (s *workerServer) QuitWorker(ctx context.Context, in *testpb.Void) (*testpb.Void, error) {
-	grpclog.Printf("quiting worker")
+	grpclog.Infof("quitting worker")
 	s.stop <- true
 	return &testpb.Void{}, nil
 }
@@ -200,7 +200,7 @@ func main() {
 	if err != nil {
 		grpclog.Fatalf("failed to listen: %v", err)
 	}
-	grpclog.Printf("worker listening at port %v", *driverPort)
+	grpclog.Infof("worker listening at port %v", *driverPort)
 
 	s := grpc.NewServer()
 	stop := make(chan bool)
@@ -221,8 +221,8 @@ func main() {
 
 	if *pprofPort >= 0 {
 		go func() {
-			grpclog.Println("Starting pprof server on port " + strconv.Itoa(*pprofPort))
-			grpclog.Println(http.ListenAndServe("localhost:"+strconv.Itoa(*pprofPort), nil))
+			grpclog.Infoln("Starting pprof server on port " + strconv.Itoa(*pprofPort))
+			grpclog.Infoln(http.ListenAndServe("localhost:"+strconv.Itoa(*pprofPort), nil))
 		}()
 	}
 

vendor/google.golang.org/grpc/benchmark/worker/util.go

@@ -1,35 +0,0 @@
-/*
- *
- * Copyright 2016 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.
- *
- */
-
-package main
-
-import "syscall"
-
-func cpuTimeDiff(first *syscall.Rusage, latest *syscall.Rusage) (float64, float64) {
-	var (
-		utimeDiffs  = latest.Utime.Sec - first.Utime.Sec
-		utimeDiffus = latest.Utime.Usec - first.Utime.Usec
-		stimeDiffs  = latest.Stime.Sec - first.Stime.Sec
-		stimeDiffus = latest.Stime.Usec - first.Stime.Usec
-	)
-
-	uTimeElapsed := float64(utimeDiffs) + float64(utimeDiffus)*1.0e-6
-	sTimeElapsed := float64(stimeDiffs) + float64(stimeDiffus)*1.0e-6
-
-	return uTimeElapsed, sTimeElapsed
-}