Add glide.yaml and vendor deps

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

@@ -0,0 +1,190 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "apply.go",
+        "autoscale.go",
+        "bash_comp_utils.go",
+        "cluster.go",
+        "clusterrolebinding.go",
+        "configmap.go",
+        "custom_column_printer.go",
+        "deployment.go",
+        "describe.go",
+        "doc.go",
+        "explain.go",
+        "generate.go",
+        "history.go",
+        "interfaces.go",
+        "kubectl.go",
+        "namespace.go",
+        "pdb.go",
+        "proxy_server.go",
+        "quota.go",
+        "resource_filter.go",
+        "resource_printer.go",
+        "rollback.go",
+        "rolling_updater.go",
+        "rollout_status.go",
+        "run.go",
+        "scale.go",
+        "secret.go",
+        "secret_for_docker_registry.go",
+        "secret_for_tls.go",
+        "service.go",
+        "service_basic.go",
+        "serviceaccount.go",
+        "sorted_resource_name_list.go",
+        "sorting_printer.go",
+        "stop.go",
+        "versioned_client.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//federation/apis/federation:go_default_library",
+        "//federation/apis/federation/v1beta1:go_default_library",
+        "//federation/client/clientset_generated/federation_internalclientset:go_default_library",
+        "//pkg/api:go_default_library",
+        "//pkg/api/annotations:go_default_library",
+        "//pkg/api/errors:go_default_library",
+        "//pkg/api/events:go_default_library",
+        "//pkg/api/meta:go_default_library",
+        "//pkg/api/resource:go_default_library",
+        "//pkg/api/util:go_default_library",
+        "//pkg/api/v1:go_default_library",
+        "//pkg/apis/apps:go_default_library",
+        "//pkg/apis/autoscaling:go_default_library",
+        "//pkg/apis/batch:go_default_library",
+        "//pkg/apis/batch/v1:go_default_library",
+        "//pkg/apis/batch/v2alpha1:go_default_library",
+        "//pkg/apis/certificates:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/extensions/v1beta1:go_default_library",
+        "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/apis/policy:go_default_library",
+        "//pkg/apis/rbac:go_default_library",
+        "//pkg/apis/storage:go_default_library",
+        "//pkg/apis/storage/util:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/typed/apps/internalversion:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/typed/batch/internalversion:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/typed/core/internalversion:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/typed/extensions/internalversion:go_default_library",
+        "//pkg/client/clientset_generated/release_1_5:go_default_library",
+        "//pkg/client/clientset_generated/release_1_5/typed/core/v1:go_default_library",
+        "//pkg/client/clientset_generated/release_1_5/typed/extensions/v1beta1:go_default_library",
+        "//pkg/client/restclient:go_default_library",
+        "//pkg/client/retry:go_default_library",
+        "//pkg/client/unversioned:go_default_library",
+        "//pkg/controller/deployment/util:go_default_library",
+        "//pkg/credentialprovider:go_default_library",
+        "//pkg/fieldpath:go_default_library",
+        "//pkg/fields:go_default_library",
+        "//pkg/kubectl/resource:go_default_library",
+        "//pkg/kubelet/qos:go_default_library",
+        "//pkg/labels:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/runtime/schema:go_default_library",
+        "//pkg/types:go_default_library",
+        "//pkg/util:go_default_library",
+        "//pkg/util/cert:go_default_library",
+        "//pkg/util/errors:go_default_library",
+        "//pkg/util/integer:go_default_library",
+        "//pkg/util/intstr:go_default_library",
+        "//pkg/util/jsonpath:go_default_library",
+        "//pkg/util/node:go_default_library",
+        "//pkg/util/sets:go_default_library",
+        "//pkg/util/slice:go_default_library",
+        "//pkg/util/uuid:go_default_library",
+        "//pkg/util/validation:go_default_library",
+        "//pkg/util/wait:go_default_library",
+        "//pkg/watch:go_default_library",
+        "//vendor:github.com/emicklei/go-restful/swagger",
+        "//vendor:github.com/ghodss/yaml",
+        "//vendor:github.com/golang/glog",
+        "//vendor:github.com/spf13/cobra",
+        "//vendor:github.com/spf13/pflag",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "cluster_test.go",
+        "configmap_test.go",
+        "custom_column_printer_test.go",
+        "deployment_test.go",
+        "describe_test.go",
+        "generate_test.go",
+        "kubectl_test.go",
+        "namespace_test.go",
+        "proxy_server_test.go",
+        "quota_test.go",
+        "resource_printer_test.go",
+        "rolling_updater_test.go",
+        "rollout_status_test.go",
+        "run_test.go",
+        "scale_test.go",
+        "secret_for_docker_registry_test.go",
+        "secret_for_tls_test.go",
+        "secret_test.go",
+        "service_basic_test.go",
+        "service_test.go",
+        "serviceaccount_test.go",
+        "sorted_resource_name_list_test.go",
+        "sorting_printer_test.go",
+        "stop_test.go",
+    ],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//federation/apis/federation:go_default_library",
+        "//federation/apis/federation/v1beta1:go_default_library",
+        "//federation/client/clientset_generated/federation_internalclientset/fake:go_default_library",
+        "//pkg/api:go_default_library",
+        "//pkg/api/errors:go_default_library",
+        "//pkg/api/resource:go_default_library",
+        "//pkg/api/testapi:go_default_library",
+        "//pkg/api/testing:go_default_library",
+        "//pkg/api/v1:go_default_library",
+        "//pkg/apimachinery/registered:go_default_library",
+        "//pkg/apis/batch:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/extensions/v1beta1:go_default_library",
+        "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/apis/policy:go_default_library",
+        "//pkg/apis/storage:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/fake:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/typed/batch/internalversion:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/typed/core/internalversion:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/typed/extensions/internalversion:go_default_library",
+        "//pkg/client/clientset_generated/release_1_5/fake:go_default_library",
+        "//pkg/client/restclient:go_default_library",
+        "//pkg/client/restclient/fake:go_default_library",
+        "//pkg/client/testing/core:go_default_library",
+        "//pkg/controller/deployment/util:go_default_library",
+        "//pkg/kubectl/testing:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/runtime/schema:go_default_library",
+        "//pkg/runtime/serializer/yaml:go_default_library",
+        "//pkg/util/diff:go_default_library",
+        "//pkg/util/intstr:go_default_library",
+        "//pkg/util/sets:go_default_library",
+        "//pkg/util/testing:go_default_library",
+        "//pkg/watch:go_default_library",
+        "//vendor:github.com/ghodss/yaml",
+        "//vendor:github.com/spf13/cobra",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/OWNERS

@@ -0,0 +1,4 @@
+approvers:
+- sig-cli-maintainers
+reviewers:
+- sig-cli

vendor/k8s.io/kubernetes/pkg/kubectl/apply.go

@@ -0,0 +1,190 @@
+/*
+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 kubectl
+
+import (
+	"encoding/json"
+
+	"k8s.io/kubernetes/pkg/api/annotations"
+	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+// GetOriginalConfiguration retrieves the original configuration of the object
+// from the annotation, or nil if no annotation was found.
+func GetOriginalConfiguration(mapping *meta.RESTMapping, obj runtime.Object) ([]byte, error) {
+	annots, err := mapping.MetadataAccessor.Annotations(obj)
+	if err != nil {
+		return nil, err
+	}
+
+	if annots == nil {
+		return nil, nil
+	}
+
+	original, ok := annots[annotations.LastAppliedConfigAnnotation]
+	if !ok {
+		return nil, nil
+	}
+
+	return []byte(original), nil
+}
+
+// SetOriginalConfiguration sets the original configuration of the object
+// as the annotation on the object for later use in computing a three way patch.
+func SetOriginalConfiguration(info *resource.Info, original []byte) error {
+	if len(original) < 1 {
+		return nil
+	}
+
+	accessor := info.Mapping.MetadataAccessor
+	annots, err := accessor.Annotations(info.Object)
+	if err != nil {
+		return err
+	}
+
+	if annots == nil {
+		annots = map[string]string{}
+	}
+
+	annots[annotations.LastAppliedConfigAnnotation] = string(original)
+	if err := info.Mapping.MetadataAccessor.SetAnnotations(info.Object, annots); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// GetModifiedConfiguration retrieves the modified configuration of the object.
+// If annotate is true, it embeds the result as an annotation in the modified
+// configuration. If an object was read from the command input, it will use that
+// version of the object. Otherwise, it will use the version from the server.
+func GetModifiedConfiguration(info *resource.Info, annotate bool, codec runtime.Encoder) ([]byte, error) {
+	// First serialize the object without the annotation to prevent recursion,
+	// then add that serialization to it as the annotation and serialize it again.
+	var modified []byte
+	if info.VersionedObject != nil {
+		// If an object was read from input, use that version.
+		accessor, err := meta.Accessor(info.VersionedObject)
+		if err != nil {
+			return nil, err
+		}
+
+		// Get the current annotations from the object.
+		annots := accessor.GetAnnotations()
+		if annots == nil {
+			annots = map[string]string{}
+		}
+
+		original := annots[annotations.LastAppliedConfigAnnotation]
+		delete(annots, annotations.LastAppliedConfigAnnotation)
+		accessor.SetAnnotations(annots)
+		// TODO: this needs to be abstracted - there should be no assumption that versioned object
+		// can be marshalled to JSON.
+		modified, err = json.Marshal(info.VersionedObject)
+		if err != nil {
+			return nil, err
+		}
+
+		if annotate {
+			annots[annotations.LastAppliedConfigAnnotation] = string(modified)
+			accessor.SetAnnotations(annots)
+			// TODO: this needs to be abstracted - there should be no assumption that versioned object
+			// can be marshalled to JSON.
+			modified, err = json.Marshal(info.VersionedObject)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		// Restore the object to its original condition.
+		annots[annotations.LastAppliedConfigAnnotation] = original
+		accessor.SetAnnotations(annots)
+	} else {
+		// Otherwise, use the server side version of the object.
+		accessor := info.Mapping.MetadataAccessor
+		// Get the current annotations from the object.
+		annots, err := accessor.Annotations(info.Object)
+		if err != nil {
+			return nil, err
+		}
+
+		if annots == nil {
+			annots = map[string]string{}
+		}
+
+		original := annots[annotations.LastAppliedConfigAnnotation]
+		delete(annots, annotations.LastAppliedConfigAnnotation)
+		if err := accessor.SetAnnotations(info.Object, annots); err != nil {
+			return nil, err
+		}
+
+		modified, err = runtime.Encode(codec, info.Object)
+		if err != nil {
+			return nil, err
+		}
+
+		if annotate {
+			annots[annotations.LastAppliedConfigAnnotation] = string(modified)
+			if err := info.Mapping.MetadataAccessor.SetAnnotations(info.Object, annots); err != nil {
+				return nil, err
+			}
+
+			modified, err = runtime.Encode(codec, info.Object)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		// Restore the object to its original condition.
+		annots[annotations.LastAppliedConfigAnnotation] = original
+		if err := info.Mapping.MetadataAccessor.SetAnnotations(info.Object, annots); err != nil {
+			return nil, err
+		}
+	}
+
+	return modified, nil
+}
+
+// UpdateApplyAnnotation calls CreateApplyAnnotation if the last applied
+// configuration annotation is already present. Otherwise, it does nothing.
+func UpdateApplyAnnotation(info *resource.Info, codec runtime.Encoder) error {
+	if original, err := GetOriginalConfiguration(info.Mapping, info.Object); err != nil || len(original) <= 0 {
+		return err
+	}
+	return CreateApplyAnnotation(info, codec)
+}
+
+// CreateApplyAnnotation gets the modified configuration of the object,
+// without embedding it again, and then sets it on the object as the annotation.
+func CreateApplyAnnotation(info *resource.Info, codec runtime.Encoder) error {
+	modified, err := GetModifiedConfiguration(info, false, codec)
+	if err != nil {
+		return err
+	}
+	return SetOriginalConfiguration(info, modified)
+}
+
+// Create the annotation used by kubectl apply only when createAnnotation is true
+// Otherwise, only update the annotation when it already exists
+func CreateOrUpdateAnnotation(createAnnotation bool, info *resource.Info, codec runtime.Encoder) error {
+	if createAnnotation {
+		return CreateApplyAnnotation(info, codec)
+	}
+	return UpdateApplyAnnotation(info, codec)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/autoscale.go

@@ -0,0 +1,130 @@
+/*
+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 kubectl
+
+import (
+	"fmt"
+	"strconv"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apis/autoscaling"
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+type HorizontalPodAutoscalerV1Beta1 struct{}
+
+func (HorizontalPodAutoscalerV1Beta1) ParamNames() []GeneratorParam {
+	return []GeneratorParam{
+		{"default-name", true},
+		{"name", false},
+		{"scaleRef-kind", false},
+		{"scaleRef-name", false},
+		{"scaleRef-apiVersion", false},
+		{"scaleRef-subresource", false},
+		{"min", false},
+		{"max", true},
+		{"cpu-percent", false},
+	}
+}
+
+func (HorizontalPodAutoscalerV1Beta1) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
+	return generateHPA(genericParams)
+}
+
+type HorizontalPodAutoscalerV1 struct{}
+
+func (HorizontalPodAutoscalerV1) ParamNames() []GeneratorParam {
+	return []GeneratorParam{
+		{"default-name", true},
+		{"name", false},
+		{"scaleRef-kind", false},
+		{"scaleRef-name", false},
+		{"scaleRef-apiVersion", false},
+		{"min", false},
+		{"max", true},
+		{"cpu-percent", false},
+	}
+}
+
+func (HorizontalPodAutoscalerV1) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
+	return generateHPA(genericParams)
+}
+
+func generateHPA(genericParams map[string]interface{}) (runtime.Object, error) {
+	params := map[string]string{}
+	for key, value := range genericParams {
+		strVal, isString := value.(string)
+		if !isString {
+			return nil, fmt.Errorf("expected string, saw %v for '%s'", value, key)
+		}
+		params[key] = strVal
+	}
+
+	name, found := params["name"]
+	if !found || len(name) == 0 {
+		name, found = params["default-name"]
+		if !found || len(name) == 0 {
+			return nil, fmt.Errorf("'name' is a required parameter.")
+		}
+	}
+	minString, found := params["min"]
+	min := -1
+	var err error
+	if found {
+		if min, err = strconv.Atoi(minString); err != nil {
+			return nil, err
+		}
+	}
+	maxString, found := params["max"]
+	if !found {
+		return nil, fmt.Errorf("'max' is a required parameter.")
+	}
+	max, err := strconv.Atoi(maxString)
+	if err != nil {
+		return nil, err
+	}
+	cpuString, found := params["cpu-percent"]
+	cpu := -1
+	if found {
+		if cpu, err = strconv.Atoi(cpuString); err != nil {
+			return nil, err
+		}
+	}
+
+	scaler := autoscaling.HorizontalPodAutoscaler{
+		ObjectMeta: api.ObjectMeta{
+			Name: name,
+		},
+		Spec: autoscaling.HorizontalPodAutoscalerSpec{
+			ScaleTargetRef: autoscaling.CrossVersionObjectReference{
+				Kind:       params["scaleRef-kind"],
+				Name:       params["scaleRef-name"],
+				APIVersion: params["scaleRef-apiVersion"],
+			},
+			MaxReplicas: int32(max),
+		},
+	}
+	if min > 0 {
+		v := int32(min)
+		scaler.Spec.MinReplicas = &v
+	}
+	if cpu >= 0 {
+		c := int32(cpu)
+		scaler.Spec.TargetCPUUtilizationPercentage = &c
+	}
+	return &scaler, nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/bash_comp_utils.go

@@ -0,0 +1,36 @@
+/*
+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.
+*/
+
+// A set of common functions needed by cmd/kubectl and pkg/kubectl packages.
+
+package kubectl
+
+import (
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+)
+
+func AddJsonFilenameFlag(cmd *cobra.Command, value *[]string, usage string) {
+	cmd.Flags().StringSliceVarP(value, "filename", "f", *value, usage)
+	annotations := make([]string, 0, len(resource.FileExtensions))
+	for _, ext := range resource.FileExtensions {
+		annotations = append(annotations, strings.TrimLeft(ext, "."))
+	}
+	cmd.Flags().SetAnnotation("filename", cobra.BashCompFilenameExt, annotations)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cluster.go

@@ -0,0 +1,125 @@
+/*
+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 kubectl
+
+import (
+	"fmt"
+
+	federationapi "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	"k8s.io/kubernetes/pkg/api/v1"
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+// ClusterGeneratorV1Beta1 supports stable generation of a
+// federation/cluster resource.
+type ClusterGeneratorV1Beta1 struct {
+	// Name of the cluster context (required)
+	Name string
+	// ClientCIDR is the CIDR range in which the Kubernetes APIServer
+	// is available for the client (optional)
+	ClientCIDR string
+	// ServerAddress is the APIServer address of the Kubernetes cluster
+	// that is being registered (required)
+	ServerAddress string
+	// SecretName is the name of the secret that stores the credentials
+	// for the Kubernetes cluster that is being registered (optional)
+	SecretName string
+}
+
+// Ensure it supports the generator pattern that uses parameter
+// injection.
+var _ Generator = &ClusterGeneratorV1Beta1{}
+
+// Ensure it supports the generator pattern that uses parameters
+// specified during construction.
+var _ StructuredGenerator = &ClusterGeneratorV1Beta1{}
+
+// Generate returns a cluster resource using the specified parameters.
+func (s ClusterGeneratorV1Beta1) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
+	err := ValidateParams(s.ParamNames(), genericParams)
+	if err != nil {
+		return nil, err
+	}
+	clustergen := &ClusterGeneratorV1Beta1{}
+	params := map[string]string{}
+	for key, value := range genericParams {
+		strVal, isString := value.(string)
+		if !isString {
+			return nil, fmt.Errorf("expected string, saw %v for '%s'", value, key)
+		}
+		params[key] = strVal
+	}
+	clustergen.Name = params["name"]
+	clustergen.ClientCIDR = params["client-cidr"]
+	clustergen.ServerAddress = params["server-address"]
+	clustergen.SecretName = params["secret"]
+	return clustergen.StructuredGenerate()
+}
+
+// ParamNames returns the set of supported input parameters when using
+// the parameter injection generator pattern.
+func (s ClusterGeneratorV1Beta1) ParamNames() []GeneratorParam {
+	return []GeneratorParam{
+		{"name", true},
+		{"client-cidr", false},
+		{"server-address", true},
+		{"secret", false},
+	}
+}
+
+// StructuredGenerate outputs a federation cluster resource object
+// using the configured fields.
+func (s ClusterGeneratorV1Beta1) StructuredGenerate() (runtime.Object, error) {
+	if err := s.validate(); err != nil {
+		return nil, err
+	}
+	if s.ClientCIDR == "" {
+		s.ClientCIDR = "0.0.0.0/0"
+	}
+	if s.SecretName == "" {
+		s.SecretName = s.Name
+	}
+	cluster := &federationapi.Cluster{
+		ObjectMeta: v1.ObjectMeta{
+			Name: s.Name,
+		},
+		Spec: federationapi.ClusterSpec{
+			ServerAddressByClientCIDRs: []federationapi.ServerAddressByClientCIDR{
+				{
+					ClientCIDR:    s.ClientCIDR,
+					ServerAddress: s.ServerAddress,
+				},
+			},
+			SecretRef: &v1.LocalObjectReference{
+				Name: s.SecretName,
+			},
+		},
+	}
+	return cluster, nil
+}
+
+// validate validates required fields are set to support structured
+// generation.
+func (s ClusterGeneratorV1Beta1) validate() error {
+	if len(s.Name) == 0 {
+		return fmt.Errorf("name must be specified")
+	}
+	if len(s.ServerAddress) == 0 {
+		return fmt.Errorf("server address must be specified")
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cluster_test.go

@@ -0,0 +1,160 @@
+/*
+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 kubectl
+
+import (
+	"reflect"
+	"testing"
+
+	federationapi "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	"k8s.io/kubernetes/pkg/api/v1"
+)
+
+func TestClusterGenerate(t *testing.T) {
+	tests := []struct {
+		params    map[string]interface{}
+		expected  *federationapi.Cluster
+		expectErr bool
+	}{
+		{
+			params: map[string]interface{}{
+				"name":           "foo",
+				"client-cidr":    "0.0.0.0/0",
+				"server-address": "10.20.30.40",
+				"secret":         "foo-credentials",
+			},
+			expected: &federationapi.Cluster{
+				ObjectMeta: v1.ObjectMeta{
+					Name: "foo",
+				},
+				Spec: federationapi.ClusterSpec{
+					ServerAddressByClientCIDRs: []federationapi.ServerAddressByClientCIDR{
+						{
+							ClientCIDR:    "0.0.0.0/0",
+							ServerAddress: "10.20.30.40",
+						},
+					},
+					SecretRef: &v1.LocalObjectReference{
+						Name: "foo-credentials",
+					},
+				},
+			},
+			expectErr: false,
+		},
+		{
+			params: map[string]interface{}{
+				"name":           "foo",
+				"client-cidr":    "10.20.30.40/16",
+				"server-address": "https://foo.example.com",
+				"secret":         "foo-credentials",
+			},
+			expected: &federationapi.Cluster{
+				ObjectMeta: v1.ObjectMeta{
+					Name: "foo",
+				},
+				Spec: federationapi.ClusterSpec{
+					ServerAddressByClientCIDRs: []federationapi.ServerAddressByClientCIDR{
+						{
+							ClientCIDR:    "10.20.30.40/16",
+							ServerAddress: "https://foo.example.com",
+						},
+					},
+					SecretRef: &v1.LocalObjectReference{
+						Name: "foo-credentials",
+					},
+				},
+			},
+			expectErr: false,
+		},
+		{
+			params: map[string]interface{}{
+				"name":           "bar-cluster",
+				"client-cidr":    "10.20.30.40/16",
+				"server-address": "http://10.20.30.40",
+				"secret":         "credentials",
+			},
+			expected: &federationapi.Cluster{
+				ObjectMeta: v1.ObjectMeta{
+					Name: "bar-cluster",
+				},
+				Spec: federationapi.ClusterSpec{
+					ServerAddressByClientCIDRs: []federationapi.ServerAddressByClientCIDR{
+						{
+							ClientCIDR:    "10.20.30.40/16",
+							ServerAddress: "http://10.20.30.40",
+						},
+					},
+					SecretRef: &v1.LocalObjectReference{
+						Name: "credentials",
+					},
+				},
+			},
+			expectErr: false,
+		},
+		{
+			params: map[string]interface{}{
+				"server-address": "https://10.20.30.40",
+			},
+			expected:  nil,
+			expectErr: true,
+		},
+		{
+			params: map[string]interface{}{
+				"secret": "baz-credentials",
+			},
+			expected:  nil,
+			expectErr: true,
+		},
+		{
+			params: map[string]interface{}{
+				"server-address": "http://foo.example.com",
+				"secret":         "foo-credentials",
+			},
+			expected:  nil,
+			expectErr: true,
+		},
+		{
+			params: map[string]interface{}{
+				"name":   "foo",
+				"secret": "foo-credentials",
+			},
+			expected:  nil,
+			expectErr: true,
+		},
+		{
+			params: map[string]interface{}{
+				"name":        "foo",
+				"client-cidr": "10.20.30.40/16",
+			},
+			expected:  nil,
+			expectErr: true,
+		},
+	}
+	generator := ClusterGeneratorV1Beta1{}
+	for i, test := range tests {
+		obj, err := generator.Generate(test.params)
+		if !test.expectErr && err != nil {
+			t.Errorf("[%d] unexpected error: %v", i, err)
+		}
+		if test.expectErr && err != nil {
+			continue
+		}
+		if !reflect.DeepEqual(obj.(*federationapi.Cluster), test.expected) {
+			t.Errorf("\n[%d] want:\n%#v\n[%d] got:\n%#v", i, test.expected, i, obj.(*federationapi.Cluster))
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/clusterrolebinding.go

@@ -0,0 +1,132 @@
+/*
+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 kubectl
+
+import (
+	"fmt"
+
+	"k8s.io/kubernetes/pkg/apis/rbac"
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+// ClusterRoleBindingGeneratorV1 supports stable generation of a clusterRoleBinding.
+type ClusterRoleBindingGeneratorV1 struct {
+	// Name of clusterRoleBinding (required)
+	Name string
+	// ClusterRole for the clusterRoleBinding (required)
+	ClusterRole string
+	// Users to derive the clusterRoleBinding from (optional)
+	Users []string
+	// Groups to derive the clusterRoleBinding from (optional)
+	Groups []string
+}
+
+// Ensure it supports the generator pattern that uses parameter injection.
+var _ Generator = &ClusterRoleBindingGeneratorV1{}
+
+// Ensure it supports the generator pattern that uses parameters specified during construction.
+var _ StructuredGenerator = &ClusterRoleBindingGeneratorV1{}
+
+// Generate returns a clusterRoleBinding using the specified parameters.
+func (s ClusterRoleBindingGeneratorV1) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
+	err := ValidateParams(s.ParamNames(), genericParams)
+	if err != nil {
+		return nil, err
+	}
+	delegate := &ClusterRoleBindingGeneratorV1{}
+	fromFileStrings, found := genericParams["user"]
+	if found {
+		fromFileArray, isArray := fromFileStrings.([]string)
+		if !isArray {
+			return nil, fmt.Errorf("expected []string, found :%v", fromFileStrings)
+		}
+		delegate.Users = fromFileArray
+		delete(genericParams, "user")
+	}
+	fromLiteralStrings, found := genericParams["group"]
+	if found {
+		fromLiteralArray, isArray := fromLiteralStrings.([]string)
+		if !isArray {
+			return nil, fmt.Errorf("expected []string, found :%v", fromFileStrings)
+		}
+		delegate.Groups = fromLiteralArray
+		delete(genericParams, "group")
+	}
+	params := map[string]string{}
+	for key, value := range genericParams {
+		strVal, isString := value.(string)
+		if !isString {
+			return nil, fmt.Errorf("expected string, saw %v for '%s'", value, key)
+		}
+		params[key] = strVal
+	}
+	delegate.Name = params["name"]
+	delegate.ClusterRole = params["clusterrole"]
+	return delegate.StructuredGenerate()
+}
+
+// ParamNames returns the set of supported input parameters when using the parameter injection generator pattern.
+func (s ClusterRoleBindingGeneratorV1) ParamNames() []GeneratorParam {
+	return []GeneratorParam{
+		{"name", true},
+		{"clusterrole", false},
+		{"user", false},
+		{"group", false},
+		{"force", false},
+	}
+}
+
+// StructuredGenerate outputs a clusterRoleBinding object using the configured fields.
+func (s ClusterRoleBindingGeneratorV1) StructuredGenerate() (runtime.Object, error) {
+	if err := s.validate(); err != nil {
+		return nil, err
+	}
+	clusterRoleBinding := &rbac.ClusterRoleBinding{}
+	clusterRoleBinding.Name = s.Name
+	clusterRoleBinding.RoleRef = rbac.RoleRef{
+		APIGroup: rbac.GroupName,
+		Kind:     "ClusterRole",
+		Name:     s.ClusterRole,
+	}
+	for _, user := range s.Users {
+		clusterRoleBinding.Subjects = append(clusterRoleBinding.Subjects, rbac.Subject{
+			Kind:       rbac.UserKind,
+			APIVersion: "rbac/v1alpha1",
+			Name:       user,
+		})
+	}
+	for _, group := range s.Groups {
+		clusterRoleBinding.Subjects = append(clusterRoleBinding.Subjects, rbac.Subject{
+			Kind:       rbac.GroupKind,
+			APIVersion: "rbac/v1alpha1",
+			Name:       group,
+		})
+	}
+
+	return clusterRoleBinding, nil
+}
+
+// validate validates required fields are set to support structured generation.
+func (s ClusterRoleBindingGeneratorV1) validate() error {
+	if len(s.Name) == 0 {
+		return fmt.Errorf("name must be specified")
+	}
+	if len(s.ClusterRole) == 0 {
+		return fmt.Errorf("clusterrole must be specified")
+	}
+	return nil
+}

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

@@ -0,0 +1,209 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "annotate.go",
+        "apiversions.go",
+        "apply.go",
+        "attach.go",
+        "autoscale.go",
+        "certificates.go",
+        "clusterinfo.go",
+        "clusterinfo_dump.go",
+        "cmd.go",
+        "completion.go",
+        "convert.go",
+        "cp.go",
+        "create.go",
+        "create_clusterrolebinding.go",
+        "create_configmap.go",
+        "create_deployment.go",
+        "create_namespace.go",
+        "create_pdb.go",
+        "create_quota.go",
+        "create_secret.go",
+        "create_service.go",
+        "create_serviceaccount.go",
+        "delete.go",
+        "describe.go",
+        "drain.go",
+        "edit.go",
+        "exec.go",
+        "explain.go",
+        "expose.go",
+        "get.go",
+        "help.go",
+        "label.go",
+        "logs.go",
+        "options.go",
+        "patch.go",
+        "portforward.go",
+        "proxy.go",
+        "replace.go",
+        "rollingupdate.go",
+        "run.go",
+        "scale.go",
+        "stop.go",
+        "taint.go",
+        "top.go",
+        "top_node.go",
+        "top_pod.go",
+        "version.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/annotations:go_default_library",
+        "//pkg/api/errors:go_default_library",
+        "//pkg/api/meta:go_default_library",
+        "//pkg/api/v1:go_default_library",
+        "//pkg/api/validation:go_default_library",
+        "//pkg/apimachinery/registered:go_default_library",
+        "//pkg/apis/batch/v1:go_default_library",
+        "//pkg/apis/certificates:go_default_library",
+        "//pkg/apis/extensions/v1beta1:go_default_library",
+        "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/apis/policy:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/typed/core/internalversion:go_default_library",
+        "//pkg/client/restclient:go_default_library",
+        "//pkg/client/unversioned:go_default_library",
+        "//pkg/client/unversioned/clientcmd:go_default_library",
+        "//pkg/client/unversioned/portforward:go_default_library",
+        "//pkg/client/unversioned/remotecommand:go_default_library",
+        "//pkg/fields:go_default_library",
+        "//pkg/kubectl:go_default_library",
+        "//pkg/kubectl/cmd/config:go_default_library",
+        "//pkg/kubectl/cmd/rollout:go_default_library",
+        "//pkg/kubectl/cmd/set:go_default_library",
+        "//pkg/kubectl/cmd/templates:go_default_library",
+        "//pkg/kubectl/cmd/util:go_default_library",
+        "//pkg/kubectl/cmd/util/editor:go_default_library",
+        "//pkg/kubectl/metricsutil:go_default_library",
+        "//pkg/kubectl/resource:go_default_library",
+        "//pkg/kubelet/server/remotecommand:go_default_library",
+        "//pkg/kubelet/types:go_default_library",
+        "//pkg/labels:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/runtime/schema:go_default_library",
+        "//pkg/util/crlf:go_default_library",
+        "//pkg/util/errors:go_default_library",
+        "//pkg/util/exec:go_default_library",
+        "//pkg/util/flag:go_default_library",
+        "//pkg/util/interrupt:go_default_library",
+        "//pkg/util/intstr:go_default_library",
+        "//pkg/util/sets:go_default_library",
+        "//pkg/util/strategicpatch:go_default_library",
+        "//pkg/util/term:go_default_library",
+        "//pkg/util/validation:go_default_library",
+        "//pkg/util/validation/field:go_default_library",
+        "//pkg/util/wait:go_default_library",
+        "//pkg/util/yaml:go_default_library",
+        "//pkg/version:go_default_library",
+        "//pkg/watch:go_default_library",
+        "//vendor:github.com/daviddengcn/go-colortext",
+        "//vendor:github.com/docker/distribution/reference",
+        "//vendor:github.com/docker/docker/pkg/term",
+        "//vendor:github.com/evanphx/json-patch",
+        "//vendor:github.com/golang/glog",
+        "//vendor:github.com/jonboulle/clockwork",
+        "//vendor:github.com/renstrom/dedent",
+        "//vendor:github.com/spf13/cobra",
+        "//vendor:github.com/spf13/pflag",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "annotate_test.go",
+        "apply_test.go",
+        "attach_test.go",
+        "clusterinfo_dump_test.go",
+        "cmd_test.go",
+        "cp_test.go",
+        "create_configmap_test.go",
+        "create_deployment_test.go",
+        "create_namespace_test.go",
+        "create_quota_test.go",
+        "create_secret_test.go",
+        "create_service_test.go",
+        "create_serviceaccount_test.go",
+        "create_test.go",
+        "delete_test.go",
+        "describe_test.go",
+        "drain_test.go",
+        "exec_test.go",
+        "expose_test.go",
+        "get_test.go",
+        "label_test.go",
+        "logs_test.go",
+        "patch_test.go",
+        "portforward_test.go",
+        "replace_test.go",
+        "rollingupdate_test.go",
+        "run_test.go",
+        "taint_test.go",
+        "top_node_test.go",
+        "top_pod_test.go",
+        "top_test.go",
+    ],
+    data = [
+        "//examples:config",
+        "//test/fixtures",
+    ],
+    library = "go_default_library",
+    tags = [
+        "automanaged",
+        "skip",
+    ],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/annotations:go_default_library",
+        "//pkg/api/errors:go_default_library",
+        "//pkg/api/meta:go_default_library",
+        "//pkg/api/resource:go_default_library",
+        "//pkg/api/testapi:go_default_library",
+        "//pkg/api/testing:go_default_library",
+        "//pkg/api/unversioned:go_default_library",
+        "//pkg/api/v1:go_default_library",
+        "//pkg/apimachinery/registered:go_default_library",
+        "//pkg/apis/batch:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/apis/policy:go_default_library",
+        "//pkg/client/restclient:go_default_library",
+        "//pkg/client/restclient/fake:go_default_library",
+        "//pkg/client/typed/dynamic:go_default_library",
+        "//pkg/conversion:go_default_library",
+        "//pkg/kubectl:go_default_library",
+        "//pkg/kubectl/cmd/testing:go_default_library",
+        "//pkg/kubectl/cmd/util:go_default_library",
+        "//pkg/kubectl/resource:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/runtime/schema:go_default_library",
+        "//pkg/runtime/serializer/json:go_default_library",
+        "//pkg/runtime/serializer/streaming:go_default_library",
+        "//pkg/types:go_default_library",
+        "//pkg/util/intstr:go_default_library",
+        "//pkg/util/strings:go_default_library",
+        "//pkg/util/term:go_default_library",
+        "//pkg/util/wait:go_default_library",
+        "//pkg/watch:go_default_library",
+        "//pkg/watch/versioned:go_default_library",
+        "//vendor:github.com/spf13/cobra",
+        "//vendor:github.com/stretchr/testify/assert",
+        "//vendor:k8s.io/heapster/metrics/apis/metrics/v1alpha1",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/annotate.go

@@ -0,0 +1,345 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"github.com/golang/glog"
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/util/strategicpatch"
+)
+
+// AnnotateOptions have the data required to perform the annotate operation
+type AnnotateOptions struct {
+	// Filename options
+	resource.FilenameOptions
+
+	// Common user flags
+	overwrite         bool
+	local             bool
+	dryrun            bool
+	all               bool
+	resourceVersion   string
+	selector          string
+	outputFormat      string
+	recordChangeCause bool
+
+	// results of arg parsing
+	resources         []string
+	newAnnotations    map[string]string
+	removeAnnotations []string
+
+	// Common share fields
+	out io.Writer
+}
+
+var (
+	annotate_long = templates.LongDesc(`
+		Update the annotations on one or more resources.
+
+		* An annotation is a key/value pair that can hold larger (compared to a label), and possibly not human-readable, data.
+		* It is intended to store non-identifying auxiliary data, especially data manipulated by tools and system extensions.
+		* If --overwrite is true, then existing annotations can be overwritten, otherwise attempting to overwrite an annotation will result in an error.
+		* If --resource-version is specified, then updates will use this resource version, otherwise the existing resource-version will be used.
+
+		` + valid_resources)
+
+	annotate_example = templates.Examples(`
+    # Update pod 'foo' with the annotation 'description' and the value 'my frontend'.
+    # If the same annotation is set multiple times, only the last value will be applied
+    kubectl annotate pods foo description='my frontend'
+
+    # Update a pod identified by type and name in "pod.json"
+    kubectl annotate -f pod.json description='my frontend'
+
+    # Update pod 'foo' with the annotation 'description' and the value 'my frontend running nginx', overwriting any existing value.
+    kubectl annotate --overwrite pods foo description='my frontend running nginx'
+
+    # Update all pods in the namespace
+    kubectl annotate pods --all description='my frontend running nginx'
+
+    # Update pod 'foo' only if the resource is unchanged from version 1.
+    kubectl annotate pods foo description='my frontend running nginx' --resource-version=1
+
+    # Update pod 'foo' by removing an annotation named 'description' if it exists.
+    # Does not require the --overwrite flag.
+    kubectl annotate pods foo description-`)
+)
+
+func NewCmdAnnotate(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &AnnotateOptions{}
+
+	// retrieve a list of handled resources from printer as valid args
+	validArgs, argAliases := []string{}, []string{}
+	p, err := f.Printer(nil, kubectl.PrintOptions{
+		ColumnLabels: []string{},
+	})
+	cmdutil.CheckErr(err)
+	if p != nil {
+		validArgs = p.HandledResources()
+		argAliases = kubectl.ResourceAliases(validArgs)
+	}
+
+	cmd := &cobra.Command{
+		Use:     "annotate [--overwrite] (-f FILENAME | TYPE NAME) KEY_1=VAL_1 ... KEY_N=VAL_N [--resource-version=version]",
+		Short:   "Update the annotations on a resource",
+		Long:    annotate_long,
+		Example: annotate_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := options.Complete(f, out, cmd, args); err != nil {
+				cmdutil.CheckErr(cmdutil.UsageError(cmd, err.Error()))
+			}
+			if err := options.Validate(); err != nil {
+				cmdutil.CheckErr(cmdutil.UsageError(cmd, err.Error()))
+			}
+			cmdutil.CheckErr(options.RunAnnotate(f, cmd))
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+	cmdutil.AddPrinterFlags(cmd)
+	cmd.Flags().Bool("overwrite", false, "If true, allow annotations to be overwritten, otherwise reject annotation updates that overwrite existing annotations.")
+	cmd.Flags().Bool("local", false, "If true, annotation will NOT contact api-server but run locally.")
+	cmd.Flags().StringP("selector", "l", "", "Selector (label query) to filter on")
+	cmd.Flags().Bool("all", false, "select all resources in the namespace of the specified resource types")
+	cmd.Flags().String("resource-version", "", "If non-empty, the annotation update will only succeed if this is the current resource-version for the object. Only valid when specifying a single resource.")
+	usage := "identifying the resource to update the annotation"
+	cmdutil.AddFilenameOptionFlags(cmd, &options.FilenameOptions, usage)
+	cmdutil.AddDryRunFlag(cmd)
+	cmdutil.AddRecordFlag(cmd)
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+
+	return cmd
+}
+
+// Complete adapts from the command line args and factory to the data required.
+func (o *AnnotateOptions) Complete(f cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string) (err error) {
+	o.out = out
+	o.local = cmdutil.GetFlagBool(cmd, "local")
+	o.overwrite = cmdutil.GetFlagBool(cmd, "overwrite")
+	o.all = cmdutil.GetFlagBool(cmd, "all")
+	o.resourceVersion = cmdutil.GetFlagString(cmd, "resource-version")
+	o.selector = cmdutil.GetFlagString(cmd, "selector")
+	o.outputFormat = cmdutil.GetFlagString(cmd, "output")
+	o.dryrun = cmdutil.GetDryRunFlag(cmd)
+	o.recordChangeCause = cmdutil.GetRecordFlag(cmd)
+
+	// retrieves resource and annotation args from args
+	// also checks args to verify that all resources are specified before annotations
+	resources, annotationArgs, err := cmdutil.GetResourcesAndPairs(args, "annotation")
+	if err != nil {
+		return err
+	}
+	o.resources = resources
+	o.newAnnotations, o.removeAnnotations, err = parseAnnotations(annotationArgs)
+	return err
+}
+
+// Validate checks to the AnnotateOptions to see if there is sufficient information run the command.
+func (o AnnotateOptions) Validate() error {
+	if len(o.resources) < 1 && cmdutil.IsFilenameEmpty(o.Filenames) {
+		return fmt.Errorf("one or more resources must be specified as <resource> <name> or <resource>/<name>")
+	}
+	if len(o.newAnnotations) < 1 && len(o.removeAnnotations) < 1 {
+		return fmt.Errorf("at least one annotation update is required")
+	}
+	return validateAnnotations(o.removeAnnotations, o.newAnnotations)
+}
+
+// RunAnnotate does the work
+func (o AnnotateOptions) RunAnnotate(f cmdutil.Factory, cmd *cobra.Command) error {
+	namespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	changeCause := f.Command()
+	mapper, typer := f.Object()
+	b := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
+		ContinueOnError().
+		NamespaceParam(namespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, &o.FilenameOptions).
+		Flatten()
+
+	if !o.local {
+		b = b.SelectorParam(o.selector).
+			ResourceTypeOrNameArgs(o.all, o.resources...).
+			Latest()
+	}
+	r := b.Do()
+	if err := r.Err(); err != nil {
+		return err
+	}
+
+	var singularResource bool
+	r.IntoSingular(&singularResource)
+
+	// only apply resource version locking on a single resource.
+	// we must perform this check after o.builder.Do() as
+	// []o.resources can not not accurately return the proper number
+	// of resources when they are not passed in "resource/name" format.
+	if !singularResource && len(o.resourceVersion) > 0 {
+		return fmt.Errorf("--resource-version may only be used with a single resource")
+	}
+
+	return r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+
+		var outputObj runtime.Object
+		obj, err := cmdutil.MaybeConvertObject(info.Object, info.Mapping.GroupVersionKind.GroupVersion(), info.Mapping)
+		if err != nil {
+			return err
+		}
+		if o.dryrun || o.local {
+			if err := o.updateAnnotations(obj); err != nil {
+				return err
+			}
+			outputObj = obj
+		} else {
+			name, namespace := info.Name, info.Namespace
+			oldData, err := json.Marshal(obj)
+			if err != nil {
+				return err
+			}
+			// If we should record change-cause, add it to new annotations
+			if cmdutil.ContainsChangeCause(info) || o.recordChangeCause {
+				o.newAnnotations[kubectl.ChangeCauseAnnotation] = changeCause
+			}
+			if err := o.updateAnnotations(obj); err != nil {
+				return err
+			}
+			newData, err := json.Marshal(obj)
+			if err != nil {
+				return err
+			}
+			patchBytes, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, obj)
+			createdPatch := err == nil
+			if err != nil {
+				glog.V(2).Infof("couldn't compute patch: %v", err)
+			}
+
+			mapping := info.ResourceMapping()
+			client, err := f.ClientForMapping(mapping)
+			if err != nil {
+				return err
+			}
+			helper := resource.NewHelper(client, mapping)
+
+			if createdPatch {
+				outputObj, err = helper.Patch(namespace, name, api.StrategicMergePatchType, patchBytes)
+			} else {
+				outputObj, err = helper.Replace(namespace, name, false, obj)
+			}
+			if err != nil {
+				return err
+			}
+		}
+		if o.outputFormat != "" {
+			return f.PrintObject(cmd, mapper, outputObj, o.out)
+		}
+		cmdutil.PrintSuccess(mapper, false, o.out, info.Mapping.Resource, info.Name, o.dryrun, "annotated")
+		return nil
+	})
+}
+
+// parseAnnotations retrieves new and remove annotations from annotation args
+func parseAnnotations(annotationArgs []string) (map[string]string, []string, error) {
+	return cmdutil.ParsePairs(annotationArgs, "annotation", true)
+}
+
+// validateAnnotations checks the format of annotation args and checks removed annotations aren't in the new annotations map
+func validateAnnotations(removeAnnotations []string, newAnnotations map[string]string) error {
+	var modifyRemoveBuf bytes.Buffer
+	for _, removeAnnotation := range removeAnnotations {
+		if _, found := newAnnotations[removeAnnotation]; found {
+			if modifyRemoveBuf.Len() > 0 {
+				modifyRemoveBuf.WriteString(", ")
+			}
+			modifyRemoveBuf.WriteString(fmt.Sprintf(removeAnnotation))
+		}
+	}
+	if modifyRemoveBuf.Len() > 0 {
+		return fmt.Errorf("can not both modify and remove the following annotation(s) in the same command: %s", modifyRemoveBuf.String())
+	}
+
+	return nil
+}
+
+// validateNoAnnotationOverwrites validates that when overwrite is false, to-be-updated annotations don't exist in the object annotation map (yet)
+func validateNoAnnotationOverwrites(accessor meta.Object, annotations map[string]string) error {
+	var buf bytes.Buffer
+	for key := range annotations {
+		// change-cause annotation can always be overwritten
+		if key == kubectl.ChangeCauseAnnotation {
+			continue
+		}
+		if value, found := accessor.GetAnnotations()[key]; found {
+			if buf.Len() > 0 {
+				buf.WriteString("; ")
+			}
+			buf.WriteString(fmt.Sprintf("'%s' already has a value (%s)", key, value))
+		}
+	}
+	if buf.Len() > 0 {
+		return fmt.Errorf("--overwrite is false but found the following declared annotation(s): %s", buf.String())
+	}
+	return nil
+}
+
+// updateAnnotations updates annotations of obj
+func (o AnnotateOptions) updateAnnotations(obj runtime.Object) error {
+	accessor, err := meta.Accessor(obj)
+	if err != nil {
+		return err
+	}
+	if !o.overwrite {
+		if err := validateNoAnnotationOverwrites(accessor, o.newAnnotations); err != nil {
+			return err
+		}
+	}
+
+	annotations := accessor.GetAnnotations()
+	if annotations == nil {
+		annotations = make(map[string]string)
+	}
+
+	for key, value := range o.newAnnotations {
+		annotations[key] = value
+	}
+	for _, annotation := range o.removeAnnotations {
+		delete(annotations, annotation)
+	}
+	accessor.SetAnnotations(annotations)
+
+	if len(o.resourceVersion) != 0 {
+		accessor.SetResourceVersion(o.resourceVersion)
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/apiversions.go

@@ -0,0 +1,65 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"sort"
+
+	"github.com/spf13/cobra"
+
+	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+func NewCmdApiVersions(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use: "api-versions",
+		// apiversions is deprecated.
+		Aliases: []string{"apiversions"},
+		Short:   "Print the supported API versions on the server, in the form of \"group/version\"",
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunApiVersions(f, out)
+			cmdutil.CheckErr(err)
+		},
+	}
+	return cmd
+}
+
+func RunApiVersions(f cmdutil.Factory, w io.Writer) error {
+	if len(os.Args) > 1 && os.Args[1] == "apiversions" {
+		printDeprecationWarning("api-versions", "apiversions")
+	}
+
+	clientset, err := f.ClientSet()
+	if err != nil {
+		return err
+	}
+
+	groupList, err := clientset.Discovery().ServerGroups()
+	if err != nil {
+		return fmt.Errorf("Couldn't get available api versions from server: %v\n", err)
+	}
+	apiVersions := metav1.ExtractGroupVersions(groupList)
+	sort.Strings(apiVersions)
+	for _, v := range apiVersions {
+		fmt.Fprintln(w, v)
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/apply_test.go

@@ -0,0 +1,377 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/annotations"
+	kubeerr "k8s.io/kubernetes/pkg/api/errors"
+	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/api/testapi"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/runtime/schema"
+)
+
+func TestApplyExtraArgsFail(t *testing.T) {
+	buf := bytes.NewBuffer([]byte{})
+
+	f, _, _, _ := cmdtesting.NewAPIFactory()
+	c := NewCmdApply(f, buf)
+	if validateApplyArgs(c, []string{"rc"}) == nil {
+		t.Fatalf("unexpected non-error")
+	}
+}
+
+func validateApplyArgs(cmd *cobra.Command, args []string) error {
+	if len(args) != 0 {
+		return cmdutil.UsageError(cmd, "Unexpected args: %v", args)
+	}
+	return nil
+}
+
+const (
+	filenameRC    = "../../../test/fixtures/pkg/kubectl/cmd/apply/rc.yaml"
+	filenameSVC   = "../../../test/fixtures/pkg/kubectl/cmd/apply/service.yaml"
+	filenameRCSVC = "../../../test/fixtures/pkg/kubectl/cmd/apply/rc-service.yaml"
+)
+
+func readBytesFromFile(t *testing.T, filename string) []byte {
+	file, err := os.Open(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer file.Close()
+
+	data, err := ioutil.ReadAll(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return data
+}
+
+func readReplicationControllerFromFile(t *testing.T, filename string) *api.ReplicationController {
+	data := readBytesFromFile(t, filename)
+	rc := api.ReplicationController{}
+	if err := runtime.DecodeInto(testapi.Default.Codec(), data, &rc); err != nil {
+		t.Fatal(err)
+	}
+
+	return &rc
+}
+
+func readServiceFromFile(t *testing.T, filename string) *api.Service {
+	data := readBytesFromFile(t, filename)
+	svc := api.Service{}
+	if err := runtime.DecodeInto(testapi.Default.Codec(), data, &svc); err != nil {
+		t.Fatal(err)
+	}
+
+	return &svc
+}
+
+func annotateRuntimeObject(t *testing.T, originalObj, currentObj runtime.Object, kind string) (string, []byte) {
+	originalAccessor, err := meta.Accessor(originalObj)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	originalLabels := originalAccessor.GetLabels()
+	originalLabels["DELETE_ME"] = "DELETE_ME"
+	originalAccessor.SetLabels(originalLabels)
+	original, err := runtime.Encode(testapi.Default.Codec(), originalObj)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	currentAccessor, err := meta.Accessor(currentObj)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	currentAnnotations := currentAccessor.GetAnnotations()
+	if currentAnnotations == nil {
+		currentAnnotations = make(map[string]string)
+	}
+	currentAnnotations[annotations.LastAppliedConfigAnnotation] = string(original)
+	currentAccessor.SetAnnotations(currentAnnotations)
+	current, err := runtime.Encode(testapi.Default.Codec(), currentObj)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return currentAccessor.GetName(), current
+}
+
+func readAndAnnotateReplicationController(t *testing.T, filename string) (string, []byte) {
+	rc1 := readReplicationControllerFromFile(t, filename)
+	rc2 := readReplicationControllerFromFile(t, filename)
+	return annotateRuntimeObject(t, rc1, rc2, "ReplicationController")
+}
+
+func readAndAnnotateService(t *testing.T, filename string) (string, []byte) {
+	svc1 := readServiceFromFile(t, filename)
+	svc2 := readServiceFromFile(t, filename)
+	return annotateRuntimeObject(t, svc1, svc2, "Service")
+}
+
+func validatePatchApplication(t *testing.T, req *http.Request) {
+	patch, err := ioutil.ReadAll(req.Body)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	patchMap := map[string]interface{}{}
+	if err := json.Unmarshal(patch, &patchMap); err != nil {
+		t.Fatal(err)
+	}
+
+	annotationsMap := walkMapPath(t, patchMap, []string{"metadata", "annotations"})
+	if _, ok := annotationsMap[annotations.LastAppliedConfigAnnotation]; !ok {
+		t.Fatalf("patch does not contain annotation:\n%s\n", patch)
+	}
+
+	labelMap := walkMapPath(t, patchMap, []string{"metadata", "labels"})
+	if deleteMe, ok := labelMap["DELETE_ME"]; !ok || deleteMe != nil {
+		t.Fatalf("patch does not remove deleted key: DELETE_ME:\n%s\n", patch)
+	}
+}
+
+func walkMapPath(t *testing.T, start map[string]interface{}, path []string) map[string]interface{} {
+	finish := start
+	for i := 0; i < len(path); i++ {
+		var ok bool
+		finish, ok = finish[path[i]].(map[string]interface{})
+		if !ok {
+			t.Fatalf("key:%s of path:%v not found in map:%v", path[i], path, start)
+		}
+	}
+
+	return finish
+}
+
+func TestApplyObject(t *testing.T) {
+	initTestErrorHandler(t)
+	nameRC, currentRC := readAndAnnotateReplicationController(t, filenameRC)
+	pathRC := "/namespaces/test/replicationcontrollers/" + nameRC
+
+	f, tf, _, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == pathRC && m == "GET":
+				bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC))
+				return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodyRC}, nil
+			case p == pathRC && m == "PATCH":
+				validatePatchApplication(t, req)
+				bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC))
+				return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodyRC}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdApply(f, buf)
+	cmd.Flags().Set("filename", filenameRC)
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	// uses the name from the file, not the response
+	expectRC := "replicationcontroller/" + nameRC + "\n"
+	if buf.String() != expectRC {
+		t.Fatalf("unexpected output: %s\nexpected: %s", buf.String(), expectRC)
+	}
+}
+
+func TestApplyRetry(t *testing.T) {
+	initTestErrorHandler(t)
+	nameRC, currentRC := readAndAnnotateReplicationController(t, filenameRC)
+	pathRC := "/namespaces/test/replicationcontrollers/" + nameRC
+
+	firstPatch := true
+	retry := false
+	getCount := 0
+	f, tf, _, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == pathRC && m == "GET":
+				getCount++
+				bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC))
+				return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodyRC}, nil
+			case p == pathRC && m == "PATCH":
+				if firstPatch {
+					firstPatch = false
+					statusErr := kubeerr.NewConflict(schema.GroupResource{Group: "", Resource: "rc"}, "test-rc", fmt.Errorf("the object has been modified. Please apply at first."))
+					bodyBytes, _ := json.Marshal(statusErr)
+					bodyErr := ioutil.NopCloser(bytes.NewReader(bodyBytes))
+					return &http.Response{StatusCode: http.StatusConflict, Header: defaultHeader(), Body: bodyErr}, nil
+				}
+				retry = true
+				validatePatchApplication(t, req)
+				bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC))
+				return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodyRC}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdApply(f, buf)
+	cmd.Flags().Set("filename", filenameRC)
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	if !retry || getCount != 2 {
+		t.Fatalf("apply didn't retry when get conflict error")
+	}
+
+	// uses the name from the file, not the response
+	expectRC := "replicationcontroller/" + nameRC + "\n"
+	if buf.String() != expectRC {
+		t.Fatalf("unexpected output: %s\nexpected: %s", buf.String(), expectRC)
+	}
+}
+
+func TestApplyNonExistObject(t *testing.T) {
+	nameRC, currentRC := readAndAnnotateReplicationController(t, filenameRC)
+	pathRC := "/namespaces/test/replicationcontrollers"
+	pathNameRC := pathRC + "/" + nameRC
+
+	f, tf, _, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/api/v1/namespaces/test" && m == "GET":
+				return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: ioutil.NopCloser(bytes.NewReader(nil))}, nil
+			case p == pathNameRC && m == "GET":
+				return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: ioutil.NopCloser(bytes.NewReader(nil))}, nil
+			case p == pathRC && m == "POST":
+				bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC))
+				return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: bodyRC}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdApply(f, buf)
+	cmd.Flags().Set("filename", filenameRC)
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	// uses the name from the file, not the response
+	expectRC := "replicationcontroller/" + nameRC + "\n"
+	if buf.String() != expectRC {
+		t.Errorf("unexpected output: %s\nexpected: %s", buf.String(), expectRC)
+	}
+}
+
+func TestApplyMultipleObjectsAsList(t *testing.T) {
+	testApplyMultipleObjects(t, true)
+}
+
+func TestApplyMultipleObjectsAsFiles(t *testing.T) {
+	testApplyMultipleObjects(t, false)
+}
+
+func testApplyMultipleObjects(t *testing.T, asList bool) {
+	nameRC, currentRC := readAndAnnotateReplicationController(t, filenameRC)
+	pathRC := "/namespaces/test/replicationcontrollers/" + nameRC
+
+	nameSVC, currentSVC := readAndAnnotateService(t, filenameSVC)
+	pathSVC := "/namespaces/test/services/" + nameSVC
+
+	f, tf, _, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == pathRC && m == "GET":
+				bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC))
+				return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodyRC}, nil
+			case p == pathRC && m == "PATCH":
+				validatePatchApplication(t, req)
+				bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC))
+				return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodyRC}, nil
+			case p == pathSVC && m == "GET":
+				bodySVC := ioutil.NopCloser(bytes.NewReader(currentSVC))
+				return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodySVC}, nil
+			case p == pathSVC && m == "PATCH":
+				validatePatchApplication(t, req)
+				bodySVC := ioutil.NopCloser(bytes.NewReader(currentSVC))
+				return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodySVC}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdApply(f, buf)
+	if asList {
+		cmd.Flags().Set("filename", filenameRCSVC)
+	} else {
+		cmd.Flags().Set("filename", filenameRC)
+		cmd.Flags().Set("filename", filenameSVC)
+	}
+	cmd.Flags().Set("output", "name")
+
+	cmd.Run(cmd, []string{})
+
+	// Names should come from the REST response, NOT the files
+	expectRC := "replicationcontroller/" + nameRC + "\n"
+	expectSVC := "service/" + nameSVC + "\n"
+	// Test both possible orders since output is non-deterministic.
+	expectOne := expectRC + expectSVC
+	expectTwo := expectSVC + expectRC
+	if buf.String() != expectOne && buf.String() != expectTwo {
+		t.Fatalf("unexpected output: %s\nexpected: %s OR %s", buf.String(), expectOne, expectTwo)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/attach.go

@@ -0,0 +1,287 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"net/url"
+
+	"github.com/golang/glog"
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"
+	"k8s.io/kubernetes/pkg/client/restclient"
+	"k8s.io/kubernetes/pkg/client/unversioned/remotecommand"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	remotecommandserver "k8s.io/kubernetes/pkg/kubelet/server/remotecommand"
+	utilerrors "k8s.io/kubernetes/pkg/util/errors"
+	"k8s.io/kubernetes/pkg/util/term"
+)
+
+var (
+	attach_example = templates.Examples(`
+		# Get output from running pod 123456-7890, using the first container by default
+		kubectl attach 123456-7890
+
+		# Get output from ruby-container from pod 123456-7890
+		kubectl attach 123456-7890 -c ruby-container
+
+		# Switch to raw terminal mode, sends stdin to 'bash' in ruby-container from pod 123456-7890
+		# and sends stdout/stderr from 'bash' back to the client
+		kubectl attach 123456-7890 -c ruby-container -i -t`)
+)
+
+func NewCmdAttach(f cmdutil.Factory, cmdIn io.Reader, cmdOut, cmdErr io.Writer) *cobra.Command {
+	options := &AttachOptions{
+		StreamOptions: StreamOptions{
+			In:  cmdIn,
+			Out: cmdOut,
+			Err: cmdErr,
+		},
+
+		Attach: &DefaultRemoteAttach{},
+	}
+	cmd := &cobra.Command{
+		Use:     "attach POD -c CONTAINER",
+		Short:   "Attach to a running container",
+		Long:    "Attach to a process that is already running inside an existing container.",
+		Example: attach_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(options.Complete(f, cmd, args))
+			cmdutil.CheckErr(options.Validate())
+			cmdutil.CheckErr(options.Run())
+		},
+	}
+	// TODO support UID
+	cmd.Flags().StringVarP(&options.ContainerName, "container", "c", "", "Container name. If omitted, the first container in the pod will be chosen")
+	cmd.Flags().BoolVarP(&options.Stdin, "stdin", "i", false, "Pass stdin to the container")
+	cmd.Flags().BoolVarP(&options.TTY, "tty", "t", false, "Stdin is a TTY")
+	return cmd
+}
+
+// RemoteAttach defines the interface accepted by the Attach command - provided for test stubbing
+type RemoteAttach interface {
+	Attach(method string, url *url.URL, config *restclient.Config, stdin io.Reader, stdout, stderr io.Writer, tty bool, terminalSizeQueue term.TerminalSizeQueue) error
+}
+
+// DefaultRemoteAttach is the standard implementation of attaching
+type DefaultRemoteAttach struct{}
+
+func (*DefaultRemoteAttach) Attach(method string, url *url.URL, config *restclient.Config, stdin io.Reader, stdout, stderr io.Writer, tty bool, terminalSizeQueue term.TerminalSizeQueue) error {
+	exec, err := remotecommand.NewExecutor(config, method, url)
+	if err != nil {
+		return err
+	}
+	return exec.Stream(remotecommand.StreamOptions{
+		SupportedProtocols: remotecommandserver.SupportedStreamingProtocols,
+		Stdin:              stdin,
+		Stdout:             stdout,
+		Stderr:             stderr,
+		Tty:                tty,
+		TerminalSizeQueue:  terminalSizeQueue,
+	})
+}
+
+// AttachOptions declare the arguments accepted by the Exec command
+type AttachOptions struct {
+	StreamOptions
+
+	CommandName string
+
+	Pod *api.Pod
+
+	Attach    RemoteAttach
+	PodClient coreclient.PodsGetter
+	Config    *restclient.Config
+}
+
+// Complete verifies command line arguments and loads data from the command environment
+func (p *AttachOptions) Complete(f cmdutil.Factory, cmd *cobra.Command, argsIn []string) error {
+	if len(argsIn) == 0 {
+		return cmdutil.UsageError(cmd, "POD is required for attach")
+	}
+	if len(argsIn) > 1 {
+		return cmdutil.UsageError(cmd, fmt.Sprintf("expected a single argument: POD, saw %d: %s", len(argsIn), argsIn))
+	}
+	p.PodName = argsIn[0]
+
+	namespace, _, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+	p.Namespace = namespace
+
+	config, err := f.ClientConfig()
+	if err != nil {
+		return err
+	}
+	p.Config = config
+
+	clientset, err := f.ClientSet()
+	if err != nil {
+		return err
+	}
+	p.PodClient = clientset.Core()
+
+	if p.CommandName == "" {
+		p.CommandName = cmd.CommandPath()
+	}
+
+	return nil
+}
+
+// Validate checks that the provided attach options are specified.
+func (p *AttachOptions) Validate() error {
+	allErrs := []error{}
+	if len(p.PodName) == 0 {
+		allErrs = append(allErrs, fmt.Errorf("pod name must be specified"))
+	}
+	if p.Out == nil || p.Err == nil {
+		allErrs = append(allErrs, fmt.Errorf("both output and error output must be provided"))
+	}
+	if p.Attach == nil || p.PodClient == nil || p.Config == nil {
+		allErrs = append(allErrs, fmt.Errorf("client, client config, and attach must be provided"))
+	}
+	return utilerrors.NewAggregate(allErrs)
+}
+
+// Run executes a validated remote execution against a pod.
+func (p *AttachOptions) Run() error {
+	if p.Pod == nil {
+		pod, err := p.PodClient.Pods(p.Namespace).Get(p.PodName)
+		if err != nil {
+			return err
+		}
+
+		if pod.Status.Phase == api.PodSucceeded || pod.Status.Phase == api.PodFailed {
+			return fmt.Errorf("cannot attach a container in a completed pod; current phase is %s", pod.Status.Phase)
+		}
+
+		p.Pod = pod
+		// TODO: convert this to a clean "wait" behavior
+	}
+	pod := p.Pod
+
+	// check for TTY
+	containerToAttach, err := p.containerToAttachTo(pod)
+	if err != nil {
+		return fmt.Errorf("cannot attach to the container: %v", err)
+	}
+	if p.TTY && !containerToAttach.TTY {
+		p.TTY = false
+		if p.Err != nil {
+			fmt.Fprintf(p.Err, "Unable to use a TTY - container %s did not allocate one\n", containerToAttach.Name)
+		}
+	} else if !p.TTY && containerToAttach.TTY {
+		// the container was launched with a TTY, so we have to force a TTY here, otherwise you'll get
+		// an error "Unrecognized input header"
+		p.TTY = true
+	}
+
+	// ensure we can recover the terminal while attached
+	t := p.setupTTY()
+
+	// save p.Err so we can print the command prompt message below
+	stderr := p.Err
+
+	var sizeQueue term.TerminalSizeQueue
+	if t.Raw {
+		if size := t.GetSize(); size != nil {
+			// fake resizing +1 and then back to normal so that attach-detach-reattach will result in the
+			// screen being redrawn
+			sizePlusOne := *size
+			sizePlusOne.Width++
+			sizePlusOne.Height++
+
+			// this call spawns a goroutine to monitor/update the terminal size
+			sizeQueue = t.MonitorSize(&sizePlusOne, size)
+		}
+
+		// unset p.Err if it was previously set because both stdout and stderr go over p.Out when tty is
+		// true
+		p.Err = nil
+	}
+
+	fn := func() error {
+
+		if !p.Quiet && stderr != nil {
+			fmt.Fprintln(stderr, "If you don't see a command prompt, try pressing enter.")
+		}
+
+		restClient, err := restclient.RESTClientFor(p.Config)
+		if err != nil {
+			return err
+		}
+		// TODO: consider abstracting into a client invocation or client helper
+		req := restClient.Post().
+			Resource("pods").
+			Name(pod.Name).
+			Namespace(pod.Namespace).
+			SubResource("attach")
+		req.VersionedParams(&api.PodAttachOptions{
+			Container: containerToAttach.Name,
+			Stdin:     p.Stdin,
+			Stdout:    p.Out != nil,
+			Stderr:    p.Err != nil,
+			TTY:       t.Raw,
+		}, api.ParameterCodec)
+
+		return p.Attach.Attach("POST", req.URL(), p.Config, p.In, p.Out, p.Err, t.Raw, sizeQueue)
+	}
+
+	if err := t.Safe(fn); err != nil {
+		return err
+	}
+
+	if p.Stdin && t.Raw && pod.Spec.RestartPolicy == api.RestartPolicyAlways {
+		fmt.Fprintf(p.Out, "Session ended, resume using '%s %s -c %s -i -t' command when the pod is running\n", p.CommandName, pod.Name, containerToAttach.Name)
+	}
+	return nil
+}
+
+// containerToAttach returns a reference to the container to attach to, given
+// by name or the first container if name is empty.
+func (p *AttachOptions) containerToAttachTo(pod *api.Pod) (*api.Container, error) {
+	if len(p.ContainerName) > 0 {
+		for i := range pod.Spec.Containers {
+			if pod.Spec.Containers[i].Name == p.ContainerName {
+				return &pod.Spec.Containers[i], nil
+			}
+		}
+		for i := range pod.Spec.InitContainers {
+			if pod.Spec.InitContainers[i].Name == p.ContainerName {
+				return &pod.Spec.InitContainers[i], nil
+			}
+		}
+		return nil, fmt.Errorf("container not found (%s)", p.ContainerName)
+	}
+
+	glog.V(4).Infof("defaulting container name to %s", pod.Spec.Containers[0].Name)
+	return &pod.Spec.Containers[0], nil
+}
+
+// GetContainerName returns the name of the container to attach to, with a fallback.
+func (p *AttachOptions) GetContainerName(pod *api.Pod) (string, error) {
+	c, err := p.containerToAttachTo(pod)
+	if err != nil {
+		return "", err
+	}
+	return c.Name, nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/attach_test.go

@@ -0,0 +1,317 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
+	"k8s.io/kubernetes/pkg/client/restclient"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+	"k8s.io/kubernetes/pkg/runtime/schema"
+	"k8s.io/kubernetes/pkg/util/term"
+)
+
+type fakeRemoteAttach struct {
+	method string
+	url    *url.URL
+	err    error
+}
+
+func (f *fakeRemoteAttach) Attach(method string, url *url.URL, config *restclient.Config, stdin io.Reader, stdout, stderr io.Writer, tty bool, terminalSizeQueue term.TerminalSizeQueue) error {
+	f.method = method
+	f.url = url
+	return f.err
+}
+
+func TestPodAndContainerAttach(t *testing.T) {
+	tests := []struct {
+		args              []string
+		p                 *AttachOptions
+		name              string
+		expectError       bool
+		expectedPod       string
+		expectedContainer string
+	}{
+		{
+			p:           &AttachOptions{},
+			expectError: true,
+			name:        "empty",
+		},
+		{
+			p:           &AttachOptions{},
+			args:        []string{"foo", "bar"},
+			expectError: true,
+			name:        "too many args",
+		},
+		{
+			p:           &AttachOptions{},
+			args:        []string{"foo"},
+			expectedPod: "foo",
+			name:        "no container, no flags",
+		},
+		{
+			p:                 &AttachOptions{StreamOptions: StreamOptions{ContainerName: "bar"}},
+			args:              []string{"foo"},
+			expectedPod:       "foo",
+			expectedContainer: "bar",
+			name:              "container in flag",
+		},
+		{
+			p:                 &AttachOptions{StreamOptions: StreamOptions{ContainerName: "initfoo"}},
+			args:              []string{"foo"},
+			expectedPod:       "foo",
+			expectedContainer: "initfoo",
+			name:              "init container in flag",
+		},
+		{
+			p:           &AttachOptions{StreamOptions: StreamOptions{ContainerName: "bar"}},
+			args:        []string{"foo", "-c", "wrong"},
+			expectError: true,
+			name:        "non-existing container in flag",
+		},
+	}
+
+	for _, test := range tests {
+		f, tf, _, ns := cmdtesting.NewAPIFactory()
+		tf.Client = &fake.RESTClient{
+			NegotiatedSerializer: ns,
+			Client:               fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { return nil, nil }),
+		}
+		tf.Namespace = "test"
+		tf.ClientConfig = defaultClientConfig()
+
+		cmd := &cobra.Command{}
+		options := test.p
+		err := options.Complete(f, cmd, test.args)
+		if test.expectError && err == nil {
+			t.Errorf("unexpected non-error (%s)", test.name)
+		}
+		if !test.expectError && err != nil {
+			t.Errorf("unexpected error: %v (%s)", err, test.name)
+		}
+		if err != nil {
+			continue
+		}
+		if options.PodName != test.expectedPod {
+			t.Errorf("expected: %s, got: %s (%s)", test.expectedPod, options.PodName, test.name)
+		}
+		if options.ContainerName != test.expectedContainer {
+			t.Errorf("expected: %s, got: %s (%s)", test.expectedContainer, options.ContainerName, test.name)
+		}
+	}
+}
+
+func TestAttach(t *testing.T) {
+	version := registered.GroupOrDie(api.GroupName).GroupVersion.Version
+	tests := []struct {
+		name, version, podPath, attachPath, container string
+		pod                                           *api.Pod
+		remoteAttachErr                               bool
+		exepctedErr                                   string
+	}{
+		{
+			name:       "pod attach",
+			version:    version,
+			podPath:    "/api/" + version + "/namespaces/test/pods/foo",
+			attachPath: "/api/" + version + "/namespaces/test/pods/foo/attach",
+			pod:        attachPod(),
+			container:  "bar",
+		},
+		{
+			name:            "pod attach error",
+			version:         version,
+			podPath:         "/api/" + version + "/namespaces/test/pods/foo",
+			attachPath:      "/api/" + version + "/namespaces/test/pods/foo/attach",
+			pod:             attachPod(),
+			remoteAttachErr: true,
+			container:       "bar",
+			exepctedErr:     "attach error",
+		},
+		{
+			name:        "container not found error",
+			version:     version,
+			podPath:     "/api/" + version + "/namespaces/test/pods/foo",
+			attachPath:  "/api/" + version + "/namespaces/test/pods/foo/attach",
+			pod:         attachPod(),
+			container:   "foo",
+			exepctedErr: "cannot attach to the container: container not found (foo)",
+		},
+	}
+	for _, test := range tests {
+		f, tf, codec, ns := cmdtesting.NewAPIFactory()
+		tf.Client = &fake.RESTClient{
+			NegotiatedSerializer: ns,
+			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+				switch p, m := req.URL.Path, req.Method; {
+				case p == test.podPath && m == "GET":
+					body := objBody(codec, test.pod)
+					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
+				default:
+					// Ensures no GET is performed when deleting by name
+					t.Errorf("%s: unexpected request: %s %#v\n%#v", test.name, req.Method, req.URL, req)
+					return nil, fmt.Errorf("unexpected request")
+				}
+			}),
+		}
+		tf.Namespace = "test"
+		tf.ClientConfig = &restclient.Config{APIPath: "/api", ContentConfig: restclient.ContentConfig{NegotiatedSerializer: api.Codecs, GroupVersion: &schema.GroupVersion{Version: test.version}}}
+		bufOut := bytes.NewBuffer([]byte{})
+		bufErr := bytes.NewBuffer([]byte{})
+		bufIn := bytes.NewBuffer([]byte{})
+		remoteAttach := &fakeRemoteAttach{}
+		if test.remoteAttachErr {
+			remoteAttach.err = fmt.Errorf("attach error")
+		}
+		params := &AttachOptions{
+			StreamOptions: StreamOptions{
+				ContainerName: test.container,
+				In:            bufIn,
+				Out:           bufOut,
+				Err:           bufErr,
+			},
+			Attach: remoteAttach,
+		}
+		cmd := &cobra.Command{}
+		if err := params.Complete(f, cmd, []string{"foo"}); err != nil {
+			t.Fatal(err)
+		}
+		err := params.Run()
+		if test.exepctedErr != "" && err.Error() != test.exepctedErr {
+			t.Errorf("%s: Unexpected exec error: %v", test.name, err)
+			continue
+		}
+		if test.exepctedErr == "" && err != nil {
+			t.Errorf("%s: Unexpected error: %v", test.name, err)
+			continue
+		}
+		if test.exepctedErr != "" {
+			continue
+		}
+		if remoteAttach.url.Path != test.attachPath {
+			t.Errorf("%s: Did not get expected path for exec request: %q %q", test.name, test.attachPath, remoteAttach.url.Path)
+			continue
+		}
+		if remoteAttach.method != "POST" {
+			t.Errorf("%s: Did not get method for attach request: %s", test.name, remoteAttach.method)
+		}
+		if remoteAttach.url.Query().Get("container") != "bar" {
+			t.Errorf("%s: Did not have query parameters: %s", test.name, remoteAttach.url.Query())
+		}
+	}
+}
+
+func TestAttachWarnings(t *testing.T) {
+	version := registered.GroupOrDie(api.GroupName).GroupVersion.Version
+	tests := []struct {
+		name, container, version, podPath, expectedErr, expectedOut string
+		pod                                                         *api.Pod
+		stdin, tty                                                  bool
+	}{
+		{
+			name:        "fallback tty if not supported",
+			version:     version,
+			podPath:     "/api/" + version + "/namespaces/test/pods/foo",
+			pod:         attachPod(),
+			stdin:       true,
+			tty:         true,
+			expectedErr: "Unable to use a TTY - container bar did not allocate one",
+		},
+	}
+	for _, test := range tests {
+		f, tf, codec, ns := cmdtesting.NewAPIFactory()
+		tf.Client = &fake.RESTClient{
+			NegotiatedSerializer: ns,
+			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+				switch p, m := req.URL.Path, req.Method; {
+				case p == test.podPath && m == "GET":
+					body := objBody(codec, test.pod)
+					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
+				default:
+					t.Errorf("%s: unexpected request: %s %#v\n%#v", test.name, req.Method, req.URL, req)
+					return nil, fmt.Errorf("unexpected request")
+				}
+			}),
+		}
+		tf.Namespace = "test"
+		tf.ClientConfig = &restclient.Config{APIPath: "/api", ContentConfig: restclient.ContentConfig{NegotiatedSerializer: api.Codecs, GroupVersion: &schema.GroupVersion{Version: test.version}}}
+		bufOut := bytes.NewBuffer([]byte{})
+		bufErr := bytes.NewBuffer([]byte{})
+		bufIn := bytes.NewBuffer([]byte{})
+		ex := &fakeRemoteAttach{}
+		params := &AttachOptions{
+			StreamOptions: StreamOptions{
+				ContainerName: test.container,
+				In:            bufIn,
+				Out:           bufOut,
+				Err:           bufErr,
+				Stdin:         test.stdin,
+				TTY:           test.tty,
+			},
+			Attach: ex,
+		}
+		cmd := &cobra.Command{}
+		if err := params.Complete(f, cmd, []string{"foo"}); err != nil {
+			t.Fatal(err)
+		}
+		if err := params.Run(); err != nil {
+			t.Fatal(err)
+		}
+
+		if test.stdin && test.tty {
+			if !test.pod.Spec.Containers[0].TTY {
+				if !strings.Contains(bufErr.String(), test.expectedErr) {
+					t.Errorf("%s: Expected TTY fallback warning for attach request: %s", test.name, bufErr.String())
+					continue
+				}
+			}
+		}
+	}
+}
+
+func attachPod() *api.Pod {
+	return &api.Pod{
+		ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "test", ResourceVersion: "10"},
+		Spec: api.PodSpec{
+			RestartPolicy: api.RestartPolicyAlways,
+			DNSPolicy:     api.DNSClusterFirst,
+			Containers: []api.Container{
+				{
+					Name: "bar",
+				},
+			},
+			InitContainers: []api.Container{
+				{
+					Name: "initfoo",
+				},
+			},
+		},
+		Status: api.PodStatus{
+			Phase: api.PodRunning,
+		},
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/autoscale.go

@@ -0,0 +1,203 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	utilerrors "k8s.io/kubernetes/pkg/util/errors"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	autoscaleLong = templates.LongDesc(`
+		Creates an autoscaler that automatically chooses and sets the number of pods that run in a kubernetes cluster.
+
+		Looks up a Deployment, ReplicaSet, or ReplicationController by name and creates an autoscaler that uses the given resource as a reference.
+		An autoscaler can automatically increase or decrease number of pods deployed within the system as needed.`)
+
+	autoscaleExample = templates.Examples(`
+		# Auto scale a deployment "foo", with the number of pods between 2 and 10, target CPU utilization specified so a default autoscaling policy will be used:
+		kubectl autoscale deployment foo --min=2 --max=10
+
+		# Auto scale a replication controller "foo", with the number of pods between 1 and 5, target CPU utilization at 80%:
+		kubectl autoscale rc foo --max=5 --cpu-percent=80`)
+)
+
+func NewCmdAutoscale(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &resource.FilenameOptions{}
+
+	validArgs := []string{"deployment", "replicaset", "replicationcontroller"}
+	argAliases := kubectl.ResourceAliases(validArgs)
+
+	cmd := &cobra.Command{
+		Use:     "autoscale (-f FILENAME | TYPE NAME | TYPE/NAME) [--min=MINPODS] --max=MAXPODS [--cpu-percent=CPU] [flags]",
+		Short:   "Auto-scale a Deployment, ReplicaSet, or ReplicationController",
+		Long:    autoscaleLong,
+		Example: autoscaleExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunAutoscale(f, out, cmd, args, options)
+			cmdutil.CheckErr(err)
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+	cmdutil.AddPrinterFlags(cmd)
+	cmd.Flags().String("generator", "horizontalpodautoscaler/v1", "The name of the API generator to use. Currently there is only 1 generator.")
+	cmd.Flags().Int("min", -1, "The lower limit for the number of pods that can be set by the autoscaler. If it's not specified or negative, the server will apply a default value.")
+	cmd.Flags().Int("max", -1, "The upper limit for the number of pods that can be set by the autoscaler. Required.")
+	cmd.MarkFlagRequired("max")
+	cmd.Flags().Int("cpu-percent", -1, fmt.Sprintf("The target average CPU utilization (represented as a percent of requested CPU) over all the pods. If it's not specified or negative, a default autoscaling policy will be used."))
+	cmd.Flags().String("name", "", "The name for the newly created object. If not specified, the name of the input resource will be used.")
+	cmdutil.AddDryRunFlag(cmd)
+	usage := "identifying the resource to autoscale."
+	cmdutil.AddFilenameOptionFlags(cmd, options, usage)
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddRecordFlag(cmd)
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+	return cmd
+}
+
+func RunAutoscale(f cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string, options *resource.FilenameOptions) error {
+	namespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	// validate flags
+	if err := validateFlags(cmd); err != nil {
+		return err
+	}
+
+	mapper, typer := f.Object()
+	r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
+		ContinueOnError().
+		NamespaceParam(namespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, options).
+		ResourceTypeOrNameArgs(false, args...).
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	// Get the generator, setup and validate all required parameters
+	generatorName := cmdutil.GetFlagString(cmd, "generator")
+	generators := f.Generators("autoscale")
+	generator, found := generators[generatorName]
+	if !found {
+		return cmdutil.UsageError(cmd, fmt.Sprintf("generator %q not found.", generatorName))
+	}
+	names := generator.ParamNames()
+
+	count := 0
+	err = r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+
+		mapping := info.ResourceMapping()
+		if err := f.CanBeAutoscaled(mapping.GroupVersionKind.GroupKind()); err != nil {
+			return err
+		}
+
+		name := info.Name
+		params := kubectl.MakeParams(cmd, names)
+		params["default-name"] = name
+
+		params["scaleRef-kind"] = mapping.GroupVersionKind.Kind
+		params["scaleRef-name"] = name
+		params["scaleRef-apiVersion"] = mapping.GroupVersionKind.GroupVersion().String()
+
+		if err = kubectl.ValidateParams(names, params); err != nil {
+			return err
+		}
+		// Check for invalid flags used against the present generator.
+		if err := kubectl.EnsureFlagsValid(cmd, generators, generatorName); err != nil {
+			return err
+		}
+
+		// Generate new object
+		object, err := generator.Generate(params)
+		if err != nil {
+			return err
+		}
+
+		resourceMapper := &resource.Mapper{
+			ObjectTyper:  typer,
+			RESTMapper:   mapper,
+			ClientMapper: resource.ClientMapperFunc(f.ClientForMapping),
+			Decoder:      f.Decoder(true),
+		}
+		hpa, err := resourceMapper.InfoForObject(object, nil)
+		if err != nil {
+			return err
+		}
+		if cmdutil.ShouldRecord(cmd, hpa) {
+			if err := cmdutil.RecordChangeCause(hpa.Object, f.Command()); err != nil {
+				return err
+			}
+			object = hpa.Object
+		}
+		if cmdutil.GetDryRunFlag(cmd) {
+			return f.PrintObject(cmd, mapper, object, out)
+		}
+
+		if err := kubectl.CreateOrUpdateAnnotation(cmdutil.GetFlagBool(cmd, cmdutil.ApplyAnnotationsFlag), hpa, f.JSONEncoder()); err != nil {
+			return err
+		}
+
+		object, err = resource.NewHelper(hpa.Client, hpa.Mapping).Create(namespace, false, object)
+		if err != nil {
+			return err
+		}
+
+		count++
+		if len(cmdutil.GetFlagString(cmd, "output")) > 0 {
+			return f.PrintObject(cmd, mapper, object, out)
+		}
+
+		cmdutil.PrintSuccess(mapper, false, out, info.Mapping.Resource, info.Name, cmdutil.GetDryRunFlag(cmd), "autoscaled")
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	if count == 0 {
+		return fmt.Errorf("no objects passed to autoscale")
+	}
+	return nil
+}
+
+func validateFlags(cmd *cobra.Command) error {
+	errs := []error{}
+	max, min := cmdutil.GetFlagInt(cmd, "max"), cmdutil.GetFlagInt(cmd, "min")
+	if max < 1 {
+		errs = append(errs, fmt.Errorf("--max=MAXPODS is required and must be at least 1, max: %d", max))
+	}
+	if max < min {
+		errs = append(errs, fmt.Errorf("--max=MAXPODS must be larger or equal to --min=MINPODS, max: %d, min: %d", max, min))
+	}
+	return utilerrors.NewAggregate(errs)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/certificates.go

@@ -0,0 +1,196 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"k8s.io/kubernetes/pkg/apis/certificates"
+	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+
+	"github.com/spf13/cobra"
+)
+
+func NewCmdCertificate(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "certificate SUBCOMMAND",
+		Short: "Modify certificate resources.",
+		Run: func(cmd *cobra.Command, args []string) {
+			cmd.Help()
+		},
+	}
+
+	cmd.AddCommand(NewCmdCertificateApprove(f, out))
+	cmd.AddCommand(NewCmdCertificateDeny(f, out))
+
+	return cmd
+}
+
+type CertificateOptions struct {
+	resource.FilenameOptions
+	csrNames    []string
+	outputStyle string
+}
+
+func (options *CertificateOptions) Complete(cmd *cobra.Command, args []string) error {
+	options.csrNames = args
+	options.outputStyle = cmdutil.GetFlagString(cmd, "output")
+	return nil
+}
+
+func (options *CertificateOptions) Validate() error {
+	if len(options.csrNames) < 1 && cmdutil.IsFilenameEmpty(options.Filenames) {
+		return fmt.Errorf("one or more CSRs must be specified as <name> or -f <filename>")
+	}
+	return nil
+}
+
+func NewCmdCertificateApprove(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := CertificateOptions{}
+	cmd := &cobra.Command{
+		Use:   "approve (-f FILENAME | NAME)",
+		Short: "Approve a certificate signing request",
+		Long: templates.LongDesc(`
+		Approve a certificate signing request.
+
+		kubectl certificate approve allows a cluster admin to approve a certificate
+		signing request (CSR). This action tells a certificate signing controller to
+		issue a certificate to the requestor with the attributes requested in the CSR.
+
+		SECURITY NOTICE: Depending on the requested attributes, the issued certificate
+		can potentially grant a requester access to cluster resources or to authenticate
+		as a requested identity. Before approving a CSR, ensure you understand what the
+		signed certificate can do.
+		`),
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(options.Complete(cmd, args))
+			cmdutil.CheckErr(options.Validate())
+			cmdutil.CheckErr(options.RunCertificateApprove(f, out))
+		},
+	}
+	cmdutil.AddOutputFlagsForMutation(cmd)
+	cmdutil.AddFilenameOptionFlags(cmd, &options.FilenameOptions, "identifying the resource to update")
+
+	return cmd
+}
+
+func (options *CertificateOptions) RunCertificateApprove(f cmdutil.Factory, out io.Writer) error {
+	return options.modifyCertificateCondition(f, out, func(csr *certificates.CertificateSigningRequest) (*certificates.CertificateSigningRequest, string) {
+		var alreadyApproved bool
+		for _, c := range csr.Status.Conditions {
+			if c.Type == certificates.CertificateApproved {
+				alreadyApproved = true
+			}
+		}
+		if alreadyApproved {
+			return csr, "approved"
+		}
+		csr.Status.Conditions = append(csr.Status.Conditions, certificates.CertificateSigningRequestCondition{
+			Type:           certificates.CertificateApproved,
+			Reason:         "KubectlApprove",
+			Message:        "This CSR was approved by kubectl certificate approve.",
+			LastUpdateTime: metav1.Now(),
+		})
+		return csr, "approved"
+	})
+}
+
+func NewCmdCertificateDeny(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := CertificateOptions{}
+	cmd := &cobra.Command{
+		Use:   "deny (-f FILENAME | NAME)",
+		Short: "Deny a certificate signing request",
+		Long: templates.LongDesc(`
+		Deny a certificate signing request.
+
+		kubectl certificate deny allows a cluster admin to deny a certificate
+		signing request (CSR). This action tells a certificate signing controller to
+		not to issue a certificate to the requestor.
+		`),
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(options.Complete(cmd, args))
+			cmdutil.CheckErr(options.Validate())
+			cmdutil.CheckErr(options.RunCertificateDeny(f, out))
+		},
+	}
+	cmdutil.AddOutputFlagsForMutation(cmd)
+	cmdutil.AddFilenameOptionFlags(cmd, &options.FilenameOptions, "identifying the resource to update")
+
+	return cmd
+}
+
+func (options *CertificateOptions) RunCertificateDeny(f cmdutil.Factory, out io.Writer) error {
+	return options.modifyCertificateCondition(f, out, func(csr *certificates.CertificateSigningRequest) (*certificates.CertificateSigningRequest, string) {
+		var alreadyDenied bool
+		for _, c := range csr.Status.Conditions {
+			if c.Type == certificates.CertificateDenied {
+				alreadyDenied = true
+			}
+		}
+		if alreadyDenied {
+			return csr, "denied"
+		}
+		csr.Status.Conditions = append(csr.Status.Conditions, certificates.CertificateSigningRequestCondition{
+			Type:           certificates.CertificateDenied,
+			Reason:         "KubectlDeny",
+			Message:        "This CSR was approved by kubectl certificate deny.",
+			LastUpdateTime: metav1.Now(),
+		})
+		return csr, "denied"
+	})
+}
+
+func (options *CertificateOptions) modifyCertificateCondition(f cmdutil.Factory, out io.Writer, modify func(csr *certificates.CertificateSigningRequest) (*certificates.CertificateSigningRequest, string)) error {
+	var found int
+	mapper, typer := f.Object()
+	c, err := f.ClientSet()
+	if err != nil {
+		return err
+	}
+	r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
+		ContinueOnError().
+		FilenameParam(false, &options.FilenameOptions).
+		ResourceNames("certificatesigningrequest", options.csrNames...).
+		RequireObject(true).
+		Flatten().
+		Latest().
+		Do()
+	err = r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+		csr := info.Object.(*certificates.CertificateSigningRequest)
+		csr, verb := modify(csr)
+		csr, err = c.Certificates().
+			CertificateSigningRequests().
+			UpdateApproval(csr)
+		if err != nil {
+			return err
+		}
+		found++
+		cmdutil.PrintSuccess(mapper, options.outputStyle == "name", out, info.Mapping.Resource, info.Name, false, verb)
+		return nil
+	})
+	if found == 0 {
+		fmt.Fprintf(out, "No resources found\n")
+	}
+	return err
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/clusterinfo.go

@@ -0,0 +1,125 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+
+	"github.com/daviddengcn/go-colortext"
+	"github.com/spf13/cobra"
+)
+
+var longDescr = templates.LongDesc(`
+  Display addresses of the master and services with label kubernetes.io/cluster-service=true
+  To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.`)
+
+func NewCmdClusterInfo(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use: "cluster-info",
+		// clusterinfo is deprecated.
+		Aliases: []string{"clusterinfo"},
+		Short:   "Display cluster info",
+		Long:    longDescr,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunClusterInfo(f, out, cmd)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+	cmd.AddCommand(NewCmdClusterInfoDump(f, out))
+	return cmd
+}
+
+func RunClusterInfo(f cmdutil.Factory, out io.Writer, cmd *cobra.Command) error {
+	if len(os.Args) > 1 && os.Args[1] == "clusterinfo" {
+		printDeprecationWarning("cluster-info", "clusterinfo")
+	}
+
+	client, err := f.ClientConfig()
+	if err != nil {
+		return err
+	}
+	printService(out, "Kubernetes master", client.Host)
+
+	mapper, typer := f.Object()
+	cmdNamespace := cmdutil.GetFlagString(cmd, "namespace")
+	if cmdNamespace == "" {
+		cmdNamespace = api.NamespaceSystem
+	}
+
+	// TODO use generalized labels once they are implemented (#341)
+	b := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		SelectorParam("kubernetes.io/cluster-service=true").
+		ResourceTypeOrNameArgs(false, []string{"services"}...).
+		Latest()
+	b.Do().Visit(func(r *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+		services := r.Object.(*api.ServiceList).Items
+		for _, service := range services {
+			var link string
+			if len(service.Status.LoadBalancer.Ingress) > 0 {
+				ingress := service.Status.LoadBalancer.Ingress[0]
+				ip := ingress.IP
+				if ip == "" {
+					ip = ingress.Hostname
+				}
+				for _, port := range service.Spec.Ports {
+					link += "http://" + ip + ":" + strconv.Itoa(int(port.Port)) + " "
+				}
+			} else {
+				if len(client.GroupVersion.Group) == 0 {
+					link = client.Host + "/api/" + client.GroupVersion.Version + "/proxy/namespaces/" + service.ObjectMeta.Namespace + "/services/" + service.ObjectMeta.Name
+				} else {
+					link = client.Host + "/api/" + client.GroupVersion.Group + "/" + client.GroupVersion.Version + "/proxy/namespaces/" + service.ObjectMeta.Namespace + "/services/" + service.ObjectMeta.Name
+
+				}
+			}
+			name := service.ObjectMeta.Labels["kubernetes.io/name"]
+			if len(name) == 0 {
+				name = service.ObjectMeta.Name
+			}
+			printService(out, name, link)
+		}
+		return nil
+	})
+	out.Write([]byte("\nTo further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.\n"))
+	return nil
+
+	// TODO consider printing more information about cluster
+}
+
+func printService(out io.Writer, name, link string) {
+	ct.ChangeColor(ct.Green, false, ct.None, false)
+	fmt.Fprint(out, name)
+	ct.ResetColor()
+	fmt.Fprintf(out, " is running at ")
+	ct.ChangeColor(ct.Yellow, false, ct.None, false)
+	fmt.Fprint(out, link)
+	ct.ResetColor()
+	fmt.Fprintln(out, "")
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/clusterinfo_dump.go

@@ -0,0 +1,215 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+// NewCmdCreateSecret groups subcommands to create various types of secrets
+func NewCmdClusterInfoDump(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "dump",
+		Short:   "Dump lots of relevant info for debugging and diagnosis",
+		Long:    dumpLong,
+		Example: dumpExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(dumpClusterInfo(f, cmd, args, cmdOut))
+		},
+	}
+	cmd.Flags().String("output-directory", "", "Where to output the files.  If empty or '-' uses stdout, otherwise creates a directory hierarchy in that directory")
+	cmd.Flags().StringSlice("namespaces", []string{}, "A comma separated list of namespaces to dump.")
+	cmd.Flags().Bool("all-namespaces", false, "If true, dump all namespaces.  If true, --namespaces is ignored.")
+	return cmd
+}
+
+var (
+	dumpLong = templates.LongDesc(`
+    Dumps cluster info out suitable for debugging and diagnosing cluster problems.  By default, dumps everything to
+    stdout. You can optionally specify a directory with --output-directory.  If you specify a directory, kubernetes will
+    build a set of files in that directory.  By default only dumps things in the 'kube-system' namespace, but you can
+    switch to a different namespace with the --namespaces flag, or specify --all-namespaces to dump all namespaces.
+
+    The command also dumps the logs of all of the pods in the cluster, these logs are dumped into different directories
+    based on namespace and pod name.`)
+
+	dumpExample = templates.Examples(`
+    # Dump current cluster state to stdout
+    kubectl cluster-info dump
+
+    # Dump current cluster state to /path/to/cluster-state
+    kubectl cluster-info dump --output-directory=/path/to/cluster-state
+
+    # Dump all namespaces to stdout
+    kubectl cluster-info dump --all-namespaces
+
+    # Dump a set of namespaces to /path/to/cluster-state
+    kubectl cluster-info dump --namespaces default,kube-system --output-directory=/path/to/cluster-state`)
+)
+
+func setupOutputWriter(cmd *cobra.Command, defaultWriter io.Writer, filename string) io.Writer {
+	dir := cmdutil.GetFlagString(cmd, "output-directory")
+	if len(dir) == 0 || dir == "-" {
+		return defaultWriter
+	}
+	fullFile := path.Join(dir, filename)
+	parent := path.Dir(fullFile)
+	cmdutil.CheckErr(os.MkdirAll(parent, 0755))
+
+	file, err := os.Create(path.Join(dir, filename))
+	cmdutil.CheckErr(err)
+	return file
+}
+
+func dumpClusterInfo(f cmdutil.Factory, cmd *cobra.Command, args []string, out io.Writer) error {
+	clientset, err := f.ClientSet()
+	if err != nil {
+		return err
+	}
+
+	printer, _, err := kubectl.GetPrinter("json", "", false)
+	if err != nil {
+		return err
+	}
+
+	nodes, err := clientset.Core().Nodes().List(api.ListOptions{})
+	if err != nil {
+		return err
+	}
+
+	if err := printer.PrintObj(nodes, setupOutputWriter(cmd, out, "nodes.json")); err != nil {
+		return err
+	}
+
+	var namespaces []string
+	if cmdutil.GetFlagBool(cmd, "all-namespaces") {
+		namespaceList, err := clientset.Core().Namespaces().List(api.ListOptions{})
+		if err != nil {
+			return err
+		}
+		for ix := range namespaceList.Items {
+			namespaces = append(namespaces, namespaceList.Items[ix].Name)
+		}
+	} else {
+		namespaces = cmdutil.GetFlagStringSlice(cmd, "namespaces")
+		if len(namespaces) == 0 {
+			cmdNamespace, _, err := f.DefaultNamespace()
+			if err != nil {
+				return err
+			}
+			namespaces = []string{
+				api.NamespaceSystem,
+				cmdNamespace,
+			}
+		}
+	}
+	for _, namespace := range namespaces {
+		// TODO: this is repetitive in the extreme.  Use reflection or
+		// something to make this a for loop.
+		events, err := clientset.Core().Events(namespace).List(api.ListOptions{})
+		if err != nil {
+			return err
+		}
+		if err := printer.PrintObj(events, setupOutputWriter(cmd, out, path.Join(namespace, "events.json"))); err != nil {
+			return err
+		}
+
+		rcs, err := clientset.Core().ReplicationControllers(namespace).List(api.ListOptions{})
+		if err != nil {
+			return err
+		}
+		if err := printer.PrintObj(rcs, setupOutputWriter(cmd, out, path.Join(namespace, "replication-controllers.json"))); err != nil {
+			return err
+		}
+
+		svcs, err := clientset.Core().Services(namespace).List(api.ListOptions{})
+		if err != nil {
+			return err
+		}
+		if err := printer.PrintObj(svcs, setupOutputWriter(cmd, out, path.Join(namespace, "services.json"))); err != nil {
+			return err
+		}
+
+		sets, err := clientset.Extensions().DaemonSets(namespace).List(api.ListOptions{})
+		if err != nil {
+			return err
+		}
+		if err := printer.PrintObj(sets, setupOutputWriter(cmd, out, path.Join(namespace, "daemonsets.json"))); err != nil {
+			return err
+		}
+
+		deps, err := clientset.Extensions().Deployments(namespace).List(api.ListOptions{})
+		if err != nil {
+			return err
+		}
+		if err := printer.PrintObj(deps, setupOutputWriter(cmd, out, path.Join(namespace, "deployments.json"))); err != nil {
+			return err
+		}
+
+		rps, err := clientset.Extensions().ReplicaSets(namespace).List(api.ListOptions{})
+		if err != nil {
+			return err
+		}
+		if err := printer.PrintObj(rps, setupOutputWriter(cmd, out, path.Join(namespace, "replicasets.json"))); err != nil {
+			return err
+		}
+
+		pods, err := clientset.Core().Pods(namespace).List(api.ListOptions{})
+		if err != nil {
+			return err
+		}
+
+		if err := printer.PrintObj(pods, setupOutputWriter(cmd, out, path.Join(namespace, "pods.json"))); err != nil {
+			return err
+		}
+
+		for ix := range pods.Items {
+			pod := &pods.Items[ix]
+			writer := setupOutputWriter(cmd, out, path.Join(namespace, pod.Name, "logs.txt"))
+			writer.Write([]byte(fmt.Sprintf("==== START logs for %s/%s ====\n", pod.Namespace, pod.Name)))
+			request, err := f.LogsForObject(pod, &api.PodLogOptions{})
+			if err != nil {
+				return err
+			}
+
+			data, err := request.DoRaw()
+			if err != nil {
+				return err
+			}
+			writer.Write(data)
+			writer.Write([]byte(fmt.Sprintf("==== END logs for %s/%s ====\n", pod.Namespace, pod.Name)))
+		}
+	}
+	dir := cmdutil.GetFlagString(cmd, "output-directory")
+	if len(dir) == 0 {
+		dir = "."
+	}
+	if dir != "-" {
+		fmt.Fprintf(out, "Cluster info dumped to %s", dir)
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/clusterinfo_dump_test.go

@@ -0,0 +1,70 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"path"
+	"testing"
+
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestSetupOutputWriterNoOp(t *testing.T) {
+	tests := []string{"", "-"}
+	for _, test := range tests {
+		out := &bytes.Buffer{}
+		f, _, _, _ := cmdtesting.NewAPIFactory()
+		cmd := NewCmdClusterInfoDump(f, os.Stdout)
+		cmd.Flag("output-directory").Value.Set(test)
+		writer := setupOutputWriter(cmd, out, "/some/file/that/should/be/ignored")
+		if writer != out {
+			t.Errorf("expected: %v, saw: %v", out, writer)
+		}
+	}
+}
+
+func TestSetupOutputWriterFile(t *testing.T) {
+	file := "output.json"
+	dir, err := ioutil.TempDir(os.TempDir(), "out")
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	fullPath := path.Join(dir, file)
+	defer os.RemoveAll(dir)
+
+	out := &bytes.Buffer{}
+	f, _, _, _ := cmdtesting.NewAPIFactory()
+	cmd := NewCmdClusterInfoDump(f, os.Stdout)
+	cmd.Flag("output-directory").Value.Set(dir)
+	writer := setupOutputWriter(cmd, out, file)
+	if writer == out {
+		t.Errorf("expected: %v, saw: %v", out, writer)
+	}
+	output := "some data here"
+	writer.Write([]byte(output))
+
+	data, err := ioutil.ReadFile(fullPath)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if string(data) != output {
+		t.Errorf("expected: %v, saw: %v", output, data)
+	}
+}

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

@@ -0,0 +1,334 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	cmdconfig "k8s.io/kubernetes/pkg/kubectl/cmd/config"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/rollout"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/set"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/util/flag"
+
+	"github.com/golang/glog"
+	"github.com/spf13/cobra"
+)
+
+const (
+	bash_completion_func = `# call kubectl get $1,
+__kubectl_override_flag_list=(kubeconfig cluster user context namespace server)
+__kubectl_override_flags()
+{
+    local ${__kubectl_override_flag_list[*]} two_word_of of
+    for w in "${words[@]}"; do
+        if [ -n "${two_word_of}" ]; then
+            eval "${two_word_of}=\"--${two_word_of}=\${w}\""
+            two_word_of=
+            continue
+        fi
+        for of in "${__kubectl_override_flag_list[@]}"; do
+            case "${w}" in
+                --${of}=*)
+                    eval "${of}=\"${w}\""
+                    ;;
+                --${of})
+                    two_word_of="${of}"
+                    ;;
+            esac
+        done
+        if [ "${w}" == "--all-namespaces" ]; then
+            namespace="--all-namespaces"
+        fi
+    done
+    for of in "${__kubectl_override_flag_list[@]}"; do
+        if eval "test -n \"\$${of}\""; then
+            eval "echo \${${of}}"
+        fi
+    done
+}
+
+__kubectl_get_namespaces()
+{
+    local template kubectl_out
+    template="{{ range .items  }}{{ .metadata.name }} {{ end }}"
+    if kubectl_out=$(kubectl get -o template --template="${template}" namespace 2>/dev/null); then
+        COMPREPLY=( $( compgen -W "${kubectl_out[*]}" -- "$cur" ) )
+    fi
+}
+
+__kubectl_parse_get()
+{
+    local template
+    template="{{ range .items  }}{{ .metadata.name }} {{ end }}"
+    local kubectl_out
+    if kubectl_out=$(kubectl get $(__kubectl_override_flags) -o template --template="${template}" "$1" 2>/dev/null); then
+        COMPREPLY=( $( compgen -W "${kubectl_out[*]}" -- "$cur" ) )
+    fi
+}
+
+__kubectl_get_resource()
+{
+    if [[ ${#nouns[@]} -eq 0 ]]; then
+        return 1
+    fi
+    __kubectl_parse_get "${nouns[${#nouns[@]} -1]}"
+}
+
+__kubectl_get_resource_pod()
+{
+    __kubectl_parse_get "pod"
+}
+
+__kubectl_get_resource_rc()
+{
+    __kubectl_parse_get "rc"
+}
+
+__kubectl_get_resource_node()
+{
+    __kubectl_parse_get "node"
+}
+
+# $1 is the name of the pod we want to get the list of containers inside
+__kubectl_get_containers()
+{
+    local template
+    template="{{ range .spec.containers  }}{{ .name }} {{ end }}"
+    __debug "${FUNCNAME} nouns are ${nouns[*]}"
+
+    local len="${#nouns[@]}"
+    if [[ ${len} -ne 1 ]]; then
+        return
+    fi
+    local last=${nouns[${len} -1]}
+    local kubectl_out
+    if kubectl_out=$(kubectl get $(__kubectl_override_flags) -o template --template="${template}" pods "${last}" 2>/dev/null); then
+        COMPREPLY=( $( compgen -W "${kubectl_out[*]}" -- "$cur" ) )
+    fi
+}
+
+# Require both a pod and a container to be specified
+__kubectl_require_pod_and_container()
+{
+    if [[ ${#nouns[@]} -eq 0 ]]; then
+        __kubectl_parse_get pods
+        return 0
+    fi;
+    __kubectl_get_containers
+    return 0
+}
+
+__custom_func() {
+    case ${last_command} in
+        kubectl_get | kubectl_describe | kubectl_delete | kubectl_label | kubectl_stop | kubectl_edit | kubectl_patch |\
+        kubectl_annotate | kubectl_expose | kubectl_scale | kubectl_autoscale | kubectl_taint | kubectl_rollout_*)
+            __kubectl_get_resource
+            return
+            ;;
+        kubectl_logs | kubectl_attach)
+            __kubectl_require_pod_and_container
+            return
+            ;;
+        kubectl_exec | kubectl_port-forward | kubectl_top_pod)
+            __kubectl_get_resource_pod
+            return
+            ;;
+        kubectl_rolling-update)
+            __kubectl_get_resource_rc
+            return
+            ;;
+        kubectl_cordon | kubectl_uncordon | kubectl_drain | kubectl_top_node)
+            __kubectl_get_resource_node
+            return
+            ;;
+        *)
+            ;;
+    esac
+}
+`
+
+	// If you add a resource to this list, please also take a look at pkg/kubectl/kubectl.go
+	// and add a short forms entry in expandResourceShortcut() when appropriate.
+	// TODO: This should be populated using the discovery information from apiserver.
+	valid_resources = `Valid resource types include:
+
+    * all
+    * clusters (valid only for federation apiservers)
+    * componentstatuses (aka 'cs')
+    * configmaps (aka 'cm')
+    * daemonsets (aka 'ds')
+    * deployments (aka 'deploy')
+    * endpoints (aka 'ep')
+    * events (aka 'ev')
+    * horizontalpodautoscalers (aka 'hpa')
+    * ingresses (aka 'ing')
+    * jobs
+    * limitranges (aka 'limits')
+    * namespaces (aka 'ns')
+    * networkpolicies
+    * nodes (aka 'no')
+    * persistentvolumeclaims (aka 'pvc')
+    * persistentvolumes (aka 'pv')
+    * pods (aka 'po')
+    * podsecuritypolicies (aka 'psp')
+    * podtemplates
+    * replicasets (aka 'rs')
+    * replicationcontrollers (aka 'rc')
+    * resourcequotas (aka 'quota')
+    * secrets
+    * serviceaccounts (aka 'sa')
+    * services (aka 'svc')
+    * statefulsets
+    * storageclasses
+    * thirdpartyresources
+    `
+)
+
+// NewKubectlCommand creates the `kubectl` command and its nested children.
+func NewKubectlCommand(f cmdutil.Factory, in io.Reader, out, err io.Writer) *cobra.Command {
+	// Parent command to which all subcommands are added.
+	cmds := &cobra.Command{
+		Use:   "kubectl",
+		Short: "kubectl controls the Kubernetes cluster manager",
+		Long: templates.LongDesc(`
+      kubectl controls the Kubernetes cluster manager.
+
+      Find more information at https://github.com/kubernetes/kubernetes.`),
+		Run: runHelp,
+		BashCompletionFunction: bash_completion_func,
+	}
+
+	f.BindFlags(cmds.PersistentFlags())
+	f.BindExternalFlags(cmds.PersistentFlags())
+
+	// From this point and forward we get warnings on flags that contain "_" separators
+	cmds.SetGlobalNormalizationFunc(flag.WarnWordSepNormalizeFunc)
+
+	groups := templates.CommandGroups{
+		{
+			Message: "Basic Commands (Beginner):",
+			Commands: []*cobra.Command{
+				NewCmdCreate(f, out, err),
+				NewCmdExposeService(f, out),
+				NewCmdRun(f, in, out, err),
+				set.NewCmdSet(f, out, err),
+			},
+		},
+		{
+			Message: "Basic Commands (Intermediate):",
+			Commands: []*cobra.Command{
+				NewCmdGet(f, out, err),
+				NewCmdExplain(f, out, err),
+				NewCmdEdit(f, out, err),
+				NewCmdDelete(f, out, err),
+			},
+		},
+		{
+			Message: "Deploy Commands:",
+			Commands: []*cobra.Command{
+				rollout.NewCmdRollout(f, out, err),
+				NewCmdRollingUpdate(f, out),
+				NewCmdScale(f, out),
+				NewCmdAutoscale(f, out),
+			},
+		},
+		{
+			Message: "Cluster Management Commands:",
+			Commands: []*cobra.Command{
+				NewCmdCertificate(f, out),
+				NewCmdClusterInfo(f, out),
+				NewCmdTop(f, out, err),
+				NewCmdCordon(f, out),
+				NewCmdUncordon(f, out),
+				NewCmdDrain(f, out, err),
+				NewCmdTaint(f, out),
+			},
+		},
+		{
+			Message: "Troubleshooting and Debugging Commands:",
+			Commands: []*cobra.Command{
+				NewCmdDescribe(f, out, err),
+				NewCmdLogs(f, out),
+				NewCmdAttach(f, in, out, err),
+				NewCmdExec(f, in, out, err),
+				NewCmdPortForward(f, out, err),
+				NewCmdProxy(f, out),
+				NewCmdCp(f, in, out, err),
+			},
+		},
+		{
+			Message: "Advanced Commands:",
+			Commands: []*cobra.Command{
+				NewCmdApply(f, out),
+				NewCmdPatch(f, out),
+				NewCmdReplace(f, out),
+				NewCmdConvert(f, out),
+			},
+		},
+		{
+			Message: "Settings Commands:",
+			Commands: []*cobra.Command{
+				NewCmdLabel(f, out),
+				NewCmdAnnotate(f, out),
+				NewCmdCompletion(f, out),
+			},
+		},
+	}
+	groups.Add(cmds)
+
+	filters := []string{
+		"options",
+		Deprecated("kubectl", "delete", cmds, NewCmdStop(f, out)),
+	}
+	templates.ActsAsRootCommand(cmds, filters, groups...)
+
+	if cmds.Flag("namespace") != nil {
+		if cmds.Flag("namespace").Annotations == nil {
+			cmds.Flag("namespace").Annotations = map[string][]string{}
+		}
+		cmds.Flag("namespace").Annotations[cobra.BashCompCustom] = append(
+			cmds.Flag("namespace").Annotations[cobra.BashCompCustom],
+			"__kubectl_get_namespaces",
+		)
+	}
+
+	cmds.AddCommand(cmdconfig.NewCmdConfig(clientcmd.NewDefaultPathOptions(), out, err))
+	cmds.AddCommand(NewCmdVersion(f, out))
+	cmds.AddCommand(NewCmdApiVersions(f, out))
+	cmds.AddCommand(NewCmdOptions(out))
+
+	return cmds
+}
+
+func runHelp(cmd *cobra.Command, args []string) {
+	cmd.Help()
+}
+
+func printDeprecationWarning(command, alias string) {
+	glog.Warningf("%s is DEPRECATED and will be removed in a future version. Use %s instead.", alias, command)
+}
+
+func Deprecated(baseName, to string, parent, cmd *cobra.Command) string {
+	cmd.Long = fmt.Sprintf("Deprecated: This command is deprecated, all its functionalities are covered by \"%s %s\"", baseName, to)
+	cmd.Short = fmt.Sprintf("Deprecated: %s", to)
+	parent.AddCommand(cmd)
+	return cmd.Name()
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/completion.go

@@ -0,0 +1,287 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+const boilerPlate = `
+# 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.
+`
+
+var (
+	completion_long = templates.LongDesc(`
+		Output shell completion code for the given shell (bash or zsh).
+
+		This command prints shell code which must be evaluation to provide interactive
+		completion of kubectl commands.
+
+		    $ source <(kubectl completion bash)
+
+		will load the kubectl completion code for bash. Note that this depends on the
+		bash-completion framework. It must be sourced before sourcing the kubectl
+		completion, e.g. on the Mac:
+
+		    $ brew install bash-completion
+		    $ source $(brew --prefix)/etc/bash_completion
+		    $ source <(kubectl completion bash)
+
+		If you use zsh[1], the following will load kubectl zsh completion:
+
+		    $ source <(kubectl completion zsh)
+
+		[1] zsh completions are only supported in versions of zsh >= 5.2`)
+)
+
+var (
+	completion_shells = map[string]func(out io.Writer, cmd *cobra.Command) error{
+		"bash": runCompletionBash,
+		"zsh":  runCompletionZsh,
+	}
+)
+
+func NewCmdCompletion(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	shells := []string{}
+	for s := range completion_shells {
+		shells = append(shells, s)
+	}
+
+	cmd := &cobra.Command{
+		Use:   "completion SHELL",
+		Short: "Output shell completion code for the given shell (bash or zsh)",
+		Long:  completion_long,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunCompletion(f, out, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+		ValidArgs: shells,
+	}
+
+	return cmd
+}
+
+func RunCompletion(f cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string) error {
+	if len(args) == 0 {
+		return cmdutil.UsageError(cmd, "Shell not specified.")
+	}
+	if len(args) > 1 {
+		return cmdutil.UsageError(cmd, "Too many arguments. Expected only the shell type.")
+	}
+	run, found := completion_shells[args[0]]
+	if !found {
+		return cmdutil.UsageError(cmd, "Unsupported shell type %q.", args[0])
+	}
+
+	return run(out, cmd.Parent())
+}
+
+func runCompletionBash(out io.Writer, kubectl *cobra.Command) error {
+	_, err := out.Write([]byte(boilerPlate))
+	if err != nil {
+		return err
+	}
+	return kubectl.GenBashCompletion(out)
+}
+
+func runCompletionZsh(out io.Writer, kubectl *cobra.Command) error {
+	_, err := out.Write([]byte(boilerPlate))
+	if err != nil {
+		return err
+	}
+	zsh_initialization := `
+__kubectl_bash_source() {
+	alias shopt=':'
+	alias _expand=_bash_expand
+	alias _complete=_bash_comp
+	emulate -L sh
+	setopt kshglob noshglob braceexpand
+
+	source "$@"
+}
+
+__kubectl_type() {
+	# -t is not supported by zsh
+	if [ "$1" == "-t" ]; then
+		shift
+
+		# fake Bash 4 to disable "complete -o nospace". Instead
+		# "compopt +-o nospace" is used in the code to toggle trailing
+		# spaces. We don't support that, but leave trailing spaces on
+		# all the time
+		if [ "$1" = "__kubectl_compopt" ]; then
+			echo builtin
+			return 0
+		fi
+	fi
+	type "$@"
+}
+
+__kubectl_compgen() {
+	local completions w
+	completions=( $(compgen "$@") ) || return $?
+
+	# filter by given word as prefix
+	while [[ "$1" = -* && "$1" != -- ]]; do
+		shift
+		shift
+	done
+	if [[ "$1" == -- ]]; then
+		shift
+	fi
+	for w in "${completions[@]}"; do
+		if [[ "${w}" = "$1"* ]]; then
+			echo "${w}"
+		fi
+	done
+}
+
+__kubectl_compopt() {
+	true # don't do anything. Not supported by bashcompinit in zsh
+}
+
+__kubectl_declare() {
+	if [ "$1" == "-F" ]; then
+		whence -w "$@"
+	else
+		builtin declare "$@"
+	fi
+}
+
+__kubectl_ltrim_colon_completions()
+{
+	if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
+		# Remove colon-word prefix from COMPREPLY items
+		local colon_word=${1%${1##*:}}
+		local i=${#COMPREPLY[*]}
+		while [[ $((--i)) -ge 0 ]]; do
+			COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}
+		done
+	fi
+}
+
+__kubectl_get_comp_words_by_ref() {
+	cur="${COMP_WORDS[COMP_CWORD]}"
+	prev="${COMP_WORDS[${COMP_CWORD}-1]}"
+	words=("${COMP_WORDS[@]}")
+	cword=("${COMP_CWORD[@]}")
+}
+
+__kubectl_filedir() {
+	local RET OLD_IFS w qw
+
+	__debug "_filedir $@ cur=$cur"
+	if [[ "$1" = \~* ]]; then
+		# somehow does not work. Maybe, zsh does not call this at all
+		eval echo "$1"
+		return 0
+	fi
+
+	OLD_IFS="$IFS"
+	IFS=$'\n'
+	if [ "$1" = "-d" ]; then
+		shift
+		RET=( $(compgen -d) )
+	else
+		RET=( $(compgen -f) )
+	fi
+	IFS="$OLD_IFS"
+
+	IFS="," __debug "RET=${RET[@]} len=${#RET[@]}"
+
+	for w in ${RET[@]}; do
+		if [[ ! "${w}" = "${cur}"* ]]; then
+			continue
+		fi
+		if eval "[[ \"\${w}\" = *.$1 || -d \"\${w}\" ]]"; then
+			qw="$(__kubectl_quote "${w}")"
+			if [ -d "${w}" ]; then
+				COMPREPLY+=("${qw}/")
+			else
+				COMPREPLY+=("${qw}")
+			fi
+		fi
+	done
+}
+
+__kubectl_quote() {
+    if [[ $1 == \'* || $1 == \"* ]]; then
+        # Leave out first character
+        printf %q "${1:1}"
+    else
+    	printf %q "$1"
+    fi
+}
+
+autoload -U +X bashcompinit && bashcompinit
+
+# use word boundary patterns for BSD or GNU sed
+LWORD='[[:<:]]'
+RWORD='[[:>:]]'
+if sed --help 2>&1 | grep -q GNU; then
+	LWORD='\<'
+	RWORD='\>'
+fi
+
+__kubectl_convert_bash_to_zsh() {
+	sed \
+	-e 's/declare -F/whence -w/' \
+	-e 's/local \([a-zA-Z0-9_]*\)=/local \1; \1=/' \
+	-e 's/flags+=("\(--.*\)=")/flags+=("\1"); two_word_flags+=("\1")/' \
+	-e 's/must_have_one_flag+=("\(--.*\)=")/must_have_one_flag+=("\1")/' \
+	-e "s/${LWORD}_filedir${RWORD}/__kubectl_filedir/g" \
+	-e "s/${LWORD}_get_comp_words_by_ref${RWORD}/__kubectl_get_comp_words_by_ref/g" \
+	-e "s/${LWORD}__ltrim_colon_completions${RWORD}/__kubectl_ltrim_colon_completions/g" \
+	-e "s/${LWORD}compgen${RWORD}/__kubectl_compgen/g" \
+	-e "s/${LWORD}compopt${RWORD}/__kubectl_compopt/g" \
+	-e "s/${LWORD}declare${RWORD}/__kubectl_declare/g" \
+	-e "s/\\\$(type${RWORD}/\$(__kubectl_type/g" \
+	<<'BASH_COMPLETION_EOF'
+`
+	out.Write([]byte(zsh_initialization))
+
+	buf := new(bytes.Buffer)
+	kubectl.GenBashCompletion(buf)
+	out.Write(buf.Bytes())
+
+	zsh_tail := `
+BASH_COMPLETION_EOF
+}
+
+__kubectl_bash_source <(__kubectl_convert_bash_to_zsh)
+`
+	out.Write([]byte(zsh_tail))
+	return nil
+}

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

@@ -0,0 +1,68 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "config.go",
+        "create_authinfo.go",
+        "create_cluster.go",
+        "create_context.go",
+        "current_context.go",
+        "delete_cluster.go",
+        "delete_context.go",
+        "get_clusters.go",
+        "get_contexts.go",
+        "navigation_step_parser.go",
+        "set.go",
+        "unset.go",
+        "use_context.go",
+        "view.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/client/unversioned/clientcmd:go_default_library",
+        "//pkg/client/unversioned/clientcmd/api:go_default_library",
+        "//pkg/client/unversioned/clientcmd/api/latest:go_default_library",
+        "//pkg/kubectl:go_default_library",
+        "//pkg/kubectl/cmd/templates:go_default_library",
+        "//pkg/kubectl/cmd/util:go_default_library",
+        "//pkg/util/errors:go_default_library",
+        "//pkg/util/flag:go_default_library",
+        "//pkg/util/sets:go_default_library",
+        "//vendor:github.com/spf13/cobra",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "config_test.go",
+        "create_authinfo_test.go",
+        "current_context_test.go",
+        "delete_cluster_test.go",
+        "delete_context_test.go",
+        "get_clusters_test.go",
+        "get_contexts_test.go",
+        "navigation_step_parser_test.go",
+    ],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/client/unversioned/clientcmd:go_default_library",
+        "//pkg/client/unversioned/clientcmd/api:go_default_library",
+        "//pkg/kubectl/cmd/util:go_default_library",
+        "//pkg/util/diff:go_default_library",
+        "//pkg/util/flag:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/config.go

@@ -0,0 +1,81 @@
+/*
+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 config
+
+import (
+	"io"
+	"path"
+	"strconv"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+// NewCmdConfig creates a command object for the "config" action, and adds all child commands to it.
+func NewCmdConfig(pathOptions *clientcmd.PathOptions, out, errOut io.Writer) *cobra.Command {
+	if len(pathOptions.ExplicitFileFlag) == 0 {
+		pathOptions.ExplicitFileFlag = clientcmd.RecommendedConfigPathFlag
+	}
+
+	cmd := &cobra.Command{
+		Use:   "config SUBCOMMAND",
+		Short: "Modify kubeconfig files",
+		Long: templates.LongDesc(`
+			Modify kubeconfig files using subcommands like "kubectl config set current-context my-context"
+
+			The loading order follows these rules:
+
+			1. If the --` + pathOptions.ExplicitFileFlag + ` flag is set, then only that file is loaded.  The flag may only be set once and no merging takes place.
+			2. If $` + pathOptions.EnvVar + ` environment variable is set, then it is used a list of paths (normal path delimitting rules for your system).  These paths are merged.  When a value is modified, it is modified in the file that defines the stanza.  When a value is created, it is created in the first file that exists.  If no files in the chain exist, then it creates the last file in the list.
+			3. Otherwise, ` + path.Join("${HOME}", pathOptions.GlobalFileSubpath) + ` is used and no merging takes place.`),
+		Run: cmdutil.DefaultSubCommandRun(errOut),
+	}
+
+	// file paths are common to all sub commands
+	cmd.PersistentFlags().StringVar(&pathOptions.LoadingRules.ExplicitPath, pathOptions.ExplicitFileFlag, pathOptions.LoadingRules.ExplicitPath, "use a particular kubeconfig file")
+
+	cmd.AddCommand(NewCmdConfigView(out, pathOptions))
+	cmd.AddCommand(NewCmdConfigSetCluster(out, pathOptions))
+	cmd.AddCommand(NewCmdConfigSetAuthInfo(out, pathOptions))
+	cmd.AddCommand(NewCmdConfigSetContext(out, pathOptions))
+	cmd.AddCommand(NewCmdConfigSet(out, pathOptions))
+	cmd.AddCommand(NewCmdConfigUnset(out, pathOptions))
+	cmd.AddCommand(NewCmdConfigCurrentContext(out, pathOptions))
+	cmd.AddCommand(NewCmdConfigUseContext(out, pathOptions))
+	cmd.AddCommand(NewCmdConfigGetContexts(out, pathOptions))
+	cmd.AddCommand(NewCmdConfigGetClusters(out, pathOptions))
+	cmd.AddCommand(NewCmdConfigDeleteCluster(out, pathOptions))
+	cmd.AddCommand(NewCmdConfigDeleteContext(out, pathOptions))
+
+	return cmd
+}
+
+func toBool(propertyValue string) (bool, error) {
+	boolValue := false
+	if len(propertyValue) != 0 {
+		var err error
+		boolValue, err = strconv.ParseBool(propertyValue)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	return boolValue, nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/create_authinfo.go

@@ -0,0 +1,299 @@
+/*
+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 config
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/util/flag"
+)
+
+type createAuthInfoOptions struct {
+	configAccess      clientcmd.ConfigAccess
+	name              string
+	authPath          flag.StringFlag
+	clientCertificate flag.StringFlag
+	clientKey         flag.StringFlag
+	token             flag.StringFlag
+	username          flag.StringFlag
+	password          flag.StringFlag
+	embedCertData     flag.Tristate
+	authProvider      flag.StringFlag
+
+	authProviderArgs         map[string]string
+	authProviderArgsToRemove []string
+}
+
+const (
+	flagAuthProvider    = "auth-provider"
+	flagAuthProviderArg = "auth-provider-arg"
+)
+
+var (
+	create_authinfo_long = fmt.Sprintf(templates.LongDesc(`
+		Sets a user entry in kubeconfig
+
+		Specifying a name that already exists will merge new fields on top of existing values.
+
+		    Client-certificate flags:
+		    --%v=certfile --%v=keyfile
+
+		    Bearer token flags:
+			  --%v=bearer_token
+
+		    Basic auth flags:
+			  --%v=basic_user --%v=basic_password
+
+		Bearer token and basic auth are mutually exclusive.`), clientcmd.FlagCertFile, clientcmd.FlagKeyFile, clientcmd.FlagBearerToken, clientcmd.FlagUsername, clientcmd.FlagPassword)
+
+	create_authinfo_example = templates.Examples(`
+		# Set only the "client-key" field on the "cluster-admin"
+		# entry, without touching other values:
+		kubectl config set-credentials cluster-admin --client-key=~/.kube/admin.key
+
+		# Set basic auth for the "cluster-admin" entry
+		kubectl config set-credentials cluster-admin --username=admin --password=uXFGweU9l35qcif
+
+		# Embed client certificate data in the "cluster-admin" entry
+		kubectl config set-credentials cluster-admin --client-certificate=~/.kube/admin.crt --embed-certs=true
+
+		# Enable the Google Compute Platform auth provider for the "cluster-admin" entry
+		kubectl config set-credentials cluster-admin --auth-provider=gcp
+
+		# Enable the OpenID Connect auth provider for the "cluster-admin" entry with additional args
+		kubectl config set-credentials cluster-admin --auth-provider=oidc --auth-provider-arg=client-id=foo --auth-provider-arg=client-secret=bar
+
+		# Remove the "client-secret" config value for the OpenID Connect auth provider for the "cluster-admin" entry
+		kubectl config set-credentials cluster-admin --auth-provider=oidc --auth-provider-arg=client-secret-`)
+)
+
+func NewCmdConfigSetAuthInfo(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command {
+	options := &createAuthInfoOptions{configAccess: configAccess}
+	return newCmdConfigSetAuthInfo(out, options)
+}
+
+func newCmdConfigSetAuthInfo(out io.Writer, options *createAuthInfoOptions) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     fmt.Sprintf("set-credentials NAME [--%v=path/to/certfile] [--%v=path/to/keyfile] [--%v=bearer_token] [--%v=basic_user] [--%v=basic_password] [--%v=provider_name] [--%v=key=value]", clientcmd.FlagCertFile, clientcmd.FlagKeyFile, clientcmd.FlagBearerToken, clientcmd.FlagUsername, clientcmd.FlagPassword, flagAuthProvider, flagAuthProviderArg),
+		Short:   "Sets a user entry in kubeconfig",
+		Long:    create_authinfo_long,
+		Example: create_authinfo_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			if !options.complete(cmd, out) {
+				cmd.Help()
+				return
+			}
+
+			cmdutil.CheckErr(options.run())
+			fmt.Fprintf(out, "User %q set.\n", options.name)
+		},
+	}
+
+	cmd.Flags().Var(&options.clientCertificate, clientcmd.FlagCertFile, "path to "+clientcmd.FlagCertFile+" file for the user entry in kubeconfig")
+	cmd.MarkFlagFilename(clientcmd.FlagCertFile)
+	cmd.Flags().Var(&options.clientKey, clientcmd.FlagKeyFile, "path to "+clientcmd.FlagKeyFile+" file for the user entry in kubeconfig")
+	cmd.MarkFlagFilename(clientcmd.FlagKeyFile)
+	cmd.Flags().Var(&options.token, clientcmd.FlagBearerToken, clientcmd.FlagBearerToken+" for the user entry in kubeconfig")
+	cmd.Flags().Var(&options.username, clientcmd.FlagUsername, clientcmd.FlagUsername+" for the user entry in kubeconfig")
+	cmd.Flags().Var(&options.password, clientcmd.FlagPassword, clientcmd.FlagPassword+" for the user entry in kubeconfig")
+	cmd.Flags().Var(&options.authProvider, flagAuthProvider, "auth provider for the user entry in kubeconfig")
+	cmd.Flags().StringSlice(flagAuthProviderArg, nil, "'key=value' arugments for the auth provider")
+	f := cmd.Flags().VarPF(&options.embedCertData, clientcmd.FlagEmbedCerts, "", "embed client cert/key for the user entry in kubeconfig")
+	f.NoOptDefVal = "true"
+
+	return cmd
+}
+
+func (o createAuthInfoOptions) run() error {
+	err := o.validate()
+	if err != nil {
+		return err
+	}
+
+	config, err := o.configAccess.GetStartingConfig()
+	if err != nil {
+		return err
+	}
+
+	startingStanza, exists := config.AuthInfos[o.name]
+	if !exists {
+		startingStanza = clientcmdapi.NewAuthInfo()
+	}
+	authInfo := o.modifyAuthInfo(*startingStanza)
+	config.AuthInfos[o.name] = &authInfo
+
+	if err := clientcmd.ModifyConfig(o.configAccess, *config, true); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// authInfo builds an AuthInfo object from the options
+func (o *createAuthInfoOptions) modifyAuthInfo(existingAuthInfo clientcmdapi.AuthInfo) clientcmdapi.AuthInfo {
+	modifiedAuthInfo := existingAuthInfo
+
+	var setToken, setBasic bool
+
+	if o.clientCertificate.Provided() {
+		certPath := o.clientCertificate.Value()
+		if o.embedCertData.Value() {
+			modifiedAuthInfo.ClientCertificateData, _ = ioutil.ReadFile(certPath)
+			modifiedAuthInfo.ClientCertificate = ""
+		} else {
+			certPath, _ = filepath.Abs(certPath)
+			modifiedAuthInfo.ClientCertificate = certPath
+			if len(modifiedAuthInfo.ClientCertificate) > 0 {
+				modifiedAuthInfo.ClientCertificateData = nil
+			}
+		}
+	}
+	if o.clientKey.Provided() {
+		keyPath := o.clientKey.Value()
+		if o.embedCertData.Value() {
+			modifiedAuthInfo.ClientKeyData, _ = ioutil.ReadFile(keyPath)
+			modifiedAuthInfo.ClientKey = ""
+		} else {
+			keyPath, _ = filepath.Abs(keyPath)
+			modifiedAuthInfo.ClientKey = keyPath
+			if len(modifiedAuthInfo.ClientKey) > 0 {
+				modifiedAuthInfo.ClientKeyData = nil
+			}
+		}
+	}
+
+	if o.token.Provided() {
+		modifiedAuthInfo.Token = o.token.Value()
+		setToken = len(modifiedAuthInfo.Token) > 0
+	}
+
+	if o.username.Provided() {
+		modifiedAuthInfo.Username = o.username.Value()
+		setBasic = setBasic || len(modifiedAuthInfo.Username) > 0
+	}
+	if o.password.Provided() {
+		modifiedAuthInfo.Password = o.password.Value()
+		setBasic = setBasic || len(modifiedAuthInfo.Password) > 0
+	}
+	if o.authProvider.Provided() {
+		newName := o.authProvider.Value()
+
+		// Only overwrite if the existing auth-provider is nil, or different than the newly specified one.
+		if modifiedAuthInfo.AuthProvider == nil || modifiedAuthInfo.AuthProvider.Name != newName {
+			modifiedAuthInfo.AuthProvider = &clientcmdapi.AuthProviderConfig{
+				Name: newName,
+			}
+		}
+	}
+
+	if modifiedAuthInfo.AuthProvider != nil {
+		if modifiedAuthInfo.AuthProvider.Config == nil {
+			modifiedAuthInfo.AuthProvider.Config = make(map[string]string)
+		}
+		for _, toRemove := range o.authProviderArgsToRemove {
+			delete(modifiedAuthInfo.AuthProvider.Config, toRemove)
+		}
+		for key, value := range o.authProviderArgs {
+			modifiedAuthInfo.AuthProvider.Config[key] = value
+		}
+	}
+
+	// If any auth info was set, make sure any other existing auth types are cleared
+	if setToken || setBasic {
+		if !setToken {
+			modifiedAuthInfo.Token = ""
+		}
+		if !setBasic {
+			modifiedAuthInfo.Username = ""
+			modifiedAuthInfo.Password = ""
+		}
+	}
+
+	return modifiedAuthInfo
+}
+
+func (o *createAuthInfoOptions) complete(cmd *cobra.Command, out io.Writer) bool {
+	args := cmd.Flags().Args()
+	if len(args) != 1 {
+		return false
+	}
+
+	authProviderArgs, err := cmd.Flags().GetStringSlice(flagAuthProviderArg)
+	if err != nil {
+		fmt.Fprintf(out, "Error: %s\n", err)
+		return false
+	}
+
+	if len(authProviderArgs) > 0 {
+		newPairs, removePairs, err := cmdutil.ParsePairs(authProviderArgs, flagAuthProviderArg, true)
+		if err != nil {
+			fmt.Fprintf(out, "Error: %s\n", err)
+			return false
+		}
+		o.authProviderArgs = newPairs
+		o.authProviderArgsToRemove = removePairs
+	}
+
+	o.name = args[0]
+	return true
+}
+
+func (o createAuthInfoOptions) validate() error {
+	if len(o.name) == 0 {
+		return errors.New("you must specify a non-empty user name")
+	}
+	methods := []string{}
+	if len(o.token.Value()) > 0 {
+		methods = append(methods, fmt.Sprintf("--%v", clientcmd.FlagBearerToken))
+	}
+	if len(o.username.Value()) > 0 || len(o.password.Value()) > 0 {
+		methods = append(methods, fmt.Sprintf("--%v/--%v", clientcmd.FlagUsername, clientcmd.FlagPassword))
+	}
+	if len(methods) > 1 {
+		return fmt.Errorf("you cannot specify more than one authentication method at the same time: %v", strings.Join(methods, ", "))
+	}
+	if o.embedCertData.Value() {
+		certPath := o.clientCertificate.Value()
+		keyPath := o.clientKey.Value()
+		if certPath == "" && keyPath == "" {
+			return fmt.Errorf("you must specify a --%s or --%s to embed", clientcmd.FlagCertFile, clientcmd.FlagKeyFile)
+		}
+		if certPath != "" {
+			if _, err := ioutil.ReadFile(certPath); err != nil {
+				return fmt.Errorf("error reading %s data from %s: %v", clientcmd.FlagCertFile, certPath, err)
+			}
+		}
+		if keyPath != "" {
+			if _, err := ioutil.ReadFile(keyPath); err != nil {
+				return fmt.Errorf("error reading %s data from %s: %v", clientcmd.FlagKeyFile, keyPath, err)
+			}
+		}
+	}
+
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/create_authinfo_test.go

@@ -0,0 +1,190 @@
+/*
+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 config
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/util/flag"
+)
+
+func stringFlagFor(s string) flag.StringFlag {
+	var f flag.StringFlag
+	f.Set(s)
+	return f
+}
+
+func TestCreateAuthInfoOptions(t *testing.T) {
+	tests := []struct {
+		flags           []string
+		wantParseErr    bool
+		wantCompleteErr bool
+		wantValidateErr bool
+
+		wantOptions *createAuthInfoOptions
+	}{
+		{
+			flags: []string{
+				"me",
+			},
+			wantOptions: &createAuthInfoOptions{
+				name: "me",
+			},
+		},
+		{
+			flags: []string{
+				"me",
+				"--token=foo",
+			},
+			wantOptions: &createAuthInfoOptions{
+				name:  "me",
+				token: stringFlagFor("foo"),
+			},
+		},
+		{
+			flags: []string{
+				"me",
+				"--username=jane",
+				"--password=bar",
+			},
+			wantOptions: &createAuthInfoOptions{
+				name:     "me",
+				username: stringFlagFor("jane"),
+				password: stringFlagFor("bar"),
+			},
+		},
+		{
+			// Cannot provide both token and basic auth.
+			flags: []string{
+				"me",
+				"--token=foo",
+				"--username=jane",
+				"--password=bar",
+			},
+			wantValidateErr: true,
+		},
+		{
+			flags: []string{
+				"--auth-provider=oidc",
+				"--auth-provider-arg=client-id=foo",
+				"--auth-provider-arg=client-secret=bar",
+				"me",
+			},
+			wantOptions: &createAuthInfoOptions{
+				name:         "me",
+				authProvider: stringFlagFor("oidc"),
+				authProviderArgs: map[string]string{
+					"client-id":     "foo",
+					"client-secret": "bar",
+				},
+				authProviderArgsToRemove: []string{},
+			},
+		},
+		{
+			flags: []string{
+				"--auth-provider=oidc",
+				"--auth-provider-arg=client-id-",
+				"--auth-provider-arg=client-secret-",
+				"me",
+			},
+			wantOptions: &createAuthInfoOptions{
+				name:             "me",
+				authProvider:     stringFlagFor("oidc"),
+				authProviderArgs: map[string]string{},
+				authProviderArgsToRemove: []string{
+					"client-id",
+					"client-secret",
+				},
+			},
+		},
+		{
+			flags: []string{
+				"--auth-provider-arg=client-id-", // auth provider name not required
+				"--auth-provider-arg=client-secret-",
+				"me",
+			},
+			wantOptions: &createAuthInfoOptions{
+				name:             "me",
+				authProviderArgs: map[string]string{},
+				authProviderArgsToRemove: []string{
+					"client-id",
+					"client-secret",
+				},
+			},
+		},
+		{
+			flags: []string{
+				"--auth-provider=oidc",
+				"--auth-provider-arg=client-id", // values must be of form 'key=value' or 'key-'
+				"me",
+			},
+			wantCompleteErr: true,
+		},
+		{
+			flags: []string{
+			// No name for authinfo provided.
+			},
+			wantCompleteErr: true,
+		},
+	}
+
+	for i, test := range tests {
+		buff := new(bytes.Buffer)
+
+		opts := new(createAuthInfoOptions)
+		cmd := newCmdConfigSetAuthInfo(buff, opts)
+		if err := cmd.ParseFlags(test.flags); err != nil {
+			if !test.wantParseErr {
+				t.Errorf("case %d: parsing error for flags %q: %v: %s", i, test.flags, err, buff)
+			}
+			continue
+		}
+		if test.wantParseErr {
+			t.Errorf("case %d: expected parsing error for flags %q: %s", i, test.flags, buff)
+			continue
+		}
+
+		if !opts.complete(cmd, buff) {
+			if !test.wantCompleteErr {
+				t.Errorf("case %d: complete() error for flags %q: %s", i, test.flags, buff)
+			}
+			continue
+		}
+		if test.wantCompleteErr {
+			t.Errorf("case %d: complete() expected errors for flags %q: %s", i, test.flags, buff)
+			continue
+		}
+
+		if err := opts.validate(); err != nil {
+			if !test.wantValidateErr {
+				t.Errorf("case %d: flags %q: validate failed: %v", i, test.flags, err)
+			}
+			continue
+		}
+
+		if test.wantValidateErr {
+			t.Errorf("case %d: flags %q: expected validate to fail", i, test.flags)
+			continue
+		}
+
+		if !reflect.DeepEqual(opts, test.wantOptions) {
+			t.Errorf("case %d: flags %q: mis-matched options,\nwanted=%#v\ngot=   %#v", i, test.flags, test.wantOptions, opts)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/create_cluster.go

@@ -0,0 +1,183 @@
+/*
+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 config
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"path/filepath"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/util/flag"
+)
+
+type createClusterOptions struct {
+	configAccess          clientcmd.ConfigAccess
+	name                  string
+	server                flag.StringFlag
+	apiVersion            flag.StringFlag
+	insecureSkipTLSVerify flag.Tristate
+	certificateAuthority  flag.StringFlag
+	embedCAData           flag.Tristate
+}
+
+var (
+	create_cluster_long = templates.LongDesc(`
+		Sets a cluster entry in kubeconfig.
+
+		Specifying a name that already exists will merge new fields on top of existing values for those fields.`)
+
+	create_cluster_example = templates.Examples(`
+		# Set only the server field on the e2e cluster entry without touching other values.
+		kubectl config set-cluster e2e --server=https://1.2.3.4
+
+		# Embed certificate authority data for the e2e cluster entry
+		kubectl config set-cluster e2e --certificate-authority=~/.kube/e2e/kubernetes.ca.crt
+
+		# Disable cert checking for the dev cluster entry
+		kubectl config set-cluster e2e --insecure-skip-tls-verify=true`)
+)
+
+func NewCmdConfigSetCluster(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command {
+	options := &createClusterOptions{configAccess: configAccess}
+
+	cmd := &cobra.Command{
+		Use:     fmt.Sprintf("set-cluster NAME [--%v=server] [--%v=path/to/certificate/authority] [--%v=true]", clientcmd.FlagAPIServer, clientcmd.FlagCAFile, clientcmd.FlagInsecure),
+		Short:   "Sets a cluster entry in kubeconfig",
+		Long:    create_cluster_long,
+		Example: create_cluster_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			if !options.complete(cmd) {
+				return
+			}
+
+			cmdutil.CheckErr(options.run())
+			fmt.Fprintf(out, "Cluster %q set.\n", options.name)
+		},
+	}
+
+	options.insecureSkipTLSVerify.Default(false)
+
+	cmd.Flags().Var(&options.server, clientcmd.FlagAPIServer, clientcmd.FlagAPIServer+" for the cluster entry in kubeconfig")
+	cmd.Flags().Var(&options.apiVersion, clientcmd.FlagAPIVersion, clientcmd.FlagAPIVersion+" for the cluster entry in kubeconfig")
+	f := cmd.Flags().VarPF(&options.insecureSkipTLSVerify, clientcmd.FlagInsecure, "", clientcmd.FlagInsecure+" for the cluster entry in kubeconfig")
+	f.NoOptDefVal = "true"
+	cmd.Flags().Var(&options.certificateAuthority, clientcmd.FlagCAFile, "path to "+clientcmd.FlagCAFile+" file for the cluster entry in kubeconfig")
+	cmd.MarkFlagFilename(clientcmd.FlagCAFile)
+	f = cmd.Flags().VarPF(&options.embedCAData, clientcmd.FlagEmbedCerts, "", clientcmd.FlagEmbedCerts+" for the cluster entry in kubeconfig")
+	f.NoOptDefVal = "true"
+
+	return cmd
+}
+
+func (o createClusterOptions) run() error {
+	err := o.validate()
+	if err != nil {
+		return err
+	}
+
+	config, err := o.configAccess.GetStartingConfig()
+	if err != nil {
+		return err
+	}
+
+	startingStanza, exists := config.Clusters[o.name]
+	if !exists {
+		startingStanza = clientcmdapi.NewCluster()
+	}
+	cluster := o.modifyCluster(*startingStanza)
+	config.Clusters[o.name] = &cluster
+
+	if err := clientcmd.ModifyConfig(o.configAccess, *config, true); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// cluster builds a Cluster object from the options
+func (o *createClusterOptions) modifyCluster(existingCluster clientcmdapi.Cluster) clientcmdapi.Cluster {
+	modifiedCluster := existingCluster
+
+	if o.server.Provided() {
+		modifiedCluster.Server = o.server.Value()
+	}
+	if o.insecureSkipTLSVerify.Provided() {
+		modifiedCluster.InsecureSkipTLSVerify = o.insecureSkipTLSVerify.Value()
+		// Specifying insecure mode clears any certificate authority
+		if modifiedCluster.InsecureSkipTLSVerify {
+			modifiedCluster.CertificateAuthority = ""
+			modifiedCluster.CertificateAuthorityData = nil
+		}
+	}
+	if o.certificateAuthority.Provided() {
+		caPath := o.certificateAuthority.Value()
+		if o.embedCAData.Value() {
+			modifiedCluster.CertificateAuthorityData, _ = ioutil.ReadFile(caPath)
+			modifiedCluster.InsecureSkipTLSVerify = false
+			modifiedCluster.CertificateAuthority = ""
+		} else {
+			caPath, _ = filepath.Abs(caPath)
+			modifiedCluster.CertificateAuthority = caPath
+			// Specifying a certificate authority file clears certificate authority data and insecure mode
+			if caPath != "" {
+				modifiedCluster.InsecureSkipTLSVerify = false
+				modifiedCluster.CertificateAuthorityData = nil
+			}
+		}
+	}
+
+	return modifiedCluster
+}
+
+func (o *createClusterOptions) complete(cmd *cobra.Command) bool {
+	args := cmd.Flags().Args()
+	if len(args) != 1 {
+		cmd.Help()
+		return false
+	}
+
+	o.name = args[0]
+	return true
+}
+
+func (o createClusterOptions) validate() error {
+	if len(o.name) == 0 {
+		return errors.New("you must specify a non-empty cluster name")
+	}
+	if o.insecureSkipTLSVerify.Value() && o.certificateAuthority.Value() != "" {
+		return errors.New("you cannot specify a certificate authority and insecure mode at the same time")
+	}
+	if o.embedCAData.Value() {
+		caPath := o.certificateAuthority.Value()
+		if caPath == "" {
+			return fmt.Errorf("you must specify a --%s to embed", clientcmd.FlagCAFile)
+		}
+		if _, err := ioutil.ReadFile(caPath); err != nil {
+			return fmt.Errorf("could not read %s data from %s: %v", clientcmd.FlagCAFile, caPath, err)
+		}
+	}
+
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/create_context.go

@@ -0,0 +1,135 @@
+/*
+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 config
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/util/flag"
+)
+
+type createContextOptions struct {
+	configAccess clientcmd.ConfigAccess
+	name         string
+	cluster      flag.StringFlag
+	authInfo     flag.StringFlag
+	namespace    flag.StringFlag
+}
+
+var (
+	create_context_long = templates.LongDesc(`
+		Sets a context entry in kubeconfig
+
+		Specifying a name that already exists will merge new fields on top of existing values for those fields.`)
+
+	create_context_example = templates.Examples(`
+		# Set the user field on the gce context entry without touching other values
+		kubectl config set-context gce --user=cluster-admin`)
+)
+
+func NewCmdConfigSetContext(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command {
+	options := &createContextOptions{configAccess: configAccess}
+
+	cmd := &cobra.Command{
+		Use:     fmt.Sprintf("set-context NAME [--%v=cluster_nickname] [--%v=user_nickname] [--%v=namespace]", clientcmd.FlagClusterName, clientcmd.FlagAuthInfoName, clientcmd.FlagNamespace),
+		Short:   "Sets a context entry in kubeconfig",
+		Long:    create_context_long,
+		Example: create_context_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			if !options.complete(cmd) {
+				return
+			}
+
+			cmdutil.CheckErr(options.run())
+			fmt.Fprintf(out, "Context %q set.\n", options.name)
+		},
+	}
+
+	cmd.Flags().Var(&options.cluster, clientcmd.FlagClusterName, clientcmd.FlagClusterName+" for the context entry in kubeconfig")
+	cmd.Flags().Var(&options.authInfo, clientcmd.FlagAuthInfoName, clientcmd.FlagAuthInfoName+" for the context entry in kubeconfig")
+	cmd.Flags().Var(&options.namespace, clientcmd.FlagNamespace, clientcmd.FlagNamespace+" for the context entry in kubeconfig")
+
+	return cmd
+}
+
+func (o createContextOptions) run() error {
+	err := o.validate()
+	if err != nil {
+		return err
+	}
+
+	config, err := o.configAccess.GetStartingConfig()
+	if err != nil {
+		return err
+	}
+
+	startingStanza, exists := config.Contexts[o.name]
+	if !exists {
+		startingStanza = clientcmdapi.NewContext()
+	}
+	context := o.modifyContext(*startingStanza)
+	config.Contexts[o.name] = &context
+
+	if err := clientcmd.ModifyConfig(o.configAccess, *config, true); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (o *createContextOptions) modifyContext(existingContext clientcmdapi.Context) clientcmdapi.Context {
+	modifiedContext := existingContext
+
+	if o.cluster.Provided() {
+		modifiedContext.Cluster = o.cluster.Value()
+	}
+	if o.authInfo.Provided() {
+		modifiedContext.AuthInfo = o.authInfo.Value()
+	}
+	if o.namespace.Provided() {
+		modifiedContext.Namespace = o.namespace.Value()
+	}
+
+	return modifiedContext
+}
+
+func (o *createContextOptions) complete(cmd *cobra.Command) bool {
+	args := cmd.Flags().Args()
+	if len(args) != 1 {
+		cmd.Help()
+		return false
+	}
+
+	o.name = args[0]
+	return true
+}
+
+func (o createContextOptions) validate() error {
+	if len(o.name) == 0 {
+		return errors.New("you must specify a non-empty context name")
+	}
+
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/current_context.go

@@ -0,0 +1,73 @@
+/*
+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 config
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+type CurrentContextOptions struct {
+	ConfigAccess clientcmd.ConfigAccess
+}
+
+var (
+	current_context_long = templates.LongDesc(`
+		Displays the current-context`)
+
+	current_context_example = templates.Examples(`
+		# Display the current-context
+		kubectl config current-context`)
+)
+
+func NewCmdConfigCurrentContext(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command {
+	options := &CurrentContextOptions{ConfigAccess: configAccess}
+
+	cmd := &cobra.Command{
+		Use:     "current-context",
+		Short:   "Displays the current-context",
+		Long:    current_context_long,
+		Example: current_context_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunCurrentContext(out, args, options)
+			cmdutil.CheckErr(err)
+		},
+	}
+
+	return cmd
+}
+
+func RunCurrentContext(out io.Writer, args []string, options *CurrentContextOptions) error {
+	config, err := options.ConfigAccess.GetStartingConfig()
+	if err != nil {
+		return err
+	}
+
+	if config.CurrentContext == "" {
+		err = fmt.Errorf("current-context is not set\n")
+		return err
+	}
+
+	fmt.Fprintf(out, "%s\n", config.CurrentContext)
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/current_context_test.go

@@ -0,0 +1,90 @@
+/*
+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 config
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"strings"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+)
+
+type currentContextTest struct {
+	startingConfig clientcmdapi.Config
+	expectedError  string
+}
+
+func newFederalContextConfig() clientcmdapi.Config {
+	return clientcmdapi.Config{
+		CurrentContext: "federal-context",
+	}
+}
+
+func TestCurrentContextWithSetContext(t *testing.T) {
+	test := currentContextTest{
+		startingConfig: newFederalContextConfig(),
+		expectedError:  "",
+	}
+
+	test.run(t)
+}
+
+func TestCurrentContextWithUnsetContext(t *testing.T) {
+	test := currentContextTest{
+		startingConfig: *clientcmdapi.NewConfig(),
+		expectedError:  "current-context is not set",
+	}
+
+	test.run(t)
+}
+
+func (test currentContextTest) run(t *testing.T) {
+	fakeKubeFile, _ := ioutil.TempFile("", "")
+	defer os.Remove(fakeKubeFile.Name())
+	err := clientcmd.WriteToFile(test.startingConfig, fakeKubeFile.Name())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	pathOptions := clientcmd.NewDefaultPathOptions()
+	pathOptions.GlobalFile = fakeKubeFile.Name()
+	pathOptions.EnvVar = ""
+	options := CurrentContextOptions{
+		ConfigAccess: pathOptions,
+	}
+
+	buf := bytes.NewBuffer([]byte{})
+	err = RunCurrentContext(buf, []string{}, &options)
+	if len(test.expectedError) != 0 {
+		if err == nil {
+			t.Errorf("Did not get %v", test.expectedError)
+		} else {
+			if !strings.Contains(err.Error(), test.expectedError) {
+				t.Errorf("Expected %v, but got %v", test.expectedError, err)
+			}
+		}
+		return
+	}
+
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/delete_cluster.go

@@ -0,0 +1,73 @@
+/*
+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 config
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+func NewCmdConfigDeleteCluster(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "delete-cluster NAME",
+		Short: "Delete the specified cluster from the kubeconfig",
+		Run: func(cmd *cobra.Command, args []string) {
+			err := runDeleteCluster(out, configAccess, cmd)
+			cmdutil.CheckErr(err)
+		},
+	}
+
+	return cmd
+}
+
+func runDeleteCluster(out io.Writer, configAccess clientcmd.ConfigAccess, cmd *cobra.Command) error {
+	config, err := configAccess.GetStartingConfig()
+	if err != nil {
+		return err
+	}
+
+	args := cmd.Flags().Args()
+	if len(args) != 1 {
+		cmd.Help()
+		return nil
+	}
+
+	configFile := configAccess.GetDefaultFilename()
+	if configAccess.IsExplicitFile() {
+		configFile = configAccess.GetExplicitFile()
+	}
+
+	name := args[0]
+	_, ok := config.Clusters[name]
+	if !ok {
+		return fmt.Errorf("cannot delete cluster %s, not in %s", name, configFile)
+	}
+
+	delete(config.Clusters, name)
+
+	if err := clientcmd.ModifyConfig(configAccess, *config, true); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(out, "deleted cluster %s from %s\n", name, configFile)
+
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/delete_cluster_test.go

@@ -0,0 +1,94 @@
+/*
+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 config
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"reflect"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+)
+
+type deleteClusterTest struct {
+	config           clientcmdapi.Config
+	clusterToDelete  string
+	expectedClusters []string
+	expectedOut      string
+}
+
+func TestDeleteCluster(t *testing.T) {
+	conf := clientcmdapi.Config{
+		Clusters: map[string]*clientcmdapi.Cluster{
+			"minikube":  {Server: "https://192.168.0.99"},
+			"otherkube": {Server: "https://192.168.0.100"},
+		},
+	}
+	test := deleteClusterTest{
+		config:           conf,
+		clusterToDelete:  "minikube",
+		expectedClusters: []string{"otherkube"},
+		expectedOut:      "deleted cluster minikube from %s\n",
+	}
+
+	test.run(t)
+}
+
+func (test deleteClusterTest) run(t *testing.T) {
+	fakeKubeFile, _ := ioutil.TempFile("", "")
+	defer os.Remove(fakeKubeFile.Name())
+	err := clientcmd.WriteToFile(test.config, fakeKubeFile.Name())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	pathOptions := clientcmd.NewDefaultPathOptions()
+	pathOptions.GlobalFile = fakeKubeFile.Name()
+	pathOptions.EnvVar = ""
+
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdConfigDeleteCluster(buf, pathOptions)
+	cmd.SetArgs([]string{test.clusterToDelete})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error executing command: %v", err)
+	}
+
+	expectedOutWithFile := fmt.Sprintf(test.expectedOut, fakeKubeFile.Name())
+	if expectedOutWithFile != buf.String() {
+		t.Errorf("expected output %s, but got %s", expectedOutWithFile, buf.String())
+		return
+	}
+
+	// Verify cluster was removed from kubeconfig file
+	config, err := clientcmd.LoadFromFile(fakeKubeFile.Name())
+	if err != nil {
+		t.Fatalf("unexpected error loading kubeconfig file: %v", err)
+	}
+
+	clusters := make([]string, 0, len(config.Clusters))
+	for k := range config.Clusters {
+		clusters = append(clusters, k)
+	}
+
+	if !reflect.DeepEqual(test.expectedClusters, clusters) {
+		t.Errorf("expected clusters %v, but found %v in kubeconfig", test.expectedClusters, clusters)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/delete_context.go

@@ -0,0 +1,73 @@
+/*
+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 config
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+func NewCmdConfigDeleteContext(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "delete-context NAME",
+		Short: "Delete the specified context from the kubeconfig",
+		Run: func(cmd *cobra.Command, args []string) {
+			err := runDeleteContext(out, configAccess, cmd)
+			cmdutil.CheckErr(err)
+		},
+	}
+
+	return cmd
+}
+
+func runDeleteContext(out io.Writer, configAccess clientcmd.ConfigAccess, cmd *cobra.Command) error {
+	config, err := configAccess.GetStartingConfig()
+	if err != nil {
+		return err
+	}
+
+	args := cmd.Flags().Args()
+	if len(args) != 1 {
+		cmd.Help()
+		return nil
+	}
+
+	configFile := configAccess.GetDefaultFilename()
+	if configAccess.IsExplicitFile() {
+		configFile = configAccess.GetExplicitFile()
+	}
+
+	name := args[0]
+	_, ok := config.Contexts[name]
+	if !ok {
+		return fmt.Errorf("cannot delete context %s, not in %s", name, configFile)
+	}
+
+	delete(config.Contexts, name)
+
+	if err := clientcmd.ModifyConfig(configAccess, *config, true); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(out, "deleted context %s from %s\n", name, configFile)
+
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/delete_context_test.go

@@ -0,0 +1,94 @@
+/*
+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 config
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"reflect"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+)
+
+type deleteContextTest struct {
+	config           clientcmdapi.Config
+	contextToDelete  string
+	expectedContexts []string
+	expectedOut      string
+}
+
+func TestDeleteContext(t *testing.T) {
+	conf := clientcmdapi.Config{
+		Contexts: map[string]*clientcmdapi.Context{
+			"minikube":  {Cluster: "minikube"},
+			"otherkube": {Cluster: "otherkube"},
+		},
+	}
+	test := deleteContextTest{
+		config:           conf,
+		contextToDelete:  "minikube",
+		expectedContexts: []string{"otherkube"},
+		expectedOut:      "deleted context minikube from %s\n",
+	}
+
+	test.run(t)
+}
+
+func (test deleteContextTest) run(t *testing.T) {
+	fakeKubeFile, _ := ioutil.TempFile("", "")
+	defer os.Remove(fakeKubeFile.Name())
+	err := clientcmd.WriteToFile(test.config, fakeKubeFile.Name())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	pathOptions := clientcmd.NewDefaultPathOptions()
+	pathOptions.GlobalFile = fakeKubeFile.Name()
+	pathOptions.EnvVar = ""
+
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdConfigDeleteContext(buf, pathOptions)
+	cmd.SetArgs([]string{test.contextToDelete})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error executing command: %v", err)
+	}
+
+	expectedOutWithFile := fmt.Sprintf(test.expectedOut, fakeKubeFile.Name())
+	if expectedOutWithFile != buf.String() {
+		t.Errorf("expected output %s, but got %s", expectedOutWithFile, buf.String())
+		return
+	}
+
+	// Verify context was removed from kubeconfig file
+	config, err := clientcmd.LoadFromFile(fakeKubeFile.Name())
+	if err != nil {
+		t.Fatalf("unexpected error loading kubeconfig file: %v", err)
+	}
+
+	contexts := make([]string, 0, len(config.Contexts))
+	for k := range config.Contexts {
+		contexts = append(contexts, k)
+	}
+
+	if !reflect.DeepEqual(test.expectedContexts, contexts) {
+		t.Errorf("expected contexts %v, but found %v in kubeconfig", test.expectedContexts, contexts)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/get_clusters.go

@@ -0,0 +1,55 @@
+/*
+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 config
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+// NewCmdConfigGetClusters creates a command object for the "get-clusters" action, which
+// lists all clusters defined in the kubeconfig.
+func NewCmdConfigGetClusters(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "get-clusters",
+		Short: "Display clusters defined in the kubeconfig",
+		Run: func(cmd *cobra.Command, args []string) {
+			err := runGetClusters(out, configAccess)
+			cmdutil.CheckErr(err)
+		},
+	}
+
+	return cmd
+}
+
+func runGetClusters(out io.Writer, configAccess clientcmd.ConfigAccess) error {
+	config, err := configAccess.GetStartingConfig()
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintf(out, "NAME\n")
+	for name := range config.Clusters {
+		fmt.Fprintf(out, "%s\n", name)
+	}
+
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/get_clusters_test.go

@@ -0,0 +1,81 @@
+/*
+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 config
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+)
+
+type getClustersTest struct {
+	config   clientcmdapi.Config
+	expected string
+}
+
+func TestGetClusters(t *testing.T) {
+	conf := clientcmdapi.Config{
+		Clusters: map[string]*clientcmdapi.Cluster{
+			"minikube": {Server: "https://192.168.0.99"},
+		},
+	}
+	test := getClustersTest{
+		config: conf,
+		expected: `NAME
+minikube
+`,
+	}
+
+	test.run(t)
+}
+
+func TestGetClustersEmpty(t *testing.T) {
+	test := getClustersTest{
+		config:   clientcmdapi.Config{},
+		expected: "NAME\n",
+	}
+
+	test.run(t)
+}
+
+func (test getClustersTest) run(t *testing.T) {
+	fakeKubeFile, _ := ioutil.TempFile("", "")
+	defer os.Remove(fakeKubeFile.Name())
+	err := clientcmd.WriteToFile(test.config, fakeKubeFile.Name())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	pathOptions := clientcmd.NewDefaultPathOptions()
+	pathOptions.GlobalFile = fakeKubeFile.Name()
+	pathOptions.EnvVar = ""
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdConfigGetClusters(buf, pathOptions)
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error executing command: %v", err)
+	}
+	if len(test.expected) != 0 {
+		if buf.String() != test.expected {
+			t.Errorf("expected %v, but got %v", test.expected, buf.String())
+		}
+		return
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/get_contexts.go

@@ -0,0 +1,169 @@
+/*
+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 config
+
+import (
+	"fmt"
+	"io"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	utilerrors "k8s.io/kubernetes/pkg/util/errors"
+	"k8s.io/kubernetes/pkg/util/sets"
+)
+
+// GetContextsOptions contains the assignable options from the args.
+type GetContextsOptions struct {
+	configAccess clientcmd.ConfigAccess
+	nameOnly     bool
+	showHeaders  bool
+	contextNames []string
+	out          io.Writer
+}
+
+var (
+	getContextsLong = templates.LongDesc(`Displays one or many contexts from the kubeconfig file.`)
+
+	getContextsExample = templates.Examples(`
+		# List all the contexts in your kubeconfig file
+		kubectl config get-contexts
+
+		# Describe one context in your kubeconfig file.
+		kubectl config get-contexts my-context`)
+)
+
+// NewCmdConfigGetContexts creates a command object for the "get-contexts" action, which
+// retrieves one or more contexts from a kubeconfig.
+func NewCmdConfigGetContexts(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command {
+	options := &GetContextsOptions{configAccess: configAccess}
+
+	cmd := &cobra.Command{
+		Use:     "get-contexts [(-o|--output=)name)]",
+		Short:   "Describe one or many contexts",
+		Long:    getContextsLong,
+		Example: getContextsExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			validOutputTypes := sets.NewString("", "json", "yaml", "wide", "name", "custom-columns", "custom-columns-file", "go-template", "go-template-file", "jsonpath", "jsonpath-file")
+			supportedOutputTypes := sets.NewString("", "name")
+			outputFormat := cmdutil.GetFlagString(cmd, "output")
+			if !validOutputTypes.Has(outputFormat) {
+				cmdutil.CheckErr(fmt.Errorf("output must be one of '' or 'name': %v", outputFormat))
+			}
+			if !supportedOutputTypes.Has(outputFormat) {
+				fmt.Fprintf(out, "--output %v is not available in kubectl config get-contexts; resetting to default output format\n", outputFormat)
+				cmd.Flags().Set("output", "")
+			}
+			cmdutil.CheckErr(options.Complete(cmd, args, out))
+			cmdutil.CheckErr(options.RunGetContexts())
+		},
+	}
+	cmdutil.AddOutputFlags(cmd)
+	cmdutil.AddNoHeadersFlags(cmd)
+	return cmd
+}
+
+// Complete assigns GetContextsOptions from the args.
+func (o *GetContextsOptions) Complete(cmd *cobra.Command, args []string, out io.Writer) error {
+	o.contextNames = args
+	o.out = out
+	o.nameOnly = false
+	if cmdutil.GetFlagString(cmd, "output") == "name" {
+		o.nameOnly = true
+	}
+	o.showHeaders = true
+	if cmdutil.GetFlagBool(cmd, "no-headers") || o.nameOnly {
+		o.showHeaders = false
+	}
+
+	return nil
+}
+
+// RunGetContexts implements all the necessary functionality for context retrieval.
+func (o GetContextsOptions) RunGetContexts() error {
+	config, err := o.configAccess.GetStartingConfig()
+	if err != nil {
+		return err
+	}
+
+	out, found := o.out.(*tabwriter.Writer)
+	if !found {
+		out = kubectl.GetNewTabWriter(o.out)
+		defer out.Flush()
+	}
+
+	// Build a list of context names to print, and warn if any requested contexts are not found.
+	// Do this before printing the headers so it doesn't look ugly.
+	allErrs := []error{}
+	toPrint := []string{}
+	if len(o.contextNames) == 0 {
+		for name := range config.Contexts {
+			toPrint = append(toPrint, name)
+		}
+	} else {
+		for _, name := range o.contextNames {
+			_, ok := config.Contexts[name]
+			if ok {
+				toPrint = append(toPrint, name)
+			} else {
+				allErrs = append(allErrs, fmt.Errorf("context %v not found", name))
+			}
+		}
+	}
+	if o.showHeaders {
+		err = printContextHeaders(out, o.nameOnly)
+		if err != nil {
+			allErrs = append(allErrs, err)
+		}
+	}
+
+	for _, name := range toPrint {
+		err = printContext(name, config.Contexts[name], out, o.nameOnly, config.CurrentContext == name)
+		if err != nil {
+			allErrs = append(allErrs, err)
+		}
+	}
+
+	return utilerrors.NewAggregate(allErrs)
+}
+
+func printContextHeaders(out io.Writer, nameOnly bool) error {
+	columnNames := []string{"CURRENT", "NAME", "CLUSTER", "AUTHINFO", "NAMESPACE"}
+	if nameOnly {
+		columnNames = columnNames[:1]
+	}
+	_, err := fmt.Fprintf(out, "%s\n", strings.Join(columnNames, "\t"))
+	return err
+}
+
+func printContext(name string, context *clientcmdapi.Context, w io.Writer, nameOnly, current bool) error {
+	if nameOnly {
+		_, err := fmt.Fprintf(w, "%s\n", name)
+		return err
+	}
+	prefix := " "
+	if current {
+		prefix = "*"
+	}
+	_, err := fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", prefix, name, context.Cluster, context.AuthInfo, context.Namespace)
+	return err
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/get_contexts_test.go

@@ -0,0 +1,158 @@
+/*
+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 config
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+)
+
+type getContextsTest struct {
+	startingConfig clientcmdapi.Config
+	names          []string
+	noHeader       bool
+	nameOnly       bool
+	expectedOut    string
+}
+
+func TestGetContextsAll(t *testing.T) {
+	tconf := clientcmdapi.Config{
+		CurrentContext: "shaker-context",
+		Contexts: map[string]*clientcmdapi.Context{
+			"shaker-context": {AuthInfo: "blue-user", Cluster: "big-cluster", Namespace: "saw-ns"}}}
+	test := getContextsTest{
+		startingConfig: tconf,
+		names:          []string{},
+		noHeader:       false,
+		nameOnly:       false,
+		expectedOut: `CURRENT   NAME             CLUSTER       AUTHINFO    NAMESPACE
+*         shaker-context   big-cluster   blue-user   saw-ns
+`,
+	}
+	test.run(t)
+}
+
+func TestGetContextsAllNoHeader(t *testing.T) {
+	tconf := clientcmdapi.Config{
+		CurrentContext: "shaker-context",
+		Contexts: map[string]*clientcmdapi.Context{
+			"shaker-context": {AuthInfo: "blue-user", Cluster: "big-cluster", Namespace: "saw-ns"}}}
+	test := getContextsTest{
+		startingConfig: tconf,
+		names:          []string{},
+		noHeader:       true,
+		nameOnly:       false,
+		expectedOut:    "*         shaker-context   big-cluster   blue-user   saw-ns\n",
+	}
+	test.run(t)
+}
+
+func TestGetContextsAllName(t *testing.T) {
+	tconf := clientcmdapi.Config{
+		Contexts: map[string]*clientcmdapi.Context{
+			"shaker-context": {AuthInfo: "blue-user", Cluster: "big-cluster", Namespace: "saw-ns"}}}
+	test := getContextsTest{
+		startingConfig: tconf,
+		names:          []string{},
+		noHeader:       false,
+		nameOnly:       true,
+		expectedOut:    "shaker-context\n",
+	}
+	test.run(t)
+}
+
+func TestGetContextsAllNameNoHeader(t *testing.T) {
+	tconf := clientcmdapi.Config{
+		CurrentContext: "shaker-context",
+		Contexts: map[string]*clientcmdapi.Context{
+			"shaker-context": {AuthInfo: "blue-user", Cluster: "big-cluster", Namespace: "saw-ns"}}}
+	test := getContextsTest{
+		startingConfig: tconf,
+		names:          []string{},
+		noHeader:       true,
+		nameOnly:       true,
+		expectedOut:    "shaker-context\n",
+	}
+	test.run(t)
+}
+
+func TestGetContextsAllNone(t *testing.T) {
+	test := getContextsTest{
+		startingConfig: *clientcmdapi.NewConfig(),
+		names:          []string{},
+		noHeader:       true,
+		nameOnly:       false,
+		expectedOut:    "",
+	}
+	test.run(t)
+}
+
+func TestGetContextsSelectOneOfTwo(t *testing.T) {
+	tconf := clientcmdapi.Config{
+		CurrentContext: "shaker-context",
+		Contexts: map[string]*clientcmdapi.Context{
+			"shaker-context": {AuthInfo: "blue-user", Cluster: "big-cluster", Namespace: "saw-ns"},
+			"not-this":       {AuthInfo: "blue-user", Cluster: "big-cluster", Namespace: "saw-ns"}}}
+	test := getContextsTest{
+		startingConfig: tconf,
+		names:          []string{"shaker-context"},
+		noHeader:       true,
+		nameOnly:       true,
+		expectedOut:    "shaker-context\n",
+	}
+	test.run(t)
+}
+
+func (test getContextsTest) run(t *testing.T) {
+	fakeKubeFile, _ := ioutil.TempFile("", "")
+	defer os.Remove(fakeKubeFile.Name())
+	err := clientcmd.WriteToFile(test.startingConfig, fakeKubeFile.Name())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	pathOptions := clientcmd.NewDefaultPathOptions()
+	pathOptions.GlobalFile = fakeKubeFile.Name()
+	pathOptions.EnvVar = ""
+	buf := bytes.NewBuffer([]byte{})
+	options := GetContextsOptions{
+		configAccess: pathOptions,
+	}
+	cmd := NewCmdConfigGetContexts(buf, options.configAccess)
+	if test.nameOnly {
+		cmd.Flags().Set("output", "name")
+	}
+	if test.noHeader {
+		cmd.Flags().Set("no-headers", "true")
+	}
+	cmd.Run(cmd, test.names)
+	if len(test.expectedOut) != 0 {
+		if buf.String() != test.expectedOut {
+			t.Errorf("Expected %v, but got %v", test.expectedOut, buf.String())
+		}
+		return
+	}
+
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/navigation_step_parser.go

@@ -0,0 +1,152 @@
+/*
+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 config
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+	"k8s.io/kubernetes/pkg/util/sets"
+)
+
+type navigationSteps struct {
+	steps            []navigationStep
+	currentStepIndex int
+}
+
+type navigationStep struct {
+	stepValue string
+	stepType  reflect.Type
+}
+
+func newNavigationSteps(path string) (*navigationSteps, error) {
+	steps := []navigationStep{}
+	individualParts := strings.Split(path, ".")
+
+	currType := reflect.TypeOf(clientcmdapi.Config{})
+	currPartIndex := 0
+	for currPartIndex < len(individualParts) {
+		switch currType.Kind() {
+		case reflect.Map:
+			// if we're in a map, we need to locate a name.  That name may contain dots, so we need to know what tokens are legal for the map's value type
+			// for example, we could have a set request like: `set clusters.10.10.12.56.insecure-skip-tls-verify true`.  We enter this case with
+			// steps representing 10, 10, 12, 56, insecure-skip-tls-verify.  The name is "10.10.12.56", so we want to collect all those parts together and
+			// store them as a single step.  In order to do that, we need to determine what set of tokens is a legal step AFTER the name of the map key
+			// This set of reflective code pulls the type of the map values, uses that type to look up the set of legal tags.  Those legal tags are used to
+			// walk the list of remaining parts until we find a match to a legal tag or the end of the string.  That name is used to burn all the used parts.
+			mapValueType := currType.Elem().Elem()
+			mapValueOptions, err := getPotentialTypeValues(mapValueType)
+			if err != nil {
+				return nil, err
+			}
+			nextPart := findNameStep(individualParts[currPartIndex:], sets.StringKeySet(mapValueOptions))
+
+			steps = append(steps, navigationStep{nextPart, mapValueType})
+			currPartIndex += len(strings.Split(nextPart, "."))
+			currType = mapValueType
+
+		case reflect.Struct:
+			nextPart := individualParts[currPartIndex]
+
+			options, err := getPotentialTypeValues(currType)
+			if err != nil {
+				return nil, err
+			}
+			fieldType, exists := options[nextPart]
+			if !exists {
+				return nil, fmt.Errorf("unable to parse %v after %v at %v", path, steps, currType)
+			}
+
+			steps = append(steps, navigationStep{nextPart, fieldType})
+			currPartIndex += len(strings.Split(nextPart, "."))
+			currType = fieldType
+		}
+	}
+
+	return &navigationSteps{steps, 0}, nil
+}
+
+func (s *navigationSteps) pop() navigationStep {
+	if s.moreStepsRemaining() {
+		s.currentStepIndex++
+		return s.steps[s.currentStepIndex-1]
+	}
+	return navigationStep{}
+}
+
+func (s *navigationSteps) peek() navigationStep {
+	if s.moreStepsRemaining() {
+		return s.steps[s.currentStepIndex]
+	}
+	return navigationStep{}
+}
+
+func (s *navigationSteps) moreStepsRemaining() bool {
+	return len(s.steps) > s.currentStepIndex
+}
+
+// findNameStep takes the list of parts and a set of valid tags that can be used after the name.  It then walks the list of parts
+// until it find a valid "next" tag or until it reaches the end of the parts and then builds the name back up out of the individual parts
+func findNameStep(parts []string, typeOptions sets.String) string {
+	if len(parts) == 0 {
+		return ""
+	}
+
+	numberOfPartsInStep := findKnownValue(parts[1:], typeOptions) + 1
+	// if we didn't find a known value, then the entire thing must be a name
+	if numberOfPartsInStep == 0 {
+		numberOfPartsInStep = len(parts)
+	}
+	nextParts := parts[0:numberOfPartsInStep]
+
+	return strings.Join(nextParts, ".")
+}
+
+// getPotentialTypeValues takes a type and looks up the tags used to represent its fields when serialized.
+func getPotentialTypeValues(typeValue reflect.Type) (map[string]reflect.Type, error) {
+	if typeValue.Kind() == reflect.Ptr {
+		typeValue = typeValue.Elem()
+	}
+
+	if typeValue.Kind() != reflect.Struct {
+		return nil, fmt.Errorf("%v is not of type struct", typeValue)
+	}
+
+	ret := make(map[string]reflect.Type)
+
+	for fieldIndex := 0; fieldIndex < typeValue.NumField(); fieldIndex++ {
+		fieldType := typeValue.Field(fieldIndex)
+		yamlTag := fieldType.Tag.Get("json")
+		yamlTagName := strings.Split(yamlTag, ",")[0]
+
+		ret[yamlTagName] = fieldType.Type
+	}
+
+	return ret, nil
+}
+
+func findKnownValue(parts []string, valueOptions sets.String) int {
+	for i := range parts {
+		if valueOptions.Has(parts[i]) {
+			return i
+		}
+	}
+
+	return -1
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/navigation_step_parser_test.go

@@ -0,0 +1,96 @@
+/*
+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 config
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+	"k8s.io/kubernetes/pkg/util/diff"
+)
+
+type stepParserTest struct {
+	path                    string
+	expectedNavigationSteps navigationSteps
+	expectedError           string
+}
+
+func TestParseWithDots(t *testing.T) {
+	test := stepParserTest{
+		path: "clusters.my.dot.delimited.name.server",
+		expectedNavigationSteps: navigationSteps{
+			steps: []navigationStep{
+				{"clusters", reflect.TypeOf(make(map[string]*clientcmdapi.Cluster))},
+				{"my.dot.delimited.name", reflect.TypeOf(clientcmdapi.Cluster{})},
+				{"server", reflect.TypeOf("")},
+			},
+		},
+	}
+
+	test.run(t)
+}
+
+func TestParseWithDotsEndingWithName(t *testing.T) {
+	test := stepParserTest{
+		path: "contexts.10.12.12.12",
+		expectedNavigationSteps: navigationSteps{
+			steps: []navigationStep{
+				{"contexts", reflect.TypeOf(make(map[string]*clientcmdapi.Context))},
+				{"10.12.12.12", reflect.TypeOf(clientcmdapi.Context{})},
+			},
+		},
+	}
+
+	test.run(t)
+}
+
+func TestParseWithBadValue(t *testing.T) {
+	test := stepParserTest{
+		path: "user.bad",
+		expectedNavigationSteps: navigationSteps{
+			steps: []navigationStep{},
+		},
+		expectedError: "unable to parse user.bad after [] at api.Config",
+	}
+
+	test.run(t)
+}
+
+func (test stepParserTest) run(t *testing.T) {
+	actualSteps, err := newNavigationSteps(test.path)
+	if len(test.expectedError) != 0 {
+		if err == nil {
+			t.Errorf("Did not get %v", test.expectedError)
+		} else {
+			if !strings.Contains(err.Error(), test.expectedError) {
+				t.Errorf("Expected %v, but got %v", test.expectedError, err)
+			}
+		}
+		return
+	}
+
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+
+	if !reflect.DeepEqual(test.expectedNavigationSteps, *actualSteps) {
+		t.Errorf("diff: %v", diff.ObjectDiff(test.expectedNavigationSteps, *actualSteps))
+		t.Errorf("expected: %#v\n actual:   %#v", test.expectedNavigationSteps, *actualSteps)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/set.go

@@ -0,0 +1,247 @@
+/*
+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 config
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"reflect"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/util/flag"
+)
+
+const (
+	cannotHaveStepsAfterError                = "Cannot have steps after %v.  %v are remaining"
+	additionStepRequiredUnlessUnsettingError = "Must have additional steps after %v unless you are unsetting it"
+)
+
+type setOptions struct {
+	configAccess  clientcmd.ConfigAccess
+	propertyName  string
+	propertyValue string
+	setRawBytes   flag.Tristate
+}
+
+var set_long = templates.LongDesc(`
+	Sets an individual value in a kubeconfig file
+
+	PROPERTY_NAME is a dot delimited name where each token represents either an attribute name or a map key.  Map keys may not contain dots.
+
+	PROPERTY_VALUE is the new value you wish to set. Binary fields such as 'certificate-authority-data' expect a base64 encoded string unless the --set-raw-bytes flag is used.`)
+
+func NewCmdConfigSet(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command {
+	options := &setOptions{configAccess: configAccess}
+
+	cmd := &cobra.Command{
+		Use:   "set PROPERTY_NAME PROPERTY_VALUE",
+		Short: "Sets an individual value in a kubeconfig file",
+		Long:  set_long,
+		Run: func(cmd *cobra.Command, args []string) {
+			if !options.complete(cmd) {
+				return
+			}
+
+			cmdutil.CheckErr(options.run())
+			fmt.Fprintf(out, "Property %q set.\n", options.propertyName)
+		},
+	}
+
+	f := cmd.Flags().VarPF(&options.setRawBytes, "set-raw-bytes", "", "When writing a []byte PROPERTY_VALUE, write the given string directly without base64 decoding.")
+	f.NoOptDefVal = "true"
+	return cmd
+}
+
+func (o setOptions) run() error {
+	err := o.validate()
+	if err != nil {
+		return err
+	}
+
+	config, err := o.configAccess.GetStartingConfig()
+	if err != nil {
+		return err
+	}
+	steps, err := newNavigationSteps(o.propertyName)
+	if err != nil {
+		return err
+	}
+
+	setRawBytes := false
+	if o.setRawBytes.Provided() {
+		setRawBytes = o.setRawBytes.Value()
+	}
+
+	err = modifyConfig(reflect.ValueOf(config), steps, o.propertyValue, false, setRawBytes)
+	if err != nil {
+		return err
+	}
+
+	if err := clientcmd.ModifyConfig(o.configAccess, *config, false); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (o *setOptions) complete(cmd *cobra.Command) bool {
+	endingArgs := cmd.Flags().Args()
+	if len(endingArgs) != 2 {
+		cmd.Help()
+		return false
+	}
+
+	o.propertyValue = endingArgs[1]
+	o.propertyName = endingArgs[0]
+	return true
+}
+
+func (o setOptions) validate() error {
+	if len(o.propertyValue) == 0 {
+		return errors.New("you cannot use set to unset a property")
+	}
+
+	if len(o.propertyName) == 0 {
+		return errors.New("you must specify a property")
+	}
+
+	return nil
+}
+
+func modifyConfig(curr reflect.Value, steps *navigationSteps, propertyValue string, unset bool, setRawBytes bool) error {
+	currStep := steps.pop()
+
+	actualCurrValue := curr
+	if curr.Kind() == reflect.Ptr {
+		actualCurrValue = curr.Elem()
+	}
+
+	switch actualCurrValue.Kind() {
+	case reflect.Map:
+		if !steps.moreStepsRemaining() && !unset {
+			return fmt.Errorf("can't set a map to a value: %v", actualCurrValue)
+		}
+
+		mapKey := reflect.ValueOf(currStep.stepValue)
+		mapValueType := curr.Type().Elem().Elem()
+
+		if !steps.moreStepsRemaining() && unset {
+			actualCurrValue.SetMapIndex(mapKey, reflect.Value{})
+			return nil
+		}
+
+		currMapValue := actualCurrValue.MapIndex(mapKey)
+
+		needToSetNewMapValue := currMapValue.Kind() == reflect.Invalid
+		if needToSetNewMapValue {
+			currMapValue = reflect.New(mapValueType.Elem()).Elem().Addr()
+			actualCurrValue.SetMapIndex(mapKey, currMapValue)
+		}
+
+		err := modifyConfig(currMapValue, steps, propertyValue, unset, setRawBytes)
+		if err != nil {
+			return err
+		}
+
+		return nil
+
+	case reflect.String:
+		if steps.moreStepsRemaining() {
+			return fmt.Errorf("can't have more steps after a string. %v", steps)
+		}
+		actualCurrValue.SetString(propertyValue)
+		return nil
+
+	case reflect.Slice:
+		if steps.moreStepsRemaining() {
+			return fmt.Errorf("can't have more steps after bytes. %v", steps)
+		}
+		innerKind := actualCurrValue.Type().Elem().Kind()
+		if innerKind != reflect.Uint8 {
+			return fmt.Errorf("unrecognized slice type. %v", innerKind)
+		}
+
+		if unset {
+			actualCurrValue.Set(reflect.Zero(actualCurrValue.Type()))
+			return nil
+		}
+
+		if setRawBytes {
+			actualCurrValue.SetBytes([]byte(propertyValue))
+		} else {
+			val, err := base64.StdEncoding.DecodeString(propertyValue)
+			if err != nil {
+				return fmt.Errorf("error decoding input value: %v", err)
+			}
+			actualCurrValue.SetBytes(val)
+		}
+		return nil
+
+	case reflect.Bool:
+		if steps.moreStepsRemaining() {
+			return fmt.Errorf("can't have more steps after a bool. %v", steps)
+		}
+		boolValue, err := toBool(propertyValue)
+		if err != nil {
+			return err
+		}
+		actualCurrValue.SetBool(boolValue)
+		return nil
+
+	case reflect.Struct:
+		for fieldIndex := 0; fieldIndex < actualCurrValue.NumField(); fieldIndex++ {
+			currFieldValue := actualCurrValue.Field(fieldIndex)
+			currFieldType := actualCurrValue.Type().Field(fieldIndex)
+			currYamlTag := currFieldType.Tag.Get("json")
+			currFieldTypeYamlName := strings.Split(currYamlTag, ",")[0]
+
+			if currFieldTypeYamlName == currStep.stepValue {
+				thisMapHasNoValue := (currFieldValue.Kind() == reflect.Map && currFieldValue.IsNil())
+
+				if thisMapHasNoValue {
+					newValue := reflect.MakeMap(currFieldValue.Type())
+					currFieldValue.Set(newValue)
+
+					if !steps.moreStepsRemaining() && unset {
+						return nil
+					}
+				}
+
+				if !steps.moreStepsRemaining() && unset {
+					// if we're supposed to unset the value or if the value is a map that doesn't exist, create a new value and overwrite
+					newValue := reflect.New(currFieldValue.Type()).Elem()
+					currFieldValue.Set(newValue)
+					return nil
+				}
+
+				return modifyConfig(currFieldValue.Addr(), steps, propertyValue, unset, setRawBytes)
+			}
+		}
+
+		return fmt.Errorf("unable to locate path %#v under %v", currStep, actualCurrValue)
+
+	}
+
+	panic(fmt.Errorf("unrecognized type: %v", actualCurrValue))
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/unset.go

@@ -0,0 +1,106 @@
+/*
+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 config
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"reflect"
+
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+type unsetOptions struct {
+	configAccess clientcmd.ConfigAccess
+	propertyName string
+}
+
+var unset_long = templates.LongDesc(`
+	Unsets an individual value in a kubeconfig file
+
+	PROPERTY_NAME is a dot delimited name where each token represents either an attribute name or a map key.  Map keys may not contain dots.`)
+
+func NewCmdConfigUnset(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command {
+	options := &unsetOptions{configAccess: configAccess}
+
+	cmd := &cobra.Command{
+		Use:   "unset PROPERTY_NAME",
+		Short: "Unsets an individual value in a kubeconfig file",
+		Long:  unset_long,
+		Run: func(cmd *cobra.Command, args []string) {
+			if !options.complete(cmd) {
+				return
+			}
+
+			cmdutil.CheckErr(options.run())
+			fmt.Fprintf(out, "Property %q unset.\n", options.propertyName)
+		},
+	}
+
+	return cmd
+}
+
+func (o unsetOptions) run() error {
+	err := o.validate()
+	if err != nil {
+		return err
+	}
+
+	config, err := o.configAccess.GetStartingConfig()
+	if err != nil {
+		return err
+	}
+
+	steps, err := newNavigationSteps(o.propertyName)
+	if err != nil {
+		return err
+	}
+	err = modifyConfig(reflect.ValueOf(config), steps, "", true, true)
+	if err != nil {
+		return err
+	}
+
+	if err := clientcmd.ModifyConfig(o.configAccess, *config, false); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (o *unsetOptions) complete(cmd *cobra.Command) bool {
+	endingArgs := cmd.Flags().Args()
+	if len(endingArgs) != 1 {
+		cmd.Help()
+		return false
+	}
+
+	o.propertyName = endingArgs[0]
+	return true
+}
+
+func (o unsetOptions) validate() error {
+	if len(o.propertyName) == 0 {
+		return errors.New("you must specify a property")
+	}
+
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/use_context.go

@@ -0,0 +1,99 @@
+/*
+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 config
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+type useContextOptions struct {
+	configAccess clientcmd.ConfigAccess
+	contextName  string
+}
+
+func NewCmdConfigUseContext(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command {
+	options := &useContextOptions{configAccess: configAccess}
+
+	cmd := &cobra.Command{
+		Use:   "use-context CONTEXT_NAME",
+		Short: "Sets the current-context in a kubeconfig file",
+		Long:  `Sets the current-context in a kubeconfig file`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if !options.complete(cmd) {
+				return
+			}
+
+			cmdutil.CheckErr(options.run())
+			fmt.Fprintf(out, "Switched to context %q.\n", options.contextName)
+		},
+	}
+
+	return cmd
+}
+
+func (o useContextOptions) run() error {
+	config, err := o.configAccess.GetStartingConfig()
+	if err != nil {
+		return err
+	}
+
+	err = o.validate(config)
+	if err != nil {
+		return err
+	}
+
+	config.CurrentContext = o.contextName
+
+	if err := clientcmd.ModifyConfig(o.configAccess, *config, true); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (o *useContextOptions) complete(cmd *cobra.Command) bool {
+	endingArgs := cmd.Flags().Args()
+	if len(endingArgs) != 1 {
+		cmd.Help()
+		return false
+	}
+
+	o.contextName = endingArgs[0]
+	return true
+}
+
+func (o useContextOptions) validate(config *clientcmdapi.Config) error {
+	if len(o.contextName) == 0 {
+		return errors.New("you must specify a current-context")
+	}
+
+	for name := range config.Contexts {
+		if name == o.contextName {
+			return nil
+		}
+	}
+
+	return fmt.Errorf("no context exists with the name: %q.", o.contextName)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/config/view.go

@@ -0,0 +1,166 @@
+/*
+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 config
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api/latest"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/util/flag"
+)
+
+type ViewOptions struct {
+	ConfigAccess clientcmd.ConfigAccess
+	Merge        flag.Tristate
+	Flatten      bool
+	Minify       bool
+	RawByteData  bool
+}
+
+var (
+	view_long = templates.LongDesc(`
+		Display merged kubeconfig settings or a specified kubeconfig file.
+
+		You can use --output jsonpath={...} to extract specific values using a jsonpath expression.`)
+
+	view_example = templates.Examples(`
+		# Show Merged kubeconfig settings.
+		kubectl config view
+
+		# Get the password for the e2e user
+		kubectl config view -o jsonpath='{.users[?(@.name == "e2e")].user.password}'`)
+)
+
+func NewCmdConfigView(out io.Writer, ConfigAccess clientcmd.ConfigAccess) *cobra.Command {
+	options := &ViewOptions{ConfigAccess: ConfigAccess}
+	// Default to yaml
+	defaultOutputFormat := "yaml"
+
+	cmd := &cobra.Command{
+		Use:     "view",
+		Short:   "Display merged kubeconfig settings or a specified kubeconfig file",
+		Long:    view_long,
+		Example: view_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			options.Complete()
+			outputFormat := cmdutil.GetFlagString(cmd, "output")
+			if outputFormat == "wide" {
+				fmt.Printf("--output wide is not available in kubectl config view; reset to default output format (%s)\n\n", defaultOutputFormat)
+				cmd.Flags().Set("output", defaultOutputFormat)
+			}
+			if outputFormat == "" {
+				fmt.Printf("Reset to default output format (%s) as --output is empty\n", defaultOutputFormat)
+				cmd.Flags().Set("output", defaultOutputFormat)
+			}
+
+			printer, _, err := cmdutil.PrinterForCommand(cmd)
+			cmdutil.CheckErr(err)
+			version, err := cmdutil.OutputVersion(cmd, &latest.ExternalVersion)
+			cmdutil.CheckErr(err)
+			printer = kubectl.NewVersionedPrinter(printer, latest.Scheme, version)
+
+			cmdutil.CheckErr(options.Run(out, printer))
+		},
+	}
+
+	cmdutil.AddPrinterFlags(cmd)
+	cmd.Flags().Set("output", defaultOutputFormat)
+
+	options.Merge.Default(true)
+	f := cmd.Flags().VarPF(&options.Merge, "merge", "", "merge the full hierarchy of kubeconfig files")
+	f.NoOptDefVal = "true"
+	cmd.Flags().BoolVar(&options.RawByteData, "raw", false, "display raw byte data")
+	cmd.Flags().BoolVar(&options.Flatten, "flatten", false, "flatten the resulting kubeconfig file into self-contained output (useful for creating portable kubeconfig files)")
+	cmd.Flags().BoolVar(&options.Minify, "minify", false, "remove all information not used by current-context from the output")
+	return cmd
+}
+
+func (o ViewOptions) Run(out io.Writer, printer kubectl.ResourcePrinter) error {
+	config, err := o.loadConfig()
+	if err != nil {
+		return err
+	}
+
+	if o.Minify {
+		if err := clientcmdapi.MinifyConfig(config); err != nil {
+			return err
+		}
+	}
+
+	if o.Flatten {
+		if err := clientcmdapi.FlattenConfig(config); err != nil {
+			return err
+		}
+	} else if !o.RawByteData {
+		clientcmdapi.ShortenConfig(config)
+	}
+
+	err = printer.PrintObj(config, out)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (o *ViewOptions) Complete() bool {
+	if o.ConfigAccess.IsExplicitFile() {
+		if !o.Merge.Provided() {
+			o.Merge.Set("false")
+		}
+	}
+
+	return true
+}
+
+func (o ViewOptions) loadConfig() (*clientcmdapi.Config, error) {
+	err := o.Validate()
+	if err != nil {
+		return nil, err
+	}
+
+	config, err := o.getStartingConfig()
+	return config, err
+}
+
+func (o ViewOptions) Validate() error {
+	if !o.Merge.Value() && !o.ConfigAccess.IsExplicitFile() {
+		return errors.New("if merge==false a precise file must to specified")
+	}
+
+	return nil
+}
+
+// getStartingConfig returns the Config object built from the sources specified by the options, the filename read (only if it was a single file), and an error if something goes wrong
+func (o *ViewOptions) getStartingConfig() (*clientcmdapi.Config, error) {
+	switch {
+	case !o.Merge.Value():
+		return clientcmd.LoadFromFile(o.ConfigAccess.GetExplicitFile())
+
+	default:
+		return o.ConfigAccess.GetStartingConfig()
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/convert.go

@@ -0,0 +1,193 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/runtime/schema"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	convert_long = templates.LongDesc(`
+		Convert config files between different API versions. Both YAML
+		and JSON formats are accepted.
+
+		The command takes filename, directory, or URL as input, and convert it into format
+		of version specified by --output-version flag. If target version is not specified or
+		not supported, convert to latest version.
+
+		The default output will be printed to stdout in YAML format. One can use -o option
+		to change to output destination.`)
+
+	convert_example = templates.Examples(`
+		# Convert 'pod.yaml' to latest version and print to stdout.
+		kubectl convert -f pod.yaml
+
+		# Convert the live state of the resource specified by 'pod.yaml' to the latest version
+		# and print to stdout in json format.
+		kubectl convert -f pod.yaml --local -o json
+
+		# Convert all files under current directory to latest version and create them all.
+		kubectl convert -f . | kubectl create -f -`)
+)
+
+// NewCmdConvert creates a command object for the generic "convert" action, which
+// translates the config file into a given version.
+func NewCmdConvert(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &ConvertOptions{}
+
+	cmd := &cobra.Command{
+		Use:     "convert -f FILENAME",
+		Short:   "Convert config files between different API versions",
+		Long:    convert_long,
+		Example: convert_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := options.Complete(f, out, cmd, args)
+			cmdutil.CheckErr(err)
+			err = options.RunConvert()
+			cmdutil.CheckErr(err)
+		},
+	}
+
+	usage := "to need to get converted."
+	cmdutil.AddFilenameOptionFlags(cmd, &options.FilenameOptions, usage)
+	cmd.MarkFlagRequired("filename")
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmd.Flags().BoolVar(&options.local, "local", true, "If true, convert will NOT try to contact api-server but run locally.")
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+	return cmd
+}
+
+// ConvertOptions have the data required to perform the convert operation
+type ConvertOptions struct {
+	resource.FilenameOptions
+
+	builder *resource.Builder
+	local   bool
+
+	encoder runtime.Encoder
+	out     io.Writer
+	printer kubectl.ResourcePrinter
+
+	outputVersion schema.GroupVersion
+}
+
+// Complete collects information required to run Convert command from command line.
+func (o *ConvertOptions) Complete(f cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string) (err error) {
+	o.outputVersion, err = cmdutil.OutputVersion(cmd, &registered.EnabledVersionsForGroup(api.GroupName)[0])
+	if err != nil {
+		return err
+	}
+	if !registered.IsEnabledVersion(o.outputVersion) {
+		cmdutil.UsageError(cmd, "'%s' is not a registered version.", o.outputVersion)
+	}
+
+	// build the builder
+	mapper, typer := f.Object()
+	clientMapper := resource.ClientMapperFunc(f.ClientForMapping)
+
+	if o.local {
+		fmt.Fprintln(os.Stderr, "running in local mode...")
+		o.builder = resource.NewBuilder(mapper, typer, resource.DisabledClientForMapping{ClientMapper: clientMapper}, f.Decoder(true))
+	} else {
+		o.builder = resource.NewBuilder(mapper, typer, clientMapper, f.Decoder(true))
+		schema, err := f.Validator(cmdutil.GetFlagBool(cmd, "validate"), cmdutil.GetFlagString(cmd, "schema-cache-dir"))
+		if err != nil {
+			return err
+		}
+		o.builder = o.builder.Schema(schema)
+	}
+	cmdNamespace, _, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+	o.builder = o.builder.NamespaceParam(cmdNamespace).
+		ContinueOnError().
+		FilenameParam(false, &o.FilenameOptions).
+		Flatten()
+
+	// build the printer
+	o.out = out
+	outputFormat := cmdutil.GetFlagString(cmd, "output")
+	templateFile := cmdutil.GetFlagString(cmd, "template")
+	if len(outputFormat) == 0 {
+		if len(templateFile) == 0 {
+			outputFormat = "yaml"
+		} else {
+			outputFormat = "template"
+		}
+	}
+	o.encoder = f.JSONEncoder()
+	o.printer, _, err = kubectl.GetPrinter(outputFormat, templateFile, false)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// RunConvert implements the generic Convert command
+func (o *ConvertOptions) RunConvert() error {
+	r := o.builder.Do()
+	err := r.Err()
+	if err != nil {
+		return err
+	}
+
+	singular := false
+	infos, err := r.IntoSingular(&singular).Infos()
+	if err != nil {
+		return err
+	}
+
+	if len(infos) == 0 {
+		return fmt.Errorf("no objects passed to convert")
+	}
+
+	objects, err := resource.AsVersionedObject(infos, !singular, o.outputVersion, o.encoder)
+	if err != nil {
+		return err
+	}
+
+	if meta.IsListType(objects) {
+		_, items, err := cmdutil.FilterResourceList(objects, nil, nil)
+		if err != nil {
+			return err
+		}
+		filteredObj, err := cmdutil.ObjectListToVersionedObject(items, o.outputVersion)
+		if err != nil {
+			return err
+		}
+		return o.printer.PrintObj(filteredObj, o.out)
+	}
+
+	return o.printer.PrintObj(objects, o.out)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/cp.go

@@ -0,0 +1,303 @@
+/*
+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 cmd
+
+import (
+	"archive/tar"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+	"strings"
+
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+
+	"github.com/renstrom/dedent"
+	"github.com/spf13/cobra"
+)
+
+var (
+	cp_example = templates.Examples(`
+	    # !!!Important Note!!!
+	    # Requires that the 'tar' binary is present in your container
+	    # image.  If 'tar' is not present, 'kubectl cp' will fail.
+
+	    # Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod in the default namespace
+		kubectl cp /tmp/foo_dir <some-pod>:/tmp/bar_dir
+
+        # Copy /tmp/foo local file to /tmp/bar in a remote pod in a specific container
+		kubectl cp /tmp/foo <some-pod>:/tmp/bar -c <specific-container>
+
+		# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace <some-namespace>
+		kubectl cp /tmp/foo <some-namespace>/<some-pod>:/tmp/bar
+
+		# Copy /tmp/foo from a remote pod to /tmp/bar locally
+		kubectl cp <some-namespace>/<some-pod>:/tmp/foo /tmp/bar`)
+
+	cpUsageStr = dedent.Dedent(`
+	    expected 'cp <file-spec-src> <file-spec-dest> [-c container]'.
+	    <file-spec> is:
+		[namespace/]pod-name:/file/path for a remote file
+		/file/path for a local file`)
+)
+
+// NewCmdCp creates a new Copy command.
+func NewCmdCp(f cmdutil.Factory, cmdIn io.Reader, cmdOut, cmdErr io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "cp <file-spec-src> <file-spec-dest>",
+		Short:   "Copy files and directories to and from containers.",
+		Long:    "Copy files and directories to and from containers.",
+		Example: cp_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(runCopy(f, cmd, cmdOut, cmdErr, args))
+		},
+	}
+	cmd.Flags().StringP("container", "c", "", "Container name. If omitted, the first container in the pod will be chosen")
+
+	return cmd
+}
+
+type fileSpec struct {
+	PodNamespace string
+	PodName      string
+	File         string
+}
+
+func extractFileSpec(arg string) (fileSpec, error) {
+	pieces := strings.Split(arg, ":")
+	if len(pieces) == 1 {
+		return fileSpec{File: arg}, nil
+	}
+	if len(pieces) != 2 {
+		return fileSpec{}, fmt.Errorf("Unexpected fileSpec: %s, expected [[namespace/]pod:]file/path", arg)
+	}
+	file := pieces[1]
+
+	pieces = strings.Split(pieces[0], "/")
+	if len(pieces) == 1 {
+		return fileSpec{
+			PodName: pieces[0],
+			File:    file,
+		}, nil
+	}
+	if len(pieces) == 2 {
+		return fileSpec{
+			PodNamespace: pieces[0],
+			PodName:      pieces[1],
+			File:         file,
+		}, nil
+	}
+
+	return fileSpec{}, fmt.Errorf("Unexpected file spec: %s, expected [[namespace/]pod:]file/path", arg)
+}
+
+func runCopy(f cmdutil.Factory, cmd *cobra.Command, out, cmderr io.Writer, args []string) error {
+	if len(args) != 2 {
+		return cmdutil.UsageError(cmd, cpUsageStr)
+	}
+	srcSpec, err := extractFileSpec(args[0])
+	if err != nil {
+		return err
+	}
+	destSpec, err := extractFileSpec(args[1])
+	if err != nil {
+		return err
+	}
+	if len(srcSpec.PodName) != 0 {
+		return copyFromPod(f, cmd, out, cmderr, srcSpec, destSpec)
+	}
+	if len(destSpec.PodName) != 0 {
+		return copyToPod(f, cmd, out, cmderr, srcSpec, destSpec)
+	}
+	return cmdutil.UsageError(cmd, "One of src or dest must be a remote file specification")
+}
+
+func copyToPod(f cmdutil.Factory, cmd *cobra.Command, stdout, stderr io.Writer, src, dest fileSpec) error {
+	reader, writer := io.Pipe()
+	go func() {
+		defer writer.Close()
+		err := makeTar(src.File, writer)
+		cmdutil.CheckErr(err)
+	}()
+
+	// TODO: Improve error messages by first testing if 'tar' is present in the container?
+	cmdArr := []string{"tar", "xf", "-"}
+	destDir := path.Dir(dest.File)
+	if len(destDir) > 0 {
+		cmdArr = append(cmdArr, "-C", destDir)
+	}
+
+	options := &ExecOptions{
+		StreamOptions: StreamOptions{
+			In:    reader,
+			Out:   stdout,
+			Err:   stderr,
+			Stdin: true,
+
+			Namespace: dest.PodNamespace,
+			PodName:   dest.PodName,
+		},
+
+		Command:  cmdArr,
+		Executor: &DefaultRemoteExecutor{},
+	}
+	return execute(f, cmd, options)
+}
+
+func copyFromPod(f cmdutil.Factory, cmd *cobra.Command, out, cmderr io.Writer, src, dest fileSpec) error {
+	reader, outStream := io.Pipe()
+	options := &ExecOptions{
+		StreamOptions: StreamOptions{
+			In:  nil,
+			Out: outStream,
+			Err: cmderr,
+
+			Namespace: src.PodNamespace,
+			PodName:   src.PodName,
+		},
+
+		// TODO: Improve error messages by first testing if 'tar' is present in the container?
+		Command:  []string{"tar", "cf", "-", src.File},
+		Executor: &DefaultRemoteExecutor{},
+	}
+
+	go func() {
+		defer outStream.Close()
+		execute(f, cmd, options)
+	}()
+	prefix := getPrefix(src.File)
+
+	return untarAll(reader, dest.File, prefix)
+}
+
+func makeTar(filepath string, writer io.Writer) error {
+	// TODO: use compression here?
+	tarWriter := tar.NewWriter(writer)
+	defer tarWriter.Close()
+	return recursiveTar(path.Dir(filepath), path.Base(filepath), tarWriter)
+}
+
+func recursiveTar(base, file string, tw *tar.Writer) error {
+	filepath := path.Join(base, file)
+	stat, err := os.Stat(filepath)
+	if err != nil {
+		return err
+	}
+	if stat.IsDir() {
+		files, err := ioutil.ReadDir(filepath)
+		if err != nil {
+			return err
+		}
+		for _, f := range files {
+			if err := recursiveTar(base, path.Join(file, f.Name()), tw); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	hdr, err := tar.FileInfoHeader(stat, filepath)
+	if err != nil {
+		return err
+	}
+	hdr.Name = file
+	if err := tw.WriteHeader(hdr); err != nil {
+		return err
+	}
+	f, err := os.Open(filepath)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	_, err = io.Copy(tw, f)
+	return err
+}
+
+func untarAll(reader io.Reader, destFile, prefix string) error {
+	// TODO: use compression here?
+	tarReader := tar.NewReader(reader)
+	for {
+		header, err := tarReader.Next()
+		if err != nil {
+			if err != io.EOF {
+				return err
+			}
+			break
+		}
+		outFileName := path.Join(destFile, header.Name[len(prefix):])
+		baseName := path.Dir(outFileName)
+		if err := os.MkdirAll(baseName, 0755); err != nil {
+			return err
+		}
+		if header.FileInfo().IsDir() {
+			os.MkdirAll(outFileName, 0755)
+			continue
+		}
+		outFile, err := os.Create(outFileName)
+		if err != nil {
+			return err
+		}
+		defer outFile.Close()
+		io.Copy(outFile, tarReader)
+	}
+	return nil
+}
+
+func getPrefix(file string) string {
+	if file[0] == '/' {
+		// tar strips the leading '/' if it's there, so we will too
+		return file[1:]
+	}
+	return file
+}
+
+func execute(f cmdutil.Factory, cmd *cobra.Command, options *ExecOptions) error {
+	if len(options.Namespace) == 0 {
+		namespace, _, err := f.DefaultNamespace()
+		if err != nil {
+			return err
+		}
+		options.Namespace = namespace
+	}
+
+	container := cmdutil.GetFlagString(cmd, "container")
+	if len(container) > 0 {
+		options.ContainerName = container
+	}
+
+	config, err := f.ClientConfig()
+	if err != nil {
+		return err
+	}
+	options.Config = config
+
+	clientset, err := f.ClientSet()
+	if err != nil {
+		return err
+	}
+	options.PodClient = clientset.Core()
+
+	if err := options.Validate(); err != nil {
+		return err
+	}
+
+	if err := options.Run(); err != nil {
+		return err
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/cp_test.go

@@ -0,0 +1,180 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+	"testing"
+)
+
+func TestExtractFileSpec(t *testing.T) {
+	tests := []struct {
+		spec              string
+		expectedPod       string
+		expectedNamespace string
+		expectedFile      string
+		expectErr         bool
+	}{
+		{
+			spec:              "namespace/pod:/some/file",
+			expectedPod:       "pod",
+			expectedNamespace: "namespace",
+			expectedFile:      "/some/file",
+		},
+		{
+			spec:         "pod:/some/file",
+			expectedPod:  "pod",
+			expectedFile: "/some/file",
+		},
+		{
+			spec:         "/some/file",
+			expectedFile: "/some/file",
+		},
+		{
+			spec:      "some:bad:spec",
+			expectErr: true,
+		},
+	}
+	for _, test := range tests {
+		spec, err := extractFileSpec(test.spec)
+		if test.expectErr && err == nil {
+			t.Errorf("unexpected non-error")
+			continue
+		}
+		if err != nil && !test.expectErr {
+			t.Errorf("unexpected error: %v", err)
+			continue
+		}
+		if spec.PodName != test.expectedPod {
+			t.Errorf("expected: %s, saw: %s", test.expectedPod, spec.PodName)
+		}
+		if spec.PodNamespace != test.expectedNamespace {
+			t.Errorf("expected: %s, saw: %s", test.expectedNamespace, spec.PodNamespace)
+		}
+		if spec.File != test.expectedFile {
+			t.Errorf("expected: %s, saw: %s", test.expectedFile, spec.File)
+		}
+	}
+}
+
+func TestGetPrefix(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{
+			input:    "/foo/bar",
+			expected: "foo/bar",
+		},
+		{
+			input:    "foo/bar",
+			expected: "foo/bar",
+		},
+	}
+	for _, test := range tests {
+		out := getPrefix(test.input)
+		if out != test.expected {
+			t.Errorf("expected: %s, saw: %s", test.expected, out)
+		}
+	}
+}
+
+func TestTarUntar(t *testing.T) {
+	dir, err := ioutil.TempDir(os.TempDir(), "input")
+	dir2, err2 := ioutil.TempDir(os.TempDir(), "output")
+	if err != nil || err2 != nil {
+		t.Errorf("unexpected error: %v | %v", err, err2)
+		t.FailNow()
+	}
+	defer func() {
+		if err := os.RemoveAll(dir); err != nil {
+			t.Errorf("Unexpected error cleaning up: %v", err)
+		}
+		if err := os.RemoveAll(dir2); err != nil {
+			t.Errorf("Unexpected error cleaning up: %v", err)
+		}
+	}()
+
+	files := []struct {
+		name string
+		data string
+	}{
+		{
+			name: "foo",
+			data: "foobarbaz",
+		},
+		{
+			name: "dir/blah",
+			data: "bazblahfoo",
+		},
+		{
+			name: "some/other/directory",
+			data: "with more data here",
+		},
+		{
+			name: "blah",
+			data: "same file name different data",
+		},
+	}
+
+	for _, file := range files {
+		filepath := path.Join(dir, file.name)
+		if err := os.MkdirAll(path.Dir(filepath), 0755); err != nil {
+			t.Errorf("unexpected error: %v", err)
+			t.FailNow()
+		}
+		f, err := os.Create(filepath)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			t.FailNow()
+		}
+		defer f.Close()
+		if _, err := io.Copy(f, bytes.NewBuffer([]byte(file.data))); err != nil {
+			t.Errorf("unexpected error: %v", err)
+			t.FailNow()
+		}
+	}
+
+	writer := &bytes.Buffer{}
+	if err := makeTar(dir, writer); err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	reader := bytes.NewBuffer(writer.Bytes())
+	if err := untarAll(reader, dir2, ""); err != nil {
+		t.Errorf("unexpected error: %v", err)
+		t.FailNow()
+	}
+
+	for _, file := range files {
+		filepath := path.Join(dir, file.name)
+		f, err := os.Open(filepath)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		defer f.Close()
+		buff := &bytes.Buffer{}
+		io.Copy(buff, f)
+		if file.data != string(buff.Bytes()) {
+			t.Errorf("expected: %s, saw: %s", file.data, string(buff.Bytes()))
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create.go

@@ -0,0 +1,256 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	gruntime "runtime"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/runtime/schema"
+)
+
+var (
+	create_long = templates.LongDesc(`
+		Create a resource by filename or stdin.
+
+		JSON and YAML formats are accepted.`)
+
+	create_example = templates.Examples(`
+		# Create a pod using the data in pod.json.
+		kubectl create -f ./pod.json
+
+		# Create a pod based on the JSON passed into stdin.
+		cat pod.json | kubectl create -f -
+
+		# Edit the data in docker-registry.yaml in JSON using the v1 API format then create the resource using the edited data.
+		kubectl create -f docker-registry.yaml --edit --output-version=v1 -o json`)
+)
+
+func NewCmdCreate(f cmdutil.Factory, out, errOut io.Writer) *cobra.Command {
+	options := &resource.FilenameOptions{}
+
+	cmd := &cobra.Command{
+		Use:     "create -f FILENAME",
+		Short:   "Create a resource by filename or stdin",
+		Long:    create_long,
+		Example: create_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			if cmdutil.IsFilenameEmpty(options.Filenames) {
+				defaultRunFunc := cmdutil.DefaultSubCommandRun(errOut)
+				defaultRunFunc(cmd, args)
+				return
+			}
+			cmdutil.CheckErr(ValidateArgs(cmd, args))
+			cmdutil.CheckErr(RunCreate(f, cmd, out, errOut, options))
+		},
+	}
+
+	usage := "to use to create the resource"
+	cmdutil.AddFilenameOptionFlags(cmd, options, usage)
+	cmd.MarkFlagRequired("filename")
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmd.Flags().Bool("edit", false, "Edit the API resource before creating")
+	cmd.Flags().Bool("windows-line-endings", gruntime.GOOS == "windows", "Only relevant if --edit=true. Use Windows line-endings (default Unix line-endings)")
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddRecordFlag(cmd)
+	cmdutil.AddDryRunFlag(cmd)
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+
+	// create subcommands
+	cmd.AddCommand(NewCmdCreateNamespace(f, out))
+	cmd.AddCommand(NewCmdCreateQuota(f, out))
+	cmd.AddCommand(NewCmdCreateSecret(f, out, errOut))
+	cmd.AddCommand(NewCmdCreateConfigMap(f, out))
+	cmd.AddCommand(NewCmdCreateServiceAccount(f, out))
+	cmd.AddCommand(NewCmdCreateService(f, out, errOut))
+	cmd.AddCommand(NewCmdCreateDeployment(f, out))
+	cmd.AddCommand(NewCmdCreateClusterRoleBinding(f, out))
+	cmd.AddCommand(NewCmdCreatePodDisruptionBudget(f, out))
+	return cmd
+}
+
+func ValidateArgs(cmd *cobra.Command, args []string) error {
+	if len(args) != 0 {
+		return cmdutil.UsageError(cmd, "Unexpected args: %v", args)
+	}
+	return nil
+}
+
+func RunCreate(f cmdutil.Factory, cmd *cobra.Command, out, errOut io.Writer, options *resource.FilenameOptions) error {
+	if cmdutil.GetFlagBool(cmd, "edit") {
+		return RunEditOnCreate(f, out, errOut, cmd, options)
+	}
+	schema, err := f.Validator(cmdutil.GetFlagBool(cmd, "validate"), cmdutil.GetFlagString(cmd, "schema-cache-dir"))
+	if err != nil {
+		return err
+	}
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	mapper, typer, err := f.UnstructuredObject()
+	if err != nil {
+		return err
+	}
+	r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.UnstructuredClientForMapping), runtime.UnstructuredJSONScheme).
+		Schema(schema).
+		ContinueOnError().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, options).
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	dryRun := cmdutil.GetFlagBool(cmd, "dry-run")
+
+	count := 0
+	err = r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+		if err := kubectl.CreateOrUpdateAnnotation(cmdutil.GetFlagBool(cmd, cmdutil.ApplyAnnotationsFlag), info, f.JSONEncoder()); err != nil {
+			return cmdutil.AddSourceToErr("creating", info.Source, err)
+		}
+
+		if cmdutil.ShouldRecord(cmd, info) {
+			if err := cmdutil.RecordChangeCause(info.Object, f.Command()); err != nil {
+				return cmdutil.AddSourceToErr("creating", info.Source, err)
+			}
+		}
+
+		if !dryRun {
+			if err := createAndRefresh(info); err != nil {
+				return cmdutil.AddSourceToErr("creating", info.Source, err)
+			}
+		}
+
+		count++
+		shortOutput := cmdutil.GetFlagString(cmd, "output") == "name"
+		if !shortOutput {
+			f.PrintObjectSpecificMessage(info.Object, out)
+		}
+
+		cmdutil.PrintSuccess(mapper, shortOutput, out, info.Mapping.Resource, info.Name, dryRun, "created")
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	if count == 0 {
+		return fmt.Errorf("no objects passed to create")
+	}
+	return nil
+}
+
+func RunEditOnCreate(f cmdutil.Factory, out, errOut io.Writer, cmd *cobra.Command, options *resource.FilenameOptions) error {
+	return runEdit(f, out, errOut, cmd, []string{}, options, EditBeforeCreateMode)
+}
+
+// createAndRefresh creates an object from input info and refreshes info with that object
+func createAndRefresh(info *resource.Info) error {
+	obj, err := resource.NewHelper(info.Client, info.Mapping).Create(info.Namespace, true, info.Object)
+	if err != nil {
+		return err
+	}
+	info.Refresh(obj, true)
+	return nil
+}
+
+// NameFromCommandArgs is a utility function for commands that assume the first argument is a resource name
+func NameFromCommandArgs(cmd *cobra.Command, args []string) (string, error) {
+	if len(args) == 0 {
+		return "", cmdutil.UsageError(cmd, "NAME is required")
+	}
+	return args[0], nil
+}
+
+// CreateSubcommandOptions is an options struct to support create subcommands
+type CreateSubcommandOptions struct {
+	// Name of resource being created
+	Name string
+	// StructuredGenerator is the resource generator for the object being created
+	StructuredGenerator kubectl.StructuredGenerator
+	// DryRun is true if the command should be simulated but not run against the server
+	DryRun bool
+	// OutputFormat
+	OutputFormat string
+}
+
+// RunCreateSubcommand executes a create subcommand using the specified options
+func RunCreateSubcommand(f cmdutil.Factory, cmd *cobra.Command, out io.Writer, options *CreateSubcommandOptions) error {
+	namespace, _, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+	obj, err := options.StructuredGenerator.StructuredGenerate()
+	if err != nil {
+		return err
+	}
+	mapper, typer := f.Object()
+	gvks, _, err := typer.ObjectKinds(obj)
+	if err != nil {
+		return err
+	}
+	gvk := gvks[0]
+	mapping, err := mapper.RESTMapping(schema.GroupKind{Group: gvk.Group, Kind: gvk.Kind}, gvk.Version)
+	if err != nil {
+		return err
+	}
+	client, err := f.ClientForMapping(mapping)
+	if err != nil {
+		return err
+	}
+	resourceMapper := &resource.Mapper{
+		ObjectTyper:  typer,
+		RESTMapper:   mapper,
+		ClientMapper: resource.ClientMapperFunc(f.ClientForMapping),
+	}
+	info, err := resourceMapper.InfoForObject(obj, nil)
+	if err != nil {
+		return err
+	}
+	if err := kubectl.UpdateApplyAnnotation(info, f.JSONEncoder()); err != nil {
+		return err
+	}
+	if !options.DryRun {
+		obj, err = resource.NewHelper(client, mapping).Create(namespace, false, info.Object)
+		if err != nil {
+			return err
+		}
+	}
+
+	if useShortOutput := options.OutputFormat == "name"; useShortOutput || len(options.OutputFormat) == 0 {
+		cmdutil.PrintSuccess(mapper, useShortOutput, out, mapping.Resource, options.Name, options.DryRun, "created")
+		return nil
+	}
+
+	return f.PrintObject(cmd, mapper, obj, out)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_clusterrolebinding.go

@@ -0,0 +1,86 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+var (
+	clusterRoleBindingLong = templates.LongDesc(`
+		Create a ClusterRoleBinding for a particular ClusterRole.`)
+
+	clusterRoleBindingExample = templates.Examples(`
+		  # Create a ClusterRoleBinding for user1, user2, and group1 using the cluster-admin ClusterRole
+		  kubectl create clusterrolebinding cluster-admin --clusterrole=cluster-admin --user=user1 --user=user2 --group=group1`)
+)
+
+// ClusterRoleBinding is a command to ease creating ClusterRoleBindings.
+func NewCmdCreateClusterRoleBinding(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "clusterrolebinding NAME --clusterrole=NAME [--user=username] [--group=groupname] [--dry-run]",
+		Aliases: []string{"cm"},
+		Short:   "Create a ClusterRoleBinding for a particular ClusterRole",
+		Long:    clusterRoleBindingLong,
+		Example: clusterRoleBindingExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateClusterRoleBinding(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.ClusterRoleBindingV1GeneratorName)
+	cmd.Flags().String("clusterrole", "", "ClusterRole this ClusterRoleBinding should reference")
+	cmd.Flags().StringSlice("user", []string{}, "usernames to bind to the role")
+	cmd.Flags().StringSlice("group", []string{}, "groups to bind to the role")
+	return cmd
+}
+
+// CreateClusterRoleBinding is the implementation of the create configmap command.
+func CreateClusterRoleBinding(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.ClusterRoleBindingV1GeneratorName:
+		generator = &kubectl.ClusterRoleBindingGeneratorV1{
+			Name:        name,
+			ClusterRole: cmdutil.GetFlagString(cmd, "clusterrole"),
+			Users:       cmdutil.GetFlagStringSlice(cmd, "user"),
+			Groups:      cmdutil.GetFlagStringSlice(cmd, "group"),
+		}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetDryRunFlag(cmd),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_configmap.go

@@ -0,0 +1,99 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+var (
+	configMapLong = templates.LongDesc(`
+		Create a configmap based on a file, directory, or specified literal value.
+
+		A single configmap may package one or more key/value pairs.
+
+		When creating a configmap based on a file, the key will default to the basename of the file, and the value will
+		default to the file content.  If the basename is an invalid key, you may specify an alternate key.
+
+		When creating a configmap based on a directory, each file whose basename is a valid key in the directory will be
+		packaged into the configmap.  Any directory entries except regular files are ignored (e.g. subdirectories,
+		symlinks, devices, pipes, etc).`)
+
+	configMapExample = templates.Examples(`
+		  # Create a new configmap named my-config with keys for each file in folder bar
+		  kubectl create configmap my-config --from-file=path/to/bar
+
+		  # Create a new configmap named my-config with specified keys instead of names on disk
+		  kubectl create configmap my-config --from-file=key1=/path/to/bar/file1.txt --from-file=key2=/path/to/bar/file2.txt
+
+		  # Create a new configmap named my-config with key1=config1 and key2=config2
+		  kubectl create configmap my-config --from-literal=key1=config1 --from-literal=key2=config2`)
+)
+
+// ConfigMap is a command to ease creating ConfigMaps.
+func NewCmdCreateConfigMap(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "configmap NAME [--from-file=[key=]source] [--from-literal=key1=value1] [--dry-run]",
+		Aliases: []string{"cm"},
+		Short:   "Create a configmap from a local file, directory or literal value",
+		Long:    configMapLong,
+		Example: configMapExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateConfigMap(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.ConfigMapV1GeneratorName)
+	cmd.Flags().StringSlice("from-file", []string{}, "Key files can be specified using their file path, in which case a default name will be given to them, or optionally with a name and file path, in which case the given name will be used.  Specifying a directory will iterate each named file in the directory that is a valid configmap key.")
+	cmd.Flags().StringArray("from-literal", []string{}, "Specify a key and literal value to insert in configmap (i.e. mykey=somevalue)")
+	return cmd
+}
+
+// CreateConfigMap is the implementation of the create configmap command.
+func CreateConfigMap(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.ConfigMapV1GeneratorName:
+		generator = &kubectl.ConfigMapGeneratorV1{
+			Name:           name,
+			FileSources:    cmdutil.GetFlagStringSlice(cmd, "from-file"),
+			LiteralSources: cmdutil.GetFlagStringArray(cmd, "from-literal"),
+		}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetDryRunFlag(cmd),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_configmap_test.go

@@ -0,0 +1,55 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestCreateConfigMap(t *testing.T) {
+	configMap := &api.ConfigMap{}
+	configMap.Name = "my-configmap"
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/configmaps" && m == "POST":
+				return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, configMap)}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdCreateConfigMap(f, buf)
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{configMap.Name})
+	expectedOutput := "configmap/" + configMap.Name + "\n"
+	if buf.String() != expectedOutput {
+		t.Errorf("expected output: %s, but got: %s", buf.String(), expectedOutput)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_deployment.go

@@ -0,0 +1,80 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+var (
+	deploymentLong = templates.LongDesc(`
+    Create a deployment with the specified name.`)
+
+	deploymentExample = templates.Examples(`
+    # Create a new deployment named my-dep that runs the busybox image.
+    kubectl create deployment my-dep --image=busybox`)
+)
+
+// NewCmdCreateDeployment is a macro command to create a new deployment
+func NewCmdCreateDeployment(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "deployment NAME --image=image [--dry-run]",
+		Aliases: []string{"deploy"},
+		Short:   "Create a deployment with the specified name.",
+		Long:    deploymentLong,
+		Example: deploymentExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateDeployment(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.DeploymentBasicV1Beta1GeneratorName)
+	cmd.Flags().StringSlice("image", []string{}, "Image name to run.")
+	cmd.MarkFlagRequired("image")
+	return cmd
+}
+
+// CreateDeployment implements the behavior to run the create deployment command
+func CreateDeployment(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.DeploymentBasicV1Beta1GeneratorName:
+		generator = &kubectl.DeploymentBasicGeneratorV1{Name: name, Images: cmdutil.GetFlagStringSlice(cmd, "image")}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetDryRunFlag(cmd),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_deployment_test.go

@@ -0,0 +1,56 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestCreateDeployment(t *testing.T) {
+	depName := "jonny-dep"
+	f, tf, _, _ := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdCreateDeployment(f, buf)
+	cmd.Flags().Set("dry-run", "true")
+	cmd.Flags().Set("output", "name")
+	cmd.Flags().Set("image", "hollywood/jonny.depp:v2")
+	cmd.Run(cmd, []string{depName})
+	expectedOutput := "deployment/" + depName + "\n"
+	if buf.String() != expectedOutput {
+		t.Errorf("expected output: %s, but got: %s", expectedOutput, buf.String())
+	}
+}
+
+func TestCreateDeploymentNoImage(t *testing.T) {
+	depName := "jonny-dep"
+	f, tf, _, _ := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdCreateDeployment(f, buf)
+	cmd.Flags().Set("dry-run", "true")
+	cmd.Flags().Set("output", "name")
+	err := CreateDeployment(f, buf, cmd, []string{depName})
+	assert.Error(t, err, "at least one image must be specified")
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_namespace.go

@@ -0,0 +1,79 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+var (
+	namespaceLong = templates.LongDesc(`
+		Create a namespace with the specified name.`)
+
+	namespaceExample = templates.Examples(`
+	  # Create a new namespace named my-namespace
+	  kubectl create namespace my-namespace`)
+)
+
+// NewCmdCreateNamespace is a macro command to create a new namespace
+func NewCmdCreateNamespace(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "namespace NAME [--dry-run]",
+		Aliases: []string{"ns"},
+		Short:   "Create a namespace with the specified name",
+		Long:    namespaceLong,
+		Example: namespaceExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateNamespace(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.NamespaceV1GeneratorName)
+
+	return cmd
+}
+
+// CreateNamespace implements the behavior to run the create namespace command
+func CreateNamespace(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.NamespaceV1GeneratorName:
+		generator = &kubectl.NamespaceGeneratorV1{Name: name}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetDryRunFlag(cmd),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_namespace_test.go

@@ -0,0 +1,54 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestCreateNamespace(t *testing.T) {
+	namespaceObject := &api.Namespace{}
+	namespaceObject.Name = "my-namespace"
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces" && m == "POST":
+				return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, namespaceObject)}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdCreateNamespace(f, buf)
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{namespaceObject.Name})
+	expectedOutput := "namespace/" + namespaceObject.Name + "\n"
+	if buf.String() != expectedOutput {
+		t.Errorf("expected output: %s, but got: %s", buf.String(), expectedOutput)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_pdb.go

@@ -0,0 +1,90 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+var (
+	pdbLong = templates.LongDesc(`
+		Create a pod disruption budget with the specified name, selector, and desired minimum available pods`)
+
+	pdbExample = templates.Examples(`
+		# Create a pod disruption budget named my-pdb that will select all pods with the app=rails label
+		# and require at least one of them being available at any point in time.
+		kubectl create poddisruptionbudget my-pdb --selector=app=rails --min-available=1
+
+		# Create a pod disruption budget named my-pdb that will select all pods with the app=nginx label
+		# and require at least half of the pods selected to be available at any point in time.
+		kubectl create pdb my-pdb --selector=app=nginx --min-available=50%`)
+)
+
+// NewCmdCreatePodDisruptionBudget is a macro command to create a new pod disruption budget.
+func NewCmdCreatePodDisruptionBudget(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "poddisruptionbudget NAME --selector=SELECTOR --min-available=N [--dry-run]",
+		Aliases: []string{"pdb"},
+		Short:   "Create a pod disruption budget with the specified name.",
+		Long:    pdbLong,
+		Example: pdbExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreatePodDisruptionBudget(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.PodDisruptionBudgetV1GeneratorName)
+	cmd.Flags().String("min-available", "1", "The minimum number or percentage of available pods this budget requires.")
+	cmd.Flags().String("selector", "", "A label selector to use for this budget. Only equality-based selector requirements are supported.")
+	return cmd
+}
+
+// CreatePodDisruptionBudget implements the behavior to run the create pdb command.
+func CreatePodDisruptionBudget(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.PodDisruptionBudgetV1GeneratorName:
+		generator = &kubectl.PodDisruptionBudgetV1Generator{
+			Name:         name,
+			MinAvailable: cmdutil.GetFlagString(cmd, "min-available"),
+			Selector:     cmdutil.GetFlagString(cmd, "selector"),
+		}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetFlagBool(cmd, "dry-run"),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_quota.go

@@ -0,0 +1,88 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+var (
+	quotaLong = templates.LongDesc(`
+		Create a resourcequota with the specified name, hard limits and optional scopes`)
+
+	quotaExample = templates.Examples(`
+		# Create a new resourcequota named my-quota
+		kubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3,replicationcontrollers=2,resourcequotas=1,secrets=5,persistentvolumeclaims=10
+
+		# Create a new resourcequota named best-effort
+		kubectl create quota best-effort --hard=pods=100 --scopes=BestEffort`)
+)
+
+// NewCmdCreateQuota is a macro command to create a new quota
+func NewCmdCreateQuota(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "quota NAME [--hard=key1=value1,key2=value2] [--scopes=Scope1,Scope2] [--dry-run=bool]",
+		Aliases: []string{"resourcequota"},
+		Short:   "Create a quota with the specified name.",
+		Long:    quotaLong,
+		Example: quotaExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateQuota(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.ResourceQuotaV1GeneratorName)
+	cmd.Flags().String("hard", "", "A comma-delimited set of resource=quantity pairs that define a hard limit.")
+	cmd.Flags().String("scopes", "", "A comma-delimited set of quota scopes that must all match each object tracked by the quota.")
+	return cmd
+}
+
+// CreateQuota implements the behavior to run the create quota command
+func CreateQuota(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.ResourceQuotaV1GeneratorName:
+		generator = &kubectl.ResourceQuotaGeneratorV1{
+			Name:   name,
+			Hard:   cmdutil.GetFlagString(cmd, "hard"),
+			Scopes: cmdutil.GetFlagString(cmd, "scopes"),
+		}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetFlagBool(cmd, "dry-run"),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_quota_test.go

@@ -0,0 +1,80 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestCreateQuota(t *testing.T) {
+	resourceQuotaObject := &api.ResourceQuota{}
+	resourceQuotaObject.Name = "my-quota"
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/resourcequotas" && m == "POST":
+				return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, resourceQuotaObject)}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+
+	tests := map[string]struct {
+		flags          map[string]string
+		expectedOutput string
+	}{
+		"single resource": {
+			flags:          map[string]string{"hard": "cpu=1", "output": "name"},
+			expectedOutput: "resourcequota/" + resourceQuotaObject.Name + "\n",
+		},
+		"single resource with a scope": {
+			flags:          map[string]string{"hard": "cpu=1", "output": "name", "scopes": "BestEffort"},
+			expectedOutput: "resourcequota/" + resourceQuotaObject.Name + "\n",
+		},
+		"multiple resources": {
+			flags:          map[string]string{"hard": "cpu=1,pods=42", "output": "name", "scopes": "BestEffort"},
+			expectedOutput: "resourcequota/" + resourceQuotaObject.Name + "\n",
+		},
+		"single resource with multiple scopes": {
+			flags:          map[string]string{"hard": "cpu=1", "output": "name", "scopes": "BestEffort,NotTerminating"},
+			expectedOutput: "resourcequota/" + resourceQuotaObject.Name + "\n",
+		},
+	}
+	for name, test := range tests {
+		buf := bytes.NewBuffer([]byte{})
+		cmd := NewCmdCreateQuota(f, buf)
+		cmd.Flags().Set("hard", "cpu=1")
+		cmd.Flags().Set("output", "name")
+		cmd.Run(cmd, []string{resourceQuotaObject.Name})
+
+		if buf.String() != test.expectedOutput {
+			t.Errorf("%s: expected output: %s, but got: %s", name, test.expectedOutput, buf.String())
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_secret.go

@@ -0,0 +1,260 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+// NewCmdCreateSecret groups subcommands to create various types of secrets
+func NewCmdCreateSecret(f cmdutil.Factory, cmdOut, errOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "secret",
+		Short: "Create a secret using specified subcommand",
+		Long:  "Create a secret using specified subcommand.",
+		Run:   cmdutil.DefaultSubCommandRun(errOut),
+	}
+	cmd.AddCommand(NewCmdCreateSecretDockerRegistry(f, cmdOut))
+	cmd.AddCommand(NewCmdCreateSecretTLS(f, cmdOut))
+	cmd.AddCommand(NewCmdCreateSecretGeneric(f, cmdOut))
+
+	return cmd
+}
+
+var (
+	secretLong = templates.LongDesc(`
+		Create a secret based on a file, directory, or specified literal value.
+
+		A single secret may package one or more key/value pairs.
+
+		When creating a secret based on a file, the key will default to the basename of the file, and the value will
+		default to the file content.  If the basename is an invalid key, you may specify an alternate key.
+
+		When creating a secret based on a directory, each file whose basename is a valid key in the directory will be
+		packaged into the secret.  Any directory entries except regular files are ignored (e.g. subdirectories,
+		symlinks, devices, pipes, etc).`)
+
+	secretExample = templates.Examples(`
+	  # Create a new secret named my-secret with keys for each file in folder bar
+	  kubectl create secret generic my-secret --from-file=path/to/bar
+
+	  # Create a new secret named my-secret with specified keys instead of names on disk
+	  kubectl create secret generic my-secret --from-file=ssh-privatekey=~/.ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub
+
+	  # Create a new secret named my-secret with key1=supersecret and key2=topsecret
+	  kubectl create secret generic my-secret --from-literal=key1=supersecret --from-literal=key2=topsecret`)
+)
+
+// NewCmdCreateSecretGeneric is a command to create generic secrets from files, directories, or literal values
+func NewCmdCreateSecretGeneric(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "generic NAME [--type=string] [--from-file=[key=]source] [--from-literal=key1=value1] [--dry-run]",
+		Short:   "Create a secret from a local file, directory or literal value",
+		Long:    secretLong,
+		Example: secretExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateSecretGeneric(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.SecretV1GeneratorName)
+	cmd.Flags().StringSlice("from-file", []string{}, "Key files can be specified using their file path, in which case a default name will be given to them, or optionally with a name and file path, in which case the given name will be used.  Specifying a directory will iterate each named file in the directory that is a valid secret key.")
+	cmd.Flags().StringSlice("from-literal", []string{}, "Specify a key and literal value to insert in secret (i.e. mykey=somevalue)")
+	cmd.Flags().String("type", "", "The type of secret to create")
+	return cmd
+}
+
+// CreateSecretGeneric is the implementation of the create secret generic command
+func CreateSecretGeneric(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.SecretV1GeneratorName:
+		generator = &kubectl.SecretGeneratorV1{
+			Name:           name,
+			Type:           cmdutil.GetFlagString(cmd, "type"),
+			FileSources:    cmdutil.GetFlagStringSlice(cmd, "from-file"),
+			LiteralSources: cmdutil.GetFlagStringSlice(cmd, "from-literal"),
+		}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetDryRunFlag(cmd),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}
+
+var (
+	secretForDockerRegistryLong = templates.LongDesc(`
+		Create a new secret for use with Docker registries.
+
+		Dockercfg secrets are used to authenticate against Docker registries.
+
+		When using the Docker command line to push images, you can authenticate to a given registry by running
+
+		    $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.
+
+    That produces a ~/.dockercfg file that is used by subsequent 'docker push' and 'docker pull' commands to
+		authenticate to the registry.
+
+		When creating applications, you may have a Docker registry that requires authentication.  In order for the
+		nodes to pull images on your behalf, they have to have the credentials.  You can provide this information
+		by creating a dockercfg secret and attaching it to your service account.`)
+
+	secretForDockerRegistryExample = templates.Examples(`
+		  # If you don't already have a .dockercfg file, you can create a dockercfg secret directly by using:
+		  kubectl create secret docker-registry my-secret --docker-server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL`)
+)
+
+// NewCmdCreateSecretDockerRegistry is a macro command for creating secrets to work with Docker registries
+func NewCmdCreateSecretDockerRegistry(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "docker-registry NAME --docker-username=user --docker-password=password --docker-email=email [--docker-server=string] [--from-literal=key1=value1] [--dry-run]",
+		Short:   "Create a secret for use with a Docker registry",
+		Long:    secretForDockerRegistryLong,
+		Example: secretForDockerRegistryExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateSecretDockerRegistry(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.SecretForDockerRegistryV1GeneratorName)
+	cmd.Flags().String("docker-username", "", "Username for Docker registry authentication")
+	cmd.MarkFlagRequired("docker-username")
+	cmd.Flags().String("docker-password", "", "Password for Docker registry authentication")
+	cmd.MarkFlagRequired("docker-password")
+	cmd.Flags().String("docker-email", "", "Email for Docker registry")
+	cmd.MarkFlagRequired("docker-email")
+	cmd.Flags().String("docker-server", "https://index.docker.io/v1/", "Server location for Docker registry")
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+	return cmd
+}
+
+// CreateSecretDockerRegistry is the implementation of the create secret docker-registry command
+func CreateSecretDockerRegistry(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	requiredFlags := []string{"docker-username", "docker-password", "docker-email", "docker-server"}
+	for _, requiredFlag := range requiredFlags {
+		if value := cmdutil.GetFlagString(cmd, requiredFlag); len(value) == 0 {
+			return cmdutil.UsageError(cmd, "flag %s is required", requiredFlag)
+		}
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.SecretForDockerRegistryV1GeneratorName:
+		generator = &kubectl.SecretForDockerRegistryGeneratorV1{
+			Name:     name,
+			Username: cmdutil.GetFlagString(cmd, "docker-username"),
+			Email:    cmdutil.GetFlagString(cmd, "docker-email"),
+			Password: cmdutil.GetFlagString(cmd, "docker-password"),
+			Server:   cmdutil.GetFlagString(cmd, "docker-server"),
+		}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetDryRunFlag(cmd),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}
+
+var (
+	secretForTLSLong = templates.LongDesc(`
+		Create a TLS secret from the given public/private key pair.
+
+		The public/private key pair must exist before hand. The public key certificate must be .PEM encoded and match the given private key.`)
+
+	secretForTLSExample = templates.Examples(`
+	  # Create a new TLS secret named tls-secret with the given key pair:
+	  kubectl create secret tls tls-secret --cert=path/to/tls.cert --key=path/to/tls.key`)
+)
+
+// NewCmdCreateSecretTLS is a macro command for creating secrets to work with Docker registries
+func NewCmdCreateSecretTLS(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "tls NAME --cert=path/to/cert/file --key=path/to/key/file [--dry-run]",
+		Short:   "Create a TLS secret",
+		Long:    secretForTLSLong,
+		Example: secretForTLSExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateSecretTLS(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.SecretForTLSV1GeneratorName)
+	cmd.Flags().String("cert", "", "Path to PEM encoded public key certificate.")
+	cmd.Flags().String("key", "", "Path to private key associated with given certificate.")
+	return cmd
+}
+
+// CreateSecretTLS is the implementation of the create secret tls command
+func CreateSecretTLS(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	requiredFlags := []string{"cert", "key"}
+	for _, requiredFlag := range requiredFlags {
+		if value := cmdutil.GetFlagString(cmd, requiredFlag); len(value) == 0 {
+			return cmdutil.UsageError(cmd, "flag %s is required", requiredFlag)
+		}
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.SecretForTLSV1GeneratorName:
+		generator = &kubectl.SecretForTLSGeneratorV1{
+			Name: name,
+			Key:  cmdutil.GetFlagString(cmd, "key"),
+			Cert: cmdutil.GetFlagString(cmd, "cert"),
+		}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetFlagBool(cmd, "dry-run"),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_secret_test.go

@@ -0,0 +1,86 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestCreateSecretGeneric(t *testing.T) {
+	secretObject := &api.Secret{}
+	secretObject.Name = "my-secret"
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/secrets" && m == "POST":
+				return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, secretObject)}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdCreateSecretGeneric(f, buf)
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{secretObject.Name})
+	expectedOutput := "secret/" + secretObject.Name + "\n"
+	if buf.String() != expectedOutput {
+		t.Errorf("expected output: %s, but got: %s", buf.String(), expectedOutput)
+	}
+}
+
+func TestCreateSecretDockerRegistry(t *testing.T) {
+	secretObject := &api.Secret{}
+	secretObject.Name = "my-secret"
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/secrets" && m == "POST":
+				return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, secretObject)}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdCreateSecretDockerRegistry(f, buf)
+	cmd.Flags().Set("docker-username", "test-user")
+	cmd.Flags().Set("docker-password", "test-pass")
+	cmd.Flags().Set("docker-email", "test-email")
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{secretObject.Name})
+	expectedOutput := "secret/" + secretObject.Name + "\n"
+	if buf.String() != expectedOutput {
+		t.Errorf("expected output: %s, but got: %s", buf.String(), expectedOutput)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_service.go

@@ -0,0 +1,282 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+// NewCmdCreateService is a macro command to create a new service
+func NewCmdCreateService(f cmdutil.Factory, cmdOut, errOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "service",
+		Aliases: []string{"svc"},
+		Short:   "Create a service using specified subcommand.",
+		Long:    "Create a service using specified subcommand.",
+		Run:     cmdutil.DefaultSubCommandRun(errOut),
+	}
+	cmd.AddCommand(NewCmdCreateServiceClusterIP(f, cmdOut))
+	cmd.AddCommand(NewCmdCreateServiceNodePort(f, cmdOut))
+	cmd.AddCommand(NewCmdCreateServiceLoadBalancer(f, cmdOut))
+	cmd.AddCommand(NewCmdCreateServiceExternalName(f, cmdOut))
+
+	return cmd
+}
+
+var (
+	serviceClusterIPLong = templates.LongDesc(`
+    Create a clusterIP service with the specified name.`)
+
+	serviceClusterIPExample = templates.Examples(`
+    # Create a new clusterIP service named my-cs
+    kubectl create service clusterip my-cs --tcp=5678:8080
+
+    # Create a new clusterIP service named my-cs (in headless mode)
+    kubectl create service clusterip my-cs --clusterip="None"`)
+)
+
+func addPortFlags(cmd *cobra.Command) {
+	cmd.Flags().StringSlice("tcp", []string{}, "Port pairs can be specified as '<port>:<targetPort>'.")
+}
+
+// NewCmdCreateServiceClusterIP is a command to create a clusterIP service
+func NewCmdCreateServiceClusterIP(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "clusterip NAME [--tcp=<port>:<targetPort>] [--dry-run]",
+		Short:   "Create a clusterIP service.",
+		Long:    serviceClusterIPLong,
+		Example: serviceClusterIPExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateServiceClusterIP(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.ServiceClusterIPGeneratorV1Name)
+	addPortFlags(cmd)
+	cmd.Flags().String("clusterip", "", "Assign your own ClusterIP or set to 'None' for a 'headless' service (no loadbalancing).")
+	return cmd
+}
+
+// CreateServiceClusterIP implements the behavior to run the create service clusterIP command
+func CreateServiceClusterIP(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.ServiceClusterIPGeneratorV1Name:
+		generator = &kubectl.ServiceCommonGeneratorV1{
+			Name:      name,
+			TCP:       cmdutil.GetFlagStringSlice(cmd, "tcp"),
+			Type:      api.ServiceTypeClusterIP,
+			ClusterIP: cmdutil.GetFlagString(cmd, "clusterip"),
+		}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetDryRunFlag(cmd),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}
+
+var (
+	serviceNodePortLong = templates.LongDesc(`
+    Create a nodeport service with the specified name.`)
+
+	serviceNodePortExample = templates.Examples(`
+    # Create a new nodeport service named my-ns
+    kubectl create service nodeport my-ns --tcp=5678:8080`)
+)
+
+// NewCmdCreateServiceNodePort is a macro command for creating a NodePort service
+func NewCmdCreateServiceNodePort(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "nodeport NAME [--tcp=port:targetPort] [--dry-run]",
+		Short:   "Create a NodePort service.",
+		Long:    serviceNodePortLong,
+		Example: serviceNodePortExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateServiceNodePort(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.ServiceNodePortGeneratorV1Name)
+	cmd.Flags().Int("node-port", 0, "Port used to expose the service on each node in a cluster.")
+	addPortFlags(cmd)
+	return cmd
+}
+
+// CreateServiceNodePort is the implementation of the create service nodeport command
+func CreateServiceNodePort(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.ServiceNodePortGeneratorV1Name:
+		generator = &kubectl.ServiceCommonGeneratorV1{
+			Name:      name,
+			TCP:       cmdutil.GetFlagStringSlice(cmd, "tcp"),
+			Type:      api.ServiceTypeNodePort,
+			ClusterIP: "",
+			NodePort:  cmdutil.GetFlagInt(cmd, "node-port"),
+		}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetDryRunFlag(cmd),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}
+
+var (
+	serviceLoadBalancerLong = templates.LongDesc(`
+    Create a LoadBalancer service with the specified name.`)
+
+	serviceLoadBalancerExample = templates.Examples(`
+    # Create a new LoadBalancer service named my-lbs
+    kubectl create service loadbalancer my-lbs --tcp=5678:8080`)
+)
+
+// NewCmdCreateServiceLoadBalancer is a macro command for creating a LoadBalancer service
+func NewCmdCreateServiceLoadBalancer(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "loadbalancer NAME [--tcp=port:targetPort] [--dry-run]",
+		Short:   "Create a LoadBalancer service.",
+		Long:    serviceLoadBalancerLong,
+		Example: serviceLoadBalancerExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateServiceLoadBalancer(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.ServiceLoadBalancerGeneratorV1Name)
+	addPortFlags(cmd)
+	return cmd
+}
+
+// CreateServiceLoadBalancer is the implementation of the service loadbalancer command
+func CreateServiceLoadBalancer(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.ServiceLoadBalancerGeneratorV1Name:
+		generator = &kubectl.ServiceCommonGeneratorV1{
+			Name:      name,
+			TCP:       cmdutil.GetFlagStringSlice(cmd, "tcp"),
+			Type:      api.ServiceTypeLoadBalancer,
+			ClusterIP: "",
+		}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetFlagBool(cmd, "dry-run"),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}
+
+var (
+	serviceExternalNameLong = templates.LongDesc(`
+	Create an ExternalName service with the specified name.
+
+	ExternalName service references to an external DNS address instead of
+	only pods, which will allow application authors to reference services
+	that exist off platform, on other clusters, or locally.`)
+
+	serviceExternalNameExample = templates.Examples(`
+	# Create a new ExternalName service named my-ns 
+	kubectl create service externalname my-ns --external-name bar.com`)
+)
+
+// NewCmdCreateServiceExternalName is a macro command for creating a ExternalName service
+func NewCmdCreateServiceExternalName(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "externalname NAME --external-name external.name [--dry-run]",
+		Short:   "Create an ExternalName service.",
+		Long:    serviceExternalNameLong,
+		Example: serviceExternalNameExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateExternalNameService(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.ServiceExternalNameGeneratorV1Name)
+	addPortFlags(cmd)
+	cmd.Flags().String("external-name", "", "external name of service")
+	cmd.MarkFlagRequired("external-name")
+	return cmd
+}
+
+// CreateExternalNameService is the implementation of the service externalname command
+func CreateExternalNameService(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.ServiceExternalNameGeneratorV1Name:
+		generator = &kubectl.ServiceCommonGeneratorV1{
+			Name:         name,
+			Type:         api.ServiceTypeExternalName,
+			ExternalName: cmdutil.GetFlagString(cmd, "external-name"),
+			ClusterIP:    "",
+		}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetDryRunFlag(cmd),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_service_test.go

@@ -0,0 +1,56 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestCreateService(t *testing.T) {
+	service := &api.Service{}
+	service.Name = "my-service"
+	f, tf, codec, negSer := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: negSer,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/services" && m == "POST":
+				return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, service)}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdCreateServiceClusterIP(f, buf)
+	cmd.Flags().Set("output", "name")
+	cmd.Flags().Set("tcp", "8080:8000")
+	cmd.Run(cmd, []string{service.Name})
+	expectedOutput := "service/" + service.Name + "\n"
+	if buf.String() != expectedOutput {
+		t.Errorf("expected output: %s, but got: %s", expectedOutput, buf.String())
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_serviceaccount.go

@@ -0,0 +1,79 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+var (
+	serviceAccountLong = templates.LongDesc(`
+		Create a service account with the specified name.`)
+
+	serviceAccountExample = templates.Examples(`
+	  # Create a new service account named my-service-account
+	  kubectl create serviceaccount my-service-account`)
+)
+
+// NewCmdCreateServiceAccount is a macro command to create a new service account
+func NewCmdCreateServiceAccount(f cmdutil.Factory, cmdOut io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "serviceaccount NAME [--dry-run]",
+		Aliases: []string{"sa"},
+		Short:   "Create a service account with the specified name",
+		Long:    serviceAccountLong,
+		Example: serviceAccountExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := CreateServiceAccount(f, cmdOut, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+	cmdutil.AddGeneratorFlags(cmd, cmdutil.ServiceAccountV1GeneratorName)
+	return cmd
+}
+
+// CreateServiceAccount implements the behavior to run the create service account command
+func CreateServiceAccount(f cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error {
+	name, err := NameFromCommandArgs(cmd, args)
+	if err != nil {
+		return err
+	}
+	var generator kubectl.StructuredGenerator
+	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	case cmdutil.ServiceAccountV1GeneratorName:
+		generator = &kubectl.ServiceAccountGeneratorV1{Name: name}
+	default:
+		return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName))
+	}
+	return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{
+		Name:                name,
+		StructuredGenerator: generator,
+		DryRun:              cmdutil.GetDryRunFlag(cmd),
+		OutputFormat:        cmdutil.GetFlagString(cmd, "output"),
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_serviceaccount_test.go

@@ -0,0 +1,55 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestCreateServiceAccount(t *testing.T) {
+	serviceAccountObject := &api.ServiceAccount{}
+	serviceAccountObject.Name = "my-service-account"
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/serviceaccounts" && m == "POST":
+				return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, serviceAccountObject)}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdCreateServiceAccount(f, buf)
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{serviceAccountObject.Name})
+	expectedOutput := "serviceaccount/" + serviceAccountObject.Name + "\n"
+	if buf.String() != expectedOutput {
+		t.Errorf("expected output: %s, but got: %s", expectedOutput, buf.String())
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/create_test.go

@@ -0,0 +1,145 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	"k8s.io/kubernetes/pkg/client/typed/dynamic"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestExtraArgsFail(t *testing.T) {
+	initTestErrorHandler(t)
+	buf := bytes.NewBuffer([]byte{})
+	errBuf := bytes.NewBuffer([]byte{})
+
+	f, _, _, _ := cmdtesting.NewAPIFactory()
+	c := NewCmdCreate(f, buf, errBuf)
+	if ValidateArgs(c, []string{"rc"}) == nil {
+		t.Errorf("unexpected non-error")
+	}
+}
+
+func TestCreateObject(t *testing.T) {
+	initTestErrorHandler(t)
+	_, _, rc := testData()
+	rc.Items[0].Name = "redis-master-controller"
+
+	f, tf, codec, _ := cmdtesting.NewAPIFactory()
+	ns := dynamic.ContentConfig().NegotiatedSerializer
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/replicationcontrollers" && m == http.MethodPost:
+				return &http.Response{StatusCode: http.StatusCreated, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	errBuf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdCreate(f, buf, errBuf)
+	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	// uses the name from the file, not the response
+	if buf.String() != "replicationcontroller/redis-master-controller\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}
+
+func TestCreateMultipleObject(t *testing.T) {
+	initTestErrorHandler(t)
+	_, svc, rc := testData()
+
+	f, tf, codec, _ := cmdtesting.NewAPIFactory()
+	ns := dynamic.ContentConfig().NegotiatedSerializer
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/services" && m == http.MethodPost:
+				return &http.Response{StatusCode: http.StatusCreated, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil
+			case p == "/namespaces/test/replicationcontrollers" && m == http.MethodPost:
+				return &http.Response{StatusCode: http.StatusCreated, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	errBuf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdCreate(f, buf, errBuf)
+	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
+	cmd.Flags().Set("filename", "../../../examples/guestbook/frontend-service.yaml")
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	// Names should come from the REST response, NOT the files
+	if buf.String() != "replicationcontroller/rc1\nservice/baz\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}
+
+func TestCreateDirectory(t *testing.T) {
+	initTestErrorHandler(t)
+	_, _, rc := testData()
+	rc.Items[0].Name = "name"
+
+	f, tf, codec, _ := cmdtesting.NewAPIFactory()
+	ns := dynamic.ContentConfig().NegotiatedSerializer
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/replicationcontrollers" && m == http.MethodPost:
+				return &http.Response{StatusCode: http.StatusCreated, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	errBuf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdCreate(f, buf, errBuf)
+	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy")
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	if buf.String() != "replicationcontroller/name\nreplicationcontroller/name\nreplicationcontroller/name\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/delete.go

@@ -0,0 +1,293 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/errors"
+	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/util/wait"
+)
+
+var (
+	delete_long = templates.LongDesc(`
+		Delete resources by filenames, stdin, resources and names, or by resources and label selector.
+
+		JSON and YAML formats are accepted. Only one type of the arguments may be specified: filenames,
+		resources and names, or resources and label selector.
+
+		Some resources, such as pods, support graceful deletion. These resources define a default period
+		before they are forcibly terminated (the grace period) but you may override that value with
+		the --grace-period flag, or pass --now to set a grace-period of 1. Because these resources often
+		represent entities in the cluster, deletion may not be acknowledged immediately. If the node
+		hosting a pod is down or cannot reach the API server, termination may take significantly longer
+		than the grace period. To force delete a resource,	you must pass a grace	period of 0 and specify
+		the --force flag.
+
+		IMPORTANT: Force deleting pods does not wait for confirmation that the pod's processes have been
+		terminated, which can leave those processes running until the node detects the deletion and
+		completes graceful deletion. If your processes use shared storage or talk to a remote API and
+		depend on the name of the pod to identify themselves, force deleting those pods may result in
+		multiple processes running on different machines using the same identification which may lead
+		to data corruption or inconsistency. Only force delete pods when you are sure the pod is
+		terminated, or if your application can tolerate multiple copies of the same pod running at once.
+		Also, if you force delete pods the scheduler may place new pods on those nodes before the node
+		has released those resources and causing those pods to be evicted immediately.
+
+		Note that the delete command does NOT do resource version checks, so if someone
+		submits an update to a resource right when you submit a delete, their update
+		will be lost along with the rest of the resource.`)
+
+	delete_example = templates.Examples(`
+		# Delete a pod using the type and name specified in pod.json.
+		kubectl delete -f ./pod.json
+
+		# Delete a pod based on the type and name in the JSON passed into stdin.
+		cat pod.json | kubectl delete -f -
+
+		# Delete pods and services with same names "baz" and "foo"
+		kubectl delete pod,service baz foo
+
+		# Delete pods and services with label name=myLabel.
+		kubectl delete pods,services -l name=myLabel
+
+		# Delete a pod with minimal delay
+		kubectl delete pod foo --now
+
+		# Force delete a pod on a dead node
+		kubectl delete pod foo --grace-period=0 --force
+
+		# Delete a pod with UID 1234-56-7890-234234-456456.
+		kubectl delete pod 1234-56-7890-234234-456456
+
+		# Delete all pods
+		kubectl delete pods --all`)
+)
+
+func NewCmdDelete(f cmdutil.Factory, out, errOut io.Writer) *cobra.Command {
+	options := &resource.FilenameOptions{}
+
+	// retrieve a list of handled resources from printer as valid args
+	validArgs, argAliases := []string{}, []string{}
+	p, err := f.Printer(nil, kubectl.PrintOptions{
+		ColumnLabels: []string{},
+	})
+	cmdutil.CheckErr(err)
+	if p != nil {
+		validArgs = p.HandledResources()
+		argAliases = kubectl.ResourceAliases(validArgs)
+	}
+
+	cmd := &cobra.Command{
+		Use:     "delete ([-f FILENAME] | TYPE [(NAME | -l label | --all)])",
+		Short:   "Delete resources by filenames, stdin, resources and names, or by resources and label selector",
+		Long:    delete_long,
+		Example: delete_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(cmdutil.ValidateOutputArgs(cmd))
+			err := RunDelete(f, out, errOut, cmd, args, options)
+			cmdutil.CheckErr(err)
+		},
+		SuggestFor: []string{"rm"},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+	usage := "containing the resource to delete."
+	cmdutil.AddFilenameOptionFlags(cmd, options, usage)
+	cmd.Flags().StringP("selector", "l", "", "Selector (label query) to filter on.")
+	cmd.Flags().Bool("all", false, "[-all] to select all the specified resources.")
+	cmd.Flags().Bool("ignore-not-found", false, "Treat \"resource not found\" as a successful delete. Defaults to \"true\" when --all is specified.")
+	cmd.Flags().Bool("cascade", true, "If true, cascade the deletion of the resources managed by this resource (e.g. Pods created by a ReplicationController).  Default true.")
+	cmd.Flags().Int("grace-period", -1, "Period of time in seconds given to the resource to terminate gracefully. Ignored if negative.")
+	cmd.Flags().Bool("now", false, "If true, resources are signaled for immediate shutdown (same as --grace-period=1).")
+	cmd.Flags().Bool("force", false, "Immediate deletion of some resources may result in inconsistency or data loss and requires confirmation.")
+	cmd.Flags().Duration("timeout", 0, "The length of time to wait before giving up on a delete, zero means determine a timeout from the size of the object")
+	cmdutil.AddOutputFlagsForMutation(cmd)
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+	return cmd
+}
+
+func RunDelete(f cmdutil.Factory, out, errOut io.Writer, cmd *cobra.Command, args []string, options *resource.FilenameOptions) error {
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+	deleteAll := cmdutil.GetFlagBool(cmd, "all")
+	mapper, typer, err := f.UnstructuredObject()
+	if err != nil {
+		return err
+	}
+	r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.UnstructuredClientForMapping), runtime.UnstructuredJSONScheme).
+		ContinueOnError().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, options).
+		SelectorParam(cmdutil.GetFlagString(cmd, "selector")).
+		SelectAllParam(deleteAll).
+		ResourceTypeOrNameArgs(false, args...).RequireObject(false).
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	ignoreNotFound := cmdutil.GetFlagBool(cmd, "ignore-not-found")
+	if deleteAll {
+		f := cmd.Flags().Lookup("ignore-not-found")
+		// The flag should never be missing
+		if f == nil {
+			return fmt.Errorf("missing --ignore-not-found flag")
+		}
+		// If the user didn't explicitly set the option, default to ignoring NotFound errors when used with --all
+		if !f.Changed {
+			ignoreNotFound = true
+		}
+	}
+
+	gracePeriod := cmdutil.GetFlagInt(cmd, "grace-period")
+	force := cmdutil.GetFlagBool(cmd, "force")
+	if cmdutil.GetFlagBool(cmd, "now") {
+		if gracePeriod != -1 {
+			return fmt.Errorf("--now and --grace-period cannot be specified together")
+		}
+		gracePeriod = 1
+	}
+	wait := false
+	if gracePeriod == 0 {
+		if force {
+			fmt.Fprintf(errOut, "warning: Immediate deletion does not wait for confirmation that the running resource has been terminated. The resource may continue to run on the cluster indefinitely.\n")
+		} else {
+			// To preserve backwards compatibility, but prevent accidental data loss, we convert --grace-period=0
+			// into --grace-period=1 and wait until the object is successfully deleted. Users may provide --force
+			// to bypass this wait.
+			wait = true
+			gracePeriod = 1
+		}
+	}
+
+	shortOutput := cmdutil.GetFlagString(cmd, "output") == "name"
+	// By default use a reaper to delete all related resources.
+	if cmdutil.GetFlagBool(cmd, "cascade") {
+		return ReapResult(r, f, out, cmdutil.GetFlagBool(cmd, "cascade"), ignoreNotFound, cmdutil.GetFlagDuration(cmd, "timeout"), gracePeriod, wait, shortOutput, mapper, false)
+	}
+	return DeleteResult(r, out, ignoreNotFound, shortOutput, mapper)
+}
+
+func ReapResult(r *resource.Result, f cmdutil.Factory, out io.Writer, isDefaultDelete, ignoreNotFound bool, timeout time.Duration, gracePeriod int, waitForDeletion, shortOutput bool, mapper meta.RESTMapper, quiet bool) error {
+	found := 0
+	if ignoreNotFound {
+		r = r.IgnoreErrors(errors.IsNotFound)
+	}
+	err := r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+		found++
+		reaper, err := f.Reaper(info.Mapping)
+		if err != nil {
+			// If there is no reaper for this resources and the user didn't explicitly ask for stop.
+			if kubectl.IsNoSuchReaperError(err) && isDefaultDelete {
+				return deleteResource(info, out, shortOutput, mapper)
+			}
+			return cmdutil.AddSourceToErr("reaping", info.Source, err)
+		}
+		var options *api.DeleteOptions
+		if gracePeriod >= 0 {
+			options = api.NewDeleteOptions(int64(gracePeriod))
+		}
+		if err := reaper.Stop(info.Namespace, info.Name, timeout, options); err != nil {
+			return cmdutil.AddSourceToErr("stopping", info.Source, err)
+		}
+		if waitForDeletion {
+			if err := waitForObjectDeletion(info, timeout); err != nil {
+				return cmdutil.AddSourceToErr("stopping", info.Source, err)
+			}
+		}
+		if !quiet {
+			cmdutil.PrintSuccess(mapper, shortOutput, out, info.Mapping.Resource, info.Name, false, "deleted")
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	if found == 0 {
+		fmt.Fprintf(out, "No resources found\n")
+	}
+	return nil
+}
+
+func DeleteResult(r *resource.Result, out io.Writer, ignoreNotFound bool, shortOutput bool, mapper meta.RESTMapper) error {
+	found := 0
+	if ignoreNotFound {
+		r = r.IgnoreErrors(errors.IsNotFound)
+	}
+	err := r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+		found++
+		return deleteResource(info, out, shortOutput, mapper)
+	})
+	if err != nil {
+		return err
+	}
+	if found == 0 {
+		fmt.Fprintf(out, "No resources found\n")
+	}
+	return nil
+}
+
+func deleteResource(info *resource.Info, out io.Writer, shortOutput bool, mapper meta.RESTMapper) error {
+	if err := resource.NewHelper(info.Client, info.Mapping).Delete(info.Namespace, info.Name); err != nil {
+		return cmdutil.AddSourceToErr("deleting", info.Source, err)
+	}
+	cmdutil.PrintSuccess(mapper, shortOutput, out, info.Mapping.Resource, info.Name, false, "deleted")
+	return nil
+}
+
+// objectDeletionWaitInterval is the interval to wait between checks for deletion. Exposed for testing.
+var objectDeletionWaitInterval = time.Second
+
+// waitForObjectDeletion refreshes the object, waiting until it is deleted, a timeout is reached, or
+// an error is encountered. It checks once a second.
+func waitForObjectDeletion(info *resource.Info, timeout time.Duration) error {
+	copied := *info
+	info = &copied
+	// TODO: refactor Reaper so that we can pass the "wait" option into it, and then check for UID change.
+	return wait.PollImmediate(objectDeletionWaitInterval, timeout, func() (bool, error) {
+		switch err := info.Get(); {
+		case err == nil:
+			return false, nil
+		case errors.IsNotFound(err):
+			return true, nil
+		default:
+			return false, err
+		}
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/describe.go

@@ -0,0 +1,195 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	apierrors "k8s.io/kubernetes/pkg/api/errors"
+	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+	utilerrors "k8s.io/kubernetes/pkg/util/errors"
+)
+
+var (
+	describe_long = templates.LongDesc(`
+		Show details of a specific resource or group of resources.
+		This command joins many API calls together to form a detailed description of a
+		given resource or group of resources.
+
+		    $ kubectl describe TYPE NAME_PREFIX
+
+		will first check for an exact match on TYPE and NAME_PREFIX. If no such resource
+		exists, it will output details for every resource that has a name prefixed with NAME_PREFIX.
+
+		` + valid_resources)
+
+	describe_example = templates.Examples(`
+		# Describe a node
+		kubectl describe nodes kubernetes-node-emt8.c.myproject.internal
+
+		# Describe a pod
+		kubectl describe pods/nginx
+
+		# Describe a pod identified by type and name in "pod.json"
+		kubectl describe -f pod.json
+
+		# Describe all pods
+		kubectl describe pods
+
+		# Describe pods by label name=myLabel
+		kubectl describe po -l name=myLabel
+
+		# Describe all pods managed by the 'frontend' replication controller (rc-created pods
+		# get the name of the rc as a prefix in the pod the name).
+		kubectl describe pods frontend`)
+)
+
+func NewCmdDescribe(f cmdutil.Factory, out, cmdErr io.Writer) *cobra.Command {
+	options := &resource.FilenameOptions{}
+	describerSettings := &kubectl.DescriberSettings{}
+
+	validArgs := kubectl.DescribableResources()
+	argAliases := kubectl.ResourceAliases(validArgs)
+
+	cmd := &cobra.Command{
+		Use:     "describe (-f FILENAME | TYPE [NAME_PREFIX | -l label] | TYPE/NAME)",
+		Short:   "Show details of a specific resource or group of resources",
+		Long:    describe_long,
+		Example: describe_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunDescribe(f, out, cmdErr, cmd, args, options, describerSettings)
+			cmdutil.CheckErr(err)
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+	usage := "containing the resource to describe"
+	cmdutil.AddFilenameOptionFlags(cmd, options, usage)
+	cmd.Flags().StringP("selector", "l", "", "Selector (label query) to filter on")
+	cmd.Flags().Bool("all-namespaces", false, "If present, list the requested object(s) across all namespaces. Namespace in current context is ignored even if specified with --namespace.")
+	cmd.Flags().BoolVar(&describerSettings.ShowEvents, "show-events", true, "If true, display events related to the described object.")
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+	return cmd
+}
+
+func RunDescribe(f cmdutil.Factory, out, cmdErr io.Writer, cmd *cobra.Command, args []string, options *resource.FilenameOptions, describerSettings *kubectl.DescriberSettings) error {
+	selector := cmdutil.GetFlagString(cmd, "selector")
+	allNamespaces := cmdutil.GetFlagBool(cmd, "all-namespaces")
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+	if allNamespaces {
+		enforceNamespace = false
+	}
+	if len(args) == 0 && cmdutil.IsFilenameEmpty(options.Filenames) {
+		fmt.Fprint(cmdErr, "You must specify the type of resource to describe. ", valid_resources)
+		return cmdutil.UsageError(cmd, "Required resource not specified.")
+	}
+
+	mapper, typer := f.Object()
+	r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
+		ContinueOnError().
+		NamespaceParam(cmdNamespace).DefaultNamespace().AllNamespaces(allNamespaces).
+		FilenameParam(enforceNamespace, options).
+		SelectorParam(selector).
+		ResourceTypeOrNameArgs(true, args...).
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	allErrs := []error{}
+	infos, err := r.Infos()
+	if err != nil {
+		if apierrors.IsNotFound(err) && len(args) == 2 {
+			return DescribeMatchingResources(mapper, typer, f, cmdNamespace, args[0], args[1], describerSettings, out, err)
+		}
+		allErrs = append(allErrs, err)
+	}
+
+	first := true
+	for _, info := range infos {
+		mapping := info.ResourceMapping()
+		describer, err := f.Describer(mapping)
+		if err != nil {
+			allErrs = append(allErrs, err)
+			continue
+		}
+		s, err := describer.Describe(info.Namespace, info.Name, *describerSettings)
+		if err != nil {
+			allErrs = append(allErrs, err)
+			continue
+		}
+		if first {
+			first = false
+			fmt.Fprint(out, s)
+		} else {
+			fmt.Fprintf(out, "\n\n%s", s)
+		}
+	}
+
+	return utilerrors.NewAggregate(allErrs)
+}
+
+func DescribeMatchingResources(mapper meta.RESTMapper, typer runtime.ObjectTyper, f cmdutil.Factory, namespace, rsrc, prefix string, describerSettings *kubectl.DescriberSettings, out io.Writer, originalError error) error {
+	r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
+		NamespaceParam(namespace).DefaultNamespace().
+		ResourceTypeOrNameArgs(true, rsrc).
+		SingleResourceType().
+		Flatten().
+		Do()
+	mapping, err := r.ResourceMapping()
+	if err != nil {
+		return err
+	}
+	describer, err := f.Describer(mapping)
+	if err != nil {
+		return err
+	}
+	infos, err := r.Infos()
+	if err != nil {
+		return err
+	}
+	isFound := false
+	for ix := range infos {
+		info := infos[ix]
+		if strings.HasPrefix(info.Name, prefix) {
+			isFound = true
+			s, err := describer.Describe(info.Namespace, info.Name, *describerSettings)
+			if err != nil {
+				return err
+			}
+			fmt.Fprintf(out, "%s\n", s)
+		}
+	}
+	if !isFound {
+		return originalError
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/describe_test.go

@@ -0,0 +1,146 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+// Verifies that schemas that are not in the master tree of Kubernetes can be retrieved via Get.
+func TestDescribeUnknownSchemaObject(t *testing.T) {
+	d := &testDescriber{Output: "test output"}
+	f, tf, codec, ns := cmdtesting.NewTestFactory()
+	tf.Describer = d
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Resp:                 &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, cmdtesting.NewInternalType("", "", "foo"))},
+	}
+	tf.Namespace = "non-default"
+	buf := bytes.NewBuffer([]byte{})
+	buferr := bytes.NewBuffer([]byte{})
+	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd.Run(cmd, []string{"type", "foo"})
+
+	if d.Name != "foo" || d.Namespace != "non-default" {
+		t.Errorf("unexpected describer: %#v", d)
+	}
+
+	if buf.String() != fmt.Sprintf("%s", d.Output) {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}
+
+func TestDescribeObject(t *testing.T) {
+	_, _, rc := testData()
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	d := &testDescriber{Output: "test output"}
+	tf.Describer = d
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/replicationcontrollers/redis-master" && m == "GET":
+				return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	buferr := bytes.NewBuffer([]byte{})
+	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
+	cmd.Run(cmd, []string{})
+
+	if d.Name != "redis-master" || d.Namespace != "test" {
+		t.Errorf("unexpected describer: %#v", d)
+	}
+
+	if buf.String() != fmt.Sprintf("%s", d.Output) {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}
+
+func TestDescribeListObjects(t *testing.T) {
+	pods, _, _ := testData()
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	d := &testDescriber{Output: "test output"}
+	tf.Describer = d
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Resp:                 &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)},
+	}
+
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	buferr := bytes.NewBuffer([]byte{})
+	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd.Run(cmd, []string{"pods"})
+	if buf.String() != fmt.Sprintf("%s\n\n%s", d.Output, d.Output) {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}
+
+func TestDescribeObjectShowEvents(t *testing.T) {
+	pods, _, _ := testData()
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	d := &testDescriber{Output: "test output"}
+	tf.Describer = d
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Resp:                 &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)},
+	}
+
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	buferr := bytes.NewBuffer([]byte{})
+	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd.Flags().Set("show-events", "true")
+	cmd.Run(cmd, []string{"pods"})
+	if d.Settings.ShowEvents != true {
+		t.Errorf("ShowEvents = true expected, got ShowEvents = %v", d.Settings.ShowEvents)
+	}
+}
+
+func TestDescribeObjectSkipEvents(t *testing.T) {
+	pods, _, _ := testData()
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	d := &testDescriber{Output: "test output"}
+	tf.Describer = d
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Resp:                 &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)},
+	}
+
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+	buferr := bytes.NewBuffer([]byte{})
+	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd.Flags().Set("show-events", "false")
+	cmd.Run(cmd, []string{"pods"})
+	if d.Settings.ShowEvents != false {
+		t.Errorf("ShowEvents = false expected, got ShowEvents = %v", d.Settings.ShowEvents)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/exec.go

@@ -0,0 +1,325 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"net/url"
+
+	dockerterm "github.com/docker/docker/pkg/term"
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"
+	"k8s.io/kubernetes/pkg/client/restclient"
+	"k8s.io/kubernetes/pkg/client/unversioned/remotecommand"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	remotecommandserver "k8s.io/kubernetes/pkg/kubelet/server/remotecommand"
+	"k8s.io/kubernetes/pkg/util/interrupt"
+	"k8s.io/kubernetes/pkg/util/term"
+)
+
+var (
+	exec_example = templates.Examples(`
+		# Get output from running 'date' from pod 123456-7890, using the first container by default
+		kubectl exec 123456-7890 date
+
+		# Get output from running 'date' in ruby-container from pod 123456-7890
+		kubectl exec 123456-7890 -c ruby-container date
+
+		# Switch to raw terminal mode, sends stdin to 'bash' in ruby-container from pod 123456-7890
+		# and sends stdout/stderr from 'bash' back to the client
+		kubectl exec 123456-7890 -c ruby-container -i -t -- bash -il`)
+)
+
+const (
+	execUsageStr = "expected 'exec POD_NAME COMMAND [ARG1] [ARG2] ... [ARGN]'.\nPOD_NAME and COMMAND are required arguments for the exec command"
+)
+
+func NewCmdExec(f cmdutil.Factory, cmdIn io.Reader, cmdOut, cmdErr io.Writer) *cobra.Command {
+	options := &ExecOptions{
+		StreamOptions: StreamOptions{
+			In:  cmdIn,
+			Out: cmdOut,
+			Err: cmdErr,
+		},
+
+		Executor: &DefaultRemoteExecutor{},
+	}
+	cmd := &cobra.Command{
+		Use:     "exec POD [-c CONTAINER] -- COMMAND [args...]",
+		Short:   "Execute a command in a container",
+		Long:    "Execute a command in a container.",
+		Example: exec_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			argsLenAtDash := cmd.ArgsLenAtDash()
+			cmdutil.CheckErr(options.Complete(f, cmd, args, argsLenAtDash))
+			cmdutil.CheckErr(options.Validate())
+			cmdutil.CheckErr(options.Run())
+		},
+	}
+	cmd.Flags().StringVarP(&options.PodName, "pod", "p", "", "Pod name")
+	// TODO support UID
+	cmd.Flags().StringVarP(&options.ContainerName, "container", "c", "", "Container name. If omitted, the first container in the pod will be chosen")
+	cmd.Flags().BoolVarP(&options.Stdin, "stdin", "i", false, "Pass stdin to the container")
+	cmd.Flags().BoolVarP(&options.TTY, "tty", "t", false, "Stdin is a TTY")
+	return cmd
+}
+
+// RemoteExecutor defines the interface accepted by the Exec command - provided for test stubbing
+type RemoteExecutor interface {
+	Execute(method string, url *url.URL, config *restclient.Config, stdin io.Reader, stdout, stderr io.Writer, tty bool, terminalSizeQueue term.TerminalSizeQueue) error
+}
+
+// DefaultRemoteExecutor is the standard implementation of remote command execution
+type DefaultRemoteExecutor struct{}
+
+func (*DefaultRemoteExecutor) Execute(method string, url *url.URL, config *restclient.Config, stdin io.Reader, stdout, stderr io.Writer, tty bool, terminalSizeQueue term.TerminalSizeQueue) error {
+	exec, err := remotecommand.NewExecutor(config, method, url)
+	if err != nil {
+		return err
+	}
+	return exec.Stream(remotecommand.StreamOptions{
+		SupportedProtocols: remotecommandserver.SupportedStreamingProtocols,
+		Stdin:              stdin,
+		Stdout:             stdout,
+		Stderr:             stderr,
+		Tty:                tty,
+		TerminalSizeQueue:  terminalSizeQueue,
+	})
+}
+
+type StreamOptions struct {
+	Namespace     string
+	PodName       string
+	ContainerName string
+	Stdin         bool
+	TTY           bool
+	// minimize unnecessary output
+	Quiet bool
+	// InterruptParent, if set, is used to handle interrupts while attached
+	InterruptParent *interrupt.Handler
+	In              io.Reader
+	Out             io.Writer
+	Err             io.Writer
+
+	// for testing
+	overrideStreams func() (io.ReadCloser, io.Writer, io.Writer)
+	isTerminalIn    func(t term.TTY) bool
+}
+
+// ExecOptions declare the arguments accepted by the Exec command
+type ExecOptions struct {
+	StreamOptions
+
+	Command []string
+
+	FullCmdName       string
+	SuggestedCmdUsage string
+
+	Executor  RemoteExecutor
+	PodClient coreclient.PodsGetter
+	Config    *restclient.Config
+}
+
+// Complete verifies command line arguments and loads data from the command environment
+func (p *ExecOptions) Complete(f cmdutil.Factory, cmd *cobra.Command, argsIn []string, argsLenAtDash int) error {
+	// Let kubectl exec follow rules for `--`, see #13004 issue
+	if len(p.PodName) == 0 && (len(argsIn) == 0 || argsLenAtDash == 0) {
+		return cmdutil.UsageError(cmd, execUsageStr)
+	}
+	if len(p.PodName) != 0 {
+		printDeprecationWarning("exec POD_NAME", "-p POD_NAME")
+		if len(argsIn) < 1 {
+			return cmdutil.UsageError(cmd, execUsageStr)
+		}
+		p.Command = argsIn
+	} else {
+		p.PodName = argsIn[0]
+		p.Command = argsIn[1:]
+		if len(p.Command) < 1 {
+			return cmdutil.UsageError(cmd, execUsageStr)
+		}
+	}
+
+	cmdParent := cmd.Parent()
+	if cmdParent != nil {
+		p.FullCmdName = cmdParent.CommandPath()
+	}
+	if len(p.FullCmdName) > 0 && cmdutil.IsSiblingCommandExists(cmd, "describe") {
+		p.SuggestedCmdUsage = fmt.Sprintf("Use '%s describe pod/%s' to see all of the containers in this pod.", p.FullCmdName, p.PodName)
+	}
+
+	namespace, _, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+	p.Namespace = namespace
+
+	config, err := f.ClientConfig()
+	if err != nil {
+		return err
+	}
+	p.Config = config
+
+	clientset, err := f.ClientSet()
+	if err != nil {
+		return err
+	}
+	p.PodClient = clientset.Core()
+
+	return nil
+}
+
+// Validate checks that the provided exec options are specified.
+func (p *ExecOptions) Validate() error {
+	if len(p.PodName) == 0 {
+		return fmt.Errorf("pod name must be specified")
+	}
+	if len(p.Command) == 0 {
+		return fmt.Errorf("you must specify at least one command for the container")
+	}
+	if p.Out == nil || p.Err == nil {
+		return fmt.Errorf("both output and error output must be provided")
+	}
+	if p.Executor == nil || p.PodClient == nil || p.Config == nil {
+		return fmt.Errorf("client, client config, and executor must be provided")
+	}
+	return nil
+}
+
+func (o *StreamOptions) setupTTY() term.TTY {
+	t := term.TTY{
+		Parent: o.InterruptParent,
+		Out:    o.Out,
+	}
+
+	if !o.Stdin {
+		// need to nil out o.In to make sure we don't create a stream for stdin
+		o.In = nil
+		o.TTY = false
+		return t
+	}
+
+	t.In = o.In
+	if !o.TTY {
+		return t
+	}
+
+	if o.isTerminalIn == nil {
+		o.isTerminalIn = func(tty term.TTY) bool {
+			return tty.IsTerminalIn()
+		}
+	}
+	if !o.isTerminalIn(t) {
+		o.TTY = false
+
+		if o.Err != nil {
+			fmt.Fprintln(o.Err, "Unable to use a TTY - input is not a terminal or the right kind of file")
+		}
+
+		return t
+	}
+
+	// if we get to here, the user wants to attach stdin, wants a TTY, and o.In is a terminal, so we
+	// can safely set t.Raw to true
+	t.Raw = true
+
+	if o.overrideStreams == nil {
+		// use dockerterm.StdStreams() to get the right I/O handles on Windows
+		o.overrideStreams = dockerterm.StdStreams
+	}
+	stdin, stdout, _ := o.overrideStreams()
+	o.In = stdin
+	t.In = stdin
+	if o.Out != nil {
+		o.Out = stdout
+		t.Out = stdout
+	}
+
+	return t
+}
+
+// Run executes a validated remote execution against a pod.
+func (p *ExecOptions) Run() error {
+	pod, err := p.PodClient.Pods(p.Namespace).Get(p.PodName)
+	if err != nil {
+		return err
+	}
+
+	if pod.Status.Phase == api.PodSucceeded || pod.Status.Phase == api.PodFailed {
+		return fmt.Errorf("cannot exec into a container in a completed pod; current phase is %s", pod.Status.Phase)
+	}
+
+	containerName := p.ContainerName
+	if len(containerName) == 0 {
+		if len(pod.Spec.Containers) > 1 {
+			usageString := fmt.Sprintf("Defaulting container name to %s.", pod.Spec.Containers[0].Name)
+			if len(p.SuggestedCmdUsage) > 0 {
+				usageString = fmt.Sprintf("%s\n%s", usageString, p.SuggestedCmdUsage)
+			}
+			fmt.Fprintf(p.Err, "%s\n", usageString)
+		}
+		containerName = pod.Spec.Containers[0].Name
+	}
+
+	// ensure we can recover the terminal while attached
+	t := p.setupTTY()
+
+	var sizeQueue term.TerminalSizeQueue
+	if t.Raw {
+		// this call spawns a goroutine to monitor/update the terminal size
+		sizeQueue = t.MonitorSize(t.GetSize())
+
+		// unset p.Err if it was previously set because both stdout and stderr go over p.Out when tty is
+		// true
+		p.Err = nil
+	}
+
+	fn := func() error {
+		restClient, err := restclient.RESTClientFor(p.Config)
+		if err != nil {
+			return err
+		}
+
+		// TODO: consider abstracting into a client invocation or client helper
+		req := restClient.Post().
+			Resource("pods").
+			Name(pod.Name).
+			Namespace(pod.Namespace).
+			SubResource("exec").
+			Param("container", containerName)
+		req.VersionedParams(&api.PodExecOptions{
+			Container: containerName,
+			Command:   p.Command,
+			Stdin:     p.Stdin,
+			Stdout:    p.Out != nil,
+			Stderr:    p.Err != nil,
+			TTY:       t.Raw,
+		}, api.ParameterCodec)
+
+		return p.Executor.Execute("POST", req.URL(), p.Config, p.In, p.Out, p.Err, t.Raw, sizeQueue)
+	}
+
+	if err := t.Safe(fn); err != nil {
+		return err
+	}
+
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/exec_test.go

@@ -0,0 +1,382 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
+	"k8s.io/kubernetes/pkg/client/restclient"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+	"k8s.io/kubernetes/pkg/util/term"
+)
+
+type fakeRemoteExecutor struct {
+	method  string
+	url     *url.URL
+	execErr error
+}
+
+func (f *fakeRemoteExecutor) Execute(method string, url *url.URL, config *restclient.Config, stdin io.Reader, stdout, stderr io.Writer, tty bool, terminalSizeQueue term.TerminalSizeQueue) error {
+	f.method = method
+	f.url = url
+	return f.execErr
+}
+
+func TestPodAndContainer(t *testing.T) {
+	tests := []struct {
+		args              []string
+		argsLenAtDash     int
+		p                 *ExecOptions
+		name              string
+		expectError       bool
+		expectedPod       string
+		expectedContainer string
+		expectedArgs      []string
+	}{
+		{
+			p:             &ExecOptions{},
+			argsLenAtDash: -1,
+			expectError:   true,
+			name:          "empty",
+		},
+		{
+			p:             &ExecOptions{StreamOptions: StreamOptions{PodName: "foo"}},
+			argsLenAtDash: -1,
+			expectError:   true,
+			name:          "no cmd",
+		},
+		{
+			p:             &ExecOptions{StreamOptions: StreamOptions{PodName: "foo", ContainerName: "bar"}},
+			argsLenAtDash: -1,
+			expectError:   true,
+			name:          "no cmd, w/ container",
+		},
+		{
+			p:             &ExecOptions{StreamOptions: StreamOptions{PodName: "foo"}},
+			args:          []string{"cmd"},
+			argsLenAtDash: -1,
+			expectedPod:   "foo",
+			expectedArgs:  []string{"cmd"},
+			name:          "pod in flags",
+		},
+		{
+			p:             &ExecOptions{},
+			args:          []string{"foo", "cmd"},
+			argsLenAtDash: 0,
+			expectError:   true,
+			name:          "no pod, pod name is behind dash",
+		},
+		{
+			p:             &ExecOptions{},
+			args:          []string{"foo"},
+			argsLenAtDash: -1,
+			expectError:   true,
+			name:          "no cmd, w/o flags",
+		},
+		{
+			p:             &ExecOptions{},
+			args:          []string{"foo", "cmd"},
+			argsLenAtDash: -1,
+			expectedPod:   "foo",
+			expectedArgs:  []string{"cmd"},
+			name:          "cmd, w/o flags",
+		},
+		{
+			p:             &ExecOptions{},
+			args:          []string{"foo", "cmd"},
+			argsLenAtDash: 1,
+			expectedPod:   "foo",
+			expectedArgs:  []string{"cmd"},
+			name:          "cmd, cmd is behind dash",
+		},
+		{
+			p:                 &ExecOptions{StreamOptions: StreamOptions{ContainerName: "bar"}},
+			args:              []string{"foo", "cmd"},
+			argsLenAtDash:     -1,
+			expectedPod:       "foo",
+			expectedContainer: "bar",
+			expectedArgs:      []string{"cmd"},
+			name:              "cmd, container in flag",
+		},
+	}
+	for _, test := range tests {
+		f, tf, _, ns := cmdtesting.NewAPIFactory()
+		tf.Client = &fake.RESTClient{
+			NegotiatedSerializer: ns,
+			Client:               fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { return nil, nil }),
+		}
+		tf.Namespace = "test"
+		tf.ClientConfig = defaultClientConfig()
+
+		cmd := &cobra.Command{}
+		options := test.p
+		err := options.Complete(f, cmd, test.args, test.argsLenAtDash)
+		if test.expectError && err == nil {
+			t.Errorf("unexpected non-error (%s)", test.name)
+		}
+		if !test.expectError && err != nil {
+			t.Errorf("unexpected error: %v (%s)", err, test.name)
+		}
+		if err != nil {
+			continue
+		}
+		if options.PodName != test.expectedPod {
+			t.Errorf("expected: %s, got: %s (%s)", test.expectedPod, options.PodName, test.name)
+		}
+		if options.ContainerName != test.expectedContainer {
+			t.Errorf("expected: %s, got: %s (%s)", test.expectedContainer, options.ContainerName, test.name)
+		}
+		if !reflect.DeepEqual(test.expectedArgs, options.Command) {
+			t.Errorf("expected: %v, got %v (%s)", test.expectedArgs, options.Command, test.name)
+		}
+	}
+}
+
+func TestExec(t *testing.T) {
+	version := registered.GroupOrDie(api.GroupName).GroupVersion.Version
+	tests := []struct {
+		name, podPath, execPath, container string
+		pod                                *api.Pod
+		execErr                            bool
+	}{
+		{
+			name:     "pod exec",
+			podPath:  "/api/" + version + "/namespaces/test/pods/foo",
+			execPath: "/api/" + version + "/namespaces/test/pods/foo/exec",
+			pod:      execPod(),
+		},
+		{
+			name:     "pod exec error",
+			podPath:  "/api/" + version + "/namespaces/test/pods/foo",
+			execPath: "/api/" + version + "/namespaces/test/pods/foo/exec",
+			pod:      execPod(),
+			execErr:  true,
+		},
+	}
+	for _, test := range tests {
+		f, tf, codec, ns := cmdtesting.NewAPIFactory()
+		tf.Client = &fake.RESTClient{
+			NegotiatedSerializer: ns,
+			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+				switch p, m := req.URL.Path, req.Method; {
+				case p == test.podPath && m == "GET":
+					body := objBody(codec, test.pod)
+					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
+				default:
+					// Ensures no GET is performed when deleting by name
+					t.Errorf("%s: unexpected request: %s %#v\n%#v", test.name, req.Method, req.URL, req)
+					return nil, fmt.Errorf("unexpected request")
+				}
+			}),
+		}
+		tf.Namespace = "test"
+		tf.ClientConfig = defaultClientConfig()
+		bufOut := bytes.NewBuffer([]byte{})
+		bufErr := bytes.NewBuffer([]byte{})
+		bufIn := bytes.NewBuffer([]byte{})
+		ex := &fakeRemoteExecutor{}
+		if test.execErr {
+			ex.execErr = fmt.Errorf("exec error")
+		}
+		params := &ExecOptions{
+			StreamOptions: StreamOptions{
+				PodName:       "foo",
+				ContainerName: "bar",
+				In:            bufIn,
+				Out:           bufOut,
+				Err:           bufErr,
+			},
+			Executor: ex,
+		}
+		cmd := &cobra.Command{}
+		args := []string{"test", "command"}
+		if err := params.Complete(f, cmd, args, -1); err != nil {
+			t.Fatal(err)
+		}
+		err := params.Run()
+		if test.execErr && err != ex.execErr {
+			t.Errorf("%s: Unexpected exec error: %v", test.name, err)
+			continue
+		}
+		if !test.execErr && err != nil {
+			t.Errorf("%s: Unexpected error: %v", test.name, err)
+			continue
+		}
+		if test.execErr {
+			continue
+		}
+		if ex.url.Path != test.execPath {
+			t.Errorf("%s: Did not get expected path for exec request", test.name)
+			continue
+		}
+		if ex.method != "POST" {
+			t.Errorf("%s: Did not get method for exec request: %s", test.name, ex.method)
+		}
+	}
+}
+
+func execPod() *api.Pod {
+	return &api.Pod{
+		ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "test", ResourceVersion: "10"},
+		Spec: api.PodSpec{
+			RestartPolicy: api.RestartPolicyAlways,
+			DNSPolicy:     api.DNSClusterFirst,
+			Containers: []api.Container{
+				{
+					Name: "bar",
+				},
+			},
+		},
+		Status: api.PodStatus{
+			Phase: api.PodRunning,
+		},
+	}
+}
+
+func TestSetupTTY(t *testing.T) {
+	stderr := &bytes.Buffer{}
+
+	// test 1 - don't attach stdin
+	o := &StreamOptions{
+		// InterruptParent: ,
+		Stdin: false,
+		In:    &bytes.Buffer{},
+		Out:   &bytes.Buffer{},
+		Err:   stderr,
+		TTY:   true,
+	}
+
+	tty := o.setupTTY()
+
+	if o.In != nil {
+		t.Errorf("don't attach stdin: o.In should be nil")
+	}
+	if tty.In != nil {
+		t.Errorf("don't attach stdin: tty.In should be nil")
+	}
+	if o.TTY {
+		t.Errorf("don't attach stdin: o.TTY should be false")
+	}
+	if tty.Raw {
+		t.Errorf("don't attach stdin: tty.Raw should be false")
+	}
+	if len(stderr.String()) > 0 {
+		t.Errorf("don't attach stdin: stderr wasn't empty: %s", stderr.String())
+	}
+
+	// tests from here on attach stdin
+	// test 2 - don't request a TTY
+	o.Stdin = true
+	o.In = &bytes.Buffer{}
+	o.TTY = false
+
+	tty = o.setupTTY()
+
+	if o.In == nil {
+		t.Errorf("attach stdin, no TTY: o.In should not be nil")
+	}
+	if tty.In != o.In {
+		t.Errorf("attach stdin, no TTY: tty.In should equal o.In")
+	}
+	if o.TTY {
+		t.Errorf("attach stdin, no TTY: o.TTY should be false")
+	}
+	if tty.Raw {
+		t.Errorf("attach stdin, no TTY: tty.Raw should be false")
+	}
+	if len(stderr.String()) > 0 {
+		t.Errorf("attach stdin, no TTY: stderr wasn't empty: %s", stderr.String())
+	}
+
+	// test 3 - request a TTY, but stdin is not a terminal
+	o.Stdin = true
+	o.In = &bytes.Buffer{}
+	o.Err = stderr
+	o.TTY = true
+
+	tty = o.setupTTY()
+
+	if o.In == nil {
+		t.Errorf("attach stdin, TTY, not a terminal: o.In should not be nil")
+	}
+	if tty.In != o.In {
+		t.Errorf("attach stdin, TTY, not a terminal: tty.In should equal o.In")
+	}
+	if o.TTY {
+		t.Errorf("attach stdin, TTY, not a terminal: o.TTY should be false")
+	}
+	if tty.Raw {
+		t.Errorf("attach stdin, TTY, not a terminal: tty.Raw should be false")
+	}
+	if !strings.Contains(stderr.String(), "input is not a terminal") {
+		t.Errorf("attach stdin, TTY, not a terminal: expected 'input is not a terminal' to stderr")
+	}
+
+	// test 4 - request a TTY, stdin is a terminal
+	o.Stdin = true
+	o.In = &bytes.Buffer{}
+	stderr.Reset()
+	o.TTY = true
+
+	overrideStdin := ioutil.NopCloser(&bytes.Buffer{})
+	overrideStdout := &bytes.Buffer{}
+	overrideStderr := &bytes.Buffer{}
+	o.overrideStreams = func() (io.ReadCloser, io.Writer, io.Writer) {
+		return overrideStdin, overrideStdout, overrideStderr
+	}
+
+	o.isTerminalIn = func(tty term.TTY) bool {
+		return true
+	}
+
+	tty = o.setupTTY()
+
+	if o.In != overrideStdin {
+		t.Errorf("attach stdin, TTY, is a terminal: o.In should equal overrideStdin")
+	}
+	if tty.In != o.In {
+		t.Errorf("attach stdin, TTY, is a terminal: tty.In should equal o.In")
+	}
+	if !o.TTY {
+		t.Errorf("attach stdin, TTY, is a terminal: o.TTY should be true")
+	}
+	if !tty.Raw {
+		t.Errorf("attach stdin, TTY, is a terminal: tty.Raw should be true")
+	}
+	if len(stderr.String()) > 0 {
+		t.Errorf("attach stdin, TTY, is a terminal: stderr wasn't empty: %s", stderr.String())
+	}
+	if o.Out != overrideStdout {
+		t.Errorf("attach stdin, TTY, is a terminal: o.Out should equal overrideStdout")
+	}
+	if tty.Out != o.Out {
+		t.Errorf("attach stdin, TTY, is a terminal: tty.Out should equal o.Out")
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/explain.go

@@ -0,0 +1,119 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/runtime/schema"
+)
+
+var (
+	explainLong = templates.LongDesc(`
+		Documentation of resources.
+
+		` + valid_resources)
+
+	explainExamples = templates.Examples(`
+		# Get the documentation of the resource and its fields
+		kubectl explain pods
+
+		# Get the documentation of a specific field of a resource
+		kubectl explain pods.spec.containers`)
+)
+
+// NewCmdExplain returns a cobra command for swagger docs
+func NewCmdExplain(f cmdutil.Factory, out, cmdErr io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "explain RESOURCE",
+		Short:   "Documentation of resources",
+		Long:    explainLong,
+		Example: explainExamples,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunExplain(f, out, cmdErr, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmd.Flags().Bool("recursive", false, "Print the fields of fields (Currently only 1 level deep)")
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+	return cmd
+}
+
+// RunExplain executes the appropriate steps to print a model's documentation
+func RunExplain(f cmdutil.Factory, out, cmdErr io.Writer, cmd *cobra.Command, args []string) error {
+	if len(args) == 0 {
+		fmt.Fprint(cmdErr, "You must specify the type of resource to explain. ", valid_resources)
+		return cmdutil.UsageError(cmd, "Required resource not specified.")
+	}
+	if len(args) > 1 {
+		return cmdutil.UsageError(cmd, "We accept only this format: explain RESOURCE")
+	}
+
+	recursive := cmdutil.GetFlagBool(cmd, "recursive")
+	apiVersionString := cmdutil.GetFlagString(cmd, "api-version")
+	apiVersion := schema.GroupVersion{}
+
+	mapper, _ := f.Object()
+	// TODO: After we figured out the new syntax to separate group and resource, allow
+	// the users to use it in explain (kubectl explain <group><syntax><resource>).
+	// Refer to issue #16039 for why we do this. Refer to PR #15808 that used "/" syntax.
+	inModel, fieldsPath, err := kubectl.SplitAndParseResourceRequest(args[0], mapper)
+	if err != nil {
+		return err
+	}
+
+	// TODO: We should deduce the group for a resource by discovering the supported resources at server.
+	fullySpecifiedGVR, groupResource := schema.ParseResourceArg(inModel)
+	gvk := schema.GroupVersionKind{}
+	if fullySpecifiedGVR != nil {
+		gvk, _ = mapper.KindFor(*fullySpecifiedGVR)
+	}
+	if gvk.Empty() {
+		gvk, err = mapper.KindFor(groupResource.WithVersion(""))
+		if err != nil {
+			return err
+		}
+	}
+
+	if len(apiVersionString) == 0 {
+		groupMeta, err := registered.Group(gvk.Group)
+		if err != nil {
+			return err
+		}
+		apiVersion = groupMeta.GroupVersion
+
+	} else {
+		apiVersion, err = schema.ParseGroupVersion(apiVersionString)
+		if err != nil {
+			return nil
+		}
+	}
+
+	schema, err := f.SwaggerSchema(apiVersion.WithKind(gvk.Kind))
+	if err != nil {
+		return err
+	}
+
+	return kubectl.PrintModelDescription(inModel, fieldsPath, out, schema, recursive)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/expose.go

@@ -0,0 +1,282 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"regexp"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/util/validation"
+)
+
+var (
+	expose_resources = `pod (po), service (svc), replicationcontroller (rc), deployment (deploy), replicaset (rs)`
+
+	expose_long = templates.LongDesc(`
+		Expose a resource as a new Kubernetes service.
+
+		Looks up a deployment, service, replica set, replication controller or pod by name and uses the selector
+		for that resource as the selector for a new service on the specified port. A deployment or replica set
+		will be exposed as a service only if its selector is convertible to a selector that service supports,
+		i.e. when the selector contains only the matchLabels component. Note that if no port is specified via
+		--port and the exposed resource has multiple ports, all will be re-used by the new service. Also if no
+		labels are specified, the new service will re-use the labels from the resource it exposes.
+
+		Possible resources include (case insensitive):
+
+		` + expose_resources)
+
+	expose_example = templates.Examples(`
+		# Create a service for a replicated nginx, which serves on port 80 and connects to the containers on port 8000.
+		kubectl expose rc nginx --port=80 --target-port=8000
+
+		# Create a service for a replication controller identified by type and name specified in "nginx-controller.yaml", which serves on port 80 and connects to the containers on port 8000.
+		kubectl expose -f nginx-controller.yaml --port=80 --target-port=8000
+
+		# Create a service for a pod valid-pod, which serves on port 444 with the name "frontend"
+		kubectl expose pod valid-pod --port=444 --name=frontend
+
+		# Create a second service based on the above service, exposing the container port 8443 as port 443 with the name "nginx-https"
+		kubectl expose service nginx --port=443 --target-port=8443 --name=nginx-https
+
+		# Create a service for a replicated streaming application on port 4100 balancing UDP traffic and named 'video-stream'.
+		kubectl expose rc streamer --port=4100 --protocol=udp --name=video-stream
+
+		# Create a service for a replicated nginx using replica set, which serves on port 80 and connects to the containers on port 8000.
+		kubectl expose rs nginx --port=80 --target-port=8000
+
+		# Create a service for an nginx deployment, which serves on port 80 and connects to the containers on port 8000.
+		kubectl expose deployment nginx --port=80 --target-port=8000`)
+)
+
+func NewCmdExposeService(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &resource.FilenameOptions{}
+
+	validArgs, argAliases := []string{}, []string{}
+	resources := regexp.MustCompile(`\s*,`).Split(expose_resources, -1)
+	for _, r := range resources {
+		validArgs = append(validArgs, strings.Fields(r)[0])
+		argAliases = kubectl.ResourceAliases(validArgs)
+	}
+
+	cmd := &cobra.Command{
+		Use:     "expose (-f FILENAME | TYPE NAME) [--port=port] [--protocol=TCP|UDP] [--target-port=number-or-name] [--name=name] [--external-ip=external-ip-of-service] [--type=type]",
+		Short:   "Take a replication controller, service, deployment or pod and expose it as a new Kubernetes Service",
+		Long:    expose_long,
+		Example: expose_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunExpose(f, out, cmd, args, options)
+			cmdutil.CheckErr(err)
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+	cmdutil.AddPrinterFlags(cmd)
+	cmd.Flags().String("generator", "service/v2", "The name of the API generator to use. There are 2 generators: 'service/v1' and 'service/v2'. The only difference between them is that service port in v1 is named 'default', while it is left unnamed in v2. Default is 'service/v2'.")
+	cmd.Flags().String("protocol", "", "The network protocol for the service to be created. Default is 'TCP'.")
+	cmd.Flags().String("port", "", "The port that the service should serve on. Copied from the resource being exposed, if unspecified")
+	cmd.Flags().String("type", "", "Type for this service: ClusterIP, NodePort, or LoadBalancer. Default is 'ClusterIP'.")
+	// TODO: remove create-external-load-balancer in code on or after Aug 25, 2016.
+	cmd.Flags().Bool("create-external-load-balancer", false, "If true, create an external load balancer for this service (trumped by --type). Implementation is cloud provider dependent. Default is 'false'.")
+	cmd.Flags().MarkDeprecated("create-external-load-balancer", "use --type=\"LoadBalancer\" instead")
+	cmd.Flags().String("load-balancer-ip", "", "IP to assign to the Load Balancer. If empty, an ephemeral IP will be created and used (cloud-provider specific).")
+	cmd.Flags().String("selector", "", "A label selector to use for this service. Only equality-based selector requirements are supported. If empty (the default) infer the selector from the replication controller or replica set.")
+	cmd.Flags().StringP("labels", "l", "", "Labels to apply to the service created by this call.")
+	cmd.Flags().String("container-port", "", "Synonym for --target-port")
+	cmd.Flags().MarkDeprecated("container-port", "--container-port will be removed in the future, please use --target-port instead")
+	cmd.Flags().String("target-port", "", "Name or number for the port on the container that the service should direct traffic to. Optional.")
+	cmd.Flags().String("external-ip", "", "Additional external IP address (not managed by Kubernetes) to accept for the service. If this IP is routed to a node, the service can be accessed by this IP in addition to its generated service IP.")
+	cmd.Flags().String("overrides", "", "An inline JSON override for the generated object. If this is non-empty, it is used to override the generated object. Requires that the object supply a valid apiVersion field.")
+	cmd.Flags().String("name", "", "The name for the newly created object.")
+	cmd.Flags().String("session-affinity", "", "If non-empty, set the session affinity for the service to this; legal values: 'None', 'ClientIP'")
+	cmd.Flags().String("cluster-ip", "", "ClusterIP to be assigned to the service. Leave empty to auto-allocate, or set to 'None' to create a headless service.")
+
+	usage := "identifying the resource to expose a service"
+	cmdutil.AddFilenameOptionFlags(cmd, options, usage)
+	cmdutil.AddDryRunFlag(cmd)
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddRecordFlag(cmd)
+	return cmd
+}
+
+func RunExpose(f cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string, options *resource.FilenameOptions) error {
+	namespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	mapper, typer := f.Object()
+	r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
+		ContinueOnError().
+		NamespaceParam(namespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, options).
+		ResourceTypeOrNameArgs(false, args...).
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return cmdutil.UsageError(cmd, err.Error())
+	}
+
+	// Get the generator, setup and validate all required parameters
+	generatorName := cmdutil.GetFlagString(cmd, "generator")
+	generators := f.Generators("expose")
+	generator, found := generators[generatorName]
+	if !found {
+		return cmdutil.UsageError(cmd, fmt.Sprintf("generator %q not found.", generatorName))
+	}
+	names := generator.ParamNames()
+
+	err = r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+
+		mapping := info.ResourceMapping()
+		if err := f.CanBeExposed(mapping.GroupVersionKind.GroupKind()); err != nil {
+			return err
+		}
+
+		params := kubectl.MakeParams(cmd, names)
+		name := info.Name
+		if len(name) > validation.DNS1035LabelMaxLength {
+			name = name[:validation.DNS1035LabelMaxLength]
+		}
+		params["default-name"] = name
+
+		// For objects that need a pod selector, derive it from the exposed object in case a user
+		// didn't explicitly specify one via --selector
+		if s, found := params["selector"]; found && kubectl.IsZero(s) {
+			s, err := f.MapBasedSelectorForObject(info.Object)
+			if err != nil {
+				return cmdutil.UsageError(cmd, fmt.Sprintf("couldn't retrieve selectors via --selector flag or introspection: %s", err))
+			}
+			params["selector"] = s
+		}
+
+		// For objects that need a port, derive it from the exposed object in case a user
+		// didn't explicitly specify one via --port
+		if port, found := params["port"]; found && kubectl.IsZero(port) {
+			ports, err := f.PortsForObject(info.Object)
+			if err != nil {
+				return cmdutil.UsageError(cmd, fmt.Sprintf("couldn't find port via --port flag or introspection: %s", err))
+			}
+			switch len(ports) {
+			case 0:
+				return cmdutil.UsageError(cmd, "couldn't find port via --port flag or introspection")
+			case 1:
+				params["port"] = ports[0]
+			default:
+				params["ports"] = strings.Join(ports, ",")
+			}
+		}
+
+		// Always try to derive protocols from the exposed object, may use
+		// different protocols for different ports.
+		if _, found := params["protocol"]; found {
+			protocolsMap, err := f.ProtocolsForObject(info.Object)
+			if err != nil {
+				return cmdutil.UsageError(cmd, fmt.Sprintf("couldn't find protocol via introspection: %s", err))
+			}
+			if protocols := kubectl.MakeProtocols(protocolsMap); !kubectl.IsZero(protocols) {
+				params["protocols"] = protocols
+			}
+		}
+
+		if kubectl.IsZero(params["labels"]) {
+			labels, err := f.LabelsForObject(info.Object)
+			if err != nil {
+				return err
+			}
+			params["labels"] = kubectl.MakeLabels(labels)
+		}
+		if err = kubectl.ValidateParams(names, params); err != nil {
+			return err
+		}
+		// Check for invalid flags used against the present generator.
+		if err := kubectl.EnsureFlagsValid(cmd, generators, generatorName); err != nil {
+			return err
+		}
+
+		// Generate new object
+		object, err := generator.Generate(params)
+		if err != nil {
+			return err
+		}
+
+		if inline := cmdutil.GetFlagString(cmd, "overrides"); len(inline) > 0 {
+			codec := runtime.NewCodec(f.JSONEncoder(), f.Decoder(true))
+			object, err = cmdutil.Merge(codec, object, inline, mapping.GroupVersionKind.Kind)
+			if err != nil {
+				return err
+			}
+		}
+
+		resourceMapper := &resource.Mapper{
+			ObjectTyper:  typer,
+			RESTMapper:   mapper,
+			ClientMapper: resource.ClientMapperFunc(f.ClientForMapping),
+			Decoder:      f.Decoder(true),
+		}
+		info, err = resourceMapper.InfoForObject(object, nil)
+		if err != nil {
+			return err
+		}
+		if cmdutil.ShouldRecord(cmd, info) {
+			if err := cmdutil.RecordChangeCause(object, f.Command()); err != nil {
+				return err
+			}
+		}
+		info.Refresh(object, true)
+		if cmdutil.GetDryRunFlag(cmd) {
+			if len(cmdutil.GetFlagString(cmd, "output")) > 0 {
+				return f.PrintObject(cmd, mapper, object, out)
+			}
+			cmdutil.PrintSuccess(mapper, false, out, info.Mapping.Resource, info.Name, true, "exposed")
+			return nil
+		}
+		if err := kubectl.CreateOrUpdateAnnotation(cmdutil.GetFlagBool(cmd, cmdutil.ApplyAnnotationsFlag), info, f.JSONEncoder()); err != nil {
+			return err
+		}
+
+		// Serialize the object with the annotation applied.
+		object, err = resource.NewHelper(info.Client, info.Mapping).Create(namespace, false, object)
+		if err != nil {
+			return err
+		}
+
+		if len(cmdutil.GetFlagString(cmd, "output")) > 0 {
+			return f.PrintObject(cmd, mapper, object, out)
+		}
+
+		cmdutil.PrintSuccess(mapper, false, out, info.Mapping.Resource, info.Name, false, "exposed")
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/expose_test.go

@@ -0,0 +1,476 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	"k8s.io/kubernetes/pkg/kubectl"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/util/intstr"
+)
+
+func TestRunExposeService(t *testing.T) {
+	tests := []struct {
+		name     string
+		args     []string
+		ns       string
+		calls    map[string]string
+		input    runtime.Object
+		flags    map[string]string
+		output   runtime.Object
+		expected string
+		status   int
+	}{
+		{
+			name: "expose-service-from-service-no-selector-defined",
+			args: []string{"service", "baz"},
+			ns:   "test",
+			calls: map[string]string{
+				"GET":  "/namespaces/test/services/baz",
+				"POST": "/namespaces/test/services",
+			},
+			input: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "baz", Namespace: "test", ResourceVersion: "12"},
+				Spec: api.ServiceSpec{
+					Selector: map[string]string{"app": "go"},
+				},
+			},
+			flags: map[string]string{"protocol": "UDP", "port": "14", "name": "foo", "labels": "svc=test"},
+			output: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "", Labels: map[string]string{"svc": "test"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Protocol:   api.ProtocolUDP,
+							Port:       14,
+							TargetPort: intstr.FromInt(14),
+						},
+					},
+					Selector: map[string]string{"app": "go"},
+				},
+			},
+			expected: "service \"foo\" exposed",
+			status:   200,
+		},
+		{
+			name: "expose-service-from-service",
+			args: []string{"service", "baz"},
+			ns:   "test",
+			calls: map[string]string{
+				"GET":  "/namespaces/test/services/baz",
+				"POST": "/namespaces/test/services",
+			},
+			input: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "baz", Namespace: "test", ResourceVersion: "12"},
+				Spec: api.ServiceSpec{
+					Selector: map[string]string{"app": "go"},
+				},
+			},
+			flags: map[string]string{"selector": "func=stream", "protocol": "UDP", "port": "14", "name": "foo", "labels": "svc=test"},
+			output: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "", Labels: map[string]string{"svc": "test"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Protocol:   api.ProtocolUDP,
+							Port:       14,
+							TargetPort: intstr.FromInt(14),
+						},
+					},
+					Selector: map[string]string{"func": "stream"},
+				},
+			},
+			expected: "service \"foo\" exposed",
+			status:   200,
+		},
+		{
+			name: "no-name-passed-from-the-cli",
+			args: []string{"service", "mayor"},
+			ns:   "default",
+			calls: map[string]string{
+				"GET":  "/namespaces/default/services/mayor",
+				"POST": "/namespaces/default/services",
+			},
+			input: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "mayor", Namespace: "default", ResourceVersion: "12"},
+				Spec: api.ServiceSpec{
+					Selector: map[string]string{"run": "this"},
+				},
+			},
+			// No --name flag specified below. Service will use the rc's name passed via the 'default-name' parameter
+			flags: map[string]string{"selector": "run=this", "port": "80", "labels": "runas=amayor"},
+			output: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "mayor", Namespace: "", Labels: map[string]string{"runas": "amayor"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Protocol:   api.ProtocolTCP,
+							Port:       80,
+							TargetPort: intstr.FromInt(80),
+						},
+					},
+					Selector: map[string]string{"run": "this"},
+				},
+			},
+			expected: "service \"mayor\" exposed",
+			status:   200,
+		},
+		{
+			name: "expose-service",
+			args: []string{"service", "baz"},
+			ns:   "test",
+			calls: map[string]string{
+				"GET":  "/namespaces/test/services/baz",
+				"POST": "/namespaces/test/services",
+			},
+			input: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "baz", Namespace: "test", ResourceVersion: "12"},
+				Spec: api.ServiceSpec{
+					Selector: map[string]string{"app": "go"},
+				},
+			},
+			flags: map[string]string{"selector": "func=stream", "protocol": "UDP", "port": "14", "name": "foo", "labels": "svc=test", "type": "LoadBalancer", "dry-run": "true"},
+			output: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "", Labels: map[string]string{"svc": "test"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Protocol:   api.ProtocolUDP,
+							Port:       14,
+							TargetPort: intstr.FromInt(14),
+						},
+					},
+					Selector: map[string]string{"func": "stream"},
+					Type:     api.ServiceTypeLoadBalancer,
+				},
+			},
+			status: 200,
+		},
+		{
+			name: "expose-affinity-service",
+			args: []string{"service", "baz"},
+			ns:   "test",
+			calls: map[string]string{
+				"GET":  "/namespaces/test/services/baz",
+				"POST": "/namespaces/test/services",
+			},
+			input: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "baz", Namespace: "test", ResourceVersion: "12"},
+				Spec: api.ServiceSpec{
+					Selector: map[string]string{"app": "go"},
+				},
+			},
+			flags: map[string]string{"selector": "func=stream", "protocol": "UDP", "port": "14", "name": "foo", "labels": "svc=test", "type": "LoadBalancer", "session-affinity": "ClientIP", "dry-run": "true"},
+			output: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "", Labels: map[string]string{"svc": "test"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Protocol:   api.ProtocolUDP,
+							Port:       14,
+							TargetPort: intstr.FromInt(14),
+						},
+					},
+					Selector:        map[string]string{"func": "stream"},
+					Type:            api.ServiceTypeLoadBalancer,
+					SessionAffinity: api.ServiceAffinityClientIP,
+				},
+			},
+			status: 200,
+		},
+		{
+			name: "expose-service-cluster-ip",
+			args: []string{"service", "baz"},
+			ns:   "test",
+			calls: map[string]string{
+				"GET":  "/namespaces/test/services/baz",
+				"POST": "/namespaces/test/services",
+			},
+			input: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "baz", Namespace: "test", ResourceVersion: "12"},
+				Spec: api.ServiceSpec{
+					Selector: map[string]string{"app": "go"},
+				},
+			},
+			flags: map[string]string{"selector": "func=stream", "protocol": "UDP", "port": "14", "name": "foo", "labels": "svc=test", "cluster-ip": "10.10.10.10", "dry-run": "true"},
+			output: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "", Labels: map[string]string{"svc": "test"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Protocol:   api.ProtocolUDP,
+							Port:       14,
+							TargetPort: intstr.FromInt(14),
+						},
+					},
+					Selector:  map[string]string{"func": "stream"},
+					ClusterIP: "10.10.10.10",
+				},
+			},
+			expected: "service \"foo\" exposed",
+			status:   200,
+		},
+		{
+			name: "expose-headless-service",
+			args: []string{"service", "baz"},
+			ns:   "test",
+			calls: map[string]string{
+				"GET":  "/namespaces/test/services/baz",
+				"POST": "/namespaces/test/services",
+			},
+			input: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "baz", Namespace: "test", ResourceVersion: "12"},
+				Spec: api.ServiceSpec{
+					Selector: map[string]string{"app": "go"},
+				},
+			},
+			flags: map[string]string{"selector": "func=stream", "protocol": "UDP", "port": "14", "name": "foo", "labels": "svc=test", "cluster-ip": "None", "dry-run": "true"},
+			output: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "", Labels: map[string]string{"svc": "test"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Protocol:   api.ProtocolUDP,
+							Port:       14,
+							TargetPort: intstr.FromInt(14),
+						},
+					},
+					Selector:  map[string]string{"func": "stream"},
+					ClusterIP: api.ClusterIPNone,
+				},
+			},
+			expected: "service \"foo\" exposed",
+			status:   200,
+		},
+		{
+			name: "expose-from-file",
+			args: []string{},
+			ns:   "test",
+			calls: map[string]string{
+				"GET":  "/namespaces/test/services/redis-master",
+				"POST": "/namespaces/test/services",
+			},
+			input: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "redis-master", Namespace: "test", ResourceVersion: "12"},
+				Spec: api.ServiceSpec{
+					Selector: map[string]string{"app": "go"},
+				},
+			},
+			flags: map[string]string{"filename": "../../../examples/guestbook/redis-master-service.yaml", "selector": "func=stream", "protocol": "UDP", "port": "14", "name": "foo", "labels": "svc=test", "dry-run": "true"},
+			output: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "foo", Labels: map[string]string{"svc": "test"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Protocol:   api.ProtocolUDP,
+							Port:       14,
+							TargetPort: intstr.FromInt(14),
+						},
+					},
+					Selector: map[string]string{"func": "stream"},
+				},
+			},
+			status: 200,
+		},
+		{
+			name: "truncate-name",
+			args: []string{"pod", "a-name-that-is-toooo-big-for-a-service-because-it-can-only-handle-63-characters"},
+			ns:   "test",
+			calls: map[string]string{
+				"GET":  "/namespaces/test/pods/a-name-that-is-toooo-big-for-a-service-because-it-can-only-handle-63-characters",
+				"POST": "/namespaces/test/services",
+			},
+			input: &api.Pod{
+				ObjectMeta: api.ObjectMeta{Name: "baz", Namespace: "test", ResourceVersion: "12"},
+			},
+			flags: map[string]string{"selector": "svc=frompod", "port": "90", "labels": "svc=frompod", "generator": "service/v2"},
+			output: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "a-name-that-is-toooo-big-for-a-service-because-it-can-only-handle-63-characters", Namespace: "", Labels: map[string]string{"svc": "frompod"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Protocol:   api.ProtocolTCP,
+							Port:       90,
+							TargetPort: intstr.FromInt(90),
+						},
+					},
+					Selector: map[string]string{"svc": "frompod"},
+				},
+			},
+			expected: "service \"a-name-that-is-toooo-big-for-a-service-because-it-can-only-hand\" exposed",
+			status:   200,
+		},
+		{
+			name: "expose-multiport-object",
+			args: []string{"service", "foo"},
+			ns:   "test",
+			calls: map[string]string{
+				"GET":  "/namespaces/test/services/foo",
+				"POST": "/namespaces/test/services",
+			},
+			input: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "", Labels: map[string]string{"svc": "multiport"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Protocol:   api.ProtocolTCP,
+							Port:       80,
+							TargetPort: intstr.FromInt(80),
+						},
+						{
+							Protocol:   api.ProtocolTCP,
+							Port:       443,
+							TargetPort: intstr.FromInt(443),
+						},
+					},
+				},
+			},
+			flags: map[string]string{"selector": "svc=fromfoo", "generator": "service/v2", "name": "fromfoo", "dry-run": "true"},
+			output: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "fromfoo", Namespace: "", Labels: map[string]string{"svc": "multiport"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Name:       "port-1",
+							Protocol:   api.ProtocolTCP,
+							Port:       80,
+							TargetPort: intstr.FromInt(80),
+						},
+						{
+							Name:       "port-2",
+							Protocol:   api.ProtocolTCP,
+							Port:       443,
+							TargetPort: intstr.FromInt(443),
+						},
+					},
+					Selector: map[string]string{"svc": "fromfoo"},
+				},
+			},
+			status: 200,
+		},
+		{
+			name: "expose-multiprotocol-object",
+			args: []string{"service", "foo"},
+			ns:   "test",
+			calls: map[string]string{
+				"GET":  "/namespaces/test/services/foo",
+				"POST": "/namespaces/test/services",
+			},
+			input: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "", Labels: map[string]string{"svc": "multiport"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Protocol:   api.ProtocolTCP,
+							Port:       80,
+							TargetPort: intstr.FromInt(80),
+						},
+						{
+							Protocol:   api.ProtocolUDP,
+							Port:       8080,
+							TargetPort: intstr.FromInt(8080),
+						},
+						{
+							Protocol:   api.ProtocolUDP,
+							Port:       8081,
+							TargetPort: intstr.FromInt(8081),
+						},
+					},
+				},
+			},
+			flags: map[string]string{"selector": "svc=fromfoo", "generator": "service/v2", "name": "fromfoo", "dry-run": "true"},
+			output: &api.Service{
+				ObjectMeta: api.ObjectMeta{Name: "fromfoo", Namespace: "", Labels: map[string]string{"svc": "multiport"}},
+				Spec: api.ServiceSpec{
+					Ports: []api.ServicePort{
+						{
+							Name:       "port-1",
+							Protocol:   api.ProtocolTCP,
+							Port:       80,
+							TargetPort: intstr.FromInt(80),
+						},
+						{
+							Name:       "port-2",
+							Protocol:   api.ProtocolUDP,
+							Port:       8080,
+							TargetPort: intstr.FromInt(8080),
+						},
+						{
+							Name:       "port-3",
+							Protocol:   api.ProtocolUDP,
+							Port:       8081,
+							TargetPort: intstr.FromInt(8081),
+						},
+					},
+					Selector: map[string]string{"svc": "fromfoo"},
+				},
+			},
+			status: 200,
+		},
+	}
+
+	for _, test := range tests {
+		f, tf, codec, ns := cmdtesting.NewAPIFactory()
+		tf.Printer = &kubectl.JSONPrinter{}
+		tf.Client = &fake.RESTClient{
+			NegotiatedSerializer: ns,
+			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+				switch p, m := req.URL.Path, req.Method; {
+				case p == test.calls[m] && m == "GET":
+					return &http.Response{StatusCode: test.status, Header: defaultHeader(), Body: objBody(codec, test.input)}, nil
+				case p == test.calls[m] && m == "POST":
+					return &http.Response{StatusCode: test.status, Header: defaultHeader(), Body: objBody(codec, test.output)}, nil
+				default:
+					t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+					return nil, nil
+				}
+			}),
+		}
+		tf.Namespace = test.ns
+		buf := bytes.NewBuffer([]byte{})
+
+		cmd := NewCmdExposeService(f, buf)
+		cmd.SetOutput(buf)
+		for flag, value := range test.flags {
+			cmd.Flags().Set(flag, value)
+		}
+		cmd.Run(cmd, test.args)
+
+		out := buf.String()
+		if _, ok := test.flags["dry-run"]; ok {
+			buf.Reset()
+			if err := tf.Printer.PrintObj(test.output, buf); err != nil {
+				t.Errorf("%s: Unexpected error: %v", test.name, err)
+				continue
+			}
+
+			test.expected = fmt.Sprintf("service %q exposed (dry run)", test.flags["name"])
+		}
+
+		if !strings.Contains(out, test.expected) {
+			t.Errorf("%s: Unexpected output! Expected\n%s\ngot\n%s", test.name, test.expected, out)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/help.go

@@ -0,0 +1,82 @@
+/*
+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 cmd
+
+import (
+	"io"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+var help_long = templates.LongDesc(`
+	Help provides help for any command in the application.
+	Simply type kubectl help [path to command] for full details.`)
+
+func NewCmdHelp(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "help [command] | STRING_TO_SEARCH",
+		Short: "Help about any command",
+		Long:  help_long,
+
+		Run: RunHelp,
+	}
+
+	return cmd
+}
+
+func RunHelp(cmd *cobra.Command, args []string) {
+	foundCmd, _, err := cmd.Root().Find(args)
+
+	// NOTE(andreykurilin): actually, I did not find any cases when foundCmd can be nil,
+	//   but let's make this check since it is included in original code of initHelpCmd
+	//   from github.com/spf13/cobra
+	if foundCmd == nil {
+		cmd.Printf("Unknown help topic %#q.\n", args)
+		cmd.Root().Usage()
+	} else if err != nil {
+		// print error message at first, since it can contain suggestions
+		cmd.Println(err)
+
+		argsString := strings.Join(args, " ")
+		var matchedMsgIsPrinted bool = false
+		for _, foundCmd := range foundCmd.Commands() {
+			if strings.Contains(foundCmd.Short, argsString) {
+				if !matchedMsgIsPrinted {
+					cmd.Printf("Matchers of string '%s' in short descriptions of commands: \n", argsString)
+					matchedMsgIsPrinted = true
+				}
+				cmd.Printf("  %-14s %s\n", foundCmd.Name(), foundCmd.Short)
+			}
+		}
+
+		if !matchedMsgIsPrinted {
+			// if nothing is found, just print usage
+			cmd.Root().Usage()
+		}
+	} else {
+		if len(args) == 0 {
+			// help message for help command :)
+			foundCmd = cmd
+		}
+		helpFunc := foundCmd.HelpFunc()
+		helpFunc(foundCmd, args)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/label.go

@@ -0,0 +1,344 @@
+/*
+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 cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"reflect"
+	"strings"
+
+	"github.com/golang/glog"
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+	utilerrors "k8s.io/kubernetes/pkg/util/errors"
+	"k8s.io/kubernetes/pkg/util/strategicpatch"
+	"k8s.io/kubernetes/pkg/util/validation"
+)
+
+// LabelOptions have the data required to perform the label operation
+type LabelOptions struct {
+	// Filename options
+	resource.FilenameOptions
+
+	// Common user flags
+	overwrite       bool
+	local           bool
+	dryrun          bool
+	all             bool
+	resourceVersion string
+	selector        string
+	outputFormat    string
+
+	// results of arg parsing
+	resources    []string
+	newLabels    map[string]string
+	removeLabels []string
+
+	// Common shared fields
+	out io.Writer
+}
+
+var (
+	label_long = templates.LongDesc(`
+		Update the labels on a resource.
+
+		* A label must begin with a letter or number, and may contain letters, numbers, hyphens, dots, and underscores, up to %[1]d characters.
+		* If --overwrite is true, then existing labels can be overwritten, otherwise attempting to overwrite a label will result in an error.
+		* If --resource-version is specified, then updates will use this resource version, otherwise the existing resource-version will be used.`)
+
+	label_example = templates.Examples(`
+		# Update pod 'foo' with the label 'unhealthy' and the value 'true'.
+		kubectl label pods foo unhealthy=true
+
+		# Update pod 'foo' with the label 'status' and the value 'unhealthy', overwriting any existing value.
+		kubectl label --overwrite pods foo status=unhealthy
+
+		# Update all pods in the namespace
+		kubectl label pods --all status=unhealthy
+
+		# Update a pod identified by the type and name in "pod.json"
+		kubectl label -f pod.json status=unhealthy
+
+		# Update pod 'foo' only if the resource is unchanged from version 1.
+		kubectl label pods foo status=unhealthy --resource-version=1
+
+		# Update pod 'foo' by removing a label named 'bar' if it exists.
+		# Does not require the --overwrite flag.
+		kubectl label pods foo bar-`)
+)
+
+func NewCmdLabel(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &LabelOptions{}
+
+	// retrieve a list of handled resources from printer as valid args
+	validArgs, argAliases := []string{}, []string{}
+	p, err := f.Printer(nil, kubectl.PrintOptions{
+		ColumnLabels: []string{},
+	})
+	cmdutil.CheckErr(err)
+	if p != nil {
+		validArgs = p.HandledResources()
+		argAliases = kubectl.ResourceAliases(validArgs)
+	}
+
+	cmd := &cobra.Command{
+		Use:     "label [--overwrite] (-f FILENAME | TYPE NAME) KEY_1=VAL_1 ... KEY_N=VAL_N [--resource-version=version]",
+		Short:   "Update the labels on a resource",
+		Long:    fmt.Sprintf(label_long, validation.LabelValueMaxLength),
+		Example: label_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := options.Complete(f, out, cmd, args); err != nil {
+				cmdutil.CheckErr(cmdutil.UsageError(cmd, err.Error()))
+			}
+			if err := options.Validate(); err != nil {
+				cmdutil.CheckErr(cmdutil.UsageError(cmd, err.Error()))
+			}
+			cmdutil.CheckErr(options.RunLabel(f, cmd))
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+	cmdutil.AddPrinterFlags(cmd)
+	cmd.Flags().Bool("overwrite", false, "If true, allow labels to be overwritten, otherwise reject label updates that overwrite existing labels.")
+	cmd.Flags().Bool("local", false, "If true, label will NOT contact api-server but run locally.")
+	cmd.Flags().StringP("selector", "l", "", "Selector (label query) to filter on")
+	cmd.Flags().Bool("all", false, "select all resources in the namespace of the specified resource types")
+	cmd.Flags().String("resource-version", "", "If non-empty, the labels update will only succeed if this is the current resource-version for the object. Only valid when specifying a single resource.")
+	usage := "identifying the resource to update the labels"
+	cmdutil.AddFilenameOptionFlags(cmd, &options.FilenameOptions, usage)
+	cmdutil.AddDryRunFlag(cmd)
+	cmdutil.AddRecordFlag(cmd)
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+
+	return cmd
+}
+
+// Complete adapts from the command line args and factory to the data required.
+func (o *LabelOptions) Complete(f cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string) (err error) {
+	o.out = out
+	o.local = cmdutil.GetFlagBool(cmd, "local")
+	o.overwrite = cmdutil.GetFlagBool(cmd, "overwrite")
+	o.all = cmdutil.GetFlagBool(cmd, "all")
+	o.resourceVersion = cmdutil.GetFlagString(cmd, "resource-version")
+	o.selector = cmdutil.GetFlagString(cmd, "selector")
+	o.outputFormat = cmdutil.GetFlagString(cmd, "output")
+	o.dryrun = cmdutil.GetDryRunFlag(cmd)
+
+	resources, labelArgs, err := cmdutil.GetResourcesAndPairs(args, "label")
+	if err != nil {
+		return err
+	}
+	o.resources = resources
+	o.newLabels, o.removeLabels, err = parseLabels(labelArgs)
+	return err
+}
+
+// Validate checks to the LabelOptions to see if there is sufficient information run the command.
+func (o *LabelOptions) Validate() error {
+	if len(o.resources) < 1 && cmdutil.IsFilenameEmpty(o.FilenameOptions.Filenames) {
+		return fmt.Errorf("one or more resources must be specified as <resource> <name> or <resource>/<name>")
+	}
+	if len(o.newLabels) < 1 && len(o.removeLabels) < 1 {
+		return fmt.Errorf("at least one label update is required")
+	}
+	return nil
+}
+
+// RunLabel does the work
+func (o *LabelOptions) RunLabel(f cmdutil.Factory, cmd *cobra.Command) error {
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	changeCause := f.Command()
+	mapper, typer := f.Object()
+	b := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
+		ContinueOnError().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, &o.FilenameOptions).
+		Flatten()
+
+	if !o.local {
+		b = b.SelectorParam(o.selector).
+			ResourceTypeOrNameArgs(o.all, o.resources...).
+			Latest()
+	}
+	one := false
+	r := b.Do().IntoSingular(&one)
+	if err := r.Err(); err != nil {
+		return err
+	}
+
+	// only apply resource version locking on a single resource
+	if !one && len(o.resourceVersion) > 0 {
+		return fmt.Errorf("--resource-version may only be used with a single resource")
+	}
+
+	// TODO: support bulk generic output a la Get
+	return r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+
+		var outputObj runtime.Object
+		dataChangeMsg := "not labeled"
+		if o.dryrun || o.local {
+			err = labelFunc(info.Object, o.overwrite, o.resourceVersion, o.newLabels, o.removeLabels)
+			if err != nil {
+				return err
+			}
+			outputObj = info.Object
+		} else {
+			obj, err := cmdutil.MaybeConvertObject(info.Object, info.Mapping.GroupVersionKind.GroupVersion(), info.Mapping)
+			if err != nil {
+				return err
+			}
+			name, namespace := info.Name, info.Namespace
+			oldData, err := json.Marshal(obj)
+			if err != nil {
+				return err
+			}
+			accessor, err := meta.Accessor(obj)
+			if err != nil {
+				return err
+			}
+			for _, label := range o.removeLabels {
+				if _, ok := accessor.GetLabels()[label]; !ok {
+					fmt.Fprintf(o.out, "label %q not found.\n", label)
+				}
+			}
+
+			if err := labelFunc(obj, o.overwrite, o.resourceVersion, o.newLabels, o.removeLabels); err != nil {
+				return err
+			}
+			if cmdutil.ShouldRecord(cmd, info) {
+				if err := cmdutil.RecordChangeCause(obj, changeCause); err != nil {
+					return err
+				}
+			}
+			newData, err := json.Marshal(obj)
+			if err != nil {
+				return err
+			}
+			if !reflect.DeepEqual(oldData, newData) {
+				dataChangeMsg = "labeled"
+			}
+			patchBytes, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, obj)
+			createdPatch := err == nil
+			if err != nil {
+				glog.V(2).Infof("couldn't compute patch: %v", err)
+			}
+
+			mapping := info.ResourceMapping()
+			client, err := f.ClientForMapping(mapping)
+			if err != nil {
+				return err
+			}
+			helper := resource.NewHelper(client, mapping)
+
+			if createdPatch {
+				outputObj, err = helper.Patch(namespace, name, api.StrategicMergePatchType, patchBytes)
+			} else {
+				outputObj, err = helper.Replace(namespace, name, false, obj)
+			}
+			if err != nil {
+				return err
+			}
+		}
+		if o.outputFormat != "" {
+			return f.PrintObject(cmd, mapper, outputObj, o.out)
+		}
+		cmdutil.PrintSuccess(mapper, false, o.out, info.Mapping.Resource, info.Name, o.dryrun, dataChangeMsg)
+		return nil
+	})
+}
+
+func validateNoOverwrites(accessor meta.Object, labels map[string]string) error {
+	allErrs := []error{}
+	for key := range labels {
+		if value, found := accessor.GetLabels()[key]; found {
+			allErrs = append(allErrs, fmt.Errorf("'%s' already has a value (%s), and --overwrite is false", key, value))
+		}
+	}
+	return utilerrors.NewAggregate(allErrs)
+}
+
+func parseLabels(spec []string) (map[string]string, []string, error) {
+	labels := map[string]string{}
+	var remove []string
+	for _, labelSpec := range spec {
+		if strings.Index(labelSpec, "=") != -1 {
+			parts := strings.Split(labelSpec, "=")
+			if len(parts) != 2 {
+				return nil, nil, fmt.Errorf("invalid label spec: %v", labelSpec)
+			}
+			if errs := validation.IsValidLabelValue(parts[1]); len(errs) != 0 {
+				return nil, nil, fmt.Errorf("invalid label value: %q: %s", labelSpec, strings.Join(errs, ";"))
+			}
+			labels[parts[0]] = parts[1]
+		} else if strings.HasSuffix(labelSpec, "-") {
+			remove = append(remove, labelSpec[:len(labelSpec)-1])
+		} else {
+			return nil, nil, fmt.Errorf("unknown label spec: %v", labelSpec)
+		}
+	}
+	for _, removeLabel := range remove {
+		if _, found := labels[removeLabel]; found {
+			return nil, nil, fmt.Errorf("can not both modify and remove a label in the same command")
+		}
+	}
+	return labels, remove, nil
+}
+
+func labelFunc(obj runtime.Object, overwrite bool, resourceVersion string, labels map[string]string, remove []string) error {
+	accessor, err := meta.Accessor(obj)
+	if err != nil {
+		return err
+	}
+	if !overwrite {
+		if err := validateNoOverwrites(accessor, labels); err != nil {
+			return err
+		}
+	}
+
+	objLabels := accessor.GetLabels()
+	if objLabels == nil {
+		objLabels = make(map[string]string)
+	}
+
+	for key, value := range labels {
+		objLabels[key] = value
+	}
+	for _, label := range remove {
+		delete(objLabels, label)
+	}
+	accessor.SetLabels(objLabels)
+
+	if len(resourceVersion) != 0 {
+		accessor.SetResourceVersion(resourceVersion)
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/label_test.go

@@ -0,0 +1,483 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"net/http"
+	"reflect"
+	"strings"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
+	"k8s.io/kubernetes/pkg/client/restclient"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+func TestValidateLabels(t *testing.T) {
+	tests := []struct {
+		meta      *api.ObjectMeta
+		labels    map[string]string
+		expectErr bool
+		test      string
+	}{
+		{
+			meta: &api.ObjectMeta{
+				Labels: map[string]string{
+					"a": "b",
+					"c": "d",
+				},
+			},
+			labels: map[string]string{
+				"a": "c",
+				"d": "b",
+			},
+			test:      "one shared",
+			expectErr: true,
+		},
+		{
+			meta: &api.ObjectMeta{
+				Labels: map[string]string{
+					"a": "b",
+					"c": "d",
+				},
+			},
+			labels: map[string]string{
+				"b": "d",
+				"c": "a",
+			},
+			test:      "second shared",
+			expectErr: true,
+		},
+		{
+			meta: &api.ObjectMeta{
+				Labels: map[string]string{
+					"a": "b",
+					"c": "d",
+				},
+			},
+			labels: map[string]string{
+				"b": "a",
+				"d": "c",
+			},
+			test: "no overlap",
+		},
+		{
+			meta: &api.ObjectMeta{},
+			labels: map[string]string{
+				"b": "a",
+				"d": "c",
+			},
+			test: "no labels",
+		},
+	}
+	for _, test := range tests {
+		err := validateNoOverwrites(test.meta, test.labels)
+		if test.expectErr && err == nil {
+			t.Errorf("%s: unexpected non-error", test.test)
+		}
+		if !test.expectErr && err != nil {
+			t.Errorf("%s: unexpected error: %v", test.test, err)
+		}
+	}
+}
+
+func TestParseLabels(t *testing.T) {
+	tests := []struct {
+		labels         []string
+		expected       map[string]string
+		expectedRemove []string
+		expectErr      bool
+	}{
+		{
+			labels:   []string{"a=b", "c=d"},
+			expected: map[string]string{"a": "b", "c": "d"},
+		},
+		{
+			labels:   []string{},
+			expected: map[string]string{},
+		},
+		{
+			labels:         []string{"a=b", "c=d", "e-"},
+			expected:       map[string]string{"a": "b", "c": "d"},
+			expectedRemove: []string{"e"},
+		},
+		{
+			labels:    []string{"ab", "c=d"},
+			expectErr: true,
+		},
+		{
+			labels:    []string{"a=b", "c=d", "a-"},
+			expectErr: true,
+		},
+		{
+			labels:   []string{"a="},
+			expected: map[string]string{"a": ""},
+		},
+		{
+			labels:    []string{"a=%^$"},
+			expectErr: true,
+		},
+	}
+	for _, test := range tests {
+		labels, remove, err := parseLabels(test.labels)
+		if test.expectErr && err == nil {
+			t.Errorf("unexpected non-error: %v", test)
+		}
+		if !test.expectErr && err != nil {
+			t.Errorf("unexpected error: %v %v", err, test)
+		}
+		if !reflect.DeepEqual(labels, test.expected) {
+			t.Errorf("expected: %v, got %v", test.expected, labels)
+		}
+		if !reflect.DeepEqual(remove, test.expectedRemove) {
+			t.Errorf("expected: %v, got %v", test.expectedRemove, remove)
+		}
+	}
+}
+
+func TestLabelFunc(t *testing.T) {
+	tests := []struct {
+		obj       runtime.Object
+		overwrite bool
+		version   string
+		labels    map[string]string
+		remove    []string
+		expected  runtime.Object
+		expectErr bool
+	}{
+		{
+			obj: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{"a": "b"},
+				},
+			},
+			labels:    map[string]string{"a": "b"},
+			expectErr: true,
+		},
+		{
+			obj: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{"a": "b"},
+				},
+			},
+			labels:    map[string]string{"a": "c"},
+			overwrite: true,
+			expected: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{"a": "c"},
+				},
+			},
+		},
+		{
+			obj: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{"a": "b"},
+				},
+			},
+			labels: map[string]string{"c": "d"},
+			expected: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{"a": "b", "c": "d"},
+				},
+			},
+		},
+		{
+			obj: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{"a": "b"},
+				},
+			},
+			labels:  map[string]string{"c": "d"},
+			version: "2",
+			expected: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels:          map[string]string{"a": "b", "c": "d"},
+					ResourceVersion: "2",
+				},
+			},
+		},
+		{
+			obj: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{"a": "b"},
+				},
+			},
+			labels: map[string]string{},
+			remove: []string{"a"},
+			expected: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{},
+				},
+			},
+		},
+		{
+			obj: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{"a": "b", "c": "d"},
+				},
+			},
+			labels: map[string]string{"e": "f"},
+			remove: []string{"a"},
+			expected: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{
+						"c": "d",
+						"e": "f",
+					},
+				},
+			},
+		},
+		{
+			obj: &api.Pod{
+				ObjectMeta: api.ObjectMeta{},
+			},
+			labels: map[string]string{"a": "b"},
+			expected: &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{"a": "b"},
+				},
+			},
+		},
+	}
+	for _, test := range tests {
+		err := labelFunc(test.obj, test.overwrite, test.version, test.labels, test.remove)
+		if test.expectErr {
+			if err == nil {
+				t.Errorf("unexpected non-error: %v", test)
+			}
+			continue
+		}
+		if !test.expectErr && err != nil {
+			t.Errorf("unexpected error: %v %v", err, test)
+		}
+		if !reflect.DeepEqual(test.obj, test.expected) {
+			t.Errorf("expected: %v, got %v", test.expected, test.obj)
+		}
+	}
+}
+
+func TestLabelErrors(t *testing.T) {
+	testCases := map[string]struct {
+		args  []string
+		flags map[string]string
+		errFn func(error) bool
+	}{
+		"no args": {
+			args:  []string{},
+			errFn: func(err error) bool { return strings.Contains(err.Error(), "one or more resources must be specified") },
+		},
+		"not enough labels": {
+			args:  []string{"pods"},
+			errFn: func(err error) bool { return strings.Contains(err.Error(), "at least one label update is required") },
+		},
+		"no resources": {
+			args:  []string{"pods-"},
+			errFn: func(err error) bool { return strings.Contains(err.Error(), "one or more resources must be specified") },
+		},
+		"no resources 2": {
+			args:  []string{"pods=bar"},
+			errFn: func(err error) bool { return strings.Contains(err.Error(), "one or more resources must be specified") },
+		},
+		"resources but no selectors": {
+			args: []string{"pods", "app=bar"},
+			errFn: func(err error) bool {
+				return strings.Contains(err.Error(), "resource(s) were provided, but no name, label selector, or --all flag specified")
+			},
+		},
+		"multiple resources but no selectors": {
+			args: []string{"pods,deployments", "app=bar"},
+			errFn: func(err error) bool {
+				return strings.Contains(err.Error(), "resource(s) were provided, but no name, label selector, or --all flag specified")
+			},
+		},
+	}
+
+	for k, testCase := range testCases {
+		f, tf, _, _ := cmdtesting.NewAPIFactory()
+		tf.Printer = &testPrinter{}
+		tf.Namespace = "test"
+		tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}}
+
+		buf := bytes.NewBuffer([]byte{})
+		cmd := NewCmdLabel(f, buf)
+		cmd.SetOutput(buf)
+
+		for k, v := range testCase.flags {
+			cmd.Flags().Set(k, v)
+		}
+		opts := LabelOptions{}
+		err := opts.Complete(f, buf, cmd, testCase.args)
+		if err == nil {
+			err = opts.Validate()
+		}
+		if err == nil {
+			err = opts.RunLabel(f, cmd)
+		}
+		if !testCase.errFn(err) {
+			t.Errorf("%s: unexpected error: %v", k, err)
+			continue
+		}
+		if tf.Printer.(*testPrinter).Objects != nil {
+			t.Errorf("unexpected print to default printer")
+		}
+		if buf.Len() > 0 {
+			t.Errorf("buffer should be empty: %s", string(buf.Bytes()))
+		}
+	}
+}
+
+func TestLabelForResourceFromFile(t *testing.T) {
+	pods, _, _ := testData()
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch req.Method {
+			case "GET":
+				switch req.URL.Path {
+				case "/namespaces/test/replicationcontrollers/cassandra":
+					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil
+				default:
+					t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+					return nil, nil
+				}
+			case "PATCH":
+				switch req.URL.Path {
+				case "/namespaces/test/replicationcontrollers/cassandra":
+					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil
+				default:
+					t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+					return nil, nil
+				}
+			default:
+				t.Fatalf("unexpected request: %s %#v\n%#v", req.Method, req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}}
+
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdLabel(f, buf)
+	opts := LabelOptions{FilenameOptions: resource.FilenameOptions{
+		Filenames: []string{"../../../examples/storage/cassandra/cassandra-controller.yaml"}}}
+	err := opts.Complete(f, buf, cmd, []string{"a=b"})
+	if err == nil {
+		err = opts.Validate()
+	}
+	if err == nil {
+		err = opts.RunLabel(f, cmd)
+	}
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(buf.String(), "labeled") {
+		t.Errorf("did not set labels: %s", buf.String())
+	}
+}
+
+func TestLabelLocal(t *testing.T) {
+	f, tf, _, ns := cmdtesting.NewAPIFactory()
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			t.Fatalf("unexpected request: %s %#v\n%#v", req.Method, req.URL, req)
+			return nil, nil
+		}),
+	}
+	tf.Namespace = "test"
+	tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}}
+
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdLabel(f, buf)
+	cmd.Flags().Set("local", "true")
+	opts := LabelOptions{FilenameOptions: resource.FilenameOptions{
+		Filenames: []string{"../../../examples/storage/cassandra/cassandra-controller.yaml"}}}
+	err := opts.Complete(f, buf, cmd, []string{"a=b"})
+	if err == nil {
+		err = opts.Validate()
+	}
+	if err == nil {
+		err = opts.RunLabel(f, cmd)
+	}
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(buf.String(), "labeled") {
+		t.Errorf("did not set labels: %s", buf.String())
+	}
+}
+
+func TestLabelMultipleObjects(t *testing.T) {
+	pods, _, _ := testData()
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch req.Method {
+			case "GET":
+				switch req.URL.Path {
+				case "/namespaces/test/pods":
+					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, nil
+				default:
+					t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+					return nil, nil
+				}
+			case "PATCH":
+				switch req.URL.Path {
+				case "/namespaces/test/pods/foo":
+					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil
+				case "/namespaces/test/pods/bar":
+					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[1])}, nil
+				default:
+					t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+					return nil, nil
+				}
+			default:
+				t.Fatalf("unexpected request: %s %#v\n%#v", req.Method, req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}}
+
+	buf := bytes.NewBuffer([]byte{})
+	cmd := NewCmdLabel(f, buf)
+	cmd.Flags().Set("all", "true")
+
+	opts := LabelOptions{}
+	err := opts.Complete(f, buf, cmd, []string{"pods", "a=b"})
+	if err == nil {
+		err = opts.Validate()
+	}
+	if err == nil {
+		err = opts.RunLabel(f, cmd)
+	}
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if strings.Count(buf.String(), "labeled") != len(pods.Items) {
+		t.Errorf("not all labels are set: %s", buf.String())
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/logs.go

@@ -0,0 +1,214 @@
+/*
+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 cmd
+
+import (
+	"errors"
+	"io"
+	"math"
+	"os"
+	"time"
+
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/api/validation"
+	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/client/restclient"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+var (
+	logs_example = templates.Examples(`
+		# Return snapshot logs from pod nginx with only one container
+		kubectl logs nginx
+
+		# Return snapshot of previous terminated ruby container logs from pod web-1
+		kubectl logs -p -c ruby web-1
+
+		# Begin streaming the logs of the ruby container in pod web-1
+		kubectl logs -f -c ruby web-1
+
+		# Display only the most recent 20 lines of output in pod nginx
+		kubectl logs --tail=20 nginx
+
+		# Show all logs from pod nginx written in the last hour
+		kubectl logs --since=1h nginx`)
+)
+
+const (
+	logsUsageStr = "expected 'logs POD_NAME [CONTAINER_NAME]'.\nPOD_NAME is a required argument for the logs command"
+)
+
+type LogsOptions struct {
+	Namespace   string
+	ResourceArg string
+	Options     runtime.Object
+
+	Mapper       meta.RESTMapper
+	Typer        runtime.ObjectTyper
+	ClientMapper resource.ClientMapper
+	Decoder      runtime.Decoder
+
+	Object        runtime.Object
+	LogsForObject func(object, options runtime.Object) (*restclient.Request, error)
+
+	Out io.Writer
+}
+
+// NewCmdLog creates a new pod logs command
+func NewCmdLogs(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	o := &LogsOptions{}
+	cmd := &cobra.Command{
+		Use:     "logs [-f] [-p] POD [-c CONTAINER]",
+		Short:   "Print the logs for a container in a pod",
+		Long:    "Print the logs for a container in a pod. If the pod has only one container, the container name is optional.",
+		Example: logs_example,
+		PreRun: func(cmd *cobra.Command, args []string) {
+			if len(os.Args) > 1 && os.Args[1] == "log" {
+				printDeprecationWarning("logs", "log")
+			}
+		},
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(o.Complete(f, out, cmd, args))
+			if err := o.Validate(); err != nil {
+				cmdutil.CheckErr(cmdutil.UsageError(cmd, err.Error()))
+			}
+			_, err := o.RunLogs()
+			cmdutil.CheckErr(err)
+		},
+		Aliases: []string{"log"},
+	}
+	cmd.Flags().BoolP("follow", "f", false, "Specify if the logs should be streamed.")
+	cmd.Flags().Bool("timestamps", false, "Include timestamps on each line in the log output")
+	cmd.Flags().Int64("limit-bytes", 0, "Maximum bytes of logs to return. Defaults to no limit.")
+	cmd.Flags().BoolP("previous", "p", false, "If true, print the logs for the previous instance of the container in a pod if it exists.")
+	cmd.Flags().Int64("tail", -1, "Lines of recent log file to display. Defaults to -1, showing all log lines.")
+	cmd.Flags().String("since-time", "", "Only return logs after a specific date (RFC3339). Defaults to all logs. Only one of since-time / since may be used.")
+	cmd.Flags().Duration("since", 0, "Only return logs newer than a relative duration like 5s, 2m, or 3h. Defaults to all logs. Only one of since-time / since may be used.")
+	cmd.Flags().StringP("container", "c", "", "Print the logs of this container")
+
+	cmd.Flags().Bool("interactive", false, "If true, prompt the user for input when required.")
+	cmd.Flags().MarkDeprecated("interactive", "This flag is no longer respected and there is no replacement.")
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+	return cmd
+}
+
+func (o *LogsOptions) Complete(f cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string) error {
+	containerName := cmdutil.GetFlagString(cmd, "container")
+	switch len(args) {
+	case 0:
+		return cmdutil.UsageError(cmd, logsUsageStr)
+	case 1:
+		o.ResourceArg = args[0]
+	case 2:
+		if cmd.Flag("container").Changed {
+			return cmdutil.UsageError(cmd, "only one of -c or an inline [CONTAINER] arg is allowed")
+		}
+		o.ResourceArg = args[0]
+		containerName = args[1]
+	default:
+		return cmdutil.UsageError(cmd, logsUsageStr)
+	}
+	var err error
+	o.Namespace, _, err = f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	logOptions := &api.PodLogOptions{
+		Container:  containerName,
+		Follow:     cmdutil.GetFlagBool(cmd, "follow"),
+		Previous:   cmdutil.GetFlagBool(cmd, "previous"),
+		Timestamps: cmdutil.GetFlagBool(cmd, "timestamps"),
+	}
+	if sinceTime := cmdutil.GetFlagString(cmd, "since-time"); len(sinceTime) > 0 {
+		t, err := api.ParseRFC3339(sinceTime, metav1.Now)
+		if err != nil {
+			return err
+		}
+		logOptions.SinceTime = &t
+	}
+	if limit := cmdutil.GetFlagInt64(cmd, "limit-bytes"); limit != 0 {
+		logOptions.LimitBytes = &limit
+	}
+	if tail := cmdutil.GetFlagInt64(cmd, "tail"); tail != -1 {
+		logOptions.TailLines = &tail
+	}
+	if sinceSeconds := cmdutil.GetFlagDuration(cmd, "since"); sinceSeconds != 0 {
+		// round up to the nearest second
+		sec := int64(math.Ceil(float64(sinceSeconds) / float64(time.Second)))
+		logOptions.SinceSeconds = &sec
+	}
+	o.Options = logOptions
+	o.LogsForObject = f.LogsForObject
+	o.ClientMapper = resource.ClientMapperFunc(f.ClientForMapping)
+	o.Out = out
+
+	mapper, typer := f.Object()
+	decoder := f.Decoder(true)
+	if o.Object == nil {
+		infos, err := resource.NewBuilder(mapper, typer, o.ClientMapper, decoder).
+			NamespaceParam(o.Namespace).DefaultNamespace().
+			ResourceNames("pods", o.ResourceArg).
+			SingleResourceType().
+			Do().Infos()
+		if err != nil {
+			return err
+		}
+		if len(infos) != 1 {
+			return errors.New("expected a resource")
+		}
+		o.Object = infos[0].Object
+	}
+
+	return nil
+}
+
+func (o LogsOptions) Validate() error {
+	if len(o.ResourceArg) == 0 {
+		return errors.New("a pod must be specified")
+	}
+	logsOptions, ok := o.Options.(*api.PodLogOptions)
+	if !ok {
+		return errors.New("unexpected logs options object")
+	}
+	if errs := validation.ValidatePodLogOptions(logsOptions); len(errs) > 0 {
+		return errs.ToAggregate()
+	}
+
+	return nil
+}
+
+// RunLogs retrieves a pod log
+func (o LogsOptions) RunLogs() (int64, error) {
+	req, err := o.LogsForObject(o.Object, o.Options)
+	if err != nil {
+		return 0, err
+	}
+
+	readCloser, err := req.Stream()
+	if err != nil {
+		return 0, err
+	}
+	defer readCloser.Close()
+
+	return io.Copy(o.Out, readCloser)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/logs_test.go

@@ -0,0 +1,141 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/client/restclient"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+	"k8s.io/kubernetes/pkg/runtime/schema"
+)
+
+func TestLog(t *testing.T) {
+	tests := []struct {
+		name, version, podPath, logPath, container string
+		pod                                        *api.Pod
+	}{
+		{
+			name:    "v1 - pod log",
+			version: "v1",
+			podPath: "/namespaces/test/pods/foo",
+			logPath: "/api/v1/namespaces/test/pods/foo/log",
+			pod:     testPod(),
+		},
+	}
+	for _, test := range tests {
+		logContent := "test log content"
+		f, tf, codec, ns := cmdtesting.NewAPIFactory()
+		tf.Client = &fake.RESTClient{
+			NegotiatedSerializer: ns,
+			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+				switch p, m := req.URL.Path, req.Method; {
+				case p == test.podPath && m == "GET":
+					body := objBody(codec, test.pod)
+					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
+				case p == test.logPath && m == "GET":
+					body := ioutil.NopCloser(bytes.NewBufferString(logContent))
+					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
+				default:
+					// Ensures no GET is performed when deleting by name
+					t.Errorf("%s: unexpected request: %#v\n%#v", test.name, req.URL, req)
+					return nil, nil
+				}
+			}),
+		}
+		tf.Namespace = "test"
+		tf.ClientConfig = &restclient.Config{APIPath: "/api", ContentConfig: restclient.ContentConfig{NegotiatedSerializer: api.Codecs, GroupVersion: &schema.GroupVersion{Version: test.version}}}
+		buf := bytes.NewBuffer([]byte{})
+
+		cmd := NewCmdLogs(f, buf)
+		cmd.Flags().Set("namespace", "test")
+		cmd.Run(cmd, []string{"foo"})
+
+		if buf.String() != logContent {
+			t.Errorf("%s: did not get expected log content. Got: %s", test.name, buf.String())
+		}
+	}
+}
+
+func testPod() *api.Pod {
+	return &api.Pod{
+		ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "test", ResourceVersion: "10"},
+		Spec: api.PodSpec{
+			RestartPolicy: api.RestartPolicyAlways,
+			DNSPolicy:     api.DNSClusterFirst,
+			Containers: []api.Container{
+				{
+					Name: "bar",
+				},
+			},
+		},
+	}
+}
+
+func TestValidateLogFlags(t *testing.T) {
+	f, _, _, _ := cmdtesting.NewAPIFactory()
+
+	tests := []struct {
+		name     string
+		flags    map[string]string
+		expected string
+	}{
+		{
+			name:     "since & since-time",
+			flags:    map[string]string{"since": "1h", "since-time": "2006-01-02T15:04:05Z"},
+			expected: "at most one of `sinceTime` or `sinceSeconds` may be specified",
+		},
+		{
+			name:     "negative limit-bytes",
+			flags:    map[string]string{"limit-bytes": "-100"},
+			expected: "must be greater than 0",
+		},
+		{
+			name:     "negative tail",
+			flags:    map[string]string{"tail": "-100"},
+			expected: "must be greater than or equal to 0",
+		},
+	}
+	for _, test := range tests {
+		cmd := NewCmdLogs(f, bytes.NewBuffer([]byte{}))
+		out := ""
+		for flag, value := range test.flags {
+			cmd.Flags().Set(flag, value)
+		}
+		// checkErr breaks tests in case of errors, plus we just
+		// need to check errors returned by the command validation
+		o := &LogsOptions{}
+		cmd.Run = func(cmd *cobra.Command, args []string) {
+			o.Complete(f, os.Stdout, cmd, args)
+			out = o.Validate().Error()
+		}
+		cmd.Run(cmd, []string{"foo"})
+
+		if !strings.Contains(out, test.expected) {
+			t.Errorf("%s: expected to find:\n\t%s\nfound:\n\t%s\n", test.name, test.expected, out)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/options.go

@@ -0,0 +1,39 @@
+/*
+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 cmd
+
+import (
+	"io"
+
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+
+	"github.com/spf13/cobra"
+)
+
+// NewCmdOptions implements the options command
+func NewCmdOptions(out io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use: "options",
+		Run: func(cmd *cobra.Command, args []string) {
+			cmd.Usage()
+		},
+	}
+
+	templates.UseOptionsTemplates(cmd)
+
+	return cmd
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/patch.go

@@ -0,0 +1,254 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/evanphx/json-patch"
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/util/sets"
+	"k8s.io/kubernetes/pkg/util/strategicpatch"
+	"k8s.io/kubernetes/pkg/util/yaml"
+)
+
+var patchTypes = map[string]api.PatchType{"json": api.JSONPatchType, "merge": api.MergePatchType, "strategic": api.StrategicMergePatchType}
+
+// PatchOptions is the start of the data required to perform the operation.  As new fields are added, add them here instead of
+// referencing the cmd.Flags()
+type PatchOptions struct {
+	resource.FilenameOptions
+
+	Local bool
+
+	OutputFormat string
+}
+
+var (
+	patch_long = templates.LongDesc(`
+		Update field(s) of a resource using strategic merge patch
+
+		JSON and YAML formats are accepted.
+
+		Please refer to the models in https://htmlpreview.github.io/?https://github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions.html to find if a field is mutable.`)
+
+	patch_example = templates.Examples(`
+		# Partially update a node using strategic merge patch
+		kubectl patch node k8s-node-1 -p '{"spec":{"unschedulable":true}}'
+
+		# Partially update a node identified by the type and name specified in "node.json" using strategic merge patch
+		kubectl patch -f node.json -p '{"spec":{"unschedulable":true}}'
+
+		# Update a container's image; spec.containers[*].name is required because it's a merge key
+		kubectl patch pod valid-pod -p '{"spec":{"containers":[{"name":"kubernetes-serve-hostname","image":"new image"}]}}'
+
+		# Update a container's image using a json patch with positional arrays
+		kubectl patch pod valid-pod --type='json' -p='[{"op": "replace", "path": "/spec/containers/0/image", "value":"new image"}]'`)
+)
+
+func NewCmdPatch(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &PatchOptions{}
+
+	// retrieve a list of handled resources from printer as valid args
+	validArgs, argAliases := []string{}, []string{}
+	p, err := f.Printer(nil, kubectl.PrintOptions{
+		ColumnLabels: []string{},
+	})
+	cmdutil.CheckErr(err)
+	if p != nil {
+		validArgs = p.HandledResources()
+		argAliases = kubectl.ResourceAliases(validArgs)
+	}
+
+	cmd := &cobra.Command{
+		Use:     "patch (-f FILENAME | TYPE NAME) -p PATCH",
+		Short:   "Update field(s) of a resource using strategic merge patch",
+		Long:    patch_long,
+		Example: patch_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			options.OutputFormat = cmdutil.GetFlagString(cmd, "output")
+			err := RunPatch(f, out, cmd, args, options)
+			cmdutil.CheckErr(err)
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+	cmd.Flags().StringP("patch", "p", "", "The patch to be applied to the resource JSON file.")
+	cmd.MarkFlagRequired("patch")
+	cmd.Flags().String("type", "strategic", fmt.Sprintf("The type of patch being provided; one of %v", sets.StringKeySet(patchTypes).List()))
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddRecordFlag(cmd)
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+
+	usage := "identifying the resource to update"
+	cmdutil.AddFilenameOptionFlags(cmd, &options.FilenameOptions, usage)
+
+	cmd.Flags().BoolVar(&options.Local, "local", false, "If true, patch will operate on the content of the file, not the server-side resource.")
+
+	return cmd
+}
+
+func RunPatch(f cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string, options *PatchOptions) error {
+	switch {
+	case options.Local && len(args) != 0:
+		return fmt.Errorf("cannot specify --local and server resources")
+	}
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	patchType := api.StrategicMergePatchType
+	patchTypeString := strings.ToLower(cmdutil.GetFlagString(cmd, "type"))
+	if len(patchTypeString) != 0 {
+		ok := false
+		patchType, ok = patchTypes[patchTypeString]
+		if !ok {
+			return cmdutil.UsageError(cmd, fmt.Sprintf("--type must be one of %v, not %q", sets.StringKeySet(patchTypes).List(), patchTypeString))
+		}
+	}
+
+	patch := cmdutil.GetFlagString(cmd, "patch")
+	if len(patch) == 0 {
+		return cmdutil.UsageError(cmd, "Must specify -p to patch")
+	}
+	patchBytes, err := yaml.ToJSON([]byte(patch))
+	if err != nil {
+		return fmt.Errorf("unable to parse %q: %v", patch, err)
+	}
+
+	mapper, typer := f.Object()
+	r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
+		ContinueOnError().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, &options.FilenameOptions).
+		ResourceTypeOrNameArgs(false, args...).
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	count := 0
+	err = r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+		name, namespace := info.Name, info.Namespace
+		mapping := info.ResourceMapping()
+		client, err := f.ClientForMapping(mapping)
+		if err != nil {
+			return err
+		}
+
+		if !options.Local {
+			helper := resource.NewHelper(client, mapping)
+			_, err := helper.Patch(namespace, name, patchType, patchBytes)
+			if err != nil {
+				return err
+			}
+			if cmdutil.ShouldRecord(cmd, info) {
+				// don't return an error on failure.  The patch itself succeeded, its only the hint for that change that failed
+				// don't bother checking for failures of this replace, because a failure to indicate the hint doesn't fail the command
+				// also, don't force the replacement.  If the replacement fails on a resourceVersion conflict, then it means this
+				// record hint is likely to be invalid anyway, so avoid the bad hint
+				patch, err := cmdutil.ChangeResourcePatch(info, f.Command())
+				if err == nil {
+					helper.Patch(info.Namespace, info.Name, api.StrategicMergePatchType, patch)
+				}
+			}
+			count++
+
+			if options.OutputFormat == "name" || len(options.OutputFormat) == 0 {
+				cmdutil.PrintSuccess(mapper, options.OutputFormat == "name", out, "", name, false, "patched")
+			}
+			return nil
+		}
+
+		count++
+
+		patchedObj, err := api.Scheme.DeepCopy(info.VersionedObject)
+		if err != nil {
+			return err
+		}
+		originalObjJS, err := runtime.Encode(api.Codecs.LegacyCodec(mapping.GroupVersionKind.GroupVersion()), info.VersionedObject.(runtime.Object))
+		if err != nil {
+			return err
+		}
+		originalPatchedObjJS, err := getPatchedJSON(patchType, originalObjJS, patchBytes, patchedObj.(runtime.Object))
+		if err != nil {
+			return err
+		}
+		targetObj, err := runtime.Decode(api.Codecs.UniversalDecoder(), originalPatchedObjJS)
+		if err != nil {
+			return err
+		}
+		// TODO: if we ever want to go generic, this allows a clean -o yaml without trying to print columns or anything
+		// rawExtension := &runtime.Unknown{
+		//	Raw: originalPatchedObjJS,
+		// }
+
+		printer, err := f.PrinterForMapping(cmd, mapping, false)
+		if err != nil {
+			return err
+		}
+		if err := printer.PrintObj(targetObj, out); err != nil {
+			return err
+		}
+
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	if count == 0 {
+		return fmt.Errorf("no objects passed to patch")
+	}
+	return nil
+}
+
+func getPatchedJSON(patchType api.PatchType, originalJS, patchJS []byte, obj runtime.Object) ([]byte, error) {
+	switch patchType {
+	case api.JSONPatchType:
+		patchObj, err := jsonpatch.DecodePatch(patchJS)
+		if err != nil {
+			return nil, err
+		}
+		return patchObj.Apply(originalJS)
+
+	case api.MergePatchType:
+		return jsonpatch.MergePatch(originalJS, patchJS)
+
+	case api.StrategicMergePatchType:
+		return strategicpatch.StrategicMergePatchData(originalJS, patchJS, obj)
+
+	default:
+		// only here as a safety net - go-restful filters content-type
+		return nil, fmt.Errorf("unknown Content-Type header for patch: %v", patchType)
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/patch_test.go

@@ -0,0 +1,91 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestPatchObject(t *testing.T) {
+	_, svc, _ := testData()
+
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/services/frontend" && (m == "PATCH" || m == "GET"):
+				return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdPatch(f, buf)
+	cmd.Flags().Set("namespace", "test")
+	cmd.Flags().Set("patch", `{"spec":{"type":"NodePort"}}`)
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{"services/frontend"})
+
+	// uses the name from the file, not the response
+	if buf.String() != "frontend\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}
+
+func TestPatchObjectFromFile(t *testing.T) {
+	_, svc, _ := testData()
+
+	f, tf, codec, ns := cmdtesting.NewAPIFactory()
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/namespaces/test/services/frontend" && (m == "PATCH" || m == "GET"):
+				return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdPatch(f, buf)
+	cmd.Flags().Set("namespace", "test")
+	cmd.Flags().Set("patch", `{"spec":{"type":"NodePort"}}`)
+	cmd.Flags().Set("output", "name")
+	cmd.Flags().Set("filename", "../../../examples/guestbook/frontend-service.yaml")
+	cmd.Run(cmd, []string{})
+
+	// uses the name from the file, not the response
+	if buf.String() != "frontend\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/portforward.go

@@ -0,0 +1,200 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"os/signal"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"
+	"k8s.io/kubernetes/pkg/client/restclient"
+	"k8s.io/kubernetes/pkg/client/unversioned/portforward"
+	"k8s.io/kubernetes/pkg/client/unversioned/remotecommand"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+// PortForwardOptions contains all the options for running the port-forward cli command.
+type PortForwardOptions struct {
+	Namespace     string
+	PodName       string
+	RESTClient    *restclient.RESTClient
+	Config        *restclient.Config
+	PodClient     coreclient.PodsGetter
+	Ports         []string
+	PortForwarder portForwarder
+	StopChannel   chan struct{}
+	ReadyChannel  chan struct{}
+}
+
+var (
+	portforward_example = templates.Examples(`
+		# Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in the pod
+		kubectl port-forward mypod 5000 6000
+
+		# Listen on port 8888 locally, forwarding to 5000 in the pod
+		kubectl port-forward mypod 8888:5000
+
+		# Listen on a random port locally, forwarding to 5000 in the pod
+		kubectl port-forward mypod :5000
+
+		# Listen on a random port locally, forwarding to 5000 in the pod
+		kubectl port-forward  mypod 0:5000`)
+)
+
+func NewCmdPortForward(f cmdutil.Factory, cmdOut, cmdErr io.Writer) *cobra.Command {
+	opts := &PortForwardOptions{
+		PortForwarder: &defaultPortForwarder{
+			cmdOut: cmdOut,
+			cmdErr: cmdErr,
+		},
+	}
+	cmd := &cobra.Command{
+		Use:     "port-forward POD [LOCAL_PORT:]REMOTE_PORT [...[LOCAL_PORT_N:]REMOTE_PORT_N]",
+		Short:   "Forward one or more local ports to a pod",
+		Long:    "Forward one or more local ports to a pod.",
+		Example: portforward_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := opts.Complete(f, cmd, args, cmdOut, cmdErr); err != nil {
+				cmdutil.CheckErr(err)
+			}
+			if err := opts.Validate(); err != nil {
+				cmdutil.CheckErr(cmdutil.UsageError(cmd, err.Error()))
+			}
+			if err := opts.RunPortForward(); err != nil {
+				cmdutil.CheckErr(err)
+			}
+		},
+	}
+	cmd.Flags().StringP("pod", "p", "", "Pod name")
+	// TODO support UID
+	return cmd
+}
+
+type portForwarder interface {
+	ForwardPorts(method string, url *url.URL, opts PortForwardOptions) error
+}
+
+type defaultPortForwarder struct {
+	cmdOut, cmdErr io.Writer
+}
+
+func (f *defaultPortForwarder) ForwardPorts(method string, url *url.URL, opts PortForwardOptions) error {
+	dialer, err := remotecommand.NewExecutor(opts.Config, method, url)
+	if err != nil {
+		return err
+	}
+	fw, err := portforward.New(dialer, opts.Ports, opts.StopChannel, opts.ReadyChannel, f.cmdOut, f.cmdErr)
+	if err != nil {
+		return err
+	}
+	return fw.ForwardPorts()
+}
+
+// Complete completes all the required options for port-forward cmd.
+func (o *PortForwardOptions) Complete(f cmdutil.Factory, cmd *cobra.Command, args []string, cmdOut io.Writer, cmdErr io.Writer) error {
+	var err error
+	o.PodName = cmdutil.GetFlagString(cmd, "pod")
+	if len(o.PodName) == 0 && len(args) == 0 {
+		return cmdutil.UsageError(cmd, "POD is required for port-forward")
+	}
+
+	if len(o.PodName) != 0 {
+		printDeprecationWarning("port-forward POD", "-p POD")
+		o.Ports = args
+	} else {
+		o.PodName = args[0]
+		o.Ports = args[1:]
+	}
+
+	o.Namespace, _, err = f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	clientset, err := f.ClientSet()
+	if err != nil {
+		return err
+	}
+	o.PodClient = clientset.Core()
+
+	o.Config, err = f.ClientConfig()
+	if err != nil {
+		return err
+	}
+	o.RESTClient, err = f.RESTClient()
+	if err != nil {
+		return err
+	}
+
+	o.StopChannel = make(chan struct{}, 1)
+	o.ReadyChannel = make(chan struct{})
+	return nil
+}
+
+// Validate validates all the required options for port-forward cmd.
+func (o PortForwardOptions) Validate() error {
+	if len(o.PodName) == 0 {
+		return fmt.Errorf("pod name must be specified")
+	}
+
+	if len(o.Ports) < 1 {
+		return fmt.Errorf("at least 1 PORT is required for port-forward")
+	}
+
+	if o.PortForwarder == nil || o.PodClient == nil || o.RESTClient == nil || o.Config == nil {
+		return fmt.Errorf("client, client config, restClient, and portforwarder must be provided")
+	}
+	return nil
+}
+
+// RunPortForward implements all the necessary functionality for port-forward cmd.
+func (o PortForwardOptions) RunPortForward() error {
+	pod, err := o.PodClient.Pods(o.Namespace).Get(o.PodName)
+	if err != nil {
+		return err
+	}
+
+	if pod.Status.Phase != api.PodRunning {
+		return fmt.Errorf("unable to forward port because pod is not running. Current status=%v", pod.Status.Phase)
+	}
+
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, os.Interrupt)
+	defer signal.Stop(signals)
+
+	go func() {
+		<-signals
+		if o.StopChannel != nil {
+			close(o.StopChannel)
+		}
+	}()
+
+	req := o.RESTClient.Post().
+		Resource("pods").
+		Namespace(o.Namespace).
+		Name(pod.Name).
+		SubResource("portforward")
+
+	return o.PortForwarder.ForwardPorts("POST", req.URL(), o)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/portforward_test.go

@@ -0,0 +1,136 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"os"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+type fakePortForwarder struct {
+	method string
+	url    *url.URL
+	pfErr  error
+}
+
+func (f *fakePortForwarder) ForwardPorts(method string, url *url.URL, opts PortForwardOptions) error {
+	f.method = method
+	f.url = url
+	return f.pfErr
+}
+
+func testPortForward(t *testing.T, flags map[string]string, args []string) {
+	version := registered.GroupOrDie(api.GroupName).GroupVersion.Version
+
+	tests := []struct {
+		name                       string
+		podPath, pfPath, container string
+		pod                        *api.Pod
+		pfErr                      bool
+	}{
+		{
+			name:    "pod portforward",
+			podPath: "/api/" + version + "/namespaces/test/pods/foo",
+			pfPath:  "/api/" + version + "/namespaces/test/pods/foo/portforward",
+			pod:     execPod(),
+		},
+		{
+			name:    "pod portforward error",
+			podPath: "/api/" + version + "/namespaces/test/pods/foo",
+			pfPath:  "/api/" + version + "/namespaces/test/pods/foo/portforward",
+			pod:     execPod(),
+			pfErr:   true,
+		},
+	}
+	for _, test := range tests {
+		var err error
+		f, tf, codec, ns := cmdtesting.NewAPIFactory()
+		tf.Client = &fake.RESTClient{
+			NegotiatedSerializer: ns,
+			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+				switch p, m := req.URL.Path, req.Method; {
+				case p == test.podPath && m == "GET":
+					body := objBody(codec, test.pod)
+					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
+				default:
+					// Ensures no GET is performed when deleting by name
+					t.Errorf("%s: unexpected request: %#v\n%#v", test.name, req.URL, req)
+					return nil, nil
+				}
+			}),
+		}
+		tf.Namespace = "test"
+		tf.ClientConfig = defaultClientConfig()
+		ff := &fakePortForwarder{}
+		if test.pfErr {
+			ff.pfErr = fmt.Errorf("pf error")
+		}
+
+		opts := &PortForwardOptions{}
+		cmd := NewCmdPortForward(f, os.Stdout, os.Stderr)
+		cmd.Run = func(cmd *cobra.Command, args []string) {
+			if err = opts.Complete(f, cmd, args, os.Stdout, os.Stderr); err != nil {
+				return
+			}
+			opts.PortForwarder = ff
+			if err = opts.Validate(); err != nil {
+				return
+			}
+			err = opts.RunPortForward()
+		}
+
+		for name, value := range flags {
+			cmd.Flags().Set(name, value)
+		}
+		cmd.Run(cmd, args)
+
+		if test.pfErr && err != ff.pfErr {
+			t.Errorf("%s: Unexpected port-forward error: %v", test.name, err)
+		}
+		if !test.pfErr && err != nil {
+			t.Errorf("%s: Unexpected error: %v", test.name, err)
+		}
+		if test.pfErr {
+			continue
+		}
+
+		if ff.url.Path != test.pfPath {
+			t.Errorf("%s: Did not get expected path for portforward request", test.name)
+		}
+		if ff.method != "POST" {
+			t.Errorf("%s: Did not get method for attach request: %s", test.name, ff.method)
+		}
+	}
+}
+
+func TestPortForward(t *testing.T) {
+	testPortForward(t, nil, []string{"foo", ":5000", ":1000"})
+}
+
+func TestPortForwardWithPFlag(t *testing.T) {
+	testPortForward(t, map[string]string{"pod": "foo"}, []string{":5000", ":1000"})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/proxy.go

@@ -0,0 +1,141 @@
+/*
+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 cmd
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"strings"
+
+	"github.com/golang/glog"
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+var (
+	default_port = 8001
+	proxy_long   = templates.LongDesc(`
+		To proxy all of the kubernetes api and nothing else, use:
+
+		    $ kubectl proxy --api-prefix=/
+
+		To proxy only part of the kubernetes api and also some static files:
+
+		    $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-prefix=/api/
+
+		The above lets you 'curl localhost:8001/api/v1/pods'.
+
+		To proxy the entire kubernetes api at a different root, use:
+
+		    $ kubectl proxy --api-prefix=/custom/
+
+		The above lets you 'curl localhost:8001/custom/api/v1/pods'`)
+
+	proxy_example = templates.Examples(`
+		# Run a proxy to kubernetes apiserver on port 8011, serving static content from ./local/www/
+		kubectl proxy --port=8011 --www=./local/www/
+
+		# Run a proxy to kubernetes apiserver on an arbitrary local port.
+		# The chosen port for the server will be output to stdout.
+		kubectl proxy --port=0
+
+		# Run a proxy to kubernetes apiserver, changing the api prefix to k8s-api
+		# This makes e.g. the pods api available at localhost:8001/k8s-api/v1/pods/
+		kubectl proxy --api-prefix=/k8s-api`)
+)
+
+func NewCmdProxy(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "proxy [--port=PORT] [--www=static-dir] [--www-prefix=prefix] [--api-prefix=prefix]",
+		Short:   "Run a proxy to the Kubernetes API server",
+		Long:    proxy_long,
+		Example: proxy_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunProxy(f, out, cmd)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmd.Flags().StringP("www", "w", "", "Also serve static files from the given directory under the specified prefix.")
+	cmd.Flags().StringP("www-prefix", "P", "/static/", "Prefix to serve static files under, if static file directory is specified.")
+	cmd.Flags().StringP("api-prefix", "", "/", "Prefix to serve the proxied API under.")
+	cmd.Flags().String("accept-paths", kubectl.DefaultPathAcceptRE, "Regular expression for paths that the proxy should accept.")
+	cmd.Flags().String("reject-paths", kubectl.DefaultPathRejectRE, "Regular expression for paths that the proxy should reject.")
+	cmd.Flags().String("accept-hosts", kubectl.DefaultHostAcceptRE, "Regular expression for hosts that the proxy should accept.")
+	cmd.Flags().String("reject-methods", kubectl.DefaultMethodRejectRE, "Regular expression for HTTP methods that the proxy should reject.")
+	cmd.Flags().IntP("port", "p", default_port, "The port on which to run the proxy. Set to 0 to pick a random port.")
+	cmd.Flags().StringP("address", "", "127.0.0.1", "The IP address on which to serve on.")
+	cmd.Flags().Bool("disable-filter", false, "If true, disable request filtering in the proxy. This is dangerous, and can leave you vulnerable to XSRF attacks, when used with an accessible port.")
+	cmd.Flags().StringP("unix-socket", "u", "", "Unix socket on which to run the proxy.")
+	return cmd
+}
+
+func RunProxy(f cmdutil.Factory, out io.Writer, cmd *cobra.Command) error {
+	path := cmdutil.GetFlagString(cmd, "unix-socket")
+	port := cmdutil.GetFlagInt(cmd, "port")
+	address := cmdutil.GetFlagString(cmd, "address")
+
+	if port != default_port && path != "" {
+		return errors.New("Don't specify both --unix-socket and --port")
+	}
+
+	clientConfig, err := f.ClientConfig()
+	if err != nil {
+		return err
+	}
+
+	staticPrefix := cmdutil.GetFlagString(cmd, "www-prefix")
+	if !strings.HasSuffix(staticPrefix, "/") {
+		staticPrefix += "/"
+	}
+
+	apiProxyPrefix := cmdutil.GetFlagString(cmd, "api-prefix")
+	if !strings.HasSuffix(apiProxyPrefix, "/") {
+		apiProxyPrefix += "/"
+	}
+	filter := &kubectl.FilterServer{
+		AcceptPaths: kubectl.MakeRegexpArrayOrDie(cmdutil.GetFlagString(cmd, "accept-paths")),
+		RejectPaths: kubectl.MakeRegexpArrayOrDie(cmdutil.GetFlagString(cmd, "reject-paths")),
+		AcceptHosts: kubectl.MakeRegexpArrayOrDie(cmdutil.GetFlagString(cmd, "accept-hosts")),
+	}
+	if cmdutil.GetFlagBool(cmd, "disable-filter") {
+		if path == "" {
+			glog.Warning("Request filter disabled, your proxy is vulnerable to XSRF attacks, please be cautious")
+		}
+		filter = nil
+	}
+
+	server, err := kubectl.NewProxyServer(cmdutil.GetFlagString(cmd, "www"), apiProxyPrefix, staticPrefix, filter, clientConfig)
+
+	// Separate listening from serving so we can report the bound port
+	// when it is chosen by os (eg: port == 0)
+	var l net.Listener
+	if path == "" {
+		l, err = server.Listen(address, port)
+	} else {
+		l, err = server.ListenUnix(path)
+	}
+	if err != nil {
+		glog.Fatal(err)
+	}
+	fmt.Fprintf(out, "Starting to serve on %s", l.Addr().String())
+	glog.Fatal(server.ServeOnListener(l))
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/replace.go

@@ -0,0 +1,297 @@
+/*
+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 cmd
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/spf13/cobra"
+
+	"github.com/golang/glog"
+	"k8s.io/kubernetes/pkg/api/errors"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/util/wait"
+)
+
+var (
+	replace_long = templates.LongDesc(`
+		Replace a resource by filename or stdin.
+
+		JSON and YAML formats are accepted. If replacing an existing resource, the
+		complete resource spec must be provided. This can be obtained by
+
+		    $ kubectl get TYPE NAME -o yaml
+
+		Please refer to the models in https://htmlpreview.github.io/?https://github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions.html to find if a field is mutable.`)
+
+	replace_example = templates.Examples(`
+		# Replace a pod using the data in pod.json.
+		kubectl replace -f ./pod.json
+
+		# Replace a pod based on the JSON passed into stdin.
+		cat pod.json | kubectl replace -f -
+
+		# Update a single-container pod's image version (tag) to v4
+		kubectl get pod mypod -o yaml | sed 's/\(image: myimage\):.*$/\1:v4/' | kubectl replace -f -
+
+		# Force replace, delete and then re-create the resource
+		kubectl replace --force -f ./pod.json`)
+)
+
+func NewCmdReplace(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &resource.FilenameOptions{}
+
+	cmd := &cobra.Command{
+		Use: "replace -f FILENAME",
+		// update is deprecated.
+		Aliases: []string{"update"},
+		Short:   "Replace a resource by filename or stdin",
+		Long:    replace_long,
+		Example: replace_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(cmdutil.ValidateOutputArgs(cmd))
+			err := RunReplace(f, out, cmd, args, options)
+			cmdutil.CheckErr(err)
+		},
+	}
+	usage := "to use to replace the resource."
+	cmdutil.AddFilenameOptionFlags(cmd, options, usage)
+	cmd.MarkFlagRequired("filename")
+	cmd.Flags().Bool("force", false, "Delete and re-create the specified resource")
+	cmd.Flags().Bool("cascade", false, "Only relevant during a force replace. If true, cascade the deletion of the resources managed by this resource (e.g. Pods created by a ReplicationController).")
+	cmd.Flags().Int("grace-period", -1, "Only relevant during a force replace. Period of time in seconds given to the old resource to terminate gracefully. Ignored if negative.")
+	cmd.Flags().Duration("timeout", 0, "Only relevant during a force replace. The length of time to wait before giving up on a delete of the old resource, zero means determine a timeout from the size of the object. Any other values should contain a corresponding time unit (e.g. 1s, 2m, 3h).")
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddOutputFlagsForMutation(cmd)
+	cmdutil.AddApplyAnnotationFlags(cmd)
+	cmdutil.AddRecordFlag(cmd)
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+
+	return cmd
+}
+
+func RunReplace(f cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string, options *resource.FilenameOptions) error {
+	if len(os.Args) > 1 && os.Args[1] == "update" {
+		printDeprecationWarning("replace", "update")
+	}
+	schema, err := f.Validator(cmdutil.GetFlagBool(cmd, "validate"), cmdutil.GetFlagString(cmd, "schema-cache-dir"))
+	if err != nil {
+		return err
+	}
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	force := cmdutil.GetFlagBool(cmd, "force")
+	if cmdutil.IsFilenameEmpty(options.Filenames) {
+		return cmdutil.UsageError(cmd, "Must specify --filename to replace")
+	}
+
+	shortOutput := cmdutil.GetFlagString(cmd, "output") == "name"
+	if force {
+		return forceReplace(f, out, cmd, args, shortOutput, options)
+	}
+
+	if cmdutil.GetFlagInt(cmd, "grace-period") >= 0 {
+		return fmt.Errorf("--grace-period must have --force specified")
+	}
+
+	if cmdutil.GetFlagDuration(cmd, "timeout") != 0 {
+		return fmt.Errorf("--timeout must have --force specified")
+	}
+
+	mapper, typer, err := f.UnstructuredObject()
+	if err != nil {
+		return err
+	}
+	r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.UnstructuredClientForMapping), runtime.UnstructuredJSONScheme).
+		Schema(schema).
+		ContinueOnError().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, options).
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	return r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if err := kubectl.CreateOrUpdateAnnotation(cmdutil.GetFlagBool(cmd, cmdutil.ApplyAnnotationsFlag), info, f.JSONEncoder()); err != nil {
+			return cmdutil.AddSourceToErr("replacing", info.Source, err)
+		}
+
+		if cmdutil.ShouldRecord(cmd, info) {
+			if err := cmdutil.RecordChangeCause(info.Object, f.Command()); err != nil {
+				return cmdutil.AddSourceToErr("replacing", info.Source, err)
+			}
+		}
+
+		// Serialize the object with the annotation applied.
+		obj, err := resource.NewHelper(info.Client, info.Mapping).Replace(info.Namespace, info.Name, true, info.Object)
+		if err != nil {
+			return cmdutil.AddSourceToErr("replacing", info.Source, err)
+		}
+
+		info.Refresh(obj, true)
+		f.PrintObjectSpecificMessage(obj, out)
+		cmdutil.PrintSuccess(mapper, shortOutput, out, info.Mapping.Resource, info.Name, false, "replaced")
+		return nil
+	})
+}
+
+func forceReplace(f cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string, shortOutput bool, options *resource.FilenameOptions) error {
+	schema, err := f.Validator(cmdutil.GetFlagBool(cmd, "validate"), cmdutil.GetFlagString(cmd, "schema-cache-dir"))
+	if err != nil {
+		return err
+	}
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	for i, filename := range options.Filenames {
+		if filename == "-" {
+			tempDir, err := ioutil.TempDir("", "kubectl_replace_")
+			if err != nil {
+				return err
+			}
+			defer os.RemoveAll(tempDir)
+			tempFilename := filepath.Join(tempDir, "resource.stdin")
+			err = cmdutil.DumpReaderToFile(os.Stdin, tempFilename)
+			if err != nil {
+				return err
+			}
+			options.Filenames[i] = tempFilename
+		}
+	}
+
+	mapper, typer, err := f.UnstructuredObject()
+	if err != nil {
+		return err
+	}
+	r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.UnstructuredClientForMapping), runtime.UnstructuredJSONScheme).
+		ContinueOnError().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, options).
+		ResourceTypeOrNameArgs(false, args...).RequireObject(false).
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+	//Replace will create a resource if it doesn't exist already, so ignore not found error
+	ignoreNotFound := true
+	timeout := cmdutil.GetFlagDuration(cmd, "timeout")
+	gracePeriod := cmdutil.GetFlagInt(cmd, "grace-period")
+	waitForDeletion := false
+	if gracePeriod == 0 {
+		// To preserve backwards compatibility, but prevent accidental data loss, we convert --grace-period=0
+		// into --grace-period=1 and wait until the object is successfully deleted.
+		gracePeriod = 1
+		waitForDeletion = true
+	}
+	// By default use a reaper to delete all related resources.
+	if cmdutil.GetFlagBool(cmd, "cascade") {
+		glog.Warningf("\"cascade\" is set, kubectl will delete and re-create all resources managed by this resource (e.g. Pods created by a ReplicationController). Consider using \"kubectl rolling-update\" if you want to update a ReplicationController together with its Pods.")
+		err = ReapResult(r, f, out, cmdutil.GetFlagBool(cmd, "cascade"), ignoreNotFound, timeout, gracePeriod, waitForDeletion, shortOutput, mapper, false)
+	} else {
+		err = DeleteResult(r, out, ignoreNotFound, shortOutput, mapper)
+	}
+	if err != nil {
+		return err
+	}
+
+	if timeout == 0 {
+		timeout = kubectl.Timeout
+	}
+	r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+
+		return wait.PollImmediate(kubectl.Interval, timeout, func() (bool, error) {
+			if err := info.Get(); !errors.IsNotFound(err) {
+				return false, err
+			}
+			return true, nil
+		})
+	})
+
+	r = resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.UnstructuredClientForMapping), runtime.UnstructuredJSONScheme).
+		Schema(schema).
+		ContinueOnError().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, options).
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	count := 0
+	err = r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if err := kubectl.CreateOrUpdateAnnotation(cmdutil.GetFlagBool(cmd, cmdutil.ApplyAnnotationsFlag), info, f.JSONEncoder()); err != nil {
+			return err
+		}
+
+		if cmdutil.ShouldRecord(cmd, info) {
+			if err := cmdutil.RecordChangeCause(info.Object, f.Command()); err != nil {
+				return cmdutil.AddSourceToErr("replacing", info.Source, err)
+			}
+		}
+
+		obj, err := resource.NewHelper(info.Client, info.Mapping).Create(info.Namespace, true, info.Object)
+		if err != nil {
+			return err
+		}
+
+		count++
+		info.Refresh(obj, true)
+		f.PrintObjectSpecificMessage(obj, out)
+		cmdutil.PrintSuccess(mapper, shortOutput, out, info.Mapping.Resource, info.Name, false, "replaced")
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	if count == 0 {
+		return fmt.Errorf("no objects passed to replace")
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/replace_test.go

@@ -0,0 +1,249 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"net/http"
+	"strings"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	"k8s.io/kubernetes/pkg/client/typed/dynamic"
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestReplaceObject(t *testing.T) {
+	_, _, rc := testData()
+
+	f, tf, codec, _ := cmdtesting.NewAPIFactory()
+	ns := dynamic.ContentConfig().NegotiatedSerializer
+	tf.Printer = &testPrinter{}
+	deleted := false
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/api/v1/namespaces/test" && m == http.MethodGet:
+				return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, &api.Namespace{})}, nil
+			case p == "/namespaces/test/replicationcontrollers/redis-master" && m == http.MethodDelete:
+				deleted = true
+				fallthrough
+			case p == "/namespaces/test/replicationcontrollers/redis-master" && m == http.MethodPut:
+				return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			case p == "/namespaces/test/replicationcontrollers/redis-master" && m == http.MethodGet:
+				statusCode := http.StatusOK
+				if deleted {
+					statusCode = http.StatusNotFound
+				}
+				return &http.Response{StatusCode: statusCode, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			case p == "/namespaces/test/replicationcontrollers" && m == http.MethodPost:
+				return &http.Response{StatusCode: http.StatusCreated, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdReplace(f, buf)
+	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	// uses the name from the file, not the response
+	if buf.String() != "replicationcontroller/rc1\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+
+	buf.Reset()
+	cmd.Flags().Set("force", "true")
+	cmd.Flags().Set("cascade", "false")
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	if buf.String() != "replicationcontroller/redis-master\nreplicationcontroller/rc1\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}
+
+func TestReplaceMultipleObject(t *testing.T) {
+	_, svc, rc := testData()
+
+	f, tf, codec, _ := cmdtesting.NewAPIFactory()
+	ns := dynamic.ContentConfig().NegotiatedSerializer
+	tf.Printer = &testPrinter{}
+	redisMasterDeleted := false
+	frontendDeleted := false
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/api/v1/namespaces/test" && m == http.MethodGet:
+				return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, &api.Namespace{})}, nil
+			case p == "/namespaces/test/replicationcontrollers/redis-master" && m == http.MethodDelete:
+				redisMasterDeleted = true
+				fallthrough
+			case p == "/namespaces/test/replicationcontrollers/redis-master" && m == http.MethodPut:
+				return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			case p == "/namespaces/test/replicationcontrollers/redis-master" && m == http.MethodGet:
+				statusCode := http.StatusOK
+				if redisMasterDeleted {
+					statusCode = http.StatusNotFound
+				}
+				return &http.Response{StatusCode: statusCode, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			case p == "/namespaces/test/replicationcontrollers" && m == http.MethodPost:
+				return &http.Response{StatusCode: http.StatusCreated, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			case p == "/namespaces/test/services/frontend" && m == http.MethodDelete:
+				frontendDeleted = true
+				fallthrough
+			case p == "/namespaces/test/services/frontend" && m == http.MethodPut:
+				return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil
+			case p == "/namespaces/test/services/frontend" && m == http.MethodGet:
+				statusCode := http.StatusOK
+				if frontendDeleted {
+					statusCode = http.StatusNotFound
+				}
+				return &http.Response{StatusCode: statusCode, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil
+			case p == "/namespaces/test/services" && m == http.MethodPost:
+				return &http.Response{StatusCode: http.StatusCreated, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdReplace(f, buf)
+	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
+	cmd.Flags().Set("filename", "../../../examples/guestbook/frontend-service.yaml")
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	if buf.String() != "replicationcontroller/rc1\nservice/baz\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+
+	buf.Reset()
+	cmd.Flags().Set("force", "true")
+	cmd.Flags().Set("cascade", "false")
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	if buf.String() != "replicationcontroller/redis-master\nservice/frontend\nreplicationcontroller/rc1\nservice/baz\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}
+
+func TestReplaceDirectory(t *testing.T) {
+	_, _, rc := testData()
+
+	f, tf, codec, _ := cmdtesting.NewAPIFactory()
+	ns := dynamic.ContentConfig().NegotiatedSerializer
+	tf.Printer = &testPrinter{}
+	created := map[string]bool{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/api/v1/namespaces/test" && m == http.MethodGet:
+				return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, &api.Namespace{})}, nil
+			case strings.HasPrefix(p, "/namespaces/test/replicationcontrollers/") && m == http.MethodPut:
+				created[p] = true
+				return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			case strings.HasPrefix(p, "/namespaces/test/replicationcontrollers/") && m == http.MethodGet:
+				statusCode := http.StatusNotFound
+				if created[p] {
+					statusCode = http.StatusOK
+				}
+				return &http.Response{StatusCode: statusCode, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			case strings.HasPrefix(p, "/namespaces/test/replicationcontrollers/") && m == http.MethodDelete:
+				delete(created, p)
+				return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			case strings.HasPrefix(p, "/namespaces/test/replicationcontrollers") && m == http.MethodPost:
+				return &http.Response{StatusCode: http.StatusCreated, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdReplace(f, buf)
+	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy")
+	cmd.Flags().Set("namespace", "test")
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	if buf.String() != "replicationcontroller/rc1\nreplicationcontroller/rc1\nreplicationcontroller/rc1\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+
+	buf.Reset()
+	cmd.Flags().Set("force", "true")
+	cmd.Flags().Set("cascade", "false")
+	cmd.Run(cmd, []string{})
+
+	if buf.String() != "replicationcontroller/frontend\nreplicationcontroller/redis-master\nreplicationcontroller/redis-slave\n"+
+		"replicationcontroller/rc1\nreplicationcontroller/rc1\nreplicationcontroller/rc1\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}
+
+func TestForceReplaceObjectNotFound(t *testing.T) {
+	_, _, rc := testData()
+
+	f, tf, codec, _ := cmdtesting.NewAPIFactory()
+	ns := dynamic.ContentConfig().NegotiatedSerializer
+	tf.Printer = &testPrinter{}
+	tf.Client = &fake.RESTClient{
+		NegotiatedSerializer: ns,
+		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+			switch p, m := req.URL.Path, req.Method; {
+			case p == "/api/v1/namespaces/test" && m == http.MethodGet:
+				return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, &api.Namespace{})}, nil
+			case p == "/namespaces/test/replicationcontrollers/redis-master" && (m == http.MethodGet || m == http.MethodDelete):
+				return &http.Response{StatusCode: http.StatusNotFound, Header: defaultHeader(), Body: stringBody("")}, nil
+			case p == "/namespaces/test/replicationcontrollers" && m == http.MethodPost:
+				return &http.Response{StatusCode: http.StatusCreated, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
+			default:
+				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+				return nil, nil
+			}
+		}),
+	}
+	tf.Namespace = "test"
+	buf := bytes.NewBuffer([]byte{})
+
+	cmd := NewCmdReplace(f, buf)
+	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
+	cmd.Flags().Set("force", "true")
+	cmd.Flags().Set("cascade", "false")
+	cmd.Flags().Set("output", "name")
+	cmd.Run(cmd, []string{})
+
+	if buf.String() != "replicationcontroller/rc1\n" {
+		t.Errorf("unexpected output: %s", buf.String())
+	}
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/rollingupdate.go

@@ -0,0 +1,415 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"time"
+
+	"github.com/golang/glog"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/errors"
+	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/api/v1"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	utilerrors "k8s.io/kubernetes/pkg/util/errors"
+	"k8s.io/kubernetes/pkg/util/intstr"
+)
+
+var (
+	rollingUpdate_long = templates.LongDesc(`
+		Perform a rolling update of the given ReplicationController.
+
+		Replaces the specified replication controller with a new replication controller by updating one pod at a time to use the
+		new PodTemplate. The new-controller.json must specify the same namespace as the
+		existing replication controller and overwrite at least one (common) label in its replicaSelector.
+
+		![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate.svg)`)
+
+	rollingUpdate_example = templates.Examples(`
+		# Update pods of frontend-v1 using new replication controller data in frontend-v2.json.
+		kubectl rolling-update frontend-v1 -f frontend-v2.json
+
+		# Update pods of frontend-v1 using JSON data passed into stdin.
+		cat frontend-v2.json | kubectl rolling-update frontend-v1 -f -
+
+		# Update the pods of frontend-v1 to frontend-v2 by just changing the image, and switching the
+		# name of the replication controller.
+		kubectl rolling-update frontend-v1 frontend-v2 --image=image:v2
+
+		# Update the pods of frontend by just changing the image, and keeping the old name.
+		kubectl rolling-update frontend --image=image:v2
+
+		# Abort and reverse an existing rollout in progress (from frontend-v1 to frontend-v2).
+		kubectl rolling-update frontend-v1 frontend-v2 --rollback`)
+)
+
+var (
+	updatePeriod, _ = time.ParseDuration("1m0s")
+	timeout, _      = time.ParseDuration("5m0s")
+	pollInterval, _ = time.ParseDuration("3s")
+)
+
+func NewCmdRollingUpdate(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &resource.FilenameOptions{}
+
+	cmd := &cobra.Command{
+		Use: "rolling-update OLD_CONTROLLER_NAME ([NEW_CONTROLLER_NAME] --image=NEW_CONTAINER_IMAGE | -f NEW_CONTROLLER_SPEC)",
+		// rollingupdate is deprecated.
+		Aliases: []string{"rollingupdate"},
+		Short:   "Perform a rolling update of the given ReplicationController",
+		Long:    rollingUpdate_long,
+		Example: rollingUpdate_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunRollingUpdate(f, out, cmd, args, options)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmd.Flags().Duration("update-period", updatePeriod, `Time to wait between updating pods. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".`)
+	cmd.Flags().Duration("poll-interval", pollInterval, `Time delay between polling for replication controller status after the update. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".`)
+	cmd.Flags().Duration("timeout", timeout, `Max time to wait for a replication controller to update before giving up. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".`)
+	usage := "Filename or URL to file to use to create the new replication controller."
+	kubectl.AddJsonFilenameFlag(cmd, &options.Filenames, usage)
+	cmd.MarkFlagRequired("filename")
+	cmd.Flags().String("image", "", "Image to use for upgrading the replication controller. Must be distinct from the existing image (either new image or new image tag).  Can not be used with --filename/-f")
+	cmd.MarkFlagRequired("image")
+	cmd.Flags().String("deployment-label-key", "deployment", "The key to use to differentiate between two different controllers, default 'deployment'.  Only relevant when --image is specified, ignored otherwise")
+	cmd.Flags().String("container", "", "Container name which will have its image upgraded. Only relevant when --image is specified, ignored otherwise. Required when using --image on a multi-container pod")
+	cmd.Flags().String("image-pull-policy", "", "Explicit policy for when to pull container images. Required when --image is same as existing image, ignored otherwise.")
+	cmd.Flags().Bool("rollback", false, "If true, this is a request to abort an existing rollout that is partially rolled out. It effectively reverses current and next and runs a rollout")
+	cmdutil.AddDryRunFlag(cmd)
+	cmdutil.AddValidateFlags(cmd)
+	cmdutil.AddPrinterFlags(cmd)
+	cmdutil.AddInclude3rdPartyFlags(cmd)
+
+	return cmd
+}
+
+func validateArguments(cmd *cobra.Command, filenames, args []string) error {
+	deploymentKey := cmdutil.GetFlagString(cmd, "deployment-label-key")
+	image := cmdutil.GetFlagString(cmd, "image")
+	rollback := cmdutil.GetFlagBool(cmd, "rollback")
+
+	errors := []error{}
+	if len(deploymentKey) == 0 {
+		errors = append(errors, cmdutil.UsageError(cmd, "--deployment-label-key can not be empty"))
+	}
+	if len(filenames) > 1 {
+		errors = append(errors, cmdutil.UsageError(cmd, "May only specify a single filename for new controller"))
+	}
+
+	if !rollback {
+		if len(filenames) == 0 && len(image) == 0 {
+			errors = append(errors, cmdutil.UsageError(cmd, "Must specify --filename or --image for new controller"))
+		} else if len(filenames) != 0 && len(image) != 0 {
+			errors = append(errors, cmdutil.UsageError(cmd, "--filename and --image can not both be specified"))
+		}
+	} else {
+		if len(filenames) != 0 || len(image) != 0 {
+			errors = append(errors, cmdutil.UsageError(cmd, "Don't specify --filename or --image on rollback"))
+		}
+	}
+
+	if len(args) < 1 {
+		errors = append(errors, cmdutil.UsageError(cmd, "Must specify the controller to update"))
+	}
+
+	return utilerrors.NewAggregate(errors)
+}
+
+func RunRollingUpdate(f cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string, options *resource.FilenameOptions) error {
+	if len(os.Args) > 1 && os.Args[1] == "rollingupdate" {
+		printDeprecationWarning("rolling-update", "rollingupdate")
+	}
+	err := validateArguments(cmd, options.Filenames, args)
+	if err != nil {
+		return err
+	}
+
+	deploymentKey := cmdutil.GetFlagString(cmd, "deployment-label-key")
+	filename := ""
+	image := cmdutil.GetFlagString(cmd, "image")
+	pullPolicy := cmdutil.GetFlagString(cmd, "image-pull-policy")
+	oldName := args[0]
+	rollback := cmdutil.GetFlagBool(cmd, "rollback")
+	period := cmdutil.GetFlagDuration(cmd, "update-period")
+	interval := cmdutil.GetFlagDuration(cmd, "poll-interval")
+	timeout := cmdutil.GetFlagDuration(cmd, "timeout")
+	dryrun := cmdutil.GetDryRunFlag(cmd)
+	outputFormat := cmdutil.GetFlagString(cmd, "output")
+	container := cmdutil.GetFlagString(cmd, "container")
+
+	if len(options.Filenames) > 0 {
+		filename = options.Filenames[0]
+	}
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	clientset, err := f.ClientSet()
+	if err != nil {
+		return err
+	}
+	coreClient := clientset.Core()
+
+	var newRc *api.ReplicationController
+	// fetch rc
+	oldRc, err := coreClient.ReplicationControllers(cmdNamespace).Get(oldName)
+	if err != nil {
+		if !errors.IsNotFound(err) || len(image) == 0 || len(args) > 1 {
+			return err
+		}
+		// We're in the middle of a rename, look for an RC with a source annotation of oldName
+		newRc, err := kubectl.FindSourceController(coreClient, cmdNamespace, oldName)
+		if err != nil {
+			return err
+		}
+		return kubectl.Rename(coreClient, newRc, oldName)
+	}
+
+	var keepOldName bool
+	var replicasDefaulted bool
+
+	mapper, typer := f.Object()
+
+	if len(filename) != 0 {
+		schema, err := f.Validator(cmdutil.GetFlagBool(cmd, "validate"), cmdutil.GetFlagString(cmd, "schema-cache-dir"))
+		if err != nil {
+			return err
+		}
+
+		request := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
+			Schema(schema).
+			NamespaceParam(cmdNamespace).DefaultNamespace().
+			FilenameParam(enforceNamespace, &resource.FilenameOptions{Recursive: false, Filenames: []string{filename}}).
+			Do()
+		obj, err := request.Object()
+		if err != nil {
+			return err
+		}
+		var ok bool
+		// Handle filename input from stdin. The resource builder always returns an api.List
+		// when creating resource(s) from a stream.
+		if list, ok := obj.(*api.List); ok {
+			if len(list.Items) > 1 {
+				return cmdutil.UsageError(cmd, "%s specifies multiple items", filename)
+			}
+			if len(list.Items) == 0 {
+				return cmdutil.UsageError(cmd, "please make sure %s exists and is not empty", filename)
+			}
+			obj = list.Items[0]
+		}
+		newRc, ok = obj.(*api.ReplicationController)
+		if !ok {
+			if gvks, _, err := typer.ObjectKinds(obj); err == nil {
+				return cmdutil.UsageError(cmd, "%s contains a %v not a ReplicationController", filename, gvks[0])
+			}
+			glog.V(4).Infof("Object %#v is not a ReplicationController", obj)
+			return cmdutil.UsageError(cmd, "%s does not specify a valid ReplicationController", filename)
+		}
+		infos, err := request.Infos()
+		if err != nil || len(infos) != 1 {
+			glog.V(2).Infof("was not able to recover adequate information to discover if .spec.replicas was defaulted")
+		} else {
+			replicasDefaulted = isReplicasDefaulted(infos[0])
+		}
+	}
+	// If the --image option is specified, we need to create a new rc with at least one different selector
+	// than the old rc. This selector is the hash of the rc, with a suffix to provide uniqueness for
+	// same-image updates.
+	if len(image) != 0 {
+		codec := api.Codecs.LegacyCodec(clientset.CoreClient.RESTClient().APIVersion())
+		keepOldName = len(args) == 1
+		newName := findNewName(args, oldRc)
+		if newRc, err = kubectl.LoadExistingNextReplicationController(coreClient, cmdNamespace, newName); err != nil {
+			return err
+		}
+		if newRc != nil {
+			if inProgressImage := newRc.Spec.Template.Spec.Containers[0].Image; inProgressImage != image {
+				return cmdutil.UsageError(cmd, "Found existing in-progress update to image (%s).\nEither continue in-progress update with --image=%s or rollback with --rollback", inProgressImage, inProgressImage)
+			}
+			fmt.Fprintf(out, "Found existing update in progress (%s), resuming.\n", newRc.Name)
+		} else {
+			config := &kubectl.NewControllerConfig{
+				Namespace:     cmdNamespace,
+				OldName:       oldName,
+				NewName:       newName,
+				Image:         image,
+				Container:     container,
+				DeploymentKey: deploymentKey,
+			}
+			if oldRc.Spec.Template.Spec.Containers[0].Image == image {
+				if len(pullPolicy) == 0 {
+					return cmdutil.UsageError(cmd, "--image-pull-policy (Always|Never|IfNotPresent) must be provided when --image is the same as existing container image")
+				}
+				config.PullPolicy = api.PullPolicy(pullPolicy)
+			}
+			newRc, err = kubectl.CreateNewControllerFromCurrentController(coreClient, codec, config)
+			if err != nil {
+				return err
+			}
+		}
+		// Update the existing replication controller with pointers to the 'next' controller
+		// and adding the <deploymentKey> label if necessary to distinguish it from the 'next' controller.
+		oldHash, err := api.HashObject(oldRc, codec)
+		if err != nil {
+			return err
+		}
+		// If new image is same as old, the hash may not be distinct, so add a suffix.
+		oldHash += "-orig"
+		oldRc, err = kubectl.UpdateExistingReplicationController(coreClient, coreClient, oldRc, cmdNamespace, newRc.Name, deploymentKey, oldHash, out)
+		if err != nil {
+			return err
+		}
+	}
+
+	if rollback {
+		keepOldName = len(args) == 1
+		newName := findNewName(args, oldRc)
+		if newRc, err = kubectl.LoadExistingNextReplicationController(coreClient, cmdNamespace, newName); err != nil {
+			return err
+		}
+
+		if newRc == nil {
+			return cmdutil.UsageError(cmd, "Could not find %s to rollback.\n", newName)
+		}
+	}
+
+	if oldName == newRc.Name {
+		return cmdutil.UsageError(cmd, "%s cannot have the same name as the existing ReplicationController %s",
+			filename, oldName)
+	}
+
+	updater := kubectl.NewRollingUpdater(newRc.Namespace, coreClient, coreClient)
+
+	// To successfully pull off a rolling update the new and old rc have to differ
+	// by at least one selector. Every new pod should have the selector and every
+	// old pod should not have the selector.
+	var hasLabel bool
+	for key, oldValue := range oldRc.Spec.Selector {
+		if newValue, ok := newRc.Spec.Selector[key]; ok && newValue != oldValue {
+			hasLabel = true
+			break
+		}
+	}
+	if !hasLabel {
+		return cmdutil.UsageError(cmd, "%s must specify a matching key with non-equal value in Selector for %s",
+			filename, oldName)
+	}
+	// TODO: handle scales during rolling update
+	if replicasDefaulted {
+		newRc.Spec.Replicas = oldRc.Spec.Replicas
+	}
+	if dryrun {
+		oldRcData := &bytes.Buffer{}
+		newRcData := &bytes.Buffer{}
+		if outputFormat == "" {
+			oldRcData.WriteString(oldRc.Name)
+			newRcData.WriteString(newRc.Name)
+		} else {
+			if err := f.PrintObject(cmd, mapper, oldRc, oldRcData); err != nil {
+				return err
+			}
+			if err := f.PrintObject(cmd, mapper, newRc, newRcData); err != nil {
+				return err
+			}
+		}
+		fmt.Fprintf(out, "Rolling from:\n%s\nTo:\n%s\n", string(oldRcData.Bytes()), string(newRcData.Bytes()))
+		return nil
+	}
+	updateCleanupPolicy := kubectl.DeleteRollingUpdateCleanupPolicy
+	if keepOldName {
+		updateCleanupPolicy = kubectl.RenameRollingUpdateCleanupPolicy
+	}
+	config := &kubectl.RollingUpdaterConfig{
+		Out:            out,
+		OldRc:          oldRc,
+		NewRc:          newRc,
+		UpdatePeriod:   period,
+		Interval:       interval,
+		Timeout:        timeout,
+		CleanupPolicy:  updateCleanupPolicy,
+		MaxUnavailable: intstr.FromInt(0),
+		MaxSurge:       intstr.FromInt(1),
+	}
+	if rollback {
+		err = kubectl.AbortRollingUpdate(config)
+		if err != nil {
+			return err
+		}
+		coreClient.ReplicationControllers(config.NewRc.Namespace).Update(config.NewRc)
+	}
+	err = updater.Update(config)
+	if err != nil {
+		return err
+	}
+
+	message := "rolling updated"
+	if keepOldName {
+		newRc.Name = oldName
+	} else {
+		message = fmt.Sprintf("rolling updated to %q", newRc.Name)
+	}
+	newRc, err = coreClient.ReplicationControllers(cmdNamespace).Get(newRc.Name)
+	if err != nil {
+		return err
+	}
+	if outputFormat != "" {
+		return f.PrintObject(cmd, mapper, newRc, out)
+	}
+	kinds, _, err := api.Scheme.ObjectKinds(newRc)
+	if err != nil {
+		return err
+	}
+	_, res := meta.KindToResource(kinds[0])
+	cmdutil.PrintSuccess(mapper, false, out, res.Resource, oldName, dryrun, message)
+	return nil
+}
+
+func findNewName(args []string, oldRc *api.ReplicationController) string {
+	if len(args) >= 2 {
+		return args[1]
+	}
+	if oldRc != nil {
+		newName, _ := kubectl.GetNextControllerAnnotation(oldRc)
+		return newName
+	}
+	return ""
+}
+
+func isReplicasDefaulted(info *resource.Info) bool {
+	if info == nil || info.VersionedObject == nil {
+		// was unable to recover versioned info
+		return false
+	}
+	switch t := info.VersionedObject.(type) {
+	case *v1.ReplicationController:
+		return t.Spec.Replicas == nil
+	}
+	return false
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/rollingupdate_test.go

@@ -0,0 +1,92 @@
+/*
+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 cmd
+
+import (
+	"bytes"
+	"testing"
+
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
+)
+
+func TestValidateArgs(t *testing.T) {
+	f, _, _, _ := cmdtesting.NewAPIFactory()
+
+	tests := []struct {
+		flags     map[string]string
+		filenames []string
+		args      []string
+		expectErr bool
+		testName  string
+	}{
+		{
+			expectErr: true,
+			testName:  "nothing",
+		},
+		{
+			flags:     map[string]string{},
+			args:      []string{"foo"},
+			expectErr: true,
+			testName:  "no file, no image",
+		},
+		{
+			filenames: []string{"bar.yaml"},
+			args:      []string{"foo"},
+			testName:  "valid file example",
+		},
+		{
+			flags: map[string]string{
+				"image": "foo:v2",
+			},
+			args:     []string{"foo"},
+			testName: "missing second image name",
+		},
+		{
+			flags: map[string]string{
+				"image": "foo:v2",
+			},
+			args:     []string{"foo", "foo-v2"},
+			testName: "valid image example",
+		},
+		{
+			flags: map[string]string{
+				"image": "foo:v2",
+			},
+			filenames: []string{"bar.yaml"},
+			args:      []string{"foo", "foo-v2"},
+			expectErr: true,
+			testName:  "both filename and image example",
+		},
+	}
+	for _, test := range tests {
+		out := &bytes.Buffer{}
+		cmd := NewCmdRollingUpdate(f, out)
+
+		if test.flags != nil {
+			for key, val := range test.flags {
+				cmd.Flags().Set(key, val)
+			}
+		}
+		err := validateArguments(cmd, test.filenames, test.args)
+		if err != nil && !test.expectErr {
+			t.Errorf("unexpected error: %v (%s)", err, test.testName)
+		}
+		if err == nil && test.expectErr {
+			t.Errorf("unexpected non-error (%s)", test.testName)
+		}
+	}
+}

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

@@ -0,0 +1,39 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "rollout.go",
+        "rollout_history.go",
+        "rollout_pause.go",
+        "rollout_resume.go",
+        "rollout_status.go",
+        "rollout_undo.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/meta:go_default_library",
+        "//pkg/kubectl:go_default_library",
+        "//pkg/kubectl/cmd/set:go_default_library",
+        "//pkg/kubectl/cmd/templates:go_default_library",
+        "//pkg/kubectl/cmd/util:go_default_library",
+        "//pkg/kubectl/resource:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/util/errors:go_default_library",
+        "//pkg/util/interrupt:go_default_library",
+        "//pkg/watch:go_default_library",
+        "//vendor:github.com/renstrom/dedent",
+        "//vendor:github.com/spf13/cobra",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/rollout/rollout.go

@@ -0,0 +1,60 @@
+/*
+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 rollout
+
+import (
+	"io"
+
+	"github.com/renstrom/dedent"
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+var (
+	rollout_long = templates.LongDesc(`
+		Manage a deployment using subcommands like "kubectl rollout undo deployment/abc"`)
+
+	rollout_example = templates.Examples(`
+		# Rollback to the previous deployment
+		kubectl rollout undo deployment/abc`)
+
+	rollout_valid_resources = dedent.Dedent(`
+		Valid resource types include:
+		   * deployments
+		`)
+)
+
+func NewCmdRollout(f cmdutil.Factory, out, errOut io.Writer) *cobra.Command {
+
+	cmd := &cobra.Command{
+		Use:     "rollout SUBCOMMAND",
+		Short:   "Manage a deployment rollout",
+		Long:    rollout_long,
+		Example: rollout_example,
+		Run:     cmdutil.DefaultSubCommandRun(errOut),
+	}
+	// subcommands
+	cmd.AddCommand(NewCmdRolloutHistory(f, out))
+	cmd.AddCommand(NewCmdRolloutPause(f, out))
+	cmd.AddCommand(NewCmdRolloutResume(f, out))
+	cmd.AddCommand(NewCmdRolloutUndo(f, out))
+
+	cmd.AddCommand(NewCmdRolloutStatus(f, out))
+
+	return cmd
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/rollout/rollout_history.go

@@ -0,0 +1,118 @@
+/*
+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 rollout
+
+import (
+	"fmt"
+	"io"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	history_long = templates.LongDesc(`
+		View previous rollout revisions and configurations.`)
+
+	history_example = templates.Examples(`
+		# View the rollout history of a deployment
+		kubectl rollout history deployment/abc
+
+		# View the details of deployment revision 3
+		kubectl rollout history deployment/abc --revision=3`)
+)
+
+func NewCmdRolloutHistory(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &resource.FilenameOptions{}
+
+	validArgs := []string{"deployment"}
+	argAliases := kubectl.ResourceAliases(validArgs)
+
+	cmd := &cobra.Command{
+		Use:     "history (TYPE NAME | TYPE/NAME) [flags]",
+		Short:   "View rollout history",
+		Long:    history_long,
+		Example: history_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(RunHistory(f, cmd, out, args, options))
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+
+	cmd.Flags().Int64("revision", 0, "See the details, including podTemplate of the revision specified")
+	usage := "identifying the resource to get from a server."
+	cmdutil.AddFilenameOptionFlags(cmd, options, usage)
+	return cmd
+}
+
+func RunHistory(f cmdutil.Factory, cmd *cobra.Command, out io.Writer, args []string, options *resource.FilenameOptions) error {
+	if len(args) == 0 && cmdutil.IsFilenameEmpty(options.Filenames) {
+		return cmdutil.UsageError(cmd, "Required resource not specified.")
+	}
+	revision := cmdutil.GetFlagInt64(cmd, "revision")
+	if revision < 0 {
+		return fmt.Errorf("revision must be a positive integer: %v", revision)
+	}
+
+	mapper, typer := f.Object()
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, options).
+		ResourceTypeOrNameArgs(true, args...).
+		ContinueOnError().
+		Latest().
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	return r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+		mapping := info.ResourceMapping()
+		historyViewer, err := f.HistoryViewer(mapping)
+		if err != nil {
+			return err
+		}
+		historyInfo, err := historyViewer.ViewHistory(info.Namespace, info.Name, revision)
+		if err != nil {
+			return err
+		}
+
+		header := fmt.Sprintf("%s %q", mapping.Resource, info.Name)
+		if revision > 0 {
+			header = fmt.Sprintf("%s with revision #%d", header, revision)
+		}
+		fmt.Fprintf(out, "%s\n", header)
+		fmt.Fprintf(out, "%s\n", historyInfo)
+		return nil
+	})
+}