vendor update for CSI 0.3.0

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/BUILD

@@ -0,0 +1,97 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "attachablepodforobject.go",
+        "canbeautoscaled.go",
+        "canbeexposed.go",
+        "helpers.go",
+        "historyviewer.go",
+        "interface.go",
+        "logsforobject.go",
+        "mapbasedselectorforobject.go",
+        "objectpauser.go",
+        "objectresumer.go",
+        "portsforobject.go",
+        "protocolsforobject.go",
+        "rollbacker.go",
+        "statusviewer.go",
+        "updatepodspec.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/kubectl/polymorphichelpers",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/apis/apps:go_default_library",
+        "//pkg/apis/batch:go_default_library",
+        "//pkg/apis/core:go_default_library",
+        "//pkg/apis/core/v1:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/typed/core/internalversion:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/kubectl:go_default_library",
+        "//pkg/kubectl/genericclioptions:go_default_library",
+        "//vendor/k8s.io/api/apps/v1:go_default_library",
+        "//vendor/k8s.io/api/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/api/apps/v1beta2:go_default_library",
+        "//vendor/k8s.io/api/batch/v1:go_default_library",
+        "//vendor/k8s.io/api/batch/v1beta1:go_default_library",
+        "//vendor/k8s.io/api/batch/v2alpha1:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_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/watch:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "canbeexposed_test.go",
+        "helpers_test.go",
+        "logsforobject_test.go",
+        "portsforobject_test.go",
+    ],
+    embed = [":go_default_library"],
+    deps = [
+        "//pkg/apis/apps:go_default_library",
+        "//pkg/apis/batch:go_default_library",
+        "//pkg/apis/core:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/fake:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/equality:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_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/util/diff:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/testing:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/attachablepodforobject.go

@@ -0,0 +1,62 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"fmt"
+	"sort"
+	"time"
+
+	"k8s.io/api/core/v1"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	apiv1 "k8s.io/kubernetes/pkg/apis/core/v1"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions"
+)
+
+// attachablePodForObject returns the pod to which to attach given an object.
+func attachablePodForObject(restClientGetter genericclioptions.RESTClientGetter, object runtime.Object, timeout time.Duration) (*api.Pod, error) {
+	switch t := object.(type) {
+	case *api.Pod:
+		return t, nil
+	case *corev1.Pod:
+		internalPod := &api.Pod{}
+		err := apiv1.Convert_v1_Pod_To_core_Pod(t, internalPod, nil)
+		return internalPod, err
+
+	}
+
+	clientConfig, err := restClientGetter.ToRESTConfig()
+	if err != nil {
+		return nil, err
+	}
+	clientset, err := internalclientset.NewForConfig(clientConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	namespace, selector, err := SelectorsForObject(object)
+	if err != nil {
+		return nil, fmt.Errorf("cannot attach to %T: %v", object, err)
+	}
+	sortBy := func(pods []*v1.Pod) sort.Interface { return sort.Reverse(controller.ActivePods(pods)) }
+	pod, _, err := GetFirstPod(clientset.Core(), namespace, selector.String(), timeout, sortBy)
+	return pod, err
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/canbeautoscaled.go

@@ -0,0 +1,37 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+)
+
+func canBeAutoscaled(kind schema.GroupKind) error {
+	switch kind {
+	case api.Kind("ReplicationController"), extensions.Kind("ReplicaSet"),
+		extensions.Kind("Deployment"), apps.Kind("Deployment"), apps.Kind("ReplicaSet"):
+		// nothing to do here
+	default:
+		return fmt.Errorf("cannot autoscale a %v", kind)
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/canbeexposed.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+)
+
+// Check whether the kind of resources could be exposed
+func canBeExposed(kind schema.GroupKind) error {
+	switch kind {
+	case api.Kind("ReplicationController"), api.Kind("Service"), api.Kind("Pod"),
+		extensions.Kind("Deployment"), apps.Kind("Deployment"), extensions.Kind("ReplicaSet"), apps.Kind("ReplicaSet"):
+		// nothing to do here
+	default:
+		return fmt.Errorf("cannot expose a %s", kind)
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/canbeexposed_test.go

@@ -0,0 +1,50 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"testing"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+func TestCanBeExposed(t *testing.T) {
+	tests := []struct {
+		kind      schema.GroupKind
+		expectErr bool
+	}{
+		{
+			kind:      api.Kind("ReplicationController"),
+			expectErr: false,
+		},
+		{
+			kind:      api.Kind("Node"),
+			expectErr: true,
+		},
+	}
+
+	for _, test := range tests {
+		err := canBeExposed(test.kind)
+		if test.expectErr && err == nil {
+			t.Error("unexpected non-error")
+		}
+		if !test.expectErr && err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/helpers.go

@@ -0,0 +1,235 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"fmt"
+	"sort"
+	"time"
+
+	appsv1 "k8s.io/api/apps/v1"
+	appsv1beta1 "k8s.io/api/apps/v1beta1"
+	appsv1beta2 "k8s.io/api/apps/v1beta2"
+	batchv1 "k8s.io/api/batch/v1"
+	"k8s.io/api/core/v1"
+	corev1 "k8s.io/api/core/v1"
+	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	"k8s.io/kubernetes/pkg/apis/batch"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	apiv1 "k8s.io/kubernetes/pkg/apis/core/v1"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"
+)
+
+// GetFirstPod returns a pod matching the namespace and label selector
+// and the number of all pods that match the label selector.
+func GetFirstPod(client coreclient.PodsGetter, namespace string, selector string, timeout time.Duration, sortBy func([]*v1.Pod) sort.Interface) (*api.Pod, int, error) {
+	options := metav1.ListOptions{LabelSelector: selector}
+
+	podList, err := client.Pods(namespace).List(options)
+	if err != nil {
+		return nil, 0, err
+	}
+	pods := []*v1.Pod{}
+	for i := range podList.Items {
+		pod := podList.Items[i]
+		externalPod := &v1.Pod{}
+		apiv1.Convert_core_Pod_To_v1_Pod(&pod, externalPod, nil)
+		pods = append(pods, externalPod)
+	}
+	if len(pods) > 0 {
+		sort.Sort(sortBy(pods))
+		internalPod := &api.Pod{}
+		apiv1.Convert_v1_Pod_To_core_Pod(pods[0], internalPod, nil)
+		return internalPod, len(podList.Items), nil
+	}
+
+	// Watch until we observe a pod
+	options.ResourceVersion = podList.ResourceVersion
+	w, err := client.Pods(namespace).Watch(options)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer w.Stop()
+
+	condition := func(event watch.Event) (bool, error) {
+		return event.Type == watch.Added || event.Type == watch.Modified, nil
+	}
+	event, err := watch.Until(timeout, w, condition)
+	if err != nil {
+		return nil, 0, err
+	}
+	pod, ok := event.Object.(*api.Pod)
+	if !ok {
+		return nil, 0, fmt.Errorf("%#v is not a pod event", event)
+	}
+	return pod, 1, nil
+}
+
+// SelectorsForObject returns the pod label selector for a given object
+func SelectorsForObject(object runtime.Object) (namespace string, selector labels.Selector, err error) {
+	switch t := object.(type) {
+	case *extensions.ReplicaSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *extensionsv1beta1.ReplicaSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *appsv1.ReplicaSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *appsv1beta2.ReplicaSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+
+	case *api.ReplicationController:
+		namespace = t.Namespace
+		selector = labels.SelectorFromSet(t.Spec.Selector)
+	case *corev1.ReplicationController:
+		namespace = t.Namespace
+		selector = labels.SelectorFromSet(t.Spec.Selector)
+
+	case *apps.StatefulSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *appsv1.StatefulSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *appsv1beta1.StatefulSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *appsv1beta2.StatefulSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+
+	case *extensions.DaemonSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *extensionsv1beta1.DaemonSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *appsv1.DaemonSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *appsv1beta2.DaemonSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+
+	case *extensions.Deployment:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *extensionsv1beta1.Deployment:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *appsv1.Deployment:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *appsv1beta1.Deployment:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *appsv1beta2.Deployment:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+
+	case *batch.Job:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+	case *batchv1.Job:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+
+	case *api.Service:
+		namespace = t.Namespace
+		if t.Spec.Selector == nil || len(t.Spec.Selector) == 0 {
+			return "", nil, fmt.Errorf("invalid service '%s': Service is defined without a selector", t.Name)
+		}
+		selector = labels.SelectorFromSet(t.Spec.Selector)
+	case *corev1.Service:
+		namespace = t.Namespace
+		if t.Spec.Selector == nil || len(t.Spec.Selector) == 0 {
+			return "", nil, fmt.Errorf("invalid service '%s': Service is defined without a selector", t.Name)
+		}
+		selector = labels.SelectorFromSet(t.Spec.Selector)
+
+	default:
+		return "", nil, fmt.Errorf("selector for %T not implemented", object)
+	}
+
+	return namespace, selector, nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/helpers_test.go

@@ -0,0 +1,229 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"fmt"
+	"sort"
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/watch"
+	testcore "k8s.io/client-go/testing"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake"
+	"k8s.io/kubernetes/pkg/controller"
+)
+
+func TestGetFirstPod(t *testing.T) {
+	labelSet := map[string]string{"test": "selector"}
+	tests := []struct {
+		name string
+
+		podList  *api.PodList
+		watching []watch.Event
+		sortBy   func([]*v1.Pod) sort.Interface
+
+		expected    *api.Pod
+		expectedNum int
+		expectedErr bool
+	}{
+		{
+			name:    "kubectl logs - two ready pods",
+			podList: newPodList(2, -1, -1, labelSet),
+			sortBy:  func(pods []*v1.Pod) sort.Interface { return controller.ByLogging(pods) },
+			expected: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "pod-1",
+					Namespace:         metav1.NamespaceDefault,
+					CreationTimestamp: metav1.Date(2016, time.April, 1, 1, 0, 0, 0, time.UTC),
+					Labels:            map[string]string{"test": "selector"},
+				},
+				Status: api.PodStatus{
+					Conditions: []api.PodCondition{
+						{
+							Status: api.ConditionTrue,
+							Type:   api.PodReady,
+						},
+					},
+				},
+			},
+			expectedNum: 2,
+		},
+		{
+			name:    "kubectl logs - one unhealthy, one healthy",
+			podList: newPodList(2, -1, 1, labelSet),
+			sortBy:  func(pods []*v1.Pod) sort.Interface { return controller.ByLogging(pods) },
+			expected: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "pod-2",
+					Namespace:         metav1.NamespaceDefault,
+					CreationTimestamp: metav1.Date(2016, time.April, 1, 1, 0, 1, 0, time.UTC),
+					Labels:            map[string]string{"test": "selector"},
+				},
+				Status: api.PodStatus{
+					Conditions: []api.PodCondition{
+						{
+							Status: api.ConditionTrue,
+							Type:   api.PodReady,
+						},
+					},
+					ContainerStatuses: []api.ContainerStatus{{RestartCount: 5}},
+				},
+			},
+			expectedNum: 2,
+		},
+		{
+			name:    "kubectl attach - two ready pods",
+			podList: newPodList(2, -1, -1, labelSet),
+			sortBy:  func(pods []*v1.Pod) sort.Interface { return sort.Reverse(controller.ActivePods(pods)) },
+			expected: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "pod-1",
+					Namespace:         metav1.NamespaceDefault,
+					CreationTimestamp: metav1.Date(2016, time.April, 1, 1, 0, 0, 0, time.UTC),
+					Labels:            map[string]string{"test": "selector"},
+				},
+				Status: api.PodStatus{
+					Conditions: []api.PodCondition{
+						{
+							Status: api.ConditionTrue,
+							Type:   api.PodReady,
+						},
+					},
+				},
+			},
+			expectedNum: 2,
+		},
+		{
+			name:    "kubectl attach - wait for ready pod",
+			podList: newPodList(1, 1, -1, labelSet),
+			watching: []watch.Event{
+				{
+					Type: watch.Modified,
+					Object: &api.Pod{
+						ObjectMeta: metav1.ObjectMeta{
+							Name:              "pod-1",
+							Namespace:         metav1.NamespaceDefault,
+							CreationTimestamp: metav1.Date(2016, time.April, 1, 1, 0, 0, 0, time.UTC),
+							Labels:            map[string]string{"test": "selector"},
+						},
+						Status: api.PodStatus{
+							Conditions: []api.PodCondition{
+								{
+									Status: api.ConditionTrue,
+									Type:   api.PodReady,
+								},
+							},
+						},
+					},
+				},
+			},
+			sortBy: func(pods []*v1.Pod) sort.Interface { return sort.Reverse(controller.ActivePods(pods)) },
+			expected: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "pod-1",
+					Namespace:         metav1.NamespaceDefault,
+					CreationTimestamp: metav1.Date(2016, time.April, 1, 1, 0, 0, 0, time.UTC),
+					Labels:            map[string]string{"test": "selector"},
+				},
+				Status: api.PodStatus{
+					Conditions: []api.PodCondition{
+						{
+							Status: api.ConditionTrue,
+							Type:   api.PodReady,
+						},
+					},
+				},
+			},
+			expectedNum: 1,
+		},
+	}
+
+	for i := range tests {
+		test := tests[i]
+		fake := fake.NewSimpleClientset(test.podList)
+		if len(test.watching) > 0 {
+			watcher := watch.NewFake()
+			for _, event := range test.watching {
+				switch event.Type {
+				case watch.Added:
+					go watcher.Add(event.Object)
+				case watch.Modified:
+					go watcher.Modify(event.Object)
+				}
+			}
+			fake.PrependWatchReactor("pods", testcore.DefaultWatchReactor(watcher, nil))
+		}
+		selector := labels.Set(labelSet).AsSelector()
+
+		pod, numPods, err := GetFirstPod(fake.Core(), metav1.NamespaceDefault, selector.String(), 1*time.Minute, test.sortBy)
+		pod.Spec.SecurityContext = nil
+		if !test.expectedErr && err != nil {
+			t.Errorf("%s: unexpected error: %v", test.name, err)
+			continue
+		}
+		if test.expectedErr && err == nil {
+			t.Errorf("%s: expected an error", test.name)
+			continue
+		}
+		if test.expectedNum != numPods {
+			t.Errorf("%s: expected %d pods, got %d", test.name, test.expectedNum, numPods)
+			continue
+		}
+		if !apiequality.Semantic.DeepEqual(test.expected, pod) {
+			t.Errorf("%s:\nexpected pod:\n%#v\ngot:\n%#v\n\n", test.name, test.expected, pod)
+		}
+	}
+}
+
+func newPodList(count, isUnready, isUnhealthy int, labels map[string]string) *api.PodList {
+	pods := []api.Pod{}
+	for i := 0; i < count; i++ {
+		newPod := api.Pod{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:              fmt.Sprintf("pod-%d", i+1),
+				Namespace:         metav1.NamespaceDefault,
+				CreationTimestamp: metav1.Date(2016, time.April, 1, 1, 0, i, 0, time.UTC),
+				Labels:            labels,
+			},
+			Status: api.PodStatus{
+				Conditions: []api.PodCondition{
+					{
+						Status: api.ConditionTrue,
+						Type:   api.PodReady,
+					},
+				},
+			},
+		}
+		pods = append(pods, newPod)
+	}
+	if isUnready > -1 && isUnready < count {
+		pods[isUnready].Status.Conditions[0].Status = api.ConditionFalse
+	}
+	if isUnhealthy > -1 && isUnhealthy < count {
+		pods[isUnhealthy].Status.ContainerStatuses = []api.ContainerStatus{{RestartCount: 5}}
+	}
+	return &api.PodList{
+		Items: pods,
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/historyviewer.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions"
+)
+
+// historyViewer Returns a HistoryViewer for viewing change history
+func historyViewer(restClientGetter genericclioptions.RESTClientGetter, mapping *meta.RESTMapping) (kubectl.HistoryViewer, error) {
+	clientConfig, err := restClientGetter.ToRESTConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	external, err := kubernetes.NewForConfig(clientConfig)
+	if err != nil {
+		return nil, err
+	}
+	return kubectl.HistoryViewerFor(mapping.GroupVersionKind.GroupKind(), external)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/interface.go

@@ -0,0 +1,115 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"time"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/rest"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions"
+)
+
+// LogsForObjectFunc is a function type that can tell you how to get logs for a runtime.object
+type LogsForObjectFunc func(restClientGetter genericclioptions.RESTClientGetter, object, options runtime.Object, timeout time.Duration) (*rest.Request, error)
+
+// LogsForObjectFn gives a way to easily override the function for unit testing if needed.
+var LogsForObjectFn LogsForObjectFunc = logsForObject
+
+// AttachableLogsForObjectFunc is a function type that can tell you how to get the pod for which to attach a given object
+type AttachableLogsForObjectFunc func(restClientGetter genericclioptions.RESTClientGetter, object runtime.Object, timeout time.Duration) (*api.Pod, error)
+
+// AttachablePodForObjectFn gives a way to easily override the function for unit testing if needed.
+var AttachablePodForObjectFn AttachableLogsForObjectFunc = attachablePodForObject
+
+// HistoryViewerFunc is a function type that can tell you how to view change history
+type HistoryViewerFunc func(restClientGetter genericclioptions.RESTClientGetter, mapping *meta.RESTMapping) (kubectl.HistoryViewer, error)
+
+// HistoryViewerFn gives a way to easily override the function for unit testing if needed
+var HistoryViewerFn HistoryViewerFunc = historyViewer
+
+// StatusViewerFunc is a function type that can tell you how to print rollout status
+type StatusViewerFunc func(restClientGetter genericclioptions.RESTClientGetter, mapping *meta.RESTMapping) (kubectl.StatusViewer, error)
+
+// StatusViewerFn gives a way to easily override the function for unit testing if needed
+var StatusViewerFn StatusViewerFunc = statusViewer
+
+// UpdatePodSpecForObjectFunc will call the provided function on the pod spec this object supports,
+// return false if no pod spec is supported, or return an error.
+type UpdatePodSpecForObjectFunc func(obj runtime.Object, fn func(*v1.PodSpec) error) (bool, error)
+
+// UpdatePodSpecForObjectFn gives a way to easily override the function for unit testing if needed
+var UpdatePodSpecForObjectFn UpdatePodSpecForObjectFunc = updatePodSpecForObject
+
+// MapBasedSelectorForObjectFunc will call the provided function on mapping the baesd selector for object,
+// return "" if object is not supported, or return an error.
+type MapBasedSelectorForObjectFunc func(object runtime.Object) (string, error)
+
+// MapBasedSelectorForObjectFn gives a way to easily override the function for unit testing if needed
+var MapBasedSelectorForObjectFn MapBasedSelectorForObjectFunc = mapBasedSelectorForObject
+
+// ProtocolsForObjectFunc will call the provided function on the protocols for the object,
+// return nil-map if no protocols for the object, or return an error.
+type ProtocolsForObjectFunc func(object runtime.Object) (map[string]string, error)
+
+// ProtocolsForObjectFn gives a way to easily override the function for unit testing if needed
+var ProtocolsForObjectFn ProtocolsForObjectFunc = protocolsForObject
+
+// PortsForObjectFunc returns the ports associated with the provided object
+type PortsForObjectFunc func(object runtime.Object) ([]string, error)
+
+// PortsForObjectFn gives a way to easily override the function for unit testing if needed
+var PortsForObjectFn PortsForObjectFunc = portsForObject
+
+// CanBeAutoscaledFunc checks whether the kind of resources could be autoscaled
+type CanBeAutoscaledFunc func(kind schema.GroupKind) error
+
+// CanBeAutoscaledFn gives a way to easily override the function for unit testing if needed
+var CanBeAutoscaledFn CanBeAutoscaledFunc = canBeAutoscaled
+
+// CanBeExposedFunc is a function type that can tell you whether a given GroupKind is capable of being exposed
+type CanBeExposedFunc func(kind schema.GroupKind) error
+
+// CanBeExposedFn gives a way to easily override the function for unit testing if needed
+var CanBeExposedFn CanBeExposedFunc = canBeExposed
+
+// ObjectPauserFunc is a function type that marks the object in a given info as paused.
+type ObjectPauserFunc func(runtime.Object) ([]byte, error)
+
+// ObjectPauserFn gives a way to easily override the function for unit testing if needed.
+// Returns the patched object in bytes and any error that occurred during the encoding or
+// in case the object is already paused.
+var ObjectPauserFn ObjectPauserFunc = defaultObjectPauser
+
+// ObjectResumerFunc is a function type that marks the object in a given info as resumed.
+type ObjectResumerFunc func(runtime.Object) ([]byte, error)
+
+// ObjectResumerFn gives a way to easily override the function for unit testing if needed.
+// Returns the patched object in bytes and any error that occurred during the encoding or
+// in case the object is already resumed.
+var ObjectResumerFn ObjectResumerFunc = defaultObjectResumer
+
+// RollbackerFunc gives a way to change the rollback version of the specified RESTMapping type
+type RollbackerFunc func(restClientGetter genericclioptions.RESTClientGetter, mapping *meta.RESTMapping) (kubectl.Rollbacker, error)
+
+// RollbackerFn gives a way to easily override the function for unit testing if needed
+var RollbackerFn RollbackerFunc = rollbacker

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/logsforobject.go

