Replace godep with dep

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/BUILD

@@ -0,0 +1,152 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cached_discovery.go",
+        "clientcache.go",
+        "factory.go",
+        "factory_builder.go",
+        "factory_client_access.go",
+        "factory_object_mapping.go",
+        "helpers.go",
+        "printing.go",
+        "shortcut_restmapper.go",
+    ],
+    visibility = [
+        "//build/visible_to:pkg_kubectl_cmd_util_CONSUMERS",
+    ],
+    deps = [
+        "//federation/apis/federation:go_default_library",
+        "//federation/client/clientset_generated/federation_clientset:go_default_library",
+        "//pkg/api:go_default_library",
+        "//pkg/api/v1: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:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/typed/core/internalversion:go_default_library",
+        "//pkg/client/unversioned:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/kubectl:go_default_library",
+        "//pkg/kubectl/cmd/util/openapi:go_default_library",
+        "//pkg/kubectl/cmd/util/openapi/validation:go_default_library",
+        "//pkg/kubectl/plugins:go_default_library",
+        "//pkg/kubectl/resource:go_default_library",
+        "//pkg/kubectl/validation:go_default_library",
+        "//pkg/printers:go_default_library",
+        "//pkg/printers/internalversion:go_default_library",
+        "//pkg/version:go_default_library",
+        "//vendor/github.com/emicklei/go-restful-swagger12:go_default_library",
+        "//vendor/github.com/evanphx/json-patch:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/github.com/googleapis/gnostic/OpenAPIv2:go_default_library",
+        "//vendor/github.com/spf13/cobra:go_default_library",
+        "//vendor/github.com/spf13/pflag:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors: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/runtime/serializer/json:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/json:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/strategicpatch:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/yaml:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/version:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/flag:go_default_library",
+        "//vendor/k8s.io/client-go/discovery:go_default_library",
+        "//vendor/k8s.io/client-go/dynamic:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/tools/clientcmd:go_default_library",
+        "//vendor/k8s.io/client-go/util/homedir:go_default_library",
+        "//vendor/k8s.io/utils/exec:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "cached_discovery_test.go",
+        "factory_object_mapping_test.go",
+        "factory_test.go",
+        "helpers_test.go",
+        "shortcut_restmapper_test.go",
+    ],
+    data = [
+        "//api/swagger-spec",
+    ],
+    library = ":go_default_library",
+    visibility = [
+        "//build/visible_to:COMMON_testing",
+    ],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/testapi:go_default_library",
+        "//pkg/api/testing: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:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/fake:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/kubectl:go_default_library",
+        "//pkg/kubectl/resource:go_default_library",
+        "//pkg/kubectl/validation:go_default_library",
+        "//vendor/github.com/emicklei/go-restful-swagger12:go_default_library",
+        "//vendor/github.com/googleapis/gnostic/OpenAPIv2:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert: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/api/errors: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/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/util/validation/field:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/version:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/flag:go_default_library",
+        "//vendor/k8s.io/client-go/discovery:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/rest/fake:go_default_library",
+        "//vendor/k8s.io/client-go/testing:go_default_library",
+        "//vendor/k8s.io/client-go/tools/clientcmd:go_default_library",
+        "//vendor/k8s.io/client-go/tools/clientcmd/api:go_default_library",
+        "//vendor/k8s.io/utils/exec:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/kubectl/cmd/util/editor:all-srcs",
+        "//pkg/kubectl/cmd/util/env:all-srcs",
+        "//pkg/kubectl/cmd/util/jsonmerge:all-srcs",
+        "//pkg/kubectl/cmd/util/openapi:all-srcs",
+        "//pkg/kubectl/cmd/util/sanity:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//build/visible_to:pkg_kubectl_cmd_util_CONSUMERS"],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/cached_discovery.go

