vendor update for CSI 0.3.0

vendor/k8s.io/kubernetes/pkg/kubelet/server/BUILD

@@ -19,13 +19,13 @@ go_library(
         "//pkg/apis/core:go_default_library",
         "//pkg/apis/core/v1/validation:go_default_library",
         "//pkg/kubelet/container:go_default_library",
+        "//pkg/kubelet/prober:go_default_library",
         "//pkg/kubelet/server/portforward:go_default_library",
         "//pkg/kubelet/server/remotecommand:go_default_library",
         "//pkg/kubelet/server/stats:go_default_library",
         "//pkg/kubelet/server/streaming:go_default_library",
         "//pkg/kubelet/types:go_default_library",
         "//pkg/util/configz:go_default_library",
-        "//pkg/util/limitwriter:go_default_library",
         "//vendor/github.com/emicklei/go-restful:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
@@ -37,7 +37,7 @@ go_library(
         "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/util/remotecommand:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/proxy:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
         "//vendor/k8s.io/apiserver/pkg/authentication/authenticator:go_default_library",
         "//vendor/k8s.io/apiserver/pkg/authentication/user:go_default_library",
@@ -45,7 +45,6 @@ go_library(
         "//vendor/k8s.io/apiserver/pkg/server/healthz:go_default_library",
         "//vendor/k8s.io/apiserver/pkg/server/httplog:go_default_library",
         "//vendor/k8s.io/apiserver/pkg/util/flushwriter:go_default_library",
-        "//vendor/k8s.io/client-go/tools/remotecommand:go_default_library",
     ],
 )
 
@@ -60,13 +59,14 @@ go_test(
     deps = [
         "//pkg/apis/core:go_default_library",
         "//pkg/apis/core/install:go_default_library",
+        "//pkg/kubelet/apis/cri/runtime/v1alpha2:go_default_library",
         "//pkg/kubelet/apis/stats/v1alpha1:go_default_library",
         "//pkg/kubelet/cm:go_default_library",
         "//pkg/kubelet/container:go_default_library",
-        "//pkg/kubelet/container/testing:go_default_library",
         "//pkg/kubelet/server/portforward:go_default_library",
         "//pkg/kubelet/server/remotecommand:go_default_library",
         "//pkg/kubelet/server/stats:go_default_library",
+        "//pkg/kubelet/server/streaming:go_default_library",
         "//pkg/volume:go_default_library",
         "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
         "//vendor/github.com/stretchr/testify/assert:go_default_library",

vendor/k8s.io/kubernetes/pkg/kubelet/server/server.go

@@ -42,30 +42,30 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
-	remotecommandconsts "k8s.io/apimachinery/pkg/util/remotecommand"
+	"k8s.io/apimachinery/pkg/util/proxy"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apiserver/pkg/authentication/authenticator"
 	"k8s.io/apiserver/pkg/authorization/authorizer"
 	"k8s.io/apiserver/pkg/server/healthz"
 	"k8s.io/apiserver/pkg/server/httplog"
 	"k8s.io/apiserver/pkg/util/flushwriter"
-	"k8s.io/client-go/tools/remotecommand"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/apis/core/v1/validation"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
+	"k8s.io/kubernetes/pkg/kubelet/prober"
 	"k8s.io/kubernetes/pkg/kubelet/server/portforward"
 	remotecommandserver "k8s.io/kubernetes/pkg/kubelet/server/remotecommand"
 	"k8s.io/kubernetes/pkg/kubelet/server/stats"
 	"k8s.io/kubernetes/pkg/kubelet/server/streaming"
 	kubelettypes "k8s.io/kubernetes/pkg/kubelet/types"
 	"k8s.io/kubernetes/pkg/util/configz"
-	"k8s.io/kubernetes/pkg/util/limitwriter"
 )
 
 const (
 	metricsPath         = "/metrics"
 	cadvisorMetricsPath = "/metrics/cadvisor"
+	proberMetricsPath   = "/metrics/probes"
 	specPath            = "/spec/"
 	statsPath           = "/stats/"
 	logsPath            = "/logs/"
@@ -73,11 +73,11 @@ const (
 
 // Server is a http.Handler which exposes kubelet functionality over HTTP.
 type Server struct {
-	auth             AuthInterface
-	host             HostInterface
-	restfulCont      containerInterface
-	resourceAnalyzer stats.ResourceAnalyzer
-	runtime          kubecontainer.Runtime
+	auth                       AuthInterface
+	host                       HostInterface
+	restfulCont                containerInterface
+	resourceAnalyzer           stats.ResourceAnalyzer
+	redirectContainerStreaming bool
 }
 
 type TLSOptions struct {
@@ -123,11 +123,11 @@ func ListenAndServeKubeletServer(
 	tlsOptions *TLSOptions,
 	auth AuthInterface,
 	enableDebuggingHandlers,
-	enableContentionProfiling bool,
-	runtime kubecontainer.Runtime,
+	enableContentionProfiling,
+	redirectContainerStreaming bool,
 	criHandler http.Handler) {
 	glog.Infof("Starting to listen on %s:%d", address, port)
-	handler := NewServer(host, resourceAnalyzer, auth, enableDebuggingHandlers, enableContentionProfiling, runtime, criHandler)
+	handler := NewServer(host, resourceAnalyzer, auth, enableDebuggingHandlers, enableContentionProfiling, redirectContainerStreaming, criHandler)
 	s := &http.Server{
 		Addr:           net.JoinHostPort(address.String(), strconv.FormatUint(uint64(port), 10)),
 		Handler:        &handler,
@@ -145,9 +145,9 @@ func ListenAndServeKubeletServer(
 }
 
 // ListenAndServeKubeletReadOnlyServer initializes a server to respond to HTTP network requests on the Kubelet.
-func ListenAndServeKubeletReadOnlyServer(host HostInterface, resourceAnalyzer stats.ResourceAnalyzer, address net.IP, port uint, runtime kubecontainer.Runtime) {
+func ListenAndServeKubeletReadOnlyServer(host HostInterface, resourceAnalyzer stats.ResourceAnalyzer, address net.IP, port uint) {
 	glog.V(1).Infof("Starting to listen read-only on %s:%d", address, port)
-	s := NewServer(host, resourceAnalyzer, nil, false, false, runtime, nil)
+	s := NewServer(host, resourceAnalyzer, nil, false, false, false, nil)
 
 	server := &http.Server{
 		Addr:           net.JoinHostPort(address.String(), strconv.FormatUint(uint64(port), 10)),
@@ -172,12 +172,8 @@ type HostInterface interface {
 	GetCachedMachineInfo() (*cadvisorapi.MachineInfo, error)
 	GetRunningPods() ([]*v1.Pod, error)
 	RunInContainer(name string, uid types.UID, container string, cmd []string) ([]byte, error)
-	ExecInContainer(name string, uid types.UID, container string, cmd []string, in io.Reader, out, err io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize, timeout time.Duration) error
-	AttachContainer(name string, uid types.UID, container string, in io.Reader, out, err io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize) error
 	GetKubeletContainerLogs(podFullName, containerName string, logOptions *v1.PodLogOptions, stdout, stderr io.Writer) error
 	ServeLogs(w http.ResponseWriter, req *http.Request)
-	PortForward(name string, uid types.UID, port int32, stream io.ReadWriteCloser) error
-	StreamingConnectionIdleTimeout() time.Duration
 	ResyncInterval() time.Duration
 	GetHostname() string
 	LatestLoopEntryTime() time.Time
@@ -192,15 +188,15 @@ func NewServer(
 	resourceAnalyzer stats.ResourceAnalyzer,
 	auth AuthInterface,
 	enableDebuggingHandlers,
-	enableContentionProfiling bool,
-	runtime kubecontainer.Runtime,
+	enableContentionProfiling,
+	redirectContainerStreaming bool,
 	criHandler http.Handler) Server {
 	server := Server{
-		host:             host,
-		resourceAnalyzer: resourceAnalyzer,
-		auth:             auth,
-		restfulCont:      &filteringContainer{Container: restful.NewContainer()},
-		runtime:          runtime,
+		host:                       host,
+		resourceAnalyzer:           resourceAnalyzer,
+		auth:                       auth,
+		restfulCont:                &filteringContainer{Container: restful.NewContainer()},
+		redirectContainerStreaming: redirectContainerStreaming,
 	}
 	if auth != nil {
 		server.InstallAuthFilter()
@@ -276,11 +272,18 @@ func (s *Server) InstallDefaultHandlers() {
 
 	// cAdvisor metrics are exposed under the secured handler as well
 	r := prometheus.NewRegistry()
-	r.MustRegister(metrics.NewPrometheusCollector(prometheusHostAdapter{s.host}, containerPrometheusLabels))
+	r.MustRegister(metrics.NewPrometheusCollector(prometheusHostAdapter{s.host}, containerPrometheusLabelsFunc(s.host)))
 	s.restfulCont.Handle(cadvisorMetricsPath,
 		promhttp.HandlerFor(r, promhttp.HandlerOpts{ErrorHandling: promhttp.ContinueOnError}),
 	)
 
+	// prober metrics are exposed under a different endpoint
+	p := prometheus.NewRegistry()
+	p.MustRegister(prober.ProberResults)
+	s.restfulCont.Handle(proberMetricsPath,
+		promhttp.HandlerFor(p, promhttp.HandlerOpts{ErrorHandling: promhttp.ContinueOnError}),
+	)
+
 	ws = new(restful.WebService)
 	ws.
 		Path(specPath).
@@ -523,17 +526,9 @@ func (s *Server) getContainerLogs(request *restful.Request, response *restful.Re
 		return
 	}
 	fw := flushwriter.Wrap(response.ResponseWriter)
-	// Byte limit logic is already implemented in kuberuntime. However, we still need this for
-	// old runtime integration.
-	// TODO(random-liu): Remove this once we switch to CRI integration.
-	if logOptions.LimitBytes != nil {
-		fw = limitwriter.New(fw, *logOptions.LimitBytes)
-	}
 	response.Header().Set("Transfer-Encoding", "chunked")
 	if err := s.host.GetKubeletContainerLogs(kubecontainer.GetPodFullName(pod), containerName, logOptions, fw, fw); err != nil {
-		if err != limitwriter.ErrMaximumWrite {
-			response.WriteError(http.StatusBadRequest, err)
-		}
+		response.WriteError(http.StatusBadRequest, err)
 		return
 	}
 }
@@ -627,6 +622,22 @@ func getPortForwardRequestParams(req *restful.Request) portForwardRequestParams
 	}
 }
 
+type responder struct {
+	errorMessage string
+}
+
+func (r *responder) Error(w http.ResponseWriter, req *http.Request, err error) {
+	glog.Errorf("Error while proxying request: %v", err)
+	http.Error(w, err.Error(), http.StatusInternalServerError)
+}
+
+// proxyStream proxies stream to url.
+func proxyStream(w http.ResponseWriter, r *http.Request, url *url.URL) {
+	// TODO(random-liu): Set MaxBytesPerSec to throttle the stream.
+	handler := proxy.NewUpgradeAwareHandler(url, nil /*transport*/, false /*wrapTransport*/, true /*upgradeRequired*/, &responder{})
+	handler.ServeHTTP(w, r)
+}
+
 // getAttach handles requests to attach to a container.
 func (s *Server) getAttach(request *restful.Request, response *restful.Response) {
 	params := getExecRequestParams(request)
@@ -643,26 +654,17 @@ func (s *Server) getAttach(request *restful.Request, response *restful.Response)
 	}
 
 	podFullName := kubecontainer.GetPodFullName(pod)
-	redirect, err := s.host.GetAttach(podFullName, params.podUID, params.containerName, *streamOpts)
+	url, err := s.host.GetAttach(podFullName, params.podUID, params.containerName, *streamOpts)
 	if err != nil {
 		streaming.WriteError(err, response.ResponseWriter)
 		return
 	}
-	if redirect != nil {
-		http.Redirect(response.ResponseWriter, request.Request, redirect.String(), http.StatusFound)
+
+	if s.redirectContainerStreaming {
+		http.Redirect(response.ResponseWriter, request.Request, url.String(), http.StatusFound)
 		return
 	}
-
-	remotecommandserver.ServeAttach(response.ResponseWriter,
-		request.Request,
-		s.host,
-		podFullName,
-		params.podUID,
-		params.containerName,
-		streamOpts,
-		s.host.StreamingConnectionIdleTimeout(),
-		remotecommandconsts.DefaultStreamCreationTimeout,
-		remotecommandconsts.SupportedStreamingProtocols)
+	proxyStream(response.ResponseWriter, request.Request, url)
 }
 
 // getExec handles requests to run a command inside a container.
@@ -681,27 +683,16 @@ func (s *Server) getExec(request *restful.Request, response *restful.Response) {
 	}
 
 	podFullName := kubecontainer.GetPodFullName(pod)
-	redirect, err := s.host.GetExec(podFullName, params.podUID, params.containerName, params.cmd, *streamOpts)
+	url, err := s.host.GetExec(podFullName, params.podUID, params.containerName, params.cmd, *streamOpts)
 	if err != nil {
 		streaming.WriteError(err, response.ResponseWriter)
 		return
 	}
-	if redirect != nil {
-		http.Redirect(response.ResponseWriter, request.Request, redirect.String(), http.StatusFound)
+	if s.redirectContainerStreaming {
+		http.Redirect(response.ResponseWriter, request.Request, url.String(), http.StatusFound)
 		return
 	}
-
-	remotecommandserver.ServeExec(response.ResponseWriter,
-		request.Request,
-		s.host,
-		podFullName,
-		params.podUID,
-		params.containerName,
-		params.cmd,
-		streamOpts,
-		s.host.StreamingConnectionIdleTimeout(),
-		remotecommandconsts.DefaultStreamCreationTimeout,
-		remotecommandconsts.SupportedStreamingProtocols)
+	proxyStream(response.ResponseWriter, request.Request, url)
 }
 
 // getRun handles requests to run a command inside a container.
@@ -758,25 +749,16 @@ func (s *Server) getPortForward(request *restful.Request, response *restful.Resp
 		return
 	}
 
-	redirect, err := s.host.GetPortForward(pod.Name, pod.Namespace, pod.UID, *portForwardOptions)
+	url, err := s.host.GetPortForward(pod.Name, pod.Namespace, pod.UID, *portForwardOptions)
 	if err != nil {
 		streaming.WriteError(err, response.ResponseWriter)
 		return
 	}
-	if redirect != nil {
-		http.Redirect(response.ResponseWriter, request.Request, redirect.String(), http.StatusFound)
+	if s.redirectContainerStreaming {
+		http.Redirect(response.ResponseWriter, request.Request, url.String(), http.StatusFound)
 		return
 	}
-
-	portforward.ServePortForward(response.ResponseWriter,
-		request.Request,
-		s.host,
-		kubecontainer.GetPodFullName(pod),
-		params.podUID,
-		portForwardOptions,
-		s.host.StreamingConnectionIdleTimeout(),
-		remotecommandconsts.DefaultStreamCreationTimeout,
-		portforward.SupportedProtocols)
+	proxyStream(response.ResponseWriter, request.Request, url)
 }
 
 // ServeHTTP responds to HTTP requests on the Kubelet.
@@ -816,31 +798,40 @@ func (a prometheusHostAdapter) GetMachineInfo() (*cadvisorapi.MachineInfo, error
 	return a.host.GetCachedMachineInfo()
 }
 
-// containerPrometheusLabels maps cAdvisor labels to prometheus labels.
-func containerPrometheusLabels(c *cadvisorapi.ContainerInfo) map[string]string {
-	// Prometheus requires that all metrics in the same family have the same labels,
-	// so we arrange to supply blank strings for missing labels
-	var name, image, podName, namespace, containerName string
-	if len(c.Aliases) > 0 {
-		name = c.Aliases[0]
+func containerPrometheusLabelsFunc(s stats.StatsProvider) metrics.ContainerLabelsFunc {
+	// containerPrometheusLabels maps cAdvisor labels to prometheus labels.
+	return func(c *cadvisorapi.ContainerInfo) map[string]string {
+		// Prometheus requires that all metrics in the same family have the same labels,
+		// so we arrange to supply blank strings for missing labels
+		var name, image, podName, namespace, containerName string
+		if len(c.Aliases) > 0 {
+			name = c.Aliases[0]
+		}
+		image = c.Spec.Image
+		if v, ok := c.Spec.Labels[kubelettypes.KubernetesPodNameLabel]; ok {
+			podName = v
+		}
+		if v, ok := c.Spec.Labels[kubelettypes.KubernetesPodNamespaceLabel]; ok {
+			namespace = v
+		}
+		if v, ok := c.Spec.Labels[kubelettypes.KubernetesContainerNameLabel]; ok {
+			containerName = v
+		}
+		// Associate pod cgroup with pod so we have an accurate accounting of sandbox
+		if podName == "" && namespace == "" {
+			if pod, found := s.GetPodByCgroupfs(c.Name); found {
+				podName = pod.Name
+				namespace = pod.Namespace
+			}
+		}
+		set := map[string]string{
+			metrics.LabelID:    c.Name,
+			metrics.LabelName:  name,
+			metrics.LabelImage: image,
+			"pod_name":         podName,
+			"namespace":        namespace,
+			"container_name":   containerName,
+		}
+		return set
 	}
-	image = c.Spec.Image
-	if v, ok := c.Spec.Labels[kubelettypes.KubernetesPodNameLabel]; ok {
-		podName = v
-	}
-	if v, ok := c.Spec.Labels[kubelettypes.KubernetesPodNamespaceLabel]; ok {
-		namespace = v
-	}
-	if v, ok := c.Spec.Labels[kubelettypes.KubernetesContainerNameLabel]; ok {
-		containerName = v
-	}
-	set := map[string]string{
-		metrics.LabelID:    c.Name,
-		metrics.LabelName:  name,
-		metrics.LabelImage: image,
-		"pod_name":         podName,
-		"namespace":        namespace,
-		"container_name":   containerName,
-	}
-	return set
 }

vendor/k8s.io/kubernetes/pkg/kubelet/server/server_websocket_test.go

@@ -23,11 +23,13 @@ import (
 	"strconv"
 	"sync"
 	"testing"
-	"time"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"golang.org/x/net/websocket"
 
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/kubernetes/pkg/kubelet/server/portforward"
 )
 
 const (
@@ -36,152 +38,114 @@ const (
 )
 
 func TestServeWSPortForward(t *testing.T) {
-	tests := []struct {
+	tests := map[string]struct {
 		port          string
 		uid           bool
 		clientData    string
 		containerData string
 		shouldError   bool
 	}{
-		{port: "", shouldError: true},
-		{port: "abc", shouldError: true},
-		{port: "-1", shouldError: true},
-		{port: "65536", shouldError: true},
-		{port: "0", shouldError: true},
-		{port: "1", shouldError: false},
-		{port: "8000", shouldError: false},
-		{port: "8000", clientData: "client data", containerData: "container data", shouldError: false},
-		{port: "65535", shouldError: false},
-		{port: "65535", uid: true, shouldError: false},
+		"no port":                       {port: "", shouldError: true},
+		"none number port":              {port: "abc", shouldError: true},
+		"negative port":                 {port: "-1", shouldError: true},
+		"too large port":                {port: "65536", shouldError: true},
+		"0 port":                        {port: "0", shouldError: true},
+		"min port":                      {port: "1", shouldError: false},
+		"normal port":                   {port: "8000", shouldError: false},
+		"normal port with data forward": {port: "8000", clientData: "client data", containerData: "container data", shouldError: false},
+		"max port":                      {port: "65535", shouldError: false},
+		"normal port with uid":          {port: "8000", uid: true, shouldError: false},
 	}
 
 	podNamespace := "other"
 	podName := "foo"
-	expectedPodName := getPodName(podName, podNamespace)
-	expectedUid := "9b01b80f-8fb4-11e4-95ab-4200af06647"
 
-	for i, test := range tests {
-		fw := newServerTest()
-		defer fw.testHTTPServer.Close()
+	for desc, test := range tests {
+		test := test
+		t.Run(desc, func(t *testing.T) {
+			ss, err := newTestStreamingServer(0)
+			require.NoError(t, err)
+			defer ss.testHTTPServer.Close()
+			fw := newServerTestWithDebug(true, false, ss)
+			defer fw.testHTTPServer.Close()
 
-		fw.fakeKubelet.streamingConnectionIdleTimeoutFunc = func() time.Duration {
-			return 0
-		}
+			portForwardFuncDone := make(chan struct{})
 
-		portForwardFuncDone := make(chan struct{})
-
-		fw.fakeKubelet.portForwardFunc = func(name string, uid types.UID, port int32, stream io.ReadWriteCloser) error {
-			defer close(portForwardFuncDone)
-
-			if e, a := expectedPodName, name; e != a {
-				t.Fatalf("%d: pod name: expected '%v', got '%v'", i, e, a)
+			fw.fakeKubelet.getPortForwardCheck = func(name, namespace string, uid types.UID, opts portforward.V4Options) {
+				assert.Equal(t, podName, name, "pod name")
+				assert.Equal(t, podNamespace, namespace, "pod namespace")
+				if test.uid {
+					assert.Equal(t, testUID, string(uid), "uid")
+				}
 			}
 
-			if e, a := expectedUid, uid; test.uid && e != string(a) {
-				t.Fatalf("%d: uid: expected '%v', got '%v'", i, e, a)
+			ss.fakeRuntime.portForwardFunc = func(podSandboxID string, port int32, stream io.ReadWriteCloser) error {
+				defer close(portForwardFuncDone)
+				assert.Equal(t, testPodSandboxID, podSandboxID, "pod sandbox id")
+				// The port should be valid if it reaches here.
+				testPort, err := strconv.ParseInt(test.port, 10, 32)
+				require.NoError(t, err, "parse port")
+				assert.Equal(t, int32(testPort), port, "port")
+
+				if test.clientData != "" {
+					fromClient := make([]byte, 32)
+					n, err := stream.Read(fromClient)
+					assert.NoError(t, err, "reading client data")
+					assert.Equal(t, test.clientData, string(fromClient[0:n]), "client data")
+				}
+
+				if test.containerData != "" {
+					_, err := stream.Write([]byte(test.containerData))
+					assert.NoError(t, err, "writing container data")
+				}
+
+				return nil
 			}
 
-			p, err := strconv.ParseInt(test.port, 10, 32)
-			if err != nil {
-				t.Fatalf("%d: error parsing port string '%s': %v", i, test.port, err)
+			var url string
+			if test.uid {
+				url = fmt.Sprintf("ws://%s/portForward/%s/%s/%s?port=%s", fw.testHTTPServer.Listener.Addr().String(), podNamespace, podName, testUID, test.port)
+			} else {
+				url = fmt.Sprintf("ws://%s/portForward/%s/%s?port=%s", fw.testHTTPServer.Listener.Addr().String(), podNamespace, podName, test.port)
 			}
-			if e, a := int32(p), port; e != a {
-				t.Fatalf("%d: port: expected '%v', got '%v'", i, e, a)
+
+			ws, err := websocket.Dial(url, "", "http://127.0.0.1/")
+			assert.Equal(t, test.shouldError, err != nil, "websocket dial")
+			if test.shouldError {
+				return
 			}
+			defer ws.Close()
+
+			p, err := strconv.ParseUint(test.port, 10, 16)
+			require.NoError(t, err, "parse port")
+			p16 := uint16(p)
+
+			channel, data, err := wsRead(ws)
+			require.NoError(t, err, "read")
+			assert.Equal(t, dataChannel, int(channel), "channel")
+			assert.Len(t, data, binary.Size(p16), "data size")
+			assert.Equal(t, p16, binary.LittleEndian.Uint16(data), "data")
+
+			channel, data, err = wsRead(ws)
+			assert.NoError(t, err, "read")
+			assert.Equal(t, errorChannel, int(channel), "channel")
+			assert.Len(t, data, binary.Size(p16), "data size")
+			assert.Equal(t, p16, binary.LittleEndian.Uint16(data), "data")
 
 			if test.clientData != "" {
-				fromClient := make([]byte, 32)
-				n, err := stream.Read(fromClient)
-				if err != nil {
-					t.Fatalf("%d: error reading client data: %v", i, err)
-				}
-				if e, a := test.clientData, string(fromClient[0:n]); e != a {
-					t.Fatalf("%d: client data: expected to receive '%v', got '%v'", i, e, a)
-				}
+				println("writing the client data")
+				err := wsWrite(ws, dataChannel, []byte(test.clientData))
+				assert.NoError(t, err, "writing client data")
 			}
 
 			if test.containerData != "" {
-				_, err := stream.Write([]byte(test.containerData))
-				if err != nil {
-					t.Fatalf("%d: error writing container data: %v", i, err)
-				}
+				_, data, err = wsRead(ws)
+				assert.NoError(t, err, "reading container data")
+				assert.Equal(t, test.containerData, string(data), "container data")
 			}
 
-			return nil
-		}
-
-		var url string
-		if test.uid {
-			url = fmt.Sprintf("ws://%s/portForward/%s/%s/%s?port=%s", fw.testHTTPServer.Listener.Addr().String(), podNamespace, podName, expectedUid, test.port)
-		} else {
-			url = fmt.Sprintf("ws://%s/portForward/%s/%s?port=%s", fw.testHTTPServer.Listener.Addr().String(), podNamespace, podName, test.port)
-		}
-
-		ws, err := websocket.Dial(url, "", "http://127.0.0.1/")
-		if test.shouldError {
-			if err == nil {
-				t.Fatalf("%d: websocket dial expected err", i)
-			}
-			continue
-		} else if err != nil {
-			t.Fatalf("%d: websocket dial unexpected err: %v", i, err)
-		}
-
-		defer ws.Close()
-
-		p, err := strconv.ParseUint(test.port, 10, 16)
-		if err != nil {
-			t.Fatalf("%d: error parsing port string '%s': %v", i, test.port, err)
-		}
-		p16 := uint16(p)
-
-		channel, data, err := wsRead(ws)
-		if err != nil {
-			t.Fatalf("%d: read failed: expected no error: got %v", i, err)
-		}
-		if channel != dataChannel {
-			t.Fatalf("%d: wrong channel: got %q: expected %q", i, channel, dataChannel)
-		}
-		if len(data) != binary.Size(p16) {
-			t.Fatalf("%d: wrong data size: got %q: expected %d", i, data, binary.Size(p16))
-		}
-		if e, a := p16, binary.LittleEndian.Uint16(data); e != a {
-			t.Fatalf("%d: wrong data: got %q: expected %s", i, data, test.port)
-		}
-
-		channel, data, err = wsRead(ws)
-		if err != nil {
-			t.Fatalf("%d: read succeeded: expected no error: got %v", i, err)
-		}
-		if channel != errorChannel {
-			t.Fatalf("%d: wrong channel: got %q: expected %q", i, channel, errorChannel)
-		}
-		if len(data) != binary.Size(p16) {
-			t.Fatalf("%d: wrong data size: got %q: expected %d", i, data, binary.Size(p16))
-		}
-		if e, a := p16, binary.LittleEndian.Uint16(data); e != a {
-			t.Fatalf("%d: wrong data: got %q: expected %s", i, data, test.port)
-		}
-
-		if test.clientData != "" {
-			println("writing the client data")
-			err := wsWrite(ws, dataChannel, []byte(test.clientData))
-			if err != nil {
-				t.Fatalf("%d: unexpected error writing client data: %v", i, err)
-			}
-		}
-
-		if test.containerData != "" {
-			_, data, err = wsRead(ws)
-			if err != nil {
-				t.Fatalf("%d: unexpected error reading container data: %v", i, err)
-			}
-			if e, a := test.containerData, string(data); e != a {
-				t.Fatalf("%d: expected to receive '%v' from container, got '%v'", i, e, a)
-			}
-		}
-
-		<-portForwardFuncDone
+			<-portForwardFuncDone
+		})
 	}
 }
 
@@ -190,27 +154,27 @@ func TestServeWSMultiplePortForward(t *testing.T) {
 	ports := []uint16{7000, 8000, 9000}
 	podNamespace := "other"
 	podName := "foo"
-	expectedPodName := getPodName(podName, podNamespace)
 
-	fw := newServerTest()
+	ss, err := newTestStreamingServer(0)
+	require.NoError(t, err)
+	defer ss.testHTTPServer.Close()
+	fw := newServerTestWithDebug(true, false, ss)
 	defer fw.testHTTPServer.Close()
 
-	fw.fakeKubelet.streamingConnectionIdleTimeoutFunc = func() time.Duration {
-		return 0
-	}
-
 	portForwardWG := sync.WaitGroup{}
 	portForwardWG.Add(len(ports))
 
 	portsMutex := sync.Mutex{}
 	portsForwarded := map[int32]struct{}{}
 
-	fw.fakeKubelet.portForwardFunc = func(name string, uid types.UID, port int32, stream io.ReadWriteCloser) error {
-		defer portForwardWG.Done()
+	fw.fakeKubelet.getPortForwardCheck = func(name, namespace string, uid types.UID, opts portforward.V4Options) {
+		assert.Equal(t, podName, name, "pod name")
+		assert.Equal(t, podNamespace, namespace, "pod namespace")
+	}
 
-		if e, a := expectedPodName, name; e != a {
-			t.Fatalf("%d: pod name: expected '%v', got '%v'", port, e, a)
-		}
+	ss.fakeRuntime.portForwardFunc = func(podSandboxID string, port int32, stream io.ReadWriteCloser) error {
+		defer portForwardWG.Done()
+		assert.Equal(t, testPodSandboxID, podSandboxID, "pod sandbox id")
 
 		portsMutex.Lock()
 		portsForwarded[port] = struct{}{}
@@ -218,17 +182,11 @@ func TestServeWSMultiplePortForward(t *testing.T) {
 
 		fromClient := make([]byte, 32)
 		n, err := stream.Read(fromClient)
-		if err != nil {
-			t.Fatalf("%d: error reading client data: %v", port, err)
-		}
-		if e, a := fmt.Sprintf("client data on port %d", port), string(fromClient[0:n]); e != a {
-			t.Fatalf("%d: client data: expected to receive '%v', got '%v'", port, e, a)
-		}
+		assert.NoError(t, err, "reading client data")
+		assert.Equal(t, fmt.Sprintf("client data on port %d", port), string(fromClient[0:n]), "client data")
 
 		_, err = stream.Write([]byte(fmt.Sprintf("container data on port %d", port)))
-		if err != nil {
-			t.Fatalf("%d: error writing container data: %v", port, err)
-		}
+		assert.NoError(t, err, "writing container data")
 
 		return nil
 	}
@@ -239,70 +197,42 @@ func TestServeWSMultiplePortForward(t *testing.T) {
 	}
 
 	ws, err := websocket.Dial(url, "", "http://127.0.0.1/")
-	if err != nil {
-		t.Fatalf("websocket dial unexpected err: %v", err)
-	}
+	require.NoError(t, err, "websocket dial")
 
 	defer ws.Close()
 
 	for i, port := range ports {
 		channel, data, err := wsRead(ws)
-		if err != nil {
-			t.Fatalf("%d: read failed: expected no error: got %v", i, err)
-		}
-		if int(channel) != i*2+dataChannel {
-			t.Fatalf("%d: wrong channel: got %q: expected %q", i, channel, i*2+dataChannel)
-		}
-		if len(data) != binary.Size(port) {
-			t.Fatalf("%d: wrong data size: got %q: expected %d", i, data, binary.Size(port))
-		}
-		if e, a := port, binary.LittleEndian.Uint16(data); e != a {
-			t.Fatalf("%d: wrong data: got %q: expected %d", i, data, port)
-		}
+		assert.NoError(t, err, "port %d read", port)
+		assert.Equal(t, i*2+dataChannel, int(channel), "port %d channel", port)
+		assert.Len(t, data, binary.Size(port), "port %d data size", port)
+		assert.Equal(t, binary.LittleEndian.Uint16(data), port, "port %d data", port)
 
 		channel, data, err = wsRead(ws)
-		if err != nil {
-			t.Fatalf("%d: read succeeded: expected no error: got %v", i, err)
-		}
-		if int(channel) != i*2+errorChannel {
-			t.Fatalf("%d: wrong channel: got %q: expected %q", i, channel, i*2+errorChannel)
-		}
-		if len(data) != binary.Size(port) {
-			t.Fatalf("%d: wrong data size: got %q: expected %d", i, data, binary.Size(port))
-		}
-		if e, a := port, binary.LittleEndian.Uint16(data); e != a {
-			t.Fatalf("%d: wrong data: got %q: expected %d", i, data, port)
-		}
+		assert.NoError(t, err, "port %d read", port)
+		assert.Equal(t, i*2+errorChannel, int(channel), "port %d channel", port)
+		assert.Len(t, data, binary.Size(port), "port %d data size", port)
+		assert.Equal(t, binary.LittleEndian.Uint16(data), port, "port %d data", port)
 	}
 
 	for i, port := range ports {
-		println("writing the client data", port)
+		t.Logf("port %d writing the client data", port)
 		err := wsWrite(ws, byte(i*2+dataChannel), []byte(fmt.Sprintf("client data on port %d", port)))
-		if err != nil {
-			t.Fatalf("%d: unexpected error writing client data: %v", i, err)
-		}
+		assert.NoError(t, err, "port %d write client data", port)
 
 		channel, data, err := wsRead(ws)
-		if err != nil {
-			t.Fatalf("%d: unexpected error reading container data: %v", i, err)
-		}
-
-		if int(channel) != i*2+dataChannel {
-			t.Fatalf("%d: wrong channel: got %q: expected %q", port, channel, i*2+dataChannel)
-		}
-		if e, a := fmt.Sprintf("container data on port %d", port), string(data); e != a {
-			t.Fatalf("%d: expected to receive '%v' from container, got '%v'", i, e, a)
-		}
+		assert.NoError(t, err, "port %d read container data", port)
+		assert.Equal(t, i*2+dataChannel, int(channel), "port %d channel", port)
+		assert.Equal(t, fmt.Sprintf("container data on port %d", port), string(data), "port %d container data", port)
 	}
 
 	portForwardWG.Wait()
 
 	portsMutex.Lock()
 	defer portsMutex.Unlock()
-	if len(ports) != len(portsForwarded) {
-		t.Fatalf("expected to forward %d ports; got %v", len(ports), portsForwarded)
-	}
+	assert.Len(t, portsForwarded, len(ports), "all ports forwarded")
 }
+
 func wsWrite(conn *websocket.Conn, channel byte, data []byte) error {
 	frame := make([]byte, len(data)+1)
 	frame[0] = channel

vendor/k8s.io/kubernetes/pkg/kubelet/server/stats/handler.go

@@ -84,6 +84,10 @@ type StatsProvider interface {
 
 	// GetPodCgroupRoot returns the literal cgroupfs value for the cgroup containing all pods
 	GetPodCgroupRoot() string
+
+	// GetPodByCgroupfs provides the pod that maps to the specified cgroup literal, as well
+	// as whether the pod was found.
+	GetPodByCgroupfs(cgroupfs string) (*v1.Pod, bool)
 }
 
 type handler struct {

vendor/k8s.io/kubernetes/pkg/kubelet/server/stats/testing/mock_stats_provider.go

@@ -25,7 +25,6 @@ import v1 "github.com/google/cadvisor/info/v1"
 import v1alpha1 "k8s.io/kubernetes/pkg/kubelet/apis/stats/v1alpha1"
 import volume "k8s.io/kubernetes/pkg/volume"
 
-// DO NOT EDIT
 // GENERATED BY mockery
 
 // StatsProvider is an autogenerated mock type for the StatsProvider type
@@ -65,6 +64,12 @@ func (_m *StatsProvider) GetCgroupStats(cgroupName string, updateStats bool) (*v
 	return r0, r1, r2
 }
 
+// GetPodByCgroupfs provides the pod that maps to the specified cgroup, as well
+// as whether the pod was found.
+func (_m *StatsProvider) GetPodByCgroupfs(cgroupfs string) (*corev1.Pod, bool) {
+	return nil, false
+}
+
 // GetContainerInfo provides a mock function with given fields: podFullName, uid, containerName, req
 func (_m *StatsProvider) GetContainerInfo(podFullName string, uid types.UID, containerName string, req *v1.ContainerInfoRequest) (*v1.ContainerInfo, error) {
 	ret := _m.Called(podFullName, uid, containerName, req)

vendor/k8s.io/kubernetes/pkg/kubelet/server/streaming/BUILD

@@ -21,6 +21,7 @@ go_library(
         "//vendor/github.com/emicklei/go-restful:go_default_library",
         "//vendor/google.golang.org/grpc:go_default_library",
         "//vendor/google.golang.org/grpc/codes:go_default_library",
+        "//vendor/google.golang.org/grpc/status:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/clock:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/remotecommand:go_default_library",

vendor/k8s.io/kubernetes/pkg/kubelet/server/streaming/errors.go

@@ -23,15 +23,16 @@ import (
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
 func ErrorStreamingDisabled(method string) error {
-	return grpc.Errorf(codes.NotFound, fmt.Sprintf("streaming method %s disabled", method))
+	return status.Errorf(codes.NotFound, fmt.Sprintf("streaming method %s disabled", method))
 }
 
 // The error returned when the maximum number of in-flight requests is exceeded.
 func ErrorTooManyInFlight() error {
-	return grpc.Errorf(codes.ResourceExhausted, "maximum number of in-flight requests exceeded")
+	return status.Errorf(codes.ResourceExhausted, "maximum number of in-flight requests exceeded")
 }
 
 // Translates a CRI streaming error into an appropriate HTTP response.

vendor/k8s.io/kubernetes/pkg/kubelet/server/streaming/server.go

@@ -20,13 +20,14 @@ import (
 	"crypto/tls"
 	"errors"
 	"io"
+	"net"
 	"net/http"
 	"net/url"
 	"path"
 	"time"
 
-	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 
 	restful "github.com/emicklei/go-restful"
 
@@ -71,6 +72,7 @@ type Config struct {
 	Addr string
 	// The optional base URL for constructing streaming URLs. If empty, the baseURL will be
 	// constructed from the serve address.
+	// Note that for port "0", the URL port will be set to actual port in use.
 	BaseURL *url.URL
 
 	// How long to leave idle connections open for.
@@ -160,15 +162,15 @@ type server struct {
 
 func validateExecRequest(req *runtimeapi.ExecRequest) error {
 	if req.ContainerId == "" {
-		return grpc.Errorf(codes.InvalidArgument, "missing required container_id")
+		return status.Errorf(codes.InvalidArgument, "missing required container_id")
 	}
 	if req.Tty && req.Stderr {
 		// If TTY is set, stderr cannot be true because multiplexing is not
 		// supported.
-		return grpc.Errorf(codes.InvalidArgument, "tty and stderr cannot both be true")
+		return status.Errorf(codes.InvalidArgument, "tty and stderr cannot both be true")
 	}
 	if !req.Stdin && !req.Stdout && !req.Stderr {
-		return grpc.Errorf(codes.InvalidArgument, "one of stdin, stdout, or stderr must be set")
+		return status.Errorf(codes.InvalidArgument, "one of stdin, stdout, or stderr must be set")
 	}
 	return nil
 }
@@ -188,15 +190,15 @@ func (s *server) GetExec(req *runtimeapi.ExecRequest) (*runtimeapi.ExecResponse,
 
 func validateAttachRequest(req *runtimeapi.AttachRequest) error {
 	if req.ContainerId == "" {
-		return grpc.Errorf(codes.InvalidArgument, "missing required container_id")
+		return status.Errorf(codes.InvalidArgument, "missing required container_id")
 	}
 	if req.Tty && req.Stderr {
 		// If TTY is set, stderr cannot be true because multiplexing is not
 		// supported.
-		return grpc.Errorf(codes.InvalidArgument, "tty and stderr cannot both be true")
+		return status.Errorf(codes.InvalidArgument, "tty and stderr cannot both be true")
 	}
 	if !req.Stdin && !req.Stdout && !req.Stderr {
-		return grpc.Errorf(codes.InvalidArgument, "one of stdin, stdout, and stderr must be set")
+		return status.Errorf(codes.InvalidArgument, "one of stdin, stdout, and stderr must be set")
 	}
 	return nil
 }
@@ -216,7 +218,7 @@ func (s *server) GetAttach(req *runtimeapi.AttachRequest) (*runtimeapi.AttachRes
 
 func (s *server) GetPortForward(req *runtimeapi.PortForwardRequest) (*runtimeapi.PortForwardResponse, error) {
 	if req.PodSandboxId == "" {
-		return nil, grpc.Errorf(codes.InvalidArgument, "missing required pod_sandbox_id")
+		return nil, status.Errorf(codes.InvalidArgument, "missing required pod_sandbox_id")
 	}
 	token, err := s.cache.Insert(req)
 	if err != nil {
@@ -233,10 +235,16 @@ func (s *server) Start(stayUp bool) error {
 		return errors.New("stayUp=false is not yet implemented")
 	}
 
+	listener, err := net.Listen("tcp", s.config.Addr)
+	if err != nil {
+		return err
+	}
+	// Use the actual address as baseURL host. This handles the "0" port case.
+	s.config.BaseURL.Host = listener.Addr().String()
 	if s.config.TLSConfig != nil {
-		return s.server.ListenAndServeTLS("", "") // Use certs from TLSConfig.
+		return s.server.ServeTLS(listener, "", "") // Use certs from TLSConfig.
 	} else {
-		return s.server.ListenAndServe()
+		return s.server.Serve(listener)
 	}
 }