@@ -0,0 +1,75 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"sort"
+	"time"
+
+	"k8s.io/api/core/v1"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/rest"
+	coreinternal "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions"
+)
+
+func logsForObject(restClientGetter genericclioptions.RESTClientGetter, object, options runtime.Object, timeout time.Duration) (*rest.Request, error) {
+	clientConfig, err := restClientGetter.ToRESTConfig()
+	if err != nil {
+		return nil, err
+	}
+	clientset, err := internalclientset.NewForConfig(clientConfig)
+	if err != nil {
+		return nil, err
+	}
+	return logsForObjectWithClient(clientset, object, options, timeout)
+}
+
+// this is split for easy test-ability
+func logsForObjectWithClient(clientset internalclientset.Interface, object, options runtime.Object, timeout time.Duration) (*rest.Request, error) {
+	opts, ok := options.(*coreinternal.PodLogOptions)
+	if !ok {
+		return nil, errors.New("provided options object is not a PodLogOptions")
+	}
+
+	switch t := object.(type) {
+	case *coreinternal.Pod:
+		return clientset.Core().Pods(t.Namespace).GetLogs(t.Name, opts), nil
+	case *corev1.Pod:
+		return clientset.Core().Pods(t.Namespace).GetLogs(t.Name, opts), nil
+	}
+
+	namespace, selector, err := SelectorsForObject(object)
+	if err != nil {
+		return nil, fmt.Errorf("cannot get the logs from %T: %v", object, err)
+	}
+	sortBy := func(pods []*v1.Pod) sort.Interface { return controller.ByLogging(pods) }
+	pod, numPods, err := GetFirstPod(clientset.Core(), namespace, selector.String(), timeout, sortBy)
+	if err != nil {
+		return nil, err
+	}
+	if numPods > 1 {
+		fmt.Fprintf(os.Stderr, "Found %v pods, using pod/%v\n", numPods, pod.Name)
+	}
+	return clientset.Core().Pods(pod.Namespace).GetLogs(pod.Name, opts), nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/logsforobject_test.go

@@ -0,0 +1,176 @@
+/*
+Copyright 2017 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 polymorphichelpers
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/diff"
+	testclient "k8s.io/client-go/testing"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	"k8s.io/kubernetes/pkg/apis/batch"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake"
+)
+
+var (
+	podsResource = schema.GroupVersionResource{Resource: "pods"}
+	podsKind     = schema.GroupVersionKind{Kind: "Pod"}
+)
+
+func TestLogsForObject(t *testing.T) {
+	tests := []struct {
+		name    string
+		obj     runtime.Object
+		opts    *api.PodLogOptions
+		pods    []runtime.Object
+		actions []testclient.Action
+	}{
+		{
+			name: "pod logs",
+			obj: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "hello", Namespace: "test"},
+			},
+			pods: []runtime.Object{testPod()},
+			actions: []testclient.Action{
+				getLogsAction("test", nil),
+			},
+		},
+		{
+			name: "replication controller logs",
+			obj: &api.ReplicationController{
+				ObjectMeta: metav1.ObjectMeta{Name: "hello", Namespace: "test"},
+				Spec: api.ReplicationControllerSpec{
+					Selector: map[string]string{"foo": "bar"},
+				},
+			},
+			pods: []runtime.Object{testPod()},
+			actions: []testclient.Action{
+				testclient.NewListAction(podsResource, podsKind, "test", metav1.ListOptions{LabelSelector: "foo=bar"}),
+				getLogsAction("test", nil),
+			},
+		},
+		{
+			name: "replica set logs",
+			obj: &extensions.ReplicaSet{
+				ObjectMeta: metav1.ObjectMeta{Name: "hello", Namespace: "test"},
+				Spec: extensions.ReplicaSetSpec{
+					Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}},
+				},
+			},
+			pods: []runtime.Object{testPod()},
+			actions: []testclient.Action{
+				testclient.NewListAction(podsResource, podsKind, "test", metav1.ListOptions{LabelSelector: "foo=bar"}),
+				getLogsAction("test", nil),
+			},
+		},
+		{
+			name: "deployment logs",
+			obj: &extensions.Deployment{
+				ObjectMeta: metav1.ObjectMeta{Name: "hello", Namespace: "test"},
+				Spec: extensions.DeploymentSpec{
+					Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}},
+				},
+			},
+			pods: []runtime.Object{testPod()},
+			actions: []testclient.Action{
+				testclient.NewListAction(podsResource, podsKind, "test", metav1.ListOptions{LabelSelector: "foo=bar"}),
+				getLogsAction("test", nil),
+			},
+		},
+		{
+			name: "job logs",
+			obj: &batch.Job{
+				ObjectMeta: metav1.ObjectMeta{Name: "hello", Namespace: "test"},
+				Spec: batch.JobSpec{
+					Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}},
+				},
+			},
+			pods: []runtime.Object{testPod()},
+			actions: []testclient.Action{
+				testclient.NewListAction(podsResource, podsKind, "test", metav1.ListOptions{LabelSelector: "foo=bar"}),
+				getLogsAction("test", nil),
+			},
+		},
+		{
+			name: "stateful set logs",
+			obj: &apps.StatefulSet{
+				ObjectMeta: metav1.ObjectMeta{Name: "hello", Namespace: "test"},
+				Spec: apps.StatefulSetSpec{
+					Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}},
+				},
+			},
+			pods: []runtime.Object{testPod()},
+			actions: []testclient.Action{
+				testclient.NewListAction(podsResource, podsKind, "test", metav1.ListOptions{LabelSelector: "foo=bar"}),
+				getLogsAction("test", nil),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		fakeClientset := fake.NewSimpleClientset(test.pods...)
+		_, err := logsForObjectWithClient(fakeClientset, test.obj, test.opts, 20*time.Second)
+		if err != nil {
+			t.Errorf("%s: unexpected error: %v", test.name, err)
+			continue
+		}
+		for i := range test.actions {
+			if len(fakeClientset.Actions()) < i {
+				t.Errorf("%s: action %d does not exists in actual actions: %#v",
+					test.name, i, fakeClientset.Actions())
+				continue
+			}
+			got := fakeClientset.Actions()[i]
+			want := test.actions[i]
+			if !reflect.DeepEqual(got, want) {
+				t.Errorf("%s: unexpected action: %s", test.name, diff.ObjectDiff(got, want))
+			}
+		}
+	}
+}
+
+func testPod() runtime.Object {
+	return &api.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "foo",
+			Namespace: "test",
+			Labels:    map[string]string{"foo": "bar"},
+		},
+		Spec: api.PodSpec{
+			RestartPolicy: api.RestartPolicyAlways,
+			DNSPolicy:     api.DNSClusterFirst,
+			Containers:    []api.Container{{Name: "c1"}},
+		},
+	}
+}
+
+func getLogsAction(namespace string, opts *api.PodLogOptions) testclient.Action {
+	action := testclient.GenericActionImpl{}
+	action.Verb = "get"
+	action.Namespace = namespace
+	action.Resource = podsResource
+	action.Subresource = "logs"
+	action.Value = opts
+	return action
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/mapbasedselectorforobject.go

@@ -0,0 +1,63 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/kubectl"
+)
+
+// mapBasedSelectorForObject returns the map-based selector associated with the provided object. If a
+// new set-based selector is provided, an error is returned if the selector cannot be converted to a
+// map-based selector
+func mapBasedSelectorForObject(object runtime.Object) (string, error) {
+	// TODO: replace with a swagger schema based approach (identify pod selector via schema introspection)
+	switch t := object.(type) {
+	case *api.ReplicationController:
+		return kubectl.MakeLabels(t.Spec.Selector), nil
+	case *api.Pod:
+		if len(t.Labels) == 0 {
+			return "", fmt.Errorf("the pod has no labels and cannot be exposed")
+		}
+		return kubectl.MakeLabels(t.Labels), nil
+	case *api.Service:
+		if t.Spec.Selector == nil {
+			return "", fmt.Errorf("the service has no pod selector set")
+		}
+		return kubectl.MakeLabels(t.Spec.Selector), nil
+	case *extensions.Deployment:
+		// TODO(madhusudancs): Make this smarter by admitting MatchExpressions with Equals
+		// operator, DoubleEquals operator and In operator with only one element in the set.
+		if len(t.Spec.Selector.MatchExpressions) > 0 {
+			return "", fmt.Errorf("couldn't convert expressions - \"%+v\" to map-based selector format", t.Spec.Selector.MatchExpressions)
+		}
+		return kubectl.MakeLabels(t.Spec.Selector.MatchLabels), nil
+	case *extensions.ReplicaSet:
+		// TODO(madhusudancs): Make this smarter by admitting MatchExpressions with Equals
+		// operator, DoubleEquals operator and In operator with only one element in the set.
+		if len(t.Spec.Selector.MatchExpressions) > 0 {
+			return "", fmt.Errorf("couldn't convert expressions - \"%+v\" to map-based selector format", t.Spec.Selector.MatchExpressions)
+		}
+		return kubectl.MakeLabels(t.Spec.Selector.MatchLabels), nil
+	default:
+		return "", fmt.Errorf("cannot extract pod selector from %T", object)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/objectpauser.go

@@ -0,0 +1,46 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"errors"
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+)
+
+// Currently only supports Deployments.
+func defaultObjectPauser(obj runtime.Object) ([]byte, error) {
+	switch obj := obj.(type) {
+	case *extensions.Deployment:
+		if obj.Spec.Paused {
+			return nil, errors.New("is already paused")
+		}
+		obj.Spec.Paused = true
+		return runtime.Encode(internalVersionJSONEncoder(), obj)
+	default:
+		return nil, fmt.Errorf("pausing is not supported")
+	}
+}
+
+func internalVersionJSONEncoder() runtime.Encoder {
+	encoder := legacyscheme.Codecs.LegacyCodec(legacyscheme.Scheme.PrioritizedVersionsAllGroups()...)
+	return unstructured.JSONFallbackEncoder{Encoder: encoder}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/objectresumer.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"errors"
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+)
+
+func defaultObjectResumer(obj runtime.Object) ([]byte, error) {
+	switch obj := obj.(type) {
+	case *extensions.Deployment:
+		if !obj.Spec.Paused {
+			return nil, errors.New("is not paused")
+		}
+		obj.Spec.Paused = false
+		return runtime.Encode(internalVersionJSONEncoder(), obj)
+	default:
+		return nil, fmt.Errorf("resuming is not supported")
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/portsforobject.go

@@ -0,0 +1,62 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"fmt"
+	"strconv"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+)
+
+func portsForObject(object runtime.Object) ([]string, error) {
+	switch t := object.(type) {
+	case *api.ReplicationController:
+		return getPorts(t.Spec.Template.Spec), nil
+	case *api.Pod:
+		return getPorts(t.Spec), nil
+	case *api.Service:
+		return getServicePorts(t.Spec), nil
+	case *extensions.Deployment:
+		return getPorts(t.Spec.Template.Spec), nil
+	case *extensions.ReplicaSet:
+		return getPorts(t.Spec.Template.Spec), nil
+	default:
+		return nil, fmt.Errorf("cannot extract ports from %T", object)
+	}
+}
+
+func getPorts(spec api.PodSpec) []string {
+	result := []string{}
+	for _, container := range spec.Containers {
+		for _, port := range container.Ports {
+			result = append(result, strconv.Itoa(int(port.ContainerPort)))
+		}
+	}
+	return result
+}
+
+// Extracts the ports exposed by a service from the given service spec.
+func getServicePorts(spec api.ServiceSpec) []string {
+	result := []string{}
+	for _, servicePort := range spec.Ports {
+		result = append(result, strconv.Itoa(int(servicePort.Port)))
+	}
+	return result
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/portsforobject_test.go

@@ -0,0 +1,54 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/sets"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+func TestPortsForObject(t *testing.T) {
+	pod := &api.Pod{
+		ObjectMeta: metav1.ObjectMeta{Name: "baz", Namespace: "test", ResourceVersion: "12"},
+		Spec: api.PodSpec{
+			Containers: []api.Container{
+				{
+					Ports: []api.ContainerPort{
+						{
+							ContainerPort: 101,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	expected := sets.NewString("101")
+	ports, err := portsForObject(pod)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+
+	got := sets.NewString(ports...)
+
+	if !expected.Equal(got) {
+		t.Fatalf("Ports mismatch! Expected %v, got %v", expected, got)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/protocolsforobject.go

@@ -0,0 +1,63 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"fmt"
+	"strconv"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+)
+
+func protocolsForObject(object runtime.Object) (map[string]string, error) {
+	// TODO: replace with a swagger schema based approach (identify pod selector via schema introspection)
+	switch t := object.(type) {
+	case *api.ReplicationController:
+		return getProtocols(t.Spec.Template.Spec), nil
+	case *api.Pod:
+		return getProtocols(t.Spec), nil
+	case *api.Service:
+		return getServiceProtocols(t.Spec), nil
+	case *extensions.Deployment:
+		return getProtocols(t.Spec.Template.Spec), nil
+	case *extensions.ReplicaSet:
+		return getProtocols(t.Spec.Template.Spec), nil
+	default:
+		return nil, fmt.Errorf("cannot extract protocols from %T", object)
+	}
+}
+
+func getProtocols(spec api.PodSpec) map[string]string {
+	result := make(map[string]string)
+	for _, container := range spec.Containers {
+		for _, port := range container.Ports {
+			result[strconv.Itoa(int(port.ContainerPort))] = string(port.Protocol)
+		}
+	}
+	return result
+}
+
+// Extracts the protocols exposed by a service from the given service spec.
+func getServiceProtocols(spec api.ServiceSpec) map[string]string {
+	result := make(map[string]string)
+	for _, servicePort := range spec.Ports {
+		result[strconv.Itoa(int(servicePort.Port))] = string(servicePort.Protocol)
+	}
+	return result
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/rollbacker.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions"
+)
+
+// Returns a Rollbacker for changing the rollback version of the specified RESTMapping type or an error
+func rollbacker(restClientGetter genericclioptions.RESTClientGetter, mapping *meta.RESTMapping) (kubectl.Rollbacker, error) {
+	clientConfig, err := restClientGetter.ToRESTConfig()
+	if err != nil {
+		return nil, err
+	}
+	external, err := kubernetes.NewForConfig(clientConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	return kubectl.RollbackerFor(mapping.GroupVersionKind.GroupKind(), external)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/statusviewer.go

@@ -0,0 +1,37 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions"
+)
+
+// statusViewer returns a StatusViewer for printing rollout status.
+func statusViewer(restClientGetter genericclioptions.RESTClientGetter, mapping *meta.RESTMapping) (kubectl.StatusViewer, error) {
+	clientConfig, err := restClientGetter.ToRESTConfig()
+	if err != nil {
+		return nil, err
+	}
+	clientset, err := kubernetes.NewForConfig(clientConfig)
+	if err != nil {
+		return nil, err
+	}
+	return kubectl.StatusViewerFor(mapping.GroupVersionKind.GroupKind(), clientset)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/polymorphichelpers/updatepodspec.go

@@ -0,0 +1,91 @@
+/*
+Copyright 2018 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 polymorphichelpers
+
+import (
+	"fmt"
+
+	appsv1 "k8s.io/api/apps/v1"
+	appsv1beta1 "k8s.io/api/apps/v1beta1"
+	appsv1beta2 "k8s.io/api/apps/v1beta2"
+	batchv1 "k8s.io/api/batch/v1"
+	batchv1beta1 "k8s.io/api/batch/v1beta1"
+	batchv2alpha1 "k8s.io/api/batch/v2alpha1"
+	"k8s.io/api/core/v1"
+	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+func updatePodSpecForObject(obj runtime.Object, fn func(*v1.PodSpec) error) (bool, error) {
+	switch t := obj.(type) {
+	case *v1.Pod:
+		return true, fn(&t.Spec)
+		// ReplicationController
+	case *v1.ReplicationController:
+		if t.Spec.Template == nil {
+			t.Spec.Template = &v1.PodTemplateSpec{}
+		}
+		return true, fn(&t.Spec.Template.Spec)
+
+		// Deployment
+	case *extensionsv1beta1.Deployment:
+		return true, fn(&t.Spec.Template.Spec)
+	case *appsv1beta1.Deployment:
+		return true, fn(&t.Spec.Template.Spec)
+	case *appsv1beta2.Deployment:
+		return true, fn(&t.Spec.Template.Spec)
+	case *appsv1.Deployment:
+		return true, fn(&t.Spec.Template.Spec)
+
+		// DaemonSet
+	case *extensionsv1beta1.DaemonSet:
+		return true, fn(&t.Spec.Template.Spec)
+	case *appsv1beta2.DaemonSet:
+		return true, fn(&t.Spec.Template.Spec)
+	case *appsv1.DaemonSet:
+		return true, fn(&t.Spec.Template.Spec)
+
+		// ReplicaSet
+	case *extensionsv1beta1.ReplicaSet:
+		return true, fn(&t.Spec.Template.Spec)
+	case *appsv1beta2.ReplicaSet:
+		return true, fn(&t.Spec.Template.Spec)
+	case *appsv1.ReplicaSet:
+		return true, fn(&t.Spec.Template.Spec)
+
+		// StatefulSet
+	case *appsv1beta1.StatefulSet:
+		return true, fn(&t.Spec.Template.Spec)
+	case *appsv1beta2.StatefulSet:
+		return true, fn(&t.Spec.Template.Spec)
+	case *appsv1.StatefulSet:
+		return true, fn(&t.Spec.Template.Spec)
+
+		// Job
+	case *batchv1.Job:
+		return true, fn(&t.Spec.Template.Spec)
+
+		// CronJob
+	case *batchv1beta1.CronJob:
+		return true, fn(&t.Spec.JobTemplate.Spec.Template.Spec)
+	case *batchv2alpha1.CronJob:
+		return true, fn(&t.Spec.JobTemplate.Spec.Template.Spec)
+
+	default:
+		return false, fmt.Errorf("the object is not a pod or does not have a pod template: %T", t)
+	}
+}