Update godeps

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

@@ -0,0 +1,80 @@
+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 = [
+        "builder.go",
+        "doc.go",
+        "helper.go",
+        "interfaces.go",
+        "mapper.go",
+        "result.go",
+        "selector.go",
+        "visitor.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/errors:go_default_library",
+        "//pkg/api/meta:go_default_library",
+        "//pkg/api/unversioned:go_default_library",
+        "//pkg/api/validation:go_default_library",
+        "//pkg/apimachinery/registered:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/client/restclient:go_default_library",
+        "//pkg/labels:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/util/errors:go_default_library",
+        "//pkg/util/sets:go_default_library",
+        "//pkg/util/yaml:go_default_library",
+        "//pkg/watch:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "builder_test.go",
+        "helper_test.go",
+        "visitor_test.go",
+    ],
+    data = [
+        "//examples:config",
+        "//test/fixtures",
+    ],
+    library = "go_default_library",
+    tags = [
+        "automanaged",
+        "skip",
+    ],
+    deps = [
+        "//pkg/api: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/client/restclient/fake:go_default_library",
+        "//pkg/labels:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/runtime/serializer/streaming:go_default_library",
+        "//pkg/util/errors:go_default_library",
+        "//pkg/util/testing:go_default_library",
+        "//pkg/watch:go_default_library",
+        "//pkg/watch/versioned:go_default_library",
+        "//vendor:github.com/ghodss/yaml",
+        "//vendor:github.com/stretchr/testify/assert",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/resource/builder.go

@@ -55,8 +55,9 @@ type Builder struct {
 
 	resources []string
 
-	namespace string
-	names     []string
+	namespace    string
+	allNamespace bool
+	names        []string
 
 	resourceTuples []resourceTuple
 
@@ -93,6 +94,11 @@ func IsUsageError(err error) bool {
 	return err == missingResourceError
 }
 
+type FilenameOptions struct {
+	Filenames []string
+	Recursive bool
+}
+
 type resourceTuple struct {
 	Resource string
 	Name     string
@@ -117,7 +123,9 @@ func (b *Builder) Schema(schema validation.Schema) *Builder {
 // will cause an error.
 // If ContinueOnError() is set prior to this method, objects on the path that are not
 // recognized will be ignored (but logged at V(2)).
-func (b *Builder) FilenameParam(enforceNamespace, recursive bool, paths ...string) *Builder {
+func (b *Builder) FilenameParam(enforceNamespace bool, filenameOptions *FilenameOptions) *Builder {
+	recursive := filenameOptions.Recursive
+	paths := filenameOptions.Filenames
 	for _, s := range paths {
 		switch {
 		case s == "-":
@@ -284,11 +292,12 @@ func (b *Builder) DefaultNamespace() *Builder {
 }
 
 // AllNamespaces instructs the builder to use NamespaceAll as a namespace to request resources
-// acroll all namespace. This overrides the namespace set by NamespaceParam().
+// across all of the namespace. This overrides the namespace set by NamespaceParam().
 func (b *Builder) AllNamespaces(allNamespace bool) *Builder {
 	if allNamespace {
 		b.namespace = api.NamespaceAll
 	}
+	b.allNamespace = allNamespace
 	return b
 }
 
@@ -336,7 +345,7 @@ func (b *Builder) ResourceTypeOrNameArgs(allowEmptySelector bool, args ...string
 	}
 	if len(args) > 0 {
 		// Try replacing aliases only in types
-		args[0] = b.replaceAliases(args[0])
+		args[0] = b.ReplaceAliases(args[0])
 	}
 	switch {
 	case len(args) > 2:
@@ -357,9 +366,9 @@ func (b *Builder) ResourceTypeOrNameArgs(allowEmptySelector bool, args ...string
 	return b
 }
 
-// replaceAliases accepts an argument and tries to expand any existing
+// ReplaceAliases accepts an argument and tries to expand any existing
 // aliases found in it
-func (b *Builder) replaceAliases(input string) string {
+func (b *Builder) ReplaceAliases(input string) string {
 	replaced := []string{}
 	for _, arg := range strings.Split(input, ",") {
 		if aliases, ok := b.mapper.AliasesForResource(arg); ok {
@@ -531,191 +540,213 @@ func (b *Builder) visitorResult() *Result {
 		b.selector = labels.Everything()
 	}
 
+	// visit items specified by paths
+	if len(b.paths) != 0 {
+		return b.visitByPaths()
+	}
+
 	// visit selectors
 	if b.selector != nil {
-		if len(b.names) != 0 {
-			return &Result{err: fmt.Errorf("name cannot be provided when a selector is specified")}
-		}
-		if len(b.resourceTuples) != 0 {
-			return &Result{err: fmt.Errorf("selectors and the all flag cannot be used when passing resource/name arguments")}
-		}
-		if len(b.resources) == 0 {
-			return &Result{err: fmt.Errorf("at least one resource must be specified to use a selector")}
-		}
-		// empty selector has different error message for paths being provided
-		if len(b.paths) != 0 {
-			if b.selector.Empty() {
-				return &Result{err: fmt.Errorf("when paths, URLs, or stdin is provided as input, you may not specify a resource by arguments as well")}
-			} else {
-				return &Result{err: fmt.Errorf("a selector may not be specified when path, URL, or stdin is provided as input")}
-			}
-		}
-		mappings, err := b.resourceMappings()
-		if err != nil {
-			return &Result{err: err}
-		}
-
-		visitors := []Visitor{}
-		for _, mapping := range mappings {
-			client, err := b.mapper.ClientForMapping(mapping)
-			if err != nil {
-				return &Result{err: err}
-			}
-			selectorNamespace := b.namespace
-			if mapping.Scope.Name() != meta.RESTScopeNameNamespace {
-				selectorNamespace = ""
-			}
-			visitors = append(visitors, NewSelector(client, mapping, selectorNamespace, b.selector, b.export))
-		}
-		if b.continueOnError {
-			return &Result{visitor: EagerVisitorList(visitors), sources: visitors}
-		}
-		return &Result{visitor: VisitorList(visitors), sources: visitors}
+		return b.visitBySelector()
 	}
 
 	// visit items specified by resource and name
 	if len(b.resourceTuples) != 0 {
-		// if b.singular is false, this could be by default, so double-check length
-		// of resourceTuples to determine if in fact it is singular or not
-		isSingular := b.singular
-		if !isSingular {
-			isSingular = len(b.resourceTuples) == 1
-		}
-
-		if len(b.paths) != 0 {
-			return &Result{singular: isSingular, err: fmt.Errorf("when paths, URLs, or stdin is provided as input, you may not specify a resource by arguments as well")}
-		}
-		if len(b.resources) != 0 {
-			return &Result{singular: isSingular, err: fmt.Errorf("you may not specify individual resources and bulk resources in the same call")}
-		}
-
-		// retrieve one client for each resource
-		mappings, err := b.resourceTupleMappings()
-		if err != nil {
-			return &Result{singular: isSingular, err: err}
-		}
-		clients := make(map[string]RESTClient)
-		for _, mapping := range mappings {
-			s := fmt.Sprintf("%s/%s", mapping.GroupVersionKind.GroupVersion().String(), mapping.Resource)
-			if _, ok := clients[s]; ok {
-				continue
-			}
-			client, err := b.mapper.ClientForMapping(mapping)
-			if err != nil {
-				return &Result{err: err}
-			}
-			clients[s] = client
-		}
-
-		items := []Visitor{}
-		for _, tuple := range b.resourceTuples {
-			mapping, ok := mappings[tuple.Resource]
-			if !ok {
-				return &Result{singular: isSingular, err: fmt.Errorf("resource %q is not recognized: %v", tuple.Resource, mappings)}
-			}
-			s := fmt.Sprintf("%s/%s", mapping.GroupVersionKind.GroupVersion().String(), mapping.Resource)
-			client, ok := clients[s]
-			if !ok {
-				return &Result{singular: isSingular, err: fmt.Errorf("could not find a client for resource %q", tuple.Resource)}
-			}
-
-			selectorNamespace := b.namespace
-			if mapping.Scope.Name() != meta.RESTScopeNameNamespace {
-				selectorNamespace = ""
-			} else {
-				if len(b.namespace) == 0 {
-					return &Result{singular: isSingular, err: fmt.Errorf("namespace may not be empty when retrieving a resource by name")}
-				}
-			}
-
-			info := NewInfo(client, mapping, selectorNamespace, tuple.Name, b.export)
-			items = append(items, info)
-		}
-
-		var visitors Visitor
-		if b.continueOnError {
-			visitors = EagerVisitorList(items)
-		} else {
-			visitors = VisitorList(items)
-		}
-		return &Result{singular: isSingular, visitor: visitors, sources: items}
+		return b.visitByResource()
 	}
 
 	// visit items specified by name
 	if len(b.names) != 0 {
-		isSingular := len(b.names) == 1
+		return b.visitByName()
+	}
 
-		if len(b.paths) != 0 {
-			return &Result{singular: isSingular, err: fmt.Errorf("when paths, URLs, or stdin is provided as input, you may not specify a resource by arguments as well")}
-		}
-		if len(b.resources) == 0 {
-			return &Result{singular: isSingular, err: fmt.Errorf("you must provide a resource and a resource name together")}
-		}
-		if len(b.resources) > 1 {
-			return &Result{singular: isSingular, err: fmt.Errorf("you must specify only one resource")}
-		}
+	if len(b.resources) != 0 {
+		return &Result{err: fmt.Errorf("resource(s) were provided, but no name, label selector, or --all flag specified")}
+	}
+	return &Result{err: missingResourceError}
+}
 
-		mappings, err := b.resourceMappings()
-		if err != nil {
-			return &Result{singular: isSingular, err: err}
-		}
-		mapping := mappings[0]
+func (b *Builder) visitBySelector() *Result {
+	if len(b.names) != 0 {
+		return &Result{err: fmt.Errorf("name cannot be provided when a selector is specified")}
+	}
+	if len(b.resourceTuples) != 0 {
+		return &Result{err: fmt.Errorf("selectors and the all flag cannot be used when passing resource/name arguments")}
+	}
+	if len(b.resources) == 0 {
+		return &Result{err: fmt.Errorf("at least one resource must be specified to use a selector")}
+	}
+	mappings, err := b.resourceMappings()
+	if err != nil {
+		return &Result{err: err}
+	}
 
+	visitors := []Visitor{}
+	for _, mapping := range mappings {
 		client, err := b.mapper.ClientForMapping(mapping)
 		if err != nil {
 			return &Result{err: err}
 		}
+		selectorNamespace := b.namespace
+		if mapping.Scope.Name() != meta.RESTScopeNameNamespace {
+			selectorNamespace = ""
+		}
+		visitors = append(visitors, NewSelector(client, mapping, selectorNamespace, b.selector, b.export))
+	}
+	if b.continueOnError {
+		return &Result{visitor: EagerVisitorList(visitors), sources: visitors}
+	}
+	return &Result{visitor: VisitorList(visitors), sources: visitors}
+}
+
+func (b *Builder) visitByResource() *Result {
+	// if b.singular is false, this could be by default, so double-check length
+	// of resourceTuples to determine if in fact it is singular or not
+	isSingular := b.singular
+	if !isSingular {
+		isSingular = len(b.resourceTuples) == 1
+	}
+
+	if len(b.resources) != 0 {
+		return &Result{singular: isSingular, err: fmt.Errorf("you may not specify individual resources and bulk resources in the same call")}
+	}
+
+	// retrieve one client for each resource
+	mappings, err := b.resourceTupleMappings()
+	if err != nil {
+		return &Result{singular: isSingular, err: err}
+	}
+	clients := make(map[string]RESTClient)
+	for _, mapping := range mappings {
+		s := fmt.Sprintf("%s/%s", mapping.GroupVersionKind.GroupVersion().String(), mapping.Resource)
+		if _, ok := clients[s]; ok {
+			continue
+		}
+		client, err := b.mapper.ClientForMapping(mapping)
+		if err != nil {
+			return &Result{err: err}
+		}
+		clients[s] = client
+	}
+
+	items := []Visitor{}
+	for _, tuple := range b.resourceTuples {
+		mapping, ok := mappings[tuple.Resource]
+		if !ok {
+			return &Result{singular: isSingular, err: fmt.Errorf("resource %q is not recognized: %v", tuple.Resource, mappings)}
+		}
+		s := fmt.Sprintf("%s/%s", mapping.GroupVersionKind.GroupVersion().String(), mapping.Resource)
+		client, ok := clients[s]
+		if !ok {
+			return &Result{singular: isSingular, err: fmt.Errorf("could not find a client for resource %q", tuple.Resource)}
+		}
 
 		selectorNamespace := b.namespace
 		if mapping.Scope.Name() != meta.RESTScopeNameNamespace {
 			selectorNamespace = ""
 		} else {
 			if len(b.namespace) == 0 {
-				return &Result{singular: isSingular, err: fmt.Errorf("namespace may not be empty when retrieving a resource by name")}
+				errMsg := "namespace may not be empty when retrieving a resource by name"
+				if b.allNamespace {
+					errMsg = "a resource cannot be retrieved by name across all namespaces"
+				}
+				return &Result{singular: isSingular, err: fmt.Errorf(errMsg)}
 			}
 		}
 
-		visitors := []Visitor{}
-		for _, name := range b.names {
-			info := NewInfo(client, mapping, selectorNamespace, name, b.export)
-			visitors = append(visitors, info)
-		}
-		return &Result{singular: isSingular, visitor: VisitorList(visitors), sources: visitors}
+		info := NewInfo(client, mapping, selectorNamespace, tuple.Name, b.export)
+		items = append(items, info)
 	}
 
-	// visit items specified by paths
+	var visitors Visitor
+	if b.continueOnError {
+		visitors = EagerVisitorList(items)
+	} else {
+		visitors = VisitorList(items)
+	}
+	return &Result{singular: isSingular, visitor: visitors, sources: items}
+}
+
+func (b *Builder) visitByName() *Result {
+	isSingular := len(b.names) == 1
+
 	if len(b.paths) != 0 {
-		singular := !b.dir && !b.stream && len(b.paths) == 1
-		if len(b.resources) != 0 {
-			return &Result{singular: singular, err: fmt.Errorf("when paths, URLs, or stdin is provided as input, you may not specify resource arguments as well")}
-		}
-
-		var visitors Visitor
-		if b.continueOnError {
-			visitors = EagerVisitorList(b.paths)
-		} else {
-			visitors = VisitorList(b.paths)
-		}
-
-		// only items from disk can be refetched
-		if b.latest {
-			// must flatten lists prior to fetching
-			if b.flatten {
-				visitors = NewFlattenListVisitor(visitors, b.mapper)
-			}
-			// must set namespace prior to fetching
-			if b.defaultNamespace {
-				visitors = NewDecoratedVisitor(visitors, SetNamespace(b.namespace))
-			}
-			visitors = NewDecoratedVisitor(visitors, RetrieveLatest)
-		}
-		return &Result{singular: singular, visitor: visitors, sources: b.paths}
+		return &Result{singular: isSingular, err: fmt.Errorf("when paths, URLs, or stdin is provided as input, you may not specify a resource by arguments as well")}
+	}
+	if len(b.resources) == 0 {
+		return &Result{singular: isSingular, err: fmt.Errorf("you must provide a resource and a resource name together")}
+	}
+	if len(b.resources) > 1 {
+		return &Result{singular: isSingular, err: fmt.Errorf("you must specify only one resource")}
 	}
 
+	mappings, err := b.resourceMappings()
+	if err != nil {
+		return &Result{singular: isSingular, err: err}
+	}
+	mapping := mappings[0]
+
+	client, err := b.mapper.ClientForMapping(mapping)
+	if err != nil {
+		return &Result{err: err}
+	}
+
+	selectorNamespace := b.namespace
+	if mapping.Scope.Name() != meta.RESTScopeNameNamespace {
+		selectorNamespace = ""
+	} else {
+		if len(b.namespace) == 0 {
+			errMsg := "namespace may not be empty when retrieving a resource by name"
+			if b.allNamespace {
+				errMsg = "a resource cannot be retrieved by name across all namespaces"
+			}
+			return &Result{singular: isSingular, err: fmt.Errorf(errMsg)}
+		}
+	}
+
+	visitors := []Visitor{}
+	for _, name := range b.names {
+		info := NewInfo(client, mapping, selectorNamespace, name, b.export)
+		visitors = append(visitors, info)
+	}
+	return &Result{singular: isSingular, visitor: VisitorList(visitors), sources: visitors}
+}
+
+func (b *Builder) visitByPaths() *Result {
+	singular := !b.dir && !b.stream && len(b.paths) == 1
 	if len(b.resources) != 0 {
-		return &Result{err: fmt.Errorf("resource(s) were provided, but no name, label selector, or --all flag specified")}
+		return &Result{singular: singular, err: fmt.Errorf("when paths, URLs, or stdin is provided as input, you may not specify resource arguments as well")}
 	}
-	return &Result{err: missingResourceError}
+	if len(b.names) != 0 {
+		return &Result{err: fmt.Errorf("name cannot be provided when a path is specified")}
+	}
+	if len(b.resourceTuples) != 0 {
+		return &Result{err: fmt.Errorf("resource/name arguments cannot be provided when a path is specified")}
+	}
+
+	var visitors Visitor
+	if b.continueOnError {
+		visitors = EagerVisitorList(b.paths)
+	} else {
+		visitors = VisitorList(b.paths)
+	}
+
+	// only items from disk can be refetched
+	if b.latest {
+		// must flatten lists prior to fetching
+		if b.flatten {
+			visitors = NewFlattenListVisitor(visitors, b.mapper)
+		}
+		// must set namespace prior to fetching
+		if b.defaultNamespace {
+			visitors = NewDecoratedVisitor(visitors, SetNamespace(b.namespace))
+		}
+		visitors = NewDecoratedVisitor(visitors, RetrieveLatest)
+	}
+	if b.selector != nil {
+		visitors = NewFilteredVisitor(visitors, FilterBySelector(b.selector))
+	}
+	return &Result{singular: singular, visitor: visitors, sources: b.paths}
 }
 
 // Do returns a Result object with a Visitor for the resources identified by the Builder.

vendor/k8s.io/kubernetes/pkg/kubectl/resource/result.go

@@ -222,7 +222,7 @@ func AsVersionedObject(infos []*Info, forceList bool, version unversioned.GroupV
 		object = objects[0]
 	} else {
 		object = &api.List{Items: objects}
-		converted, err := tryConvert(api.Scheme, object, version, registered.GroupOrDie(api.GroupName).GroupVersion)
+		converted, err := TryConvert(api.Scheme, object, version, registered.GroupOrDie(api.GroupName).GroupVersion)
 		if err != nil {
 			return nil, err
 		}
@@ -263,7 +263,7 @@ func AsVersionedObjects(infos []*Info, version unversioned.GroupVersion, encoder
 			}
 		}
 
-		converted, err := tryConvert(info.Mapping.ObjectConvertor, info.Object, version, info.Mapping.GroupVersionKind.GroupVersion())
+		converted, err := TryConvert(info.Mapping.ObjectConvertor, info.Object, version, info.Mapping.GroupVersionKind.GroupVersion())
 		if err != nil {
 			return nil, err
 		}
@@ -272,9 +272,9 @@ func AsVersionedObjects(infos []*Info, version unversioned.GroupVersion, encoder
 	return objects, nil
 }
 
-// tryConvert attempts to convert the given object to the provided versions in order. This function assumes
+// TryConvert attempts to convert the given object to the provided versions in order. This function assumes
 // the object is in internal version.
-func tryConvert(converter runtime.ObjectConvertor, object runtime.Object, versions ...unversioned.GroupVersion) (runtime.Object, error) {
+func TryConvert(converter runtime.ObjectConvertor, object runtime.Object, versions ...unversioned.GroupVersion) (runtime.Object, error) {
 	var last error
 	for _, version := range versions {
 		if version.Empty() {

vendor/k8s.io/kubernetes/pkg/kubectl/resource/visitor.go

@@ -26,9 +26,12 @@ import (
 	"path/filepath"
 	"time"
 
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/api/validation"
+	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/runtime"
 	utilerrors "k8s.io/kubernetes/pkg/util/errors"
 	"k8s.io/kubernetes/pkg/util/yaml"
@@ -110,6 +113,12 @@ func (i *Info) Visit(fn VisitorFunc) error {
 func (i *Info) Get() (err error) {
 	obj, err := NewHelper(i.Client, i.Mapping).Get(i.Namespace, i.Name, i.Export)
 	if err != nil {
+		if errors.IsNotFound(err) && len(i.Namespace) > 0 && i.Namespace != api.NamespaceDefault && i.Namespace != api.NamespaceAll {
+			err2 := i.Client.Get().AbsPath("api", "v1", "namespaces", i.Namespace).Do().Error()
+			if err2 != nil && errors.IsNotFound(err2) {
+				return err2
+			}
+		}
 		return err
 	}
 	i.Object = obj
@@ -631,3 +640,51 @@ func RetrieveLazy(info *Info, err error) error {
 	}
 	return nil
 }
+
+type FilterFunc func(info *Info, err error) (bool, error)
+
+type FilteredVisitor struct {
+	visitor Visitor
+	filters []FilterFunc
+}
+
+func NewFilteredVisitor(v Visitor, fn ...FilterFunc) Visitor {
+	if len(fn) == 0 {
+		return v
+	}
+	return FilteredVisitor{v, fn}
+}
+
+func (v FilteredVisitor) Visit(fn VisitorFunc) error {
+	return v.visitor.Visit(func(info *Info, err error) error {
+		if err != nil {
+			return err
+		}
+		for _, filter := range v.filters {
+			ok, err := filter(info, nil)
+			if err != nil {
+				return err
+			}
+			if !ok {
+				return nil
+			}
+		}
+		return fn(info, nil)
+	})
+}
+
+func FilterBySelector(s labels.Selector) FilterFunc {
+	return func(info *Info, err error) (bool, error) {
+		if err != nil {
+			return false, err
+		}
+		a, err := meta.Accessor(info.Object)
+		if err != nil {
+			return false, err
+		}
+		if !s.Matches(labels.Set(a.GetLabels())) {
+			return false, nil
+		}
+		return true, nil
+	}
+}