Update ingress godeps

vendor/k8s.io/kubernetes/pkg/api/meta/errors.go

@@ -38,19 +38,40 @@ func (e *AmbiguousResourceError) Error() string {
 		return fmt.Sprintf("%v matches multiple kinds %v", e.PartialResource, e.MatchingKinds)
 	case len(e.MatchingResources) > 0:
 		return fmt.Sprintf("%v matches multiple resources %v", e.PartialResource, e.MatchingResources)
-
 	}
-
 	return fmt.Sprintf("%v matches multiple resources or kinds", e.PartialResource)
 }
 
-func IsAmbiguousResourceError(err error) bool {
+// AmbiguousKindError is returned if the RESTMapper finds multiple matches for a kind
+type AmbiguousKindError struct {
+	PartialKind unversioned.GroupVersionKind
+
+	MatchingResources []unversioned.GroupVersionResource
+	MatchingKinds     []unversioned.GroupVersionKind
+}
+
+func (e *AmbiguousKindError) Error() string {
+	switch {
+	case len(e.MatchingKinds) > 0 && len(e.MatchingResources) > 0:
+		return fmt.Sprintf("%v matches multiple resources %v and kinds %v", e.PartialKind, e.MatchingResources, e.MatchingKinds)
+	case len(e.MatchingKinds) > 0:
+		return fmt.Sprintf("%v matches multiple kinds %v", e.PartialKind, e.MatchingKinds)
+	case len(e.MatchingResources) > 0:
+		return fmt.Sprintf("%v matches multiple resources %v", e.PartialKind, e.MatchingResources)
+	}
+	return fmt.Sprintf("%v matches multiple resources or kinds", e.PartialKind)
+}
+
+func IsAmbiguousError(err error) bool {
 	if err == nil {
 		return false
 	}
-
-	_, ok := err.(*AmbiguousResourceError)
-	return ok
+	switch err.(type) {
+	case *AmbiguousResourceError, *AmbiguousKindError:
+		return true
+	default:
+		return false
+	}
 }
 
 // NoResourceMatchError is returned if the RESTMapper can't find any match for a resource
@@ -62,11 +83,23 @@ func (e *NoResourceMatchError) Error() string {
 	return fmt.Sprintf("no matches for %v", e.PartialResource)
 }
 
-func IsNoResourceMatchError(err error) bool {
+// NoKindMatchError is returned if the RESTMapper can't find any match for a kind
+type NoKindMatchError struct {
+	PartialKind unversioned.GroupVersionKind
+}
+
+func (e *NoKindMatchError) Error() string {
+	return fmt.Sprintf("no matches for %v", e.PartialKind)
+}
+
+func IsNoMatchError(err error) bool {
 	if err == nil {
 		return false
 	}
-
-	_, ok := err.(*NoResourceMatchError)
-	return ok
+	switch err.(type) {
+	case *NoResourceMatchError, *NoKindMatchError:
+		return true
+	default:
+		return false
+	}
 }

vendor/k8s.io/kubernetes/pkg/api/meta/interfaces.go

@@ -62,6 +62,8 @@ type Object interface {
 	SetFinalizers(finalizers []string)
 	GetOwnerReferences() []metatypes.OwnerReference
 	SetOwnerReferences([]metatypes.OwnerReference)
+	GetClusterName() string
+	SetClusterName(clusterName string)
 }
 
 var _ Object = &runtime.Unstructured{}
@@ -173,7 +175,10 @@ type RESTMapper interface {
 	// ResourcesFor takes a partial resource and returns back the list of potential resource in priority order
 	ResourcesFor(input unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error)
 
+	// RESTMapping identifies a preferred resource mapping for the provided group kind.
 	RESTMapping(gk unversioned.GroupKind, versions ...string) (*RESTMapping, error)
+	// RESTMappings returns all resource mappings for the provided group kind.
+	RESTMappings(gk unversioned.GroupKind) ([]*RESTMapping, error)
 
 	AliasesForResource(resource string) ([]string, bool)
 	ResourceSingularizer(resource string) (singular string, err error)

vendor/k8s.io/kubernetes/pkg/api/meta/multirestmapper.go

@@ -56,7 +56,7 @@ func (m MultiRESTMapper) ResourcesFor(resource unversioned.GroupVersionResource)
 	for _, t := range m {
 		gvrs, err := t.ResourcesFor(resource)
 		// ignore "no match" errors, but any other error percolates back up
-		if IsNoResourceMatchError(err) {
+		if IsNoMatchError(err) {
 			continue
 		}
 		if err != nil {
@@ -91,7 +91,7 @@ func (m MultiRESTMapper) KindsFor(resource unversioned.GroupVersionResource) (gv
 	for _, t := range m {
 		gvks, err := t.KindsFor(resource)
 		// ignore "no match" errors, but any other error percolates back up
-		if IsNoResourceMatchError(err) {
+		if IsNoMatchError(err) {
 			continue
 		}
 		if err != nil {
@@ -155,7 +155,7 @@ func (m MultiRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...strin
 	for _, t := range m {
 		currMapping, err := t.RESTMapping(gk, versions...)
 		// ignore "no match" errors, but any other error percolates back up
-		if IsNoResourceMatchError(err) {
+		if IsNoMatchError(err) {
 			continue
 		}
 		if err != nil {
@@ -171,12 +171,43 @@ func (m MultiRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...strin
 		return allMappings[0], nil
 	}
 	if len(allMappings) > 1 {
-		return nil, fmt.Errorf("multiple matches found for %v in %v", gk, versions)
+		var kinds []unversioned.GroupVersionKind
+		for _, m := range allMappings {
+			kinds = append(kinds, m.GroupVersionKind)
+		}
+		return nil, &AmbiguousKindError{PartialKind: gk.WithVersion(""), MatchingKinds: kinds}
 	}
 	if len(errors) > 0 {
 		return nil, utilerrors.NewAggregate(errors)
 	}
-	return nil, fmt.Errorf("no match found for %v in %v", gk, versions)
+	return nil, &NoKindMatchError{PartialKind: gk.WithVersion("")}
+}
+
+// RESTMappings returns all possible RESTMappings for the provided group kind, or an error
+// if the type is not recognized.
+func (m MultiRESTMapper) RESTMappings(gk unversioned.GroupKind) ([]*RESTMapping, error) {
+	var allMappings []*RESTMapping
+	var errors []error
+
+	for _, t := range m {
+		currMappings, err := t.RESTMappings(gk)
+		// ignore "no match" errors, but any other error percolates back up
+		if IsNoMatchError(err) {
+			continue
+		}
+		if err != nil {
+			errors = append(errors, err)
+			continue
+		}
+		allMappings = append(allMappings, currMappings...)
+	}
+	if len(errors) > 0 {
+		return nil, utilerrors.NewAggregate(errors)
+	}
+	if len(allMappings) == 0 {
+		return nil, &NoKindMatchError{PartialKind: gk.WithVersion("")}
+	}
+	return allMappings, nil
 }
 
 // AliasesForResource finds the first alias response for the provided mappers.

vendor/k8s.io/kubernetes/pkg/api/meta/priority.go

@@ -153,7 +153,60 @@ func kindMatches(pattern unversioned.GroupVersionKind, kind unversioned.GroupVer
 }
 
 func (m PriorityRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (mapping *RESTMapping, err error) {
-	return m.Delegate.RESTMapping(gk, versions...)
+	mappings, err := m.Delegate.RESTMappings(gk)
+	if err != nil {
+		return nil, err
+	}
+
+	// any versions the user provides take priority
+	priorities := m.KindPriority
+	if len(versions) > 0 {
+		priorities = make([]unversioned.GroupVersionKind, 0, len(m.KindPriority)+len(versions))
+		for _, version := range versions {
+			gv, err := unversioned.ParseGroupVersion(version)
+			if err != nil {
+				return nil, err
+			}
+			priorities = append(priorities, gv.WithKind(AnyKind))
+		}
+		priorities = append(priorities, m.KindPriority...)
+	}
+
+	remaining := append([]*RESTMapping{}, mappings...)
+	for _, pattern := range priorities {
+		var matching []*RESTMapping
+		for _, m := range remaining {
+			if kindMatches(pattern, m.GroupVersionKind) {
+				matching = append(matching, m)
+			}
+		}
+
+		switch len(matching) {
+		case 0:
+			// if you have no matches, then nothing matched this pattern just move to the next
+			continue
+		case 1:
+			// one match, return
+			return matching[0], nil
+		default:
+			// more than one match, use the matched hits as the list moving to the next pattern.
+			// this way you can have a series of selection criteria
+			remaining = matching
+		}
+	}
+	if len(remaining) == 1 {
+		return remaining[0], nil
+	}
+
+	var kinds []unversioned.GroupVersionKind
+	for _, m := range mappings {
+		kinds = append(kinds, m.GroupVersionKind)
+	}
+	return nil, &AmbiguousKindError{PartialKind: gk.WithVersion(""), MatchingKinds: kinds}
+}
+
+func (m PriorityRESTMapper) RESTMappings(gk unversioned.GroupKind) ([]*RESTMapping, error) {
+	return m.Delegate.RESTMappings(gk)
 }
 
 func (m PriorityRESTMapper) AliasesForResource(alias string) (aliases []string, ok bool) {

vendor/k8s.io/kubernetes/pkg/api/meta/restmapper.go

@@ -183,7 +183,7 @@ func (m *DefaultRESTMapper) ResourceSingularizer(resourceType string) (string, e
 		if !ok {
 			continue
 		}
-		if singular.IsEmpty() {
+		if singular.Empty() {
 			singular = currSingular
 			continue
 		}
@@ -193,7 +193,7 @@ func (m *DefaultRESTMapper) ResourceSingularizer(resourceType string) (string, e
 		}
 	}
 
-	if singular.IsEmpty() {
+	if singular.Empty() {
 		return resourceType, fmt.Errorf("no singular of resource %v has been defined", resourceType)
 	}
 
@@ -431,6 +431,7 @@ func (o resourceByPreferredGroupVersion) Less(i, j int) bool {
 // RESTClient should use to operate on the provided group/kind in order of versions. If a version search
 // order is not provided, the search order provided to DefaultRESTMapper will be used to resolve which
 // version should be used to access the named group/kind.
+// TODO: consider refactoring to use RESTMappings in a way that preserves version ordering and preference
 func (m *DefaultRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (*RESTMapping, error) {
 	// Pick an appropriate version
 	var gvk *unversioned.GroupVersionKind
@@ -462,7 +463,7 @@ func (m *DefaultRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...st
 		}
 	}
 	if gvk == nil {
-		return nil, fmt.Errorf("no kind named %q is registered in versions %q", gk, versions)
+		return nil, &NoKindMatchError{PartialKind: gk.WithVersion("")}
 	}
 
 	// Ensure we have a REST mapping
@@ -503,6 +504,49 @@ func (m *DefaultRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...st
 	return retVal, nil
 }
 
+// RESTMappings returns the RESTMappings for the provided group kind in a rough internal preferred order. If no
+// kind is found it will return a NoResourceMatchError.
+func (m *DefaultRESTMapper) RESTMappings(gk unversioned.GroupKind) ([]*RESTMapping, error) {
+	// Use the default preferred versions
+	var mappings []*RESTMapping
+	for _, gv := range m.defaultGroupVersions {
+		if gv.Group != gk.Group {
+			continue
+		}
+
+		gvk := gk.WithVersion(gv.Version)
+		gvr, ok := m.kindToPluralResource[gvk]
+		if !ok {
+			continue
+		}
+
+		// Ensure we have a REST scope
+		scope, ok := m.kindToScope[gvk]
+		if !ok {
+			return nil, fmt.Errorf("the provided version %q and kind %q cannot be mapped to a supported scope", gvk.GroupVersion(), gvk.Kind)
+		}
+
+		interfaces, err := m.interfacesFunc(gvk.GroupVersion())
+		if err != nil {
+			return nil, fmt.Errorf("the provided version %q has no relevant versions", gvk.GroupVersion().String())
+		}
+
+		mappings = append(mappings, &RESTMapping{
+			Resource:         gvr.Resource,
+			GroupVersionKind: gvk,
+			Scope:            scope,
+
+			ObjectConvertor:  interfaces.ObjectConvertor,
+			MetadataAccessor: interfaces.MetadataAccessor,
+		})
+	}
+
+	if len(mappings) == 0 {
+		return nil, &NoResourceMatchError{PartialResource: unversioned.GroupVersionResource{Group: gk.Group, Resource: gk.Kind}}
+	}
+	return mappings, nil
+}
+
 // AddResourceAlias maps aliases to resources
 func (m *DefaultRESTMapper) AddResourceAlias(alias string, resources ...string) {
 	if len(resources) == 0 {

vendor/k8s.io/kubernetes/pkg/api/meta/unstructured.go

@@ -0,0 +1,31 @@
+/*
+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 meta
+
+import (
+	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+// InterfacesForUnstructured returns VersionInterfaces suitable for
+// dealing with runtime.Unstructured objects.
+func InterfacesForUnstructured(unversioned.GroupVersion) (*VersionInterfaces, error) {
+	return &VersionInterfaces{
+		ObjectConvertor:  &runtime.UnstructuredObjectConverter{},
+		MetadataAccessor: NewAccessor(),
+	}, nil
+}