@@ -0,0 +1,269 @@
+/*
+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 util
+
+import (
+	"errors"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/emicklei/go-restful-swagger12"
+	"github.com/golang/glog"
+	"github.com/googleapis/gnostic/OpenAPIv2"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/version"
+	"k8s.io/client-go/discovery"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/kubernetes/pkg/api"
+)
+
+// CachedDiscoveryClient implements the functions that discovery server-supported API groups,
+// versions and resources.
+type CachedDiscoveryClient struct {
+	delegate discovery.DiscoveryInterface
+
+	// cacheDirectory is the directory where discovery docs are held.  It must be unique per host:port combination to work well.
+	cacheDirectory string
+
+	// ttl is how long the cache should be considered valid
+	ttl time.Duration
+
+	// mutex protects the variables below
+	mutex sync.Mutex
+
+	// ourFiles are all filenames of cache files created by this process
+	ourFiles map[string]struct{}
+	// invalidated is true if all cache files should be ignored that are not ours (e.g. after Invalidate() was called)
+	invalidated bool
+	// fresh is true if all used cache files were ours
+	fresh bool
+}
+
+var _ discovery.CachedDiscoveryInterface = &CachedDiscoveryClient{}
+
+// ServerResourcesForGroupVersion returns the supported resources for a group and version.
+func (d *CachedDiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
+	filename := filepath.Join(d.cacheDirectory, groupVersion, "serverresources.json")
+	cachedBytes, err := d.getCachedFile(filename)
+	// don't fail on errors, we either don't have a file or won't be able to run the cached check. Either way we can fallback.
+	if err == nil {
+		cachedResources := &metav1.APIResourceList{}
+		if err := runtime.DecodeInto(api.Codecs.UniversalDecoder(), cachedBytes, cachedResources); err == nil {
+			glog.V(6).Infof("returning cached discovery info from %v", filename)
+			return cachedResources, nil
+		}
+	}
+
+	liveResources, err := d.delegate.ServerResourcesForGroupVersion(groupVersion)
+	if err != nil {
+		glog.V(3).Infof("skipped caching discovery info due to %v", err)
+		return liveResources, err
+	}
+	if liveResources == nil || len(liveResources.APIResources) == 0 {
+		glog.V(3).Infof("skipped caching discovery info, no resources found")
+		return liveResources, err
+	}
+
+	if err := d.writeCachedFile(filename, liveResources); err != nil {
+		glog.V(3).Infof("failed to write cache to %v due to %v", filename, err)
+	}
+
+	return liveResources, nil
+}
+
+// ServerResources returns the supported resources for all groups and versions.
+func (d *CachedDiscoveryClient) ServerResources() ([]*metav1.APIResourceList, error) {
+	apiGroups, err := d.ServerGroups()
+	if err != nil {
+		return nil, err
+	}
+	groupVersions := metav1.ExtractGroupVersions(apiGroups)
+	result := []*metav1.APIResourceList{}
+	for _, groupVersion := range groupVersions {
+		resources, err := d.ServerResourcesForGroupVersion(groupVersion)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, resources)
+	}
+	return result, nil
+}
+
+func (d *CachedDiscoveryClient) ServerGroups() (*metav1.APIGroupList, error) {
+	filename := filepath.Join(d.cacheDirectory, "servergroups.json")
+	cachedBytes, err := d.getCachedFile(filename)
+	// don't fail on errors, we either don't have a file or won't be able to run the cached check. Either way we can fallback.
+	if err == nil {
+		cachedGroups := &metav1.APIGroupList{}
+		if err := runtime.DecodeInto(api.Codecs.UniversalDecoder(), cachedBytes, cachedGroups); err == nil {
+			glog.V(6).Infof("returning cached discovery info from %v", filename)
+			return cachedGroups, nil
+		}
+	}
+
+	liveGroups, err := d.delegate.ServerGroups()
+	if err != nil {
+		glog.V(3).Infof("skipped caching discovery info due to %v", err)
+		return liveGroups, err
+	}
+	if liveGroups == nil || len(liveGroups.Groups) == 0 {
+		glog.V(3).Infof("skipped caching discovery info, no groups found")
+		return liveGroups, err
+	}
+
+	if err := d.writeCachedFile(filename, liveGroups); err != nil {
+		glog.V(3).Infof("failed to write cache to %v due to %v", filename, err)
+	}
+
+	return liveGroups, nil
+}
+
+func (d *CachedDiscoveryClient) getCachedFile(filename string) ([]byte, error) {
+	// after invalidation ignore cache files not created by this process
+	d.mutex.Lock()
+	_, ourFile := d.ourFiles[filename]
+	if d.invalidated && !ourFile {
+		d.mutex.Unlock()
+		return nil, errors.New("cache invalidated")
+	}
+	d.mutex.Unlock()
+
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	fileInfo, err := file.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	if time.Now().After(fileInfo.ModTime().Add(d.ttl)) {
+		return nil, errors.New("cache expired")
+	}
+
+	// the cache is present and its valid.  Try to read and use it.
+	cachedBytes, err := ioutil.ReadAll(file)
+	if err != nil {
+		return nil, err
+	}
+
+	d.mutex.Lock()
+	defer d.mutex.Unlock()
+	d.fresh = d.fresh && ourFile
+
+	return cachedBytes, nil
+}
+
+func (d *CachedDiscoveryClient) writeCachedFile(filename string, obj runtime.Object) error {
+	if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil {
+		return err
+	}
+
+	bytes, err := runtime.Encode(api.Codecs.LegacyCodec(), obj)
+	if err != nil {
+		return err
+	}
+
+	f, err := ioutil.TempFile(filepath.Dir(filename), filepath.Base(filename)+".")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(f.Name())
+	_, err = f.Write(bytes)
+	if err != nil {
+		return err
+	}
+
+	err = os.Chmod(f.Name(), 0755)
+	if err != nil {
+		return err
+	}
+
+	name := f.Name()
+	err = f.Close()
+	if err != nil {
+		return err
+	}
+
+	// atomic rename
+	d.mutex.Lock()
+	defer d.mutex.Unlock()
+	err = os.Rename(name, filename)
+	if err == nil {
+		d.ourFiles[filename] = struct{}{}
+	}
+	return err
+}
+
+func (d *CachedDiscoveryClient) RESTClient() restclient.Interface {
+	return d.delegate.RESTClient()
+}
+
+func (d *CachedDiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
+	return d.delegate.ServerPreferredResources()
+}
+
+func (d *CachedDiscoveryClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
+	return d.delegate.ServerPreferredNamespacedResources()
+}
+
+func (d *CachedDiscoveryClient) ServerVersion() (*version.Info, error) {
+	return d.delegate.ServerVersion()
+}
+
+func (d *CachedDiscoveryClient) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
+	return d.delegate.SwaggerSchema(version)
+}
+
+func (d *CachedDiscoveryClient) OpenAPISchema() (*openapi_v2.Document, error) {
+	return d.delegate.OpenAPISchema()
+}
+
+func (d *CachedDiscoveryClient) Fresh() bool {
+	d.mutex.Lock()
+	defer d.mutex.Unlock()
+
+	return d.fresh
+}
+
+func (d *CachedDiscoveryClient) Invalidate() {
+	d.mutex.Lock()
+	defer d.mutex.Unlock()
+
+	d.ourFiles = map[string]struct{}{}
+	d.fresh = true
+	d.invalidated = true
+}
+
+// NewCachedDiscoveryClient creates a new DiscoveryClient.  cacheDirectory is the directory where discovery docs are held.  It must be unique per host:port combination to work well.
+func NewCachedDiscoveryClient(delegate discovery.DiscoveryInterface, cacheDirectory string, ttl time.Duration) *CachedDiscoveryClient {
+	return &CachedDiscoveryClient{
+		delegate:       delegate,
+		cacheDirectory: cacheDirectory,
+		ttl:            ttl,
+		ourFiles:       map[string]struct{}{},
+		fresh:          true,
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/cached_discovery_test.go

@@ -0,0 +1,177 @@
+/*
+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 util
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/emicklei/go-restful-swagger12"
+	"github.com/googleapis/gnostic/OpenAPIv2"
+	"github.com/stretchr/testify/assert"
+
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/version"
+	"k8s.io/client-go/discovery"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/rest/fake"
+)
+
+func TestCachedDiscoveryClient_Fresh(t *testing.T) {
+	assert := assert.New(t)
+
+	d, err := ioutil.TempDir("", "")
+	assert.NoError(err)
+	defer os.RemoveAll(d)
+
+	c := fakeDiscoveryClient{}
+	cdc := NewCachedDiscoveryClient(&c, d, 60*time.Second)
+	assert.True(cdc.Fresh(), "should be fresh after creation")
+
+	cdc.ServerGroups()
+	assert.True(cdc.Fresh(), "should be fresh after groups call without cache")
+	assert.Equal(c.groupCalls, 1)
+
+	cdc.ServerGroups()
+	assert.True(cdc.Fresh(), "should be fresh after another groups call")
+	assert.Equal(c.groupCalls, 1)
+
+	cdc.ServerResources()
+	assert.True(cdc.Fresh(), "should be fresh after resources call")
+	assert.Equal(c.resourceCalls, 1)
+
+	cdc.ServerResources()
+	assert.True(cdc.Fresh(), "should be fresh after another resources call")
+	assert.Equal(c.resourceCalls, 1)
+
+	cdc = NewCachedDiscoveryClient(&c, d, 60*time.Second)
+	cdc.ServerGroups()
+	assert.False(cdc.Fresh(), "should NOT be fresh after recreation with existing groups cache")
+	assert.Equal(c.groupCalls, 1)
+
+	cdc.ServerResources()
+	assert.False(cdc.Fresh(), "should NOT be fresh after recreation with existing resources cache")
+	assert.Equal(c.resourceCalls, 1)
+
+	cdc.Invalidate()
+	assert.True(cdc.Fresh(), "should be fresh after cache invalidation")
+
+	cdc.ServerResources()
+	assert.True(cdc.Fresh(), "should ignore existing resources cache after invalidation")
+	assert.Equal(c.resourceCalls, 2)
+}
+
+func TestNewCachedDiscoveryClient_TTL(t *testing.T) {
+	assert := assert.New(t)
+
+	d, err := ioutil.TempDir("", "")
+	assert.NoError(err)
+	defer os.RemoveAll(d)
+
+	c := fakeDiscoveryClient{}
+	cdc := NewCachedDiscoveryClient(&c, d, 1*time.Nanosecond)
+	cdc.ServerGroups()
+	assert.Equal(c.groupCalls, 1)
+
+	time.Sleep(1 * time.Second)
+
+	cdc.ServerGroups()
+	assert.Equal(c.groupCalls, 2)
+}
+
+type fakeDiscoveryClient struct {
+	groupCalls    int
+	resourceCalls int
+	versionCalls  int
+	swaggerCalls  int
+	openAPICalls  int
+
+	serverResourcesHandler func() ([]*metav1.APIResourceList, error)
+}
+
+var _ discovery.DiscoveryInterface = &fakeDiscoveryClient{}
+
+func (c *fakeDiscoveryClient) RESTClient() restclient.Interface {
+	return &fake.RESTClient{}
+}
+
+func (c *fakeDiscoveryClient) ServerGroups() (*metav1.APIGroupList, error) {
+	c.groupCalls = c.groupCalls + 1
+	return &metav1.APIGroupList{
+		Groups: []metav1.APIGroup{
+			{
+				Name: "a",
+				Versions: []metav1.GroupVersionForDiscovery{
+					{
+						GroupVersion: "a/v1",
+						Version:      "v1",
+					},
+				},
+				PreferredVersion: metav1.GroupVersionForDiscovery{
+					GroupVersion: "a/v1",
+					Version:      "v1",
+				},
+			},
+		},
+	}, nil
+}
+
+func (c *fakeDiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
+	c.resourceCalls = c.resourceCalls + 1
+	if groupVersion == "a/v1" {
+		return &metav1.APIResourceList{APIResources: []metav1.APIResource{{Name: "widgets", Kind: "Widget"}}}, nil
+	}
+
+	return nil, errors.NewNotFound(schema.GroupResource{}, "")
+}
+
+func (c *fakeDiscoveryClient) ServerResources() ([]*metav1.APIResourceList, error) {
+	c.resourceCalls = c.resourceCalls + 1
+	if c.serverResourcesHandler != nil {
+		return c.serverResourcesHandler()
+	}
+	return []*metav1.APIResourceList{}, nil
+}
+
+func (c *fakeDiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
+	c.resourceCalls = c.resourceCalls + 1
+	return nil, nil
+}
+
+func (c *fakeDiscoveryClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
+	c.resourceCalls = c.resourceCalls + 1
+	return nil, nil
+}
+
+func (c *fakeDiscoveryClient) ServerVersion() (*version.Info, error) {
+	c.versionCalls = c.versionCalls + 1
+	return &version.Info{}, nil
+}
+
+func (c *fakeDiscoveryClient) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
+	c.swaggerCalls = c.swaggerCalls + 1
+	return &swagger.ApiDeclaration{}, nil
+}
+
+func (c *fakeDiscoveryClient) OpenAPISchema() (*openapi_v2.Document, error) {
+	c.openAPICalls = c.openAPICalls + 1
+	return &openapi_v2.Document{}, nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/clientcache.go

@@ -0,0 +1,261 @@
+/*
+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 util
+
+import (
+	"sync"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/discovery"
+	"k8s.io/client-go/kubernetes"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+	fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_clientset"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	oldclient "k8s.io/kubernetes/pkg/client/unversioned"
+	"k8s.io/kubernetes/pkg/version"
+)
+
+func NewClientCache(loader clientcmd.ClientConfig, discoveryClientFactory DiscoveryClientFactory) *ClientCache {
+	return &ClientCache{
+		clientsets:             make(map[schema.GroupVersion]internalclientset.Interface),
+		configs:                make(map[schema.GroupVersion]*restclient.Config),
+		fedClientSets:          make(map[schema.GroupVersion]fedclientset.Interface),
+		loader:                 loader,
+		discoveryClientFactory: discoveryClientFactory,
+	}
+}
+
+// ClientCache caches previously loaded clients for reuse, and ensures MatchServerVersion
+// is invoked only once
+type ClientCache struct {
+	loader        clientcmd.ClientConfig
+	clientsets    map[schema.GroupVersion]internalclientset.Interface
+	fedClientSets map[schema.GroupVersion]fedclientset.Interface
+	configs       map[schema.GroupVersion]*restclient.Config
+
+	// noVersionConfig provides a cached config for the case of no required version specified
+	noVersionConfig *restclient.Config
+
+	matchVersion bool
+
+	lock          sync.Mutex
+	defaultConfig *restclient.Config
+	// discoveryClientFactory comes as a factory method so that we can defer resolution until after
+	// argument evaluation
+	discoveryClientFactory DiscoveryClientFactory
+	discoveryClient        discovery.DiscoveryInterface
+
+	kubernetesClientCache kubernetesClientCache
+}
+
+// kubernetesClientCache creates a new kubernetes.Clientset one time
+// and then returns the result for all future requests
+type kubernetesClientCache struct {
+	// once makes sure the client is only initialized once
+	once sync.Once
+	// client is the cached client value
+	client *kubernetes.Clientset
+	// err is the cached error value
+	err error
+}
+
+// KubernetesClientSetForVersion returns a new kubernetes.Clientset.  It will cache the value
+// the first time it is called and return the cached value on subsequent calls.
+// If an error is encountered the first time KubernetesClientSetForVersion is called,
+// the error will be cached.
+func (c *ClientCache) KubernetesClientSetForVersion(requiredVersion *schema.GroupVersion) (*kubernetes.Clientset, error) {
+	c.kubernetesClientCache.once.Do(func() {
+		config, err := c.ClientConfigForVersion(requiredVersion)
+		if err != nil {
+			c.kubernetesClientCache.err = err
+			return
+		}
+		c.kubernetesClientCache.client, c.kubernetesClientCache.err = kubernetes.NewForConfig(config)
+	})
+	return c.kubernetesClientCache.client, c.kubernetesClientCache.err
+}
+
+// also looks up the discovery client.  We can't do this during init because the flags won't have been set
+// because this is constructed pre-command execution before the command tree is
+// even set up. Requires the lock to already be acquired
+func (c *ClientCache) getDefaultConfig() (restclient.Config, discovery.DiscoveryInterface, error) {
+	if c.defaultConfig != nil && c.discoveryClient != nil {
+		return *c.defaultConfig, c.discoveryClient, nil
+	}
+
+	config, err := c.loader.ClientConfig()
+	if err != nil {
+		return restclient.Config{}, nil, err
+	}
+	discoveryClient, err := c.discoveryClientFactory.DiscoveryClient()
+	if err != nil {
+		return restclient.Config{}, nil, err
+	}
+	if c.matchVersion {
+		if err := discovery.MatchesServerVersion(version.Get(), discoveryClient); err != nil {
+			return restclient.Config{}, nil, err
+		}
+	}
+
+	c.defaultConfig = config
+	c.discoveryClient = discoveryClient
+	return *c.defaultConfig, c.discoveryClient, nil
+}
+
+// ClientConfigForVersion returns the correct config for a server
+func (c *ClientCache) ClientConfigForVersion(requiredVersion *schema.GroupVersion) (*restclient.Config, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	return c.clientConfigForVersion(requiredVersion)
+}
+
+// clientConfigForVersion returns the correct config for a server
+func (c *ClientCache) clientConfigForVersion(requiredVersion *schema.GroupVersion) (*restclient.Config, error) {
+	// only lookup in the cache if the requiredVersion is set
+	if requiredVersion != nil {
+		if config, ok := c.configs[*requiredVersion]; ok {
+			return copyConfig(config), nil
+		}
+	} else if c.noVersionConfig != nil {
+		return copyConfig(c.noVersionConfig), nil
+	}
+
+	// this returns a shallow copy to work with
+	config, discoveryClient, err := c.getDefaultConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	if requiredVersion != nil {
+		if err := discovery.ServerSupportsVersion(discoveryClient, *requiredVersion); err != nil {
+			return nil, err
+		}
+		config.GroupVersion = requiredVersion
+	} else {
+		// TODO remove this hack.  This is allowing the GetOptions to be serialized.
+		config.GroupVersion = &schema.GroupVersion{Group: "", Version: "v1"}
+	}
+
+	// TODO this isn't what we want.  Each clientset should be setting defaults as it sees fit.
+	oldclient.SetKubernetesDefaults(&config)
+
+	if requiredVersion != nil {
+		c.configs[*requiredVersion] = copyConfig(&config)
+	} else {
+		c.noVersionConfig = copyConfig(&config)
+	}
+
+	// `version` does not necessarily equal `config.Version`.  However, we know that we call this method again with
+	// `config.Version`, we should get the config we've just built.
+	c.configs[*config.GroupVersion] = copyConfig(&config)
+
+	return copyConfig(&config), nil
+}
+
+func copyConfig(in *restclient.Config) *restclient.Config {
+	configCopy := *in
+	copyGroupVersion := *configCopy.GroupVersion
+	configCopy.GroupVersion = &copyGroupVersion
+	return &configCopy
+}
+
+// ClientSetForVersion initializes or reuses a clientset for the specified version, or returns an
+// error if that is not possible
+func (c *ClientCache) ClientSetForVersion(requiredVersion *schema.GroupVersion) (internalclientset.Interface, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	if requiredVersion != nil {
+		if clientset, ok := c.clientsets[*requiredVersion]; ok {
+			return clientset, nil
+		}
+	}
+	config, err := c.clientConfigForVersion(requiredVersion)
+	if err != nil {
+		return nil, err
+	}
+
+	clientset, err := internalclientset.NewForConfig(config)
+	if err != nil {
+		return nil, err
+	}
+	c.clientsets[*config.GroupVersion] = clientset
+
+	// `version` does not necessarily equal `config.Version`.  However, we know that if we call this method again with
+	// `version`, we should get a client based on the same config we just found.  There's no guarantee that a client
+	// is copiable, so create a new client and save it in the cache.
+	if requiredVersion != nil {
+		configCopy := *config
+		clientset, err := internalclientset.NewForConfig(&configCopy)
+		if err != nil {
+			return nil, err
+		}
+		c.clientsets[*requiredVersion] = clientset
+	}
+
+	return clientset, nil
+}
+
+func (c *ClientCache) FederationClientSetForVersion(version *schema.GroupVersion) (fedclientset.Interface, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	return c.federationClientSetForVersion(version)
+}
+
+func (c *ClientCache) federationClientSetForVersion(version *schema.GroupVersion) (fedclientset.Interface, error) {
+	if version != nil {
+		if clientSet, found := c.fedClientSets[*version]; found {
+			return clientSet, nil
+		}
+	}
+	config, err := c.clientConfigForVersion(version)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: support multi versions of client with clientset
+	clientSet, err := fedclientset.NewForConfig(config)
+	if err != nil {
+		return nil, err
+	}
+	c.fedClientSets[*config.GroupVersion] = clientSet
+
+	if version != nil {
+		configCopy := *config
+		clientSet, err := fedclientset.NewForConfig(&configCopy)
+		if err != nil {
+			return nil, err
+		}
+		c.fedClientSets[*version] = clientSet
+	}
+
+	return clientSet, nil
+}
+
+func (c *ClientCache) FederationClientForVersion(version *schema.GroupVersion) (*restclient.RESTClient, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	fedClientSet, err := c.federationClientSetForVersion(version)
+	if err != nil {
+		return nil, err
+	}
+	return fedClientSet.Federation().RESTClient().(*restclient.RESTClient), nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/editor/BUILD

@@ -0,0 +1,59 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "editoptions.go",
+        "editor.go",
+    ],
+    visibility = [
+        "//build/visible_to:pkg_kubectl_cmd_util_editor_CONSUMERS",
+    ],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/kubectl:go_default_library",
+        "//pkg/kubectl/cmd/util:go_default_library",
+        "//pkg/kubectl/resource:go_default_library",
+        "//pkg/kubectl/util/crlf:go_default_library",
+        "//pkg/kubectl/util/term:go_default_library",
+        "//pkg/printers:go_default_library",
+        "//vendor/github.com/evanphx/json-patch:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/github.com/spf13/cobra:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured: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/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/mergepatch:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/strategicpatch:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/yaml:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["editor_test.go"],
+    library = ":go_default_library",
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = [
+        "//build/visible_to:pkg_kubectl_cmd_util_editor_CONSUMERS",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/editor/editoptions.go

@@ -0,0 +1,749 @@
+/*
+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 editor
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/evanphx/json-patch"
+	"github.com/golang/glog"
+	"github.com/spf13/cobra"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/mergepatch"
+	"k8s.io/apimachinery/pkg/util/strategicpatch"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	"k8s.io/apimachinery/pkg/util/yaml"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/kubectl"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/kubectl/util/crlf"
+	"k8s.io/kubernetes/pkg/printers"
+)
+
+// EditOptions contains all the options for running edit cli command.
+type EditOptions struct {
+	resource.FilenameOptions
+
+	Output             string
+	OutputPatch        bool
+	WindowsLineEndings bool
+
+	cmdutil.ValidateOptions
+
+	Mapper         meta.RESTMapper
+	ResourceMapper *resource.Mapper
+	OriginalResult *resource.Result
+	Encoder        runtime.Encoder
+
+	EditMode EditMode
+
+	CmdNamespace    string
+	ApplyAnnotation bool
+	Record          bool
+	ChangeCause     string
+	Include3rdParty bool
+
+	Out    io.Writer
+	ErrOut io.Writer
+
+	f                   cmdutil.Factory
+	editPrinterOptions  *editPrinterOptions
+	updatedResultGetter func(data []byte) *resource.Result
+}
+
+type editPrinterOptions struct {
+	printer   printers.ResourcePrinter
+	ext       string
+	addHeader bool
+}
+
+// Complete completes all the required options
+func (o *EditOptions) Complete(f cmdutil.Factory, out, errOut io.Writer, args []string, cmd *cobra.Command) error {
+	if o.EditMode != NormalEditMode && o.EditMode != EditBeforeCreateMode && o.EditMode != ApplyEditMode {
+		return fmt.Errorf("unsupported edit mode %q", o.EditMode)
+	}
+	if o.Output != "" {
+		if o.Output != "yaml" && o.Output != "json" {
+			return fmt.Errorf("invalid output format %s, only yaml|json supported", o.Output)
+		}
+	}
+	o.editPrinterOptions = getPrinter(o.Output)
+
+	if o.OutputPatch && o.EditMode != NormalEditMode {
+		return fmt.Errorf("the edit mode doesn't support output the patch")
+	}
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+	mapper, typer, err := f.UnstructuredObject()
+	if err != nil {
+		return err
+	}
+
+	b, err := f.NewUnstructuredBuilder(true)
+	if err != nil {
+		return err
+	}
+	if o.EditMode == NormalEditMode || o.EditMode == ApplyEditMode {
+		// when do normal edit or apply edit we need to always retrieve the latest resource from server
+		b = b.ResourceTypeOrNameArgs(true, args...).Latest()
+	}
+	includeUninitialized := cmdutil.ShouldIncludeUninitialized(cmd, false)
+	r := b.NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, &o.FilenameOptions).
+		IncludeUninitialized(includeUninitialized).
+		ContinueOnError().
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+	o.OriginalResult = r
+
+	o.updatedResultGetter = func(data []byte) *resource.Result {
+		// resource builder to read objects from edited data
+		return resource.NewBuilder(mapper, f.CategoryExpander(), typer, resource.ClientMapperFunc(f.UnstructuredClientForMapping), unstructured.UnstructuredJSONScheme).
+			Stream(bytes.NewReader(data), "edited-file").
+			IncludeUninitialized(includeUninitialized).
+			ContinueOnError().
+			Flatten().
+			Do()
+	}
+
+	o.Mapper = mapper
+	o.CmdNamespace = cmdNamespace
+	o.Encoder = f.JSONEncoder()
+	o.f = f
+
+	// Set up writer
+	o.Out = out
+	o.ErrOut = errOut
+
+	return nil
+}
+
+// Validate checks the EditOptions to see if there is sufficient information to run the command.
+func (o *EditOptions) Validate() error {
+	return nil
+}
+
+func (o *EditOptions) Run() error {
+	edit := NewDefaultEditor(o.f.EditorEnvs())
+	// editFn is invoked for each edit session (once with a list for normal edit, once for each individual resource in a edit-on-create invocation)
+	editFn := func(infos []*resource.Info) error {
+		var (
+			results  = editResults{}
+			original = []byte{}
+			edited   = []byte{}
+			file     string
+			err      error
+		)
+
+		containsError := false
+		// loop until we succeed or cancel editing
+		for {
+			// get the object we're going to serialize as input to the editor
+			var originalObj runtime.Object
+			switch len(infos) {
+			case 1:
+				originalObj = infos[0].Object
+			default:
+				l := &unstructured.UnstructuredList{
+					Object: map[string]interface{}{
+						"kind":       "List",
+						"apiVersion": "v1",
+						"metadata":   map[string]interface{}{},
+					},
+				}
+				for _, info := range infos {
+					l.Items = append(l.Items, *info.Object.(*unstructured.Unstructured))
+				}
+				originalObj = l
+			}
+
+			// generate the file to edit
+			buf := &bytes.Buffer{}
+			var w io.Writer = buf
+			if o.WindowsLineEndings {
+				w = crlf.NewCRLFWriter(w)
+			}
+
+			if o.editPrinterOptions.addHeader {
+				results.header.writeTo(w, o.EditMode)
+			}
+
+			if !containsError {
+				if err := o.editPrinterOptions.printer.PrintObj(originalObj, w); err != nil {
+					return preservedFile(err, results.file, o.ErrOut)
+				}
+				original = buf.Bytes()
+			} else {
+				// In case of an error, preserve the edited file.
+				// Remove the comments (header) from it since we already
+				// have included the latest header in the buffer above.
+				buf.Write(cmdutil.ManualStrip(edited))
+			}
+
+			// launch the editor
+			editedDiff := edited
+			edited, file, err = edit.LaunchTempFile(fmt.Sprintf("%s-edit-", filepath.Base(os.Args[0])), o.editPrinterOptions.ext, buf)
+			if err != nil {
+				return preservedFile(err, results.file, o.ErrOut)
+			}
+			// If we're retrying the loop because of an error, and no change was made in the file, short-circuit
+			if containsError && bytes.Equal(cmdutil.StripComments(editedDiff), cmdutil.StripComments(edited)) {
+				return preservedFile(fmt.Errorf("%s", "Edit cancelled, no valid changes were saved."), file, o.ErrOut)
+			}
+			// cleanup any file from the previous pass
+			if len(results.file) > 0 {
+				os.Remove(results.file)
+			}
+			glog.V(4).Infof("User edited:\n%s", string(edited))
+
+			// Apply validation
+			schema, err := o.f.Validator(o.EnableValidation, o.UseOpenAPI, o.SchemaCacheDir)
+			if err != nil {
+				return preservedFile(err, file, o.ErrOut)
+			}
+			err = schema.ValidateBytes(cmdutil.StripComments(edited))
+			if err != nil {
+				results = editResults{
+					file: file,
+				}
+				containsError = true
+				fmt.Fprintln(o.ErrOut, results.addError(apierrors.NewInvalid(api.Kind(""), "", field.ErrorList{field.Invalid(nil, "The edited file failed validation", fmt.Sprintf("%v", err))}), infos[0]))
+				continue
+			}
+
+			// Compare content without comments
+			if bytes.Equal(cmdutil.StripComments(original), cmdutil.StripComments(edited)) {
+				os.Remove(file)
+				fmt.Fprintln(o.ErrOut, "Edit cancelled, no changes made.")
+				return nil
+			}
+
+			lines, err := hasLines(bytes.NewBuffer(edited))
+			if err != nil {
+				return preservedFile(err, file, o.ErrOut)
+			}
+			if !lines {
+				os.Remove(file)
+				fmt.Fprintln(o.ErrOut, "Edit cancelled, saved file was empty.")
+				return nil
+			}
+
+			results = editResults{
+				file: file,
+			}
+
+			// parse the edited file
+			updatedInfos, err := o.updatedResultGetter(edited).Infos()
+			if err != nil {
+				// syntax error
+				containsError = true
+				results.header.reasons = append(results.header.reasons, editReason{head: fmt.Sprintf("The edited file had a syntax error: %v", err)})
+				continue
+			}
+			// not a syntax error as it turns out...
+			containsError = false
+			updatedVisitor := resource.InfoListVisitor(updatedInfos)
+
+			// need to make sure the original namespace wasn't changed while editing
+			if err := updatedVisitor.Visit(resource.RequireNamespace(o.CmdNamespace)); err != nil {
+				return preservedFile(err, file, o.ErrOut)
+			}
+
+			// iterate through all items to apply annotations
+			if err := o.visitAnnotation(updatedVisitor); err != nil {
+				return preservedFile(err, file, o.ErrOut)
+			}
+
+			switch o.EditMode {
+			case NormalEditMode:
+				err = o.visitToPatch(infos, updatedVisitor, &results)
+			case ApplyEditMode:
+				err = o.visitToApplyEditPatch(infos, updatedVisitor)
+			case EditBeforeCreateMode:
+				err = o.visitToCreate(updatedVisitor)
+			default:
+				err = fmt.Errorf("unsupported edit mode %q", o.EditMode)
+			}
+			if err != nil {
+				return preservedFile(err, results.file, o.ErrOut)
+			}
+
+			// Handle all possible errors
+			//
+			// 1. retryable: propose kubectl replace -f
+			// 2. notfound: indicate the location of the saved configuration of the deleted resource
+			// 3. invalid: retry those on the spot by looping ie. reloading the editor
+			if results.retryable > 0 {
+				fmt.Fprintf(o.ErrOut, "You can run `%s replace -f %s` to try this update again.\n", filepath.Base(os.Args[0]), file)
+				return cmdutil.ErrExit
+			}
+			if results.notfound > 0 {
+				fmt.Fprintf(o.ErrOut, "The edits you made on deleted resources have been saved to %q\n", file)
+				return cmdutil.ErrExit
+			}
+
+			if len(results.edit) == 0 {
+				if results.notfound == 0 {
+					os.Remove(file)
+				} else {
+					fmt.Fprintf(o.Out, "The edits you made on deleted resources have been saved to %q\n", file)
+				}
+				return nil
+			}
+
+			if len(results.header.reasons) > 0 {
+				containsError = true
+			}
+		}
+	}
+
+	switch o.EditMode {
+	// If doing normal edit we cannot use Visit because we need to edit a list for convenience. Ref: #20519
+	case NormalEditMode:
+		infos, err := o.OriginalResult.Infos()
+		if err != nil {
+			return err
+		}
+		if len(infos) == 0 {
+			return errors.New("edit cancelled, no objects found.")
+		}
+		return editFn(infos)
+	case ApplyEditMode:
+		infos, err := o.OriginalResult.Infos()
+		if err != nil {
+			return err
+		}
+		var annotationInfos []*resource.Info
+		for i := range infos {
+			data, err := kubectl.GetOriginalConfiguration(infos[i].Mapping, infos[i].Object)
+			if err != nil {
+				return err
+			}
+			if data == nil {
+				continue
+			}
+
+			tempInfos, err := o.updatedResultGetter(data).Infos()
+			if err != nil {
+				return err
+			}
+			annotationInfos = append(annotationInfos, tempInfos[0])
+		}
+		if len(annotationInfos) == 0 {
+			return errors.New("no last-applied-configuration annotation found on resources, to create the annotation, use command `kubectl apply set-last-applied --create-annotation`")
+		}
+		return editFn(annotationInfos)
+	// If doing an edit before created, we don't want a list and instead want the normal behavior as kubectl create.
+	case EditBeforeCreateMode:
+		return o.OriginalResult.Visit(func(info *resource.Info, err error) error {
+			return editFn([]*resource.Info{info})
+		})
+	default:
+		return fmt.Errorf("unsupported edit mode %q", o.EditMode)
+	}
+}
+
+func (o *EditOptions) visitToApplyEditPatch(originalInfos []*resource.Info, patchVisitor resource.Visitor) error {
+	err := patchVisitor.Visit(func(info *resource.Info, incomingErr error) error {
+		editObjUID, err := meta.NewAccessor().UID(info.Object)
+		if err != nil {
+			return err
+		}
+
+		var originalInfo *resource.Info
+		for _, i := range originalInfos {
+			originalObjUID, err := meta.NewAccessor().UID(i.Object)
+			if err != nil {
+				return err
+			}
+			if editObjUID == originalObjUID {
+				originalInfo = i
+				break
+			}
+		}
+		if originalInfo == nil {
+			return fmt.Errorf("no original object found for %#v", info.Object)
+		}
+
+		originalJS, err := encodeToJson(o.Encoder, originalInfo.Object)
+		if err != nil {
+			return err
+		}
+
+		editedJS, err := encodeToJson(o.Encoder, info.Object)
+		if err != nil {
+			return err
+		}
+
+		if reflect.DeepEqual(originalJS, editedJS) {
+			cmdutil.PrintSuccess(o.Mapper, false, o.Out, info.Mapping.Resource, info.Name, false, "skipped")
+			return nil
+		} else {
+			err := o.annotationPatch(info)
+			if err != nil {
+				return err
+			}
+			cmdutil.PrintSuccess(o.Mapper, false, o.Out, info.Mapping.Resource, info.Name, false, "edited")
+			return nil
+		}
+	})
+	return err
+}
+
+func (o *EditOptions) annotationPatch(update *resource.Info) error {
+	patch, _, patchType, err := GetApplyPatch(update.Object, o.Encoder)
+	if err != nil {
+		return err
+	}
+	mapping := update.ResourceMapping()
+	client, err := o.f.UnstructuredClientForMapping(mapping)
+	if err != nil {
+		return err
+	}
+	helper := resource.NewHelper(client, mapping)
+	_, err = helper.Patch(o.CmdNamespace, update.Name, patchType, patch)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetApplyPatch(obj runtime.Object, codec runtime.Encoder) ([]byte, []byte, types.PatchType, error) {
+	beforeJSON, err := encodeToJson(codec, obj)
+	if err != nil {
+		return nil, []byte(""), types.MergePatchType, err
+	}
+	objCopy := obj.DeepCopyObject()
+	accessor := meta.NewAccessor()
+	annotations, err := accessor.Annotations(objCopy)
+	if err != nil {
+		return nil, beforeJSON, types.MergePatchType, err
+	}
+	if annotations == nil {
+		annotations = map[string]string{}
+	}
+	annotations[api.LastAppliedConfigAnnotation] = string(beforeJSON)
+	accessor.SetAnnotations(objCopy, annotations)
+	afterJSON, err := encodeToJson(codec, objCopy)
+	if err != nil {
+		return nil, beforeJSON, types.MergePatchType, err
+	}
+	patch, err := jsonpatch.CreateMergePatch(beforeJSON, afterJSON)
+	return patch, beforeJSON, types.MergePatchType, err
+}
+
+func encodeToJson(codec runtime.Encoder, obj runtime.Object) ([]byte, error) {
+	serialization, err := runtime.Encode(codec, obj)
+	if err != nil {
+		return nil, err
+	}
+	js, err := yaml.ToJSON(serialization)
+	if err != nil {
+		return nil, err
+	}
+	return js, nil
+}
+
+func getPrinter(format string) *editPrinterOptions {
+	switch format {
+	case "json":
+		return &editPrinterOptions{
+			printer:   &printers.JSONPrinter{},
+			ext:       ".json",
+			addHeader: false,
+		}
+	case "yaml":
+		return &editPrinterOptions{
+			printer:   &printers.YAMLPrinter{},
+			ext:       ".yaml",
+			addHeader: true,
+		}
+	default:
+		// if format is not specified, use yaml as default
+		return &editPrinterOptions{
+			printer:   &printers.YAMLPrinter{},
+			ext:       ".yaml",
+			addHeader: true,
+		}
+	}
+}
+
+func (o *EditOptions) visitToPatch(originalInfos []*resource.Info, patchVisitor resource.Visitor, results *editResults) error {
+	err := patchVisitor.Visit(func(info *resource.Info, incomingErr error) error {
+		editObjUID, err := meta.NewAccessor().UID(info.Object)
+		if err != nil {
+			return err
+		}
+
+		var originalInfo *resource.Info
+		for _, i := range originalInfos {
+			originalObjUID, err := meta.NewAccessor().UID(i.Object)
+			if err != nil {
+				return err
+			}
+			if editObjUID == originalObjUID {
+				originalInfo = i
+				break
+			}
+		}
+		if originalInfo == nil {
+			return fmt.Errorf("no original object found for %#v", info.Object)
+		}
+
+		originalJS, err := encodeToJson(o.Encoder, originalInfo.Object)
+		if err != nil {
+			return err
+		}
+
+		editedJS, err := encodeToJson(o.Encoder, info.Object)
+		if err != nil {
+			return err
+		}
+
+		if reflect.DeepEqual(originalJS, editedJS) {
+			// no edit, so just skip it.
+			cmdutil.PrintSuccess(o.Mapper, false, o.Out, info.Mapping.Resource, info.Name, false, "skipped")
+			return nil
+		}
+
+		preconditions := []mergepatch.PreconditionFunc{
+			mergepatch.RequireKeyUnchanged("apiVersion"),
+			mergepatch.RequireKeyUnchanged("kind"),
+			mergepatch.RequireMetadataKeyUnchanged("name"),
+		}
+
+		// Create the versioned struct from the type defined in the mapping
+		// (which is the API version we'll be submitting the patch to)
+		versionedObject, err := api.Scheme.New(info.Mapping.GroupVersionKind)
+		var patchType types.PatchType
+		var patch []byte
+		switch {
+		case runtime.IsNotRegisteredError(err):
+			// fall back to generic JSON merge patch
+			patchType = types.MergePatchType
+			patch, err = jsonpatch.CreateMergePatch(originalJS, editedJS)
+			if err != nil {
+				glog.V(4).Infof("Unable to calculate diff, no merge is possible: %v", err)
+				return err
+			}
+			for _, precondition := range preconditions {
+				if !precondition(patch) {
+					glog.V(4).Infof("Unable to calculate diff, no merge is possible: %v", err)
+					return fmt.Errorf("%s", "At least one of apiVersion, kind and name was changed")
+				}
+			}
+		case err != nil:
+			return err
+		default:
+			patchType = types.StrategicMergePatchType
+			patch, err = strategicpatch.CreateTwoWayMergePatch(originalJS, editedJS, versionedObject, preconditions...)
+			if err != nil {
+				glog.V(4).Infof("Unable to calculate diff, no merge is possible: %v", err)
+				if mergepatch.IsPreconditionFailed(err) {
+					return fmt.Errorf("%s", "At least one of apiVersion, kind and name was changed")
+				}
+				return err
+			}
+		}
+
+		if o.OutputPatch {
+			fmt.Fprintf(o.Out, "Patch: %s\n", string(patch))
+		}
+
+		patched, err := resource.NewHelper(info.Client, info.Mapping).Patch(info.Namespace, info.Name, patchType, patch)
+		if err != nil {
+			fmt.Fprintln(o.ErrOut, results.addError(err, info))
+			return nil
+		}
+		info.Refresh(patched, true)
+		cmdutil.PrintSuccess(o.Mapper, false, o.Out, info.Mapping.Resource, info.Name, false, "edited")
+		return nil
+	})
+	return err
+}
+
+func (o *EditOptions) visitToCreate(createVisitor resource.Visitor) error {
+	err := createVisitor.Visit(func(info *resource.Info, incomingErr error) error {
+		if err := resource.CreateAndRefresh(info); err != nil {
+			return err
+		}
+		cmdutil.PrintSuccess(o.Mapper, false, o.Out, info.Mapping.Resource, info.Name, false, "created")
+		return nil
+	})
+	return err
+}
+
+func (o *EditOptions) visitAnnotation(annotationVisitor resource.Visitor) error {
+	// iterate through all items to apply annotations
+	err := annotationVisitor.Visit(func(info *resource.Info, incomingErr error) error {
+		// put configuration annotation in "updates"
+		if o.ApplyAnnotation {
+			if err := kubectl.CreateOrUpdateAnnotation(true, info, o.Encoder); err != nil {
+				return err
+			}
+		}
+		if o.Record || cmdutil.ContainsChangeCause(info) {
+			if err := cmdutil.RecordChangeCause(info.Object, o.ChangeCause); err != nil {
+				return err
+			}
+		}
+
+		return nil
+
+	})
+	return err
+}
+
+type EditMode string
+
+const (
+	NormalEditMode       EditMode = "normal_mode"
+	EditBeforeCreateMode EditMode = "edit_before_create_mode"
+	ApplyEditMode        EditMode = "edit_last_applied_mode"
+)
+
+// editReason preserves a message about the reason this file must be edited again
+type editReason struct {
+	head  string
+	other []string
+}
+
+// editHeader includes a list of reasons the edit must be retried
+type editHeader struct {
+	reasons []editReason
+}
+
+// writeTo outputs the current header information into a stream
+func (h *editHeader) writeTo(w io.Writer, editMode EditMode) error {
+	if editMode == ApplyEditMode {
+		fmt.Fprint(w, `# Please edit the 'last-applied-configuration' annotations below.
+# Lines beginning with a '#' will be ignored, and an empty file will abort the edit.
+#
+`)
+	} else {
+		fmt.Fprint(w, `# Please edit the object below. Lines beginning with a '#' will be ignored,
+# and an empty file will abort the edit. If an error occurs while saving this file will be
+# reopened with the relevant failures.
+#
+`)
+	}
+
+	for _, r := range h.reasons {
+		if len(r.other) > 0 {
+			fmt.Fprintf(w, "# %s:\n", r.head)
+		} else {
+			fmt.Fprintf(w, "# %s\n", r.head)
+		}
+		for _, o := range r.other {
+			fmt.Fprintf(w, "# * %s\n", o)
+		}
+		fmt.Fprintln(w, "#")
+	}
+	return nil
+}
+
+func (h *editHeader) flush() {
+	h.reasons = []editReason{}
+}
+
+// editResults capture the result of an update
+type editResults struct {
+	header    editHeader
+	retryable int
+	notfound  int
+	edit      []*resource.Info
+	file      string
+
+	version schema.GroupVersion
+}
+
+func (r *editResults) addError(err error, info *resource.Info) string {
+	switch {
+	case apierrors.IsInvalid(err):
+		r.edit = append(r.edit, info)
+		reason := editReason{
+			head: fmt.Sprintf("%s %q was not valid", info.Mapping.Resource, info.Name),
+		}
+		if err, ok := err.(apierrors.APIStatus); ok {
+			if details := err.Status().Details; details != nil {
+				for _, cause := range details.Causes {
+					reason.other = append(reason.other, fmt.Sprintf("%s: %s", cause.Field, cause.Message))
+				}
+			}
+		}
+		r.header.reasons = append(r.header.reasons, reason)
+		return fmt.Sprintf("error: %s %q is invalid", info.Mapping.Resource, info.Name)
+	case apierrors.IsNotFound(err):
+		r.notfound++
+		return fmt.Sprintf("error: %s %q could not be found on the server", info.Mapping.Resource, info.Name)
+	default:
+		r.retryable++
+		return fmt.Sprintf("error: %s %q could not be patched: %v", info.Mapping.Resource, info.Name, err)
+	}
+}
+
+// preservedFile writes out a message about the provided file if it exists to the
+// provided output stream when an error happens. Used to notify the user where
+// their updates were preserved.
+func preservedFile(err error, path string, out io.Writer) error {
+	if len(path) > 0 {
+		if _, err := os.Stat(path); !os.IsNotExist(err) {
+			fmt.Fprintf(out, "A copy of your changes has been stored to %q\n", path)
+		}
+	}
+	return err
+}
+
+// hasLines returns true if any line in the provided stream is non empty - has non-whitespace
+// characters, or the first non-whitespace character is a '#' indicating a comment. Returns
+// any errors encountered reading the stream.
+func hasLines(r io.Reader) (bool, error) {
+	// TODO: if any files we read have > 64KB lines, we'll need to switch to bytes.ReadLine
+	// TODO: probably going to be secrets
+	s := bufio.NewScanner(r)
+	for s.Scan() {
+		if line := strings.TrimSpace(s.Text()); len(line) > 0 && line[0] != '#' {
+			return true, nil
+		}
+	}
+	if err := s.Err(); err != nil && err != io.EOF {
+		return false, err
+	}
+	return false, nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/editor/editor.go

@@ -0,0 +1,192 @@
+/*
+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 editor
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/golang/glog"
+
+	"k8s.io/kubernetes/pkg/kubectl/util/term"
+)
+
+const (
+	// sorry, blame Git
+	// TODO: on Windows rely on 'start' to launch the editor associated
+	// with the given file type. If we can't because of the need of
+	// blocking, use a script with 'ftype' and 'assoc' to detect it.
+	defaultEditor = "vi"
+	defaultShell  = "/bin/bash"
+	windowsEditor = "notepad"
+	windowsShell  = "cmd"
+)
+
+type Editor struct {
+	Args  []string
+	Shell bool
+}
+
+// NewDefaultEditor creates a struct Editor that uses the OS environment to
+// locate the editor program, looking at EDITOR environment variable to find
+// the proper command line. If the provided editor has no spaces, or no quotes,
+// it is treated as a bare command to be loaded. Otherwise, the string will
+// be passed to the user's shell for execution.
+func NewDefaultEditor(envs []string) Editor {
+	args, shell := defaultEnvEditor(envs)
+	return Editor{
+		Args:  args,
+		Shell: shell,
+	}
+}
+
+func defaultEnvShell() []string {
+	shell := os.Getenv("SHELL")
+	if len(shell) == 0 {
+		shell = platformize(defaultShell, windowsShell)
+	}
+	flag := "-c"
+	if shell == windowsShell {
+		flag = "/C"
+	}
+	return []string{shell, flag}
+}
+
+func defaultEnvEditor(envs []string) ([]string, bool) {
+	var editor string
+	for _, env := range envs {
+		if len(env) > 0 {
+			editor = os.Getenv(env)
+		}
+		if len(editor) > 0 {
+			break
+		}
+	}
+	if len(editor) == 0 {
+		editor = platformize(defaultEditor, windowsEditor)
+	}
+	if !strings.Contains(editor, " ") {
+		return []string{editor}, false
+	}
+	if !strings.ContainsAny(editor, "\"'\\") {
+		return strings.Split(editor, " "), false
+	}
+	// rather than parse the shell arguments ourselves, punt to the shell
+	shell := defaultEnvShell()
+	return append(shell, editor), true
+}
+
+func (e Editor) args(path string) []string {
+	args := make([]string, len(e.Args))
+	copy(args, e.Args)
+	if e.Shell {
+		last := args[len(args)-1]
+		args[len(args)-1] = fmt.Sprintf("%s %q", last, path)
+	} else {
+		args = append(args, path)
+	}
+	return args
+}
+
+// Launch opens the described or returns an error. The TTY will be protected, and
+// SIGQUIT, SIGTERM, and SIGINT will all be trapped.
+func (e Editor) Launch(path string) error {
+	if len(e.Args) == 0 {
+		return fmt.Errorf("no editor defined, can't open %s", path)
+	}
+	abs, err := filepath.Abs(path)
+	if err != nil {
+		return err
+	}
+	args := e.args(abs)
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Stdin = os.Stdin
+	glog.V(5).Infof("Opening file with editor %v", args)
+	if err := (term.TTY{In: os.Stdin, TryDev: true}).Safe(cmd.Run); err != nil {
+		if err, ok := err.(*exec.Error); ok {
+			if err.Err == exec.ErrNotFound {
+				return fmt.Errorf("unable to launch the editor %q", strings.Join(e.Args, " "))
+			}
+		}
+		return fmt.Errorf("there was a problem with the editor %q", strings.Join(e.Args, " "))
+	}
+	return nil
+}
+
+// LaunchTempFile reads the provided stream into a temporary file in the given directory
+// and file prefix, and then invokes Launch with the path of that file. It will return
+// the contents of the file after launch, any errors that occur, and the path of the
+// temporary file so the caller can clean it up as needed.
+func (e Editor) LaunchTempFile(prefix, suffix string, r io.Reader) ([]byte, string, error) {
+	f, err := tempFile(prefix, suffix)
+	if err != nil {
+		return nil, "", err
+	}
+	defer f.Close()
+	path := f.Name()
+	if _, err := io.Copy(f, r); err != nil {
+		os.Remove(path)
+		return nil, path, err
+	}
+	// This file descriptor needs to close so the next process (Launch) can claim it.
+	f.Close()
+	if err := e.Launch(path); err != nil {
+		return nil, path, err
+	}
+	bytes, err := ioutil.ReadFile(path)
+	return bytes, path, err
+}
+
+func tempFile(prefix, suffix string) (f *os.File, err error) {
+	dir := os.TempDir()
+
+	for i := 0; i < 10000; i++ {
+		name := filepath.Join(dir, prefix+randSeq(5)+suffix)
+		f, err = os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
+		if os.IsExist(err) {
+			continue
+		}
+		break
+	}
+	return
+}
+
+var letters = []rune("abcdefghijklmnopqrstuvwxyz0123456789")
+
+func randSeq(n int) string {
+	b := make([]rune, n)
+	for i := range b {
+		b[i] = letters[rand.Intn(len(letters))]
+	}
+	return string(b)
+}
+
+func platformize(linux, windows string) string {
+	if runtime.GOOS == "windows" {
+		return windows
+	}
+	return linux
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/editor/editor_test.go

@@ -0,0 +1,63 @@
+/*
+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 editor
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestArgs(t *testing.T) {
+	if e, a := []string{"/bin/bash", "-c \"test\""}, (Editor{Args: []string{"/bin/bash", "-c"}, Shell: true}).args("test"); !reflect.DeepEqual(e, a) {
+		t.Errorf("unexpected args: %v", a)
+	}
+	if e, a := []string{"/bin/bash", "-c", "test"}, (Editor{Args: []string{"/bin/bash", "-c"}, Shell: false}).args("test"); !reflect.DeepEqual(e, a) {
+		t.Errorf("unexpected args: %v", a)
+	}
+	if e, a := []string{"/bin/bash", "-i -c \"test\""}, (Editor{Args: []string{"/bin/bash", "-i -c"}, Shell: true}).args("test"); !reflect.DeepEqual(e, a) {
+		t.Errorf("unexpected args: %v", a)
+	}
+	if e, a := []string{"/test", "test"}, (Editor{Args: []string{"/test"}}).args("test"); !reflect.DeepEqual(e, a) {
+		t.Errorf("unexpected args: %v", a)
+	}
+}
+
+func TestEditor(t *testing.T) {
+	edit := Editor{Args: []string{"cat"}}
+	testStr := "test something\n"
+	contents, path, err := edit.LaunchTempFile("", "someprefix", bytes.NewBufferString(testStr))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if _, err := os.Stat(path); err != nil {
+		t.Fatalf("no temp file: %s", path)
+	}
+	defer os.Remove(path)
+	if disk, err := ioutil.ReadFile(path); err != nil || !bytes.Equal(contents, disk) {
+		t.Errorf("unexpected file on disk: %v %s", err, string(disk))
+	}
+	if !bytes.Equal(contents, []byte(testStr)) {
+		t.Errorf("unexpected contents: %s", string(contents))
+	}
+	if !strings.Contains(path, "someprefix") {
+		t.Errorf("path not expected: %s", path)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/env/BUILD

@@ -0,0 +1,33 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "env_parse.go",
+        "env_resolve.go",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/resource:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset:go_default_library",
+        "//pkg/fieldpath:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets: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/cmd/util/env/env_parse.go

@@ -0,0 +1,154 @@
+/*
+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 env
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"regexp"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/kubernetes/pkg/api"
+)
+
+// Env returns an environment variable or a default value if not specified.
+func Env(key string, defaultValue string) string {
+	val := os.Getenv(key)
+	if len(val) == 0 {
+		return defaultValue
+	}
+	return val
+}
+
+// GetEnv returns an environment value if specified
+func GetEnv(key string) (string, bool) {
+	val := os.Getenv(key)
+	if len(val) == 0 {
+		return "", false
+	}
+	return val, true
+}
+
+var argumentEnvironment = regexp.MustCompile("(?ms)^(.+)\\=(.*)$")
+var validArgumentEnvironment = regexp.MustCompile("(?ms)^(\\w+)\\=(.*)$")
+
+// IsEnvironmentArgument check str is env args
+func IsEnvironmentArgument(s string) bool {
+	return argumentEnvironment.MatchString(s)
+}
+
+// IsValidEnvironmentArgument check str is valid env
+func IsValidEnvironmentArgument(s string) bool {
+	return validArgumentEnvironment.MatchString(s)
+}
+
+// SplitEnvironmentFromResources returns resources and envargs
+func SplitEnvironmentFromResources(args []string) (resources, envArgs []string, ok bool) {
+	first := true
+	for _, s := range args {
+		// this method also has to understand env removal syntax, i.e. KEY-
+		isEnv := IsEnvironmentArgument(s) || strings.HasSuffix(s, "-")
+		switch {
+		case first && isEnv:
+			first = false
+			fallthrough
+		case !first && isEnv:
+			envArgs = append(envArgs, s)
+		case first && !isEnv:
+			resources = append(resources, s)
+		case !first && !isEnv:
+			return nil, nil, false
+		}
+	}
+	return resources, envArgs, true
+}
+
+// parseIntoEnvVar parses the list of key-value pairs into kubernetes EnvVar.
+// envVarType is for making errors more specific to user intentions.
+func parseIntoEnvVar(spec []string, defaultReader io.Reader, envVarType string) ([]api.EnvVar, []string, error) {
+	env := []api.EnvVar{}
+	exists := sets.NewString()
+	var remove []string
+	for _, envSpec := range spec {
+		switch {
+		case !IsValidEnvironmentArgument(envSpec) && !strings.HasSuffix(envSpec, "-"):
+			return nil, nil, fmt.Errorf("%ss must be of the form key=value and can only contain letters, numbers, and underscores", envVarType)
+		case envSpec == "-":
+			if defaultReader == nil {
+				return nil, nil, fmt.Errorf("when '-' is used, STDIN must be open")
+			}
+			fileEnv, err := readEnv(defaultReader, envVarType)
+			if err != nil {
+				return nil, nil, err
+			}
+			env = append(env, fileEnv...)
+		case strings.Index(envSpec, "=") != -1:
+			parts := strings.SplitN(envSpec, "=", 2)
+			if len(parts) != 2 {
+				return nil, nil, fmt.Errorf("invalid %s: %v", envVarType, envSpec)
+			}
+			exists.Insert(parts[0])
+			env = append(env, api.EnvVar{
+				Name:  parts[0],
+				Value: parts[1],
+			})
+		case strings.HasSuffix(envSpec, "-"):
+			remove = append(remove, envSpec[:len(envSpec)-1])
+		default:
+			return nil, nil, fmt.Errorf("unknown %s: %v", envVarType, envSpec)
+		}
+	}
+	for _, removeLabel := range remove {
+		if _, found := exists[removeLabel]; found {
+			return nil, nil, fmt.Errorf("can not both modify and remove the same %s in the same command", envVarType)
+		}
+	}
+	return env, remove, nil
+}
+
+// ParseEnv parse env from reader
+func ParseEnv(spec []string, defaultReader io.Reader) ([]api.EnvVar, []string, error) {
+	return parseIntoEnvVar(spec, defaultReader, "environment variable")
+}
+
+func readEnv(r io.Reader, envVarType string) ([]api.EnvVar, error) {
+	env := []api.EnvVar{}
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		envSpec := scanner.Text()
+		if pos := strings.Index(envSpec, "#"); pos != -1 {
+			envSpec = envSpec[:pos]
+		}
+		if strings.Index(envSpec, "=") != -1 {
+			parts := strings.SplitN(envSpec, "=", 2)
+			if len(parts) != 2 {
+				return nil, fmt.Errorf("invalid %s: %v", envVarType, envSpec)
+			}
+			env = append(env, api.EnvVar{
+				Name:  parts[0],
+				Value: parts[1],
+			})
+		}
+	}
+	if err := scanner.Err(); err != nil && err != io.EOF {
+		return nil, err
+	}
+	return env, nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/env/env_resolve.go

@@ -0,0 +1,133 @@
+/*
+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 env
+
+import (
+	"fmt"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/resource"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	"k8s.io/kubernetes/pkg/fieldpath"
+)
+
+// ResourceStore defines a new resource store data structure
+type ResourceStore struct {
+	SecretStore    map[string]*api.Secret
+	ConfigMapStore map[string]*api.ConfigMap
+}
+
+// NewResourceStore returns a pointer to a new resource store data structure
+func NewResourceStore() *ResourceStore {
+	return &ResourceStore{
+		SecretStore:    make(map[string]*api.Secret),
+		ConfigMapStore: make(map[string]*api.ConfigMap),
+	}
+}
+
+// getSecretRefValue returns the value of a secret in the supplied namespace
+func getSecretRefValue(client clientset.Interface, namespace string, store *ResourceStore, secretSelector *api.SecretKeySelector) (string, error) {
+	secret, ok := store.SecretStore[secretSelector.Name]
+	if !ok {
+		var err error
+		secret, err = client.Core().Secrets(namespace).Get(secretSelector.Name, metav1.GetOptions{})
+		if err != nil {
+			return "", err
+		}
+		store.SecretStore[secretSelector.Name] = secret
+	}
+	if data, ok := secret.Data[secretSelector.Key]; ok {
+		return string(data), nil
+	}
+	return "", fmt.Errorf("key %s not found in secret %s", secretSelector.Key, secretSelector.Name)
+
+}
+
+// getConfigMapRefValue returns the value of a configmap in the supplied namespace
+func getConfigMapRefValue(client clientset.Interface, namespace string, store *ResourceStore, configMapSelector *api.ConfigMapKeySelector) (string, error) {
+	configMap, ok := store.ConfigMapStore[configMapSelector.Name]
+	if !ok {
+		var err error
+		configMap, err = client.Core().ConfigMaps(namespace).Get(configMapSelector.Name, metav1.GetOptions{})
+		if err != nil {
+			return "", err
+		}
+		store.ConfigMapStore[configMapSelector.Name] = configMap
+	}
+	if data, ok := configMap.Data[configMapSelector.Key]; ok {
+		return string(data), nil
+	}
+	return "", fmt.Errorf("key %s not found in config map %s", configMapSelector.Key, configMapSelector.Name)
+}
+
+// getFieldRef returns the value of the supplied path in the given object
+func getFieldRef(obj runtime.Object, from *api.EnvVarSource) (string, error) {
+	return fieldpath.ExtractFieldPathAsString(obj, from.FieldRef.FieldPath)
+}
+
+// getResourceFieldRef returns the value of a resource in the given container
+func getResourceFieldRef(from *api.EnvVarSource, c *api.Container) (string, error) {
+	return resource.ExtractContainerResourceValue(from.ResourceFieldRef, c)
+}
+
+// GetEnvVarRefValue returns the value referenced by the supplied envvarsource given the other supplied information
+func GetEnvVarRefValue(kc clientset.Interface, ns string, store *ResourceStore, from *api.EnvVarSource, obj runtime.Object, c *api.Container) (string, error) {
+	if from.SecretKeyRef != nil {
+		return getSecretRefValue(kc, ns, store, from.SecretKeyRef)
+	}
+
+	if from.ConfigMapKeyRef != nil {
+		return getConfigMapRefValue(kc, ns, store, from.ConfigMapKeyRef)
+	}
+
+	if from.FieldRef != nil {
+		return getFieldRef(obj, from)
+	}
+
+	if from.ResourceFieldRef != nil {
+		return getResourceFieldRef(from, c)
+	}
+
+	return "", fmt.Errorf("invalid valueFrom")
+}
+
+// GetEnvVarRefString returns a text description of the supplied envvarsource
+func GetEnvVarRefString(from *api.EnvVarSource) string {
+	if from.ConfigMapKeyRef != nil {
+		return fmt.Sprintf("configmap %s, key %s", from.ConfigMapKeyRef.Name, from.ConfigMapKeyRef.Key)
+	}
+
+	if from.SecretKeyRef != nil {
+		return fmt.Sprintf("secret %s, key %s", from.SecretKeyRef.Name, from.SecretKeyRef.Key)
+	}
+
+	if from.FieldRef != nil {
+		return fmt.Sprintf("field path %s", from.FieldRef.FieldPath)
+	}
+
+	if from.ResourceFieldRef != nil {
+		containerPrefix := ""
+		if from.ResourceFieldRef.ContainerName != "" {
+			containerPrefix = fmt.Sprintf("%s/", from.ResourceFieldRef.ContainerName)
+		}
+		return fmt.Sprintf("resource field %s%s", containerPrefix, from.ResourceFieldRef.Resource)
+	}
+
+	return "invalid valueFrom"
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/factory.go

@@ -0,0 +1,536 @@
+/*
+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 util
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/user"
+	"path"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	swagger "github.com/emicklei/go-restful-swagger12"
+	"github.com/golang/glog"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer/json"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/discovery"
+	"k8s.io/client-go/kubernetes"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+	fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_clientset"
+	"k8s.io/kubernetes/pkg/api"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+	"k8s.io/kubernetes/pkg/kubectl/plugins"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/kubectl/validation"
+	"k8s.io/kubernetes/pkg/printers"
+)
+
+const (
+	FlagMatchBinaryVersion = "match-server-version"
+)
+
+var (
+	FlagHTTPCacheDir = "cache-dir"
+)
+
+// Factory provides abstractions that allow the Kubectl command to be extended across multiple types
+// of resources and different API sets.
+// The rings are here for a reason.  In order for composers to be able to provide alternative factory implementations
+// they need to provide low level pieces of *certain* functions so that when the factory calls back into itself
+// it uses the custom version of the function.  Rather than try to enumerate everything that someone would want to override
+// we split the factory into rings, where each ring can depend on methods  an earlier ring, but cannot depend
+// upon peer methods in its own ring.
+// TODO: make the functions interfaces
+// TODO: pass the various interfaces on the factory directly into the command constructors (so the
+// commands are decoupled from the factory).
+type Factory interface {
+	ClientAccessFactory
+	ObjectMappingFactory
+	BuilderFactory
+}
+
+type DiscoveryClientFactory interface {
+	// Returns a discovery client
+	DiscoveryClient() (discovery.CachedDiscoveryInterface, error)
+
+	// BindFlags adds any discovery flags that are common to all kubectl sub commands.
+	BindFlags(flags *pflag.FlagSet)
+}
+
+// ClientAccessFactory holds the first level of factory methods.
+// Generally provides discovery, negotiation, and no-dep calls.
+// TODO The polymorphic calls probably deserve their own interface.
+type ClientAccessFactory interface {
+	// Returns a discovery client
+	DiscoveryClient() (discovery.CachedDiscoveryInterface, error)
+
+	// ClientSet gives you back an internal, generated clientset
+	ClientSet() (internalclientset.Interface, error)
+
+	// KubernetesClientSet gives you back an external clientset
+	KubernetesClientSet() (*kubernetes.Clientset, error)
+
+	// Returns a RESTClient for accessing Kubernetes resources or an error.
+	RESTClient() (*restclient.RESTClient, error)
+	// Returns a client.Config for accessing the Kubernetes server.
+	ClientConfig() (*restclient.Config, error)
+	// BareClientConfig returns a client.Config that has NOT been negotiated. It's
+	// just directions to the server. People use this to build RESTMappers on top of
+	BareClientConfig() (*restclient.Config, error)
+
+	// TODO this should probably be removed and collapsed into whatever we want to use long term
+	// probably returning a restclient for a version and leaving contruction up to someone else
+	FederationClientSetForVersion(version *schema.GroupVersion) (fedclientset.Interface, error)
+	// TODO remove this should be rolled into restclient with the right version
+	FederationClientForVersion(version *schema.GroupVersion) (*restclient.RESTClient, error)
+	// TODO remove.  This should be rolled into `ClientSet`
+	ClientSetForVersion(requiredVersion *schema.GroupVersion) (internalclientset.Interface, error)
+	// TODO remove.  This should be rolled into `ClientConfig`
+	ClientConfigForVersion(requiredVersion *schema.GroupVersion) (*restclient.Config, error)
+
+	// Returns interfaces for decoding objects - if toInternal is set, decoded objects will be converted
+	// into their internal form (if possible). Eventually the internal form will be removed as an option,
+	// and only versioned objects will be returned.
+	Decoder(toInternal bool) runtime.Decoder
+	// Returns an encoder capable of encoding a provided object into JSON in the default desired version.
+	JSONEncoder() runtime.Encoder
+
+	// UpdatePodSpecForObject will call the provided function on the pod spec this object supports,
+	// return false if no pod spec is supported, or return an error.
+	UpdatePodSpecForObject(obj runtime.Object, fn func(*api.PodSpec) error) (bool, error)
+
+	// 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
+	MapBasedSelectorForObject(object runtime.Object) (string, error)
+	// PortsForObject returns the ports associated with the provided object
+	PortsForObject(object runtime.Object) ([]string, error)
+	// ProtocolsForObject returns the <port, protocol> mapping associated with the provided object
+	ProtocolsForObject(object runtime.Object) (map[string]string, error)
+	// LabelsForObject returns the labels associated with the provided object
+	LabelsForObject(object runtime.Object) (map[string]string, error)
+
+	// Returns internal flagset
+	FlagSet() *pflag.FlagSet
+	// Command will stringify and return all environment arguments ie. a command run by a client
+	// using the factory.
+	Command(cmd *cobra.Command, showSecrets bool) string
+	// BindFlags adds any flags that are common to all kubectl sub commands.
+	BindFlags(flags *pflag.FlagSet)
+	// BindExternalFlags adds any flags defined by external projects (not part of pflags)
+	BindExternalFlags(flags *pflag.FlagSet)
+
+	// TODO: Break the dependency on cmd here.
+	DefaultResourceFilterOptions(cmd *cobra.Command, withNamespace bool) *printers.PrintOptions
+	// DefaultResourceFilterFunc returns a collection of FilterFuncs suitable for filtering specific resource types.
+	DefaultResourceFilterFunc() kubectl.Filters
+
+	// SuggestedPodTemplateResources returns a list of resource types that declare a pod template
+	SuggestedPodTemplateResources() []schema.GroupResource
+
+	// Returns a Printer for formatting objects of the given type or an error.
+	Printer(mapping *meta.RESTMapping, options printers.PrintOptions) (printers.ResourcePrinter, error)
+	// Pauser marks the object in the info as paused. Currently supported only for Deployments.
+	// Returns the patched object in bytes and any error that occured during the encoding or
+	// in case the object is already paused.
+	Pauser(info *resource.Info) ([]byte, error)
+	// Resumer resumes a paused object inside the info. Currently supported only for Deployments.
+	// Returns the patched object in bytes and any error that occured during the encoding or
+	// in case the object is already resumed.
+	Resumer(info *resource.Info) ([]byte, error)
+
+	// ResolveImage resolves the image names. For kubernetes this function is just
+	// passthrough but it allows to perform more sophisticated image name resolving for
+	// third-party vendors.
+	ResolveImage(imageName string) (string, error)
+
+	// Returns the default namespace to use in cases where no
+	// other namespace is specified and whether the namespace was
+	// overridden.
+	DefaultNamespace() (string, bool, error)
+	// Generators returns the generators for the provided command
+	Generators(cmdName string) map[string]kubectl.Generator
+	// Check whether the kind of resources could be exposed
+	CanBeExposed(kind schema.GroupKind) error
+	// Check whether the kind of resources could be autoscaled
+	CanBeAutoscaled(kind schema.GroupKind) error
+
+	// EditorEnvs returns a group of environment variables that the edit command
+	// can range over in order to determine if the user has specified an editor
+	// of their choice.
+	EditorEnvs() []string
+
+	// PrintObjectSpecificMessage prints object-specific messages on the provided writer
+	PrintObjectSpecificMessage(obj runtime.Object, out io.Writer)
+}
+
+// ObjectMappingFactory holds the second level of factory methods.  These functions depend upon ClientAccessFactory methods.
+// Generally they provide object typing and functions that build requests based on the negotiated clients.
+type ObjectMappingFactory interface {
+	// Returns interfaces for dealing with arbitrary runtime.Objects.
+	Object() (meta.RESTMapper, runtime.ObjectTyper)
+	// Returns interfaces for dealing with arbitrary
+	// runtime.Unstructured. This performs API calls to discover types.
+	UnstructuredObject() (meta.RESTMapper, runtime.ObjectTyper, error)
+	// Returns interface for expanding categories like `all`.
+	CategoryExpander() resource.CategoryExpander
+	// Returns a RESTClient for working with the specified RESTMapping or an error. This is intended
+	// for working with arbitrary resources and is not guaranteed to point to a Kubernetes APIServer.
+	ClientForMapping(mapping *meta.RESTMapping) (resource.RESTClient, error)
+	// Returns a RESTClient for working with Unstructured objects.
+	UnstructuredClientForMapping(mapping *meta.RESTMapping) (resource.RESTClient, error)
+	// Returns a Describer for displaying the specified RESTMapping type or an error.
+	Describer(mapping *meta.RESTMapping) (printers.Describer, error)
+
+	// LogsForObject returns a request for the logs associated with the provided object
+	LogsForObject(object, options runtime.Object, timeout time.Duration) (*restclient.Request, error)
+	// Returns a Scaler for changing the size of the specified RESTMapping type or an error
+	Scaler(mapping *meta.RESTMapping) (kubectl.Scaler, error)
+	// Returns a Reaper for gracefully shutting down resources.
+	Reaper(mapping *meta.RESTMapping) (kubectl.Reaper, error)
+	// Returns a HistoryViewer for viewing change history
+	HistoryViewer(mapping *meta.RESTMapping) (kubectl.HistoryViewer, error)
+	// Returns a Rollbacker for changing the rollback version of the specified RESTMapping type or an error
+	Rollbacker(mapping *meta.RESTMapping) (kubectl.Rollbacker, error)
+	// Returns a StatusViewer for printing rollout status.
+	StatusViewer(mapping *meta.RESTMapping) (kubectl.StatusViewer, error)
+
+	// AttachablePodForObject returns the pod to which to attach given an object.
+	AttachablePodForObject(object runtime.Object, timeout time.Duration) (*api.Pod, error)
+
+	// Returns a schema that can validate objects stored on disk.
+	Validator(validate bool, openapi bool, cacheDir string) (validation.Schema, error)
+	// SwaggerSchema returns the schema declaration for the provided group version kind.
+	SwaggerSchema(schema.GroupVersionKind) (*swagger.ApiDeclaration, error)
+	// OpenAPISchema returns the schema openapi schema definiton
+	OpenAPISchema() (openapi.Resources, error)
+}
+
+// BuilderFactory holds the second level of factory methods.  These functions depend upon ObjectMappingFactory and ClientAccessFactory methods.
+// Generally they depend upon client mapper functions
+type BuilderFactory interface {
+	// PrinterForCommand returns the default printer for the command. It requires that certain options
+	// are declared on the command (see AddPrinterFlags). Returns a printer, or an error if a printer
+	// could not be found.
+	// TODO: Break the dependency on cmd here.
+	PrinterForCommand(cmd *cobra.Command, isLocal bool, outputOpts *printers.OutputOptions, options printers.PrintOptions) (printers.ResourcePrinter, error)
+	// PrinterForMapping returns a printer suitable for displaying the provided resource type.
+	// Requires that printer flags have been added to cmd (see AddPrinterFlags).
+	// Returns a printer, true if the printer is generic (is not internal), or
+	// an error if a printer could not be found.
+	PrinterForMapping(cmd *cobra.Command, isLocal bool, outputOpts *printers.OutputOptions, mapping *meta.RESTMapping, withNamespace bool) (printers.ResourcePrinter, error)
+	// PrintObject prints an api object given command line flags to modify the output format
+	PrintObject(cmd *cobra.Command, isLocal bool, mapper meta.RESTMapper, obj runtime.Object, out io.Writer) error
+	// One stop shopping for a Builder
+	NewBuilder(allowRemoteCalls bool) *resource.Builder
+	// Resource builder for working with unstructured objects
+	NewUnstructuredBuilder(allowRemoteCalls bool) (*resource.Builder, error)
+	// PluginLoader provides the implementation to be used to load cli plugins.
+	PluginLoader() plugins.PluginLoader
+	// PluginRunner provides the implementation to be used to run cli plugins.
+	PluginRunner() plugins.PluginRunner
+}
+
+func getGroupVersionKinds(gvks []schema.GroupVersionKind, group string) []schema.GroupVersionKind {
+	result := []schema.GroupVersionKind{}
+	for ix := range gvks {
+		if gvks[ix].Group == group {
+			result = append(result, gvks[ix])
+		}
+	}
+	return result
+}
+
+type factory struct {
+	ClientAccessFactory
+	ObjectMappingFactory
+	BuilderFactory
+}
+
+// NewFactory creates a factory with the default Kubernetes resources defined
+// if optionalClientConfig is nil, then flags will be bound to a new clientcmd.ClientConfig.
+// if optionalClientConfig is not nil, then this factory will make use of it.
+func NewFactory(optionalClientConfig clientcmd.ClientConfig) Factory {
+	clientAccessFactory := NewClientAccessFactory(optionalClientConfig)
+	objectMappingFactory := NewObjectMappingFactory(clientAccessFactory)
+	builderFactory := NewBuilderFactory(clientAccessFactory, objectMappingFactory)
+
+	return &factory{
+		ClientAccessFactory:  clientAccessFactory,
+		ObjectMappingFactory: objectMappingFactory,
+		BuilderFactory:       builderFactory,
+	}
+}
+
+// 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 labels.Selector, timeout time.Duration, sortBy func([]*v1.Pod) sort.Interface) (*api.Pod, int, error) {
+	options := metav1.ListOptions{LabelSelector: selector.String()}
+
+	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_api_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_api_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
+}
+
+func makePortsString(ports []api.ServicePort, useNodePort bool) string {
+	pieces := make([]string, len(ports))
+	for ix := range ports {
+		var port int32
+		if useNodePort {
+			port = ports[ix].NodePort
+		} else {
+			port = ports[ix].Port
+		}
+		pieces[ix] = fmt.Sprintf("%s:%d", strings.ToLower(string(ports[ix].Protocol)), port)
+	}
+	return strings.Join(pieces, ",")
+}
+
+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
+}
+
+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 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
+}
+
+// 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
+}
+
+type clientSwaggerSchema struct {
+	c        restclient.Interface
+	cacheDir string
+}
+
+const schemaFileName = "schema.json"
+
+type schemaClient interface {
+	Get() *restclient.Request
+}
+
+func recursiveSplit(dir string) []string {
+	parent, file := path.Split(dir)
+	if len(parent) == 0 {
+		return []string{file}
+	}
+	return append(recursiveSplit(parent[:len(parent)-1]), file)
+}
+
+func substituteUserHome(dir string) (string, error) {
+	if len(dir) == 0 || dir[0] != '~' {
+		return dir, nil
+	}
+	parts := recursiveSplit(dir)
+	if len(parts[0]) == 1 {
+		parts[0] = os.Getenv("HOME")
+	} else {
+		usr, err := user.Lookup(parts[0][1:])
+		if err != nil {
+			return "", err
+		}
+		parts[0] = usr.HomeDir
+	}
+	return path.Join(parts...), nil
+}
+
+func writeSchemaFile(schemaData []byte, cacheDir, cacheFile, prefix, groupVersion string) error {
+	if err := os.MkdirAll(path.Join(cacheDir, prefix, groupVersion), 0755); err != nil {
+		return err
+	}
+	tmpFile, err := ioutil.TempFile(cacheDir, "schema")
+	if err != nil {
+		// If we can't write, keep going.
+		if os.IsPermission(err) {
+			return nil
+		}
+		return err
+	}
+	if _, err := io.Copy(tmpFile, bytes.NewBuffer(schemaData)); err != nil {
+		return err
+	}
+	glog.V(4).Infof("Writing swagger cache (dir %v) file %v (from %v)", cacheDir, cacheFile, tmpFile.Name())
+	if err := os.Link(tmpFile.Name(), cacheFile); err != nil {
+		// If we can't write due to file existing, or permission problems, keep going.
+		if os.IsExist(err) || os.IsPermission(err) {
+			return nil
+		}
+		return err
+	}
+	return nil
+}
+
+func getSchemaAndValidate(c schemaClient, data []byte, prefix, groupVersion, cacheDir string, delegate validation.Schema) (err error) {
+	var schemaData []byte
+	var firstSeen bool
+	fullDir, err := substituteUserHome(cacheDir)
+	if err != nil {
+		return err
+	}
+	cacheFile := path.Join(fullDir, prefix, groupVersion, schemaFileName)
+
+	if len(cacheDir) != 0 {
+		if schemaData, err = ioutil.ReadFile(cacheFile); err != nil && !os.IsNotExist(err) {
+			return err
+		}
+	}
+	if schemaData == nil {
+		firstSeen = true
+		schemaData, err = downloadSchemaAndStore(c, cacheDir, fullDir, cacheFile, prefix, groupVersion)
+		if err != nil {
+			return err
+		}
+	}
+	schema, err := validation.NewSwaggerSchemaFromBytes(schemaData, delegate)
+	if err != nil {
+		return err
+	}
+	err = schema.ValidateBytes(data)
+	if _, ok := err.(validation.TypeNotFoundError); ok && !firstSeen {
+		// As a temporary hack, kubectl would re-get the schema if validation
+		// fails for type not found reason.
+		// TODO: runtime-config settings needs to make into the file's name
+		schemaData, err = downloadSchemaAndStore(c, cacheDir, fullDir, cacheFile, prefix, groupVersion)
+		if err != nil {
+			return err
+		}
+		schema, err := validation.NewSwaggerSchemaFromBytes(schemaData, delegate)
+		if err != nil {
+			return err
+		}
+		return schema.ValidateBytes(data)
+	}
+
+	return err
+}
+
+// Download swagger schema from apiserver and store it to file.
+func downloadSchemaAndStore(c schemaClient, cacheDir, fullDir, cacheFile, prefix, groupVersion string) (schemaData []byte, err error) {
+	schemaData, err = c.Get().
+		AbsPath("/swaggerapi", prefix, groupVersion).
+		Do().
+		Raw()
+	if err != nil {
+		return
+	}
+	if len(cacheDir) != 0 {
+		if err = writeSchemaFile(schemaData, fullDir, cacheFile, prefix, groupVersion); err != nil {
+			return
+		}
+	}
+	return
+}
+
+func (c *clientSwaggerSchema) ValidateBytes(data []byte) error {
+	gvk, err := json.DefaultMetaFactory.Interpret(data)
+	if err != nil {
+		return err
+	}
+	if ok := api.Registry.IsEnabledVersion(gvk.GroupVersion()); !ok {
+		// if we don't have this in our scheme, just skip validation because its an object we don't recognize
+		return nil
+	}
+
+	switch gvk.Group {
+	case api.GroupName:
+		return getSchemaAndValidate(c.c, data, "api", gvk.GroupVersion().String(), c.cacheDir, c)
+
+	default:
+		return getSchemaAndValidate(c.c, data, "apis/", gvk.GroupVersion().String(), c.cacheDir, c)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/factory_builder.go

@@ -0,0 +1,193 @@
+/*
+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.
+*/
+
+// this file contains factories with no other dependencies
+
+package util
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/kubectl/plugins"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/printers"
+)
+
+type ring2Factory struct {
+	clientAccessFactory  ClientAccessFactory
+	objectMappingFactory ObjectMappingFactory
+}
+
+func NewBuilderFactory(clientAccessFactory ClientAccessFactory, objectMappingFactory ObjectMappingFactory) BuilderFactory {
+	f := &ring2Factory{
+		clientAccessFactory:  clientAccessFactory,
+		objectMappingFactory: objectMappingFactory,
+	}
+
+	return f
+}
+
+func (f *ring2Factory) PrinterForCommand(cmd *cobra.Command, isLocal bool, outputOpts *printers.OutputOptions, options printers.PrintOptions) (printers.ResourcePrinter, error) {
+	var mapper meta.RESTMapper
+	var typer runtime.ObjectTyper
+	var err error
+
+	if isLocal {
+		mapper = api.Registry.RESTMapper()
+		typer = api.Scheme
+	} else {
+		mapper, typer, err = f.objectMappingFactory.UnstructuredObject()
+		if err != nil {
+			return nil, err
+		}
+	}
+	// TODO: used by the custom column implementation and the name implementation, break this dependency
+	decoders := []runtime.Decoder{f.clientAccessFactory.Decoder(true), unstructured.UnstructuredJSONScheme}
+	encoder := f.clientAccessFactory.JSONEncoder()
+	return PrinterForCommand(cmd, outputOpts, mapper, typer, encoder, decoders, options)
+}
+
+func (f *ring2Factory) PrinterForMapping(cmd *cobra.Command, isLocal bool, outputOpts *printers.OutputOptions, mapping *meta.RESTMapping, withNamespace bool) (printers.ResourcePrinter, error) {
+	// Some callers do not have "label-columns" so we can't use the GetFlagStringSlice() helper
+	columnLabel, err := cmd.Flags().GetStringSlice("label-columns")
+	if err != nil {
+		columnLabel = []string{}
+	}
+
+	options := printers.PrintOptions{
+		NoHeaders:          GetFlagBool(cmd, "no-headers"),
+		WithNamespace:      withNamespace,
+		Wide:               GetWideFlag(cmd),
+		ShowAll:            GetFlagBool(cmd, "show-all"),
+		ShowLabels:         GetFlagBool(cmd, "show-labels"),
+		AbsoluteTimestamps: isWatch(cmd),
+		ColumnLabels:       columnLabel,
+	}
+
+	printer, err := f.PrinterForCommand(cmd, isLocal, outputOpts, options)
+	if err != nil {
+		return nil, err
+	}
+
+	// Make sure we output versioned data for generic printers
+	if printer.IsGeneric() {
+		if mapping == nil {
+			return nil, fmt.Errorf("no serialization format found")
+		}
+		version := mapping.GroupVersionKind.GroupVersion()
+		if version.Empty() {
+			return nil, fmt.Errorf("no serialization format found")
+		}
+
+		printer = printers.NewVersionedPrinter(printer, mapping.ObjectConvertor, version, mapping.GroupVersionKind.GroupVersion())
+
+	}
+
+	return printer, nil
+}
+
+func (f *ring2Factory) PrintObject(cmd *cobra.Command, isLocal bool, mapper meta.RESTMapper, obj runtime.Object, out io.Writer) error {
+	// try to get a typed object
+	_, typer := f.objectMappingFactory.Object()
+	gvks, _, err := typer.ObjectKinds(obj)
+
+	// fall back to an unstructured object if we get something unregistered
+	if runtime.IsNotRegisteredError(err) {
+		_, typer, unstructuredErr := f.objectMappingFactory.UnstructuredObject()
+		if unstructuredErr != nil {
+			// if we can't get an unstructured typer, return the original error
+			return err
+		}
+		gvks, _, err = typer.ObjectKinds(obj)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	mapping, err := mapper.RESTMapping(gvks[0].GroupKind())
+	if err != nil {
+		return err
+	}
+
+	printer, err := f.PrinterForMapping(cmd, isLocal, nil, mapping, false)
+	if err != nil {
+		return err
+	}
+	return printer.PrintObj(obj, out)
+}
+
+// NewBuilder returns a new resource builder.
+// Receives a bool flag and avoids remote calls if set to false
+func (f *ring2Factory) NewBuilder(allowRemoteCalls bool) *resource.Builder {
+	var clientMapper resource.ClientMapper
+	clientMapperFunc := resource.ClientMapperFunc(f.objectMappingFactory.ClientForMapping)
+
+	mapper, typer := f.objectMappingFactory.Object()
+	categoryExpander := f.objectMappingFactory.CategoryExpander()
+
+	if allowRemoteCalls {
+		clientMapper = clientMapperFunc
+	} else {
+		clientMapper = resource.DisabledClientForMapping{ClientMapper: clientMapperFunc}
+	}
+
+	return resource.NewBuilder(mapper, categoryExpander, typer, clientMapper, f.clientAccessFactory.Decoder(true))
+}
+
+func (f *ring2Factory) NewUnstructuredBuilder(allowRemoteCalls bool) (*resource.Builder, error) {
+	if !allowRemoteCalls {
+		return f.NewBuilder(allowRemoteCalls), nil
+	}
+
+	clientMapperFunc := resource.ClientMapperFunc(f.objectMappingFactory.UnstructuredClientForMapping)
+
+	mapper, typer, err := f.objectMappingFactory.UnstructuredObject()
+	if err != nil {
+		return nil, err
+	}
+
+	categoryExpander := f.objectMappingFactory.CategoryExpander()
+	return resource.NewBuilder(mapper, categoryExpander, typer, clientMapperFunc, unstructured.UnstructuredJSONScheme), nil
+
+}
+
+// PluginLoader loads plugins from a path set by the KUBECTL_PLUGINS_PATH env var.
+// If this env var is not set, it defaults to
+//   "~/.kube/plugins", plus
+//  "./kubectl/plugins" directory under the "data dir" directory specified by the XDG
+// system directory structure spec for the given platform.
+func (f *ring2Factory) PluginLoader() plugins.PluginLoader {
+	if len(os.Getenv("KUBECTL_PLUGINS_PATH")) > 0 {
+		return plugins.PluginsEnvVarPluginLoader()
+	}
+	return plugins.TolerantMultiPluginLoader{
+		plugins.XDGDataPluginLoader(),
+		plugins.UserDirPluginLoader(),
+	}
+}
+
+func (f *ring2Factory) PluginRunner() plugins.PluginRunner {
+	return &plugins.ExecPluginRunner{}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/factory_client_access.go

@@ -0,0 +1,643 @@
+/*
+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.
+*/
+
+// this file contains factories with no other dependencies
+
+package util
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	utilflag "k8s.io/apiserver/pkg/util/flag"
+	"k8s.io/client-go/discovery"
+	"k8s.io/client-go/kubernetes"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/client-go/util/homedir"
+	fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_clientset"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	"k8s.io/kubernetes/pkg/apis/batch"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/printers"
+	printersinternal "k8s.io/kubernetes/pkg/printers/internalversion"
+)
+
+type ring0Factory struct {
+	flags            *pflag.FlagSet
+	clientConfig     clientcmd.ClientConfig
+	discoveryFactory DiscoveryClientFactory
+	clientCache      *ClientCache
+}
+
+func NewClientAccessFactory(optionalClientConfig clientcmd.ClientConfig) ClientAccessFactory {
+	flags := pflag.NewFlagSet("", pflag.ContinueOnError)
+
+	clientConfig := optionalClientConfig
+	if optionalClientConfig == nil {
+		clientConfig = DefaultClientConfig(flags)
+	}
+
+	return NewClientAccessFactoryFromDiscovery(flags, clientConfig, &discoveryFactory{clientConfig: clientConfig})
+}
+
+// NewClientAccessFactoryFromDiscovery allows an external caller to substitute a different discoveryFactory
+// Which allows for the client cache to be built in ring0, but still rely on a custom discovery client
+func NewClientAccessFactoryFromDiscovery(flags *pflag.FlagSet, clientConfig clientcmd.ClientConfig, discoveryFactory DiscoveryClientFactory) ClientAccessFactory {
+	flags.SetNormalizeFunc(utilflag.WarnWordSepNormalizeFunc) // Warn for "_" flags
+
+	clientCache := NewClientCache(clientConfig, discoveryFactory)
+
+	f := &ring0Factory{
+		flags:            flags,
+		clientConfig:     clientConfig,
+		discoveryFactory: discoveryFactory,
+		clientCache:      clientCache,
+	}
+
+	return f
+}
+
+type discoveryFactory struct {
+	clientConfig clientcmd.ClientConfig
+	cacheDir     string
+}
+
+func (f *discoveryFactory) DiscoveryClient() (discovery.CachedDiscoveryInterface, error) {
+	cfg, err := f.clientConfig.ClientConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	cfg.CacheDir = f.cacheDir
+
+	discoveryClient, err := discovery.NewDiscoveryClientForConfig(cfg)
+	if err != nil {
+		return nil, err
+	}
+	cacheDir := computeDiscoverCacheDir(filepath.Join(homedir.HomeDir(), ".kube", "cache", "discovery"), cfg.Host)
+	return NewCachedDiscoveryClient(discoveryClient, cacheDir, time.Duration(10*time.Minute)), nil
+}
+
+func (f *discoveryFactory) BindFlags(flags *pflag.FlagSet) {
+	defaultCacheDir := filepath.Join(homedir.HomeDir(), ".kube", "http-cache")
+	flags.StringVar(&f.cacheDir, FlagHTTPCacheDir, defaultCacheDir, "Default HTTP cache directory")
+}
+
+// DefaultClientConfig creates a clientcmd.ClientConfig with the following hierarchy:
+//   1.  Use the kubeconfig builder.  The number of merges and overrides here gets a little crazy.  Stay with me.
+//       1.  Merge the kubeconfig itself.  This is done with the following hierarchy rules:
+//           1.  CommandLineLocation - this parsed from the command line, so it must be late bound.  If you specify this,
+//               then no other kubeconfig files are merged.  This file must exist.
+//           2.  If $KUBECONFIG is set, then it is treated as a list of files that should be merged.
+//	     3.  HomeDirectoryLocation
+//           Empty filenames are ignored.  Files with non-deserializable content produced errors.
+//           The first file to set a particular value or map key wins and the value or map key is never changed.
+//           This means that the first file to set CurrentContext will have its context preserved.  It also means
+//           that if two files specify a "red-user", only values from the first file's red-user are used.  Even
+//           non-conflicting entries from the second file's "red-user" are discarded.
+//       2.  Determine the context to use based on the first hit in this chain
+//           1.  command line argument - again, parsed from the command line, so it must be late bound
+//           2.  CurrentContext from the merged kubeconfig file
+//           3.  Empty is allowed at this stage
+//       3.  Determine the cluster info and auth info to use.  At this point, we may or may not have a context.  They
+//           are built based on the first hit in this chain.  (run it twice, once for auth, once for cluster)
+//           1.  command line argument
+//           2.  If context is present, then use the context value
+//           3.  Empty is allowed
+//       4.  Determine the actual cluster info to use.  At this point, we may or may not have a cluster info.  Build
+//           each piece of the cluster info based on the chain:
+//           1.  command line argument
+//           2.  If cluster info is present and a value for the attribute is present, use it.
+//           3.  If you don't have a server location, bail.
+//       5.  Auth info is build using the same rules as cluster info, EXCEPT that you can only have one authentication
+//           technique per auth info.  The following conditions result in an error:
+//           1.  If there are two conflicting techniques specified from the command line, fail.
+//           2.  If the command line does not specify one, and the auth info has conflicting techniques, fail.
+//           3.  If the command line specifies one and the auth info specifies another, honor the command line technique.
+//   2.  Use default values and potentially prompt for auth information
+//
+//   However, if it appears that we're running in a kubernetes cluster
+//   container environment, then run with the auth info kubernetes mounted for
+//   us. Specifically:
+//     The env vars KUBERNETES_SERVICE_HOST and KUBERNETES_SERVICE_PORT are
+//     set, and the file /var/run/secrets/kubernetes.io/serviceaccount/token
+//     exists and is not a directory.
+func DefaultClientConfig(flags *pflag.FlagSet) clientcmd.ClientConfig {
+	loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
+	// use the standard defaults for this client command
+	// DEPRECATED: remove and replace with something more accurate
+	loadingRules.DefaultClientConfig = &clientcmd.DefaultClientConfig
+
+	flags.StringVar(&loadingRules.ExplicitPath, "kubeconfig", "", "Path to the kubeconfig file to use for CLI requests.")
+
+	overrides := &clientcmd.ConfigOverrides{ClusterDefaults: clientcmd.ClusterDefaults}
+
+	flagNames := clientcmd.RecommendedConfigOverrideFlags("")
+	// short flagnames are disabled by default.  These are here for compatibility with existing scripts
+	flagNames.ClusterOverrideFlags.APIServer.ShortName = "s"
+
+	clientcmd.BindOverrideFlags(overrides, flags, flagNames)
+	clientConfig := clientcmd.NewInteractiveDeferredLoadingClientConfig(loadingRules, overrides, os.Stdin)
+
+	return clientConfig
+}
+
+func (f *ring0Factory) DiscoveryClient() (discovery.CachedDiscoveryInterface, error) {
+	return f.discoveryFactory.DiscoveryClient()
+}
+
+func (f *ring0Factory) KubernetesClientSet() (*kubernetes.Clientset, error) {
+	return f.clientCache.KubernetesClientSetForVersion(nil)
+}
+
+func (f *ring0Factory) ClientSet() (internalclientset.Interface, error) {
+	return f.clientCache.ClientSetForVersion(nil)
+}
+
+func (f *ring0Factory) ClientSetForVersion(requiredVersion *schema.GroupVersion) (internalclientset.Interface, error) {
+	return f.clientCache.ClientSetForVersion(requiredVersion)
+}
+
+func (f *ring0Factory) ClientConfig() (*restclient.Config, error) {
+	return f.clientCache.ClientConfigForVersion(nil)
+}
+func (f *ring0Factory) BareClientConfig() (*restclient.Config, error) {
+	return f.clientConfig.ClientConfig()
+}
+
+func (f *ring0Factory) ClientConfigForVersion(requiredVersion *schema.GroupVersion) (*restclient.Config, error) {
+	return f.clientCache.ClientConfigForVersion(nil)
+}
+
+func (f *ring0Factory) RESTClient() (*restclient.RESTClient, error) {
+	clientConfig, err := f.clientCache.ClientConfigForVersion(nil)
+	if err != nil {
+		return nil, err
+	}
+	return restclient.RESTClientFor(clientConfig)
+}
+
+func (f *ring0Factory) FederationClientSetForVersion(version *schema.GroupVersion) (fedclientset.Interface, error) {
+	return f.clientCache.FederationClientSetForVersion(version)
+}
+
+func (f *ring0Factory) FederationClientForVersion(version *schema.GroupVersion) (*restclient.RESTClient, error) {
+	return f.clientCache.FederationClientForVersion(version)
+}
+
+func (f *ring0Factory) Decoder(toInternal bool) runtime.Decoder {
+	var decoder runtime.Decoder
+	if toInternal {
+		decoder = api.Codecs.UniversalDecoder()
+	} else {
+		decoder = api.Codecs.UniversalDeserializer()
+	}
+	return decoder
+}
+
+func (f *ring0Factory) JSONEncoder() runtime.Encoder {
+	return api.Codecs.LegacyCodec(api.Registry.EnabledVersions()...)
+}
+
+func (f *ring0Factory) UpdatePodSpecForObject(obj runtime.Object, fn func(*api.PodSpec) error) (bool, error) {
+	// TODO: replace with a swagger schema based approach (identify pod template via schema introspection)
+	switch t := obj.(type) {
+	case *api.Pod:
+		return true, fn(&t.Spec)
+	case *api.ReplicationController:
+		if t.Spec.Template == nil {
+			t.Spec.Template = &api.PodTemplateSpec{}
+		}
+		return true, fn(&t.Spec.Template.Spec)
+	case *extensions.Deployment:
+		return true, fn(&t.Spec.Template.Spec)
+	case *extensions.DaemonSet:
+		return true, fn(&t.Spec.Template.Spec)
+	case *extensions.ReplicaSet:
+		return true, fn(&t.Spec.Template.Spec)
+	case *apps.StatefulSet:
+		return true, fn(&t.Spec.Template.Spec)
+	case *batch.Job:
+		return true, fn(&t.Spec.Template.Spec)
+	default:
+		return false, fmt.Errorf("the object is not a pod or does not have a pod template")
+	}
+}
+
+func (f *ring0Factory) 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:
+		gvks, _, err := api.Scheme.ObjectKinds(object)
+		if err != nil {
+			return "", err
+		}
+		return "", fmt.Errorf("cannot extract pod selector from %v", gvks[0])
+	}
+}
+
+func (f *ring0Factory) PortsForObject(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 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:
+		gvks, _, err := api.Scheme.ObjectKinds(object)
+		if err != nil {
+			return nil, err
+		}
+		return nil, fmt.Errorf("cannot extract ports from %v", gvks[0])
+	}
+}
+
+func (f *ring0Factory) 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:
+		gvks, _, err := api.Scheme.ObjectKinds(object)
+		if err != nil {
+			return nil, err
+		}
+		return nil, fmt.Errorf("cannot extract protocols from %v", gvks[0])
+	}
+}
+
+func (f *ring0Factory) LabelsForObject(object runtime.Object) (map[string]string, error) {
+	return meta.NewAccessor().Labels(object)
+}
+
+func (f *ring0Factory) FlagSet() *pflag.FlagSet {
+	return f.flags
+}
+
+// Set showSecrets false to filter out stuff like secrets.
+func (f *ring0Factory) Command(cmd *cobra.Command, showSecrets bool) string {
+	if len(os.Args) == 0 {
+		return ""
+	}
+
+	flags := ""
+	parseFunc := func(flag *pflag.Flag, value string) error {
+		flags = flags + " --" + flag.Name
+		if set, ok := flag.Annotations["classified"]; showSecrets || !ok || len(set) == 0 {
+			flags = flags + "=" + value
+		} else {
+			flags = flags + "=CLASSIFIED"
+		}
+		return nil
+	}
+	var err error
+	err = cmd.Flags().ParseAll(os.Args[1:], parseFunc)
+	if err != nil || !cmd.Flags().Parsed() {
+		return ""
+	}
+
+	args := ""
+	if arguments := cmd.Flags().Args(); len(arguments) > 0 {
+		args = " " + strings.Join(arguments, " ")
+	}
+
+	base := filepath.Base(os.Args[0])
+	return base + args + flags
+}
+
+func (f *ring0Factory) BindFlags(flags *pflag.FlagSet) {
+	// Merge factory's flags
+	flags.AddFlagSet(f.flags)
+
+	// Globally persistent flags across all subcommands.
+	// TODO Change flag names to consts to allow safer lookup from subcommands.
+	// TODO Add a verbose flag that turns on glog logging. Probably need a way
+	// to do that automatically for every subcommand.
+	flags.BoolVar(&f.clientCache.matchVersion, FlagMatchBinaryVersion, false, "Require server version to match client version")
+
+	f.discoveryFactory.BindFlags(flags)
+
+	// Normalize all flags that are coming from other packages or pre-configurations
+	// a.k.a. change all "_" to "-". e.g. glog package
+	flags.SetNormalizeFunc(utilflag.WordSepNormalizeFunc)
+}
+
+func (f *ring0Factory) BindExternalFlags(flags *pflag.FlagSet) {
+	// any flags defined by external projects (not part of pflags)
+	flags.AddGoFlagSet(flag.CommandLine)
+}
+
+func (f *ring0Factory) DefaultResourceFilterOptions(cmd *cobra.Command, withNamespace bool) *printers.PrintOptions {
+	columnLabel, err := cmd.Flags().GetStringSlice("label-columns")
+	if err != nil {
+		columnLabel = []string{}
+	}
+	opts := &printers.PrintOptions{
+		NoHeaders:          GetFlagBool(cmd, "no-headers"),
+		WithNamespace:      withNamespace,
+		Wide:               GetWideFlag(cmd),
+		ShowAll:            GetFlagBool(cmd, "show-all"),
+		ShowLabels:         GetFlagBool(cmd, "show-labels"),
+		AbsoluteTimestamps: isWatch(cmd),
+		ColumnLabels:       columnLabel,
+	}
+
+	return opts
+}
+
+func (f *ring0Factory) DefaultResourceFilterFunc() kubectl.Filters {
+	return kubectl.NewResourceFilter()
+}
+
+func (f *ring0Factory) SuggestedPodTemplateResources() []schema.GroupResource {
+	return []schema.GroupResource{
+		{Resource: "replicationcontroller"},
+		{Resource: "deployment"},
+		{Resource: "daemonset"},
+		{Resource: "job"},
+		{Resource: "replicaset"},
+	}
+}
+
+func (f *ring0Factory) Printer(mapping *meta.RESTMapping, options printers.PrintOptions) (printers.ResourcePrinter, error) {
+	p := printers.NewHumanReadablePrinter(f.JSONEncoder(), f.Decoder(true), options)
+	printersinternal.AddHandlers(p)
+	return p, nil
+}
+
+func (f *ring0Factory) Pauser(info *resource.Info) ([]byte, error) {
+	switch obj := info.Object.(type) {
+	case *extensions.Deployment:
+		if obj.Spec.Paused {
+			return nil, errors.New("is already paused")
+		}
+		obj.Spec.Paused = true
+		return runtime.Encode(f.JSONEncoder(), info.Object)
+	default:
+		return nil, fmt.Errorf("pausing is not supported")
+	}
+}
+
+func (f *ring0Factory) ResolveImage(name string) (string, error) {
+	return name, nil
+}
+
+func (f *ring0Factory) Resumer(info *resource.Info) ([]byte, error) {
+	switch obj := info.Object.(type) {
+	case *extensions.Deployment:
+		if !obj.Spec.Paused {
+			return nil, errors.New("is not paused")
+		}
+		obj.Spec.Paused = false
+		return runtime.Encode(f.JSONEncoder(), info.Object)
+	default:
+		return nil, fmt.Errorf("resuming is not supported")
+	}
+}
+
+func (f *ring0Factory) DefaultNamespace() (string, bool, error) {
+	return f.clientConfig.Namespace()
+}
+
+const (
+	// TODO(sig-cli): Enforce consistent naming for generators here.
+	// See discussion in https://github.com/kubernetes/kubernetes/issues/46237
+	// before you add any more.
+	RunV1GeneratorName                      = "run/v1"
+	RunPodV1GeneratorName                   = "run-pod/v1"
+	ServiceV1GeneratorName                  = "service/v1"
+	ServiceV2GeneratorName                  = "service/v2"
+	ServiceNodePortGeneratorV1Name          = "service-nodeport/v1"
+	ServiceClusterIPGeneratorV1Name         = "service-clusterip/v1"
+	ServiceLoadBalancerGeneratorV1Name      = "service-loadbalancer/v1"
+	ServiceExternalNameGeneratorV1Name      = "service-externalname/v1"
+	ServiceAccountV1GeneratorName           = "serviceaccount/v1"
+	HorizontalPodAutoscalerV1GeneratorName  = "horizontalpodautoscaler/v1"
+	DeploymentV1Beta1GeneratorName          = "deployment/v1beta1"
+	DeploymentAppsV1Beta1GeneratorName      = "deployment/apps.v1beta1"
+	DeploymentBasicV1Beta1GeneratorName     = "deployment-basic/v1beta1"
+	DeploymentBasicAppsV1Beta1GeneratorName = "deployment-basic/apps.v1beta1"
+	JobV1GeneratorName                      = "job/v1"
+	CronJobV2Alpha1GeneratorName            = "cronjob/v2alpha1"
+	CronJobV1Beta1GeneratorName             = "cronjob/v1beta1"
+	NamespaceV1GeneratorName                = "namespace/v1"
+	ResourceQuotaV1GeneratorName            = "resourcequotas/v1"
+	SecretV1GeneratorName                   = "secret/v1"
+	SecretForDockerRegistryV1GeneratorName  = "secret-for-docker-registry/v1"
+	SecretForTLSV1GeneratorName             = "secret-for-tls/v1"
+	ConfigMapV1GeneratorName                = "configmap/v1"
+	ClusterRoleBindingV1GeneratorName       = "clusterrolebinding.rbac.authorization.k8s.io/v1alpha1"
+	RoleBindingV1GeneratorName              = "rolebinding.rbac.authorization.k8s.io/v1alpha1"
+	ClusterV1Beta1GeneratorName             = "cluster/v1beta1"
+	PodDisruptionBudgetV1GeneratorName      = "poddisruptionbudget/v1beta1"
+	PodDisruptionBudgetV2GeneratorName      = "poddisruptionbudget/v1beta1/v2"
+)
+
+// DefaultGenerators returns the set of default generators for use in Factory instances
+func DefaultGenerators(cmdName string) map[string]kubectl.Generator {
+	var generator map[string]kubectl.Generator
+	switch cmdName {
+	case "expose":
+		generator = map[string]kubectl.Generator{
+			ServiceV1GeneratorName: kubectl.ServiceGeneratorV1{},
+			ServiceV2GeneratorName: kubectl.ServiceGeneratorV2{},
+		}
+	case "service-clusterip":
+		generator = map[string]kubectl.Generator{
+			ServiceClusterIPGeneratorV1Name: kubectl.ServiceClusterIPGeneratorV1{},
+		}
+	case "service-nodeport":
+		generator = map[string]kubectl.Generator{
+			ServiceNodePortGeneratorV1Name: kubectl.ServiceNodePortGeneratorV1{},
+		}
+	case "service-loadbalancer":
+		generator = map[string]kubectl.Generator{
+			ServiceLoadBalancerGeneratorV1Name: kubectl.ServiceLoadBalancerGeneratorV1{},
+		}
+	case "deployment":
+		// Create Deployment has only StructuredGenerators and no
+		// param-based Generators.
+		// The StructuredGenerators are as follows (as of 2017-07-17):
+		// DeploymentBasicV1Beta1GeneratorName -> kubectl.DeploymentBasicGeneratorV1
+		// DeploymentBasicAppsV1Beta1GeneratorName -> kubectl.DeploymentBasicAppsGeneratorV1
+		generator = map[string]kubectl.Generator{}
+	case "run":
+		generator = map[string]kubectl.Generator{
+			RunV1GeneratorName:                 kubectl.BasicReplicationController{},
+			RunPodV1GeneratorName:              kubectl.BasicPod{},
+			DeploymentV1Beta1GeneratorName:     kubectl.DeploymentV1Beta1{},
+			DeploymentAppsV1Beta1GeneratorName: kubectl.DeploymentAppsV1Beta1{},
+			JobV1GeneratorName:                 kubectl.JobV1{},
+			CronJobV2Alpha1GeneratorName:       kubectl.CronJobV2Alpha1{},
+			CronJobV1Beta1GeneratorName:        kubectl.CronJobV1Beta1{},
+		}
+	case "autoscale":
+		generator = map[string]kubectl.Generator{
+			HorizontalPodAutoscalerV1GeneratorName: kubectl.HorizontalPodAutoscalerV1{},
+		}
+	case "namespace":
+		generator = map[string]kubectl.Generator{
+			NamespaceV1GeneratorName: kubectl.NamespaceGeneratorV1{},
+		}
+	case "quota":
+		generator = map[string]kubectl.Generator{
+			ResourceQuotaV1GeneratorName: kubectl.ResourceQuotaGeneratorV1{},
+		}
+	case "secret":
+		generator = map[string]kubectl.Generator{
+			SecretV1GeneratorName: kubectl.SecretGeneratorV1{},
+		}
+	case "secret-for-docker-registry":
+		generator = map[string]kubectl.Generator{
+			SecretForDockerRegistryV1GeneratorName: kubectl.SecretForDockerRegistryGeneratorV1{},
+		}
+	case "secret-for-tls":
+		generator = map[string]kubectl.Generator{
+			SecretForTLSV1GeneratorName: kubectl.SecretForTLSGeneratorV1{},
+		}
+	}
+
+	return generator
+}
+
+func (f *ring0Factory) Generators(cmdName string) map[string]kubectl.Generator {
+	return DefaultGenerators(cmdName)
+}
+
+func (f *ring0Factory) 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
+}
+
+func (f *ring0Factory) 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
+}
+
+func (f *ring0Factory) EditorEnvs() []string {
+	return []string{"KUBE_EDITOR", "EDITOR"}
+}
+
+func (f *ring0Factory) PrintObjectSpecificMessage(obj runtime.Object, out io.Writer) {
+	switch obj := obj.(type) {
+	case *api.Service:
+		if obj.Spec.Type == api.ServiceTypeNodePort {
+			msg := fmt.Sprintf(
+				`You have exposed your service on an external port on all nodes in your
+cluster.  If you want to expose this service to the external internet, you may
+need to set up firewall rules for the service port(s) (%s) to serve traffic.
+
+See http://kubernetes.io/docs/user-guide/services-firewalls for more details.
+`,
+				makePortsString(obj.Spec.Ports, true))
+			out.Write([]byte(msg))
+		}
+
+		if _, ok := obj.Annotations[api.AnnotationLoadBalancerSourceRangesKey]; ok {
+			msg := fmt.Sprintf(
+				`You are using service annotation [service.beta.kubernetes.io/load-balancer-source-ranges].
+It has been promoted to field [loadBalancerSourceRanges] in service spec. This annotation will be deprecated in the future.
+Please use the loadBalancerSourceRanges field instead.
+
+See http://kubernetes.io/docs/user-guide/services-firewalls for more details.
+`)
+			out.Write([]byte(msg))
+		}
+	}
+}
+
+// overlyCautiousIllegalFileCharacters matches characters that *might* not be supported.  Windows is really restrictive, so this is really restrictive
+var overlyCautiousIllegalFileCharacters = regexp.MustCompile(`[^(\w/\.)]`)
+
+// computeDiscoverCacheDir takes the parentDir and the host and comes up with a "usually non-colliding" name.
+func computeDiscoverCacheDir(parentDir, host string) string {
+	// strip the optional scheme from host if its there:
+	schemelessHost := strings.Replace(strings.Replace(host, "https://", "", 1), "http://", "", 1)
+	// now do a simple collapse of non-AZ09 characters.  Collisions are possible but unlikely.  Even if we do collide the problem is short lived
+	safeHost := overlyCautiousIllegalFileCharacters.ReplaceAllString(schemelessHost, "_")
+
+	return filepath.Join(parentDir, safeHost)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/factory_object_mapping.go

@@ -0,0 +1,475 @@
+/*
+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.
+*/
+
+// this file contains factories with no other dependencies
+
+package util
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"sort"
+	"sync"
+	"time"
+
+	swagger "github.com/emicklei/go-restful-swagger12"
+	"github.com/golang/glog"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/discovery"
+	"k8s.io/client-go/dynamic"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/kubernetes/federation/apis/federation"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	"k8s.io/kubernetes/pkg/apis/batch"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	client "k8s.io/kubernetes/pkg/client/unversioned"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+	openapivalidation "k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/validation"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/kubectl/validation"
+	"k8s.io/kubernetes/pkg/printers"
+	printersinternal "k8s.io/kubernetes/pkg/printers/internalversion"
+)
+
+type ring1Factory struct {
+	clientAccessFactory ClientAccessFactory
+
+	// openAPIGetter loads and caches openapi specs
+	openAPIGetter openAPIGetter
+}
+
+type openAPIGetter struct {
+	once   sync.Once
+	getter openapi.Getter
+}
+
+func NewObjectMappingFactory(clientAccessFactory ClientAccessFactory) ObjectMappingFactory {
+	f := &ring1Factory{
+		clientAccessFactory: clientAccessFactory,
+	}
+	return f
+}
+
+// TODO: This method should return an error now that it can fail.  Alternatively, it needs to
+//   return lazy implementations of mapper and typer that don't hit the wire until they are
+//   invoked.
+func (f *ring1Factory) Object() (meta.RESTMapper, runtime.ObjectTyper) {
+	mapper := api.Registry.RESTMapper()
+	discoveryClient, err := f.clientAccessFactory.DiscoveryClient()
+	if err == nil {
+		mapper = meta.FirstHitRESTMapper{
+			MultiRESTMapper: meta.MultiRESTMapper{
+				discovery.NewDeferredDiscoveryRESTMapper(discoveryClient, api.Registry.InterfacesFor),
+				api.Registry.RESTMapper(), // hardcoded fall back
+			},
+		}
+
+		// wrap with shortcuts, they require a discoveryClient
+		mapper, err = NewShortcutExpander(mapper, discoveryClient)
+		// you only have an error on missing discoveryClient, so this shouldn't fail.  Check anyway.
+		CheckErr(err)
+	}
+
+	return mapper, api.Scheme
+}
+
+func (f *ring1Factory) UnstructuredObject() (meta.RESTMapper, runtime.ObjectTyper, error) {
+	discoveryClient, err := f.clientAccessFactory.DiscoveryClient()
+	if err != nil {
+		return nil, nil, err
+	}
+	groupResources, err := discovery.GetAPIGroupResources(discoveryClient)
+	if err != nil && !discoveryClient.Fresh() {
+		discoveryClient.Invalidate()
+		groupResources, err = discovery.GetAPIGroupResources(discoveryClient)
+	}
+	if err != nil {
+		return nil, nil, err
+	}
+
+	mapper := discovery.NewDeferredDiscoveryRESTMapper(discoveryClient, meta.InterfacesForUnstructured)
+	typer := discovery.NewUnstructuredObjectTyper(groupResources)
+	expander, err := NewShortcutExpander(mapper, discoveryClient)
+	return expander, typer, err
+}
+
+func (f *ring1Factory) CategoryExpander() resource.CategoryExpander {
+	legacyExpander := resource.LegacyCategoryExpander
+
+	discoveryClient, err := f.clientAccessFactory.DiscoveryClient()
+	if err == nil {
+		// fallback is the legacy expander wrapped with discovery based filtering
+		fallbackExpander, err := resource.NewDiscoveryFilteredExpander(legacyExpander, discoveryClient)
+		CheckErr(err)
+
+		// by default use the expander that discovers based on "categories" field from the API
+		discoveryCategoryExpander, err := resource.NewDiscoveryCategoryExpander(fallbackExpander, discoveryClient)
+		CheckErr(err)
+
+		return discoveryCategoryExpander
+	}
+
+	return legacyExpander
+}
+
+func (f *ring1Factory) ClientForMapping(mapping *meta.RESTMapping) (resource.RESTClient, error) {
+	cfg, err := f.clientAccessFactory.ClientConfig()
+	if err != nil {
+		return nil, err
+	}
+	if err := client.SetKubernetesDefaults(cfg); err != nil {
+		return nil, err
+	}
+	gvk := mapping.GroupVersionKind
+	switch gvk.Group {
+	case federation.GroupName:
+		mappingVersion := mapping.GroupVersionKind.GroupVersion()
+		return f.clientAccessFactory.FederationClientForVersion(&mappingVersion)
+	case api.GroupName:
+		cfg.APIPath = "/api"
+	default:
+		cfg.APIPath = "/apis"
+	}
+	gv := gvk.GroupVersion()
+	cfg.GroupVersion = &gv
+	return restclient.RESTClientFor(cfg)
+}
+
+func (f *ring1Factory) UnstructuredClientForMapping(mapping *meta.RESTMapping) (resource.RESTClient, error) {
+	cfg, err := f.clientAccessFactory.BareClientConfig()
+	if err != nil {
+		return nil, err
+	}
+	if err := restclient.SetKubernetesDefaults(cfg); err != nil {
+		return nil, err
+	}
+	cfg.APIPath = "/apis"
+	if mapping.GroupVersionKind.Group == api.GroupName {
+		cfg.APIPath = "/api"
+	}
+	gv := mapping.GroupVersionKind.GroupVersion()
+	cfg.ContentConfig = dynamic.ContentConfig()
+	cfg.GroupVersion = &gv
+	return restclient.RESTClientFor(cfg)
+}
+
+func (f *ring1Factory) Describer(mapping *meta.RESTMapping) (printers.Describer, error) {
+	mappingVersion := mapping.GroupVersionKind.GroupVersion()
+	if mapping.GroupVersionKind.Group == federation.GroupName {
+		fedClientSet, err := f.clientAccessFactory.FederationClientSetForVersion(&mappingVersion)
+		if err != nil {
+			return nil, err
+		}
+		if mapping.GroupVersionKind.Kind == "Cluster" {
+			return &printersinternal.ClusterDescriber{Interface: fedClientSet}, nil
+		}
+	}
+
+	clientset, err := f.clientAccessFactory.ClientSetForVersion(&mappingVersion)
+	if err != nil {
+		// if we can't make a client for this group/version, go generic if possible
+		if genericDescriber, genericErr := genericDescriber(f.clientAccessFactory, mapping); genericErr == nil {
+			return genericDescriber, nil
+		}
+		// otherwise return the original error
+		return nil, err
+	}
+
+	// try to get a describer
+	if describer, ok := printersinternal.DescriberFor(mapping.GroupVersionKind.GroupKind(), clientset); ok {
+		return describer, nil
+	}
+	// if this is a kind we don't have a describer for yet, go generic if possible
+	if genericDescriber, genericErr := genericDescriber(f.clientAccessFactory, mapping); genericErr == nil {
+		return genericDescriber, nil
+	}
+	// otherwise return an unregistered error
+	return nil, fmt.Errorf("no description has been implemented for %s", mapping.GroupVersionKind.String())
+}
+
+// helper function to make a generic describer, or return an error
+func genericDescriber(clientAccessFactory ClientAccessFactory, mapping *meta.RESTMapping) (printers.Describer, error) {
+	clientConfig, err := clientAccessFactory.ClientConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	clientConfigCopy := *clientConfig
+	clientConfigCopy.APIPath = dynamic.LegacyAPIPathResolverFunc(mapping.GroupVersionKind)
+	gv := mapping.GroupVersionKind.GroupVersion()
+	clientConfigCopy.GroupVersion = &gv
+
+	// used to fetch the resource
+	dynamicClient, err := dynamic.NewClient(&clientConfigCopy)
+	if err != nil {
+		return nil, err
+	}
+
+	// used to get events for the resource
+	clientSet, err := clientAccessFactory.ClientSet()
+	if err != nil {
+		return nil, err
+	}
+	eventsClient := clientSet.Core()
+
+	return printersinternal.GenericDescriberFor(mapping, dynamicClient, eventsClient), nil
+}
+
+func (f *ring1Factory) LogsForObject(object, options runtime.Object, timeout time.Duration) (*restclient.Request, error) {
+	clientset, err := f.clientAccessFactory.ClientSetForVersion(nil)
+	if err != nil {
+		return nil, err
+	}
+	opts, ok := options.(*api.PodLogOptions)
+	if !ok {
+		return nil, errors.New("provided options object is not a PodLogOptions")
+	}
+
+	var selector labels.Selector
+	var namespace string
+	switch t := object.(type) {
+	case *api.Pod:
+		return clientset.Core().Pods(t.Namespace).GetLogs(t.Name, opts), nil
+
+	case *api.ReplicationController:
+		namespace = t.Namespace
+		selector = labels.SelectorFromSet(t.Spec.Selector)
+
+	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 *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 *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 *apps.StatefulSet:
+		namespace = t.Namespace
+		selector, err = metav1.LabelSelectorAsSelector(t.Spec.Selector)
+		if err != nil {
+			return nil, fmt.Errorf("invalid label selector: %v", err)
+		}
+
+	default:
+		gvks, _, err := api.Scheme.ObjectKinds(object)
+		if err != nil {
+			return nil, err
+		}
+		return nil, fmt.Errorf("cannot get the logs from %v", gvks[0])
+	}
+
+	sortBy := func(pods []*v1.Pod) sort.Interface { return controller.ByLogging(pods) }
+	pod, numPods, err := GetFirstPod(clientset.Core(), namespace, selector, 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
+}
+
+func (f *ring1Factory) Scaler(mapping *meta.RESTMapping) (kubectl.Scaler, error) {
+	mappingVersion := mapping.GroupVersionKind.GroupVersion()
+	clientset, err := f.clientAccessFactory.ClientSetForVersion(&mappingVersion)
+	if err != nil {
+		return nil, err
+	}
+	return kubectl.ScalerFor(mapping.GroupVersionKind.GroupKind(), clientset)
+}
+
+func (f *ring1Factory) Reaper(mapping *meta.RESTMapping) (kubectl.Reaper, error) {
+	mappingVersion := mapping.GroupVersionKind.GroupVersion()
+	clientset, clientsetErr := f.clientAccessFactory.ClientSetForVersion(&mappingVersion)
+	reaper, reaperErr := kubectl.ReaperFor(mapping.GroupVersionKind.GroupKind(), clientset)
+
+	if kubectl.IsNoSuchReaperError(reaperErr) {
+		return nil, reaperErr
+	}
+	if clientsetErr != nil {
+		return nil, clientsetErr
+	}
+	return reaper, reaperErr
+}
+
+func (f *ring1Factory) HistoryViewer(mapping *meta.RESTMapping) (kubectl.HistoryViewer, error) {
+	mappingVersion := mapping.GroupVersionKind.GroupVersion()
+	clientset, err := f.clientAccessFactory.ClientSetForVersion(&mappingVersion)
+	if err != nil {
+		return nil, err
+	}
+	return kubectl.HistoryViewerFor(mapping.GroupVersionKind.GroupKind(), clientset)
+}
+
+func (f *ring1Factory) Rollbacker(mapping *meta.RESTMapping) (kubectl.Rollbacker, error) {
+	mappingVersion := mapping.GroupVersionKind.GroupVersion()
+	clientset, err := f.clientAccessFactory.ClientSetForVersion(&mappingVersion)
+	if err != nil {
+		return nil, err
+	}
+	return kubectl.RollbackerFor(mapping.GroupVersionKind.GroupKind(), clientset)
+}
+
+func (f *ring1Factory) StatusViewer(mapping *meta.RESTMapping) (kubectl.StatusViewer, error) {
+	mappingVersion := mapping.GroupVersionKind.GroupVersion()
+	clientset, err := f.clientAccessFactory.ClientSetForVersion(&mappingVersion)
+	if err != nil {
+		return nil, err
+	}
+	return kubectl.StatusViewerFor(mapping.GroupVersionKind.GroupKind(), clientset)
+}
+
+func (f *ring1Factory) AttachablePodForObject(object runtime.Object, timeout time.Duration) (*api.Pod, error) {
+	clientset, err := f.clientAccessFactory.ClientSetForVersion(nil)
+	if err != nil {
+		return nil, err
+	}
+	var selector labels.Selector
+	var namespace string
+	switch t := object.(type) {
+	case *extensions.ReplicaSet:
+		namespace = t.Namespace
+		selector = labels.SelectorFromSet(t.Spec.Selector.MatchLabels)
+
+	case *api.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 *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 *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 *api.Pod:
+		return t, nil
+
+	default:
+		gvks, _, err := api.Scheme.ObjectKinds(object)
+		if err != nil {
+			return nil, err
+		}
+		return nil, fmt.Errorf("cannot attach to %v: not implemented", gvks[0])
+	}
+
+	sortBy := func(pods []*v1.Pod) sort.Interface { return sort.Reverse(controller.ActivePods(pods)) }
+	pod, _, err := GetFirstPod(clientset.Core(), namespace, selector, timeout, sortBy)
+	return pod, err
+}
+
+func (f *ring1Factory) Validator(validate, openapi bool, cacheDir string) (validation.Schema, error) {
+	if validate {
+		if openapi {
+			resources, err := f.OpenAPISchema()
+			if err == nil {
+				return validation.ConjunctiveSchema{
+					openapivalidation.NewSchemaValidation(resources),
+					validation.NoDoubleKeySchema{},
+				}, nil
+			}
+
+			glog.Warningf("Failed to download OpenAPI (%v), falling back to swagger", err)
+		}
+
+		discovery, err := f.clientAccessFactory.DiscoveryClient()
+		if err != nil {
+			return nil, err
+		}
+		dir := cacheDir
+		if len(dir) > 0 {
+			version, err := discovery.ServerVersion()
+			if err == nil {
+				dir = path.Join(cacheDir, version.String())
+			} else {
+				dir = "" // disable caching as a fallback
+			}
+		}
+		swaggerSchema := &clientSwaggerSchema{
+			c:        discovery.RESTClient(),
+			cacheDir: dir,
+		}
+		return validation.ConjunctiveSchema{
+			swaggerSchema,
+			validation.NoDoubleKeySchema{},
+		}, nil
+	}
+	return validation.NullSchema{}, nil
+}
+
+func (f *ring1Factory) SwaggerSchema(gvk schema.GroupVersionKind) (*swagger.ApiDeclaration, error) {
+	version := gvk.GroupVersion()
+	discovery, err := f.clientAccessFactory.DiscoveryClient()
+	if err != nil {
+		return nil, err
+	}
+	return discovery.SwaggerSchema(version)
+}
+
+// OpenAPISchema returns metadata and structural information about Kubernetes object definitions.
+func (f *ring1Factory) OpenAPISchema() (openapi.Resources, error) {
+	discovery, err := f.clientAccessFactory.DiscoveryClient()
+	if err != nil {
+		return nil, err
+	}
+
+	// Lazily initialize the OpenAPIGetter once
+	f.openAPIGetter.once.Do(func() {
+		// Create the caching OpenAPIGetter
+		f.openAPIGetter.getter = openapi.NewOpenAPIGetter(discovery)
+	})
+
+	// Delegate to the OpenAPIGetter
+	return f.openAPIGetter.getter.Get()
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/factory_object_mapping_test.go

@@ -0,0 +1,194 @@
+/*
+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 util
+
+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/api"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	"k8s.io/kubernetes/pkg/apis/batch"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake"
+)
+
+type fakeClientAccessFactory struct {
+	ClientAccessFactory
+
+	fakeClientset *fake.Clientset
+}
+
+func (f *fakeClientAccessFactory) ClientSetForVersion(requiredVersion *schema.GroupVersion) (internalclientset.Interface, error) {
+	return f.fakeClientset, nil
+}
+
+func newFakeClientAccessFactory(objs []runtime.Object) *fakeClientAccessFactory {
+	return &fakeClientAccessFactory{
+		fakeClientset: fake.NewSimpleClientset(objs...),
+	}
+}
+
+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 {
+		caf := newFakeClientAccessFactory(test.pods)
+		omf := NewObjectMappingFactory(caf)
+		_, err := omf.LogsForObject(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(caf.fakeClientset.Actions()) < i {
+				t.Errorf("%s: action %d does not exists in actual actions: %#v",
+					test.name, i, caf.fakeClientset.Actions())
+				continue
+			}
+			got := caf.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/cmd/util/factory_test.go

@@ -0,0 +1,762 @@
+/*
+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 util
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"os/user"
+	"path"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/apiserver/pkg/util/flag"
+	manualfake "k8s.io/client-go/rest/fake"
+	testcore "k8s.io/client-go/testing"
+	"k8s.io/client-go/tools/clientcmd"
+	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/testapi"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/kubectl/validation"
+)
+
+func TestNewFactoryDefaultFlagBindings(t *testing.T) {
+	factory := NewFactory(nil)
+
+	if !factory.FlagSet().HasFlags() {
+		t.Errorf("Expected flags, but didn't get any")
+	}
+}
+
+func TestNewFactoryNoFlagBindings(t *testing.T) {
+	clientConfig := clientcmd.NewDefaultClientConfig(*clientcmdapi.NewConfig(), &clientcmd.ConfigOverrides{})
+	factory := NewFactory(clientConfig)
+
+	if factory.FlagSet().HasFlags() {
+		t.Errorf("Expected zero flags, but got %v", factory.FlagSet())
+	}
+}
+
+func TestPortsForObject(t *testing.T) {
+	f := NewFactory(nil)
+
+	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 := f.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)
+	}
+}
+
+func TestProtocolsForObject(t *testing.T) {
+	f := NewFactory(nil)
+
+	pod := &api.Pod{
+		ObjectMeta: metav1.ObjectMeta{Name: "baz", Namespace: "test", ResourceVersion: "12"},
+		Spec: api.PodSpec{
+			Containers: []api.Container{
+				{
+					Ports: []api.ContainerPort{
+						{
+							ContainerPort: 101,
+							Protocol:      api.ProtocolTCP,
+						},
+						{
+							ContainerPort: 102,
+							Protocol:      api.ProtocolUDP,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	expected := sets.NewString("101/TCP", "102/UDP")
+	protocolsMap, err := f.ProtocolsForObject(pod)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+
+	protocolsString := kubectl.MakeProtocols(protocolsMap)
+	protocolsStrings := strings.Split(protocolsString, ",")
+	got := sets.NewString(protocolsStrings...)
+
+	if !expected.Equal(got) {
+		t.Fatalf("Protocols mismatch! Expected %v, got %v", expected, got)
+	}
+}
+
+func TestLabelsForObject(t *testing.T) {
+	f := NewFactory(nil)
+
+	tests := []struct {
+		name     string
+		object   runtime.Object
+		expected string
+		err      error
+	}{
+		{
+			name: "successful re-use of labels",
+			object: &api.Service{
+				ObjectMeta: metav1.ObjectMeta{Name: "baz", Namespace: "test", Labels: map[string]string{"svc": "test"}},
+				TypeMeta:   metav1.TypeMeta{Kind: "Service", APIVersion: "v1"},
+			},
+			expected: "svc=test",
+			err:      nil,
+		},
+		{
+			name: "empty labels",
+			object: &api.Service{
+				ObjectMeta: metav1.ObjectMeta{Name: "foo", Namespace: "test", Labels: map[string]string{}},
+				TypeMeta:   metav1.TypeMeta{Kind: "Service", APIVersion: "v1"},
+			},
+			expected: "",
+			err:      nil,
+		},
+		{
+			name: "nil labels",
+			object: &api.Service{
+				ObjectMeta: metav1.ObjectMeta{Name: "zen", Namespace: "test", Labels: nil},
+				TypeMeta:   metav1.TypeMeta{Kind: "Service", APIVersion: "v1"},
+			},
+			expected: "",
+			err:      nil,
+		},
+	}
+
+	for _, test := range tests {
+		gotLabels, err := f.LabelsForObject(test.object)
+		if err != test.err {
+			t.Fatalf("%s: Error mismatch: Expected %v, got %v", test.name, test.err, err)
+		}
+		got := kubectl.MakeLabels(gotLabels)
+		if test.expected != got {
+			t.Fatalf("%s: Labels mismatch! Expected %s, got %s", test.name, test.expected, got)
+		}
+
+	}
+}
+
+func TestCanBeExposed(t *testing.T) {
+	factory := NewFactory(nil)
+	tests := []struct {
+		kind      schema.GroupKind
+		expectErr bool
+	}{
+		{
+			kind:      api.Kind("ReplicationController"),
+			expectErr: false,
+		},
+		{
+			kind:      api.Kind("Node"),
+			expectErr: true,
+		},
+	}
+
+	for _, test := range tests {
+		err := factory.CanBeExposed(test.kind)
+		if test.expectErr && err == nil {
+			t.Error("unexpected non-error")
+		}
+		if !test.expectErr && err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+	}
+}
+
+func TestFlagUnderscoreRenaming(t *testing.T) {
+	factory := NewFactory(nil)
+
+	factory.FlagSet().SetNormalizeFunc(flag.WordSepNormalizeFunc)
+	factory.FlagSet().Bool("valid_flag", false, "bool value")
+
+	// In case of failure of this test check this PR: spf13/pflag#23
+	if factory.FlagSet().Lookup("valid_flag").Name != "valid-flag" {
+		t.Fatalf("Expected flag name to be valid-flag, got %s", factory.FlagSet().Lookup("valid_flag").Name)
+	}
+}
+
+func loadSchemaForTest() (validation.Schema, error) {
+	pathToSwaggerSpec := "../../../../api/swagger-spec/" + api.Registry.GroupOrDie(api.GroupName).GroupVersion.Version + ".json"
+	data, err := ioutil.ReadFile(pathToSwaggerSpec)
+	if err != nil {
+		return nil, err
+	}
+	return validation.NewSwaggerSchemaFromBytes(data, nil)
+}
+
+func header() http.Header {
+	header := http.Header{}
+	header.Set("Content-Type", runtime.ContentTypeJSON)
+	return header
+}
+
+func TestRefetchSchemaWhenValidationFails(t *testing.T) {
+	schema, err := loadSchemaForTest()
+	if err != nil {
+		t.Errorf("Error loading schema: %v", err)
+		t.FailNow()
+	}
+	output, err := json.Marshal(schema)
+	if err != nil {
+		t.Errorf("Error serializing schema: %v", err)
+		t.FailNow()
+	}
+	requests := map[string]int{}
+
+	c := &manualfake.RESTClient{
+		APIRegistry:          api.Registry,
+		NegotiatedSerializer: testapi.Default.NegotiatedSerializer(),
+		Client: manualfake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case strings.HasPrefix(p, "/swaggerapi") && m == "GET":
+				requests[p] = requests[p] + 1
+				return &http.Response{StatusCode: 200, Header: header(), Body: ioutil.NopCloser(bytes.NewBuffer(output))}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	dir, err := ioutil.TempDir("", "schemaCache")
+	if err != nil {
+		t.Fatalf("Error getting tempDir: %v", err)
+	}
+	defer os.RemoveAll(dir)
+
+	fullDir, err := substituteUserHome(dir)
+	if err != nil {
+		t.Errorf("Error getting fullDir: %v", err)
+		t.FailNow()
+	}
+	cacheFile := path.Join(fullDir, "foo", "bar", schemaFileName)
+	err = writeSchemaFile(output, fullDir, cacheFile, "foo", "bar")
+	if err != nil {
+		t.Errorf("Error building old cache schema: %v", err)
+		t.FailNow()
+	}
+
+	obj := &extensions.Deployment{}
+	data, err := runtime.Encode(testapi.Extensions.Codec(), obj)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+		t.FailNow()
+	}
+
+	// Re-get request, should use HTTP and write
+	if getSchemaAndValidate(c, data, "foo", "bar", dir, nil); err != nil {
+		t.Errorf("unexpected error validating: %v", err)
+	}
+	if requests["/swaggerapi/foo/bar"] != 1 {
+		t.Errorf("expected 1 schema request, saw: %d", requests["/swaggerapi/foo/bar"])
+	}
+}
+
+func TestValidateCachesSchema(t *testing.T) {
+	schema, err := loadSchemaForTest()
+	if err != nil {
+		t.Errorf("Error loading schema: %v", err)
+		t.FailNow()
+	}
+	output, err := json.Marshal(schema)
+	if err != nil {
+		t.Errorf("Error serializing schema: %v", err)
+		t.FailNow()
+	}
+	requests := map[string]int{}
+
+	c := &manualfake.RESTClient{
+		APIRegistry:          api.Registry,
+		NegotiatedSerializer: testapi.Default.NegotiatedSerializer(),
+		Client: manualfake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case strings.HasPrefix(p, "/swaggerapi") && m == "GET":
+				requests[p] = requests[p] + 1
+				return &http.Response{StatusCode: 200, Header: header(), Body: ioutil.NopCloser(bytes.NewBuffer(output))}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	dir, err := ioutil.TempDir("", "schemaCache")
+	if err != nil {
+		t.Fatalf("Error getting tempDir: %v", err)
+	}
+	defer os.RemoveAll(dir)
+
+	obj := &api.Pod{}
+	data, err := runtime.Encode(testapi.Default.Codec(), obj)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+		t.FailNow()
+	}
+
+	// Initial request, should use HTTP and write
+	if getSchemaAndValidate(c, data, "foo", "bar", dir, nil); err != nil {
+		t.Errorf("unexpected error validating: %v", err)
+	}
+	if _, err := os.Stat(path.Join(dir, "foo", "bar", schemaFileName)); err != nil {
+		t.Errorf("unexpected missing cache file: %v", err)
+	}
+	if requests["/swaggerapi/foo/bar"] != 1 {
+		t.Errorf("expected 1 schema request, saw: %d", requests["/swaggerapi/foo/bar"])
+	}
+
+	// Same version and group, should skip HTTP
+	if getSchemaAndValidate(c, data, "foo", "bar", dir, nil); err != nil {
+		t.Errorf("unexpected error validating: %v", err)
+	}
+	if requests["/swaggerapi/foo/bar"] != 2 {
+		t.Errorf("expected 1 schema request, saw: %d", requests["/swaggerapi/foo/bar"])
+	}
+
+	// Different API group, should go to HTTP and write
+	if getSchemaAndValidate(c, data, "foo", "baz", dir, nil); err != nil {
+		t.Errorf("unexpected error validating: %v", err)
+	}
+	if _, err := os.Stat(path.Join(dir, "foo", "baz", schemaFileName)); err != nil {
+		t.Errorf("unexpected missing cache file: %v", err)
+	}
+	if requests["/swaggerapi/foo/baz"] != 1 {
+		t.Errorf("expected 1 schema request, saw: %d", requests["/swaggerapi/foo/baz"])
+	}
+
+	// Different version, should go to HTTP and write
+	if getSchemaAndValidate(c, data, "foo2", "bar", dir, nil); err != nil {
+		t.Errorf("unexpected error validating: %v", err)
+	}
+	if _, err := os.Stat(path.Join(dir, "foo2", "bar", schemaFileName)); err != nil {
+		t.Errorf("unexpected missing cache file: %v", err)
+	}
+	if requests["/swaggerapi/foo2/bar"] != 1 {
+		t.Errorf("expected 1 schema request, saw: %d", requests["/swaggerapi/foo2/bar"])
+	}
+
+	// No cache dir, should go straight to HTTP and not write
+	if getSchemaAndValidate(c, data, "foo", "blah", "", nil); err != nil {
+		t.Errorf("unexpected error validating: %v", err)
+	}
+	if requests["/swaggerapi/foo/blah"] != 1 {
+		t.Errorf("expected 1 schema request, saw: %d", requests["/swaggerapi/foo/blah"])
+	}
+	if _, err := os.Stat(path.Join(dir, "foo", "blah", schemaFileName)); err == nil || !os.IsNotExist(err) {
+		t.Errorf("unexpected cache file error: %v", err)
+	}
+}
+
+func TestSubstitueUser(t *testing.T) {
+	usr, err := user.Current()
+	if err != nil {
+		t.Logf("SKIPPING TEST: unexpected error: %v", err)
+		return
+	}
+	tests := []struct {
+		input     string
+		expected  string
+		expectErr bool
+	}{
+		{input: "~/foo", expected: path.Join(os.Getenv("HOME"), "foo")},
+		{input: "~" + usr.Username + "/bar", expected: usr.HomeDir + "/bar"},
+		{input: "/foo/bar", expected: "/foo/bar"},
+		{input: "~doesntexit/bar", expectErr: true},
+	}
+	for _, test := range tests {
+		output, err := substituteUserHome(test.input)
+		if test.expectErr {
+			if err == nil {
+				t.Error("unexpected non-error")
+			}
+			continue
+		}
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		if output != test.expected {
+			t.Errorf("expected: %s, saw: %s", test.expected, output)
+		}
+	}
+}
+
+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,
+	}
+}
+
+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, 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 TestPrintObjectSpecificMessage(t *testing.T) {
+	f := NewFactory(nil)
+	tests := []struct {
+		obj          runtime.Object
+		expectOutput bool
+	}{
+		{
+			obj:          &api.Service{},
+			expectOutput: false,
+		},
+		{
+			obj:          &api.Pod{},
+			expectOutput: false,
+		},
+		{
+			obj:          &api.Service{Spec: api.ServiceSpec{Type: api.ServiceTypeLoadBalancer}},
+			expectOutput: false,
+		},
+		{
+			obj:          &api.Service{Spec: api.ServiceSpec{Type: api.ServiceTypeNodePort}},
+			expectOutput: true,
+		},
+	}
+	for _, test := range tests {
+		buff := &bytes.Buffer{}
+		f.PrintObjectSpecificMessage(test.obj, buff)
+		if test.expectOutput && buff.Len() == 0 {
+			t.Errorf("Expected output, saw none for %v", test.obj)
+		}
+		if !test.expectOutput && buff.Len() > 0 {
+			t.Errorf("Expected no output, saw %s for %v", buff.String(), test.obj)
+		}
+	}
+}
+
+func TestMakePortsString(t *testing.T) {
+	tests := []struct {
+		ports          []api.ServicePort
+		useNodePort    bool
+		expectedOutput string
+	}{
+		{ports: nil, expectedOutput: ""},
+		{ports: []api.ServicePort{}, expectedOutput: ""},
+		{ports: []api.ServicePort{
+			{
+				Port:     80,
+				Protocol: "TCP",
+			},
+		},
+			expectedOutput: "tcp:80",
+		},
+		{ports: []api.ServicePort{
+			{
+				Port:     80,
+				Protocol: "TCP",
+			},
+			{
+				Port:     8080,
+				Protocol: "UDP",
+			},
+			{
+				Port:     9000,
+				Protocol: "TCP",
+			},
+		},
+			expectedOutput: "tcp:80,udp:8080,tcp:9000",
+		},
+		{ports: []api.ServicePort{
+			{
+				Port:     80,
+				NodePort: 9090,
+				Protocol: "TCP",
+			},
+			{
+				Port:     8080,
+				NodePort: 80,
+				Protocol: "UDP",
+			},
+		},
+			useNodePort:    true,
+			expectedOutput: "tcp:9090,udp:80",
+		},
+	}
+	for _, test := range tests {
+		output := makePortsString(test.ports, test.useNodePort)
+		if output != test.expectedOutput {
+			t.Errorf("expected: %s, saw: %s.", test.expectedOutput, output)
+		}
+	}
+}
+
+func fakeClient() resource.ClientMapper {
+	return resource.ClientMapperFunc(func(*meta.RESTMapping) (resource.RESTClient, error) {
+		return &manualfake.RESTClient{}, nil
+	})
+}
+
+func TestDiscoveryReplaceAliases(t *testing.T) {
+	tests := []struct {
+		name     string
+		arg      string
+		expected string
+	}{
+		{
+			name:     "no-replacement",
+			arg:      "service",
+			expected: "service",
+		},
+		{
+			name:     "all-replacement",
+			arg:      "all",
+			expected: "pods,replicationcontrollers,services,statefulsets.apps,horizontalpodautoscalers.autoscaling,jobs.batch,cronjobs.batch,daemonsets.extensions,deployments.extensions,replicasets.extensions",
+		},
+		{
+			name:     "alias-in-comma-separated-arg",
+			arg:      "all,secrets",
+			expected: "pods,replicationcontrollers,services,statefulsets.apps,horizontalpodautoscalers.autoscaling,jobs.batch,cronjobs.batch,daemonsets.extensions,deployments.extensions,replicasets.extensions,secrets",
+		},
+	}
+
+	ds := &fakeDiscoveryClient{}
+	mapper, err := NewShortcutExpander(testapi.Default.RESTMapper(), ds)
+	if err != nil {
+		t.Fatalf("Unable to create shortcut expander, err = %s", err.Error())
+	}
+	b := resource.NewBuilder(mapper, resource.LegacyCategoryExpander, api.Scheme, fakeClient(), testapi.Default.Codec())
+
+	for _, test := range tests {
+		replaced := b.ReplaceAliases(test.arg)
+		if replaced != test.expected {
+			t.Errorf("%s: unexpected argument: expected %s, got %s", test.name, test.expected, replaced)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go

@@ -0,0 +1,855 @@
+/*
+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 util
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+
+	jsonpatch "github.com/evanphx/json-patch"
+	"github.com/golang/glog"
+	"github.com/spf13/cobra"
+
+	kerrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+	utilerrors "k8s.io/apimachinery/pkg/util/errors"
+	"k8s.io/apimachinery/pkg/util/json"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/util/strategicpatch"
+	"k8s.io/apimachinery/pkg/util/yaml"
+	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/printers"
+	utilexec "k8s.io/utils/exec"
+)
+
+const (
+	ApplyAnnotationsFlag     = "save-config"
+	DefaultErrorExitCode     = 1
+	IncludeUninitializedFlag = "include-uninitialized"
+)
+
+type debugError interface {
+	DebugError() (msg string, args []interface{})
+}
+
+// AddSourceToErr adds handleResourcePrefix and source string to error message.
+// verb is the string like "creating", "deleting" etc.
+// source is the filename or URL to the template file(*.json or *.yaml), or stdin to use to handle the resource.
+func AddSourceToErr(verb string, source string, err error) error {
+	if source != "" {
+		if statusError, ok := err.(kerrors.APIStatus); ok {
+			status := statusError.Status()
+			status.Message = fmt.Sprintf("error when %s %q: %v", verb, source, status.Message)
+			return &kerrors.StatusError{ErrStatus: status}
+		}
+		return fmt.Errorf("error when %s %q: %v", verb, source, err)
+	}
+	return err
+}
+
+var fatalErrHandler = fatal
+
+// BehaviorOnFatal allows you to override the default behavior when a fatal
+// error occurs, which is to call os.Exit(code). You can pass 'panic' as a function
+// here if you prefer the panic() over os.Exit(1).
+func BehaviorOnFatal(f func(string, int)) {
+	fatalErrHandler = f
+}
+
+// DefaultBehaviorOnFatal allows you to undo any previous override.  Useful in
+// tests.
+func DefaultBehaviorOnFatal() {
+	fatalErrHandler = fatal
+}
+
+// fatal prints the message (if provided) and then exits. If V(2) or greater,
+// glog.Fatal is invoked for extended information.
+func fatal(msg string, code int) {
+	if glog.V(2) {
+		glog.FatalDepth(2, msg)
+	}
+	if len(msg) > 0 {
+		// add newline if needed
+		if !strings.HasSuffix(msg, "\n") {
+			msg += "\n"
+		}
+		fmt.Fprint(os.Stderr, msg)
+	}
+	os.Exit(code)
+}
+
+// ErrExit may be passed to CheckError to instruct it to output nothing but exit with
+// status code 1.
+var ErrExit = fmt.Errorf("exit")
+
+// CheckErr prints a user friendly error to STDERR and exits with a non-zero
+// exit code. Unrecognized errors will be printed with an "error: " prefix.
+//
+// This method is generic to the command in use and may be used by non-Kubectl
+// commands.
+func CheckErr(err error) {
+	checkErr(err, fatalErrHandler)
+}
+
+// checkErrWithPrefix works like CheckErr, but adds a caller-defined prefix to non-nil errors
+func checkErrWithPrefix(prefix string, err error) {
+	checkErr(err, fatalErrHandler)
+}
+
+// checkErr formats a given error as a string and calls the passed handleErr
+// func with that string and an kubectl exit code.
+func checkErr(err error, handleErr func(string, int)) {
+	// unwrap aggregates of 1
+	if agg, ok := err.(utilerrors.Aggregate); ok && len(agg.Errors()) == 1 {
+		err = agg.Errors()[0]
+	}
+
+	if err == nil {
+		return
+	}
+
+	switch {
+	case err == ErrExit:
+		handleErr("", DefaultErrorExitCode)
+	case kerrors.IsInvalid(err):
+		details := err.(*kerrors.StatusError).Status().Details
+		s := fmt.Sprintf("The %s %q is invalid", details.Kind, details.Name)
+		if len(details.Causes) > 0 {
+			errs := statusCausesToAggrError(details.Causes)
+			handleErr(MultilineError(s+": ", errs), DefaultErrorExitCode)
+		} else {
+			handleErr(s, DefaultErrorExitCode)
+		}
+	case clientcmd.IsConfigurationInvalid(err):
+		handleErr(MultilineError("Error in configuration: ", err), DefaultErrorExitCode)
+	default:
+		switch err := err.(type) {
+		case *meta.NoResourceMatchError:
+			switch {
+			case len(err.PartialResource.Group) > 0 && len(err.PartialResource.Version) > 0:
+				handleErr(fmt.Sprintf("the server doesn't have a resource type %q in group %q and version %q", err.PartialResource.Resource, err.PartialResource.Group, err.PartialResource.Version), DefaultErrorExitCode)
+			case len(err.PartialResource.Group) > 0:
+				handleErr(fmt.Sprintf("the server doesn't have a resource type %q in group %q", err.PartialResource.Resource, err.PartialResource.Group), DefaultErrorExitCode)
+			case len(err.PartialResource.Version) > 0:
+				handleErr(fmt.Sprintf("the server doesn't have a resource type %q in version %q", err.PartialResource.Resource, err.PartialResource.Version), DefaultErrorExitCode)
+			default:
+				handleErr(fmt.Sprintf("the server doesn't have a resource type %q", err.PartialResource.Resource), DefaultErrorExitCode)
+			}
+		case utilerrors.Aggregate:
+			handleErr(MultipleErrors(``, err.Errors()), DefaultErrorExitCode)
+		case utilexec.ExitError:
+			handleErr(err.Error(), err.ExitStatus())
+		default: // for any other error type
+			msg, ok := StandardErrorMessage(err)
+			if !ok {
+				msg = err.Error()
+				if !strings.HasPrefix(msg, "error: ") {
+					msg = fmt.Sprintf("error: %s", msg)
+				}
+			}
+			handleErr(msg, DefaultErrorExitCode)
+		}
+	}
+}
+
+func statusCausesToAggrError(scs []metav1.StatusCause) utilerrors.Aggregate {
+	errs := make([]error, 0, len(scs))
+	errorMsgs := sets.NewString()
+	for _, sc := range scs {
+		// check for duplicate error messages and skip them
+		msg := fmt.Sprintf("%s: %s", sc.Field, sc.Message)
+		if errorMsgs.Has(msg) {
+			continue
+		}
+		errorMsgs.Insert(msg)
+		errs = append(errs, errors.New(msg))
+	}
+	return utilerrors.NewAggregate(errs)
+}
+
+// StandardErrorMessage translates common errors into a human readable message, or returns
+// false if the error is not one of the recognized types. It may also log extended
+// information to glog.
+//
+// This method is generic to the command in use and may be used by non-Kubectl
+// commands.
+func StandardErrorMessage(err error) (string, bool) {
+	if debugErr, ok := err.(debugError); ok {
+		glog.V(4).Infof(debugErr.DebugError())
+	}
+	status, isStatus := err.(kerrors.APIStatus)
+	switch {
+	case isStatus:
+		switch s := status.Status(); {
+		case s.Reason == metav1.StatusReasonUnauthorized:
+			return fmt.Sprintf("error: You must be logged in to the server (%s)", s.Message), true
+		case len(s.Reason) > 0:
+			return fmt.Sprintf("Error from server (%s): %s", s.Reason, err.Error()), true
+		default:
+			return fmt.Sprintf("Error from server: %s", err.Error()), true
+		}
+	case kerrors.IsUnexpectedObjectError(err):
+		return fmt.Sprintf("Server returned an unexpected response: %s", err.Error()), true
+	}
+	switch t := err.(type) {
+	case *url.Error:
+		glog.V(4).Infof("Connection error: %s %s: %v", t.Op, t.URL, t.Err)
+		switch {
+		case strings.Contains(t.Err.Error(), "connection refused"):
+			host := t.URL
+			if server, err := url.Parse(t.URL); err == nil {
+				host = server.Host
+			}
+			return fmt.Sprintf("The connection to the server %s was refused - did you specify the right host or port?", host), true
+		}
+		return fmt.Sprintf("Unable to connect to the server: %v", t.Err), true
+	}
+	return "", false
+}
+
+// MultilineError returns a string representing an error that splits sub errors into their own
+// lines. The returned string will end with a newline.
+func MultilineError(prefix string, err error) string {
+	if agg, ok := err.(utilerrors.Aggregate); ok {
+		errs := utilerrors.Flatten(agg).Errors()
+		buf := &bytes.Buffer{}
+		switch len(errs) {
+		case 0:
+			return fmt.Sprintf("%s%v\n", prefix, err)
+		case 1:
+			return fmt.Sprintf("%s%v\n", prefix, messageForError(errs[0]))
+		default:
+			fmt.Fprintln(buf, prefix)
+			for _, err := range errs {
+				fmt.Fprintf(buf, "* %v\n", messageForError(err))
+			}
+			return buf.String()
+		}
+	}
+	return fmt.Sprintf("%s%s\n", prefix, err)
+}
+
+// PrintErrorWithCauses prints an error's kind, name, and each of the error's causes in a new line.
+// The returned string will end with a newline.
+// Returns true if a case exists to handle the error type, or false otherwise.
+func PrintErrorWithCauses(err error, errOut io.Writer) bool {
+	switch t := err.(type) {
+	case *kerrors.StatusError:
+		errorDetails := t.Status().Details
+		if errorDetails != nil {
+			fmt.Fprintf(errOut, "error: %s %q is invalid\n\n", errorDetails.Kind, errorDetails.Name)
+			for _, cause := range errorDetails.Causes {
+				fmt.Fprintf(errOut, "* %s: %s\n", cause.Field, cause.Message)
+			}
+			return true
+		}
+	}
+
+	fmt.Fprintf(errOut, "error: %v\n", err)
+	return false
+}
+
+// MultipleErrors returns a newline delimited string containing
+// the prefix and referenced errors in standard form.
+func MultipleErrors(prefix string, errs []error) string {
+	buf := &bytes.Buffer{}
+	for _, err := range errs {
+		fmt.Fprintf(buf, "%s%v\n", prefix, messageForError(err))
+	}
+	return buf.String()
+}
+
+// messageForError returns the string representing the error.
+func messageForError(err error) string {
+	msg, ok := StandardErrorMessage(err)
+	if !ok {
+		msg = err.Error()
+	}
+	return msg
+}
+
+func UsageErrorf(cmd *cobra.Command, format string, args ...interface{}) error {
+	msg := fmt.Sprintf(format, args...)
+	return fmt.Errorf("%s\nSee '%s -h' for help and examples.", msg, cmd.CommandPath())
+}
+
+func IsFilenameSliceEmpty(filenames []string) bool {
+	return len(filenames) == 0
+}
+
+// Whether this cmd need watching objects.
+func isWatch(cmd *cobra.Command) bool {
+	if w, err := cmd.Flags().GetBool("watch"); err == nil && w {
+		return true
+	}
+
+	wo, err := cmd.Flags().GetBool("watch-only")
+	return err == nil && wo
+}
+
+func GetFlagString(cmd *cobra.Command, flag string) string {
+	s, err := cmd.Flags().GetString(flag)
+	if err != nil {
+		glog.Fatalf("error accessing flag %s for command %s: %v", flag, cmd.Name(), err)
+	}
+	return s
+}
+
+// GetFlagStringSlice can be used to accept multiple argument with flag repetition (e.g. -f arg1,arg2 -f arg3 ...)
+func GetFlagStringSlice(cmd *cobra.Command, flag string) []string {
+	s, err := cmd.Flags().GetStringSlice(flag)
+	if err != nil {
+		glog.Fatalf("error accessing flag %s for command %s: %v", flag, cmd.Name(), err)
+	}
+	return s
+}
+
+// GetFlagStringArray can be used to accept multiple argument with flag repetition (e.g. -f arg1 -f arg2 ...)
+func GetFlagStringArray(cmd *cobra.Command, flag string) []string {
+	s, err := cmd.Flags().GetStringArray(flag)
+	if err != nil {
+		glog.Fatalf("err accessing flag %s for command %s: %v", flag, cmd.Name(), err)
+	}
+	return s
+}
+
+// GetWideFlag is used to determine if "-o wide" is used
+func GetWideFlag(cmd *cobra.Command) bool {
+	f := cmd.Flags().Lookup("output")
+	if f != nil && f.Value != nil && f.Value.String() == "wide" {
+		return true
+	}
+	return false
+}
+
+func GetFlagBool(cmd *cobra.Command, flag string) bool {
+	b, err := cmd.Flags().GetBool(flag)
+	if err != nil {
+		glog.Fatalf("error accessing flag %s for command %s: %v", flag, cmd.Name(), err)
+	}
+	return b
+}
+
+// Assumes the flag has a default value.
+func GetFlagInt(cmd *cobra.Command, flag string) int {
+	i, err := cmd.Flags().GetInt(flag)
+	if err != nil {
+		glog.Fatalf("error accessing flag %s for command %s: %v", flag, cmd.Name(), err)
+	}
+	return i
+}
+
+// Assumes the flag has a default value.
+func GetFlagInt64(cmd *cobra.Command, flag string) int64 {
+	i, err := cmd.Flags().GetInt64(flag)
+	if err != nil {
+		glog.Fatalf("error accessing flag %s for command %s: %v", flag, cmd.Name(), err)
+	}
+	return i
+}
+
+func GetFlagDuration(cmd *cobra.Command, flag string) time.Duration {
+	d, err := cmd.Flags().GetDuration(flag)
+	if err != nil {
+		glog.Fatalf("error accessing flag %s for command %s: %v", flag, cmd.Name(), err)
+	}
+	return d
+}
+
+func GetPodRunningTimeoutFlag(cmd *cobra.Command) (time.Duration, error) {
+	timeout := GetFlagDuration(cmd, "pod-running-timeout")
+	if timeout <= 0 {
+		return timeout, fmt.Errorf("--pod-running-timeout must be higher than zero")
+	}
+	return timeout, nil
+}
+
+func AddValidateFlags(cmd *cobra.Command) {
+	cmd.Flags().Bool("validate", true, "If true, use a schema to validate the input before sending it")
+	cmd.Flags().String("schema-cache-dir", fmt.Sprintf("~/%s/%s", clientcmd.RecommendedHomeDir, clientcmd.RecommendedSchemaName), fmt.Sprintf("If non-empty, load/store cached API schemas in this directory, default is '$HOME/%s/%s'", clientcmd.RecommendedHomeDir, clientcmd.RecommendedSchemaName))
+	cmd.Flags().Bool("openapi-validation", true, "If true, use openapi rather than swagger for validation.")
+	cmd.MarkFlagFilename("schema-cache-dir")
+}
+
+func AddValidateOptionFlags(cmd *cobra.Command, options *ValidateOptions) {
+	cmd.Flags().BoolVar(&options.EnableValidation, "validate", true, "If true, use a schema to validate the input before sending it")
+	cmd.Flags().StringVar(&options.SchemaCacheDir, "schema-cache-dir", fmt.Sprintf("~/%s/%s", clientcmd.RecommendedHomeDir, clientcmd.RecommendedSchemaName), fmt.Sprintf("If non-empty, load/store cached API schemas in this directory, default is '$HOME/%s/%s'", clientcmd.RecommendedHomeDir, clientcmd.RecommendedSchemaName))
+	cmd.Flags().BoolVar(&options.UseOpenAPI, "openapi-validation", true, "If true, use openapi rather than swagger for validation")
+	cmd.MarkFlagFilename("schema-cache-dir")
+}
+
+func AddOpenAPIFlags(cmd *cobra.Command) {
+	cmd.Flags().Bool("openapi-validation", true, "If true, use openapi rather than swagger for validation")
+}
+
+func AddFilenameOptionFlags(cmd *cobra.Command, options *resource.FilenameOptions, usage string) {
+	kubectl.AddJsonFilenameFlag(cmd, &options.Filenames, "Filename, directory, or URL to files "+usage)
+	cmd.Flags().BoolVarP(&options.Recursive, "recursive", "R", options.Recursive, "Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory.")
+}
+
+// AddDryRunFlag adds dry-run flag to a command. Usually used by mutations.
+func AddDryRunFlag(cmd *cobra.Command) {
+	cmd.Flags().Bool("dry-run", false, "If true, only print the object that would be sent, without sending it.")
+}
+
+func AddIncludeUninitializedFlag(cmd *cobra.Command) {
+	cmd.Flags().Bool(IncludeUninitializedFlag, false, `If true, the kubectl command applies to uninitialized objects. If explicitly set to false, this flag overrides other flags that make the kubectl commands apply to uninitialized objects, e.g., "--all". Objects with empty metadata.initializers are regarded as initialized.`)
+}
+
+func AddPodRunningTimeoutFlag(cmd *cobra.Command, defaultTimeout time.Duration) {
+	cmd.Flags().Duration("pod-running-timeout", defaultTimeout, "The length of time (like 5s, 2m, or 3h, higher than zero) to wait until at least one pod is running")
+}
+
+func AddApplyAnnotationFlags(cmd *cobra.Command) {
+	cmd.Flags().Bool(ApplyAnnotationsFlag, false, "If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future.")
+}
+
+func AddApplyAnnotationVarFlags(cmd *cobra.Command, applyAnnotation *bool) {
+	cmd.Flags().BoolVar(applyAnnotation, ApplyAnnotationsFlag, false, "If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future.")
+}
+
+// AddGeneratorFlags adds flags common to resource generation commands
+// TODO: need to take a pass at other generator commands to use this set of flags
+func AddGeneratorFlags(cmd *cobra.Command, defaultGenerator string) {
+	cmd.Flags().String("generator", defaultGenerator, "The name of the API generator to use.")
+	AddDryRunFlag(cmd)
+}
+
+type ValidateOptions struct {
+	EnableValidation bool
+	UseOpenAPI       bool
+	SchemaCacheDir   string
+}
+
+func ReadConfigDataFromReader(reader io.Reader, source string) ([]byte, error) {
+	data, err := ioutil.ReadAll(reader)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(data) == 0 {
+		return nil, fmt.Errorf("Read from %s but no data found", source)
+	}
+
+	return data, nil
+}
+
+// Merge requires JSON serialization
+// TODO: merge assumes JSON serialization, and does not properly abstract API retrieval
+func Merge(codec runtime.Codec, dst runtime.Object, fragment string) (runtime.Object, error) {
+	// encode dst into versioned json and apply fragment directly too it
+	target, err := runtime.Encode(codec, dst)
+	if err != nil {
+		return nil, err
+	}
+	patched, err := jsonpatch.MergePatch(target, []byte(fragment))
+	if err != nil {
+		return nil, err
+	}
+	out, err := runtime.Decode(codec, patched)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// DumpReaderToFile writes all data from the given io.Reader to the specified file
+// (usually for temporary use).
+func DumpReaderToFile(reader io.Reader, filename string) error {
+	f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	buffer := make([]byte, 1024)
+	for {
+		count, err := reader.Read(buffer)
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+		_, err = f.Write(buffer[:count])
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// UpdateObject updates resource object with updateFn
+func UpdateObject(info *resource.Info, codec runtime.Codec, updateFn func(runtime.Object) error) (runtime.Object, error) {
+	helper := resource.NewHelper(info.Client, info.Mapping)
+
+	if err := updateFn(info.Object); err != nil {
+		return nil, err
+	}
+
+	// Update the annotation used by kubectl apply
+	if err := kubectl.UpdateApplyAnnotation(info, codec); err != nil {
+		return nil, err
+	}
+
+	if _, err := helper.Replace(info.Namespace, info.Name, true, info.Object); err != nil {
+		return nil, err
+	}
+
+	return info.Object, nil
+}
+
+func AddRecordFlag(cmd *cobra.Command) {
+	cmd.Flags().Bool("record", false, "Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists.")
+}
+
+func AddRecordVarFlag(cmd *cobra.Command, record *bool) {
+	cmd.Flags().BoolVar(record, "record", false, "Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists.")
+}
+
+func GetRecordFlag(cmd *cobra.Command) bool {
+	return GetFlagBool(cmd, "record")
+}
+
+func GetDryRunFlag(cmd *cobra.Command) bool {
+	return GetFlagBool(cmd, "dry-run")
+}
+
+// RecordChangeCause annotate change-cause to input runtime object.
+func RecordChangeCause(obj runtime.Object, changeCause string) error {
+	accessor, err := meta.Accessor(obj)
+	if err != nil {
+		return err
+	}
+	annotations := accessor.GetAnnotations()
+	if annotations == nil {
+		annotations = make(map[string]string)
+	}
+	annotations[kubectl.ChangeCauseAnnotation] = changeCause
+	accessor.SetAnnotations(annotations)
+	return nil
+}
+
+// ChangeResourcePatch creates a patch between the origin input resource info
+// and the annotated with change-cause input resource info.
+func ChangeResourcePatch(info *resource.Info, changeCause string) ([]byte, types.PatchType, error) {
+	// Get a versioned object
+	obj, err := info.Mapping.ConvertToVersion(info.Object, info.Mapping.GroupVersionKind.GroupVersion())
+	if err != nil {
+		return nil, types.StrategicMergePatchType, err
+	}
+
+	oldData, err := json.Marshal(obj)
+	if err != nil {
+		return nil, types.StrategicMergePatchType, err
+	}
+	if err := RecordChangeCause(obj, changeCause); err != nil {
+		return nil, types.StrategicMergePatchType, err
+	}
+	newData, err := json.Marshal(obj)
+	if err != nil {
+		return nil, types.StrategicMergePatchType, err
+	}
+
+	switch obj := obj.(type) {
+	case *unstructured.Unstructured:
+		patch, err := jsonpatch.CreateMergePatch(oldData, newData)
+		return patch, types.MergePatchType, err
+	default:
+		patch, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, obj)
+		return patch, types.StrategicMergePatchType, err
+	}
+}
+
+// containsChangeCause checks if input resource info contains change-cause annotation.
+func ContainsChangeCause(info *resource.Info) bool {
+	annotations, err := info.Mapping.MetadataAccessor.Annotations(info.Object)
+	if err != nil {
+		return false
+	}
+	return len(annotations[kubectl.ChangeCauseAnnotation]) > 0
+}
+
+// ShouldRecord checks if we should record current change cause
+func ShouldRecord(cmd *cobra.Command, info *resource.Info) bool {
+	return GetRecordFlag(cmd) || (ContainsChangeCause(info) && !cmd.Flags().Changed("record"))
+}
+
+func AddInclude3rdPartyFlags(cmd *cobra.Command) {
+	cmd.Flags().Bool("include-extended-apis", true, "If true, include definitions of new APIs via calls to the API server. [default true]")
+	cmd.Flags().MarkDeprecated("include-extended-apis", "No longer required.")
+}
+
+func AddInclude3rdPartyVarFlags(cmd *cobra.Command, include3rdParty *bool) {
+	cmd.Flags().BoolVar(include3rdParty, "include-extended-apis", true, "If true, include definitions of new APIs via calls to the API server. [default true]")
+	cmd.Flags().MarkDeprecated("include-extended-apis", "No longer required.")
+}
+
+// GetResourcesAndPairs retrieves resources and "KEY=VALUE or KEY-" pair args from given args
+func GetResourcesAndPairs(args []string, pairType string) (resources []string, pairArgs []string, err error) {
+	foundPair := false
+	for _, s := range args {
+		nonResource := (strings.Contains(s, "=") && s[0] != '=') || (strings.HasSuffix(s, "-") && s != "-")
+		switch {
+		case !foundPair && nonResource:
+			foundPair = true
+			fallthrough
+		case foundPair && nonResource:
+			pairArgs = append(pairArgs, s)
+		case !foundPair && !nonResource:
+			resources = append(resources, s)
+		case foundPair && !nonResource:
+			err = fmt.Errorf("all resources must be specified before %s changes: %s", pairType, s)
+			return
+		}
+	}
+	return
+}
+
+// ParsePairs retrieves new and remove pairs (if supportRemove is true) from "KEY=VALUE or KEY-" pair args
+func ParsePairs(pairArgs []string, pairType string, supportRemove bool) (newPairs map[string]string, removePairs []string, err error) {
+	newPairs = map[string]string{}
+	if supportRemove {
+		removePairs = []string{}
+	}
+	var invalidBuf bytes.Buffer
+	var invalidBufNonEmpty bool
+	for _, pairArg := range pairArgs {
+		if strings.Contains(pairArg, "=") && pairArg[0] != '=' {
+			parts := strings.SplitN(pairArg, "=", 2)
+			if len(parts) != 2 {
+				if invalidBufNonEmpty {
+					invalidBuf.WriteString(", ")
+				}
+				invalidBuf.WriteString(pairArg)
+				invalidBufNonEmpty = true
+			} else {
+				newPairs[parts[0]] = parts[1]
+			}
+		} else if supportRemove && strings.HasSuffix(pairArg, "-") && pairArg != "-" {
+			removePairs = append(removePairs, pairArg[:len(pairArg)-1])
+		} else {
+			if invalidBufNonEmpty {
+				invalidBuf.WriteString(", ")
+			}
+			invalidBuf.WriteString(pairArg)
+			invalidBufNonEmpty = true
+		}
+	}
+	if invalidBufNonEmpty {
+		err = fmt.Errorf("invalid %s format: %s", pairType, invalidBuf.String())
+		return
+	}
+
+	return
+}
+
+// MustPrintWithKinds determines if printer is dealing
+// with multiple resource kinds, in which case it will
+// return true, indicating resource kind will be
+// included as part of printer output
+func MustPrintWithKinds(objs []runtime.Object, infos []*resource.Info, sorter *kubectl.RuntimeSort) bool {
+	var lastMap *meta.RESTMapping
+
+	for ix := range objs {
+		var mapping *meta.RESTMapping
+		if sorter != nil {
+			mapping = infos[sorter.OriginalPosition(ix)].Mapping
+		} else {
+			mapping = infos[ix].Mapping
+		}
+
+		// display "kind" only if we have mixed resources
+		if lastMap != nil && mapping.Resource != lastMap.Resource {
+			return true
+		}
+		lastMap = mapping
+	}
+
+	return false
+}
+
+// FilterResourceList receives a list of runtime objects.
+// If any objects are filtered, that number is returned along with a modified list.
+func FilterResourceList(obj runtime.Object, filterFuncs kubectl.Filters, filterOpts *printers.PrintOptions) (int, []runtime.Object, error) {
+	items, err := meta.ExtractList(obj)
+	if err != nil {
+		return 0, []runtime.Object{obj}, utilerrors.NewAggregate([]error{err})
+	}
+	if errs := runtime.DecodeList(items, api.Codecs.UniversalDecoder(), unstructured.UnstructuredJSONScheme); len(errs) > 0 {
+		return 0, []runtime.Object{obj}, utilerrors.NewAggregate(errs)
+	}
+
+	filterCount := 0
+	list := make([]runtime.Object, 0, len(items))
+	for _, obj := range items {
+		if isFiltered, err := filterFuncs.Filter(obj, filterOpts); !isFiltered {
+			if err != nil {
+				glog.V(2).Infof("Unable to filter resource: %v", err)
+				continue
+			}
+			list = append(list, obj)
+		} else if isFiltered {
+			filterCount++
+		}
+	}
+	return filterCount, list, nil
+}
+
+// PrintFilterCount displays informational messages based on the number of resources found, hidden, or
+// config flags shown.
+func PrintFilterCount(out io.Writer, found, hidden, errors int, options *printers.PrintOptions, ignoreNotFound bool) {
+	switch {
+	case errors > 0 || ignoreNotFound:
+		// print nothing
+	case found <= hidden:
+		if found == 0 {
+			fmt.Fprintln(out, "No resources found.")
+		} else {
+			fmt.Fprintln(out, "No resources found, use --show-all to see completed objects.")
+		}
+	case hidden > 0 && !options.ShowAll && !options.NoHeaders:
+		if glog.V(2) {
+			if hidden > 1 {
+				fmt.Fprintf(out, "info: %d objects not shown, use --show-all to see completed objects.\n", hidden)
+			} else {
+				fmt.Fprintf(out, "info: 1 object not shown, use --show-all to see completed objects.\n")
+			}
+		}
+	}
+}
+
+// ObjectListToVersionedObject receives a list of api objects and a group version
+// and squashes the list's items into a single versioned runtime.Object.
+func ObjectListToVersionedObject(objects []runtime.Object, version schema.GroupVersion) (runtime.Object, error) {
+	objectList := &api.List{Items: objects}
+	converted, err := resource.TryConvert(api.Scheme, objectList, version, api.Registry.GroupOrDie(api.GroupName).GroupVersion)
+	if err != nil {
+		return nil, err
+	}
+	return converted, nil
+}
+
+// IsSiblingCommandExists receives a pointer to a cobra command and a target string.
+// Returns true if the target string is found in the list of sibling commands.
+func IsSiblingCommandExists(cmd *cobra.Command, targetCmdName string) bool {
+	for _, c := range cmd.Parent().Commands() {
+		if c.Name() == targetCmdName {
+			return true
+		}
+	}
+
+	return false
+}
+
+// DefaultSubCommandRun prints a command's help string to the specified output if no
+// arguments (sub-commands) are provided, or a usage error otherwise.
+func DefaultSubCommandRun(out io.Writer) func(c *cobra.Command, args []string) {
+	return func(c *cobra.Command, args []string) {
+		c.SetOutput(out)
+		RequireNoArguments(c, args)
+		c.Help()
+	}
+}
+
+// RequireNoArguments exits with a usage error if extra arguments are provided.
+func RequireNoArguments(c *cobra.Command, args []string) {
+	if len(args) > 0 {
+		CheckErr(UsageErrorf(c, "unknown command %q", strings.Join(args, " ")))
+	}
+}
+
+// OutputsRawFormat determines if a command's output format is machine parsable
+// or returns false if it is human readable (name, wide, etc.)
+func OutputsRawFormat(cmd *cobra.Command) bool {
+	output := GetFlagString(cmd, "output")
+	if output == "json" ||
+		output == "yaml" ||
+		output == "go-template" ||
+		output == "go-template-file" ||
+		output == "jsonpath" ||
+		output == "jsonpath-file" {
+		return true
+	}
+
+	return false
+}
+
+// StripComments will transform a YAML file into JSON, thus dropping any comments
+// in it. Note that if the given file has a syntax error, the transformation will
+// fail and we will manually drop all comments from the file.
+func StripComments(file []byte) []byte {
+	stripped := file
+	stripped, err := yaml.ToJSON(stripped)
+	if err != nil {
+		stripped = ManualStrip(file)
+	}
+	return stripped
+}
+
+// ManualStrip is used for dropping comments from a YAML file
+func ManualStrip(file []byte) []byte {
+	stripped := []byte{}
+	lines := bytes.Split(file, []byte("\n"))
+	for i, line := range lines {
+		if bytes.HasPrefix(bytes.TrimSpace(line), []byte("#")) {
+			continue
+		}
+		stripped = append(stripped, line...)
+		if i < len(lines)-1 {
+			stripped = append(stripped, '\n')
+		}
+	}
+	return stripped
+}
+
+// ShouldIncludeUninitialized identifies whether to include uninitialized objects.
+// includeUninitialized is the default value.
+// Assume we can parse `all` and `selector` from cmd.
+func ShouldIncludeUninitialized(cmd *cobra.Command, includeUninitialized bool) bool {
+	shouldIncludeUninitialized := includeUninitialized
+	if cmd.Flags().Lookup("all") != nil && GetFlagBool(cmd, "all") {
+		// include the uninitialized objects by default
+		// unless explicitly set --include-uninitialized=false
+		shouldIncludeUninitialized = true
+	}
+	if cmd.Flags().Lookup("selector") != nil && GetFlagString(cmd, "selector") != "" {
+		// does not include the uninitialized objects by default
+		// unless explicitly set --include-uninitialized=true
+		shouldIncludeUninitialized = false
+	}
+	if cmd.Flags().Changed(IncludeUninitializedFlag) {
+		// get explicit value
+		shouldIncludeUninitialized = GetFlagBool(cmd, IncludeUninitializedFlag)
+	}
+	return shouldIncludeUninitialized
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers_test.go

@@ -0,0 +1,321 @@
+/*
+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 util
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strings"
+	"syscall"
+	"testing"
+
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/testapi"
+	apitesting "k8s.io/kubernetes/pkg/api/testing"
+	"k8s.io/utils/exec"
+)
+
+func TestMerge(t *testing.T) {
+	grace := int64(30)
+	tests := []struct {
+		obj       runtime.Object
+		fragment  string
+		expected  runtime.Object
+		expectErr bool
+	}{
+		{
+			obj: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "foo",
+				},
+			},
+			fragment: fmt.Sprintf(`{ "apiVersion": "%s" }`, api.Registry.GroupOrDie(api.GroupName).GroupVersion.String()),
+			expected: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "foo",
+				},
+				Spec: apitesting.DeepEqualSafePodSpec(),
+			},
+		},
+		/* TODO: uncomment this test once Merge is updated to use
+		strategic-merge-patch. See #8449.
+		{
+			obj: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "foo",
+				},
+				Spec: api.PodSpec{
+					Containers: []api.Container{
+						api.Container{
+							Name:  "c1",
+							Image: "red-image",
+						},
+						api.Container{
+							Name:  "c2",
+							Image: "blue-image",
+						},
+					},
+				},
+			},
+			fragment: fmt.Sprintf(`{ "apiVersion": "%s", "spec": { "containers": [ { "name": "c1", "image": "green-image" } ] } }`, api.Registry.GroupOrDie(api.GroupName).GroupVersion.String()),
+			expected: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "foo",
+				},
+				Spec: api.PodSpec{
+					Containers: []api.Container{
+						api.Container{
+							Name:  "c1",
+							Image: "green-image",
+						},
+						api.Container{
+							Name:  "c2",
+							Image: "blue-image",
+						},
+					},
+				},
+			},
+		}, */
+		{
+			obj: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "foo",
+				},
+			},
+			fragment: fmt.Sprintf(`{ "apiVersion": "%s", "spec": { "volumes": [ {"name": "v1"}, {"name": "v2"} ] } }`, api.Registry.GroupOrDie(api.GroupName).GroupVersion.String()),
+			expected: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "foo",
+				},
+				Spec: api.PodSpec{
+					Volumes: []api.Volume{
+						{
+							Name:         "v1",
+							VolumeSource: api.VolumeSource{EmptyDir: &api.EmptyDirVolumeSource{}},
+						},
+						{
+							Name:         "v2",
+							VolumeSource: api.VolumeSource{EmptyDir: &api.EmptyDirVolumeSource{}},
+						},
+					},
+					RestartPolicy:                 api.RestartPolicyAlways,
+					DNSPolicy:                     api.DNSClusterFirst,
+					TerminationGracePeriodSeconds: &grace,
+					SecurityContext:               &api.PodSecurityContext{},
+					SchedulerName:                 api.DefaultSchedulerName,
+				},
+			},
+		},
+		{
+			obj:       &api.Pod{},
+			fragment:  "invalid json",
+			expected:  &api.Pod{},
+			expectErr: true,
+		},
+		{
+			obj:       &api.Service{},
+			fragment:  `{ "apiVersion": "badVersion" }`,
+			expectErr: true,
+		},
+		{
+			obj: &api.Service{
+				Spec: api.ServiceSpec{},
+			},
+			fragment: fmt.Sprintf(`{ "apiVersion": "%s", "spec": { "ports": [ { "port": 0 } ] } }`, api.Registry.GroupOrDie(api.GroupName).GroupVersion.String()),
+			expected: &api.Service{
+				Spec: api.ServiceSpec{
+					SessionAffinity: "None",
+					Type:            api.ServiceTypeClusterIP,
+					Ports: []api.ServicePort{
+						{
+							Protocol: api.ProtocolTCP,
+							Port:     0,
+						},
+					},
+				},
+			},
+		},
+		{
+			obj: &api.Service{
+				Spec: api.ServiceSpec{
+					Selector: map[string]string{
+						"version": "v1",
+					},
+				},
+			},
+			fragment: fmt.Sprintf(`{ "apiVersion": "%s", "spec": { "selector": { "version": "v2" } } }`, api.Registry.GroupOrDie(api.GroupName).GroupVersion.String()),
+			expected: &api.Service{
+				Spec: api.ServiceSpec{
+					SessionAffinity: "None",
+					Type:            api.ServiceTypeClusterIP,
+					Selector: map[string]string{
+						"version": "v2",
+					},
+				},
+			},
+		},
+	}
+
+	for i, test := range tests {
+		out, err := Merge(testapi.Default.Codec(), test.obj, test.fragment)
+		if !test.expectErr {
+			if err != nil {
+				t.Errorf("testcase[%d], unexpected error: %v", i, err)
+			} else if !apiequality.Semantic.DeepEqual(out, test.expected) {
+				t.Errorf("\n\ntestcase[%d]\nexpected:\n%+v\nsaw:\n%+v", i, test.expected, out)
+			}
+		}
+		if test.expectErr && err == nil {
+			t.Errorf("testcase[%d], unexpected non-error", i)
+		}
+	}
+}
+
+type fileHandler struct {
+	data []byte
+}
+
+func (f *fileHandler) ServeHTTP(res http.ResponseWriter, req *http.Request) {
+	if req.URL.Path == "/error" {
+		res.WriteHeader(http.StatusNotFound)
+		return
+	}
+	res.WriteHeader(http.StatusOK)
+	res.Write(f.data)
+}
+
+type checkErrTestCase struct {
+	err          error
+	expectedErr  string
+	expectedCode int
+}
+
+func TestCheckInvalidErr(t *testing.T) {
+	testCheckError(t, []checkErrTestCase{
+		{
+			errors.NewInvalid(api.Kind("Invalid1"), "invalidation", field.ErrorList{field.Invalid(field.NewPath("field"), "single", "details")}),
+			"The Invalid1 \"invalidation\" is invalid: field: Invalid value: \"single\": details\n",
+			DefaultErrorExitCode,
+		},
+		{
+			errors.NewInvalid(api.Kind("Invalid2"), "invalidation", field.ErrorList{field.Invalid(field.NewPath("field1"), "multi1", "details"), field.Invalid(field.NewPath("field2"), "multi2", "details")}),
+			"The Invalid2 \"invalidation\" is invalid: \n* field1: Invalid value: \"multi1\": details\n* field2: Invalid value: \"multi2\": details\n",
+			DefaultErrorExitCode,
+		},
+		{
+			errors.NewInvalid(api.Kind("Invalid3"), "invalidation", field.ErrorList{}),
+			"The Invalid3 \"invalidation\" is invalid",
+			DefaultErrorExitCode,
+		},
+		{
+			errors.NewInvalid(api.Kind("Invalid4"), "invalidation", field.ErrorList{field.Invalid(field.NewPath("field4"), "multi4", "details"), field.Invalid(field.NewPath("field4"), "multi4", "details")}),
+			"The Invalid4 \"invalidation\" is invalid: field4: Invalid value: \"multi4\": details\n",
+			DefaultErrorExitCode,
+		},
+	})
+}
+
+func TestCheckNoResourceMatchError(t *testing.T) {
+	testCheckError(t, []checkErrTestCase{
+		{
+			&meta.NoResourceMatchError{PartialResource: schema.GroupVersionResource{Resource: "foo"}},
+			`the server doesn't have a resource type "foo"`,
+			DefaultErrorExitCode,
+		},
+		{
+			&meta.NoResourceMatchError{PartialResource: schema.GroupVersionResource{Version: "theversion", Resource: "foo"}},
+			`the server doesn't have a resource type "foo" in version "theversion"`,
+			DefaultErrorExitCode,
+		},
+		{
+			&meta.NoResourceMatchError{PartialResource: schema.GroupVersionResource{Group: "thegroup", Version: "theversion", Resource: "foo"}},
+			`the server doesn't have a resource type "foo" in group "thegroup" and version "theversion"`,
+			DefaultErrorExitCode,
+		},
+		{
+			&meta.NoResourceMatchError{PartialResource: schema.GroupVersionResource{Group: "thegroup", Resource: "foo"}},
+			`the server doesn't have a resource type "foo" in group "thegroup"`,
+			DefaultErrorExitCode,
+		},
+	})
+}
+
+func TestCheckExitError(t *testing.T) {
+	testCheckError(t, []checkErrTestCase{
+		{
+			exec.CodeExitError{Err: fmt.Errorf("pod foo/bar terminated"), Code: 42},
+			"pod foo/bar terminated",
+			42,
+		},
+	})
+}
+
+func testCheckError(t *testing.T, tests []checkErrTestCase) {
+	var errReturned string
+	var codeReturned int
+	errHandle := func(err string, code int) {
+		errReturned = err
+		codeReturned = code
+	}
+
+	for _, test := range tests {
+		checkErr(test.err, errHandle)
+
+		if errReturned != test.expectedErr {
+			t.Fatalf("Got: %s, expected: %s", errReturned, test.expectedErr)
+		}
+		if codeReturned != test.expectedCode {
+			t.Fatalf("Got: %d, expected: %d", codeReturned, test.expectedCode)
+		}
+	}
+}
+
+func TestDumpReaderToFile(t *testing.T) {
+	testString := "TEST STRING"
+	tempFile, err := ioutil.TempFile("", "hlpers_test_dump_")
+	if err != nil {
+		t.Errorf("unexpected error setting up a temporary file %v", err)
+	}
+	defer syscall.Unlink(tempFile.Name())
+	defer tempFile.Close()
+	defer func() {
+		if !t.Failed() {
+			os.Remove(tempFile.Name())
+		}
+	}()
+	err = DumpReaderToFile(strings.NewReader(testString), tempFile.Name())
+	if err != nil {
+		t.Errorf("error in DumpReaderToFile: %v", err)
+	}
+	data, err := ioutil.ReadFile(tempFile.Name())
+	if err != nil {
+		t.Errorf("error when reading %s: %v", tempFile.Name(), err)
+	}
+	stringData := string(data)
+	if stringData != testString {
+		t.Fatalf("Wrong file content %s != %s", testString, stringData)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/jsonmerge/BUILD

@@ -0,0 +1,31 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["jsonmerge.go"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/evanphx/json-patch:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/mergepatch:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/yaml:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = [
+        "//build/visible_to:pkg_kubectl_cmd_util_jsonmerge_CONSUMERS",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/jsonmerge/jsonmerge.go

@@ -0,0 +1,193 @@
+/*
+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 jsonmerge
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/evanphx/json-patch"
+	"github.com/golang/glog"
+
+	"k8s.io/apimachinery/pkg/util/mergepatch"
+	"k8s.io/apimachinery/pkg/util/yaml"
+)
+
+// Delta represents a change between two JSON documents.
+type Delta struct {
+	original []byte
+	edit     []byte
+
+	preconditions []PreconditionFunc
+}
+
+// PreconditionFunc is a test to verify that an incompatible change
+// has occurred before an Apply can be successful.
+type PreconditionFunc func(interface{}) (hold bool, message string)
+
+// AddPreconditions adds precondition checks to a change which must
+// be satisfied before an Apply is considered successful. If a
+// precondition returns false, the Apply is failed with
+// ErrPreconditionFailed.
+func (d *Delta) AddPreconditions(fns ...PreconditionFunc) {
+	d.preconditions = append(d.preconditions, fns...)
+}
+
+// RequireKeyUnchanged creates a precondition function that fails
+// if the provided key is present in the diff (indicating its value
+// has changed).
+func RequireKeyUnchanged(key string) PreconditionFunc {
+	return func(diff interface{}) (bool, string) {
+		m, ok := diff.(map[string]interface{})
+		if !ok {
+			return true, ""
+		}
+		// the presence of key in a diff means that its value has been changed, therefore
+		// we should fail the precondition.
+		_, ok = m[key]
+		if ok {
+			return false, key + " should not be changed\n"
+		} else {
+			return true, ""
+		}
+	}
+}
+
+// RequireMetadataKeyUnchanged creates a precondition function that fails
+// if the metadata.key is present in the diff (indicating its value
+// has changed).
+func RequireMetadataKeyUnchanged(key string) PreconditionFunc {
+	return func(diff interface{}) (bool, string) {
+		m, ok := diff.(map[string]interface{})
+		if !ok {
+			return true, ""
+		}
+		m1, ok := m["metadata"]
+		if !ok {
+			return true, ""
+		}
+		m2, ok := m1.(map[string]interface{})
+		if !ok {
+			return true, ""
+		}
+		_, ok = m2[key]
+		if ok {
+			return false, "metadata." + key + " should not be changed\n"
+		} else {
+			return true, ""
+		}
+	}
+}
+
+// TestPreconditions test if preconditions hold given the edit
+func TestPreconditionsHold(edit []byte, preconditions []PreconditionFunc) (bool, string) {
+	diff := make(map[string]interface{})
+	if err := json.Unmarshal(edit, &diff); err != nil {
+		return false, err.Error()
+	}
+	for _, fn := range preconditions {
+		if hold, msg := fn(diff); !hold {
+			return false, msg
+		}
+	}
+	return true, ""
+}
+
+// NewDelta accepts two JSON or YAML documents and calculates the difference
+// between them.  It returns a Delta object which can be used to resolve
+// conflicts against a third version with a common parent, or an error
+// if either document is in error.
+func NewDelta(from, to []byte) (*Delta, error) {
+	d := &Delta{}
+	before, err := yaml.ToJSON(from)
+	if err != nil {
+		return nil, err
+	}
+	after, err := yaml.ToJSON(to)
+	if err != nil {
+		return nil, err
+	}
+	diff, err := jsonpatch.CreateMergePatch(before, after)
+	if err != nil {
+		return nil, err
+	}
+	glog.V(6).Infof("Patch created from:\n%s\n%s\n%s", string(before), string(after), string(diff))
+	d.original = before
+	d.edit = diff
+	return d, nil
+}
+
+// Apply attempts to apply the changes described by Delta onto latest,
+// returning an error if the changes cannot be applied cleanly.
+// IsConflicting will be true if the changes overlap, otherwise a
+// generic error will be returned.
+func (d *Delta) Apply(latest []byte) ([]byte, error) {
+	base, err := yaml.ToJSON(latest)
+	if err != nil {
+		return nil, err
+	}
+	changes, err := jsonpatch.CreateMergePatch(d.original, base)
+	if err != nil {
+		return nil, err
+	}
+	diff1 := make(map[string]interface{})
+	if err := json.Unmarshal(d.edit, &diff1); err != nil {
+		return nil, err
+	}
+	diff2 := make(map[string]interface{})
+	if err := json.Unmarshal(changes, &diff2); err != nil {
+		return nil, err
+	}
+	for _, fn := range d.preconditions {
+		hold1, _ := fn(diff1)
+		hold2, _ := fn(diff2)
+		if !hold1 || !hold2 {
+			return nil, ErrPreconditionFailed
+		}
+	}
+
+	glog.V(6).Infof("Testing for conflict between:\n%s\n%s", string(d.edit), string(changes))
+	hasConflicts, err := mergepatch.HasConflicts(diff1, diff2)
+	if err != nil {
+		return nil, err
+	}
+	if hasConflicts {
+		return nil, ErrConflict
+	}
+
+	return jsonpatch.MergePatch(base, d.edit)
+}
+
+// IsConflicting returns true if the provided error indicates a
+// conflict exists between the original changes and the applied
+// changes.
+func IsConflicting(err error) bool {
+	return err == ErrConflict
+}
+
+// IsPreconditionFailed returns true if the provided error indicates
+// a Delta precondition did not succeed.
+func IsPreconditionFailed(err error) bool {
+	return err == ErrPreconditionFailed
+}
+
+var ErrPreconditionFailed = fmt.Errorf("a precondition failed")
+var ErrConflict = fmt.Errorf("changes are in conflict")
+
+func (d *Delta) Edit() []byte {
+	return d.edit
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/BUILD

@@ -0,0 +1,67 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "document.go",
+        "extensions.go",
+        "openapi.go",
+        "openapi_getter.go",
+    ],
+    deps = [
+        "//vendor/github.com/go-openapi/spec:go_default_library",
+        "//vendor/github.com/googleapis/gnostic/OpenAPIv2:go_default_library",
+        "//vendor/gopkg.in/yaml.v2:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/client-go/discovery:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_xtest",
+    size = "small",
+    srcs = [
+        "openapi_getter_test.go",
+        "openapi_suite_test.go",
+        "openapi_test.go",
+    ],
+    data = ["//api/openapi-spec:swagger-spec"],
+    deps = [
+        ":go_default_library",
+        "//pkg/kubectl/cmd/util/openapi/testing:go_default_library",
+        "//vendor/github.com/onsi/ginkgo:go_default_library",
+        "//vendor/github.com/onsi/ginkgo/config:go_default_library",
+        "//vendor/github.com/onsi/ginkgo/types:go_default_library",
+        "//vendor/github.com/onsi/gomega:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/kubectl/cmd/util/openapi/testing:all-srcs",
+        "//pkg/kubectl/cmd/util/openapi/validation:all-srcs",
+    ],
+    tags = ["automanaged"],
+)
+
+filegroup(
+    name = "testdata",
+    srcs = glob(["testdata/*"]),
+)

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/doc.go

@@ -0,0 +1,21 @@
+/*
+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 openapi is a collection of libraries for fetching the openapi spec
+// from a Kubernetes server and then indexing the type definitions.
+// The openapi spec contains the object model definitions and extensions metadata
+// such as the patchStrategy and patchMergeKey for creating patches.
+package openapi

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/document.go

@@ -0,0 +1,330 @@
+/*
+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 openapi
+
+import (
+	"fmt"
+	"strings"
+
+	openapi_v2 "github.com/googleapis/gnostic/OpenAPIv2"
+	yaml "gopkg.in/yaml.v2"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+func newSchemaError(path *Path, format string, a ...interface{}) error {
+	err := fmt.Sprintf(format, a...)
+	if path.Len() == 0 {
+		return fmt.Errorf("SchemaError: %v", err)
+	}
+	return fmt.Errorf("SchemaError(%v): %v", path, err)
+}
+
+// groupVersionKindExtensionKey is the key used to lookup the
+// GroupVersionKind value for an object definition from the
+// definition's "extensions" map.
+const groupVersionKindExtensionKey = "x-kubernetes-group-version-kind"
+
+func vendorExtensionToMap(e []*openapi_v2.NamedAny) map[string]interface{} {
+	values := map[string]interface{}{}
+
+	for _, na := range e {
+		if na.GetName() == "" || na.GetValue() == nil {
+			continue
+		}
+		if na.GetValue().GetYaml() == "" {
+			continue
+		}
+		var value interface{}
+		err := yaml.Unmarshal([]byte(na.GetValue().GetYaml()), &value)
+		if err != nil {
+			continue
+		}
+
+		values[na.GetName()] = value
+	}
+
+	return values
+}
+
+// Get and parse GroupVersionKind from the extension. Returns empty if it doesn't have one.
+func parseGroupVersionKind(s *openapi_v2.Schema) schema.GroupVersionKind {
+	extensionMap := vendorExtensionToMap(s.GetVendorExtension())
+
+	// Get the extensions
+	gvkExtension, ok := extensionMap[groupVersionKindExtensionKey]
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+
+	// gvk extension must be a list of 1 element.
+	gvkList, ok := gvkExtension.([]interface{})
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+	if len(gvkList) != 1 {
+		return schema.GroupVersionKind{}
+
+	}
+	gvk := gvkList[0]
+
+	// gvk extension list must be a map with group, version, and
+	// kind fields
+	gvkMap, ok := gvk.(map[interface{}]interface{})
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+	group, ok := gvkMap["group"].(string)
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+	version, ok := gvkMap["version"].(string)
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+	kind, ok := gvkMap["kind"].(string)
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+
+	return schema.GroupVersionKind{
+		Group:   group,
+		Version: version,
+		Kind:    kind,
+	}
+}
+
+// Definitions is an implementation of `Resources`. It looks for
+// resources in an openapi Schema.
+type Definitions struct {
+	models    map[string]Schema
+	resources map[schema.GroupVersionKind]string
+}
+
+var _ Resources = &Definitions{}
+
+// NewOpenAPIData creates a new `Resources` out of the openapi document.
+func NewOpenAPIData(doc *openapi_v2.Document) (Resources, error) {
+	definitions := Definitions{
+		models:    map[string]Schema{},
+		resources: map[schema.GroupVersionKind]string{},
+	}
+
+	// Save the list of all models first. This will allow us to
+	// validate that we don't have any dangling reference.
+	for _, namedSchema := range doc.GetDefinitions().GetAdditionalProperties() {
+		definitions.models[namedSchema.GetName()] = nil
+	}
+
+	// Now, parse each model. We can validate that references exists.
+	for _, namedSchema := range doc.GetDefinitions().GetAdditionalProperties() {
+		path := NewPath(namedSchema.GetName())
+		schema, err := definitions.ParseSchema(namedSchema.GetValue(), &path)
+		if err != nil {
+			return nil, err
+		}
+		definitions.models[namedSchema.GetName()] = schema
+		gvk := parseGroupVersionKind(namedSchema.GetValue())
+		if len(gvk.Kind) > 0 {
+			definitions.resources[gvk] = namedSchema.GetName()
+		}
+	}
+
+	return &definitions, nil
+}
+
+// We believe the schema is a reference, verify that and returns a new
+// Schema
+func (d *Definitions) parseReference(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	if len(s.GetProperties().GetAdditionalProperties()) > 0 {
+		return nil, newSchemaError(path, "unallowed embedded type definition")
+	}
+	if len(s.GetType().GetValue()) > 0 {
+		return nil, newSchemaError(path, "definition reference can't have a type")
+	}
+
+	if !strings.HasPrefix(s.GetXRef(), "#/definitions/") {
+		return nil, newSchemaError(path, "unallowed reference to non-definition %q", s.GetXRef())
+	}
+	reference := strings.TrimPrefix(s.GetXRef(), "#/definitions/")
+	if _, ok := d.models[reference]; !ok {
+		return nil, newSchemaError(path, "unknown model in reference: %q", reference)
+	}
+	return &Ref{
+		BaseSchema:  d.parseBaseSchema(s, path),
+		reference:   reference,
+		definitions: d,
+	}, nil
+}
+
+func (d *Definitions) parseBaseSchema(s *openapi_v2.Schema, path *Path) BaseSchema {
+	return BaseSchema{
+		Description: s.GetDescription(),
+		Extensions:  vendorExtensionToMap(s.GetVendorExtension()),
+		Path:        *path,
+	}
+}
+
+// We believe the schema is a map, verify and return a new schema
+func (d *Definitions) parseMap(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	if len(s.GetType().GetValue()) != 0 && s.GetType().GetValue()[0] != object {
+		return nil, newSchemaError(path, "invalid object type")
+	}
+	if s.GetAdditionalProperties().GetSchema() == nil {
+		return nil, newSchemaError(path, "invalid object doesn't have additional properties")
+	}
+	sub, err := d.ParseSchema(s.GetAdditionalProperties().GetSchema(), path)
+	if err != nil {
+		return nil, err
+	}
+	return &Map{
+		BaseSchema: d.parseBaseSchema(s, path),
+		SubType:    sub,
+	}, nil
+}
+
+func (d *Definitions) parsePrimitive(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	var t string
+	if len(s.GetType().GetValue()) > 1 {
+		return nil, newSchemaError(path, "primitive can't have more than 1 type")
+	}
+	if len(s.GetType().GetValue()) == 1 {
+		t = s.GetType().GetValue()[0]
+	}
+	switch t {
+	case String:
+	case Number:
+	case Integer:
+	case Boolean:
+	case "": // Some models are completely empty, and can be safely ignored.
+		// Do nothing
+	default:
+		return nil, newSchemaError(path, "Unknown primitive type: %q", t)
+	}
+	return &Primitive{
+		BaseSchema: d.parseBaseSchema(s, path),
+		Type:       t,
+		Format:     s.GetFormat(),
+	}, nil
+}
+
+func (d *Definitions) parseArray(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	if len(s.GetType().GetValue()) != 1 {
+		return nil, newSchemaError(path, "array should have exactly one type")
+	}
+	if s.GetType().GetValue()[0] != array {
+		return nil, newSchemaError(path, `array should have type "array"`)
+	}
+	if len(s.GetItems().GetSchema()) != 1 {
+		return nil, newSchemaError(path, "array should have exactly one sub-item")
+	}
+	sub, err := d.ParseSchema(s.GetItems().GetSchema()[0], path)
+	if err != nil {
+		return nil, err
+	}
+	return &Array{
+		BaseSchema: d.parseBaseSchema(s, path),
+		SubType:    sub,
+	}, nil
+}
+
+func (d *Definitions) parseKind(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	if len(s.GetType().GetValue()) != 0 && s.GetType().GetValue()[0] != object {
+		return nil, newSchemaError(path, "invalid object type")
+	}
+	if s.GetProperties() == nil {
+		return nil, newSchemaError(path, "object doesn't have properties")
+	}
+
+	fields := map[string]Schema{}
+
+	for _, namedSchema := range s.GetProperties().GetAdditionalProperties() {
+		var err error
+		path := path.FieldPath(namedSchema.GetName())
+		fields[namedSchema.GetName()], err = d.ParseSchema(namedSchema.GetValue(), &path)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return &Kind{
+		BaseSchema:     d.parseBaseSchema(s, path),
+		RequiredFields: s.GetRequired(),
+		Fields:         fields,
+	}, nil
+}
+
+// ParseSchema creates a walkable Schema from an openapi schema. While
+// this function is public, it doesn't leak through the interface.
+func (d *Definitions) ParseSchema(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	if len(s.GetType().GetValue()) == 1 {
+		t := s.GetType().GetValue()[0]
+		switch t {
+		case object:
+			return d.parseMap(s, path)
+		case array:
+			return d.parseArray(s, path)
+		}
+
+	}
+	if s.GetXRef() != "" {
+		return d.parseReference(s, path)
+	}
+	if s.GetProperties() != nil {
+		return d.parseKind(s, path)
+	}
+	return d.parsePrimitive(s, path)
+}
+
+// LookupResource is public through the interface of Resources. It
+// returns a visitable schema from the given group-version-kind.
+func (d *Definitions) LookupResource(gvk schema.GroupVersionKind) Schema {
+	modelName, found := d.resources[gvk]
+	if !found {
+		return nil
+	}
+	model, found := d.models[modelName]
+	if !found {
+		return nil
+	}
+	return model
+}
+
+type Ref struct {
+	BaseSchema
+
+	reference   string
+	definitions *Definitions
+}
+
+var _ Reference = &Ref{}
+
+func (r *Ref) Reference() string {
+	return r.reference
+}
+
+func (r *Ref) SubSchema() Schema {
+	return r.definitions.models[r.reference]
+}
+
+func (r *Ref) Accept(v SchemaVisitor) {
+	v.VisitReference(r)
+}
+
+func (r *Ref) GetName() string {
+	return fmt.Sprintf("Reference to %q", r.reference)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/extensions.go

@@ -0,0 +1,26 @@
+/*
+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 openapi
+
+import "github.com/go-openapi/spec"
+
+const PrintColumnsKey = "x-kubernetes-print-columns"
+
+// GetPrintColumns looks for the open API extension for the display columns.
+func GetPrintColumns(extensions spec.Extensions) (string, bool) {
+	return extensions.GetString(PrintColumnsKey)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/openapi.go

@@ -0,0 +1,231 @@
+/*
+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 openapi
+
+import (
+	"fmt"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+// Defines openapi types.
+const (
+	Integer = "integer"
+	Number  = "number"
+	String  = "string"
+	Boolean = "boolean"
+
+	// These types are private as they should never leak, and are
+	// represented by actual structs.
+	array  = "array"
+	object = "object"
+)
+
+// Resources interface describe a resources provider, that can give you
+// resource based on group-version-kind.
+type Resources interface {
+	LookupResource(gvk schema.GroupVersionKind) Schema
+}
+
+// SchemaVisitor is an interface that you need to implement if you want
+// to "visit" an openapi schema. A dispatch on the Schema type will call
+// the appropriate function based on its actual type:
+// - Array is a list of one and only one given subtype
+// - Map is a map of string to one and only one given subtype
+// - Primitive can be string, integer, number and boolean.
+// - Kind is an object with specific fields mapping to specific types.
+// - Reference is a link to another definition.
+type SchemaVisitor interface {
+	VisitArray(*Array)
+	VisitMap(*Map)
+	VisitPrimitive(*Primitive)
+	VisitKind(*Kind)
+	VisitReference(Reference)
+}
+
+// Schema is the base definition of an openapi type.
+type Schema interface {
+	// Giving a visitor here will let you visit the actual type.
+	Accept(SchemaVisitor)
+
+	// Pretty print the name of the type.
+	GetName() string
+	// Describes how to access this field.
+	GetPath() *Path
+	// Describes the field.
+	GetDescription() string
+	// Returns type extensions.
+	GetExtensions() map[string]interface{}
+}
+
+// Path helps us keep track of type paths
+type Path struct {
+	parent *Path
+	key    string
+}
+
+func NewPath(key string) Path {
+	return Path{key: key}
+}
+
+func (p *Path) Get() []string {
+	if p == nil {
+		return []string{}
+	}
+	if p.key == "" {
+		return p.parent.Get()
+	}
+	return append(p.parent.Get(), p.key)
+}
+
+func (p *Path) Len() int {
+	return len(p.Get())
+}
+
+func (p *Path) String() string {
+	return strings.Join(p.Get(), "")
+}
+
+// ArrayPath appends an array index and creates a new path
+func (p *Path) ArrayPath(i int) Path {
+	return Path{
+		parent: p,
+		key:    fmt.Sprintf("[%d]", i),
+	}
+}
+
+// FieldPath appends a field name and creates a new path
+func (p *Path) FieldPath(field string) Path {
+	return Path{
+		parent: p,
+		key:    fmt.Sprintf(".%s", field),
+	}
+}
+
+// BaseSchema holds data used by each types of schema.
+type BaseSchema struct {
+	Description string
+	Extensions  map[string]interface{}
+
+	Path Path
+}
+
+func (b *BaseSchema) GetDescription() string {
+	return b.Description
+}
+
+func (b *BaseSchema) GetExtensions() map[string]interface{} {
+	return b.Extensions
+}
+
+func (b *BaseSchema) GetPath() *Path {
+	return &b.Path
+}
+
+// Array must have all its element of the same `SubType`.
+type Array struct {
+	BaseSchema
+
+	SubType Schema
+}
+
+var _ Schema = &Array{}
+
+func (a *Array) Accept(v SchemaVisitor) {
+	v.VisitArray(a)
+}
+
+func (a *Array) GetName() string {
+	return fmt.Sprintf("Array of %s", a.SubType.GetName())
+}
+
+// Kind is a complex object. It can have multiple different
+// subtypes for each field, as defined in the `Fields` field. Mandatory
+// fields are listed in `RequiredFields`. The key of the object is
+// always of type `string`.
+type Kind struct {
+	BaseSchema
+
+	// Lists names of required fields.
+	RequiredFields []string
+	// Maps field names to types.
+	Fields map[string]Schema
+}
+
+var _ Schema = &Kind{}
+
+func (k *Kind) Accept(v SchemaVisitor) {
+	v.VisitKind(k)
+}
+
+func (k *Kind) GetName() string {
+	properties := []string{}
+	for key := range k.Fields {
+		properties = append(properties, key)
+	}
+	return fmt.Sprintf("Kind(%v)", properties)
+}
+
+// Map is an object who values must all be of the same `SubType`.
+// The key of the object is always of type `string`.
+type Map struct {
+	BaseSchema
+
+	SubType Schema
+}
+
+var _ Schema = &Map{}
+
+func (m *Map) Accept(v SchemaVisitor) {
+	v.VisitMap(m)
+}
+
+func (m *Map) GetName() string {
+	return fmt.Sprintf("Map of %s", m.SubType.GetName())
+}
+
+// Primitive is a literal. There can be multiple types of primitives,
+// and this subtype can be visited through the `subType` field.
+type Primitive struct {
+	BaseSchema
+
+	// Type of a primitive must be one of: integer, number, string, boolean.
+	Type   string
+	Format string
+}
+
+var _ Schema = &Primitive{}
+
+func (p *Primitive) Accept(v SchemaVisitor) {
+	v.VisitPrimitive(p)
+}
+
+func (p *Primitive) GetName() string {
+	if p.Format == "" {
+		return p.Type
+	}
+	return fmt.Sprintf("%s (%s)", p.Type, p.Format)
+}
+
+// Reference implementation depends on the type of document.
+type Reference interface {
+	Schema
+
+	Reference() string
+	SubSchema() Schema
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/openapi_getter.go

@@ -0,0 +1,65 @@
+/*
+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 openapi
+
+import (
+	"sync"
+
+	"k8s.io/client-go/discovery"
+)
+
+// synchronizedOpenAPIGetter fetches the openapi schema once and then caches it in memory
+type synchronizedOpenAPIGetter struct {
+	// Cached results
+	sync.Once
+	openAPISchema Resources
+	err           error
+
+	openAPIClient discovery.OpenAPISchemaInterface
+}
+
+var _ Getter = &synchronizedOpenAPIGetter{}
+
+// Getter is an interface for fetching openapi specs and parsing them into an Resources struct
+type Getter interface {
+	// OpenAPIData returns the parsed OpenAPIData
+	Get() (Resources, error)
+}
+
+// NewOpenAPIGetter returns an object to return OpenAPIDatas which reads
+// from a server, and then stores in memory for subsequent invocations
+func NewOpenAPIGetter(openAPIClient discovery.OpenAPISchemaInterface) Getter {
+	return &synchronizedOpenAPIGetter{
+		openAPIClient: openAPIClient,
+	}
+}
+
+// Resources implements Getter
+func (g *synchronizedOpenAPIGetter) Get() (Resources, error) {
+	g.Do(func() {
+		s, err := g.openAPIClient.OpenAPISchema()
+		if err != nil {
+			g.err = err
+			return
+		}
+
+		g.openAPISchema, g.err = NewOpenAPIData(s)
+	})
+
+	// Return the save result
+	return g.openAPISchema, g.err
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/openapi_getter_test.go

@@ -0,0 +1,77 @@
+/*
+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 openapi_test
+
+import (
+	"fmt"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+	tst "k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/testing"
+)
+
+var _ = Describe("Getting the Resources", func() {
+	var client *tst.FakeClient
+	var expectedData openapi.Resources
+	var instance openapi.Getter
+
+	BeforeEach(func() {
+		client = tst.NewFakeClient(&fakeSchema)
+		d, err := fakeSchema.OpenAPISchema()
+		Expect(err).To(BeNil())
+
+		expectedData, err = openapi.NewOpenAPIData(d)
+		Expect(err).To(BeNil())
+
+		instance = openapi.NewOpenAPIGetter(client)
+	})
+
+	Context("when the server returns a successful result", func() {
+		It("should return the same data for multiple calls", func() {
+			Expect(client.Calls).To(Equal(0))
+
+			result, err := instance.Get()
+			Expect(err).To(BeNil())
+			Expect(result).To(Equal(expectedData))
+			Expect(client.Calls).To(Equal(1))
+
+			result, err = instance.Get()
+			Expect(err).To(BeNil())
+			Expect(result).To(Equal(expectedData))
+			// No additional client calls expected
+			Expect(client.Calls).To(Equal(1))
+		})
+	})
+
+	Context("when the server returns an unsuccessful result", func() {
+		It("should return the same instance for multiple calls.", func() {
+			Expect(client.Calls).To(Equal(0))
+
+			client.Err = fmt.Errorf("expected error")
+			_, err := instance.Get()
+			Expect(err).To(Equal(client.Err))
+			Expect(client.Calls).To(Equal(1))
+
+			_, err = instance.Get()
+			Expect(err).To(Equal(client.Err))
+			// No additional client calls expected
+			Expect(client.Calls).To(Equal(1))
+		})
+	})
+})

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/openapi_suite_test.go

@@ -0,0 +1,49 @@
+/*
+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 openapi_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/config"
+	. "github.com/onsi/ginkgo/types"
+	. "github.com/onsi/gomega"
+
+	"fmt"
+	"testing"
+)
+
+func TestOpenapi(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecsWithDefaultAndCustomReporters(t, "Openapi Suite", []Reporter{newlineReporter{}})
+}
+
+// Print a newline after the default newlineReporter due to issue
+// https://github.com/jstemmer/go-junit-report/issues/31
+type newlineReporter struct{}
+
+func (newlineReporter) SpecSuiteWillBegin(config GinkgoConfigType, summary *SuiteSummary) {}
+
+func (newlineReporter) BeforeSuiteDidRun(setupSummary *SetupSummary) {}
+
+func (newlineReporter) AfterSuiteDidRun(setupSummary *SetupSummary) {}
+
+func (newlineReporter) SpecWillRun(specSummary *SpecSummary) {}
+
+func (newlineReporter) SpecDidComplete(specSummary *SpecSummary) {}
+
+// SpecSuiteDidEnd Prints a newline between "35 Passed | 0 Failed | 0 Pending | 0 Skipped" and "--- PASS:"
+func (newlineReporter) SpecSuiteDidEnd(summary *SuiteSummary) { fmt.Printf("\n") }

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/openapi_test.go

@@ -0,0 +1,218 @@
+/*
+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 openapi_test
+
+import (
+	"path/filepath"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+	tst "k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/testing"
+)
+
+var fakeSchema = tst.Fake{Path: filepath.Join("..", "..", "..", "..", "..", "api", "openapi-spec", "swagger.json")}
+
+var _ = Describe("Reading apps/v1beta1/Deployment from openAPIData", func() {
+	var resources openapi.Resources
+	BeforeEach(func() {
+		s, err := fakeSchema.OpenAPISchema()
+		Expect(err).To(BeNil())
+		resources, err = openapi.NewOpenAPIData(s)
+		Expect(err).To(BeNil())
+	})
+
+	gvk := schema.GroupVersionKind{
+		Kind:    "Deployment",
+		Version: "v1beta1",
+		Group:   "apps",
+	}
+
+	var schema openapi.Schema
+	It("should lookup the Schema by its GroupVersionKind", func() {
+		schema = resources.LookupResource(gvk)
+		Expect(schema).ToNot(BeNil())
+	})
+
+	var deployment *openapi.Kind
+	It("should be a Kind", func() {
+		deployment = schema.(*openapi.Kind)
+		Expect(deployment).ToNot(BeNil())
+	})
+
+	It("should have a path", func() {
+		Expect(deployment.GetPath().Get()).To(Equal([]string{"io.k8s.api.apps.v1beta1.Deployment"}))
+	})
+
+	It("should have a kind key of type string", func() {
+		Expect(deployment.Fields).To(HaveKey("kind"))
+		key := deployment.Fields["kind"].(*openapi.Primitive)
+		Expect(key).ToNot(BeNil())
+		Expect(key.Type).To(Equal("string"))
+		Expect(key.GetPath().Get()).To(Equal([]string{"io.k8s.api.apps.v1beta1.Deployment", ".kind"}))
+	})
+
+	It("should have a apiVersion key of type string", func() {
+		Expect(deployment.Fields).To(HaveKey("apiVersion"))
+		key := deployment.Fields["apiVersion"].(*openapi.Primitive)
+		Expect(key).ToNot(BeNil())
+		Expect(key.Type).To(Equal("string"))
+		Expect(key.GetPath().Get()).To(Equal([]string{"io.k8s.api.apps.v1beta1.Deployment", ".apiVersion"}))
+	})
+
+	It("should have a metadata key of type Reference", func() {
+		Expect(deployment.Fields).To(HaveKey("metadata"))
+		key := deployment.Fields["metadata"].(openapi.Reference)
+		Expect(key).ToNot(BeNil())
+		Expect(key.Reference()).To(Equal("io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"))
+		subSchema := key.SubSchema().(*openapi.Kind)
+		Expect(subSchema).ToNot(BeNil())
+	})
+
+	var status *openapi.Kind
+	It("should have a status key of type Reference", func() {
+		Expect(deployment.Fields).To(HaveKey("status"))
+		key := deployment.Fields["status"].(openapi.Reference)
+		Expect(key).ToNot(BeNil())
+		Expect(key.Reference()).To(Equal("io.k8s.api.apps.v1beta1.DeploymentStatus"))
+		status = key.SubSchema().(*openapi.Kind)
+		Expect(status).ToNot(BeNil())
+	})
+
+	It("should have a valid DeploymentStatus", func() {
+		By("having availableReplicas key")
+		Expect(status.Fields).To(HaveKey("availableReplicas"))
+		replicas := status.Fields["availableReplicas"].(*openapi.Primitive)
+		Expect(replicas).ToNot(BeNil())
+		Expect(replicas.Type).To(Equal("integer"))
+
+		By("having conditions key")
+		Expect(status.Fields).To(HaveKey("conditions"))
+		conditions := status.Fields["conditions"].(*openapi.Array)
+		Expect(conditions).ToNot(BeNil())
+		Expect(conditions.GetName()).To(Equal(`Array of Reference to "io.k8s.api.apps.v1beta1.DeploymentCondition"`))
+		Expect(conditions.GetExtensions()).To(Equal(map[string]interface{}{
+			"x-kubernetes-patch-merge-key": "type",
+			"x-kubernetes-patch-strategy":  "merge",
+		}))
+		condition := conditions.SubType.(openapi.Reference)
+		Expect(condition.Reference()).To(Equal("io.k8s.api.apps.v1beta1.DeploymentCondition"))
+	})
+
+	var spec *openapi.Kind
+	It("should have a spec key of type Reference", func() {
+		Expect(deployment.Fields).To(HaveKey("spec"))
+		key := deployment.Fields["spec"].(openapi.Reference)
+		Expect(key).ToNot(BeNil())
+		Expect(key.Reference()).To(Equal("io.k8s.api.apps.v1beta1.DeploymentSpec"))
+		spec = key.SubSchema().(*openapi.Kind)
+		Expect(spec).ToNot(BeNil())
+	})
+
+	It("should have a spec with no gvk", func() {
+		_, found := spec.GetExtensions()["x-kubernetes-group-version-kind"]
+		Expect(found).To(BeFalse())
+	})
+
+	It("should have a spec with a PodTemplateSpec sub-field", func() {
+		Expect(spec.Fields).To(HaveKey("template"))
+		key := spec.Fields["template"].(openapi.Reference)
+		Expect(key).ToNot(BeNil())
+		Expect(key.Reference()).To(Equal("io.k8s.api.core.v1.PodTemplateSpec"))
+	})
+})
+
+var _ = Describe("Reading authorization.k8s.io/v1/SubjectAccessReview from openAPIData", func() {
+	var resources openapi.Resources
+	BeforeEach(func() {
+		s, err := fakeSchema.OpenAPISchema()
+		Expect(err).To(BeNil())
+		resources, err = openapi.NewOpenAPIData(s)
+		Expect(err).To(BeNil())
+	})
+
+	gvk := schema.GroupVersionKind{
+		Kind:    "SubjectAccessReview",
+		Version: "v1",
+		Group:   "authorization.k8s.io",
+	}
+
+	var schema openapi.Schema
+	It("should lookup the Schema by its GroupVersionKind", func() {
+		schema = resources.LookupResource(gvk)
+		Expect(schema).ToNot(BeNil())
+	})
+
+	var sarspec *openapi.Kind
+	It("should be a Kind and have a spec", func() {
+		sar := schema.(*openapi.Kind)
+		Expect(sar).ToNot(BeNil())
+		Expect(sar.Fields).To(HaveKey("spec"))
+		specRef := sar.Fields["spec"].(openapi.Reference)
+		Expect(specRef).ToNot(BeNil())
+		Expect(specRef.Reference()).To(Equal("io.k8s.api.authorization.v1.SubjectAccessReviewSpec"))
+		sarspec = specRef.SubSchema().(*openapi.Kind)
+		Expect(sarspec).ToNot(BeNil())
+	})
+
+	It("should have a valid SubjectAccessReviewSpec", func() {
+		Expect(sarspec.Fields).To(HaveKey("extra"))
+		extra := sarspec.Fields["extra"].(*openapi.Map)
+		Expect(extra).ToNot(BeNil())
+		Expect(extra.GetName()).To(Equal("Map of Array of string"))
+		Expect(extra.GetPath().Get()).To(Equal([]string{"io.k8s.api.authorization.v1.SubjectAccessReviewSpec", ".extra"}))
+		array := extra.SubType.(*openapi.Array)
+		Expect(array).ToNot(BeNil())
+		Expect(array.GetName()).To(Equal("Array of string"))
+		Expect(array.GetPath().Get()).To(Equal([]string{"io.k8s.api.authorization.v1.SubjectAccessReviewSpec", ".extra"}))
+		str := array.SubType.(*openapi.Primitive)
+		Expect(str).ToNot(BeNil())
+		Expect(str.Type).To(Equal("string"))
+		Expect(str.GetName()).To(Equal("string"))
+		Expect(str.GetPath().Get()).To(Equal([]string{"io.k8s.api.authorization.v1.SubjectAccessReviewSpec", ".extra"}))
+	})
+})
+
+var _ = Describe("Path", func() {
+	It("can be created by NewPath", func() {
+		path := openapi.NewPath("key")
+		Expect(path.String()).To(Equal("key"))
+	})
+	It("can create and print complex paths", func() {
+		key := openapi.NewPath("key")
+		array := key.ArrayPath(12)
+		field := array.FieldPath("subKey")
+
+		Expect(field.String()).To(Equal("key[12].subKey"))
+	})
+	It("has a length", func() {
+		key := openapi.NewPath("key")
+		array := key.ArrayPath(12)
+		field := array.FieldPath("subKey")
+
+		Expect(field.Len()).To(Equal(3))
+	})
+	It("can look like an array", func() {
+		key := openapi.NewPath("key")
+		array := key.ArrayPath(12)
+		field := array.FieldPath("subKey")
+
+		Expect(field.Get()).To(Equal([]string{"key", "[12]", ".subKey"}))
+	})
+})

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/testing/BUILD

@@ -0,0 +1,32 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["openapi.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/github.com/googleapis/gnostic/OpenAPIv2:go_default_library",
+        "//vendor/github.com/googleapis/gnostic/compiler:go_default_library",
+        "//vendor/gopkg.in/yaml.v2:go_default_library",
+    ],
+)
+
+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/kubectl/cmd/util/openapi/testing/openapi.go

@@ -0,0 +1,89 @@
+/*
+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 testing
+
+import (
+	"io/ioutil"
+	"os"
+	"sync"
+
+	yaml "gopkg.in/yaml.v2"
+
+	"github.com/googleapis/gnostic/OpenAPIv2"
+	"github.com/googleapis/gnostic/compiler"
+)
+
+// Fake opens and returns a openapi swagger from a file Path. It will
+// parse only once and then return the same copy everytime.
+type Fake struct {
+	Path string
+
+	once     sync.Once
+	document *openapi_v2.Document
+	err      error
+}
+
+// OpenAPISchema returns the openapi document and a potential error.
+func (f *Fake) OpenAPISchema() (*openapi_v2.Document, error) {
+	f.once.Do(func() {
+		_, err := os.Stat(f.Path)
+		if err != nil {
+			f.err = err
+			return
+		}
+		spec, err := ioutil.ReadFile(f.Path)
+		if err != nil {
+			f.err = err
+			return
+		}
+		var info yaml.MapSlice
+		err = yaml.Unmarshal(spec, &info)
+		if err != nil {
+			f.err = err
+			return
+		}
+		f.document, f.err = openapi_v2.NewDocument(info, compiler.NewContext("$root", nil))
+	})
+	return f.document, f.err
+}
+
+// FakeClient implements a dummy OpenAPISchemaInterface that uses the
+// fake OpenAPI schema given as a parameter, and count the number of
+// call to the function.
+type FakeClient struct {
+	Calls int
+	Err   error
+
+	fake *Fake
+}
+
+// NewFakeClient creates a new FakeClient from the given Fake.
+func NewFakeClient(f *Fake) *FakeClient {
+	return &FakeClient{fake: f}
+}
+
+// OpenAPISchema returns a OpenAPI Document as returned by the fake, but
+// it also counts the number of calls.
+func (f *FakeClient) OpenAPISchema() (*openapi_v2.Document, error) {
+	f.Calls = f.Calls + 1
+
+	if f.Err != nil {
+		return nil, f.Err
+	}
+
+	return f.fake.OpenAPISchema()
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/validation/BUILD

@@ -0,0 +1,62 @@
+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 = [
+        "errors.go",
+        "types.go",
+        "validation.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/util:go_default_library",
+        "//pkg/kubectl/cmd/util/openapi:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/json:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/yaml:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_xtest",
+    srcs = [
+        "validation_suite_test.go",
+        "validation_test.go",
+    ],
+    data = ["//api/openapi-spec:swagger-spec"],
+    tags = ["automanaged"],
+    deps = [
+        ":go_default_library",
+        "//pkg/api/testapi:go_default_library",
+        "//pkg/kubectl/cmd/util/openapi:go_default_library",
+        "//pkg/kubectl/cmd/util/openapi/testing:go_default_library",
+        "//vendor/github.com/onsi/ginkgo:go_default_library",
+        "//vendor/github.com/onsi/ginkgo/config:go_default_library",
+        "//vendor/github.com/onsi/ginkgo/types:go_default_library",
+        "//vendor/github.com/onsi/gomega:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/errors:go_default_library",
+    ],
+)
+
+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/kubectl/cmd/util/openapi/validation/errors.go

@@ -0,0 +1,79 @@
+/*
+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 validation
+
+import (
+	"fmt"
+)
+
+type Errors struct {
+	errors []error
+}
+
+func (e *Errors) Errors() []error {
+	return e.errors
+}
+
+func (e *Errors) AppendErrors(err ...error) {
+	e.errors = append(e.errors, err...)
+}
+
+type ValidationError struct {
+	Path string
+	Err  error
+}
+
+func (e ValidationError) Error() string {
+	return fmt.Sprintf("ValidationError(%s): %v", e.Path, e.Err)
+}
+
+type InvalidTypeError struct {
+	Path     string
+	Expected string
+	Actual   string
+}
+
+func (e InvalidTypeError) Error() string {
+	return fmt.Sprintf("invalid type for %s: got %q, expected %q", e.Path, e.Actual, e.Expected)
+}
+
+type MissingRequiredFieldError struct {
+	Path  string
+	Field string
+}
+
+func (e MissingRequiredFieldError) Error() string {
+	return fmt.Sprintf("missing required field %q in %s", e.Field, e.Path)
+}
+
+type UnknownFieldError struct {
+	Path  string
+	Field string
+}
+
+func (e UnknownFieldError) Error() string {
+	return fmt.Sprintf("unknown field %q in %s", e.Field, e.Path)
+}
+
+type InvalidObjectTypeError struct {
+	Path string
+	Type string
+}
+
+func (e InvalidObjectTypeError) Error() string {
+	return fmt.Sprintf("unknown object type %q in %s", e.Type, e.Path)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/validation/types.go

@@ -0,0 +1,289 @@
+/*
+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 validation
+
+import (
+	"reflect"
+	"sort"
+
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+)
+
+type ValidationItem interface {
+	openapi.SchemaVisitor
+
+	Errors() []error
+	Path() *openapi.Path
+}
+
+type baseItem struct {
+	errors Errors
+	path   openapi.Path
+}
+
+// Errors returns the list of errors found for this item.
+func (item *baseItem) Errors() []error {
+	return item.errors.Errors()
+}
+
+// AddValidationError wraps the given error into a ValidationError and
+// attaches it to this item.
+func (item *baseItem) AddValidationError(err error) {
+	item.errors.AppendErrors(ValidationError{Path: item.path.String(), Err: err})
+}
+
+// AddError adds a regular (non-validation related) error to the list.
+func (item *baseItem) AddError(err error) {
+	item.errors.AppendErrors(err)
+}
+
+// CopyErrors adds a list of errors to this item. This is useful to copy
+// errors from subitems.
+func (item *baseItem) CopyErrors(errs []error) {
+	item.errors.AppendErrors(errs...)
+}
+
+// Path returns the path of this item, helps print useful errors.
+func (item *baseItem) Path() *openapi.Path {
+	return &item.path
+}
+
+// mapItem represents a map entry in the yaml.
+type mapItem struct {
+	baseItem
+
+	Map map[string]interface{}
+}
+
+func (item *mapItem) sortedKeys() []string {
+	sortedKeys := []string{}
+	for key := range item.Map {
+		sortedKeys = append(sortedKeys, key)
+	}
+	sort.Strings(sortedKeys)
+	return sortedKeys
+}
+
+var _ ValidationItem = &mapItem{}
+
+func (item *mapItem) VisitPrimitive(schema *openapi.Primitive) {
+	item.AddValidationError(InvalidTypeError{Path: schema.GetPath().String(), Expected: schema.Type, Actual: "map"})
+}
+
+func (item *mapItem) VisitArray(schema *openapi.Array) {
+	item.AddValidationError(InvalidTypeError{Path: schema.GetPath().String(), Expected: "array", Actual: "map"})
+}
+
+func (item *mapItem) VisitMap(schema *openapi.Map) {
+	for _, key := range item.sortedKeys() {
+		subItem, err := itemFactory(item.Path().FieldPath(key), item.Map[key])
+		if err != nil {
+			item.AddError(err)
+			continue
+		}
+		schema.SubType.Accept(subItem)
+		item.CopyErrors(subItem.Errors())
+	}
+}
+
+func (item *mapItem) VisitKind(schema *openapi.Kind) {
+	// Verify each sub-field.
+	for _, key := range item.sortedKeys() {
+		if item.Map[key] == nil {
+			continue
+		}
+		subItem, err := itemFactory(item.Path().FieldPath(key), item.Map[key])
+		if err != nil {
+			item.AddError(err)
+			continue
+		}
+		if _, ok := schema.Fields[key]; !ok {
+			item.AddValidationError(UnknownFieldError{Path: schema.GetPath().String(), Field: key})
+			continue
+		}
+		schema.Fields[key].Accept(subItem)
+		item.CopyErrors(subItem.Errors())
+	}
+
+	// Verify that all required fields are present.
+	for _, required := range schema.RequiredFields {
+		if v, ok := item.Map[required]; !ok || v == nil {
+			item.AddValidationError(MissingRequiredFieldError{Path: schema.GetPath().String(), Field: required})
+		}
+	}
+}
+
+func (item *mapItem) VisitReference(schema openapi.Reference) {
+	// passthrough
+	schema.SubSchema().Accept(item)
+}
+
+// arrayItem represents a yaml array.
+type arrayItem struct {
+	baseItem
+
+	Array []interface{}
+}
+
+var _ ValidationItem = &arrayItem{}
+
+func (item *arrayItem) VisitPrimitive(schema *openapi.Primitive) {
+	item.AddValidationError(InvalidTypeError{Path: schema.GetPath().String(), Expected: schema.Type, Actual: "array"})
+}
+
+func (item *arrayItem) VisitArray(schema *openapi.Array) {
+	for i, v := range item.Array {
+		path := item.Path().ArrayPath(i)
+		if v == nil {
+			item.AddValidationError(InvalidObjectTypeError{Type: "nil", Path: path.String()})
+			continue
+		}
+		subItem, err := itemFactory(path, v)
+		if err != nil {
+			item.AddError(err)
+			continue
+		}
+		schema.SubType.Accept(subItem)
+		item.CopyErrors(subItem.Errors())
+	}
+}
+
+func (item *arrayItem) VisitMap(schema *openapi.Map) {
+	item.AddValidationError(InvalidTypeError{Path: schema.GetPath().String(), Expected: "array", Actual: "map"})
+}
+
+func (item *arrayItem) VisitKind(schema *openapi.Kind) {
+	item.AddValidationError(InvalidTypeError{Path: schema.GetPath().String(), Expected: "array", Actual: "map"})
+}
+
+func (item *arrayItem) VisitReference(schema openapi.Reference) {
+	// passthrough
+	schema.SubSchema().Accept(item)
+}
+
+// primitiveItem represents a yaml value.
+type primitiveItem struct {
+	baseItem
+
+	Value interface{}
+	Kind  string
+}
+
+var _ ValidationItem = &primitiveItem{}
+
+func (item *primitiveItem) VisitPrimitive(schema *openapi.Primitive) {
+	// Some types of primitives can match more than one (a number
+	// can be a string, but not the other way around). Return from
+	// the switch if we have a valid possible type conversion
+	// NOTE(apelisse): This logic is blindly copied from the
+	// existing swagger logic, and I'm not sure I agree with it.
+	switch schema.Type {
+	case openapi.Boolean:
+		switch item.Kind {
+		case openapi.Boolean:
+			return
+		}
+	case openapi.Integer:
+		switch item.Kind {
+		case openapi.Integer, openapi.Number:
+			return
+		}
+	case openapi.Number:
+		switch item.Kind {
+		case openapi.Number:
+			return
+		}
+	case openapi.String:
+		return
+	}
+
+	item.AddValidationError(InvalidTypeError{Path: schema.GetPath().String(), Expected: schema.Type, Actual: item.Kind})
+}
+
+func (item *primitiveItem) VisitArray(schema *openapi.Array) {
+	item.AddValidationError(InvalidTypeError{Path: schema.GetPath().String(), Expected: "array", Actual: item.Kind})
+}
+
+func (item *primitiveItem) VisitMap(schema *openapi.Map) {
+	item.AddValidationError(InvalidTypeError{Path: schema.GetPath().String(), Expected: "map", Actual: item.Kind})
+}
+
+func (item *primitiveItem) VisitKind(schema *openapi.Kind) {
+	item.AddValidationError(InvalidTypeError{Path: schema.GetPath().String(), Expected: "map", Actual: item.Kind})
+}
+
+func (item *primitiveItem) VisitReference(schema openapi.Reference) {
+	// passthrough
+	schema.SubSchema().Accept(item)
+}
+
+// itemFactory creates the relevant item type/visitor based on the current yaml type.
+func itemFactory(path openapi.Path, v interface{}) (ValidationItem, error) {
+	// We need to special case for no-type fields in yaml (e.g. empty item in list)
+	if v == nil {
+		return nil, InvalidObjectTypeError{Type: "nil", Path: path.String()}
+	}
+	kind := reflect.TypeOf(v).Kind()
+	switch kind {
+	case reflect.Bool:
+		return &primitiveItem{
+			baseItem: baseItem{path: path},
+			Value:    v,
+			Kind:     openapi.Boolean,
+		}, nil
+	case reflect.Int,
+		reflect.Int8,
+		reflect.Int16,
+		reflect.Int32,
+		reflect.Int64,
+		reflect.Uint,
+		reflect.Uint8,
+		reflect.Uint16,
+		reflect.Uint32,
+		reflect.Uint64:
+		return &primitiveItem{
+			baseItem: baseItem{path: path},
+			Value:    v,
+			Kind:     openapi.Integer,
+		}, nil
+	case reflect.Float32,
+		reflect.Float64:
+		return &primitiveItem{
+			baseItem: baseItem{path: path},
+			Value:    v,
+			Kind:     openapi.Number,
+		}, nil
+	case reflect.String:
+		return &primitiveItem{
+			baseItem: baseItem{path: path},
+			Value:    v,
+			Kind:     openapi.String,
+		}, nil
+	case reflect.Array,
+		reflect.Slice:
+		return &arrayItem{
+			baseItem: baseItem{path: path},
+			Array:    v.([]interface{}),
+		}, nil
+	case reflect.Map:
+		return &mapItem{
+			baseItem: baseItem{path: path},
+			Map:      v.(map[string]interface{}),
+		}, nil
+	}
+	return nil, InvalidObjectTypeError{Type: kind.String(), Path: path.String()}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/validation/validation.go

@@ -0,0 +1,133 @@
+/*
+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 validation
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	utilerrors "k8s.io/apimachinery/pkg/util/errors"
+	"k8s.io/apimachinery/pkg/util/json"
+	"k8s.io/apimachinery/pkg/util/yaml"
+	"k8s.io/kubernetes/pkg/api"
+	apiutil "k8s.io/kubernetes/pkg/api/util"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+)
+
+type SchemaValidation struct {
+	resources openapi.Resources
+}
+
+func NewSchemaValidation(resources openapi.Resources) *SchemaValidation {
+	return &SchemaValidation{
+		resources: resources,
+	}
+}
+
+func (v *SchemaValidation) ValidateBytes(data []byte) error {
+	obj, err := parse(data)
+	if err != nil {
+		return err
+	}
+
+	gvk, err := getObjectKind(obj)
+	if err != nil {
+		return err
+	}
+
+	if strings.HasSuffix(gvk.Kind, "List") {
+		return utilerrors.NewAggregate(v.validateList(obj))
+	}
+
+	return utilerrors.NewAggregate(v.validateResource(obj, gvk))
+}
+
+func (v *SchemaValidation) validateList(object interface{}) []error {
+	fields := object.(map[string]interface{})
+	if fields == nil {
+		return []error{errors.New("invalid object to validate")}
+	}
+
+	errs := []error{}
+	for _, item := range fields["items"].([]interface{}) {
+		if gvk, err := getObjectKind(item); err != nil {
+			errs = append(errs, err)
+		} else {
+			errs = append(errs, v.validateResource(item, gvk)...)
+		}
+	}
+	return errs
+}
+
+func (v *SchemaValidation) validateResource(obj interface{}, gvk schema.GroupVersionKind) []error {
+	if !api.Registry.IsEnabledVersion(gvk.GroupVersion()) {
+		// if we don't have this in our scheme, just skip
+		// validation because its an object we don't recognize
+		return nil
+	}
+
+	resource := v.resources.LookupResource(gvk)
+	if resource == nil {
+		return []error{fmt.Errorf("unknown object type %#v", gvk)}
+	}
+
+	rootValidation, err := itemFactory(openapi.NewPath(gvk.Kind), obj)
+	if err != nil {
+		return []error{err}
+	}
+	resource.Accept(rootValidation)
+	return rootValidation.Errors()
+}
+
+func parse(data []byte) (interface{}, error) {
+	var obj interface{}
+	out, err := yaml.ToJSON(data)
+	if err != nil {
+		return nil, err
+	}
+	if err := json.Unmarshal(out, &obj); err != nil {
+		return nil, err
+	}
+	return obj, nil
+}
+
+func getObjectKind(object interface{}) (schema.GroupVersionKind, error) {
+	fields := object.(map[string]interface{})
+	if fields == nil {
+		return schema.GroupVersionKind{}, errors.New("invalid object to validate")
+	}
+	apiVersion := fields["apiVersion"]
+	if apiVersion == nil {
+		return schema.GroupVersionKind{}, errors.New("apiVersion not set")
+	}
+	if _, ok := apiVersion.(string); !ok {
+		return schema.GroupVersionKind{}, errors.New("apiVersion isn't string type")
+	}
+	version := apiutil.GetVersion(apiVersion.(string))
+	group := apiutil.GetGroup(apiVersion.(string))
+	kind := fields["kind"]
+	if kind == nil {
+		return schema.GroupVersionKind{}, errors.New("kind not set")
+	}
+	if _, ok := kind.(string); !ok {
+		return schema.GroupVersionKind{}, errors.New("kind isn't string type")
+	}
+
+	return schema.GroupVersionKind{Group: group, Version: version, Kind: kind.(string)}, nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/validation/validation_suite_test.go

@@ -0,0 +1,49 @@
+/*
+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 validation_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/config"
+	. "github.com/onsi/ginkgo/types"
+	. "github.com/onsi/gomega"
+
+	"fmt"
+	"testing"
+)
+
+func TestOpenapi(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecsWithDefaultAndCustomReporters(t, "Openapi Suite", []Reporter{newlineReporter{}})
+}
+
+// Print a newline after the default newlineReporter due to issue
+// https://github.com/jstemmer/go-junit-report/issues/31
+type newlineReporter struct{}
+
+func (newlineReporter) SpecSuiteWillBegin(config GinkgoConfigType, summary *SuiteSummary) {}
+
+func (newlineReporter) BeforeSuiteDidRun(setupSummary *SetupSummary) {}
+
+func (newlineReporter) AfterSuiteDidRun(setupSummary *SetupSummary) {}
+
+func (newlineReporter) SpecWillRun(specSummary *SpecSummary) {}
+
+func (newlineReporter) SpecDidComplete(specSummary *SpecSummary) {}
+
+// SpecSuiteDidEnd Prints a newline between "35 Passed | 0 Failed | 0 Pending | 0 Skipped" and "--- PASS:"
+func (newlineReporter) SpecSuiteDidEnd(summary *SuiteSummary) { fmt.Printf("\n") }

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/validation/validation_test.go

@@ -0,0 +1,338 @@
+/*
+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 validation_test
+
+import (
+	"path/filepath"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	utilerrors "k8s.io/apimachinery/pkg/util/errors"
+	// This dependency is needed to register API types.
+	_ "k8s.io/kubernetes/pkg/api/testapi"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+	tst "k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/testing"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/validation"
+)
+
+var fakeSchema = tst.Fake{Path: filepath.Join("..", "..", "..", "..", "..", "..", "api", "openapi-spec", "swagger.json")}
+
+var _ = Describe("resource validation using OpenAPI Schema", func() {
+	var validator *validation.SchemaValidation
+	BeforeEach(func() {
+		s, err := fakeSchema.OpenAPISchema()
+		Expect(err).To(BeNil())
+		resources, err := openapi.NewOpenAPIData(s)
+		Expect(err).To(BeNil())
+		validator = validation.NewSchemaValidation(resources)
+		Expect(validator).ToNot(BeNil())
+	})
+
+	It("finds Deployment in Schema and validates it", func() {
+		err := validator.ValidateBytes([]byte(`
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  labels:
+    name: redis-master
+  name: name
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        app: redis
+    spec:
+      containers:
+      - image: redis
+        name: redis
+`))
+		Expect(err).To(BeNil())
+	})
+
+	It("validates a valid pod", func() {
+		err := validator.ValidateBytes([]byte(`
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    name: redis-master
+  name: name
+spec:
+  containers:
+  - args:
+    - this
+    - is
+    - an
+    - ok
+    - command
+    image: gcr.io/fake_project/fake_image:fake_tag
+    name: master
+`))
+		Expect(err).To(BeNil())
+	})
+
+	It("finds invalid command (string instead of []string) in Json Pod", func() {
+		err := validator.ValidateBytes([]byte(`
+{
+  "kind": "Pod",
+  "apiVersion": "v1",
+  "metadata": {
+    "name": "name",
+    "labels": {
+      "name": "redis-master"
+    }
+  },
+  "spec": {
+    "containers": [
+      {
+        "name": "master",
+	"image": "gcr.io/fake_project/fake_image:fake_tag",
+        "args": "this is a bad command"
+      }
+    ]
+  }
+}
+`))
+		Expect(err).To(Equal(utilerrors.NewAggregate([]error{
+			validation.ValidationError{
+				Path: "Pod.spec.containers[0].args",
+				Err: validation.InvalidTypeError{
+					Path:     "io.k8s.api.core.v1.Container.args",
+					Expected: "array",
+					Actual:   "string",
+				},
+			},
+		})))
+	})
+
+	It("fails because hostPort is string instead of int", func() {
+		err := validator.ValidateBytes([]byte(`
+{
+  "kind": "Pod",
+  "apiVersion": "v1",
+  "metadata": {
+    "name": "apache-php",
+    "labels": {
+      "name": "apache-php"
+    }
+  },
+  "spec": {
+    "volumes": [{
+        "name": "shared-disk"
+    }],
+    "containers": [
+      {
+        "name": "apache-php",
+        "image": "gcr.io/fake_project/fake_image:fake_tag",
+        "ports": [
+          {
+            "name": "apache",
+            "hostPort": "13380",
+            "containerPort": 80,
+            "protocol": "TCP"
+          }
+        ],
+        "volumeMounts": [
+          {
+            "name": "shared-disk",
+            "mountPath": "/var/www/html"
+          }
+        ]
+      }
+    ]
+  }
+}
+`))
+
+		Expect(err).To(Equal(utilerrors.NewAggregate([]error{
+			validation.ValidationError{
+				Path: "Pod.spec.containers[0].ports[0].hostPort",
+				Err: validation.InvalidTypeError{
+					Path:     "io.k8s.api.core.v1.ContainerPort.hostPort",
+					Expected: "integer",
+					Actual:   "string",
+				},
+			},
+		})))
+
+	})
+
+	It("fails because volume is not an array of object", func() {
+		err := validator.ValidateBytes([]byte(`
+{
+  "kind": "Pod",
+  "apiVersion": "v1",
+  "metadata": {
+    "name": "apache-php",
+    "labels": {
+      "name": "apache-php"
+    }
+  },
+  "spec": {
+    "volumes": [
+        "name": "shared-disk"
+    ],
+    "containers": [
+      {
+        "name": "apache-php",
+	"image": "gcr.io/fake_project/fake_image:fake_tag",
+        "ports": [
+          {
+            "name": "apache",
+            "hostPort": 13380,
+            "containerPort": 80,
+            "protocol": "TCP"
+          }
+        ],
+        "volumeMounts": [
+          {
+            "name": "shared-disk",
+            "mountPath": "/var/www/html"
+          }
+        ]
+      }
+    ]
+  }
+}
+`))
+		Expect(err.Error()).To(Equal("invalid character ':' after array element"))
+	})
+
+	It("fails because some string lists have empty strings", func() {
+		err := validator.ValidateBytes([]byte(`
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    name: redis-master
+  name: name
+spec:
+  containers:
+  - image: gcr.io/fake_project/fake_image:fake_tag
+    name: master
+    args:
+    -
+    command:
+    -
+`))
+
+		Expect(err).To(Equal(utilerrors.NewAggregate([]error{
+			validation.ValidationError{
+				Path: "Pod.spec.containers[0].args",
+				Err: validation.InvalidObjectTypeError{
+					Path: "Pod.spec.containers[0].args[0]",
+					Type: "nil",
+				},
+			},
+			validation.ValidationError{
+				Path: "Pod.spec.containers[0].command",
+				Err: validation.InvalidObjectTypeError{
+					Path: "Pod.spec.containers[0].command[0]",
+					Type: "nil",
+				},
+			},
+		})))
+	})
+
+	It("fails if required fields are missing", func() {
+		err := validator.ValidateBytes([]byte(`
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    name: redis-master
+  name: name
+spec:
+  containers:
+  - command: ["my", "command"]
+`))
+
+		Expect(err).To(Equal(utilerrors.NewAggregate([]error{
+			validation.ValidationError{
+				Path: "Pod.spec.containers[0]",
+				Err: validation.MissingRequiredFieldError{
+					Path:  "io.k8s.api.core.v1.Container",
+					Field: "name",
+				},
+			},
+		})))
+	})
+
+	It("fails if required fields are empty", func() {
+		err := validator.ValidateBytes([]byte(`
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    name: redis-master
+  name: name
+spec:
+  containers:
+  - image:
+    name:
+`))
+
+		Expect(err).To(Equal(utilerrors.NewAggregate([]error{
+			validation.ValidationError{
+				Path: "Pod.spec.containers[0]",
+				Err: validation.MissingRequiredFieldError{
+					Path:  "io.k8s.api.core.v1.Container",
+					Field: "name",
+				},
+			},
+		})))
+	})
+
+	It("is fine with empty non-mandatory fields", func() {
+		err := validator.ValidateBytes([]byte(`
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    name: redis-master
+  name: name
+spec:
+  containers:
+  - image: image
+    name: name
+    command:
+`))
+
+		Expect(err).To(BeNil())
+	})
+
+	It("can validate lists", func() {
+		err := validator.ValidateBytes([]byte(`
+apiVersion: v1
+kind: List
+items:
+  - apiVersion: v1
+    kind: Pod
+    metadata:
+      labels:
+        name: redis-master
+      name: name
+    spec:
+      containers:
+      - name: name
+`))
+
+		Expect(err).To(BeNil())
+	})
+})

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/printing.go

@@ -0,0 +1,218 @@
+/*
+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 util
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/printers"
+	printersinternal "k8s.io/kubernetes/pkg/printers/internalversion"
+
+	"github.com/spf13/cobra"
+)
+
+// AddPrinterFlags adds printing related flags to a command (e.g. output format, no headers, template path)
+func AddPrinterFlags(cmd *cobra.Command) {
+	AddNonDeprecatedPrinterFlags(cmd)
+
+	cmd.Flags().String("output-version", "", "DEPRECATED: To use a specific API version, fully-qualify the resource, version, and group (for example: 'jobs.v1.batch/myjob').")
+	cmd.Flags().MarkDeprecated("output-version", "The resource is used exactly as fetched from the API. To get a specific API version, fully-qualify the resource, version, and group (for example: 'jobs.v1.batch/myjob').")
+	cmd.Flags().MarkHidden("output-version")
+}
+
+// AddNonDeprecatedPrinterFlags supports the conversion case which must logically have output-version.  Once output-version
+// is completely removed, this function can go away.
+func AddNonDeprecatedPrinterFlags(cmd *cobra.Command) {
+	AddOutputFlags(cmd)
+	AddNoHeadersFlags(cmd)
+	cmd.Flags().Bool("show-labels", false, "When printing, show all labels as the last column (default hide labels column)")
+	cmd.Flags().String("template", "", "Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates [http://golang.org/pkg/text/template/#pkg-overview].")
+	cmd.MarkFlagFilename("template")
+	cmd.Flags().String("sort-by", "", "If non-empty, sort list types using this field specification.  The field specification is expressed as a JSONPath expression (e.g. '{.metadata.name}'). The field in the API resource specified by this JSONPath expression must be an integer or a string.")
+	cmd.Flags().BoolP("show-all", "a", false, "When printing, show all resources (default hide terminated pods.)")
+}
+
+// AddOutputFlagsForMutation adds output related flags to a command. Used by mutations only.
+func AddOutputFlagsForMutation(cmd *cobra.Command) {
+	cmd.Flags().StringP("output", "o", "", "Output mode. Use \"-o name\" for shorter output (resource/name).")
+}
+
+// AddOutputVarFlagsForMutation adds output related flags to a command. Used by mutations only.
+func AddOutputVarFlagsForMutation(cmd *cobra.Command, output *string) {
+	cmd.Flags().StringVarP(output, "output", "o", "", "Output mode. Use \"-o name\" for shorter output (resource/name).")
+}
+
+// AddOutputFlags adds output related flags to a command.
+func AddOutputFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("output", "o", "", "Output format. One of: json|yaml|wide|name|custom-columns=...|custom-columns-file=...|go-template=...|go-template-file=...|jsonpath=...|jsonpath-file=... See custom columns [http://kubernetes.io/docs/user-guide/kubectl-overview/#custom-columns], golang template [http://golang.org/pkg/text/template/#pkg-overview] and jsonpath template [http://kubernetes.io/docs/user-guide/jsonpath].")
+	cmd.Flags().Bool("allow-missing-template-keys", true, "If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats.")
+}
+
+// AddNoHeadersFlags adds no-headers flags to a command.
+func AddNoHeadersFlags(cmd *cobra.Command) {
+	cmd.Flags().Bool("no-headers", false, "When using the default or custom-column output format, don't print headers (default print headers).")
+}
+
+// PrintSuccess prints message after finishing mutating operations
+func PrintSuccess(mapper meta.RESTMapper, shortOutput bool, out io.Writer, resource string, name string, dryRun bool, operation string) {
+	resource, _ = mapper.ResourceSingularizer(resource)
+	dryRunMsg := ""
+	if dryRun {
+		dryRunMsg = " (dry run)"
+	}
+	if shortOutput {
+		// -o name: prints resource/name
+		if len(resource) > 0 {
+			fmt.Fprintf(out, "%s/%s\n", resource, name)
+		} else {
+			fmt.Fprintf(out, "%s\n", name)
+		}
+	} else {
+		// understandable output by default
+		if len(resource) > 0 {
+			fmt.Fprintf(out, "%s \"%s\" %s%s\n", resource, name, operation, dryRunMsg)
+		} else {
+			fmt.Fprintf(out, "\"%s\" %s%s\n", name, operation, dryRunMsg)
+		}
+	}
+}
+
+// ValidateOutputArgs validates -o flag args for mutations
+func ValidateOutputArgs(cmd *cobra.Command) error {
+	outputMode := GetFlagString(cmd, "output")
+	if outputMode != "" && outputMode != "name" {
+		return UsageErrorf(cmd, "Unexpected -o output mode: %v. We only support '-o name'.", outputMode)
+	}
+	return nil
+}
+
+// PrinterForCommand returns the printer for the outputOptions (if given) or
+// returns the default printer for the command. Requires that printer flags have
+// been added to cmd (see AddPrinterFlags).
+// TODO: remove the dependency on cmd object
+func PrinterForCommand(cmd *cobra.Command, outputOpts *printers.OutputOptions, mapper meta.RESTMapper, typer runtime.ObjectTyper, encoder runtime.Encoder, decoders []runtime.Decoder, options printers.PrintOptions) (printers.ResourcePrinter, error) {
+
+	if outputOpts == nil {
+		outputOpts = extractOutputOptions(cmd)
+	}
+
+	// this function may be invoked by a command that did not call AddPrinterFlags first, so we need
+	// to be safe about how we access the no-headers flag
+	noHeaders := false
+	if cmd.Flags().Lookup("no-headers") != nil {
+		noHeaders = GetFlagBool(cmd, "no-headers")
+	}
+	printer, err := printers.GetStandardPrinter(outputOpts, noHeaders, mapper, typer, encoder, decoders, options)
+	if err != nil {
+		return nil, err
+	}
+
+	// we try to convert to HumanReadablePrinter, if return ok, it must be no generic
+	// we execute AddHandlers() here before maybeWrapSortingPrinter so that we don't
+	// need to convert to delegatePrinter again then invoke AddHandlers()
+	if humanReadablePrinter, ok := printer.(*printers.HumanReadablePrinter); ok {
+		printersinternal.AddHandlers(humanReadablePrinter)
+	}
+
+	return maybeWrapSortingPrinter(cmd, printer), nil
+}
+
+// PrintResourceInfoForCommand receives a *cobra.Command and a *resource.Info and
+// attempts to print an info object based on the specified output format. If the
+// object passed is non-generic, it attempts to print the object using a HumanReadablePrinter.
+// Requires that printer flags have been added to cmd (see AddPrinterFlags).
+func PrintResourceInfoForCommand(cmd *cobra.Command, info *resource.Info, f Factory, out io.Writer) error {
+	printer, err := f.PrinterForCommand(cmd, false, nil, printers.PrintOptions{})
+	if err != nil {
+		return err
+	}
+	if !printer.IsGeneric() {
+		printer, err = f.PrinterForMapping(cmd, false, nil, nil, false)
+		if err != nil {
+			return err
+		}
+	}
+	return printer.PrintObj(info.Object, out)
+}
+
+// extractOutputOptions parses printer specific commandline args and returns
+// printers.OutputsOptions object.
+func extractOutputOptions(cmd *cobra.Command) *printers.OutputOptions {
+	flags := cmd.Flags()
+
+	var outputFormat string
+	if flags.Lookup("output") != nil {
+		outputFormat = GetFlagString(cmd, "output")
+	}
+
+	// templates are logically optional for specifying a format.
+	// TODO once https://github.com/kubernetes/kubernetes/issues/12668 is fixed, this should fall back to GetFlagString
+	var templateFile string
+	if flag := flags.Lookup("template"); flag != nil {
+		if flag.Value.Type() == "string" {
+			templateFile = GetFlagString(cmd, "template")
+		}
+	}
+	if len(outputFormat) == 0 && len(templateFile) != 0 {
+		outputFormat = "template"
+	}
+
+	templateFormats := []string{
+		"go-template=", "go-template-file=", "jsonpath=", "jsonpath-file=", "custom-columns=", "custom-columns-file=",
+	}
+	for _, format := range templateFormats {
+		if strings.HasPrefix(outputFormat, format) {
+			templateFile = outputFormat[len(format):]
+			outputFormat = format[:len(format)-1]
+		}
+	}
+
+	// this function may be invoked by a command that did not call AddPrinterFlags first, so we need
+	// to be safe about how we access the allow-missing-template-keys flag
+	allowMissingTemplateKeys := false
+	if flags.Lookup("allow-missing-template-keys") != nil {
+		allowMissingTemplateKeys = GetFlagBool(cmd, "allow-missing-template-keys")
+	}
+
+	return &printers.OutputOptions{
+		FmtType:          outputFormat,
+		FmtArg:           templateFile,
+		AllowMissingKeys: allowMissingTemplateKeys,
+	}
+}
+
+func maybeWrapSortingPrinter(cmd *cobra.Command, printer printers.ResourcePrinter) printers.ResourcePrinter {
+	sorting, err := cmd.Flags().GetString("sort-by")
+	if err != nil {
+		// error can happen on missing flag or bad flag type.  In either case, this command didn't intent to sort
+		return printer
+	}
+
+	if len(sorting) != 0 {
+		return &kubectl.SortingPrinter{
+			Delegate:  printer,
+			SortField: fmt.Sprintf("{%s}", sorting),
+		}
+	}
+	return printer
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/sanity/BUILD

@@ -0,0 +1,32 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["cmd_sanity.go"],
+    visibility = [
+        "//build/visible_to:pkg_kubectl_cmd_util_sanity_CONSUMERS",
+    ],
+    deps = [
+        "//pkg/kubectl/cmd/templates:go_default_library",
+        "//vendor/github.com/spf13/cobra:go_default_library",
+        "//vendor/github.com/spf13/pflag:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = [
+        "//build/visible_to:pkg_kubectl_cmd_util_sanity_CONSUMERS",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/sanity/cmd_sanity.go

@@ -0,0 +1,149 @@
+/*
+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 sanity
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+)
+
+type CmdCheck func(cmd *cobra.Command) []error
+type GlobalCheck func() []error
+
+var (
+	AllCmdChecks = []CmdCheck{
+		CheckLongDesc,
+		CheckExamples,
+		CheckFlags,
+	}
+	AllGlobalChecks = []GlobalCheck{
+		CheckGlobalVarFlags,
+	}
+)
+
+func RunGlobalChecks(globalChecks []GlobalCheck) []error {
+	fmt.Fprint(os.Stdout, "---+ RUNNING GLOBAL CHECKS\n")
+	errors := []error{}
+	for _, check := range globalChecks {
+		errors = append(errors, check()...)
+	}
+	return errors
+}
+
+func RunCmdChecks(cmd *cobra.Command, cmdChecks []CmdCheck, skipCmd []string) []error {
+	cmdPath := cmd.CommandPath()
+
+	for _, skipCmdPath := range skipCmd {
+		if cmdPath == skipCmdPath {
+			fmt.Fprintf(os.Stdout, "---+ skipping command %s\n", cmdPath)
+			return []error{}
+		}
+	}
+
+	errors := []error{}
+
+	if cmd.HasSubCommands() {
+		for _, subCmd := range cmd.Commands() {
+			errors = append(errors, RunCmdChecks(subCmd, cmdChecks, skipCmd)...)
+		}
+	}
+
+	fmt.Fprintf(os.Stdout, "---+ RUNNING COMMAND CHECKS on %q\n", cmdPath)
+
+	for _, check := range cmdChecks {
+		if err := check(cmd); err != nil && len(err) > 0 {
+			errors = append(errors, err...)
+		}
+	}
+
+	return errors
+}
+
+func CheckLongDesc(cmd *cobra.Command) []error {
+	fmt.Fprint(os.Stdout, "   ↳ checking long description\n")
+	cmdPath := cmd.CommandPath()
+	long := cmd.Long
+	if len(long) > 0 {
+		if strings.Trim(long, " \t\n") != long {
+			return []error{fmt.Errorf(`command %q: long description is not normalized, make sure you are calling templates.LongDesc (from pkg/cmd/templates) before assigning cmd.Long`, cmdPath)}
+		}
+	}
+	return nil
+}
+
+func CheckExamples(cmd *cobra.Command) []error {
+	fmt.Fprint(os.Stdout, "   ↳ checking examples\n")
+	cmdPath := cmd.CommandPath()
+	examples := cmd.Example
+	errors := []error{}
+	if len(examples) > 0 {
+		for _, line := range strings.Split(examples, "\n") {
+			if !strings.HasPrefix(line, templates.Indentation) {
+				errors = append(errors, fmt.Errorf(`command %q: examples are not normalized, make sure you are calling templates.Examples (from pkg/cmd/templates) before assigning cmd.Example`, cmdPath))
+			}
+			if trimmed := strings.TrimSpace(line); strings.HasPrefix(trimmed, "//") {
+				errors = append(errors, fmt.Errorf(`command %q: we use # to start comments in examples instead of //`, cmdPath))
+			}
+		}
+	}
+	return errors
+}
+
+func CheckFlags(cmd *cobra.Command) []error {
+	allFlagsSlice := []*pflag.Flag{}
+
+	cmd.Flags().VisitAll(func(f *pflag.Flag) {
+		allFlagsSlice = append(allFlagsSlice, f)
+	})
+	cmd.PersistentFlags().VisitAll(func(f *pflag.Flag) {
+		allFlagsSlice = append(allFlagsSlice, f)
+	})
+
+	fmt.Fprintf(os.Stdout, "   ↳ checking %d flags\n", len(allFlagsSlice))
+
+	errors := []error{}
+
+	// check flags long names
+	regex, err := regexp.Compile(`^[a-z]+[a-z\-]*$`)
+	if err != nil {
+		errors = append(errors, fmt.Errorf("command %q: unable to compile regex to check flags", cmd.CommandPath()))
+		return errors
+	}
+	for _, flag := range allFlagsSlice {
+		name := flag.Name
+		if !regex.MatchString(name) {
+			errors = append(errors, fmt.Errorf("command %q: flag name %q is invalid, long form of flag names can only contain lowercase characters or dash (must match %v)", cmd.CommandPath(), name, regex))
+		}
+	}
+
+	return errors
+}
+
+func CheckGlobalVarFlags() []error {
+	fmt.Fprint(os.Stdout, "   ↳ checking flags from global vars\n")
+	errors := []error{}
+	pflag.CommandLine.VisitAll(func(f *pflag.Flag) {
+		errors = append(errors, fmt.Errorf("flag %q is invalid, please don't register any flag under the global variable \"CommandLine\"", f.Name))
+	})
+	return errors
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/shortcut_restmapper.go

@@ -0,0 +1,140 @@
+/*
+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 util
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/golang/glog"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/discovery"
+	"k8s.io/kubernetes/pkg/kubectl"
+)
+
+// shortcutExpander is a RESTMapper that can be used for Kubernetes resources.   It expands the resource first, then invokes the wrapped
+type shortcutExpander struct {
+	RESTMapper meta.RESTMapper
+
+	discoveryClient discovery.DiscoveryInterface
+}
+
+var _ meta.RESTMapper = &shortcutExpander{}
+
+func NewShortcutExpander(delegate meta.RESTMapper, client discovery.DiscoveryInterface) (shortcutExpander, error) {
+	if client == nil {
+		return shortcutExpander{}, errors.New("Please provide discovery client to shortcut expander")
+	}
+	return shortcutExpander{RESTMapper: delegate, discoveryClient: client}, nil
+}
+
+func (e shortcutExpander) KindFor(resource schema.GroupVersionResource) (schema.GroupVersionKind, error) {
+	return e.RESTMapper.KindFor(e.expandResourceShortcut(resource))
+}
+
+func (e shortcutExpander) KindsFor(resource schema.GroupVersionResource) ([]schema.GroupVersionKind, error) {
+	return e.RESTMapper.KindsFor(e.expandResourceShortcut(resource))
+}
+
+func (e shortcutExpander) ResourcesFor(resource schema.GroupVersionResource) ([]schema.GroupVersionResource, error) {
+	return e.RESTMapper.ResourcesFor(e.expandResourceShortcut(resource))
+}
+
+func (e shortcutExpander) ResourceFor(resource schema.GroupVersionResource) (schema.GroupVersionResource, error) {
+	return e.RESTMapper.ResourceFor(e.expandResourceShortcut(resource))
+}
+
+func (e shortcutExpander) ResourceSingularizer(resource string) (string, error) {
+	return e.RESTMapper.ResourceSingularizer(e.expandResourceShortcut(schema.GroupVersionResource{Resource: resource}).Resource)
+}
+
+func (e shortcutExpander) RESTMapping(gk schema.GroupKind, versions ...string) (*meta.RESTMapping, error) {
+	return e.RESTMapper.RESTMapping(gk, versions...)
+}
+
+func (e shortcutExpander) RESTMappings(gk schema.GroupKind, versions ...string) ([]*meta.RESTMapping, error) {
+	return e.RESTMapper.RESTMappings(gk, versions...)
+}
+
+// getShortcutMappings returns a set of tuples which holds short names for resources.
+// First the list of potential resources will be taken from the API server.
+// Next we will append the hardcoded list of resources - to be backward compatible with old servers.
+// NOTE that the list is ordered by group priority.
+func (e shortcutExpander) getShortcutMappings() ([]kubectl.ResourceShortcuts, error) {
+	res := []kubectl.ResourceShortcuts{}
+	// get server resources
+	apiResList, err := e.discoveryClient.ServerResources()
+	if err == nil {
+		for _, apiResources := range apiResList {
+			for _, apiRes := range apiResources.APIResources {
+				for _, shortName := range apiRes.ShortNames {
+					gv, err := schema.ParseGroupVersion(apiResources.GroupVersion)
+					if err != nil {
+						glog.V(1).Infof("Unable to parse groupversion = %s due to = %s", apiResources.GroupVersion, err.Error())
+						continue
+					}
+					rs := kubectl.ResourceShortcuts{
+						ShortForm: schema.GroupResource{Group: gv.Group, Resource: shortName},
+						LongForm:  schema.GroupResource{Group: gv.Group, Resource: apiRes.Name},
+					}
+					res = append(res, rs)
+				}
+			}
+		}
+	}
+
+	// append hardcoded short forms at the end of the list
+	res = append(res, kubectl.ResourcesShortcutStatic...)
+	return res, nil
+}
+
+// expandResourceShortcut will return the expanded version of resource
+// (something that a pkg/api/meta.RESTMapper can understand), if it is
+// indeed a shortcut. If no match has been found, we will match on group prefixing.
+// Lastly we will return resource unmodified.
+func (e shortcutExpander) expandResourceShortcut(resource schema.GroupVersionResource) schema.GroupVersionResource {
+	// get the shortcut mappings and return on first match.
+	if resources, err := e.getShortcutMappings(); err == nil {
+		for _, item := range resources {
+			if len(resource.Group) != 0 && resource.Group != item.ShortForm.Group {
+				continue
+			}
+			if resource.Resource == item.ShortForm.Resource {
+				resource.Resource = item.LongForm.Resource
+				return resource
+			}
+		}
+
+		// we didn't find exact match so match on group prefixing. This allows autoscal to match autoscaling
+		if len(resource.Group) == 0 {
+			return resource
+		}
+		for _, item := range resources {
+			if !strings.HasPrefix(item.ShortForm.Group, resource.Group) {
+				continue
+			}
+			if resource.Resource == item.ShortForm.Resource {
+				resource.Resource = item.LongForm.Resource
+				return resource
+			}
+		}
+	}
+
+	return resource
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/util/shortcut_restmapper_test.go

@@ -0,0 +1,146 @@
+/*
+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 util
+
+import (
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubernetes/pkg/api/testapi"
+)
+
+func TestReplaceAliases(t *testing.T) {
+	tests := []struct {
+		name     string
+		arg      string
+		expected schema.GroupVersionResource
+		srvRes   []*metav1.APIResourceList
+	}{
+		{
+			name:     "rc-resolves-to-replicationcontrollers",
+			arg:      "rc",
+			expected: schema.GroupVersionResource{Resource: "replicationcontrollers"},
+			srvRes:   []*metav1.APIResourceList{},
+		},
+		{
+			name:     "storageclasses-no-replacement",
+			arg:      "storageclasses",
+			expected: schema.GroupVersionResource{Resource: "storageclasses"},
+			srvRes:   []*metav1.APIResourceList{},
+		},
+		{
+			name:     "hpa-priority",
+			arg:      "hpa",
+			expected: schema.GroupVersionResource{Resource: "superhorizontalpodautoscalers"},
+			srvRes: []*metav1.APIResourceList{
+				{
+					GroupVersion: "autoscaling/v1",
+					APIResources: []metav1.APIResource{
+						{
+							Name:       "superhorizontalpodautoscalers",
+							ShortNames: []string{"hpa"},
+						},
+					},
+				},
+				{
+					GroupVersion: "autoscaling/v1",
+					APIResources: []metav1.APIResource{
+						{
+							Name:       "horizontalpodautoscalers",
+							ShortNames: []string{"hpa"},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	ds := &fakeDiscoveryClient{}
+	mapper, err := NewShortcutExpander(testapi.Default.RESTMapper(), ds)
+	if err != nil {
+		t.Fatalf("Unable to create shortcut expander, err %s", err.Error())
+	}
+
+	for _, test := range tests {
+		ds.serverResourcesHandler = func() ([]*metav1.APIResourceList, error) {
+			return test.srvRes, nil
+		}
+		actual := mapper.expandResourceShortcut(schema.GroupVersionResource{Resource: test.arg})
+		if actual != test.expected {
+			t.Errorf("%s: unexpected argument: expected %s, got %s", test.name, test.expected, actual)
+		}
+	}
+}
+
+func TestKindFor(t *testing.T) {
+	tests := []struct {
+		in       schema.GroupVersionResource
+		expected schema.GroupVersionKind
+		srvRes   []*metav1.APIResourceList
+	}{
+		{
+			in:       schema.GroupVersionResource{Group: "storage.k8s.io", Version: "", Resource: "sc"},
+			expected: schema.GroupVersionKind{Group: "storage.k8s.io", Version: "v1", Kind: "StorageClass"},
+			srvRes: []*metav1.APIResourceList{
+				{
+					GroupVersion: "storage.k8s.io/v1",
+					APIResources: []metav1.APIResource{
+						{
+							Name:       "storageclasses",
+							ShortNames: []string{"sc"},
+						},
+					},
+				},
+			},
+		},
+		{
+			in:       schema.GroupVersionResource{Group: "", Version: "", Resource: "sc"},
+			expected: schema.GroupVersionKind{Group: "storage.k8s.io", Version: "v1", Kind: "StorageClass"},
+			srvRes: []*metav1.APIResourceList{
+				{
+					GroupVersion: "storage.k8s.io/v1",
+					APIResources: []metav1.APIResource{
+						{
+							Name:       "storageclasses",
+							ShortNames: []string{"sc"},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	ds := &fakeDiscoveryClient{}
+	mapper, err := NewShortcutExpander(testapi.Default.RESTMapper(), ds)
+	if err != nil {
+		t.Fatalf("Unable to create shortcut expander, err %s", err.Error())
+	}
+
+	for i, test := range tests {
+		ds.serverResourcesHandler = func() ([]*metav1.APIResourceList, error) {
+			return test.srvRes, nil
+		}
+		ret, err := mapper.KindFor(test.in)
+		if err != nil {
+			t.Errorf("%d: unexpected error returned %s", i, err.Error())
+		}
+		if ret != test.expected {
+			t.Errorf("%d: unexpected data returned %#v, expected %#v", i, ret, test.expected)
+		}
+	}
+}