Vendor in latest containers/image

Some more features.
    docker-archive generates docker legacy compatible images
    Do not create $DiffID subdirectories for layers with no configs
    Ensure the layer IDs in legacy docker/tarfile metadata are unique
    docker-archive: repeated layers are symlinked in the tar file
    sysregistries: remove all trailing slashes
    Improve docker/* error messages
    Fix failure to make auth directory
    Create a new slice in Schema1.UpdateLayerInfos
    Drop unused storageImageDestination.{image,systemContext}
    Load a *storage.Image only once in storageImageSource
    Support gzip for docker-archive files
    Remove .tar extension from blob and config file names
    ostree, src: support copy of compressed layers
    ostree: re-pull layer if it misses uncompressed_digest|uncompressed_size
    image: fix docker schema v1 -> OCI conversion
    Add /etc/containers/certs.d as default certs directory

Signed-off-by: Daniel J Walsh <dwalsh@redhat.com>

Closes: #569
Approved by: mheon

1 files changed, 0 insertions, 331 deletions

diff --git a/vendor/k8s.io/client-go/discovery/restmapper.go b/vendor/k8s.io/client-go/discovery/restmapper.go
deleted file mode 100644
index 6d1de8c1b..000000000
--- a/vendor/k8s.io/client-go/discovery/restmapper.go
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
-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 discovery
-
-import (
-	"fmt"
-	"sync"
-
-	"k8s.io/apimachinery/pkg/api/meta"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-
-	"github.com/golang/glog"
-)
-
-// APIGroupResources is an API group with a mapping of versions to
-// resources.
-type APIGroupResources struct {
-	Group metav1.APIGroup
-	// A mapping of version string to a slice of APIResources for
-	// that version.
-	VersionedResources map[string][]metav1.APIResource
-}
-
-// NewRESTMapper returns a PriorityRESTMapper based on the discovered
-// groups and resources passed in.
-func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.VersionInterfacesFunc) meta.RESTMapper {
-	unionMapper := meta.MultiRESTMapper{}
-
-	var groupPriority []string
-	// /v1 is special.  It should always come first
-	resourcePriority := []schema.GroupVersionResource{{Group: "", Version: "v1", Resource: meta.AnyResource}}
-	kindPriority := []schema.GroupVersionKind{{Group: "", Version: "v1", Kind: meta.AnyKind}}
-
-	for _, group := range groupResources {
-		groupPriority = append(groupPriority, group.Group.Name)
-
-		// Make sure the preferred version comes first
-		if len(group.Group.PreferredVersion.Version) != 0 {
-			preferred := group.Group.PreferredVersion.Version
-			if _, ok := group.VersionedResources[preferred]; ok {
-				resourcePriority = append(resourcePriority, schema.GroupVersionResource{
-					Group:    group.Group.Name,
-					Version:  group.Group.PreferredVersion.Version,
-					Resource: meta.AnyResource,
-				})
-
-				kindPriority = append(kindPriority, schema.GroupVersionKind{
-					Group:   group.Group.Name,
-					Version: group.Group.PreferredVersion.Version,
-					Kind:    meta.AnyKind,
-				})
-			}
-		}
-
-		for _, discoveryVersion := range group.Group.Versions {
-			resources, ok := group.VersionedResources[discoveryVersion.Version]
-			if !ok {
-				continue
-			}
-
-			// Add non-preferred versions after the preferred version, in case there are resources that only exist in those versions
-			if discoveryVersion.Version != group.Group.PreferredVersion.Version {
-				resourcePriority = append(resourcePriority, schema.GroupVersionResource{
-					Group:    group.Group.Name,
-					Version:  discoveryVersion.Version,
-					Resource: meta.AnyResource,
-				})
-
-				kindPriority = append(kindPriority, schema.GroupVersionKind{
-					Group:   group.Group.Name,
-					Version: discoveryVersion.Version,
-					Kind:    meta.AnyKind,
-				})
-			}
-
-			gv := schema.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
-			versionMapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{gv}, versionInterfaces)
-
-			for _, resource := range resources {
-				scope := meta.RESTScopeNamespace
-				if !resource.Namespaced {
-					scope = meta.RESTScopeRoot
-				}
-
-				// this is for legacy resources and servers which don't list singular forms.  For those we must still guess.
-				if len(resource.SingularName) == 0 {
-					versionMapper.Add(gv.WithKind(resource.Kind), scope)
-					// TODO this is producing unsafe guesses that don't actually work, but it matches previous behavior
-					versionMapper.Add(gv.WithKind(resource.Kind+"List"), scope)
-					continue
-				}
-
-				plural := gv.WithResource(resource.Name)
-				singular := gv.WithResource(resource.SingularName)
-				versionMapper.AddSpecific(gv.WithKind(resource.Kind), plural, singular, scope)
-				// TODO this is producing unsafe guesses that don't actually work, but it matches previous behavior
-				versionMapper.Add(gv.WithKind(resource.Kind+"List"), scope)
-			}
-			// TODO why is this type not in discovery (at least for "v1")
-			versionMapper.Add(gv.WithKind("List"), meta.RESTScopeRoot)
-			unionMapper = append(unionMapper, versionMapper)
-		}
-	}
-
-	for _, group := range groupPriority {
-		resourcePriority = append(resourcePriority, schema.GroupVersionResource{
-			Group:    group,
-			Version:  meta.AnyVersion,
-			Resource: meta.AnyResource,
-		})
-		kindPriority = append(kindPriority, schema.GroupVersionKind{
-			Group:   group,
-			Version: meta.AnyVersion,
-			Kind:    meta.AnyKind,
-		})
-	}
-
-	return meta.PriorityRESTMapper{
-		Delegate:         unionMapper,
-		ResourcePriority: resourcePriority,
-		KindPriority:     kindPriority,
-	}
-}
-
-// GetAPIGroupResources uses the provided discovery client to gather
-// discovery information and populate a slice of APIGroupResources.
-func GetAPIGroupResources(cl DiscoveryInterface) ([]*APIGroupResources, error) {
-	apiGroups, err := cl.ServerGroups()
-	if err != nil {
-		return nil, err
-	}
-	var result []*APIGroupResources
-	for _, group := range apiGroups.Groups {
-		groupResources := &APIGroupResources{
-			Group:              group,
-			VersionedResources: make(map[string][]metav1.APIResource),
-		}
-		for _, version := range group.Versions {
-			resources, err := cl.ServerResourcesForGroupVersion(version.GroupVersion)
-			if err != nil {
-				// continue as best we can
-				// TODO track the errors and update callers to handle partial errors.
-				continue
-			}
-			groupResources.VersionedResources[version.Version] = resources.APIResources
-		}
-		result = append(result, groupResources)
-	}
-	return result, nil
-}
-
-// DeferredDiscoveryRESTMapper is a RESTMapper that will defer
-// initialization of the RESTMapper until the first mapping is
-// requested.
-type DeferredDiscoveryRESTMapper struct {
-	initMu           sync.Mutex
-	delegate         meta.RESTMapper
-	cl               CachedDiscoveryInterface
-	versionInterface meta.VersionInterfacesFunc
-}
-
-// NewDeferredDiscoveryRESTMapper returns a
-// DeferredDiscoveryRESTMapper that will lazily query the provided
-// client for discovery information to do REST mappings.
-func NewDeferredDiscoveryRESTMapper(cl CachedDiscoveryInterface, versionInterface meta.VersionInterfacesFunc) *DeferredDiscoveryRESTMapper {
-	return &DeferredDiscoveryRESTMapper{
-		cl:               cl,
-		versionInterface: versionInterface,
-	}
-}
-
-func (d *DeferredDiscoveryRESTMapper) getDelegate() (meta.RESTMapper, error) {
-	d.initMu.Lock()
-	defer d.initMu.Unlock()
-
-	if d.delegate != nil {
-		return d.delegate, nil
-	}
-
-	groupResources, err := GetAPIGroupResources(d.cl)
-	if err != nil {
-		return nil, err
-	}
-
-	d.delegate = NewRESTMapper(groupResources, d.versionInterface)
-	return d.delegate, err
-}
-
-// Reset resets the internally cached Discovery information and will
-// cause the next mapping request to re-discover.
-func (d *DeferredDiscoveryRESTMapper) Reset() {
-	glog.V(5).Info("Invalidating discovery information")
-
-	d.initMu.Lock()
-	defer d.initMu.Unlock()
-
-	d.cl.Invalidate()
-	d.delegate = nil
-}
-
-// KindFor takes a partial resource and returns back the single match.
-// It returns an error if there are multiple matches.
-func (d *DeferredDiscoveryRESTMapper) KindFor(resource schema.GroupVersionResource) (gvk schema.GroupVersionKind, err error) {
-	del, err := d.getDelegate()
-	if err != nil {
-		return schema.GroupVersionKind{}, err
-	}
-	gvk, err = del.KindFor(resource)
-	if err != nil && !d.cl.Fresh() {
-		d.Reset()
-		gvk, err = d.KindFor(resource)
-	}
-	return
-}
-
-// KindsFor takes a partial resource and returns back the list of
-// potential kinds in priority order.
-func (d *DeferredDiscoveryRESTMapper) KindsFor(resource schema.GroupVersionResource) (gvks []schema.GroupVersionKind, err error) {
-	del, err := d.getDelegate()
-	if err != nil {
-		return nil, err
-	}
-	gvks, err = del.KindsFor(resource)
-	if len(gvks) == 0 && !d.cl.Fresh() {
-		d.Reset()
-		gvks, err = d.KindsFor(resource)
-	}
-	return
-}
-
-// ResourceFor takes a partial resource and returns back the single
-// match. It returns an error if there are multiple matches.
-func (d *DeferredDiscoveryRESTMapper) ResourceFor(input schema.GroupVersionResource) (gvr schema.GroupVersionResource, err error) {
-	del, err := d.getDelegate()
-	if err != nil {
-		return schema.GroupVersionResource{}, err
-	}
-	gvr, err = del.ResourceFor(input)
-	if err != nil && !d.cl.Fresh() {
-		d.Reset()
-		gvr, err = d.ResourceFor(input)
-	}
-	return
-}
-
-// ResourcesFor takes a partial resource and returns back the list of
-// potential resource in priority order.
-func (d *DeferredDiscoveryRESTMapper) ResourcesFor(input schema.GroupVersionResource) (gvrs []schema.GroupVersionResource, err error) {
-	del, err := d.getDelegate()
-	if err != nil {
-		return nil, err
-	}
-	gvrs, err = del.ResourcesFor(input)
-	if len(gvrs) == 0 && !d.cl.Fresh() {
-		d.Reset()
-		gvrs, err = d.ResourcesFor(input)
-	}
-	return
-}
-
-// RESTMapping identifies a preferred resource mapping for the
-// provided group kind.
-func (d *DeferredDiscoveryRESTMapper) RESTMapping(gk schema.GroupKind, versions ...string) (m *meta.RESTMapping, err error) {
-	del, err := d.getDelegate()
-	if err != nil {
-		return nil, err
-	}
-	m, err = del.RESTMapping(gk, versions...)
-	if err != nil && !d.cl.Fresh() {
-		d.Reset()
-		m, err = d.RESTMapping(gk, versions...)
-	}
-	return
-}
-
-// 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 (d *DeferredDiscoveryRESTMapper) RESTMappings(gk schema.GroupKind, versions ...string) (ms []*meta.RESTMapping, err error) {
-	del, err := d.getDelegate()
-	if err != nil {
-		return nil, err
-	}
-	ms, err = del.RESTMappings(gk, versions...)
-	if len(ms) == 0 && !d.cl.Fresh() {
-		d.Reset()
-		ms, err = d.RESTMappings(gk, versions...)
-	}
-	return
-}
-
-// ResourceSingularizer converts a resource name from plural to
-// singular (e.g., from pods to pod).
-func (d *DeferredDiscoveryRESTMapper) ResourceSingularizer(resource string) (singular string, err error) {
-	del, err := d.getDelegate()
-	if err != nil {
-		return resource, err
-	}
-	singular, err = del.ResourceSingularizer(resource)
-	if err != nil && !d.cl.Fresh() {
-		d.Reset()
-		singular, err = d.ResourceSingularizer(resource)
-	}
-	return
-}
-
-func (d *DeferredDiscoveryRESTMapper) String() string {
-	del, err := d.getDelegate()
-	if err != nil {
-		return fmt.Sprintf("DeferredDiscoveryRESTMapper{%v}", err)
-	}
-	return fmt.Sprintf("DeferredDiscoveryRESTMapper{\n\t%v\n}", del)
-}
-
-// Make sure it satisfies the interface
-var _ meta.RESTMapper = &DeferredDiscoveryRESTMapper{}