vendor: remove dep and use vndr

Signed-off-by: Antonio Murdaca <runcom@redhat.com>

vendor/k8s.io/kubernetes/pkg/client/unversioned/BUILD

@@ -1,68 +0,0 @@
-package(default_visibility = ["//visibility:public"])
-
-licenses(["notice"])
-
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-    "go_test",
-)
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "conditions.go",
-        "helper.go",
-    ],
-    tags = ["automanaged"],
-    deps = [
-        "//pkg/api:go_default_library",
-        "//pkg/apis/apps:go_default_library",
-        "//pkg/apis/batch:go_default_library",
-        "//pkg/apis/extensions:go_default_library",
-        "//pkg/client/clientset_generated/internalclientset/typed/apps/internalversion:go_default_library",
-        "//pkg/client/clientset_generated/internalclientset/typed/batch/internalversion:go_default_library",
-        "//pkg/client/clientset_generated/internalclientset/typed/core/internalversion:go_default_library",
-        "//pkg/client/clientset_generated/internalclientset/typed/extensions/internalversion:go_default_library",
-        "//vendor:k8s.io/apimachinery/pkg/api/errors",
-        "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
-        "//vendor:k8s.io/apimachinery/pkg/runtime/schema",
-        "//vendor:k8s.io/apimachinery/pkg/util/wait",
-        "//vendor:k8s.io/apimachinery/pkg/watch",
-        "//vendor:k8s.io/client-go/plugin/pkg/client/auth",
-        "//vendor:k8s.io/client-go/rest",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["helper_test.go"],
-    library = ":go_default_library",
-    tags = ["automanaged"],
-    deps = [
-        "//pkg/api:go_default_library",
-        "//pkg/api/testapi:go_default_library",
-        "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
-        "//vendor:k8s.io/apimachinery/pkg/runtime",
-        "//vendor:k8s.io/apimachinery/pkg/runtime/schema",
-        "//vendor:k8s.io/client-go/rest",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [
-        ":package-srcs",
-        "//pkg/client/unversioned/portforward:all-srcs",
-        "//pkg/client/unversioned/remotecommand:all-srcs",
-        "//pkg/client/unversioned/testclient/simple:all-srcs",
-    ],
-    tags = ["automanaged"],
-)

vendor/k8s.io/kubernetes/pkg/client/unversioned/OWNERS

@@ -1,40 +0,0 @@
-reviewers:
-- thockin
-- lavalamp
-- smarterclayton
-- wojtek-t
-- deads2k
-- derekwaynecarr
-- caesarxuchao
-- vishh
-- mikedanese
-- liggitt
-- nikhiljindal
-- bprashanth
-- ixdy
-- gmarek
-- erictune
-- davidopp
-- pmorie
-- sttts
-- kargakis
-- saad-ali
-- zmerlynn
-- janetkuo
-- ncdc
-- timstclair
-- mwielgus
-- timothysc
-- feiskyer
-- jlowdermilk
-- soltysh
-- piosz
-- dims
-- errordeveloper
-- madhusudancs
-- hongchaodeng
-- krousey
-- jayunit100
-- jszczepkowski
-- jdef
-- mml

vendor/k8s.io/kubernetes/pkg/client/unversioned/conditions.go

@@ -1,273 +0,0 @@
-/*
-Copyright 2014 The Kubernetes 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 unversioned
-
-import (
-	"fmt"
-
-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/wait"
-	"k8s.io/apimachinery/pkg/watch"
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/apis/apps"
-	"k8s.io/kubernetes/pkg/apis/batch"
-	"k8s.io/kubernetes/pkg/apis/extensions"
-	appsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/apps/internalversion"
-	batchclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/internalversion"
-	coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"
-	extensionsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/internalversion"
-)
-
-// ControllerHasDesiredReplicas returns a condition that will be true if and only if
-// the desired replica count for a controller's ReplicaSelector equals the Replicas count.
-func ControllerHasDesiredReplicas(rcClient coreclient.ReplicationControllersGetter, controller *api.ReplicationController) wait.ConditionFunc {
-
-	// If we're given a controller where the status lags the spec, it either means that the controller is stale,
-	// or that the rc manager hasn't noticed the update yet. Polling status.Replicas is not safe in the latter case.
-	desiredGeneration := controller.Generation
-
-	return func() (bool, error) {
-		ctrl, err := rcClient.ReplicationControllers(controller.Namespace).Get(controller.Name, metav1.GetOptions{})
-		if err != nil {
-			return false, err
-		}
-		// There's a chance a concurrent update modifies the Spec.Replicas causing this check to pass,
-		// or, after this check has passed, a modification causes the rc manager to create more pods.
-		// This will not be an issue once we've implemented graceful delete for rcs, but till then
-		// concurrent stop operations on the same rc might have unintended side effects.
-		return ctrl.Status.ObservedGeneration >= desiredGeneration && ctrl.Status.Replicas == ctrl.Spec.Replicas, nil
-	}
-}
-
-// ReplicaSetHasDesiredReplicas returns a condition that will be true if and only if
-// the desired replica count for a ReplicaSet's ReplicaSelector equals the Replicas count.
-func ReplicaSetHasDesiredReplicas(rsClient extensionsclient.ReplicaSetsGetter, replicaSet *extensions.ReplicaSet) wait.ConditionFunc {
-
-	// If we're given a ReplicaSet where the status lags the spec, it either means that the
-	// ReplicaSet is stale, or that the ReplicaSet manager hasn't noticed the update yet.
-	// Polling status.Replicas is not safe in the latter case.
-	desiredGeneration := replicaSet.Generation
-
-	return func() (bool, error) {
-		rs, err := rsClient.ReplicaSets(replicaSet.Namespace).Get(replicaSet.Name, metav1.GetOptions{})
-		if err != nil {
-			return false, err
-		}
-		// There's a chance a concurrent update modifies the Spec.Replicas causing this check to
-		// pass, or, after this check has passed, a modification causes the ReplicaSet manager to
-		// create more pods. This will not be an issue once we've implemented graceful delete for
-		// ReplicaSets, but till then concurrent stop operations on the same ReplicaSet might have
-		// unintended side effects.
-		return rs.Status.ObservedGeneration >= desiredGeneration && rs.Status.Replicas == rs.Spec.Replicas, nil
-	}
-}
-
-// StatefulSetHasDesiredPets returns a conditon that checks the number of petset replicas
-func StatefulSetHasDesiredPets(psClient appsclient.StatefulSetsGetter, petset *apps.StatefulSet) wait.ConditionFunc {
-	// TODO: Differentiate between 0 pets and a really quick scale down using generation.
-	return func() (bool, error) {
-		ps, err := psClient.StatefulSets(petset.Namespace).Get(petset.Name, metav1.GetOptions{})
-		if err != nil {
-			return false, err
-		}
-		return ps.Status.Replicas == ps.Spec.Replicas, nil
-	}
-}
-
-// JobHasDesiredParallelism returns a condition that will be true if the desired parallelism count
-// for a job equals the current active counts or is less by an appropriate successful/unsuccessful count.
-func JobHasDesiredParallelism(jobClient batchclient.JobsGetter, job *batch.Job) wait.ConditionFunc {
-	return func() (bool, error) {
-		job, err := jobClient.Jobs(job.Namespace).Get(job.Name, metav1.GetOptions{})
-		if err != nil {
-			return false, err
-		}
-
-		// desired parallelism can be either the exact number, in which case return immediately
-		if job.Status.Active == *job.Spec.Parallelism {
-			return true, nil
-		}
-		if job.Spec.Completions == nil {
-			// A job without specified completions needs to wait for Active to reach Parallelism.
-			return false, nil
-		}
-
-		// otherwise count successful
-		progress := *job.Spec.Completions - job.Status.Active - job.Status.Succeeded
-		return progress == 0, nil
-	}
-}
-
-// DeploymentHasDesiredReplicas returns a condition that will be true if and only if
-// the desired replica count for a deployment equals its updated replicas count.
-// (non-terminated pods that have the desired template spec).
-func DeploymentHasDesiredReplicas(dClient extensionsclient.DeploymentsGetter, deployment *extensions.Deployment) wait.ConditionFunc {
-	// If we're given a deployment where the status lags the spec, it either
-	// means that the deployment is stale, or that the deployment manager hasn't
-	// noticed the update yet. Polling status.Replicas is not safe in the latter
-	// case.
-	desiredGeneration := deployment.Generation
-
-	return func() (bool, error) {
-		deployment, err := dClient.Deployments(deployment.Namespace).Get(deployment.Name, metav1.GetOptions{})
-		if err != nil {
-			return false, err
-		}
-		return deployment.Status.ObservedGeneration >= desiredGeneration &&
-			deployment.Status.UpdatedReplicas == deployment.Spec.Replicas, nil
-	}
-}
-
-// ErrPodCompleted is returned by PodRunning or PodContainerRunning to indicate that
-// the pod has already reached completed state.
-var ErrPodCompleted = fmt.Errorf("pod ran to completion")
-
-// ErrContainerTerminated is returned by PodContainerRunning in the intermediate
-// state where the pod indicates it's still running, but its container is already terminated
-var ErrContainerTerminated = fmt.Errorf("container terminated")
-
-// PodRunning returns true if the pod is running, false if the pod has not yet reached running state,
-// returns ErrPodCompleted if the pod has run to completion, or an error in any other case.
-func PodRunning(event watch.Event) (bool, error) {
-	switch event.Type {
-	case watch.Deleted:
-		return false, errors.NewNotFound(schema.GroupResource{Resource: "pods"}, "")
-	}
-	switch t := event.Object.(type) {
-	case *api.Pod:
-		switch t.Status.Phase {
-		case api.PodRunning:
-			return true, nil
-		case api.PodFailed, api.PodSucceeded:
-			return false, ErrPodCompleted
-		}
-	}
-	return false, nil
-}
-
-// PodCompleted returns true if the pod has run to completion, false if the pod has not yet
-// reached running state, or an error in any other case.
-func PodCompleted(event watch.Event) (bool, error) {
-	switch event.Type {
-	case watch.Deleted:
-		return false, errors.NewNotFound(schema.GroupResource{Resource: "pods"}, "")
-	}
-	switch t := event.Object.(type) {
-	case *api.Pod:
-		switch t.Status.Phase {
-		case api.PodFailed, api.PodSucceeded:
-			return true, nil
-		}
-	}
-	return false, nil
-}
-
-// PodRunningAndReady returns true if the pod is running and ready, false if the pod has not
-// yet reached those states, returns ErrPodCompleted if the pod has run to completion, or
-// an error in any other case.
-func PodRunningAndReady(event watch.Event) (bool, error) {
-	switch event.Type {
-	case watch.Deleted:
-		return false, errors.NewNotFound(schema.GroupResource{Resource: "pods"}, "")
-	}
-	switch t := event.Object.(type) {
-	case *api.Pod:
-		switch t.Status.Phase {
-		case api.PodFailed, api.PodSucceeded:
-			return false, ErrPodCompleted
-		case api.PodRunning:
-			return api.IsPodReady(t), nil
-		}
-	}
-	return false, nil
-}
-
-// PodNotPending returns true if the pod has left the pending state, false if it has not,
-// or an error in any other case (such as if the pod was deleted).
-func PodNotPending(event watch.Event) (bool, error) {
-	switch event.Type {
-	case watch.Deleted:
-		return false, errors.NewNotFound(schema.GroupResource{Resource: "pods"}, "")
-	}
-	switch t := event.Object.(type) {
-	case *api.Pod:
-		switch t.Status.Phase {
-		case api.PodPending:
-			return false, nil
-		default:
-			return true, nil
-		}
-	}
-	return false, nil
-}
-
-// PodContainerRunning returns false until the named container has ContainerStatus running (at least once),
-// and will return an error if the pod is deleted, runs to completion, or the container pod is not available.
-func PodContainerRunning(containerName string) watch.ConditionFunc {
-	return func(event watch.Event) (bool, error) {
-		switch event.Type {
-		case watch.Deleted:
-			return false, errors.NewNotFound(schema.GroupResource{Resource: "pods"}, "")
-		}
-		switch t := event.Object.(type) {
-		case *api.Pod:
-			switch t.Status.Phase {
-			case api.PodRunning, api.PodPending:
-			case api.PodFailed, api.PodSucceeded:
-				return false, ErrPodCompleted
-			default:
-				return false, nil
-			}
-			for _, s := range t.Status.ContainerStatuses {
-				if s.Name != containerName {
-					continue
-				}
-				if s.State.Terminated != nil {
-					return false, ErrContainerTerminated
-				}
-				return s.State.Running != nil, nil
-			}
-			for _, s := range t.Status.InitContainerStatuses {
-				if s.Name != containerName {
-					continue
-				}
-				if s.State.Terminated != nil {
-					return false, ErrContainerTerminated
-				}
-				return s.State.Running != nil, nil
-			}
-			return false, nil
-		}
-		return false, nil
-	}
-}
-
-// ServiceAccountHasSecrets returns true if the service account has at least one secret,
-// false if it does not, or an error.
-func ServiceAccountHasSecrets(event watch.Event) (bool, error) {
-	switch event.Type {
-	case watch.Deleted:
-		return false, errors.NewNotFound(schema.GroupResource{Resource: "serviceaccounts"}, "")
-	}
-	switch t := event.Object.(type) {
-	case *api.ServiceAccount:
-		return len(t.Secrets) > 0, nil
-	}
-	return false, nil
-}

vendor/k8s.io/kubernetes/pkg/client/unversioned/helper.go

@@ -1,69 +0,0 @@
-/*
-Copyright 2014 The Kubernetes 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 unversioned
-
-import (
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/kubernetes/pkg/api"
-	// Import solely to initialize client auth plugins.
-	_ "k8s.io/client-go/plugin/pkg/client/auth"
-)
-
-const (
-	legacyAPIPath  = "/api"
-	defaultAPIPath = "/apis"
-)
-
-// SetKubernetesDefaults sets default values on the provided client config for accessing the
-// Kubernetes API or returns an error if any of the defaults are impossible or invalid.
-// TODO: this method needs to be split into one that sets defaults per group, expected to be fix in PR "Refactoring clientcache.go and helper.go #14592"
-func SetKubernetesDefaults(config *restclient.Config) error {
-	if config.APIPath == "" {
-		config.APIPath = legacyAPIPath
-	}
-	if config.GroupVersion == nil || config.GroupVersion.Group != api.GroupName {
-		g, err := api.Registry.Group(api.GroupName)
-		if err != nil {
-			return err
-		}
-		copyGroupVersion := g.GroupVersion
-		config.GroupVersion = &copyGroupVersion
-	}
-	if config.NegotiatedSerializer == nil {
-		config.NegotiatedSerializer = api.Codecs
-	}
-	return restclient.SetKubernetesDefaults(config)
-}
-
-func setGroupDefaults(groupName string, config *restclient.Config) error {
-	config.APIPath = defaultAPIPath
-	if config.UserAgent == "" {
-		config.UserAgent = restclient.DefaultKubernetesUserAgent()
-	}
-	if config.GroupVersion == nil || config.GroupVersion.Group != groupName {
-		g, err := api.Registry.Group(groupName)
-		if err != nil {
-			return err
-		}
-		copyGroupVersion := g.GroupVersion
-		config.GroupVersion = &copyGroupVersion
-	}
-	if config.NegotiatedSerializer == nil {
-		config.NegotiatedSerializer = api.Codecs
-	}
-	return nil
-}

vendor/k8s.io/kubernetes/pkg/client/unversioned/helper_test.go

@@ -1,182 +0,0 @@
-/*
-Copyright 2014 The Kubernetes 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 unversioned
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"reflect"
-	"testing"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/testapi"
-)
-
-func TestSetKubernetesDefaults(t *testing.T) {
-	testCases := []struct {
-		Config restclient.Config
-		After  restclient.Config
-		Err    bool
-	}{
-		{
-			restclient.Config{},
-			restclient.Config{
-				APIPath: "/api",
-				ContentConfig: restclient.ContentConfig{
-					GroupVersion:         &api.Registry.GroupOrDie(api.GroupName).GroupVersion,
-					NegotiatedSerializer: testapi.Default.NegotiatedSerializer(),
-				},
-			},
-			false,
-		},
-		// Add this test back when we fixed config and SetKubernetesDefaults
-		// {
-		// 	restclient.Config{
-		// 		GroupVersion: &schema.GroupVersion{Group: "not.a.group", Version: "not_an_api"},
-		// 	},
-		// 	restclient.Config{},
-		// 	true,
-		// },
-	}
-	for _, testCase := range testCases {
-		val := &testCase.Config
-		err := SetKubernetesDefaults(val)
-		val.UserAgent = ""
-		switch {
-		case err == nil && testCase.Err:
-			t.Errorf("expected error but was nil")
-			continue
-		case err != nil && !testCase.Err:
-			t.Errorf("unexpected error %v", err)
-			continue
-		case err != nil:
-			continue
-		}
-		if !reflect.DeepEqual(*val, testCase.After) {
-			t.Errorf("unexpected result object: %#v", val)
-		}
-	}
-}
-
-func TestHelperGetServerAPIVersions(t *testing.T) {
-	expect := []string{"v1", "v2", "v3"}
-	APIVersions := metav1.APIVersions{Versions: expect}
-	expect = append(expect, "group1/v1", "group1/v2", "group2/v1", "group2/v2")
-	APIGroupList := metav1.APIGroupList{
-		Groups: []metav1.APIGroup{
-			{
-				Versions: []metav1.GroupVersionForDiscovery{
-					{
-						GroupVersion: "group1/v1",
-					},
-					{
-						GroupVersion: "group1/v2",
-					},
-				},
-			},
-			{
-				Versions: []metav1.GroupVersionForDiscovery{
-					{
-						GroupVersion: "group2/v1",
-					},
-					{
-						GroupVersion: "group2/v2",
-					},
-				},
-			},
-		},
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		var output []byte
-		var err error
-		switch req.URL.Path {
-		case "/api":
-			output, err = json.Marshal(APIVersions)
-
-		case "/apis":
-			output, err = json.Marshal(APIGroupList)
-		}
-		if err != nil {
-			t.Errorf("unexpected encoding error: %v", err)
-			return
-		}
-
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write(output)
-	}))
-	defer server.Close()
-	got, err := restclient.ServerAPIVersions(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "invalid version", Version: "one"}, NegotiatedSerializer: testapi.Default.NegotiatedSerializer()}})
-	if err != nil {
-		t.Fatalf("unexpected encoding error: %v", err)
-	}
-	if e, a := expect, got; !reflect.DeepEqual(e, a) {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-}
-
-func TestSetsCodec(t *testing.T) {
-	testCases := map[string]struct {
-		Err                  bool
-		Prefix               string
-		NegotiatedSerializer runtime.NegotiatedSerializer
-	}{
-		api.Registry.GroupOrDie(api.GroupName).GroupVersion.Version: {
-			Err:                  false,
-			Prefix:               "/api/" + api.Registry.GroupOrDie(api.GroupName).GroupVersion.Version,
-			NegotiatedSerializer: testapi.Default.NegotiatedSerializer(),
-		},
-		// Add this test back when we fixed config and SetKubernetesDefaults
-		// "invalidVersion":                       {true, "", nil},
-	}
-	for version, expected := range testCases {
-		conf := &restclient.Config{
-			Host: "127.0.0.1",
-			ContentConfig: restclient.ContentConfig{
-				GroupVersion: &schema.GroupVersion{Version: version},
-			},
-		}
-
-		var versionedPath string
-		err := SetKubernetesDefaults(conf)
-		if err == nil {
-			_, versionedPath, err = restclient.DefaultServerURL(conf.Host, conf.APIPath, *conf.GroupVersion, false)
-		}
-
-		switch {
-		case err == nil && expected.Err:
-			t.Errorf("expected error but was nil")
-			continue
-		case err != nil && !expected.Err:
-			t.Errorf("unexpected error %v", err)
-			continue
-		case err != nil:
-			continue
-		}
-		if e, a := expected.Prefix, versionedPath; e != a {
-			t.Errorf("expected %#v, got %#v", e, a)
-		}
-		if e, a := expected.NegotiatedSerializer, conf.NegotiatedSerializer; !reflect.DeepEqual(e, a) {
-			t.Errorf("expected %#v, got %#v", e, a)
-		}
-	}
-}

vendor/k8s.io/kubernetes/pkg/client/unversioned/portforward/BUILD

@@ -1,51 +0,0 @@
-package(default_visibility = ["//visibility:public"])
-
-licenses(["notice"])
-
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-    "go_test",
-)
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "doc.go",
-        "portforward.go",
-    ],
-    tags = ["automanaged"],
-    deps = [
-        "//pkg/api:go_default_library",
-        "//pkg/kubelet/server/portforward:go_default_library",
-        "//pkg/util/httpstream:go_default_library",
-        "//vendor:k8s.io/apimachinery/pkg/util/runtime",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["portforward_test.go"],
-    library = ":go_default_library",
-    tags = ["automanaged"],
-    deps = [
-        "//pkg/client/unversioned/remotecommand:go_default_library",
-        "//pkg/kubelet/server/portforward:go_default_library",
-        "//pkg/util/httpstream:go_default_library",
-        "//vendor:k8s.io/apimachinery/pkg/types",
-        "//vendor:k8s.io/client-go/rest",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-)

vendor/k8s.io/kubernetes/pkg/client/unversioned/portforward/doc.go

@@ -1,19 +0,0 @@
-/*
-Copyright 2015 The Kubernetes 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 portforward adds support for SSH-like port forwarding from the client's
-// local host to remote containers.
-package portforward // import "k8s.io/kubernetes/pkg/client/unversioned/portforward"

vendor/k8s.io/kubernetes/pkg/client/unversioned/portforward/portforward.go

@@ -1,340 +0,0 @@
-/*
-Copyright 2015 The Kubernetes 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 portforward
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"strconv"
-	"strings"
-	"sync"
-
-	"k8s.io/apimachinery/pkg/util/runtime"
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/kubelet/server/portforward"
-	"k8s.io/kubernetes/pkg/util/httpstream"
-)
-
-// PortForwarder knows how to listen for local connections and forward them to
-// a remote pod via an upgraded HTTP request.
-type PortForwarder struct {
-	ports    []ForwardedPort
-	stopChan <-chan struct{}
-
-	dialer        httpstream.Dialer
-	streamConn    httpstream.Connection
-	listeners     []io.Closer
-	Ready         chan struct{}
-	requestIDLock sync.Mutex
-	requestID     int
-	out           io.Writer
-	errOut        io.Writer
-}
-
-// ForwardedPort contains a Local:Remote port pairing.
-type ForwardedPort struct {
-	Local  uint16
-	Remote uint16
-}
-
-/*
-	valid port specifications:
-
-	5000
-	- forwards from localhost:5000 to pod:5000
-
-	8888:5000
-	- forwards from localhost:8888 to pod:5000
-
-	0:5000
-	:5000
-	- selects a random available local port,
-	  forwards from localhost:<random port> to pod:5000
-*/
-func parsePorts(ports []string) ([]ForwardedPort, error) {
-	var forwards []ForwardedPort
-	for _, portString := range ports {
-		parts := strings.Split(portString, ":")
-		var localString, remoteString string
-		if len(parts) == 1 {
-			localString = parts[0]
-			remoteString = parts[0]
-		} else if len(parts) == 2 {
-			localString = parts[0]
-			if localString == "" {
-				// support :5000
-				localString = "0"
-			}
-			remoteString = parts[1]
-		} else {
-			return nil, fmt.Errorf("Invalid port format '%s'", portString)
-		}
-
-		localPort, err := strconv.ParseUint(localString, 10, 16)
-		if err != nil {
-			return nil, fmt.Errorf("Error parsing local port '%s': %s", localString, err)
-		}
-
-		remotePort, err := strconv.ParseUint(remoteString, 10, 16)
-		if err != nil {
-			return nil, fmt.Errorf("Error parsing remote port '%s': %s", remoteString, err)
-		}
-		if remotePort == 0 {
-			return nil, fmt.Errorf("Remote port must be > 0")
-		}
-
-		forwards = append(forwards, ForwardedPort{uint16(localPort), uint16(remotePort)})
-	}
-
-	return forwards, nil
-}
-
-// New creates a new PortForwarder.
-func New(dialer httpstream.Dialer, ports []string, stopChan <-chan struct{}, readyChan chan struct{}, out, errOut io.Writer) (*PortForwarder, error) {
-	if len(ports) == 0 {
-		return nil, errors.New("You must specify at least 1 port")
-	}
-	parsedPorts, err := parsePorts(ports)
-	if err != nil {
-		return nil, err
-	}
-	return &PortForwarder{
-		dialer:   dialer,
-		ports:    parsedPorts,
-		stopChan: stopChan,
-		Ready:    readyChan,
-		out:      out,
-		errOut:   errOut,
-	}, nil
-}
-
-// ForwardPorts formats and executes a port forwarding request. The connection will remain
-// open until stopChan is closed.
-func (pf *PortForwarder) ForwardPorts() error {
-	defer pf.Close()
-
-	var err error
-	pf.streamConn, _, err = pf.dialer.Dial(portforward.PortForwardProtocolV1Name)
-	if err != nil {
-		return fmt.Errorf("error upgrading connection: %s", err)
-	}
-	defer pf.streamConn.Close()
-
-	return pf.forward()
-}
-
-// forward dials the remote host specific in req, upgrades the request, starts
-// listeners for each port specified in ports, and forwards local connections
-// to the remote host via streams.
-func (pf *PortForwarder) forward() error {
-	var err error
-
-	listenSuccess := false
-	for _, port := range pf.ports {
-		err = pf.listenOnPort(&port)
-		switch {
-		case err == nil:
-			listenSuccess = true
-		default:
-			if pf.errOut != nil {
-				fmt.Fprintf(pf.errOut, "Unable to listen on port %d: %v\n", port.Local, err)
-			}
-		}
-	}
-
-	if !listenSuccess {
-		return fmt.Errorf("Unable to listen on any of the requested ports: %v", pf.ports)
-	}
-
-	if pf.Ready != nil {
-		close(pf.Ready)
-	}
-
-	// wait for interrupt or conn closure
-	select {
-	case <-pf.stopChan:
-	case <-pf.streamConn.CloseChan():
-		runtime.HandleError(errors.New("lost connection to pod"))
-	}
-
-	return nil
-}
-
-// listenOnPort delegates tcp4 and tcp6 listener creation and waits for connections on both of these addresses.
-// If both listener creation fail, an error is raised.
-func (pf *PortForwarder) listenOnPort(port *ForwardedPort) error {
-	errTcp4 := pf.listenOnPortAndAddress(port, "tcp4", "127.0.0.1")
-	errTcp6 := pf.listenOnPortAndAddress(port, "tcp6", "[::1]")
-	if errTcp4 != nil && errTcp6 != nil {
-		return fmt.Errorf("All listeners failed to create with the following errors: %s, %s", errTcp4, errTcp6)
-	}
-	return nil
-}
-
-// listenOnPortAndAddress delegates listener creation and waits for new connections
-// in the background f
-func (pf *PortForwarder) listenOnPortAndAddress(port *ForwardedPort, protocol string, address string) error {
-	listener, err := pf.getListener(protocol, address, port)
-	if err != nil {
-		return err
-	}
-	pf.listeners = append(pf.listeners, listener)
-	go pf.waitForConnection(listener, *port)
-	return nil
-}
-
-// getListener creates a listener on the interface targeted by the given hostname on the given port with
-// the given protocol. protocol is in net.Listen style which basically admits values like tcp, tcp4, tcp6
-func (pf *PortForwarder) getListener(protocol string, hostname string, port *ForwardedPort) (net.Listener, error) {
-	listener, err := net.Listen(protocol, fmt.Sprintf("%s:%d", hostname, port.Local))
-	if err != nil {
-		runtime.HandleError(fmt.Errorf("Unable to create listener: Error %s", err))
-		return nil, err
-	}
-	listenerAddress := listener.Addr().String()
-	host, localPort, _ := net.SplitHostPort(listenerAddress)
-	localPortUInt, err := strconv.ParseUint(localPort, 10, 16)
-
-	if err != nil {
-		return nil, fmt.Errorf("Error parsing local port: %s from %s (%s)", err, listenerAddress, host)
-	}
-	port.Local = uint16(localPortUInt)
-	if pf.out != nil {
-		fmt.Fprintf(pf.out, "Forwarding from %s:%d -> %d\n", hostname, localPortUInt, port.Remote)
-	}
-
-	return listener, nil
-}
-
-// waitForConnection waits for new connections to listener and handles them in
-// the background.
-func (pf *PortForwarder) waitForConnection(listener net.Listener, port ForwardedPort) {
-	for {
-		conn, err := listener.Accept()
-		if err != nil {
-			// TODO consider using something like https://github.com/hydrogen18/stoppableListener?
-			if !strings.Contains(strings.ToLower(err.Error()), "use of closed network connection") {
-				runtime.HandleError(fmt.Errorf("Error accepting connection on port %d: %v", port.Local, err))
-			}
-			return
-		}
-		go pf.handleConnection(conn, port)
-	}
-}
-
-func (pf *PortForwarder) nextRequestID() int {
-	pf.requestIDLock.Lock()
-	defer pf.requestIDLock.Unlock()
-	id := pf.requestID
-	pf.requestID++
-	return id
-}
-
-// handleConnection copies data between the local connection and the stream to
-// the remote server.
-func (pf *PortForwarder) handleConnection(conn net.Conn, port ForwardedPort) {
-	defer conn.Close()
-
-	if pf.out != nil {
-		fmt.Fprintf(pf.out, "Handling connection for %d\n", port.Local)
-	}
-
-	requestID := pf.nextRequestID()
-
-	// create error stream
-	headers := http.Header{}
-	headers.Set(api.StreamType, api.StreamTypeError)
-	headers.Set(api.PortHeader, fmt.Sprintf("%d", port.Remote))
-	headers.Set(api.PortForwardRequestIDHeader, strconv.Itoa(requestID))
-	errorStream, err := pf.streamConn.CreateStream(headers)
-	if err != nil {
-		runtime.HandleError(fmt.Errorf("error creating error stream for port %d -> %d: %v", port.Local, port.Remote, err))
-		return
-	}
-	// we're not writing to this stream
-	errorStream.Close()
-
-	errorChan := make(chan error)
-	go func() {
-		message, err := ioutil.ReadAll(errorStream)
-		switch {
-		case err != nil:
-			errorChan <- fmt.Errorf("error reading from error stream for port %d -> %d: %v", port.Local, port.Remote, err)
-		case len(message) > 0:
-			errorChan <- fmt.Errorf("an error occurred forwarding %d -> %d: %v", port.Local, port.Remote, string(message))
-		}
-		close(errorChan)
-	}()
-
-	// create data stream
-	headers.Set(api.StreamType, api.StreamTypeData)
-	dataStream, err := pf.streamConn.CreateStream(headers)
-	if err != nil {
-		runtime.HandleError(fmt.Errorf("error creating forwarding stream for port %d -> %d: %v", port.Local, port.Remote, err))
-		return
-	}
-
-	localError := make(chan struct{})
-	remoteDone := make(chan struct{})
-
-	go func() {
-		// Copy from the remote side to the local port.
-		if _, err := io.Copy(conn, dataStream); err != nil && !strings.Contains(err.Error(), "use of closed network connection") {
-			runtime.HandleError(fmt.Errorf("error copying from remote stream to local connection: %v", err))
-		}
-
-		// inform the select below that the remote copy is done
-		close(remoteDone)
-	}()
-
-	go func() {
-		// inform server we're not sending any more data after copy unblocks
-		defer dataStream.Close()
-
-		// Copy from the local port to the remote side.
-		if _, err := io.Copy(dataStream, conn); err != nil && !strings.Contains(err.Error(), "use of closed network connection") {
-			runtime.HandleError(fmt.Errorf("error copying from local connection to remote stream: %v", err))
-			// break out of the select below without waiting for the other copy to finish
-			close(localError)
-		}
-	}()
-
-	// wait for either a local->remote error or for copying from remote->local to finish
-	select {
-	case <-remoteDone:
-	case <-localError:
-	}
-
-	// always expect something on errorChan (it may be nil)
-	err = <-errorChan
-	if err != nil {
-		runtime.HandleError(err)
-	}
-}
-
-func (pf *PortForwarder) Close() {
-	// stop all listeners
-	for _, l := range pf.listeners {
-		if err := l.Close(); err != nil {
-			runtime.HandleError(fmt.Errorf("error closing listener: %v", err))
-		}
-	}
-}

vendor/k8s.io/kubernetes/pkg/client/unversioned/portforward/portforward_test.go

@@ -1,398 +0,0 @@
-/*
-Copyright 2015 The Kubernetes 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 portforward
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"os"
-	"reflect"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"k8s.io/apimachinery/pkg/types"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/kubernetes/pkg/client/unversioned/remotecommand"
-	"k8s.io/kubernetes/pkg/kubelet/server/portforward"
-	"k8s.io/kubernetes/pkg/util/httpstream"
-)
-
-type fakeDialer struct {
-	dialed             bool
-	conn               httpstream.Connection
-	err                error
-	negotiatedProtocol string
-}
-
-func (d *fakeDialer) Dial(protocols ...string) (httpstream.Connection, string, error) {
-	d.dialed = true
-	return d.conn, d.negotiatedProtocol, d.err
-}
-
-func TestParsePortsAndNew(t *testing.T) {
-	tests := []struct {
-		input            []string
-		expected         []ForwardedPort
-		expectParseError bool
-		expectNewError   bool
-	}{
-		{input: []string{}, expectNewError: true},
-		{input: []string{"a"}, expectParseError: true, expectNewError: true},
-		{input: []string{":a"}, expectParseError: true, expectNewError: true},
-		{input: []string{"-1"}, expectParseError: true, expectNewError: true},
-		{input: []string{"65536"}, expectParseError: true, expectNewError: true},
-		{input: []string{"0"}, expectParseError: true, expectNewError: true},
-		{input: []string{"0:0"}, expectParseError: true, expectNewError: true},
-		{input: []string{"a:5000"}, expectParseError: true, expectNewError: true},
-		{input: []string{"5000:a"}, expectParseError: true, expectNewError: true},
-		{
-			input: []string{"5000", "5000:5000", "8888:5000", "5000:8888", ":5000", "0:5000"},
-			expected: []ForwardedPort{
-				{5000, 5000},
-				{5000, 5000},
-				{8888, 5000},
-				{5000, 8888},
-				{0, 5000},
-				{0, 5000},
-			},
-		},
-	}
-
-	for i, test := range tests {
-		parsed, err := parsePorts(test.input)
-		haveError := err != nil
-		if e, a := test.expectParseError, haveError; e != a {
-			t.Fatalf("%d: parsePorts: error expected=%t, got %t: %s", i, e, a, err)
-		}
-
-		dialer := &fakeDialer{}
-		expectedStopChan := make(chan struct{})
-		readyChan := make(chan struct{})
-		pf, err := New(dialer, test.input, expectedStopChan, readyChan, os.Stdout, os.Stderr)
-		haveError = err != nil
-		if e, a := test.expectNewError, haveError; e != a {
-			t.Fatalf("%d: New: error expected=%t, got %t: %s", i, e, a, err)
-		}
-
-		if test.expectParseError || test.expectNewError {
-			continue
-		}
-
-		for pi, expectedPort := range test.expected {
-			if e, a := expectedPort.Local, parsed[pi].Local; e != a {
-				t.Fatalf("%d: local expected: %d, got: %d", i, e, a)
-			}
-			if e, a := expectedPort.Remote, parsed[pi].Remote; e != a {
-				t.Fatalf("%d: remote expected: %d, got: %d", i, e, a)
-			}
-		}
-
-		if dialer.dialed {
-			t.Fatalf("%d: expected not dialed", i)
-		}
-		if e, a := test.expected, pf.ports; !reflect.DeepEqual(e, a) {
-			t.Fatalf("%d: ports: expected %#v, got %#v", i, e, a)
-		}
-		if e, a := expectedStopChan, pf.stopChan; e != a {
-			t.Fatalf("%d: stopChan: expected %#v, got %#v", i, e, a)
-		}
-		if pf.Ready == nil {
-			t.Fatalf("%d: Ready should be non-nil", i)
-		}
-	}
-}
-
-type GetListenerTestCase struct {
-	Hostname                string
-	Protocol                string
-	ShouldRaiseError        bool
-	ExpectedListenerAddress string
-}
-
-func TestGetListener(t *testing.T) {
-	var pf PortForwarder
-	testCases := []GetListenerTestCase{
-		{
-			Hostname:                "localhost",
-			Protocol:                "tcp4",
-			ShouldRaiseError:        false,
-			ExpectedListenerAddress: "127.0.0.1",
-		},
-		{
-			Hostname:                "127.0.0.1",
-			Protocol:                "tcp4",
-			ShouldRaiseError:        false,
-			ExpectedListenerAddress: "127.0.0.1",
-		},
-		{
-			Hostname:                "[::1]",
-			Protocol:                "tcp6",
-			ShouldRaiseError:        false,
-			ExpectedListenerAddress: "::1",
-		},
-		{
-			Hostname:         "[::1]",
-			Protocol:         "tcp4",
-			ShouldRaiseError: true,
-		},
-		{
-			Hostname:         "127.0.0.1",
-			Protocol:         "tcp6",
-			ShouldRaiseError: true,
-		},
-		{
-			// IPv6 address must be put into brackets. This test reveals this.
-			Hostname:         "::1",
-			Protocol:         "tcp6",
-			ShouldRaiseError: true,
-		},
-	}
-
-	for i, testCase := range testCases {
-		expectedListenerPort := "12345"
-		listener, err := pf.getListener(testCase.Protocol, testCase.Hostname, &ForwardedPort{12345, 12345})
-		if err != nil && strings.Contains(err.Error(), "cannot assign requested address") {
-			t.Logf("Can't test #%d: %v", i, err)
-			continue
-		}
-		errorRaised := err != nil
-
-		if testCase.ShouldRaiseError != errorRaised {
-			t.Errorf("Test case #%d failed: Data %v an error has been raised(%t) where it should not (or reciprocally): %v", i, testCase, testCase.ShouldRaiseError, err)
-			continue
-		}
-		if errorRaised {
-			continue
-		}
-
-		if listener == nil {
-			t.Errorf("Test case #%d did not raise an error but failed in initializing listener", i)
-			continue
-		}
-
-		host, port, _ := net.SplitHostPort(listener.Addr().String())
-		t.Logf("Asked a %s forward for: %s:%v, got listener %s:%s, expected: %s", testCase.Protocol, testCase.Hostname, 12345, host, port, expectedListenerPort)
-		if host != testCase.ExpectedListenerAddress {
-			t.Errorf("Test case #%d failed: Listener does not listen on exepected address: asked %v got %v", i, testCase.ExpectedListenerAddress, host)
-		}
-		if port != expectedListenerPort {
-			t.Errorf("Test case #%d failed: Listener does not listen on exepected port: asked %v got %v", i, expectedListenerPort, port)
-
-		}
-		listener.Close()
-
-	}
-}
-
-// fakePortForwarder simulates port forwarding for testing. It implements
-// portforward.PortForwarder.
-type fakePortForwarder struct {
-	lock sync.Mutex
-	// stores data expected from the stream per port
-	expected map[uint16]string
-	// stores data received from the stream per port
-	received map[uint16]string
-	// data to be sent to the stream per port
-	send map[uint16]string
-}
-
-var _ portforward.PortForwarder = &fakePortForwarder{}
-
-func (pf *fakePortForwarder) PortForward(name string, uid types.UID, port uint16, stream io.ReadWriteCloser) error {
-	defer stream.Close()
-
-	// read from the client
-	received := make([]byte, len(pf.expected[port]))
-	n, err := stream.Read(received)
-	if err != nil {
-		return fmt.Errorf("error reading from client for port %d: %v", port, err)
-	}
-	if n != len(pf.expected[port]) {
-		return fmt.Errorf("unexpected length read from client for port %d: got %d, expected %d. data=%q", port, n, len(pf.expected[port]), string(received))
-	}
-
-	// store the received content
-	pf.lock.Lock()
-	pf.received[port] = string(received)
-	pf.lock.Unlock()
-
-	// send the hardcoded data to the client
-	io.Copy(stream, strings.NewReader(pf.send[port]))
-
-	return nil
-}
-
-// fakePortForwardServer creates an HTTP server that can handle port forwarding
-// requests.
-func fakePortForwardServer(t *testing.T, testName string, serverSends, expectedFromClient map[uint16]string) http.HandlerFunc {
-	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		pf := &fakePortForwarder{
-			expected: expectedFromClient,
-			received: make(map[uint16]string),
-			send:     serverSends,
-		}
-		portforward.ServePortForward(w, req, pf, "pod", "uid", 0, 10*time.Second)
-
-		for port, expected := range expectedFromClient {
-			actual, ok := pf.received[port]
-			if !ok {
-				t.Errorf("%s: server didn't receive any data for port %d", testName, port)
-				continue
-			}
-
-			if expected != actual {
-				t.Errorf("%s: server expected to receive %q, got %q for port %d", testName, expected, actual, port)
-			}
-		}
-
-		for port, actual := range pf.received {
-			if _, ok := expectedFromClient[port]; !ok {
-				t.Errorf("%s: server unexpectedly received %q for port %d", testName, actual, port)
-			}
-		}
-	})
-}
-
-func TestForwardPorts(t *testing.T) {
-	tests := map[string]struct {
-		ports       []string
-		clientSends map[uint16]string
-		serverSends map[uint16]string
-	}{
-		"forward 1 port with no data either direction": {
-			ports: []string{"5000"},
-		},
-		"forward 2 ports with bidirectional data": {
-			ports: []string{"5001", "6000"},
-			clientSends: map[uint16]string{
-				5001: "abcd",
-				6000: "ghij",
-			},
-			serverSends: map[uint16]string{
-				5001: "1234",
-				6000: "5678",
-			},
-		},
-	}
-
-	for testName, test := range tests {
-		server := httptest.NewServer(fakePortForwardServer(t, testName, test.serverSends, test.clientSends))
-
-		url, _ := url.Parse(server.URL)
-		exec, err := remotecommand.NewExecutor(&restclient.Config{}, "POST", url)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		stopChan := make(chan struct{}, 1)
-		readyChan := make(chan struct{})
-
-		pf, err := New(exec, test.ports, stopChan, readyChan, os.Stdout, os.Stderr)
-		if err != nil {
-			t.Fatalf("%s: unexpected error calling New: %v", testName, err)
-		}
-
-		doneChan := make(chan error)
-		go func() {
-			doneChan <- pf.ForwardPorts()
-		}()
-		<-pf.Ready
-
-		for port, data := range test.clientSends {
-			clientConn, err := net.Dial("tcp", fmt.Sprintf("localhost:%d", port))
-			if err != nil {
-				t.Errorf("%s: error dialing %d: %s", testName, port, err)
-				server.Close()
-				continue
-			}
-			defer clientConn.Close()
-
-			n, err := clientConn.Write([]byte(data))
-			if err != nil && err != io.EOF {
-				t.Errorf("%s: Error sending data '%s': %s", testName, data, err)
-				server.Close()
-				continue
-			}
-			if n == 0 {
-				t.Errorf("%s: unexpected write of 0 bytes", testName)
-				server.Close()
-				continue
-			}
-			b := make([]byte, 4)
-			n, err = clientConn.Read(b)
-			if err != nil && err != io.EOF {
-				t.Errorf("%s: Error reading data: %s", testName, err)
-				server.Close()
-				continue
-			}
-			if !bytes.Equal([]byte(test.serverSends[port]), b) {
-				t.Errorf("%s: expected to read '%s', got '%s'", testName, test.serverSends[port], b)
-				server.Close()
-				continue
-			}
-		}
-		// tell r.ForwardPorts to stop
-		close(stopChan)
-
-		// wait for r.ForwardPorts to actually return
-		err = <-doneChan
-		if err != nil {
-			t.Errorf("%s: unexpected error: %s", testName, err)
-		}
-		server.Close()
-	}
-
-}
-
-func TestForwardPortsReturnsErrorWhenAllBindsFailed(t *testing.T) {
-	server := httptest.NewServer(fakePortForwardServer(t, "allBindsFailed", nil, nil))
-	defer server.Close()
-
-	url, _ := url.Parse(server.URL)
-	exec, err := remotecommand.NewExecutor(&restclient.Config{}, "POST", url)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	stopChan1 := make(chan struct{}, 1)
-	defer close(stopChan1)
-	readyChan1 := make(chan struct{})
-
-	pf1, err := New(exec, []string{"5555"}, stopChan1, readyChan1, os.Stdout, os.Stderr)
-	if err != nil {
-		t.Fatalf("error creating pf1: %v", err)
-	}
-	go pf1.ForwardPorts()
-	<-pf1.Ready
-
-	stopChan2 := make(chan struct{}, 1)
-	readyChan2 := make(chan struct{})
-	pf2, err := New(exec, []string{"5555"}, stopChan2, readyChan2, os.Stdout, os.Stderr)
-	if err != nil {
-		t.Fatalf("error creating pf2: %v", err)
-	}
-	if err := pf2.ForwardPorts(); err == nil {
-		t.Fatal("expected non-nil error for pf2.ForwardPorts")
-	}
-}

vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/BUILD

@@ -1,72 +0,0 @@
-package(default_visibility = ["//visibility:public"])
-
-licenses(["notice"])
-
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-    "go_test",
-)
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "doc.go",
-        "errorstream.go",
-        "remotecommand.go",
-        "v1.go",
-        "v2.go",
-        "v3.go",
-        "v4.go",
-    ],
-    tags = ["automanaged"],
-    deps = [
-        "//pkg/api:go_default_library",
-        "//pkg/kubelet/server/remotecommand:go_default_library",
-        "//pkg/util/exec:go_default_library",
-        "//pkg/util/httpstream:go_default_library",
-        "//pkg/util/httpstream/spdy:go_default_library",
-        "//pkg/util/term:go_default_library",
-        "//vendor:github.com/golang/glog",
-        "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
-        "//vendor:k8s.io/apimachinery/pkg/util/runtime",
-        "//vendor:k8s.io/client-go/rest",
-        "//vendor:k8s.io/client-go/transport",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "remotecommand_test.go",
-        "v2_test.go",
-        "v4_test.go",
-    ],
-    library = ":go_default_library",
-    tags = ["automanaged"],
-    deps = [
-        "//pkg/api:go_default_library",
-        "//pkg/api/testapi:go_default_library",
-        "//pkg/kubelet/server/remotecommand:go_default_library",
-        "//pkg/util/httpstream:go_default_library",
-        "//pkg/util/term:go_default_library",
-        "//vendor:github.com/stretchr/testify/require",
-        "//vendor:k8s.io/apimachinery/pkg/runtime/schema",
-        "//vendor:k8s.io/apimachinery/pkg/types",
-        "//vendor:k8s.io/apimachinery/pkg/util/wait",
-        "//vendor:k8s.io/client-go/rest",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-)

vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/remotecommand.go

@@ -24,11 +24,11 @@ import (
 
 	"github.com/golang/glog"
 
+	"k8s.io/apimachinery/pkg/util/httpstream"
+	"k8s.io/apimachinery/pkg/util/httpstream/spdy"
 	restclient "k8s.io/client-go/rest"
 	"k8s.io/client-go/transport"
 	"k8s.io/kubernetes/pkg/kubelet/server/remotecommand"
-	"k8s.io/kubernetes/pkg/util/httpstream"
-	"k8s.io/kubernetes/pkg/util/httpstream/spdy"
 	"k8s.io/kubernetes/pkg/util/term"
 )
 

vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/remotecommand_test.go

@@ -1,369 +0,0 @@
-/*
-Copyright 2015 The Kubernetes 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 remotecommand
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/types"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/testapi"
-	"k8s.io/kubernetes/pkg/kubelet/server/remotecommand"
-	"k8s.io/kubernetes/pkg/util/httpstream"
-	"k8s.io/kubernetes/pkg/util/term"
-)
-
-type fakeExecutor struct {
-	t             *testing.T
-	testName      string
-	errorData     string
-	stdoutData    string
-	stderrData    string
-	expectStdin   bool
-	stdinReceived bytes.Buffer
-	tty           bool
-	messageCount  int
-	command       []string
-	exec          bool
-}
-
-func (ex *fakeExecutor) ExecInContainer(name string, uid types.UID, container string, cmd []string, in io.Reader, out, err io.WriteCloser, tty bool, resize <-chan term.Size, timeout time.Duration) error {
-	return ex.run(name, uid, container, cmd, in, out, err, tty)
-}
-
-func (ex *fakeExecutor) AttachContainer(name string, uid types.UID, container string, in io.Reader, out, err io.WriteCloser, tty bool, resize <-chan term.Size) error {
-	return ex.run(name, uid, container, nil, in, out, err, tty)
-}
-
-func (ex *fakeExecutor) run(name string, uid types.UID, container string, cmd []string, in io.Reader, out, err io.WriteCloser, tty bool) error {
-	ex.command = cmd
-	ex.tty = tty
-
-	if e, a := "pod", name; e != a {
-		ex.t.Errorf("%s: pod: expected %q, got %q", ex.testName, e, a)
-	}
-	if e, a := "uid", uid; e != string(a) {
-		ex.t.Errorf("%s: uid: expected %q, got %q", ex.testName, e, a)
-	}
-	if ex.exec {
-		if e, a := "ls /", strings.Join(ex.command, " "); e != a {
-			ex.t.Errorf("%s: command: expected %q, got %q", ex.testName, e, a)
-		}
-	} else {
-		if len(ex.command) > 0 {
-			ex.t.Errorf("%s: command: expected nothing, got %v", ex.testName, ex.command)
-		}
-	}
-
-	if len(ex.errorData) > 0 {
-		return errors.New(ex.errorData)
-	}
-
-	if len(ex.stdoutData) > 0 {
-		for i := 0; i < ex.messageCount; i++ {
-			fmt.Fprint(out, ex.stdoutData)
-		}
-	}
-
-	if len(ex.stderrData) > 0 {
-		for i := 0; i < ex.messageCount; i++ {
-			fmt.Fprint(err, ex.stderrData)
-		}
-	}
-
-	if ex.expectStdin {
-		io.Copy(&ex.stdinReceived, in)
-	}
-
-	return nil
-}
-
-func fakeServer(t *testing.T, testName string, exec bool, stdinData, stdoutData, stderrData, errorData string, tty bool, messageCount int, serverProtocols []string) http.HandlerFunc {
-	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		executor := &fakeExecutor{
-			t:            t,
-			testName:     testName,
-			errorData:    errorData,
-			stdoutData:   stdoutData,
-			stderrData:   stderrData,
-			expectStdin:  len(stdinData) > 0,
-			tty:          tty,
-			messageCount: messageCount,
-			exec:         exec,
-		}
-
-		opts, err := remotecommand.NewOptions(req)
-		require.NoError(t, err)
-		if exec {
-			cmd := req.URL.Query()[api.ExecCommandParamm]
-			remotecommand.ServeExec(w, req, executor, "pod", "uid", "container", cmd, opts, 0, 10*time.Second, serverProtocols)
-		} else {
-			remotecommand.ServeAttach(w, req, executor, "pod", "uid", "container", opts, 0, 10*time.Second, serverProtocols)
-		}
-
-		if e, a := strings.Repeat(stdinData, messageCount), executor.stdinReceived.String(); e != a {
-			t.Errorf("%s: stdin: expected %q, got %q", testName, e, a)
-		}
-	})
-}
-
-func TestStream(t *testing.T) {
-	testCases := []struct {
-		TestName        string
-		Stdin           string
-		Stdout          string
-		Stderr          string
-		Error           string
-		Tty             bool
-		MessageCount    int
-		ClientProtocols []string
-		ServerProtocols []string
-	}{
-		{
-			TestName:        "error",
-			Error:           "bail",
-			Stdout:          "a",
-			ClientProtocols: []string{remotecommand.StreamProtocolV2Name},
-			ServerProtocols: []string{remotecommand.StreamProtocolV2Name},
-		},
-		{
-			TestName:        "in/out/err",
-			Stdin:           "a",
-			Stdout:          "b",
-			Stderr:          "c",
-			MessageCount:    100,
-			ClientProtocols: []string{remotecommand.StreamProtocolV2Name},
-			ServerProtocols: []string{remotecommand.StreamProtocolV2Name},
-		},
-		{
-			TestName:        "in/out/tty",
-			Stdin:           "a",
-			Stdout:          "b",
-			Tty:             true,
-			MessageCount:    100,
-			ClientProtocols: []string{remotecommand.StreamProtocolV2Name},
-			ServerProtocols: []string{remotecommand.StreamProtocolV2Name},
-		},
-		{
-			// 1.0 kubectl, 1.0 kubelet
-			TestName:        "unversioned client, unversioned server",
-			Stdout:          "b",
-			Stderr:          "c",
-			MessageCount:    1,
-			ClientProtocols: []string{},
-			ServerProtocols: []string{},
-		},
-		{
-			// 1.0 kubectl, 1.1+ kubelet
-			TestName:        "unversioned client, versioned server",
-			Stdout:          "b",
-			Stderr:          "c",
-			MessageCount:    1,
-			ClientProtocols: []string{},
-			ServerProtocols: []string{remotecommand.StreamProtocolV2Name, remotecommand.StreamProtocolV1Name},
-		},
-		{
-			// 1.1+ kubectl, 1.0 kubelet
-			TestName:        "versioned client, unversioned server",
-			Stdout:          "b",
-			Stderr:          "c",
-			MessageCount:    1,
-			ClientProtocols: []string{remotecommand.StreamProtocolV2Name, remotecommand.StreamProtocolV1Name},
-			ServerProtocols: []string{},
-		},
-	}
-
-	for _, testCase := range testCases {
-		for _, exec := range []bool{true, false} {
-			var name string
-			if exec {
-				name = testCase.TestName + " (exec)"
-			} else {
-				name = testCase.TestName + " (attach)"
-			}
-			var (
-				streamIn             io.Reader
-				streamOut, streamErr io.Writer
-			)
-			localOut := &bytes.Buffer{}
-			localErr := &bytes.Buffer{}
-
-			server := httptest.NewServer(fakeServer(t, name, exec, testCase.Stdin, testCase.Stdout, testCase.Stderr, testCase.Error, testCase.Tty, testCase.MessageCount, testCase.ServerProtocols))
-
-			url, _ := url.ParseRequestURI(server.URL)
-			config := restclient.ContentConfig{
-				GroupVersion:         &schema.GroupVersion{Group: "x"},
-				NegotiatedSerializer: testapi.Default.NegotiatedSerializer(),
-			}
-			c, err := restclient.NewRESTClient(url, "", config, -1, -1, nil, nil)
-			if err != nil {
-				t.Fatalf("failed to create a client: %v", err)
-			}
-			req := c.Post().Resource("testing")
-
-			if exec {
-				req.Param("command", "ls")
-				req.Param("command", "/")
-			}
-
-			if len(testCase.Stdin) > 0 {
-				req.Param(api.ExecStdinParam, "1")
-				streamIn = strings.NewReader(strings.Repeat(testCase.Stdin, testCase.MessageCount))
-			}
-
-			if len(testCase.Stdout) > 0 {
-				req.Param(api.ExecStdoutParam, "1")
-				streamOut = localOut
-			}
-
-			if testCase.Tty {
-				req.Param(api.ExecTTYParam, "1")
-			} else if len(testCase.Stderr) > 0 {
-				req.Param(api.ExecStderrParam, "1")
-				streamErr = localErr
-			}
-
-			conf := &restclient.Config{
-				Host: server.URL,
-			}
-			e, err := NewExecutor(conf, "POST", req.URL())
-			if err != nil {
-				t.Errorf("%s: unexpected error: %v", name, err)
-				continue
-			}
-			err = e.Stream(StreamOptions{
-				SupportedProtocols: testCase.ClientProtocols,
-				Stdin:              streamIn,
-				Stdout:             streamOut,
-				Stderr:             streamErr,
-				Tty:                testCase.Tty,
-			})
-			hasErr := err != nil
-
-			if len(testCase.Error) > 0 {
-				if !hasErr {
-					t.Errorf("%s: expected an error", name)
-				} else {
-					if e, a := testCase.Error, err.Error(); !strings.Contains(a, e) {
-						t.Errorf("%s: expected error stream read %q, got %q", name, e, a)
-					}
-				}
-
-				server.Close()
-				continue
-			}
-
-			if hasErr {
-				t.Errorf("%s: unexpected error: %v", name, err)
-				server.Close()
-				continue
-			}
-
-			if len(testCase.Stdout) > 0 {
-				if e, a := strings.Repeat(testCase.Stdout, testCase.MessageCount), localOut; e != a.String() {
-					t.Errorf("%s: expected stdout data %q, got %q", name, e, a)
-				}
-			}
-
-			if testCase.Stderr != "" {
-				if e, a := strings.Repeat(testCase.Stderr, testCase.MessageCount), localErr; e != a.String() {
-					t.Errorf("%s: expected stderr data %q, got %q", name, e, a)
-				}
-			}
-
-			server.Close()
-		}
-	}
-}
-
-type fakeUpgrader struct {
-	req           *http.Request
-	resp          *http.Response
-	conn          httpstream.Connection
-	err, connErr  error
-	checkResponse bool
-
-	t *testing.T
-}
-
-func (u *fakeUpgrader) RoundTrip(req *http.Request) (*http.Response, error) {
-	u.req = req
-	return u.resp, u.err
-}
-
-func (u *fakeUpgrader) NewConnection(resp *http.Response) (httpstream.Connection, error) {
-	if u.checkResponse && u.resp != resp {
-		u.t.Errorf("response objects passed did not match: %#v", resp)
-	}
-	return u.conn, u.connErr
-}
-
-type fakeConnection struct {
-	httpstream.Connection
-}
-
-// Dial is the common functionality between any stream based upgrader, regardless of protocol.
-// This method ensures that someone can use a generic stream executor without being dependent
-// on the core Kube client config behavior.
-func TestDial(t *testing.T) {
-	upgrader := &fakeUpgrader{
-		t:             t,
-		checkResponse: true,
-		conn:          &fakeConnection{},
-		resp: &http.Response{
-			StatusCode: http.StatusSwitchingProtocols,
-			Body:       ioutil.NopCloser(&bytes.Buffer{}),
-		},
-	}
-	var called bool
-	testFn := func(rt http.RoundTripper) http.RoundTripper {
-		if rt != upgrader {
-			t.Fatalf("unexpected round tripper: %#v", rt)
-		}
-		called = true
-		return rt
-	}
-	exec, err := NewStreamExecutor(upgrader, testFn, "POST", &url.URL{Host: "something.com", Scheme: "https"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	conn, protocol, err := exec.Dial("protocol1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if conn != upgrader.conn {
-		t.Errorf("unexpected connection: %#v", conn)
-	}
-	if !called {
-		t.Errorf("wrapper not called")
-	}
-	_ = protocol
-}

vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/v1.go

@@ -23,8 +23,8 @@ import (
 	"net/http"
 
 	"github.com/golang/glog"
+	"k8s.io/apimachinery/pkg/util/httpstream"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/util/httpstream"
 )
 
 // streamProtocolV1 implements the first version of the streaming exec & attach

vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/v2_test.go

@@ -1,228 +0,0 @@
-/*
-Copyright 2016 The Kubernetes 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 remotecommand
-
-import (
-	"errors"
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"k8s.io/apimachinery/pkg/util/wait"
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/util/httpstream"
-)
-
-type fakeReader struct {
-	err error
-}
-
-func (r *fakeReader) Read([]byte) (int, error) { return 0, r.err }
-
-type fakeWriter struct{}
-
-func (*fakeWriter) Write([]byte) (int, error) { return 0, nil }
-
-type fakeStreamCreator struct {
-	created map[string]bool
-	errors  map[string]error
-}
-
-var _ streamCreator = &fakeStreamCreator{}
-
-func (f *fakeStreamCreator) CreateStream(headers http.Header) (httpstream.Stream, error) {
-	streamType := headers.Get(api.StreamType)
-	f.created[streamType] = true
-	return nil, f.errors[streamType]
-}
-
-func TestV2CreateStreams(t *testing.T) {
-	tests := []struct {
-		name        string
-		stdin       bool
-		stdinError  error
-		stdout      bool
-		stdoutError error
-		stderr      bool
-		stderrError error
-		errorError  error
-		tty         bool
-		expectError bool
-	}{
-		{
-			name:        "stdin error",
-			stdin:       true,
-			stdinError:  errors.New("stdin error"),
-			expectError: true,
-		},
-		{
-			name:        "stdout error",
-			stdout:      true,
-			stdoutError: errors.New("stdout error"),
-			expectError: true,
-		},
-		{
-			name:        "stderr error",
-			stderr:      true,
-			stderrError: errors.New("stderr error"),
-			expectError: true,
-		},
-		{
-			name:        "error stream error",
-			stdin:       true,
-			stdout:      true,
-			stderr:      true,
-			errorError:  errors.New("error stream error"),
-			expectError: true,
-		},
-		{
-			name:        "no errors",
-			stdin:       true,
-			stdout:      true,
-			stderr:      true,
-			expectError: false,
-		},
-		{
-			name:        "no errors, stderr & tty set, don't expect stderr",
-			stdin:       true,
-			stdout:      true,
-			stderr:      true,
-			tty:         true,
-			expectError: false,
-		},
-	}
-	for _, test := range tests {
-		conn := &fakeStreamCreator{
-			created: make(map[string]bool),
-			errors: map[string]error{
-				api.StreamTypeStdin:  test.stdinError,
-				api.StreamTypeStdout: test.stdoutError,
-				api.StreamTypeStderr: test.stderrError,
-				api.StreamTypeError:  test.errorError,
-			},
-		}
-
-		opts := StreamOptions{Tty: test.tty}
-		if test.stdin {
-			opts.Stdin = &fakeReader{}
-		}
-		if test.stdout {
-			opts.Stdout = &fakeWriter{}
-		}
-		if test.stderr {
-			opts.Stderr = &fakeWriter{}
-		}
-
-		h := newStreamProtocolV2(opts).(*streamProtocolV2)
-		err := h.createStreams(conn)
-
-		if test.expectError {
-			if err == nil {
-				t.Errorf("%s: expected error", test.name)
-				continue
-			}
-			if e, a := test.stdinError, err; test.stdinError != nil && e != a {
-				t.Errorf("%s: expected %v, got %v", test.name, e, a)
-			}
-			if e, a := test.stdoutError, err; test.stdoutError != nil && e != a {
-				t.Errorf("%s: expected %v, got %v", test.name, e, a)
-			}
-			if e, a := test.stderrError, err; test.stderrError != nil && e != a {
-				t.Errorf("%s: expected %v, got %v", test.name, e, a)
-			}
-			if e, a := test.errorError, err; test.errorError != nil && e != a {
-				t.Errorf("%s: expected %v, got %v", test.name, e, a)
-			}
-			continue
-		}
-
-		if !test.expectError && err != nil {
-			t.Errorf("%s: unexpected error: %v", test.name, err)
-			continue
-		}
-
-		if test.stdin && !conn.created[api.StreamTypeStdin] {
-			t.Errorf("%s: expected stdin stream", test.name)
-		}
-		if test.stdout && !conn.created[api.StreamTypeStdout] {
-			t.Errorf("%s: expected stdout stream", test.name)
-		}
-		if test.stderr {
-			if test.tty && conn.created[api.StreamTypeStderr] {
-				t.Errorf("%s: unexpected stderr stream because tty is set", test.name)
-			} else if !test.tty && !conn.created[api.StreamTypeStderr] {
-				t.Errorf("%s: expected stderr stream", test.name)
-			}
-		}
-		if !conn.created[api.StreamTypeError] {
-			t.Errorf("%s: expected error stream", test.name)
-		}
-
-	}
-}
-
-func TestV2ErrorStreamReading(t *testing.T) {
-	tests := []struct {
-		name          string
-		stream        io.Reader
-		expectedError error
-	}{
-		{
-			name:          "error reading from stream",
-			stream:        &fakeReader{errors.New("foo")},
-			expectedError: errors.New("error reading from error stream: foo"),
-		},
-		{
-			name:          "stream returns an error",
-			stream:        strings.NewReader("some error"),
-			expectedError: errors.New("error executing remote command: some error"),
-		},
-	}
-
-	for _, test := range tests {
-		h := newStreamProtocolV2(StreamOptions{}).(*streamProtocolV2)
-		h.errorStream = test.stream
-
-		ch := watchErrorStream(h.errorStream, &errorDecoderV2{})
-		if ch == nil {
-			t.Fatalf("%s: unexpected nil channel", test.name)
-		}
-
-		var err error
-		select {
-		case err = <-ch:
-		case <-time.After(wait.ForeverTestTimeout):
-			t.Fatalf("%s: timed out", test.name)
-		}
-
-		if test.expectedError != nil {
-			if err == nil {
-				t.Errorf("%s: expected an error", test.name)
-			} else if e, a := test.expectedError, err; e.Error() != a.Error() {
-				t.Errorf("%s: expected %q, got %q", test.name, e, a)
-			}
-			continue
-		}
-
-		if test.expectedError == nil && err != nil {
-			t.Errorf("%s: unexpected error: %v", test.name, err)
-			continue
-		}
-	}
-}

vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/v4_test.go

@@ -1,71 +0,0 @@
-/*
-Copyright 2016 The Kubernetes 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 remotecommand
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestV4ErrorDecoder(t *testing.T) {
-	dec := errorDecoderV4{}
-
-	type Test struct {
-		message string
-		err     string
-	}
-
-	for _, test := range []Test{
-		{
-			message: "{}",
-			err:     "error stream protocol error: unknown error",
-		},
-		{
-			message: "{",
-			err:     "error stream protocol error: unexpected end of JSON input in \"{\"",
-		},
-		{
-			message: `{"status": "Success" }`,
-			err:     "",
-		},
-		{
-			message: `{"status": "Failure", "message": "foobar" }`,
-			err:     "foobar",
-		},
-		{
-			message: `{"status": "Failure", "message": "foobar", "reason": "NonZeroExitCode", "details": {"causes": [{"reason": "foo"}] } }`,
-			err:     "error stream protocol error: no ExitCode cause given",
-		},
-		{
-			message: `{"status": "Failure", "message": "foobar", "reason": "NonZeroExitCode", "details": {"causes": [{"reason": "ExitCode"}] } }`,
-			err:     "error stream protocol error: invalid exit code value \"\"",
-		},
-		{
-			message: `{"status": "Failure", "message": "foobar", "reason": "NonZeroExitCode", "details": {"causes": [{"reason": "ExitCode", "message": "42"}] } }`,
-			err:     "command terminated with exit code 42",
-		},
-	} {
-		err := dec.decode([]byte(test.message))
-		want := test.err
-		if want == "" {
-			want = "<nil>"
-		}
-		if got := fmt.Sprintf("%v", err); got != want {
-			t.Errorf("wrong error for message %q: want=%q, got=%q", test.message, want, got)
-		}
-	}
-}

vendor/k8s.io/kubernetes/pkg/client/unversioned/testclient/simple/BUILD

@@ -1,38 +0,0 @@
-package(default_visibility = ["//visibility:public"])
-
-licenses(["notice"])
-
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-)
-
-go_library(
-    name = "go_default_library",
-    srcs = ["simple_testclient.go"],
-    tags = ["automanaged"],
-    deps = [
-        "//pkg/api:go_default_library",
-        "//pkg/api/testapi:go_default_library",
-        "//pkg/client/clientset_generated/internalclientset:go_default_library",
-        "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
-        "//vendor:k8s.io/apimachinery/pkg/fields",
-        "//vendor:k8s.io/apimachinery/pkg/labels",
-        "//vendor:k8s.io/apimachinery/pkg/runtime",
-        "//vendor:k8s.io/client-go/rest",
-        "//vendor:k8s.io/client-go/util/testing",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-)

vendor/k8s.io/kubernetes/pkg/client/unversioned/testclient/simple/simple_testclient.go

@@ -1,222 +0,0 @@
-/*
-Copyright 2015 The Kubernetes 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 simple
-
-import (
-	"net/http/httptest"
-	"net/url"
-	"path"
-	"reflect"
-	"strings"
-	"testing"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/fields"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/apimachinery/pkg/runtime"
-	restclient "k8s.io/client-go/rest"
-	utiltesting "k8s.io/client-go/util/testing"
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/testapi"
-	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-)
-
-const NameRequiredError = "resource name may not be empty"
-
-type Request struct {
-	Method  string
-	Path    string
-	Header  string
-	Query   url.Values
-	Body    runtime.Object
-	RawBody *string
-}
-
-type Response struct {
-	StatusCode int
-	Body       runtime.Object
-	RawBody    *string
-}
-
-type Client struct {
-	Clientset *clientset.Clientset
-	Request   Request
-	Response  Response
-	Error     bool
-	Created   bool
-	server    *httptest.Server
-	handler   *utiltesting.FakeHandler
-	// For query args, an optional function to validate the contents
-	// useful when the contents can change but still be correct.
-	// Maps from query arg key to validator.
-	// If no validator is present, string equality is used.
-	QueryValidator map[string]func(string, string) bool
-
-	// If your object could exist in multiple groups, set this to
-	// correspond to the URL you're testing it with.
-	ResourceGroup string
-}
-
-func (c *Client) Setup(t *testing.T) *Client {
-	c.handler = &utiltesting.FakeHandler{
-		StatusCode: c.Response.StatusCode,
-	}
-	if responseBody := c.body(t, c.Response.Body, c.Response.RawBody); responseBody != nil {
-		c.handler.ResponseBody = *responseBody
-	}
-	c.server = httptest.NewServer(c.handler)
-	if c.Clientset == nil {
-		c.Clientset = clientset.NewForConfigOrDie(&restclient.Config{Host: c.server.URL})
-	}
-	c.QueryValidator = map[string]func(string, string) bool{}
-	return c
-}
-
-func (c *Client) Close() {
-	if c.server != nil {
-		c.server.Close()
-	}
-}
-
-func (c *Client) ServerURL() string {
-	return c.server.URL
-}
-
-func (c *Client) Validate(t *testing.T, received runtime.Object, err error) {
-	c.ValidateCommon(t, err)
-
-	if c.Response.Body != nil && !api.Semantic.DeepDerivative(c.Response.Body, received) {
-		t.Errorf("bad response for request %#v: \nexpected %#v\ngot %#v\n", c.Request, c.Response.Body, received)
-	}
-}
-
-func (c *Client) ValidateRaw(t *testing.T, received []byte, err error) {
-	c.ValidateCommon(t, err)
-
-	if c.Response.Body != nil && !reflect.DeepEqual(c.Response.Body, received) {
-		t.Errorf("bad response for request %#v: expected %#v, got %#v", c.Request, c.Response.Body, received)
-	}
-}
-
-func (c *Client) ValidateCommon(t *testing.T, err error) {
-	if c.Error {
-		if err == nil {
-			t.Errorf("error expected for %#v, got none", c.Request)
-		}
-		return
-	}
-	if err != nil {
-		t.Errorf("no error expected for %#v, got: %v", c.Request, err)
-	}
-
-	if c.handler.RequestReceived == nil {
-		t.Errorf("handler had an empty request, %#v", c)
-		return
-	}
-
-	requestBody := c.body(t, c.Request.Body, c.Request.RawBody)
-	actualQuery := c.handler.RequestReceived.URL.Query()
-	t.Logf("got query: %v", actualQuery)
-	t.Logf("path: %v", c.Request.Path)
-	// We check the query manually, so blank it out so that FakeHandler.ValidateRequest
-	// won't check it.
-	c.handler.RequestReceived.URL.RawQuery = ""
-	c.handler.ValidateRequest(t, path.Join(c.Request.Path), c.Request.Method, requestBody)
-	for key, values := range c.Request.Query {
-		validator, ok := c.QueryValidator[key]
-		if !ok {
-			switch key {
-			case metav1.LabelSelectorQueryParam(api.Registry.GroupOrDie(api.GroupName).GroupVersion.String()):
-				validator = ValidateLabels
-			case metav1.FieldSelectorQueryParam(api.Registry.GroupOrDie(api.GroupName).GroupVersion.String()):
-				validator = validateFields
-			default:
-				validator = func(a, b string) bool { return a == b }
-			}
-		}
-		observed := actualQuery.Get(key)
-		wanted := strings.Join(values, "")
-		if !validator(wanted, observed) {
-			t.Errorf("Unexpected query arg for key: %s.  Expected %s, Received %s", key, wanted, observed)
-		}
-	}
-	if c.Request.Header != "" {
-		if c.handler.RequestReceived.Header.Get(c.Request.Header) == "" {
-			t.Errorf("header %q not found in request %#v", c.Request.Header, c.handler.RequestReceived)
-		}
-	}
-
-	if expected, received := requestBody, c.handler.RequestBody; expected != nil && *expected != received {
-		t.Errorf("bad body for request %#v: expected %s, got %s", c.Request, *expected, received)
-	}
-}
-
-// buildQueryValues is a convenience function for knowing if a namespace should be in a query param or not
-func BuildQueryValues(query url.Values) url.Values {
-	v := url.Values{}
-	if query != nil {
-		for key, values := range query {
-			for _, value := range values {
-				v.Add(key, value)
-			}
-		}
-	}
-	return v
-}
-
-func ValidateLabels(a, b string) bool {
-	sA, eA := labels.Parse(a)
-	if eA != nil {
-		return false
-	}
-	sB, eB := labels.Parse(b)
-	if eB != nil {
-		return false
-	}
-	return sA.String() == sB.String()
-}
-
-func validateFields(a, b string) bool {
-	sA, _ := fields.ParseSelector(a)
-	sB, _ := fields.ParseSelector(b)
-	return sA.String() == sB.String()
-}
-
-func (c *Client) body(t *testing.T, obj runtime.Object, raw *string) *string {
-	if obj != nil {
-		fqKinds, _, err := api.Scheme.ObjectKinds(obj)
-		if err != nil {
-			t.Errorf("unexpected encoding error: %v", err)
-		}
-		groupName := fqKinds[0].GroupVersion().Group
-		if c.ResourceGroup != "" {
-			groupName = c.ResourceGroup
-		}
-		var bs []byte
-		g, found := testapi.Groups[groupName]
-		if !found {
-			t.Errorf("Group %s is not registered in testapi", groupName)
-		}
-		bs, err = runtime.Encode(g.Codec(), obj)
-		if err != nil {
-			t.Errorf("unexpected encoding error: %v", err)
-		}
-		body := string(bs)
-		return &body
-	}
-	return raw
-}